csvpath 0.0.474__tar.gz → 0.0.476__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: csvpath
-Version: 0.0.474
+Version: 0.0.476
 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.476}/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.476}/csvpath/csvpath.py

@@ -232,11 +232,12 @@ class CsvPath(CsvPathPublic, ErrorCollector):  # pylint: disable=R0902, R0904
         #
         # the config.ini file loaded as a ConfigParser instance
         #
-        # we're moving this to a property can set up there. we
         # definitely do not want this coming from CsvPaths because
         # we want to be able to override config.ini specifically for
-        # this instance, if needed.
-        self._config = None
+        # this instance, if needed; however, we do want to be able
+        # to pass in a config object that has been configured in some
+        # way.
+        self._config = config
         #
         # there are two logger components one for CsvPath and one for CsvPaths.
         # the default levels are set in config.ini. to change the levels pass LogUtility
@@ -318,7 +319,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.476}/csvpath/csvpaths.py

@@ -122,7 +122,13 @@ class CsvPaths(CsvPathsPublic, CsvPathsCoordinator):
     # pylint: disable=too-many-instance-attributes
 
     def __init__(
-        self, *, delimiter=",", quotechar='"', skip_blank_lines=True, print_default=True
+        self,
+        *,
+        delimiter=",",
+        quotechar='"',
+        skip_blank_lines=True,
+        print_default=True,
+        config: Config = None,
     ):
         self.paths_manager = PathsManager(csvpaths=self)
         self.file_manager = FileManager(csvpaths=self)
@@ -132,7 +138,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() if config is None else config
         self.logger = LogUtility.logger(self)
         self.logger.info("initialized CsvPaths")
         self._errors = []
@@ -155,6 +161,11 @@ class CsvPaths(CsvPathsPublic, CsvPathsCoordinator):
             delimiter=self.delimiter,
             quotechar=self.quotechar,
             skip_blank_lines=self.skip_blank_lines,
+            #
+            # in the usual case we don't want csvpaths and its csvpath children
+            # to share the same config. sharing doesn't offer much. the flexibility
+            # of having separate configs is valuable.
+            #
             config=None,
             print_default=self.print_default,
         )

{csvpath-0.0.474 → csvpath-0.0.476}/csvpath/matching/functions/function_factory.py

@@ -80,7 +80,7 @@ from .misc.random import Random
 from .misc.nonef import Nonef
 from .misc.intf import Int
 from .misc.importf import Import
-from .testing.debug import Debug, BriefStackTrace, VoteStack, DoWhenStack
+from .testing.debug import Debug, BriefStackTrace, VoteStack, DoWhenStack, Log
 from .validity.failed import Failed
 from .validity.fail import Fail, FailAll
 
@@ -350,6 +350,8 @@ class FunctionFactory:
             f = Put(matcher, name, child)
         elif name == "debug":
             f = Debug(matcher, name, child)
+        elif name == "log":
+            f = Log(matcher, name, child)
         elif name == "brief_stack_trace":
             f = BriefStackTrace(matcher, name, child)
         elif name == "vote_stack":

{csvpath-0.0.474 → csvpath-0.0.476}/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.476}/csvpath/matching/functions/testing/debug.py

@@ -6,6 +6,32 @@ from csvpath.matching.util.expression_utility import ExpressionUtility
 from csvpath.matching.productions import Equality
 
 
+class Log(SideEffect):
+    """logs a msg at a log level, defaulting to info"""
+
+    def check_valid(self) -> None:
+        self.validate_one_or_two_args()
+        super().check_valid()
+
+    def _produce_value(self, skip=None) -> None:
+        self.value = self.matches(skip=skip)
+
+    def _decide_match(self, skip=None) -> None:
+        msg = self._value_one(skip=skip)
+        level = self._value_two(skip=skip)
+        if level in [None, "info"]:
+            self.matcher.csvpath.logger.info(msg)
+        elif level == "debug":
+            self.matcher.csvpath.logger.debug(msg)
+        elif level in ["warn", "warning"]:
+            self.matcher.csvpath.logger.warning(msg)
+        elif level == "error":
+            self.matcher.csvpath.logger.error(msg)
+        else:
+            self.matcher.csvpath.logger.info(msg)
+        self.match = self.default_match()
+
+
 class Debug(SideEffect):
     """sets the logging level"""
 

{csvpath-0.0.474 → csvpath-0.0.476}/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, lo: bool) -> None:
+        self._load = lo
 
     def reload(self):
         self._config = RawConfigParser()
+        self._load = True
         self._load_config()
 
     def set_config_path_and_reload(self, path: str) -> None:
@@ -90,15 +114,28 @@ class Config:
                 ret = s
             return ret
         except KeyError:
-            raise ConfigurationException(
-                f"Check config at {self.config_path} for [{section}][{name}]"
+            print(
+                f"WARNING: Check config at {self.config_path} for [{section}][{name}]"
             )
 
+    def save_config(self) -> None:
+        with open(self.configpath, "w") as f:
+            self._config.write(f)
+
     def _create_default_config(self) -> None:
-        if not path.exists("config"):
-            os.makedirs("config")
-            with open(Config.CONFIG, "w") as file:
-                c = """
+        directory = ""
+        name = ""
+        if self._configpath is None or self._configpath.strip() == "":
+            raise ConfigurationException("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 +151,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 +178,25 @@ 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 +220,20 @@ 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")
         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 +338,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.476}/csvpath/util/printer.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
 import sys
+from .config_exception import ConfigurationException
 
 
 class Printer(ABC):
@@ -75,3 +76,28 @@ class TestPrinter(Printer):
 
     def print_to(self, name: str, string: str) -> None:
         self.lines.append(string)
+
+
+class LogPrinter(StdOutPrinter):
+    """logs to info by default"""
+
+    def __init__(self, logger):
+        self._logger = logger
+        if logger is None:
+            raise ConfigurationException("Logger cannot be None")
+        super().__init__()
+
+    def print_to(self, name: str, msg: str) -> None:
+        self._count += 1
+        if name in ["info", None]:
+            self._logger.info(msg)
+        elif name == "debug":
+            self._logger.debug(msg)
+        elif name in ["warn", "warning"]:
+            self._logger.warning(msg)
+        elif name == "error":
+            self._logger.error(msg)
+        else:
+            self._logger.info(msg)
+
+        self._last_line = msg

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "csvpath"
-version = "0.0.474"
+version = "0.0.476"
 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