csvpath 0.0.480__tar.gz → 0.0.481__tar.gz

{csvpath-0.0.480 → csvpath-0.0.481}/PKG-INFO

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

{csvpath-0.0.480 → csvpath-0.0.481}/csvpath/csvpath.py

@@ -172,7 +172,6 @@ class CsvPath(CsvPathPublic, ErrorCollector, Printer):  # pylint: disable=R0902,
         #
         self.stopped = False
         self._advance = 0
-
         #
         # set by fail()
         #
@@ -249,9 +248,12 @@ class CsvPath(CsvPathPublic, ErrorCollector, Printer):  # pylint: disable=R0902,
         # use match component rules and exceptions to generate validation
         # info. but long term this capability may go away.
         #
-        self._log_validation_errors = False
+        self._log_validation_errors = True
         self._print_validation_errors = True
-        self._raise_validation_errors = True
+        self._raise_validation_errors = None
+        self._match_validation_errors = None
+        self._stop_on_validation_errors = None
+        self._fail_on_validation_errors = None
         #
         # 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
@@ -372,28 +374,70 @@ class CsvPath(CsvPathPublic, ErrorCollector, Printer):  # pylint: disable=R0902,
                 self._errors = []
             self._errors.append(error)
 
-    def report_validation_errors(self, msg: str) -> None:
-        if self.print_validation_errors:
-            self.print(msg)
-        elif self.log_validation_errors:
-            self.logger.warning(msg)
-        #
-        # the args class will do the raise if it is told to by the prop
-        #
-
+    #
+    # validation error handling overrides the error policy in config. this
+    # is because the validation handling is:
+    #   - different. it is built-in. it deals with programmatic decisions
+    #     about how functions work and is the basis for structural (schema)
+    #     validation.
+    #   - set on a per csvpath basis in comments
+    #
+    # by default, validation errors do not impact matching. they are print
+    # and raise only. however, you can set them to raise or match/not-match
+    # and/or suppress printing.
+    #
     def set_validation_error_handling(self, veh) -> None:
-        if veh and veh.find("print") > -1:
-            self._print_validation_errors = True
-        else:
+        # print prints to the Printer(s), not std.out. atm, no
+        # customization of messages is possible, so there is likely
+        # to be stylistic mismatch with other output.
+        if veh and veh.find("no-print") > -1:
             self._print_validation_errors = False
-        if veh and veh.find("log") > -1:
-            self._log_validation_errors = True
+        elif veh and veh.find("print") > -1:
+            self._print_validation_errors = True
         else:
-            self._log_validation_errors = False
-        if veh and veh.find("raise") > -1:
+            self._print_validation_errors = None
+        #
+        if veh and veh.find("no-raise") > -1:
+            self._raise_validation_errors = False
+        elif veh and veh.find("raise") > -1:
             self._raise_validation_errors = True
         else:
-            self._raise_validation_errors = False
+            self._raise_validation_errors = None
+        #
+        # match, no-match, and None do:
+        #   match: return True on error
+        #   no-match: return False on error
+        #   None: default behavior: default_match() or result of matches()
+        if veh and veh.find("no-match") > -1:
+            self._match_validation_errors = False
+        elif veh and veh.find("match") > -1:
+            self._match_validation_errors = True
+        else:
+            self._match_validation_errors = None
+        #
+        # also stop and fail to match the config
+        #
+        if veh and veh.find("no-stop") > -1:
+            self._stop_on_validation_errors = False
+        elif veh and veh.find("stop") > -1:
+            self._stop_on_validation_errors = True
+        else:
+            self._stop_on_validation_errors = None
+        #
+        if veh and veh.find("no-fail") > -1:
+            self._fail_on_validation_errors = False
+        elif veh and veh.find("fail") > -1:
+            self._fail_on_validation_errors = True
+        else:
+            self._fail_on_validation_errors = None
+
+    @property
+    def stop_on_validation_errors(self) -> bool:
+        return self._stop_on_validation_errors
+
+    @property
+    def fail_on_validation_errors(self) -> bool:
+        return self._fail_on_validation_errors
 
     @property
     def print_validation_errors(self) -> bool:
