csvpath 0.0.455__tar.gz → 0.0.457__tar.gz

{csvpath-0.0.455 → csvpath-0.0.457}/PKG-INFO

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

{csvpath-0.0.455 → csvpath-0.0.457}/csvpath/csvpath.py

@@ -114,26 +114,27 @@ class CsvPath(CsvPathPublic):  # pylint: disable=R0902, R0904
         #
         self.match = None
         #
+        # when AND is True we do a logical AND of the match components
+        # to see if there is a match. this is the default. when AND is
+        # False (or set OR to True) the match components are ORed to
+        # determine if a line matches. in the former case all the match
+        # components must agree for a line to match. in the latter case,
+        # if any one match component votes True the line is matched.
+        # technically you can switch from AND to OR, or vice versa, in
+        # the middle of iterating a file using next(). probably not a
+        # good idea, tho.
+        #
+        self._AND = True
+        #
         # when True the lines that do not match are returned from next()
         # and collect(). this effectively switches CsvPath from being an
-        # AND machine to being an OR machine; though we do not actually
-        # create an OR expression. in the default, we say:
+        # AND machine to being a NOT AND machine. we do not actually
+        # create an OR expression in this case. in the default, we say:
         #     are all of these things true?
         # but when collect_when_not_matched is True we ask:
         #     are any of these things not true?
         #
         self._when_not_matched = False
-        #
-        # note-to-self: by default CsvPath's matcher does an AND match. if
-        # we set this property to True we tell the matcher to do an OR.
-        # i.e. if any of the match components return true there is a match.
-        # HOWEVER, this would be a big change because default values and
-        # nocontrib would have to be negative when ORing. we don't have a
-        # way to do that today -- defaults aren't completely centralized.
-        # they are, easy.
-        #
-        # self._or_match = False
-        #
         self.headers = None
         self.variables: Dict[str, Any] = {}
         self.delimiter = delimiter
@@ -247,6 +248,22 @@ class CsvPath(CsvPathPublic):  # pylint: disable=R0902, R0904
         self.logger = LogUtility.logger(self)
         self.logger.info("initialized CsvPath")
 
