csvpath 0.0.474__tar.gz → 0.0.475__tar.gz

{csvpath-0.0.474 → csvpath-0.0.475}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: csvpath
-Version: 0.0.474
+Version: 0.0.475
 Summary: A declarative language for data extraction and validation of CSV files
 Author: David Kershaw
 Author-email: dk107dk@hotmail.com

{csvpath-0.0.474 → csvpath-0.0.475}/config/config.ini

@@ -22,5 +22,5 @@ path = config/config.ini
 path = cache
 
 [functions]
-imports =
+imports = config/functions.imports
 

{csvpath-0.0.474 → csvpath-0.0.475}/csvpath/csvpath.py

@@ -318,7 +318,7 @@ class CsvPath(CsvPathPublic, ErrorCollector):  # pylint: disable=R0902, R0904
     @property
     def config(self) -> Config:  # pylint: disable=C0116
         if not self._config:
-            self._config = Config(self)
+            self._config = Config()
         return self._config
 
     def has_errors(self) -> bool:  # pylint: disable=C0116

{csvpath-0.0.474 → csvpath-0.0.475}/csvpath/csvpaths.py

@@ -132,7 +132,7 @@ class CsvPaths(CsvPathsPublic, CsvPathsCoordinator):
         self.quotechar = quotechar
         self.skip_blank_lines = skip_blank_lines
         self.current_matcher: CsvPath = None
-        self._config = Config(self)
+        self._config = Config()
         self.logger = LogUtility.logger(self)
         self.logger.info("initialized CsvPaths")
         self._errors = []

{csvpath-0.0.474 → csvpath-0.0.475}/csvpath/matching/functions/function_finder.py

@@ -21,7 +21,7 @@ class FunctionFinder:
             return
         if not os.path.exists(path):
             matcher.csvpath.logger.error(
-                "No [functions][imports] path from config.ini does not exist"
+                f"[functions][imports] path in {config.configpath} does not exist"
             )
             return
         with open(path, "r") as file:

{csvpath-0.0.474 → csvpath-0.0.475}/csvpath/util/config.py

@@ -43,6 +43,7 @@ class Sections(Enum):
     ERRORS = "errors"
     LOGGING = "logging"
     FUNCTIONS = "functions"
+    CACHE = "cache"
 
 
 class Config:
@@ -51,22 +52,45 @@ class Config:
      - set a CSVPATH_CONFIG_FILE env var
      - create a Config instance set its CONFIG member and call reload
      - or set Config.CONFIG and reload to reset all instances w/o own specific settings