@@ -407,6 +451,10 @@ class CsvPath(CsvPathPublic, ErrorCollector, Printer):  # pylint: disable=R0902,
     def raise_validation_errors(self) -> bool:
         return self._raise_validation_errors
 
+    @property
+    def match_validation_errors(self) -> bool:
+        return self._match_validation_errors
+
     def add_printer(self, printer) -> None:  # pylint: disable=C0116
         if printer not in self.printers:
             self.printers.append(printer)
@@ -522,8 +570,8 @@ class CsvPath(CsvPathPublic, ErrorCollector, Printer):  # pylint: disable=R0902,
         # settings:
         #   - logic-mode: AND | OR
         #   - match-mode: matches | no-matches
-        #   - print-mode: default-off | default-on
-        #   - arg-validation-mode: print | log | raise | quiet
+        #   - print-mode: default | no-default
+        #   - validation-mode: (no-)print | log | (no-)raise | quiet | (no-)match
         #
         self.update_logic_mode_if()
         self.update_match_mode_if()
@@ -531,18 +579,18 @@ class CsvPath(CsvPathPublic, ErrorCollector, Printer):  # pylint: disable=R0902,
         self.update_arg_validation_mode_if()
 
     def update_arg_validation_mode_if(self) -> None:
-        if self.metadata and "arg-validation-mode" in self.metadata:
+        if self.metadata and "validation-mode" in self.metadata:
             # sets arg validation reporting. one or more or none of:
             #  - print
             #  - log
             #  - raise
             #
-            validation_mode = f"{self.metadata['arg-validation-mode']}".strip()
+            validation_mode = f"{self.metadata['validation-mode']}".strip()
             if validation_mode:
                 self.set_validation_error_handling(validation_mode)
                 self.logger.info(
-                    "Setting 'arg-validation-mode': %s",
-                    self.metadata["arg-validation-mode"],
+                    "Setting 'validation-mode': %s",
+                    self.metadata["validation-mode"],
                 )
 
     def update_logic_mode_if(self) -> None:
@@ -571,7 +619,7 @@ class CsvPath(CsvPathPublic, ErrorCollector, Printer):  # pylint: disable=R0902,
 
     def update_print_mode_if(self) -> None:
         if "print-mode" in self.metadata:
-            if f"{self.metadata['print-mode']}".strip() == "default-off":
+            if f"{self.metadata['print-mode']}".strip() == "no-default":
                 remove = -1
                 for i, p in enumerate(self.printers):
                     if isinstance(p, StdOutPrinter):
@@ -579,7 +627,7 @@ class CsvPath(CsvPathPublic, ErrorCollector, Printer):  # pylint: disable=R0902,
                         break
                 if remove >= 0:
                     del self.printers[remove]
-            elif f"{self.metadata['print-mode']}".strip() == "default-on":
+            elif f"{self.metadata['print-mode']}".strip() == "default":
                 done = False
                 for i, p in enumerate(self.printers):
                     if isinstance(p, StdOutPrinter):

{csvpath-0.0.480 → csvpath-0.0.481}/csvpath/matching/functions/args.py

@@ -8,7 +8,7 @@ from csvpath.matching.functions.function import Function
 from csvpath.matching.productions.reference import Reference
 from csvpath.matching.productions.equality import Equality
 from csvpath.matching.util.expression_utility import ExpressionUtility
-from ..util.exceptions import ChildrenException
+from ..util.exceptions import ChildrenException, ChildrenValidationException
 from csvpath.util.config_exception import ConfigurationException
 
 #   from csvpath.util.log_utility import LogUtility
@@ -194,7 +194,7 @@ class ArgSet:
             self._args = args
             self.max_length = len(self._args)
 
-    def validate(self, siblings: List[Matchable]) -> None:
+    def validate_structure(self, siblings: List[Matchable]) -> None:
         b = self._validate_length(siblings)
         if b is False:
             return False
