Refactor global state

pyiron_base/__init__.py

@@ -2,14 +2,15 @@
 # Copyright (c) Max-Planck-Institut für Eisenforschung GmbH - Computational Materials Design (CM) Department
 # Distributed under the terms of "New BSD License", see the LICENSE file.
 
-# API of the pyiron_base module - in alphabetical order 
+# API of the pyiron_base module - in alphabetical order
 from pyiron_base.generic.factory import PyironFactory
 from pyiron_base.generic.flattenedstorage import FlattenedStorage
 from pyiron_base.generic.hdfio import FileHDFio, ProjectHDFio
 from pyiron_base.generic.datacontainer import DataContainer
 from pyiron_base.generic.inputlist import InputList
 from pyiron_base.generic.parameters import GenericParameters
 from pyiron_base.generic.util import deprecate, deprecate_soon, ImportAlarm
+from pyiron_base.state import state
 from pyiron_base.job.executable import Executable
 from pyiron_base.job.external import Notebook
 from pyiron_base.job.generic import GenericJob
@@ -27,8 +28,8 @@
 from pyiron_base.project.generic import Project, Creator
 from pyiron_base.pyio.parser import Logstatus, extract_data_from_file
 from pyiron_base.server.queuestatus import validate_que_request
-from pyiron_base.settings.generic import Settings
-from pyiron_base.settings.install import install_dialog
+from pyiron_base.state.settings import Settings
+from pyiron_base.state.install import install_dialog
 from pyiron_base.table.datamining import PyironTable, TableJob
 from pyiron_base.generic.object import HasDatabase, HasStorage, PyironObject
 from pyiron_base.database.performance import get_database_statistics

pyiron_base/_tests.py

@@ -56,7 +56,7 @@ def test_docstrings(self):
         with StringIO() as buf, redirect_stdout(buf):
             result = doctest.testmod(self.docstring_module)
             output = buf.getvalue()
-        self.failIf(result.failed > 0, msg=output)
+        self.assertFalse(result.failed > 0, msg=output)
 
 
 class TestWithProject(PyironTestCase, ABC):

pyiron_base/archiving/import_archive.py

@@ -5,10 +5,7 @@
 from distutils.dir_util import copy_tree
 import tarfile
 from pyiron_base.generic.util import static_isinstance
-from pyiron_base.settings.generic import Settings
-
-
-s = Settings()
+from pyiron_base.state import state
 
 
 def getdir(path):