+    Also, you can pass Config(load=False) to give you the opportunity to set some/all
+    properties programmatically.
     """
 
     CONFIG: str = "config/config.ini"
     CSVPATH_CONFIG_FILE_ENV: str = "CSVPATH_CONFIG_PATH"
 
-    def __init__(self, holder):
-        self._holder = holder
+    def __init__(self, *, load=True):
+        self.load = load
+        self._cache_dir_path = None
+        self._function_imports = None
+        self._csvpath_file_extensions = None
+        self._csv_file_extensions = None
+        self._csvpath_errors_policy = None
+        self._csvpaths_errors_policy = None
+        self._csvpath_log_level = None
+        self._csvpaths_log_level = None
+        self._log_file = None
+        self._log_files_to_keep = None
+        self._log_file_size = None
         self._config = RawConfigParser()
         self.log_file_handler = None
         self._configpath = environ.get(Config.CSVPATH_CONFIG_FILE_ENV)
         if self._configpath is None:
             self._configpath = Config.CONFIG
-        self._load_config()
+        if self.load:
+            self._load_config()
+
+    @property
+    def load(self) -> bool:
+        return self._load
+
+    @load.setter
+    def load(self, l:bool) -> None:
+        self._load = l
 
     def reload(self):
         self._config = RawConfigParser()
+        self._load = True
         self._load_config()
 
     def set_config_path_and_reload(self, path: str) -> None:
@@ -95,10 +119,19 @@ class Config:
             )
 
     def _create_default_config(self) -> None:
-        if not path.exists("config"):
-            os.makedirs("config")
-            with open(Config.CONFIG, "w") as file:
-                c = """
+        directory = ""
+        file = ""
+        if self._configpath is None or self._configpath.strip() == "":
+            raise ConfiguationException("Config path cannot be None")
+        if self._configpath.find(os.sep) > 0:
+            s = self._configpath.rfind(os.sep)
+            directory = self._configpath[0:s]
+            name = self._configpath[s+1:]
+        if directory != "":
+            if not path.exists(directory):
+                os.makedirs(directory)
+        with open(self._configpath, "w") as file:
+            c = """
 [csvpath_files]
 extensions = txt, csvpath, csvpaths
 [csv_files]
@@ -114,20 +147,25 @@ log_files_to_keep = 100
 log_file_size = 52428800
 [config]
 path =
-                """
-                file.write(c)
-            print(f"Creating a default config file at {Config.CONFIG}.")
+[functions]
+imports =
+[cache]
+path =
+            """
+            file.write(c)
+            print(f"Created a default config file at {directory} with name {name}.")
             print("If you want your config to be somewhere else remember to")
             print("update the path in the default config.ini")
 
     def _assure_logs_path(self) -> None:
-        filepath = self.log_file
-        if not filepath:
-            filepath = "logs/csvpath.log"
-            self.log_file = filepath
-        dirpath = self._get_dir_path(filepath)
-        if dirpath and not path.exists(dirpath):
-            os.makedirs(dirpath)
+        if self.load:
+            filepath = self.log_file
+            if not filepath or filepath.strip() == "":
+                filepath = "logs/csvpath.log"
+                self.log_file = filepath
+            dirpath = self._get_dir_path(filepath)
+            if dirpath and not path.exists(dirpath):
+                os.makedirs(dirpath)
 
     def _get_dir_path(self, filepath):
         if filepath.find(os.sep) > -1:
@@ -136,20 +174,23 @@ path =
         return None
 
     def _assure_cache_path(self) -> None:
-        dirpath = self.cache_dir_path
-        if dirpath and not path.exists(dirpath):
-            os.makedirs(dirpath)
-        elif not dirpath:
-            raise ConfigurationException(
-                "No cache path available. Check config.ini [cache][path]."
-            )
+        if self.load:
+            if self.cache_dir_path is None or self.cache_dir_path.strip() == "":
+                self.cache_dir_path = "cache"
+            if not path.exists(self.cache_dir_path):
+                os.makedirs(self.cache_dir_path)
 
     def _assure_config_file_path(self) -> None:
-        if not self._configpath or not os.path.isfile(self._configpath):
-            self._configpath = Config.CONFIG
-            self._create_default_config()
+        if self.load:
+            if not self._configpath or self._configpath.strip() == "":
+                self._configpath = Config.CONFIG
+            if not os.path.isfile(self._configpath):
+                self._create_default_config()
 
     def _load_config(self, norecurse=False):
+        if self._load is False:
+            print("WARNING: _load_config called on a config instance that is set to not load")
+            return
         self._assure_config_file_path()
         #
         #
@@ -173,13 +214,19 @@ path =
         self.log_file_size = self._get(
             Sections.LOGGING.value, LogFile.LOG_FILE_SIZE.value
         )
-        #
         # path to external functions list. external functions are very optional.
         # not blowing up when absent seems reasonable.
-        #
         try:
             self.function_imports = self._get(Sections.FUNCTIONS.value, "imports")
+            print(f"config fuc im: {self.function_imports}")
+        except Exception:
+            print("WARNING: config cannot load [functions][imports] from {self.configpath}")
+            pass
+        # likewise caching.
+        try:
+            self.cache_dir_path = self._get(Sections.CACHE.value, "path")
         except Exception:
+            print("WARNING: config cannot load [cache][path] from {self.configpath}")
             pass
         #
         # reload if another config path is set
@@ -284,13 +331,11 @@ path =
 
     @property
     def cache_dir_path(self) -> str:
-        try:
-            path = self._get("cache", "path")
-        except Exception:
-            path = "config"
-            self._config.add_section("cache")
-            self._config.set("cache", "path", path)
-        return path
+        return self._cache_dir_path
+
+    @cache_dir_path.setter
+    def cache_dir_path(self, p) -> None:
+        self._cache_dir_path = p
 
     @property
     def function_imports(self) -> str:

{csvpath-0.0.474 → csvpath-0.0.475}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "csvpath"
-version = "0.0.474"
+version = "0.0.475"
 description = "A declarative language for data extraction and validation of CSV files"
 authors = ["David Kershaw <dk107dk@hotmail.com>"]
 readme = "README.md"

csvpath-0.0.474/config/imports.txt

@@ -1 +0,0 @@
-from csvpath.matching.functions.boolean.yes import Yes as sure