@@ -235,11 +235,44 @@ class ArgSet:
                 break
             arg = self._args[i]
             #
+            # in principle we would want to avoid any case where we don't have an arg
+            # or the arg's actuals are none
+            # -- and ---
+            # if the arg exists but has [] elements treat it as a requirement that no
+            # optional values should be passed in on that arg in that particular use
+            # case.
+            #
+            # however, that approach a) breaks stuff i'd like to not break atm, and b)
+            # the only use case today (in empty()) is obviated by a second arg set
+            # that would in essence override the [] actuals in the first argset. so
+            # we have no case. given that, letting this idea go until it resurfaces
+            # in a more practical way.
+            #
+            # exp!
+            self._parent._csvpath.logger.debug("Checking arg[%i]: %s", i, arg)
+            """
+            if ( not arg or arg.actuals is None ):
+                if self._parent and self._parent._csvpath:
+                    self._parent._csvpath.logger.debug(
+                        "No expectations to validate actual values against in argset {self.argset_number}"
+                    )
+                found = True
+                break
+            if len(arg.actuals) == 0 and len(actuals) > 0:
+                if self._parent and self._parent._csvpath:
+                    self._parent._csvpath.logger.debug(
+                        "No optional args should be presented in {self.argset_number}"
+                    )
+                found = False
+                break
+            """
+            # end exp
+            #
+            # start orig w/orig comment:
             # we can't validate arg if we have no actuals expectations.
             # this is a way to disable line-by-line validation -- just
             # remove the expectations from the args
             #
-            self._parent._csvpath.logger.debug("Checking arg[%i]: %s", i, arg)
             if not arg or not arg.actuals or len(arg.actuals) == 0:
                 if self._parent and self._parent._csvpath:
                     self._parent._csvpath.logger.debug(
@@ -247,6 +280,9 @@ class ArgSet:
                     )
                 found = True
                 break
+            #
+            # end orig
+            #
             if Any in arg.actuals:
                 self._parent._csvpath.logger.debug("Found Any so we're done")
                 found = True
@@ -309,6 +345,21 @@ class Args:
         # child.to_value(skips=skips) to result in an int, did it?
         #
         self.matched = False
+        self._args_match = True
+
+    def reset(self) -> None:
+        self._args_match = True
+        self.matched = False
+
+    @property
+    def args_match(self) -> bool | None:
+        """Only used in the runtime actuals matching. speaks
+        to if the line should be considered matched or not.
+        None is default
+        True means matching succeeded
+        False means matching failed
+        """
+        return self._args_match
 
     def argset(self, maxlength: int = -1) -> ArgSet:
         a = ArgSet(maxlength, parent=self)
@@ -339,10 +390,10 @@ class Args:
         #
         good = False
         for aset in self._argsets:
-            if aset.validate(siblings):
+            if aset.validate_structure(siblings):
                 good = True
         if not good:
-            _ = " at {self.matchable.my_chain}" if self.matchable else ""
+            _ = f" at {self.matchable.my_chain}" if self.matchable else ""
             msg = f"{self._csvpath_id()} Incorrectly written{_}. Wrong type or number of args."
             raise ChildrenException(msg)
         self.validated = True
@@ -390,19 +441,13 @@ class Args:
 
     def handle_errors_if(self, mismatch_count, mismatches):
         if mismatch_count == len(self._argsets):
+            self._args_match = False
             pm = f"mismatch in {self.matchable.my_chain}: {mismatches}"
             # when would we not have a csvpath?
             pln = (
                 self._csvpath.line_monitor.physical_line_number if self._csvpath else 0
             )
