diff --git a/.gitignore b/.gitignore
index 341b2e3c76bec5694ecbf38c3e95fcba040b6d95..6fac279814d6437bd8f2657629d93d35e8f9cc80 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,6 @@
 *.pyc
 .idea/*
 *.env
-*checkpoints*
\ No newline at end of file
+*checkpoints*
+*.egg-info
+build
diff --git a/examples/Boolean signals.ipynb b/examples/Boolean signals.ipynb
index 171f9be87c5679f28d778160e9beff59a5052a38..631f3336ed1a8e212cef4fa1efb9118a9f3d1e67 100644
--- a/examples/Boolean signals.ipynb	
+++ b/examples/Boolean signals.ipynb	
@@ -18,7 +18,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 54,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -35,7 +35,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 55,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -44,7 +44,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 56,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -65,7 +65,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 57,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
@@ -111,7 +111,7 @@
        "      <td>EpicsStatus.NO_ALARM</td>\n",
        "      <td>EpicsSeverity.NO_ALARM</td>\n",
        "      <td>1.626271e+09</td>\n",
-       "      <td>2021-07-14 14:00:03.976284981</td>\n",
+       "      <td>2021-07-14 14:00:03.976284928</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
@@ -123,7 +123,7 @@
        "      <td>EpicsStatus.NO_ALARM</td>\n",
        "      <td>EpicsSeverity.NO_ALARM</td>\n",
        "      <td>1.626271e+09</td>\n",
-       "      <td>2021-07-14 14:00:04.070791006</td>\n",
+       "      <td>2021-07-14 14:00:04.070790912</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
@@ -135,7 +135,7 @@
        "      <td>EpicsStatus.NO_ALARM</td>\n",
        "      <td>EpicsSeverity.NO_ALARM</td>\n",
        "      <td>1.626271e+09</td>\n",
-       "      <td>2021-07-14 14:00:11.148172617</td>\n",
+       "      <td>2021-07-14 14:00:11.148172544</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
@@ -147,7 +147,7 @@
        "      <td>EpicsStatus.NO_ALARM</td>\n",
        "      <td>EpicsSeverity.NO_ALARM</td>\n",
        "      <td>1.626271e+09</td>\n",
-       "      <td>2021-07-14 14:00:11.233532906</td>\n",
+       "      <td>2021-07-14 14:00:11.233532928</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>4</th>\n",
@@ -159,7 +159,7 @@
        "      <td>EpicsStatus.NO_ALARM</td>\n",
        "      <td>EpicsSeverity.NO_ALARM</td>\n",
        "      <td>1.626271e+09</td>\n",
-       "      <td>2021-07-14 14:00:11.322027206</td>\n",
+       "      <td>2021-07-14 14:00:11.322027264</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>...</th>\n",
@@ -183,7 +183,7 @@
        "      <td>EpicsStatus.NO_ALARM</td>\n",
        "      <td>EpicsSeverity.NO_ALARM</td>\n",
        "      <td>1.626276e+09</td>\n",
-       "      <td>2021-07-14 15:27:21.711938858</td>\n",
+       "      <td>2021-07-14 15:27:21.711938816</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>666</th>\n",
@@ -195,7 +195,7 @@
        "      <td>EpicsStatus.NO_ALARM</td>\n",
        "      <td>EpicsSeverity.NO_ALARM</td>\n",
        "      <td>1.626276e+09</td>\n",
-       "      <td>2021-07-14 15:27:22.703005314</td>\n",
+       "      <td>2021-07-14 15:27:22.703005440</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>667</th>\n",
@@ -207,7 +207,7 @@
        "      <td>EpicsStatus.NO_ALARM</td>\n",
        "      <td>EpicsSeverity.NO_ALARM</td>\n",
        "      <td>1.626276e+09</td>\n",
-       "      <td>2021-07-14 15:27:23.711986542</td>\n",
+       "      <td>2021-07-14 15:27:23.711986432</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>668</th>\n",
@@ -219,7 +219,7 @@
        "      <td>EpicsStatus.NO_ALARM</td>\n",
        "      <td>EpicsSeverity.NO_ALARM</td>\n",
        "      <td>1.626277e+09</td>\n",
-       "      <td>2021-07-14 15:29:38.144469023</td>\n",
+       "      <td>2021-07-14 15:29:38.144468992</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>669</th>\n",
@@ -231,7 +231,7 @@
        "      <td>EpicsStatus.NO_ALARM</td>\n",
        "      <td>EpicsSeverity.NO_ALARM</td>\n",
        "      <td>1.626277e+09</td>\n",
-       "      <td>2021-07-14 15:29:38.648600340</td>\n",
+       "      <td>2021-07-14 15:29:38.648600320</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -253,22 +253,22 @@
        "669  1626276578    1  648600398         0       0  EpicsStatus.NO_ALARM   \n",
        "\n",
        "             severity_label    secs_nanos                          time  \n",
-       "0    EpicsSeverity.NO_ALARM  1.626271e+09 2021-07-14 14:00:03.976284981  \n",
-       "1    EpicsSeverity.NO_ALARM  1.626271e+09 2021-07-14 14:00:04.070791006  \n",
-       "2    EpicsSeverity.NO_ALARM  1.626271e+09 2021-07-14 14:00:11.148172617  \n",
-       "3    EpicsSeverity.NO_ALARM  1.626271e+09 2021-07-14 14:00:11.233532906  \n",
-       "4    EpicsSeverity.NO_ALARM  1.626271e+09 2021-07-14 14:00:11.322027206  \n",
+       "0    EpicsSeverity.NO_ALARM  1.626271e+09 2021-07-14 14:00:03.976284928  \n",
+       "1    EpicsSeverity.NO_ALARM  1.626271e+09 2021-07-14 14:00:04.070790912  \n",
+       "2    EpicsSeverity.NO_ALARM  1.626271e+09 2021-07-14 14:00:11.148172544  \n",
+       "3    EpicsSeverity.NO_ALARM  1.626271e+09 2021-07-14 14:00:11.233532928  \n",
+       "4    EpicsSeverity.NO_ALARM  1.626271e+09 2021-07-14 14:00:11.322027264  \n",
        "..                      ...           ...                           ...  \n",
-       "665  EpicsSeverity.NO_ALARM  1.626276e+09 2021-07-14 15:27:21.711938858  \n",
-       "666  EpicsSeverity.NO_ALARM  1.626276e+09 2021-07-14 15:27:22.703005314  \n",
-       "667  EpicsSeverity.NO_ALARM  1.626276e+09 2021-07-14 15:27:23.711986542  \n",
-       "668  EpicsSeverity.NO_ALARM  1.626277e+09 2021-07-14 15:29:38.144469023  \n",
-       "669  EpicsSeverity.NO_ALARM  1.626277e+09 2021-07-14 15:29:38.648600340  \n",
+       "665  EpicsSeverity.NO_ALARM  1.626276e+09 2021-07-14 15:27:21.711938816  \n",
+       "666  EpicsSeverity.NO_ALARM  1.626276e+09 2021-07-14 15:27:22.703005440  \n",
+       "667  EpicsSeverity.NO_ALARM  1.626276e+09 2021-07-14 15:27:23.711986432  \n",
+       "668  EpicsSeverity.NO_ALARM  1.626277e+09 2021-07-14 15:29:38.144468992  \n",
+       "669  EpicsSeverity.NO_ALARM  1.626277e+09 2021-07-14 15:29:38.648600320  \n",
        "\n",
        "[670 rows x 9 columns]"
       ]
      },
-     "execution_count": 57,
+     "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -279,12 +279,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 59,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -296,7 +296,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -323,7 +323,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 61,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
@@ -336,11 +336,12 @@
    ],
    "source": [
     "from pychiver.calculations import Edge\n",
+    "import pychiver\n",
     "\n",
+    "#pychiver.setVerbose()\n",
     "comp_data = archiver.compare(pvs_subset,\n",
     "                        start_date=start,\n",
     "                        end_date=end,\n",
-    "                        #verbose=True,\n",
     "                        tolerance_in_seconds=0.15,\n",
     "                        compare_edge=Edge.FALLING\n",
     "                            )\n",
@@ -361,7 +362,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -375,7 +376,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.3"
+   "version": "3.9.7"
   }
  },
  "nbformat": 4,
diff --git a/pychiver/__init__.py b/pychiver/__init__.py
index 84a7dc83ca5ad9a3f5fa966d0435e026d343f4a5..f5a40df12f5b63614588510bf85e365e6234ec3f 100644
--- a/pychiver/__init__.py
+++ b/pychiver/__init__.py
@@ -2,6 +2,7 @@ from . import archiver
 from . import timeutils
 from . import calculations
 from . import waveform
+from .config import setVerbose
 
 __title__ = "pychiver"
-__all__ = [archiver, timeutils, calculations, waveform]
+__all__ = [archiver, timeutils, calculations, waveform, setVerbose]
diff --git a/pychiver/archiver.py b/pychiver/archiver.py
index ac7c2e46e8c17872bea797c780e7578242ea9441..635c0fd0456dff055551f9b4299701c704b9fd53 100644
--- a/pychiver/archiver.py
+++ b/pychiver/archiver.py
@@ -30,12 +30,13 @@ import os
 import warnings
 
 import numpy
+import pandas
 
 from .calculations import LinearInterpolationStrategy, alignDataFrames, calculateMovingAverage, findCloseTimestamps, \
     Edge
-from .endpoints import JsonEndPointArchiver
 from .domain import PVMetaInfo
-import pandas
+from .endpoints import JsonEndPointArchiver
+from .  import config
 
 
 class Archiver:
@@ -57,7 +58,7 @@ class Archiver:
 
         self.archiver = DefaultEndPoint(archiver_url=archiver_url)
 
-    def get(self, PV, start_date, end_date=None, entries_limit=None, verbose=False, force_non_archived=False):
+    def get(self, PV, start_date, end_date=None, entries_limit=None, force_non_archived=False):
         """
         Returns the archiver data for one or many pvs within the given start_date and end_date.
 
@@ -65,7 +66,6 @@ class Archiver:
         :param start_date:
         :param end_date: default None => now()
         :param entries_limit: default None, ie. all entries are extracted
-        :param verbose: default False, if True the processing printout is provided
         :param force_non_archived: default False, when True, an attempt to extract archived data is made,
                 may raise exception
         :return: dict of PV to a DataFrame
@@ -77,22 +77,22 @@ class Archiver:
                 useSeparateLimits = True
             dataToReturn = {}
             for index, onePV in enumerate(PV):
-                if verbose: print('Collecting data for', onePV)
+                config.printVerbose('Collecting data for', onePV)
                 e_limit = entries_limit
                 if useSeparateLimits:
                     e_limit = entries_limit[index]
                 dataToReturn[onePV] = self._get(onePV, start_date=start_date, end_date=end_date,
-                                                entries_limit=e_limit, verbose=verbose,
+                                                entries_limit=e_limit,
                                                 force_non_archived=force_non_archived)[0]
             return dataToReturn
         else:
             if isinstance(entries_limit, tuple) and len(entries_limit) > 0:
                 entries_limit = entries_limit[0]
             return {PV: self._get(PV, start_date=start_date, end_date=end_date,
-                                  entries_limit=entries_limit, verbose=verbose,
+                                  entries_limit=entries_limit,
                                   force_non_archived=force_non_archived)[0]}
 
-    def getWaveform(self, onePV: str, start_date, end_date=None, verbose=False,
+    def getWaveform(self, onePV: str, start_date, end_date=None,
                     force_non_archived=False) -> pandas.DataFrame:
         """
         Returns an pandas DataFrame that contains a waveform
@@ -100,19 +100,17 @@ class Archiver:
         :param onePV: PV to be extracted
         :param start_date:
         :param end_date: default None => now()
-        :param verbose: default False, if True the processing printout is provided
         :param force_non_archived: default False, when True, an attempt to extract archived data is made anyway
         :return:
         """
         if not isinstance(onePV, str):
             raise ValueError('Only one waveform at the time! Too many or none PVs provided.')
-        return self._get(onePV, start_date=start_date, end_date=end_date, verbose=verbose,
+        return self._get(onePV, start_date=start_date, end_date=end_date,
                          waveform_alert=False, force_non_archived=force_non_archived)[0]
 
     def getAligned(self, PVS: list, start_date, end_date=None,
                    time_base=None, strategy=LinearInterpolationStrategy,
                    entries_limit=None, time_column="secs_nanos", value_columns=("val",),
-                   verbose=False,
                    force_non_archived=False) -> pandas.DataFrame:
         """
         Extracts PVs and aligns them to the timestamps of the first PV in the list or separately provided time base.
@@ -128,24 +126,23 @@ class Archiver:
         :param time_column: optional, default 'time' column will be used
         :param value_columns: optional, default 'val' column will be used,
                      the alignment can be performed for many columns at the same time, provide a tuple.
-        :param verbose: default False
         :param force_non_archived: default False, when True, an attempt to extract archived data is made anyway
 
         :return: a DataFrame with all PVS and their values
         """
         dict_of_dataframes = self.get(PVS, start_date, end_date=end_date,
-                                      entries_limit=entries_limit, verbose=verbose,
+                                      entries_limit=entries_limit,
                                       force_non_archived=force_non_archived)
         if not isinstance(dict_of_dataframes, dict):
             raise ValueError('Wrong data format provided. Dict of pandas.DataFrames expected, {} provided'. \
                              format(dict_of_dataframes.__class__))
         return alignDataFrames(dict_of_dataframes, time_base=time_base,
                                time_column=time_column, value_columns=value_columns,
-                               InterpolationStrategyImpl=strategy, verbose=verbose)
+                               InterpolationStrategyImpl=strategy)
 
     def getMovingAverage(self, PV, start_date, end_date=None, entries_limit=None, window=10,
                          time_column="secs_nanos", value_columns=("val",),
-                         force_non_archived=False, verbose=False) -> pandas.DataFrame:
+                         force_non_archived=False) -> pandas.DataFrame:
         """
         Retrieves the data for a given PV and calculates the moving average for a selected window.
         The resulting dataframe is cleared from all NaN cases.
@@ -158,27 +155,24 @@ class Archiver:
         :param time_column:
         :param value_columns:
         :param force_non_archived:
-        :param verbose:
         :return:
         """
         if isinstance(PV, list) or isinstance(PV, tuple) or isinstance(PV, dict):
             raise ValueError('Cannot handle more than one PV at the time. \
                                 Use getAligned together with calculations.calculateMovingAverage')
         df, isWaveform = self._get(PV, start_date, end_date=end_date, entries_limit=entries_limit,
-                                   force_non_archived=force_non_archived, verbose=verbose)
+                                   force_non_archived=force_non_archived)
         if isWaveform:
             warnings.warn('Moving average over the waveform is not implemented! Returning simple DataForm')
             return df
         return calculateMovingAverage(df[PV], window=window,
-                                      time_column=time_column, value_columns=value_columns,
-                                      verbose=verbose)
+                                      time_column=time_column, value_columns=value_columns)
 
     def compare(self, PVs: list, start_date, end_date=None,
                 # index_of_reference_PV=0,
                 compare_edge=Edge.FALLING,
                 tolerance_in_seconds=0.1,
-                force_non_archived=False,
-                verbose=False) -> numpy.array:
+                force_non_archived=False) -> numpy.array:
         """
         Returns timestamps of the close occurrences of the RISING or FALLING for two
 
@@ -188,20 +182,18 @@ class Archiver:
         :param compare_edge: compare the occurrences of the selected change
         :param tolerance_in_seconds: absolute (+/-) acceptable difference for simultaneous events
         :param force_non_archived:
-        :param verbose:
         :return:
         """
         if len(PVs) != 2:
             raise ValueError('Only two signals expected for comparison!')
 
         # TODO see what to pass more, limits? etc..
-        dfs = self.get(PVs, start_date=start_date, end_date=end_date, verbose=verbose,
+        dfs = self.get(PVs, start_date=start_date, end_date=end_date,
                        force_non_archived=force_non_archived,)
 
         closeTimeStamps = findCloseTimestamps(dfs,
                                               tolerance_in_seconds=tolerance_in_seconds,
-                                              edge_to_use=compare_edge,
-                                              verbose=verbose)
+                                              edge_to_use=compare_edge)
         return closeTimeStamps
 
     def getPulseData(self, cycle_id: int) -> pandas.DataFrame:
@@ -214,16 +206,16 @@ class Archiver:
         # TODO waveforms should go as ArchiverCollectors
         raise NotImplementedError("Not implemented yet")
 
-    def check(self, PV: str, type=PVMetaInfo.STATUS) -> dict:
+    def check(self, PV: str, info_type=PVMetaInfo.STATUS) -> dict:
         """
         Provides information on the requested PV(s)
-        :param type: STATUS (default) returns info on PVs, INFO returns info on a given PVs
+        :param info_type: STATUS (default) returns info on PVs, INFO returns info on a given PVs
         :param PV: PVs to check status or info
         :return: dict of PV to its data
         """
-        return self.archiver.getPVStatus(PV, type=type)
+        return self.archiver.getPVStatus(PV, info_type=info_type)
 
-    def _get(self, onePV: str, start_date, end_date=None, entries_limit: int = None, verbose=False,
+    def _get(self, onePV: str, start_date, end_date=None, entries_limit: int = None,
              waveform_alert=True, force_non_archived=False) \
             -> pandas.DataFrame:
         isWaveform = False
@@ -237,8 +229,7 @@ class Archiver:
             pass
         else:
             df = self.archiver.getDataForPV(onePV, start_date=start_date, end_date=end_date,
-                                            entries_limit=entries_limit,
-                                            verbose=verbose)
+                                            entries_limit=entries_limit)
         try:
             if len(df) > 0 and len(df['val'][0]):
                 isWaveform = True
@@ -249,3 +240,4 @@ class Archiver:
             pass  # This error is thrown on scalar types, due to len(df['val'])
 
         return df, isWaveform
+
diff --git a/pychiver/calculations.py b/pychiver/calculations.py
index bd720043f044ec0d56a7fc92893ca236585a0530..b077fd2421a078f6d0537229583a3b7c6807833f 100644
--- a/pychiver/calculations.py
+++ b/pychiver/calculations.py
@@ -9,6 +9,8 @@ from enum import Enum
 import numpy as np
 import pandas as pd
 
+from . import config
+
 
 class InterpolationStrategy:
 
@@ -60,7 +62,7 @@ class LastAcquiredValueInterpolationStrategy(InterpolationStrategy):
 def alignDataFrames(dict_of_datasets,
                     time_base=None,
                     InterpolationStrategyImpl=None,
-                    time_column='time', value_columns=("val",), verbose=False) -> pd.DataFrame:
+                    time_column='time', value_columns=("val",)) -> pd.DataFrame:
     """
     For a given dict of DataFrames (dict of 'Data Label' -> DataFrame), the data alignment is performed for the
     provided data sets values (according to provided value columns) and the provided new time base
@@ -72,7 +74,6 @@ def alignDataFrames(dict_of_datasets,
     :param InterpolationStrategyImpl:
     :param time_column: default 'time'
     :param value_columns: default 'val'
-    :param verbose: default False, prints out the progress on the computation
     :return: pandas DataFrame with one time column and value columns for each data label
     """
     if InterpolationStrategyImpl is None:
@@ -112,25 +113,21 @@ def alignDataFrames(dict_of_datasets,
     if time_base is None:
         isImpl = InterpolationStrategyImpl(dict_of_datasets[firstPV][time_column].to_numpy())
         newDF_values.append(dict_of_datasets[firstPV][time_column].to_numpy())
-        if verbose:
-            print('First PV used as a time base: ', firstPV)
+        config.printVerbose('First PV used as a time base: ', firstPV)
     else:
         isImpl = InterpolationStrategyImpl(time_base)
         newDF_values.append(time_base)
-        if verbose:
-            print('External time base used.')
+        config.printVerbose('External time base used.')
 
     for one_PV in dict_of_datasets.keys():
         if one_PV in dfToSkip:
             continue
         for one_val_column in value_columns:
-            if verbose:
-                print("Interpolating for {}:{}".format(one_PV, one_val_column))
+            config.printVerbose(f"Interpolating for {one_PV}:{one_val_column}")
             x = isImpl.getValues(dict_of_datasets[one_PV][time_column].to_numpy(),
                                  dict_of_datasets[one_PV][one_val_column].to_numpy())
             newDF_values.append(x)
-    if verbose:
-        print('Alignment completed!')
+    config.printVerbose('Alignment completed!')
 
     returnDF = pd.DataFrame(np.transpose(np.array(newDF_values)), columns=newDF_columns)
     returnDF['time'] = pd.to_datetime(returnDF[time_column], unit='s')
@@ -138,7 +135,7 @@ def alignDataFrames(dict_of_datasets,
 
 
 def calculateMovingAverage(dataset, window=10,
-                           time_column='secs_nanos', value_columns=('val',), verbose=False):
+                           time_column='secs_nanos', value_columns=('val',)):
     """
     Modifies the the provided data set, by adding extra columns for mean time and mean values.
 
@@ -146,7 +143,6 @@ def calculateMovingAverage(dataset, window=10,
     :param value_columns:
     :param time_column:
     :param window: default 10s
-    :param verbose:
     :return: None
     """
     df = pd.DataFrame()
@@ -156,7 +152,7 @@ def calculateMovingAverage(dataset, window=10,
     df[time_column] = dataset[time_column]
     df['mean_time'] = pd.to_datetime((dataset[time_column]).rolling(window=window).mean(), unit='s')
     for one_value_column in value_columns:
-        if verbose: print("Column \'{}\' applied with {}s moving average".format(one_value_column, window))
+        config.printVerbose(f"Column '{one_value_column}' applied with {window}s moving average")
         df['mean_' + one_value_column] = dataset[one_value_column].rolling(window=window).mean()
     df.dropna(inplace=True)
     return df
@@ -213,27 +209,24 @@ def findCloseTimestamps(dfs,
                         edge_to_use=Edge.RISING,
                         tolerance_in_seconds=1,
                         timeColumn='secs_nanos',
-                        valueColumn='val',
-                        verbose=False):
+                        valueColumn='val'):
     newTs = []
     for pv in dfs.keys():
         oneDf = dfs[pv]
         if not oneDf[valueColumn].between(0, 1, inclusive="both").any():
             raise ValueError('It seems that your boolean data for {} has values outside of 0 and 1... cannot')
         toConsider = oneDf.loc[oneDf[valueColumn] != edge_to_use.value]
-        if verbose:
-            print('---------{}-----------'.format(pv))
-            print(oneDf[timeColumn].values)
-            print(toConsider)
+        config.printVerbose('---------{}-----------'.format(pv))
+        config.printVerbose(oneDf[timeColumn].values)
+        config.printVerbose(toConsider)
         newTs.extend(toConsider[timeColumn].values)
 
     allTimeStamps = np.array(newTs)
     closeOnes = allTimeStamps[:-1] - allTimeStamps[1:]
     closeOnes.sort()
     indexes = np.where(np.abs(closeOnes) < tolerance_in_seconds)
-    if verbose:
-        print(indexes)
-        print(allTimeStamps[indexes])
+    config.printVerbose(indexes)
+    config.printVerbose(allTimeStamps[indexes])
     return allTimeStamps[indexes]
 
 
@@ -252,4 +245,4 @@ def compareTwoBooleanArrays(array1, array2, method=Method.AND):
     if method == Method.OR:
         return np.bitwise_or(array1, array2)
     if method == Method.XOR:
-        return np.bitwise_xor(array1, array2)
+        return np.bitwise_xor(array1, array2)
\ No newline at end of file
diff --git a/pychiver/config.py b/pychiver/config.py
new file mode 100644
index 0000000000000000000000000000000000000000..4c83568ddd9fba740dd818118c09b6f9c3cc0f0d
--- /dev/null
+++ b/pychiver/config.py
@@ -0,0 +1,33 @@
+import sys
+
+__verbose__: bool = False
+
+
+def _getVerbose():
+    """
+    Returns True if verbose printing is active
+    """
+    global __verbose__
+
+    return __verbose__ or sys.flags.debug
+
+
+def printVerbose(*args):
+    """
+    Print verbose message
+
+    TODO: This print can then optionally be redirected to log file or something..
+    """
+    if _getVerbose():
+        print(*args)
+
+
+def setVerbose(verbose=True):
+    """
+    Verbosity is used to print extra information about the processing of commands.
+
+    :param verbose: If True, turn on verbose printing to stdout
+    """
+    global __verbose__
+
+    __verbose__ = verbose
diff --git a/pychiver/domain.py b/pychiver/domain.py
index c3d40cac4a4c9e8ddde5d6c5eb19a70168bd2243..4343b2873d4f7c72b34bd1f7d37a3e98c2a14c8e 100644
--- a/pychiver/domain.py
+++ b/pychiver/domain.py
@@ -4,4 +4,5 @@ from enum import Enum, unique
 @unique
 class PVMetaInfo(Enum):
     INFO = 0
-    STATUS = 1
\ No newline at end of file
+    STATUS = 1
+    DETAILS = 2
\ No newline at end of file
diff --git a/pychiver/endpoints.py b/pychiver/endpoints.py
index a72906709289656e3f72c50a3abf07a66c3c7eb2..dd23eaaaa0605c89d93f60e68eecd6cd0dae0871 100644
--- a/pychiver/endpoints.py
+++ b/pychiver/endpoints.py
@@ -11,6 +11,7 @@ from json import JSONDecodeError
 from .timeutils import validateTimeStamps, validateTimeStampsReturnObjects, getDateTimeObj
 from .codes import EpicsStatus, EpicsSeverity
 from .domain import PVMetaInfo
+from . import config
 
 import pandas
 import json
@@ -39,6 +40,8 @@ class EndPoint:
 def _fix(dataset: pandas.DataFrame, start_date, end_date) -> pandas.DataFrame:
     """
     Fixes the data set. by creating
+
+
     :param dataset:
     :param start_date:
     :param end_date:
@@ -78,10 +81,10 @@ class JsonEndPointArchiver(EndPoint):
         self.archiver_url_mgmt = '{}:17665/mgmt/bpl'.format(archiver_url)
 
     def getDataForPV(self, PV, start_date, end_date=None, entries_limit=None,
-                     max_number_of_hours_back=24, verbose=False) -> pandas.DataFrame:
+                     max_number_of_hours_back=24) -> pandas.DataFrame:
         try:
             jsonReturn = self._getJSONRequest(PV, start_date, end_date=end_date, entries_limit=entries_limit,
-                                              iteration=max_number_of_hours_back, verbose=verbose)
+                                              iteration=max_number_of_hours_back)
             # TODO think about putting the iterative search for an earlier value up to the Archiver class
             json_data = jsonReturn['data']
             dataset = pandas.read_json(json.dumps(json_data))
@@ -94,25 +97,22 @@ class JsonEndPointArchiver(EndPoint):
             return self.getEmptyResult()
 
     def _getJSONRequest(self, PV, start_date, end_date=None, entries_limit=None,
-                        entries_warning_limit=5000, iteration=24, verbose=False) -> dict:
-        if verbose:
-            print('No data found for \'{}\', trying earlier between: start:{} until {}'.format(PV, start_date, end_date))
+                        entries_warning_limit=5000, iteration=24) -> dict:
         if iteration == 0:
             warnings.warn('No data found in the increased time window, returning empty result.')
             return {'data': []}
         start_date_str, end_date_str = validateTimeStamps(start_date, end_date)
         start_date, end_date = validateTimeStampsReturnObjects(start_date, end_date)
         entries = self._countEntries(PV, start_date_str, end_date_str)
+        if not entries:
+            config.printVerbose(f"No data found for '{PV}', trying earlier than: start:{start_date} until {end_date}")
         # TODO see if the recursive call should be here
         if entries_limit is None:
             entries_limit = max(entries, 1)
         if entries > entries_warning_limit:
-            warnings.warn(
-                'You are about to extract {} samples, this operation may take significant amount of time...'.format(
-                    entries))
+            warnings.warn(f'You are about to extract {entries} samples, this operation may take significant amount of time...')
         # try:
-        nth_url = '{}?pv=nth_{}({})&from={}&to={}'.format(self.archiver_url_data, int(entries // entries_limit),
-                                                          PV, start_date_str, end_date_str)
+        nth_url = f'{self.archiver_url_data}?pv=nth_{int(entries // entries_limit)}({PV})&from={start_date_str}&to={end_date_str}'
         # except ZeroDivisionError:
         #     return
         toReturn = requests.get(nth_url).json()
@@ -130,40 +130,54 @@ class JsonEndPointArchiver(EndPoint):
         :param end_date:
         :return:
         """
-        count_url = '{}?pv=count({})&from={}&to={}'.format(self.archiver_url_data, PV, start_date, end_date)
-        json_data = requests.get(count_url).json()[0]['data']
+        count_url = f'{self.archiver_url_data}?pv=count({PV})&from={start_date}&to={end_date}'
+        res = requests.get(count_url)
+        if res.status_code != 200:
+            raise ValueError(f"Failed to count entries for {PV}, status {res.status_code}")
+        json_data = res.json()[0]['data']
         entries = 0
         for i in json_data:
             entries += i['val']
         return int(entries)
 
-    def getPVStatus(self, PV, type=PVMetaInfo.STATUS) -> dict:
+    def getPVStatus(self, PV, info_type=PVMetaInfo.STATUS) -> dict:
         """
-        :param type:
+        :param info_type:
         :param PV:
         :return:
         """
-        if not isinstance(type, PVMetaInfo):
+        if not isinstance(info_type, PVMetaInfo):
             raise ValueError('Type parameter of the wrong class! Use pychiver.domain.PVMetaInfo')
         if isinstance(PV, str):
             PV = (PV,)
-        if type == PVMetaInfo.STATUS:
-            url_to_check = '{}/getPVStatus?pv='.format(self.archiver_url_mgmt)
-            for onePV in PV:
-                url_to_check += onePV + ","
-            returnData = requests.get(url_to_check).json()
-            return {returnDataItem['pvName']: returnDataItem for returnDataItem in returnData}
-        if type == PVMetaInfo.INFO:
-            # this end point does not support list
-            url_to_check = '{}/getPVTypeInfo?pv='.format(self.archiver_url_mgmt)
+        url_to_check = f"{self.archiver_url_mgmt}/getPVStatus?pv={','.join(PV)}"
+        status = requests.get(url_to_check).json()
+        status = {statusItem['pvName']: statusItem for statusItem in status}
+        if info_type == PVMetaInfo.STATUS:
+            returnData = status
+        else:
             returnData = {}
             for onePV in PV:
-                r = requests.get(url_to_check+onePV)
-                if r.status_code == 200:
-                    returnData[onePV] = r.json()
+                if "Not" in status[onePV]["status"]:
+                    returnData[onePV] = status[onePV]
                 else:
-                    returnData[onePV] = {'pvName': onePV, "status": 'Not being archived'}
-            return returnData
+                    if info_type == PVMetaInfo.INFO:
+                        # this end point does not support list
+                        query = "getPVTypeInfo"
+                    elif info_type == PVMetaInfo.DETAILS:
+                        query = "getPVDetails"
+                    else:
+                        raise ValueError(f"Wrong PV status type {info_type}")
+                    r = requests.get(f'{self.archiver_url_mgmt}/{query}?pv={onePV}')
+                    if r.status_code == 200:
+                        data = r.json()
+                        if isinstance(data, list): # Details is given as list..
+                            returnData[onePV] = {item['name']: item["value"] for item in data}
+                        else:
+                            returnData[onePV] = data
+                    else:  # TODO should probably no get here anymore?
+                        returnData[onePV] = {'pvName': onePV, "status": 'Not being archived'}
+        return returnData
 
     def getEmptyResult(self):
         return pandas.DataFrame(columns=('time', 'val', 'status_label', 'severity_label', 'secs_nanos', 'secs',
diff --git a/pychiver/saveandrestore.py b/pychiver/saveandrestore.py
index d798797ef1934587fd7f3ddfb64de961b2d7ee95..cfc4e779cb78aabd8b52dc046ebcbef1e28e7018 100644
--- a/pychiver/saveandrestore.py
+++ b/pychiver/saveandrestore.py
@@ -243,7 +243,7 @@ class SaveAndRestore:
         # this has also a TODO on the https://gitlab.esss.lu.se/ics-software/jmasar-service
         raise NotImplementedError('Not implemented yet!')
 
-    def compareAndCheck(self, snapshot: SARSnapshot = None, date_time=None, verbose=False,
+    def compareAndCheck(self, snapshot: SARSnapshot = None, date_time=None,
                         timeout=1) -> bool:
         """
         Provides the true/false result of the comparison for a given snapshot.
@@ -251,24 +251,22 @@ class SaveAndRestore:
         False, when one (or more) saved values does not match the read values
 
         :param timeout:
-        :param verbose:
         :param date_time:
         :param snapshot: existing snapshot,
         :date_time: default None
         :return: True/False
         """
-        comparisonResult = self.compare(snapshot=snapshot, date_time=date_time, verbose=verbose, timeout=timeout)
+        comparisonResult = self.compare(snapshot=snapshot, date_time=date_time, timeout=timeout)
         comparisonResult = comparisonResult[~comparisonResult['delta'].between(0, 0)]
         return len(comparisonResult) == 0
 
-    def compare(self, snapshot: SARSnapshot = None, date_time=None, verbose=False, timeout=1) -> pandas.DataFrame:
+    def compare(self, snapshot: SARSnapshot = None, date_time=None, timeout=1) -> pandas.DataFrame:
         """
         Provides the way of comparing a snapshot to the:
          - live values, that are retrieved by pyepics.
          - archived values in the archiver at given date_time
 
         :param timeout:
-        :param verbose:
         :param date_time:
         :param snapshot: existing snapshot,
         :date_time: default None
@@ -292,7 +290,7 @@ class SaveAndRestore:
             print(date_time_to_consider)
             startD = date_time_to_consider - timedelta(seconds=1)  # TODO archiver window to consider?
             endD = date_time_to_consider + timedelta(seconds=1)
-            data = self._archiver.get(snapshot.getPVs(), start_date=startD, end_date=endD, verbose=verbose)
+            data = self._archiver.get(snapshot.getPVs(), start_date=startD, end_date=endD)
             print("=======")
             print(data)
             print("=======")
diff --git a/pychiver/timeutils.py b/pychiver/timeutils.py
index 7879861a973a99cef999897e32ce3e61a8d5a427..e3a2f3073841701c8c371d8fe65b6797656f3e81 100644
--- a/pychiver/timeutils.py
+++ b/pychiver/timeutils.py
@@ -3,8 +3,8 @@ AD/Operations
 Arek Gorzawski 2021, ESS
 """
 import datetime
+import dateutil.parser
 
-VALID_DATE_FORMAT = "%Y-%m-%d %H:%M:%S"
 
 
 def validateTimeStampsReturnObjects(start_date, end_date=None) -> tuple:
@@ -46,18 +46,18 @@ def validateTimeStamps(start_date, end_date=None) -> tuple:
     :raises ValueError if wrong type of objects provided
     """
     s, e = validateTimeStampsReturnObjects(start_date, end_date)
-    return getTimeStampFormatted(s), getTimeStampFormatted(e)
+    return _getTimeStampFormatted(s), _getTimeStampFormatted(e)
 
 
-def getDateTimeObj(date_obj, date_input_format=VALID_DATE_FORMAT) -> datetime.datetime:
-    if isinstance(date_obj, datetime.datetime):
-        pass
-    else:
-        date_obj = datetime.datetime.strptime(date_obj, date_input_format)
+def getDateTimeObj(date_obj) -> datetime.datetime:
+    if isinstance(date_obj, str):
+        date_obj = dateutil.parser.parse(date_obj)
+    elif not isinstance(date_obj, datetime.datetime):
+        raise ValueError(f"date string of wrong type {type(date_obj)}")
     return date_obj
 
 
-def getTimeStampFormatted(date_obj, date_input_format=VALID_DATE_FORMAT) -> str:
+def _getTimeStampFormatted(date_obj) -> str:
     """
     Formats the provided object or string (according to the input format) into the Archiver date format,
     in datetime().isoformat()+Z
@@ -66,5 +66,5 @@ def getTimeStampFormatted(date_obj, date_input_format=VALID_DATE_FORMAT) -> str:
     :param date_input_format: default "%Y-%m-%d %H:%M:%S"
     :return: ESS Archiver formatted date string
     """
-    date_obj = getDateTimeObj(date_obj, date_input_format)
+    date_obj = getDateTimeObj(date_obj)
     return date_obj.isoformat() + "Z"
diff --git a/setup.py b/setup.py
index b550d5a5ec72a8de5068d54aa0c37ac73afab8a4..d4a7d510f58cbbbd8b8499ed1aded103ff920080 100644
--- a/setup.py
+++ b/setup.py
@@ -15,6 +15,7 @@ setuptools.setup(
      long_description_content_type="text/markdown",
      install_requires=[
           'requests',
+          'python-dateutil',
           'pandas',
           'matplotlib',
           'numpy',
diff --git a/tests/test_calculations.py b/tests/test_calculations.py
index 33438950764e062be4d2da68593923274dcc8eba..048f285458f041870b16a909d1db6b1a149a3fe4 100644
--- a/tests/test_calculations.py
+++ b/tests/test_calculations.py
@@ -112,14 +112,12 @@ class TestDataAlign(unittest.TestCase):
 
     def test_align_with_first_df_time(self):
         result = alignDataFrames({"PV1": DF_1, "PV2": DF_2},
-                                 # verbose=True,
                                  InterpolationStrategyImpl=LinearInterpolationStrategy)
         self._compare_two_arrays(DF_2_VAL_FOR_DF_1_TIME, result['PV2:val'].to_numpy())
 
     def test_align_with_external_time_base(self):
         result = alignDataFrames({"PV1": DF_1, "PV2": DF_2}, time_base=EXTERNAL_TIME_BASE,
                                  value_columns=("val", 'some_other'),
-                                 # verbose=True,
                                  InterpolationStrategyImpl=LinearInterpolationStrategy)
         self._compare_two_arrays(DF_1_VAL_FOR_EXTERNAL_TIME_BASE, result['PV1:val'].to_numpy())
         self._compare_two_arrays(DF_2_VAL_FOR_EXTERNAL_TIME_BASE, result['PV2:val'].to_numpy())
@@ -127,7 +125,6 @@ class TestDataAlign(unittest.TestCase):
     def test_align_one_df_with_external_time_base(self):
         result = alignDataFrames({"PV1": DF_1}, time_base=EXTERNAL_TIME_BASE,
                                  value_columns=("val", 'some_other'),
-                                 # verbose=True,
                                  InterpolationStrategyImpl=LinearInterpolationStrategy)
         self._compare_two_arrays(DF_1_VAL_FOR_EXTERNAL_TIME_BASE, result['PV1:val'].to_numpy())
 
diff --git a/tests/test_utils.py b/tests/test_utils.py
index 64d8233cd1549e8de71d9ed7f5934ce4713553d9..3e788663718eabefca3cecacc8a2ad6fab48e621 100644
--- a/tests/test_utils.py
+++ b/tests/test_utils.py
@@ -22,12 +22,6 @@ class TestStartDateChecks(unittest.TestCase):
         with self.assertRaises(ValueError):
             validateTimeStamps(66666)
 
-    def test_incorrect_string(self):
-        with self.assertRaises(ValueError):
-            validateTimeStamps('2011-21-12 12:12:12')
-        with self.assertRaises(ValueError):
-            validateTimeStamps('2011/21/12 12:12:12')
-
 
 class TestEndDateChecks(unittest.TestCase):
 
@@ -36,9 +30,3 @@ class TestEndDateChecks(unittest.TestCase):
 
     def test_correct_date_time(self):
         validateTimeStamps(start_date=datetime.datetime.now(), end_date=CORRECT_DATE)
-
-    def test_incorrect_string(self):
-        with self.assertRaises(ValueError):
-            validateTimeStamps(start_date=CORRECT_DATE, end_date='2012 Jun 12')
-        with self.assertRaises(ValueError):
-            validateTimeStamps(start_date=CORRECT_DATE, end_date='2112/12/21 12:12:12')
\ No newline at end of file