+    @property
+    def AND(self) -> bool:
+        return self._AND
+
+    @AND.setter
+    def AND(self, a: bool) -> bool:
+        self._AND = a
+
+    @property
+    def OR(self) -> bool:
+        return not self._AND
+
+    @OR.setter
+    def OR(self, a: bool) -> bool:
+        self._AND = not a
+
     @property
     def identity(self) -> str:
         """returns id or name if found in metadata. the id or name gets
@@ -857,6 +874,7 @@ class CsvPath(CsvPathPublic):  # pylint: disable=R0902, R0904
             self.matcher = Matcher(
                 csvpath=self, data=self.match, line=line, headers=self.headers, myid=h
             )
+            self.matcher._AND = self._AND
         else:
             self.logger.debug("Resetting and reloading matcher")
             self.matcher.reset()

{csvpath-0.0.455 → csvpath-0.0.457}/csvpath/matching/functions/strings/length.py

@@ -45,4 +45,5 @@ class MinMaxLength(ValueProducer):  # pylint: disable=C0115
         return self.value
 
     def _decide_match(self, skip=None) -> None:
-        self.match = self.to_value(skip=skip) > 0
+        v = self.to_value(skip=skip)
+        self.match = v

{csvpath-0.0.455 → csvpath-0.0.457}/csvpath/matching/functions/validation.py

@@ -180,7 +180,6 @@ class Validation(Matchable):
         if hasattr(self.children[0].right, "op"):
             raise ChildrenException(f"{self.name}() can only have 2 arguments")
         if len(left) > 0:
-            print(f"validate: 183: {self.children[0].left} === {left}")
             if not self._class_match(self.children[0].left, left):
                 raise ChildrenException(
                     f"{self.name}() must have a first argument of type: {left}"

{csvpath-0.0.455 → csvpath-0.0.457}/csvpath/matching/lark_transformer.py

@@ -24,13 +24,20 @@ class LarkTransformer(Transformer):  # pylint: disable=C0115
         super().__init__()
 
     def match(self, *expressions):  # pylint: disable=C0116
-        return list(expressions)
+        return [e for e in list(expressions) if e is not None]
 
     # left (WHEN action)?
     # equality (WHEN action)?
     # assignment
     # COMMENT
     def expression(self, acted_on, when=None, action=None):  # pylint: disable=C0116
+        # print(f"expression: acted_on: {acted_on}, when: {when}, action: {action}")
+        if acted_on is None and when is None and action is None:
+            # this is a comment
+            return None
+        #
+        #
+        #
         e = Expression(self.matcher)
         if when is None:
             e.add_child(acted_on)

{csvpath-0.0.455 → csvpath-0.0.457}/csvpath/matching/matcher.py

@@ -30,6 +30,7 @@ class Matcher:  # pylint: disable=R0902
         self.if_all_match = []
         self.skip = False
         self.cachers = []
+        self._AND = True
         if data is not None:
             self.parser = LarkParser()
             tree = self.parser.parse(data)
@@ -126,7 +127,7 @@ class Matcher:  # pylint: disable=R0902
             _.clear_caches()
         self.cachers = []
 
-    def matches(self, *, syntax_only=False) -> bool:
+    def matches(self) -> bool:
         """this is the main work of the Matcher. we enumerate the self.expressions.
         if all evaluate to True in an AND operation we return True."""
         #
@@ -134,22 +135,25 @@ class Matcher:  # pylint: disable=R0902
         # last() in the csvpath.
         #
         if self.csvpath.line_monitor.is_last_line_and_blank(self.line):
-            # if self.csvpath.line_monitor.is_last_line_and_empty(self.line):
             self.csvpath.logger.debug(
                 "Is last line and blank. Doing lasts and then returning True"
             )
             self._do_lasts()
             return True
         ret = True
-        failed = False
+        failed = False if self._AND else True
         self.csvpath.logger.debug(
-            "beginning to match against line[%s]: %s",
+            "Beginning %s match against line[%s]: %s",
+            ("AND" if self._AND else "OR"),
             self.csvpath.line_monitor.physical_line_number,
             str(self.line),
         )
         for i, et in enumerate(self.expressions):
             self.csvpath.logger.debug(
-                "Beginning to consider expression: et[%s]: %s: %s", i, et[0], et[1]
+                "Beginning to consider expression: expressions[%s]: %s: %s",
+                i,
+                et[0],
+                et[1],
             )
             if self.csvpath and self.csvpath.stopped:
                 #
@@ -172,28 +176,31 @@ class Matcher:  # pylint: disable=R0902
                 self.csvpath.logger.debug("Skipping at line %s", pln)
                 self.skip = False
                 return False
+            #
+            # from here down we care what the expression tells us.
+            # we can require concordance or we can allow executive
+            # decisons.
+            #
             if et[1] is True:
                 ret = True
             elif et[1] is False:
                 ret = False
-            elif not et[0].matches(skip=[]) and not syntax_only:
+            elif et[0].matches(skip=[]) is False:
                 et[1] = False
                 ret = False
             else:
                 et[1] = True
                 ret = True
-            if not ret:
-                failed = True
             #
-            # if we're failed we need to (re)set ret in case this is the final iteration.
+            # now ret holds this expression's vote
             #
-            if failed:
-                ret = False
-        if ret is True:
-            self.csvpath.logger.debug("Setting any vars deferred till match")
-            self.do_set_if_all_match()
-        else:
-            pass
+            pln = self.csvpath.line_monitor.physical_line_number
+            if self._AND:
+                if ret is False:
+                    failed = True
+            else:
+                if ret is True:
+                    failed = False
         #
         # here we could be set to do an OR, not an AND.
         # we would do that only in the case that the answer was False. if so, we
@@ -201,28 +208,13 @@ class Matcher:  # pylint: disable=R0902
         # were found, we would respond True; else, False.
         #
         pln = self.csvpath.line_monitor.physical_line_number
-        self.csvpath.logger.debug("Match result for line %s: %s", pln, ret)
-        return ret
+        self.csvpath.logger.debug("Match result for line %s: %s", pln, failed)
+        return not failed
 
     def check_valid(self) -> None:  # pylint: disable=C0116
         for _ in self.expressions:
             _[0].check_valid()
 
-    def do_set_if_all_match(self) -> None:  # pylint: disable=C0116
-        for _ in self.if_all_match:
-            name = _[0]
-            value = _[1]
-            tracking = _[2]
-            self.set_variable(name, value=value, tracking=tracking)
-        self.if_all_match = []
-
-    def set_if_all_match(self, name: str, value: Any, tracking=None) -> None:
-        """registers a variable set to happen only after the line's consideration
-        is complete and it is found to match. this is used for setting variables
-        when they have 'onmatch'; however, more recently we handle onmatch in
-        another way. you can see that in Matchable."""
-        self.if_all_match.append((name, value, tracking))
-
     def get_variable(self, name: str, *, tracking=None, set_if_none=None) -> Any:
         """see CsvPath.get_variable"""
         if self.csvpath is None:

{csvpath-0.0.455 → csvpath-0.0.457}/csvpath/util/config.py

@@ -98,21 +98,21 @@ class CsvPathConfig:
             os.makedirs("config")
             with open(CsvPathConfig.CONFIG, "w") as file:
                 c = """
-                    [csvpath_files]
-                    extensions = txt, csvpath, csvpaths
-                    [csv_files]
-                    extensions = txt, csv, tsv, dat, tab, psv, ssv
-                    [errors]
-                    csvpath = raise, collect, stop, fail
-                    csvpaths = raise, collect
-                    [logging]
-                    csvpath = info
-                    csvpaths = info
-                    log_file = logs/csvpath.log
-                    log_files_to_keep = 100
-                    log_file_size = 52428800
-                    [config]
-                    path =
+[csvpath_files]
+extensions = txt, csvpath, csvpaths
+[csv_files]
+extensions = txt, csv, tsv, dat, tab, psv, ssv
+[errors]
+csvpath = raise, collect, stop, fail
+csvpaths = raise, collect
+[logging]
+csvpath = info
+csvpaths = info
+log_file = logs/csvpath.log
+log_files_to_keep = 100
+log_file_size = 52428800
+[config]
+path =
                 """
                 file.write(c)
             print(f"Creating a default config file at {CsvPathConfig.CONFIG}.")

{csvpath-0.0.455 → csvpath-0.0.457}/pyproject.toml

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