-            csvpathid = self._csvpath_id()
-            pm = f"{csvpathid} Wrong value(s) at line {pln}: {pm}"
-            # self._csvpath.report_validation_errors(pm)
-            if self._csvpath is None or self._csvpath.raise_validation_errors:
-                raise ChildrenException(pm)
-            # we print in-run validation errors as part of the raise handle,
-            # so this is a bit extra. We can suppress the exceptions completely
-            # but still print args validation errors. not sure that is anything
-            # more than a deep corner case. defering removing it.
-            if self._csvpath and self._csvpath.print_validation_errors:
-                self._csvpath.report_validation_errors(pm)
+            csvpathid = f"{self._csvpath_id()} " if self._csvpath_id() else ""
+            ei = ExpressionUtility.get_my_expressions_index(self._matchable)
+            pm = f"{csvpathid}Wrong value in match component {ei} at line {pln}: {pm}"
+            raise ChildrenValidationException(pm)

{csvpath-0.0.480 → csvpath-0.0.481}/csvpath/matching/functions/boolean/all.py

@@ -50,8 +50,6 @@ class All(MatchDecider):
                 self.all_exist()
             elif isinstance(child, Variables):
                 self.all_variables()
-            else:
-                raise ChildrenException("Child cannot be {child}")
 
     def all_variables(self) -> None:  # pylint: disable=C0116
         # default is True in case no vars

{csvpath-0.0.480 → csvpath-0.0.481}/csvpath/matching/functions/boolean/any.py

@@ -114,6 +114,7 @@ class Any(MatchDecider):
                     break
         else:
             c = self.children[0].left
+            # definitely a structure / children exception
             raise ChildrenException(
                 f"Left child of any() must be header or variable, not {c}"
             )

csvpath-0.0.481/csvpath/matching/functions/boolean/boolean.py

@@ -0,0 +1,31 @@
+# pylint: disable=C0114
+from csvpath.matching.util.expression_utility import ExpressionUtility
+from csvpath.matching.util.exceptions import DataException
+from csvpath.matching.productions import Term, Variable, Header
+from ..function import Function
+from ..function_focus import ValueProducer
+from ..args import Args
+
+
+class Boolean(ValueProducer):
+    def check_valid(self) -> None:
+        self.args = Args(matchable=self)
+        a = self.args.argset(1)
+        a.arg(types=[Term, Variable, Header, Function], actuals=[None, bool])
+        self.args.validate(self.siblings())
+        super().check_valid()
+
+    def _produce_value(self, skip=None) -> None:
+        i = self._value_one(skip=skip)
+        if i is None:
+            self.value = None
+        else:
+            self.value = ExpressionUtility.to_bool(i)
+
+    def _decide_match(self, skip=None) -> None:
+        # we need to make sure a value is produced so that we see
+        # any errors. when we stand alone we're just checking our
+        # boolean-iness. when we're producing a value we're checking
+        # boolean-iness and casting and raising errors.
+        self.to_value(skip=skip)
+        self.match = self.default_match()  # pragma: no cover

{csvpath-0.0.480 → csvpath-0.0.481}/csvpath/matching/functions/boolean/empty.py

@@ -1,9 +1,12 @@
 # pylint: disable=C0114
+from typing import Any
 from ..function_focus import MatchDecider
 from csvpath.matching.productions import Header, Variable, Equality, Term
 from csvpath.matching.util.exceptions import ChildrenException
 from ..headers.headers import Headers
 from csvpath.matching.util.expression_utility import ExpressionUtility
+from csvpath.matching.functions.args import Args
+from csvpath.matching.functions.function import Function
 
 
 class Empty(MatchDecider):
