csvpath 0.0.466__tar.gz → 0.0.468__tar.gz

{csvpath-0.0.466 → csvpath-0.0.468}/PKG-INFO

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

{csvpath-0.0.466 → csvpath-0.0.468}/csvpath/csvpath.py

@@ -633,6 +633,13 @@ class CsvPath(CsvPathPublic, ErrorCollector):  # pylint: disable=R0902, R0904
                     raise MatchException(msg)
                 yield line
             if self.stopped:
+                self.logger.info(
+                    "CsvPath has been stopped at line %s",
+                    self.line_monitor.physical_line_number,
+                )
+                print(
+                    f"CsvPath.next: self.stopped: {self.stopped} at {self.line_monitor.physical_line_number}"
+                )
                 break
         self.finalize()
         # moving to finalize
@@ -673,7 +680,8 @@ class CsvPath(CsvPathPublic, ErrorCollector):  # pylint: disable=R0902, R0904
         # this method can run multiple times w/np, but that
         # shouldn't happen anyway.
         self._freeze_path = True
-        self.matcher.clear_caches()
+        if self.matcher:
+            self.matcher.clear_caches()
 
     def track_line(self, line) -> None:
         """csvpaths needs to handle some of the iteration logic, and we don't want
@@ -728,6 +736,15 @@ class CsvPath(CsvPathPublic, ErrorCollector):  # pylint: disable=R0902, R0904
                 self.logger.debug(
                     "CsvPath.matches:703: %s: matches: %s", self.identity, matches
                 )
+            #
+            # if we are done scanning we can stop
+            #
+            if self.scanner.is_last(self.line_monitor.physical_line_number):
+                pln = self.line_monitor.physical_line_number
+                print(
+                    f"CsvPath._consider_line: stopping at {pln}? {self.scanner.is_last(pln)}"
+                )
+                self.stop()
             if matches is True:
                 #
                 # _current_match_count is a placeholder that

{csvpath-0.0.466 → csvpath-0.0.468}/csvpath/matching/functions/counting/tally.py

@@ -36,6 +36,11 @@ class Tally(ValueProducer):
             name = self.first_non_term_qualifier("tally")
         else:
             name = f"""{self.first_non_term_qualifier("tally")}_{name}"""
+        if f"{value}".strip() == "":
+            self.matcher.csvpath.logger.warn(
+                "Cannot store an empty tracking value in %s. >>%s<<", name, value
+            )
+            return
         count = self.matcher.get_variable(name, tracking=value)
         if count is None:
             count = 0

{csvpath-0.0.466 → csvpath-0.0.468}/csvpath/matching/functions/function_factory.py

@@ -11,6 +11,7 @@ from .strings.strip import Strip
 from .strings.length import Length, MinMaxLength
 from .strings.regex import Regex
 from .strings.concat import Concat
+from .strings.num import Num
 from .strings.metaphone import Metaphone
 from .counting.count import Count
 from .counting.has_matches import HasMatches
@@ -357,6 +358,8 @@ class FunctionFactory:
             f = VarTable(matcher, name, child)
         elif name == "empty_stack":
             f = EmptyStack(matcher, name, child)
+        elif name == "num":
+            f = Num(matcher, name, child)
 
         else:
             if (

{csvpath-0.0.466 → csvpath-0.0.468}/csvpath/matching/functions/print/table.py

@@ -51,7 +51,6 @@ class RowTable(SideEffect):
             j = v2
         headers = []
         row = None
-        print(f"tables.i: {i}, {j}")
         if i == j:
             headers.append(self.matcher.csvpath.headers[i])
             row = [[self.matcher.line[i]]]

{csvpath-0.0.466 → csvpath-0.0.468}/csvpath/matching/functions/strings/metaphone.py

@@ -10,7 +10,7 @@ class Metaphone(ValueProducer):
     first arg and expects a reference in the second arg. the
     reference must point to a lookup variable. the lookup variable
     must be in the form: Dict[metaphone,canonical]. the most
-    likely way of creating that variable today is to use tally(),
+    likely way of creating that variable today is to use track(),
     passing something like: tally(metaphone(#header), #header)"""
 
     def check_valid(self) -> None:

csvpath-0.0.468/csvpath/matching/functions/strings/num.py

@@ -0,0 +1,28 @@
+# pylint: disable=C0114
+from csvpath.matching.productions import Term, Variable, Header
+from csvpath.matching.util.expression_utility import ExpressionUtility
+from ..function_focus import ValueProducer
+from ..function import Function
+
+
+class Num(ValueProducer):
+    """parses a string to a number, if possible"""
+
+    def check_valid(self) -> None:
+        self.validate_one_arg(types=[Term, Variable, Header, Function])
+        super().check_valid()
+
+    def _produce_value(self, skip=None) -> None:
+        value = self.children[0].to_value(skip=skip)
+        if value is None:
+            self.value = 0
+        elif isinstance(value, int):
+            self.value = value
+        elif isinstance(value, float):
+            self.value = value
+        else:
+            self.value = ExpressionUtility.to_float(value)
+
+    def _decide_match(self, skip=None) -> None:
+        self.to_value(skip=skip)
+        self.match = self._noop_match()