@@ -96,7 +93,7 @@ def import_jobs(
         if 'timestop' in entry:
             entry["timestop"] = pandas.to_datetime(entry["timestop"])
         if 'username' not in entry:
-            entry["username"] = s.login_user
+            entry["username"] = state.settings.login_user
         job_id = pr_import.db.add_item_dict(par_dict=entry)
         job_id_lst.append(job_id)
 

pyiron_base/cli/install.py

@@ -5,7 +5,7 @@
 Install pyiron config and resources for the first time.
 """
 
-from pyiron_base.settings.install import install_pyiron
+from pyiron_base.state.install import install_pyiron
 
 __author__ = "Marvin Poul"
 __copyright__ = (

pyiron_base/cli/reloadfile.py

@@ -5,10 +5,7 @@
 import h5py
 import shutil
 from pyiron_base import Project
-from pyiron_base.database.manager import DatabaseManager
-
-
-dbm = DatabaseManager()
+from pyiron_base.state import state
 
 
 def register(parser):
@@ -29,7 +26,7 @@ def main(args):
     file = os.path.basename(project_path)
     job_name = os.path.splitext(file)[0]
 
-    db_project_path = dbm.top_path(project_path)
+    db_project_path = state.database.top_path(project_path)
     project = os.path.dirname(project_path)
     db_project = (project + "/")
     if db_project_path is not None:

pyiron_base/database/generic.py

@@ -5,7 +5,7 @@
 DatabaseAccess class deals with accessing the database
 """
 
-import pyiron_base.settings.logger
+from pyiron_base.state.logger import logger
 from abc import ABC, abstractmethod
 import warnings
 import numpy as np
@@ -332,7 +332,7 @@ def __init__(self, engine, timeout=60):
         self._conn = None
         self._lock = Lock()
         self._watchdog = None
-        self._logger = pyiron_base.settings.logger.get_logger()
+        self._logger = logger
         self._timeout = timeout
 
     def execute(self, *args, **kwargs):
@@ -527,10 +527,7 @@ def _job_dict(
         if element_lst is not None:
             dict_clause["element_lst"] = element_lst
 
-        # HACK: breaks circular dependency of Settings on DatabaseAccess
-        from pyiron_base.settings.generic import Settings
-        s = Settings()
-        s.logger.debug("sql_query: %s", str(dict_clause))
+        logger.debug("sql_query: %s", str(dict_clause))
         return self.get_items_dict(dict_clause)
 
     def _get_job_table(

pyiron_base/database/jobtable.py

@@ -5,9 +5,7 @@
 The Jobtable module provides a set of top level functions to interact with the database.
 """
 
-import pandas
 import numpy as np
-from pyiron_base.settings.generic import Settings
 from pyiron_base.database.filetable import FileTable
 
 __author__ = "Jan Janssen"
@@ -21,8 +19,6 @@
 __status__ = "production"
 __date__ = "Sep 1, 2017"
 
-s = Settings()
-
 
 def get_jobs(database, sql_query, user, project_path, recursive=True, columns=None):
     """

pyiron_base/database/manager.py

@@ -6,12 +6,10 @@
 """
 
 from pyiron_base.generic.util import Singleton
-from pyiron_base.settings.generic import Settings
+from pyiron_base.state.settings import settings as s
 from pyiron_base.database.generic import DatabaseAccess
 import os
 
-s = Settings()
-
 __author__ = "Jan Janssen, Liam Huber"
 __copyright__ = (
     "Copyright 2020, Max-Planck-Institut für Eisenforschung GmbH"
@@ -63,16 +61,67 @@ def connection_timeout(self):
     def connection_timeout(self, val):
         s.configuration["connection_timeout"] = val
 
+    @staticmethod
+    def _sqlalchemy_string(prefix, user, key, host, database):
+        return f"{prefix}://{user}:{key}@{host}/{database}"
+
+    def _credentialed_sqalchemy_string(self, prefix):
+        return self._sqlalchemy_string(
+            prefix,
+            s.configuration["user"],
+            s.configuration["sql_user_key"],
+            s.configuration["sql_host"],
+            s.configuration["sql_database"]
+        )
+
+    @property
+    def sql_connection_string(self):
+        sql_type = s.configuration["sql_type"]
+        if sql_type == "Postgres":
+            return self._credentialed_sqalchemy_string("postgresql")
+        elif sql_type == "MySQL":
+            return self._credentialed_sqalchemy_string("mysql+pymysql")
+        elif sql_type == "SQLalchemy":
+            return s.configuration["sql_connection_string"]
+        elif sql_type == "SQLite":
+            return "sqlite:///" + s.configuration["sql_file"].replace("\\", "/")
+        else:
+            raise ValueError(
+                f"Invalid SQL type {sql_type} -- This should have been caught at input processing, please contact the "
+                f"developers"
+            )
+
+    @property
+    def sql_view_connection_string(self):
+        if s.configuration["sql_view_user"] is None:
+            return None
+        else:
+            return self._sqlalchemy_string(
+                "postgresql",
+                s.configuration["sql_view_user"],
+                s.configuration["sql_view_user_key"],
+                s.configuration["sql_host"],
+                s.configuration["sql_database"]
+            )
+
+    @property
+    def sql_table_name(self):
+        return s.configuration["sql_table_name"]
+
+    @property
+    def sql_view_table_name(self):
+        return s.configuration["sql_view_table_name"]
+
     def open_connection(self):
         """
         Internal function to open the connection to the database. Only after this function is called the database is
         accessable.
         """
         if self._database is None and not self.database_is_disabled:
             self._database = DatabaseAccess(
-                s.configuration["sql_connection_string"],
-                s.configuration["sql_table_name"],
-                timeout=s.configuration["connection_timeout"]
+                self.sql_connection_string,
+                self.sql_table_name,
+                timeout=self.connection_timeout
             )
 
     def switch_to_local_database(self, file_name="pyiron.db", cwd=None):
@@ -94,7 +143,7 @@ def switch_to_local_database(self, file_name="pyiron.db", cwd=None):
             self.open_local_sqlite_connection(connection_string="sqlite:///" + file_name)
 
     def open_local_sqlite_connection(self, connection_string):
-        self._database = DatabaseAccess(connection_string, s.configuration["sql_table_name"])
+        self._database = DatabaseAccess(connection_string, self.sql_table_name)
         self._use_local_database = True
         self._database_is_disabled = False
 
@@ -109,8 +158,8 @@ def switch_to_central_database(self):
                 self._database = None
             else:
                 self._database = DatabaseAccess(
-                    s.configuration["sql_connection_string"],
-                    s.configuration["sql_table_name"],
+                    self.sql_connection_string,
+                    self.sql_table_name,
                 )
 
             self._use_local_database = False
@@ -121,14 +170,14 @@ def switch_to_viewer_mode(self):
         """
         Switch from user mode to viewer mode - if view_mode is enable pyiron has read only access to the database.
         """
-        if s.configuration["sql_view_connection_string"] is not None and not self.database_is_disabled:
+        if self.sql_view_connection_string is not None and not self.database_is_disabled:
             if self._database.view_mode:
                 s.logger.log("Database is already in viewer mode!")
             else:
                 self.close_connection()
                 self._database = DatabaseAccess(
-                    s.configuration["sql_view_connection_string"],
-                    s.configuration["sql_view_table_name"],
+                    self.sql_view_connection_string,
+                    self.sql_view_table_name,
                 )
                 self._database.view_mode = True
 
@@ -143,10 +192,10 @@ def switch_to_user_mode(self):
             if self._database.view_mode:
                 self.close_connection()
                 self._database = DatabaseAccess(
-                    s.configuration["sql_connection_string"],
-                    s.configuration["sql_table_name"],
+                    self.sql_connection_string,
+                    self.sql_table_name,
                 )
-                self._database.view_mode = True
+                self._database.view_mode = False
             else:
                 s.logger.log("Database is already in user mode!")
         else:
@@ -170,17 +219,28 @@ def top_path(self, full_path):
         Returns:
             str: path
         """
-        if full_path[-1] != "/":
-            full_path += "/"
+        full_path = full_path if full_path.endswith("/") else full_path + "/"
 
         if not self.project_check_enabled:
             return None
 
         for path in s.configuration["project_paths"]:
             if path in full_path:
                 return path
+
         raise ValueError(
-            "the current path {0} is not included in the .pyiron configuration. {1}".format(
-                full_path, s.configuration["project_paths"]
-            )
+            f"the current path {full_path} is not included in the .pyiron configuration 'project_paths': "
+            f"{s.configuration['project_paths']}"
         )
+
+    def update(self):
+        """
+        Warning: Database interaction does not have written spec. This method does a thing. It might not be the thing
+                 you want.
+        """
+        self.close_connection()
+        self._use_local_database = False
+        self._database_is_disabled = s.configuration["disable_database"]
+
+
+database = DatabaseManager()

pyiron_base/database/performance.py

@@ -14,8 +14,7 @@
     or_,
     false,
 )
-from pyiron_base.settings.generic import Settings
-
+from pyiron_base.state import state
 
 __author__ = "Muhammad Hassani"
 __version__ = "1.0"
@@ -79,9 +78,8 @@ class DatabaseStatistics:
     """
 
     def __init__(self):
-        s = Settings()
-        connection_string = s._configuration['sql_connection_string']
-        self._job_table = s._configuration['sql_view_table_name']
+        connection_string = state.settings.configuration['sql_connection_string']
+        self._job_table = state.settings.configuration['sql_view_table_name']
         if "postgresql" not in connection_string:
             raise RuntimeError(
                 """

pyiron_base/generic/object.py

@@ -10,7 +10,7 @@
 from pyiron_base.generic.datacontainer import DataContainer
 from pyiron_base.interfaces.has_hdf import HasHDF
 from pyiron_base.generic.hdfio import ProjectHDFio
-from pyiron_base.database.manager import DatabaseManager
+from pyiron_base.state import state
 
 __author__ = "Liam Huber"
 __copyright__ = (
@@ -23,8 +23,6 @@
 __status__ = "development"
 __date__ = "Mar 23, 2021"
 
-dbm = DatabaseManager()
-
 
 class HasStorage(HasHDF, ABC):
     """
@@ -53,9 +51,9 @@ class HasDatabase(ABC):
     """
 
     def __init__(self, *args, **kwargs):
-        if not dbm.database_is_disabled:
-            dbm.open_connection()
-            self._database = dbm.database
+        if not state.database.database_is_disabled:
+            state.database.open_connection()
+            self._database = state.database.database
         else:
             raise NotImplementedError("WIP. For now only allowed with a database")
 

pyiron_base/generic/parameters.py

@@ -12,7 +12,7 @@
 import posixpath
 import warnings
 from ast import literal_eval
-from pyiron_base.settings.generic import Settings
+from pyiron_base.state import state
 
 __author__ = "Joerg Neugebauer"
 __copyright__ = (
@@ -25,8 +25,6 @@
 __status__ = "production"
 __date__ = "Sep 1, 2017"
 
-s = Settings()
-
 
 class GenericParameters:
     """
@@ -322,7 +320,7 @@ def read_input(self, file_name, ignore_trigger=None):
             file_name (str): absolute path to the input file
             ignore_trigger (str): trigger for lines to be ignored
         """
-        Settings().logger.debug("file: %s %s", file_name, os.path.isfile(file_name))
+        state.logger.debug("file: %s %s", file_name, os.path.isfile(file_name))
         if not os.path.isfile(file_name):
             raise ValueError("file does not exist: " + file_name)
         with open(file_name, "r") as f:
@@ -829,7 +827,7 @@ def _append_line_in_block(self, parameter_name, value):
                 )
                 return True
         else:
-            s.logger.warning(
+            state.logger.warning(
                 "Unknown parameter (does not exist in block_dict): {}".format(
                     parameter_name
                 )