csvpath 0.0.467__tar.gz → 0.0.469__tar.gz

{csvpath-0.0.467 → csvpath-0.0.469}/PKG-INFO

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

{csvpath-0.0.467 → csvpath-0.0.469}/csvpath/csvpath.py

@@ -633,6 +633,10 @@ 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,
+                )
                 break
         self.finalize()
         # moving to finalize
@@ -673,7 +677,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

{csvpath-0.0.467 → csvpath-0.0.469}/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.467 → csvpath-0.0.469}/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
@@ -56,7 +57,7 @@ from .stats.percent_unique import PercentUnique
 from .stats.stdev import Stdev
 from .stats.correlate import Correlate
 from .print.printf import Print
-from .print.table import HeaderTable, RowTable, VarTable
+from .print.table import HeaderTable, RowTable, VarTable, RunTable
 from .print.print_line import PrintLine
 from .print.jinjaf import Jinjaf
 from .print.print_queue import PrintQueue
@@ -355,8 +356,12 @@ class FunctionFactory:
             f = RowTable(matcher, name, child)
         elif name == "var_table":
             f = VarTable(matcher, name, child)
+        elif name == "run_table":
+            f = RunTable(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.467 → csvpath-0.0.469}/csvpath/matching/functions/print/table.py

@@ -1,6 +1,7 @@
 # pylint: disable=C0114
 import textwrap
 from tabulate import tabulate
+from csvpath.matching.util.print_parser import PrintParser
 from ..function_focus import SideEffect
 
 
@@ -51,7 +52,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]]]
@@ -131,3 +131,53 @@ class VarTable(SideEffect):
         self.matcher.csvpath.print(
             tabulate(rows, headers=headers, tablefmt="simple_grid")
         )
+
+
+class RunTable(SideEffect):
+    """prints a table of runtime data and any metadata available"""
+
+    def check_valid(self) -> None:
+        self.validate_zero_args()
+        super().check_valid()
+
+    def _produce_value(self, skip=None) -> None:
+        self.value = self.matches(skip=skip)
+
+    def _decide_match(self, skip=None) -> None:
+        self.print_all()
+        self.match = self.default_match()
+
+    def print_all(self):
+        headers = ["Key", "Value"]
+        # do the metadata first, if any
+        rows = []
+        for k, v in self.matcher.csvpath.metadata.items():
+            headers.append(k)
+            v = str(v)
+            if len(v) > 50:
+                v = textwrap.fill(v, width=50)
+            rows.append([k, v])
+
+        if len(rows) > 0:
+            self.matcher.csvpath.print("Metadata")
+            self.matcher.csvpath.print(
+                tabulate(rows, headers=headers, tablefmt="simple_grid")
+            )
+        # there will definitely be runtime data, but just from this csvpath.
+        # it would be possible to get more, but not sure this would be the
+        # right way/place to do it.
+        parser = PrintParser()
+        table = {}
+        parser._get_runtime_data_from_local(self.matcher.csvpath, table)
+        rows = []
+        for k, v in table.items():
+            headers.append(k)
+            v = str(v)
+            if len(v) > 50:
+                v = textwrap.fill(v, width=50)
+            rows.append([k, v])
+
+        self.matcher.csvpath.print("Runtime data")
+        self.matcher.csvpath.print(
+            tabulate(rows, headers=headers, tablefmt="simple_grid")
+        )

{csvpath-0.0.467 → csvpath-0.0.469}/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.469/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.467 → csvpath-0.0.469}/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.467 → csvpath-0.0.469}/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.467 → csvpath-0.0.469}/csvpath/matching/util/print_parser.py

@@ -274,7 +274,8 @@ class PrintParser:
         _id = "csvpath" if "name" not in csvpath.metadata else csvpath.metadata["name"]
         if _id.strip() == "":
             _id = "csvpath"
-        if "failed" not in runtime:
-            runtime["failed"] = {}
-        runtime["failed"][_id] = not csvpath.is_valid
+        runtime["identity"] = csvpath.identity
+        if "valid" not in runtime:
+            runtime["valid"] = {}
+        runtime["valid"][csvpath.identity] = csvpath.is_valid
         runtime["stopped"] = csvpath.stopped

{csvpath-0.0.467 → csvpath-0.0.469}/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.467 → csvpath-0.0.469}/pyproject.toml

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