{csvpath-0.0.466 → csvpath-0.0.468}/csvpath/matching/functions/validation.py

@@ -104,7 +104,9 @@ class Validation(Matchable):
                 raise ChildrenException(f"{self.name}()'s argument must be {first_arg}")
         else:
             if not self.children[0].op == ",":
-                raise ChildrenException(f"{self.name} children opperation is incorrect")
+                raise ChildrenException(
+                    f"{self.name}'s children opperation is incorrect"
+                )
             if not self._class_match(self.children[0].left, first_arg):
                 raise ChildrenException(
                     f"{self.name}()'s first argument must be {first_arg}"
@@ -113,6 +115,8 @@ class Validation(Matchable):
                 raise ChildrenException(
                     f"{self.name}()'s second argument must be {second_arg}"
                 )
+            if len(self.children[0].children) > 2:
+                raise ChildrenException(f"{self.name} can have at most 2 args")
 
     def validate_one_arg(self, types=None) -> None:  # pylint: disable=C0116
         if types is None:

{csvpath-0.0.466 → csvpath-0.0.468}/csvpath/matching/productions/reference.py

@@ -24,7 +24,7 @@ class Reference(Matchable):
             )  # pragma: no cover
         #
         # references are in the form:
-        #    $file[.path/name].(csvpath|metadata|variable|header).name[.tracking_name/index]
+        #    $path.(csvpath|metadata|variable|header).name[.tracking_name/index]
         #
         # results are always the most recent unless we pull specific results for a
         # header ref using a tracking value against an "id" or "name" metadata
@@ -102,6 +102,28 @@ class Reference(Matchable):
                     self._cache_vars = self.value
         return self.value
 
+    def data_type(self):
+        ref = self._get_reference()
+        return ref["var_or_header"]
+
+    def is_header(self):
+        return self.data_type() == "headers"
+
+    def is_variable(self):
+        return self.data_type() != "headers"
+
+    def data_name(self):
+        """this is the name of the datum being referred to. however, it
+        is not the tracking value. that is on the "tracking" key in the ref."""
+        ref = self._get_reference()
+        return ref["name"]
+
+    def tracking_name(self):
+        """this is the name of the tracking value."""
+        ref = self._get_reference()
+        return ref["tracking"]
+
+    """"
     def _get_results(self):
         cs = self.matcher.csvpath.csvpaths
         if cs is None:
@@ -122,7 +144,6 @@ class Reference(Matchable):
         #
         results_list = cs.results_manager.get_named_results(ref["paths_name"])
         if results_list and len(results_list) > 0:
-            # if self.ref["paths_name"] is None:
             results = results_list[0]
             # else:
             #    for r in results_list:
@@ -144,6 +165,7 @@ class Reference(Matchable):
             #
             raise MatchException("Results cannot be None for reference %s", self)
         return results
+    """
 
     def _get_reference(self) -> Dict[str, str]:
         if self.ref is None:
@@ -197,6 +219,11 @@ class Reference(Matchable):
         return ret
 
     def _header_value(self) -> Any:
+        ref = self._get_reference()
+        r = self.get_results()
+        return self._get_value_from_results(ref, r)
+
+    def get_results(self) -> Any:
         ref = self._get_reference()
         name = ref["paths_name"]
         rm = self.matcher.csvpath.csvpaths.results_manager
@@ -207,7 +234,8 @@ class Reference(Matchable):
             #
             if rm.get_number_of_results(name) == 1:
                 rs = rm.get_named_results(name)
-                ret = self._get_value_from_results(ref, rs[0])
+                return rs[0]
+                # ret = self._get_value_from_results(ref, rs[0])
             elif ref["tracking"]:
                 #
                 # find the specific path if we have a tracking value.
@@ -223,7 +251,8 @@ class Reference(Matchable):
                         ref["tracking"],
                         self,
                     )
-                ret = self._get_value_from_results(ref, r)
+                # ret = self._get_value_from_results(ref, r)
+                return r
             else:
                 #
                 # are we really going to aggregate all the values from all the

{csvpath-0.0.466 → csvpath-0.0.468}/csvpath/scanning/scanner.py

@@ -53,6 +53,16 @@ class Scanner:  # pylint: disable=R0902
         to_line = self.to_line if to_line == -1 else to_line
         all_lines = self.all_lines if all_lines is None else all_lines
         these = self.these if these is None else these
+        #
+        # what if from is > to? shouldn't be but we originally wanted
+        # to support that, way back, so we can do this swap.
+        #
+        if from_line and to_line and from_line > to_line:
+            _ = from_line
+            from_line = to_line
+            to_line = _
+
+        # end exp
         if all_lines:
             return (
                 line == self.csvpath.line_monitor.physical_end_line_number

{csvpath-0.0.466 → csvpath-0.0.468}/pyproject.toml

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