@@ -12,22 +15,26 @@ class Empty(MatchDecider):
     if you pass it headers() it checks for all headers being empty."""
 
     def check_valid(self) -> None:
-        if len(self.children) == 0:
-            raise ChildrenException("empty() must have at least 1 argument")
-        elif isinstance(self.children[0], Headers):
-            if len(self.children) != 1:  # pragma: no cover
-                raise ChildrenException(
-                    "If empty() has a headers() argument it can only have 1 argument"
-                )
-        children = self.children
-        if isinstance(self.children[0], Equality):
-            children = self.children[0].commas_to_list()
-        self._validate(children)
+        self.args = Args(matchable=self)
+        #
+        # we'd like to disallow headers from taking a value in this case, but we
+        # cannot because headers is a function and will be covered by the second
+        # argset, so we handle that in a helper validation function.
+        #
+        a = self.args.argset(1)
+        a.arg(types=[Headers])
+        a = self.args.argset()
+        a.arg(types=[Variable, Function, Header], actuals=[None, Any])
+        self.args.validate(self.siblings())
+        #
+        self._validate()
         super().check_valid()  # pragma: no cover
 
-    def _validate(self, children):
-        for s in children:
-            if isinstance(s, Headers) and len(children) > 1:
+    def _validate(self):
+        sibs = self.siblings()
+        for s in sibs:
+            # both definitely structure / children exceptions
+            if isinstance(s, Headers) and len(sibs) > 1:
                 raise ChildrenException(
                     "If empty() has a headers() argument it can only have 1 argument"
                 )

{csvpath-0.0.480 → csvpath-0.0.481}/csvpath/matching/functions/boolean/inf.py

@@ -28,8 +28,9 @@ class In(MatchDecider):
         for s in siblings[1:]:
             v = s.to_value(skip=skip)
             if isinstance(s, Term):
-                vs = f"{v}".split("|")
-                inf += vs
+                v = f"{v}".strip()
+                nvs = [_.strip() for _ in v.split("|")]
+                inf += nvs
             else:
                 # tuple would mean vars were frozen. this would not be
                 # surprising from a reference
@@ -41,4 +42,5 @@ class In(MatchDecider):
                         inf.append(k)
                 else:
                     inf.append(v)
-        self.match = t in inf
+        ret = t in inf
+        self.match = ret

{csvpath-0.0.480 → csvpath-0.0.481}/csvpath/matching/functions/boolean/yes.py

@@ -8,7 +8,8 @@ class Yes(ValueProducer):
     """returns True"""
 
     def check_valid(self) -> None:
-        Args().validate(self.siblings())
+        self.args = Args(matchable=self)
+        self.args.validate(self.siblings())
         super().check_valid()
 
     def _produce_value(self, skip=None) -> None:

{csvpath-0.0.480 → csvpath-0.0.481}/csvpath/matching/functions/counting/count.py

@@ -1,6 +1,9 @@
 # pylint: disable=C0114
 from typing import Any
 from ..function_focus import ValueProducer
+from ..function import Function
+from ..args import Args
+from csvpath.matching.productions import Equality, Variable, Header, Term
 
 
 class Count(ValueProducer):
@@ -9,6 +12,16 @@ class Count(ValueProducer):
 
     def check_valid(self) -> None:  # pylint: disable=W0246
         # note to self: no specific validity checks from way back
+        # these args may need work
+        self.args = Args(matchable=self)
+        a = self.args.argset(0)
+        a = self.args.argset()
+        a.arg(
+            types=[None, Variable, Function, Header, Term, Equality],
+            actuals=[None, Any],
+        )
+        self.args.validate(self.siblings())
+        #
         super().check_valid()  # pylint: disable=W0246
         # re: W0246: Matchable handles this class's children
 

{csvpath-0.0.480 → csvpath-0.0.481}/csvpath/matching/functions/counting/increment.py

@@ -1,6 +1,6 @@
 # pylint: disable=C0114
 from typing import Any
-from csvpath.matching.util.exceptions import ChildrenException
+from csvpath.matching.util.exceptions import DataException
 from ..function_focus import ValueProducer
 from csvpath.matching.productions import Term, Header, Variable, Equality
 from ..function import Function
@@ -26,12 +26,12 @@ class Increment(ValueProducer):
             return self._noop_value()
         tv = self.children[0].right.to_value()
         if not isinstance(tv, int):
-            raise ChildrenException(
+            raise DataException(
                 "increment value must be a positive int"
             )  # pragma: no cover
         tv = int(tv)
         if tv <= 0:
-            raise ChildrenException(
+            raise DataException(
                 "increment value must be a positive int"
             )  # pragma: no cover
         if not self.value: