csvpath 0.0.484__tar.gz → 0.0.485__tar.gz

{csvpath-0.0.484 → csvpath-0.0.485}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: csvpath
-Version: 0.0.484
-Summary: A declarative language for data extraction and validation of CSV files
+Version: 0.0.485
+Summary: A declarative language for validation of CSV files
 Author: David Kershaw
 Author-email: dk107dk@hotmail.com
 Requires-Python: >=3.9,<4.0
@@ -30,7 +30,7 @@ Requires-Dist: pylightxl (>=1.61,<2.0)
 Requires-Dist: python-dateutil (>=2.9.0.post0,<3.0.0)
 Requires-Dist: tabulate (>=0.9.0,<0.10.0)
 Project-URL: Csvpath.org, https://www.csvpath.org
-Project-URL: Github, https://github.com/dk107dk/csvpath
+Project-URL: Github, https://github.com/csvpath/csvpath.git
 Description-Content-Type: text/markdown
 
 
@@ -141,12 +141,12 @@ Interactive use of csvpaths can be valuable, too, of course. There is a trivial
 <a name="running"></a>
 ## Running CsvPath
 
-CsvPath is <a href='https://pypi.org/project/csvpath/'>available on Pypi here</a>. The <a href='https://github.com/dk107dk/csvpath'>git repo is here</a>.
+CsvPath is <a href='https://pypi.org/project/csvpath/'>available on Pypi here</a>. The <a href='https://github.com/csvpath/csvpath'>git repo is here</a>.
 
 Two classes provide the functionality: CsvPath and CsvPaths. Each has only a few external methods.
 
 ### CsvPath
-(<a href='https://github.com/dk107dk/csvpath/blob/main/csvpath/csvpath.py'>code</a>)
+(<a href='https://github.com/csvpath/csvpath/blob/main/csvpath/csvpath.py'>code</a>)
 The CsvPath class is the basic entry point for running csvpaths.
 |method                      |function                                                        |
 |----------------------------|----------------------------------------------------------------|

{csvpath-0.0.484 → csvpath-0.0.485}/README.md

@@ -106,12 +106,12 @@ Interactive use of csvpaths can be valuable, too, of course. There is a trivial
 <a name="running"></a>
 ## Running CsvPath
 
-CsvPath is <a href='https://pypi.org/project/csvpath/'>available on Pypi here</a>. The <a href='https://github.com/dk107dk/csvpath'>git repo is here</a>.
+CsvPath is <a href='https://pypi.org/project/csvpath/'>available on Pypi here</a>. The <a href='https://github.com/csvpath/csvpath'>git repo is here</a>.
 
 Two classes provide the functionality: CsvPath and CsvPaths. Each has only a few external methods.
 
 ### CsvPath
-(<a href='https://github.com/dk107dk/csvpath/blob/main/csvpath/csvpath.py'>code</a>)
+(<a href='https://github.com/csvpath/csvpath/blob/main/csvpath/csvpath.py'>code</a>)
 The CsvPath class is the basic entry point for running csvpaths.
 |method                      |function                                                        |
 |----------------------------|----------------------------------------------------------------|

{csvpath-0.0.484 → csvpath-0.0.485}/csvpath/csvpath.py

@@ -37,7 +37,9 @@ class CsvPathPublic(ABC):
         """Reads a csvpath prepares to match against CSV file lines"""
 
     @abstractmethod
-    def parse_named_path(self, name):  # pragma: no cover
+    def parse_named_path(
+        self, name, *, disposably=False, specific=None
+    ):  # pragma: no cover
         """Parses a csvpath found in this CsvPath's CsvPaths parent's
         collection of named csvpaths"""
 
@@ -155,6 +157,16 @@ class CsvPath(CsvPathPublic, ErrorCollector, Printer):  # pylint: disable=R0902,
         #
         self._freeze_path = False
         #
+        # explain-mode: explain
+        # turns on capturing match reasoning and dumps the captured decisions to INFO
+        # at the end of a match. the reasoning is already present in the DEBUG but it
+        # is harder to see amid all the noise. we don't want to dump explainations
+        # all the time tho because it is very expensive -- potentially 25% worse
+        # performance. the explainations could be improved. atm this is an experimental
+        # feature.
+        #
+        self._explain = False
+        #
         # counts are 1-based
         #
         self.scan_count = 0
@@ -256,6 +268,14 @@ class CsvPath(CsvPathPublic, ErrorCollector, Printer):  # pylint: disable=R0902,
         self._stop_on_validation_errors = None
         self._fail_on_validation_errors = None
         #
+        # run mode determines if a csvpath gets run or if it is skipped. the
+        # main reasons to set run-mode: no-run vs. run are: you want to import
+        # it into other csvpaths that are in the same named-paths group, or
+        # you want to switch off a csvpath in a named-paths group for testing
+        # a similar reason.
+        #
+        self._run_mode = True
+        #
         # 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
         # your component instance and the logging level. e.g.:
@@ -264,6 +284,38 @@ class CsvPath(CsvPathPublic, ErrorCollector, Printer):  # pylint: disable=R0902,
         self.logger = LogUtility.logger(self)
         self.logger.info("initialized CsvPath")
         self._ecoms = ErrorCommsManager(csvpath=self)
+        self._function_times_match = {}
+        self._function_times_value = {}
+
+    @property
+    def run_mode(self) -> bool:
+        return self._run_mode
+
+    @run_mode.setter
+    def run_mode(self, mode) -> None:
+        self._run_mode = mode
+
+    def _up_function_time_match(self, c, t) -> None:
+        if c not in self.function_times_match:
+            self.function_times_match[c] = 0
+        st = self.function_times_match[c]
+        st += t
+        self.function_times_match[c] = st
+
+    @property
+    def function_times_match(self) -> int:
+        return self._function_times_match
+
+    def _up_function_time_value(self, c, t) -> None:
+        if c not in self.function_times_value:
+            self.function_times_value[c] = 0
+        st = self.function_times_value[c]
+        st += t
+        self.function_times_value[c] = st
+
+    @property
+    def function_times_value(self) -> int:
+        return self._function_times_value
 
     def do_i_raise(self) -> bool:
         return self._ecoms.do_i_raise()
@@ -507,6 +559,18 @@ class CsvPath(CsvPathPublic, ErrorCollector, Printer):  # pylint: disable=R0902,
     def is_frozen(self, freeze: bool) -> None:
         self._freeze_path = freeze
 
+    @property
+    def explain(self) -> bool:
+        """when this property is True CsvPath dumps a match explaination
+        to INFO. this can be expensive. a 25% performance hit wouldn't
+        be unexpected.
+        """
+        return self._explain
+
+    @explain.setter
+    def explain(self, yesno: bool) -> None:
+        self._explain = yesno
+
     @property
     def collect_when_not_matched(self) -> bool:
         """when this property is True CsvPath returns the lines that do not
@@ -579,8 +643,10 @@ class CsvPath(CsvPathPublic, ErrorCollector, Printer):  # pylint: disable=R0902,
         #   - validation-mode: (no-)print | log | (no-)raise | quiet | (no-)match
         #
         self.update_logic_mode_if()
+        self.update_run_mode_if()
         self.update_match_mode_if()
         self.update_print_mode_if()
+        self.update_explain_mode_if()
         self.update_arg_validation_mode_if()
 
     def update_arg_validation_mode_if(self) -> None:
@@ -598,6 +664,18 @@ class CsvPath(CsvPathPublic, ErrorCollector, Printer):  # pylint: disable=R0902,
                     self.metadata["validation-mode"],
                 )
 
+    def update_run_mode_if(self) -> None:
+        if self.metadata and "run-mode" in self.metadata:
+            if f"{self.metadata['run-mode']}".strip() == "no-run":
+                self.run_mode = False
+            elif f"{self.metadata['run-mode']}".strip() == "run":
+                self.run_mode = True
+            else:
+                self.logger.warning(
+                    "Incorrect metadata field value 'run-mode': %s",
+                    self.metadata["run-mode"],
+                )
+
     def update_logic_mode_if(self) -> None:
         if self.metadata and "logic-mode" in self.metadata:
             if f"{self.metadata['logic-mode']}".strip() == "AND":
@@ -622,6 +700,15 @@ class CsvPath(CsvPathPublic, ErrorCollector, Printer):  # pylint: disable=R0902,
                     self.metadata["return-mode"],
                 )
 
+    def update_explain_mode_if(self) -> None:
+        if "explain-mode" in self.metadata:
+            if f"{self.metadata['explain-mode']}".strip() == "no-explain":
+                self._explain = False
+            elif f"{self.metadata['explain-mode']}".strip() == "explain":
+                self._explain = True
+            else:
+                self._explain = False
+
     def update_print_mode_if(self) -> None:
         if "print-mode" in self.metadata:
             if f"{self.metadata['print-mode']}".strip() == "no-default":
@@ -646,32 +733,50 @@ class CsvPath(CsvPathPublic, ErrorCollector, Printer):  # pylint: disable=R0902,
                     self.metadata["print-mode"],
                 )
 
-    def parse_named_path(self, name, disposably=False):
-        """disposably is True when a Matcher is needed for some purpose other than
-        the run we were created to do. could be that a match component wanted a
-        parsed csvpath for its own purposes. import() uses this method.
-
-        when True, we create and return the Matcher, but then forget it ever existed.
-
-        also note: the path must have a name or full filename. $[*] is not enough.
-        """
+    def _pick_named_path(self, name, *, specific=None) -> str:
         if not self.csvpaths:
             raise CsvPathsException("No CsvPaths object available")
         np = self.csvpaths.paths_manager.get_named_paths(name)
         if not np:
-            raise CsvPathsException(f"Named paths {name} not found")
+            raise CsvPathsException(f"Named-paths '{name}' not found")
         if len(np) == 0:
-            raise CsvPathsException(f"Named paths {name} has no csvpaths")
-        if len(np) > 1:
+            raise CsvPathsException(f"Named-paths '{name}' has no csvpaths")
+        if len(np) == 1:
+            return np[0]
+        if specific is None:
             self.logger.warning(
-                "parse_named_path %s has %s csvpaths. Parsing just the first one.",
+                "Parse_named_path %s has %s csvpaths. Using just the first one.",
                 name,
                 len(np),
             )
-        path = np[0]
-        path = MetadataParser(self).extract_metadata(instance=self, csvpath=path)
-        path = self._update_file_path(path)
-        dis = self.parse(path, disposably=disposably)
+            return np[0]
+        for p in np:
+            # this ends up being redundant to the caller. we do it 1x so it's not
+            # a big lift and is consistent.
+            c = CsvPath()
+            MetadataParser(c).extract_metadata(instance=c, csvpath=p)
+            if c.identity == specific:
+                return p
+        self.logger.error(
+            "Cannot find csvpath identified as %s in named-paths %s", specific, name
+        )
+        raise ParsingException(f"Cannot find path '{specific}' in named-paths '{name}'")
+
+    def parse_named_path(self, name, *, disposably=False, specific=None):
+        """disposably is True when a Matcher is needed for some purpose other than
+        the run we were created to do. could be that a match component wanted a
+        parsed csvpath for its own purposes. import() uses this method.
+        when True, we create and return the Matcher, but then forget it ever existed.
+        also note: the path must have a name or full filename. $[*] is not enough.
+        """
+        if not self.csvpaths:
+            raise CsvPathsException("No CsvPaths object available")
+
+        path = self._pick_named_path(name, specific=specific)
+        c = CsvPath()
+        path = MetadataParser(c).extract_metadata(instance=c, csvpath=path)
+        path = c._update_file_path(path)
+        dis = c.parse(path, disposably=disposably)
         if disposably is True:
             return dis
         return None
@@ -753,6 +858,7 @@ class CsvPath(CsvPathPublic, ErrorCollector, Printer):  # pylint: disable=R0902,
     def __str__(self):
         return f"""
             path: {self.scanner.path if self.scanner else None}
+            identity: {self.identity}
             parsers: [scanner=Ply, matcher=Lark, print=Lark]
             from_line: {self.scanner.from_line if self.scanner else None}
             to_line: {self.scanner.to_line if self.scanner else None}
@@ -852,25 +958,30 @@ class CsvPath(CsvPathPublic, ErrorCollector, Printer):  # pylint: disable=R0902,
         the csvpath. collect() and fast_forward() call next() behind the scenes.
         """
         start = time.time()
-        for line in self._next_line():
-            b = self._consider_line(line)
-            if b:
-                line = self.limit_collection(line)
-                if line is None:
-                    msg = "Line cannot be None"
-                    self.logger.error(msg)
-                    raise MatchException(msg)
-                if len(line) == 0:
-                    msg = "Line cannot be len() == 0"
-                    self.logger.error(msg)
-                    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
+        if self.run_mode is True:
+            for line in self._next_line():
+                b = self._consider_line(line)
+                if b:
+                    line = self.limit_collection(line)
+                    if line is None:
+                        msg = "Line cannot be None"
+                        self.logger.error(msg)
+                        raise MatchException(msg)
+                    if len(line) == 0:
+                        msg = "Line cannot be len() == 0"
+                        self.logger.error(msg)
+                        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
+        else:
+            self.logger.warning(
+                "Csvpath identified as {self.identity} is disabled by run-mode:no-run"
+            )
         self.finalize()
         # moving to finalize
         # self._freeze_path = True

{csvpath-0.0.484 → csvpath-0.0.485}/csvpath/csvpaths.py

@@ -206,9 +206,11 @@ class CsvPaths(CsvPathsPublic, CsvPathsCoordinator, ErrorCollector):
         self.results_manager.clean_named_results(paths)
 
     def _validate_paths_and_file(self, *, pathsname, filename) -> None:
-        if pathsname not in self.paths_manager.named_paths:  # pragma: no cover
+        if not self.paths_manager.has_named_paths(pathsname):  # pragma: no cover
             keys = list(self.paths_manager.named_paths.keys())
-            raise InputException(f"Pathsname must be a named set of paths in {keys}")
+            raise InputException(
+                f"Pathsname '{pathsname}' must be a named set of paths in {keys}"
+            )
         if filename not in self.file_manager.named_files:  # pragma: no cover
             keys = self.file_manager.named_files.keys()
             raise InputException(f"Filename must be a named file in {keys}")

{csvpath-0.0.484 → csvpath-0.0.485}/csvpath/managers/csvpaths_manager.py

@@ -7,6 +7,9 @@ from abc import ABC, abstractmethod
 from ..util.exceptions import InputException
 from ..util.error import ErrorHandler
 
+from csvpath import CsvPath
+from csvpath.util.metadata_parser import MetadataParser
+
 
 class CsvPathsManager(ABC):
     """holds paths (the path itself, not a file name or reference) in a named set.
@@ -169,10 +172,33 @@ class PathsManager(CsvPathsManager):  # pylint: disable=C0115, C0116
     # files_manager and let csvpaths call the shots.
     #
     def get_named_paths(self, name: str) -> List[str]:
-        if name in self.named_paths:
-            return self.named_paths[name]
-        return None
-        # raise InputException("{name} not found")
+        ret = None
+        p2 = self._paths_name_path(name)
+        if p2[1] is None and p2[0] in self.named_paths:
+            ret = self.named_paths[p2[0]]
+        elif p2[1] is not None:
+            ret = self._find_one(p2)
+        return ret
+
+    def _paths_name_path(self, pathsname) -> tuple[str, str]:
+        specificpath = None
+        i = pathsname.find("#")
+        if i > 0:
+            specificpath = pathsname[i + 1 :]
+            pathsname = pathsname[0:i]
+        return (pathsname, specificpath)
+
+    def _find_one(self, p2: tuple[str]) -> str:
+        if p2[1] is not None:
+            paths = self.get_named_paths(p2[0])
+            for path in paths:
+                c = CsvPath()
+                MetadataParser(c).extract_metadata(instance=c, csvpath=path)
+                if c.identity == p2[1]:
+                    return [path]
+        raise InputException(
+            f"Path identified as '{p2[1]}' must be in the group identitied as '{p2[0]}'"
+        )
 
     def remove_named_paths(self, name: str) -> None:
         if name in self.named_paths:
@@ -181,7 +207,7 @@ class PathsManager(CsvPathsManager):  # pylint: disable=C0115, C0116
             raise InputException("{name} not found")
 
     def has_named_paths(self, name: str) -> bool:
-        return name in self.named_paths
+        return self.get_named_paths(name)
 
     def number_of_named_paths(self) -> bool:
         return len(self.named_paths)  # pragma: no cover

{csvpath-0.0.484 → csvpath-0.0.485}/csvpath/matching/functions/args.py

@@ -400,9 +400,16 @@ class Args:
             if _m is None:
                 good = True
         if not good:
+            # _ = f" at {self.matchable.my_chain}" if self.matchable else ""
+            # msg = f"{self._csvpath_id()} Incorrectly written{_}. Wrong type or number of args: {_m}."
+            # raise ChildrenException(msg)
+            #
             _ = f" at {self.matchable.my_chain}" if self.matchable else ""
-            msg = f"{self._csvpath_id()} Incorrectly written{_}. Wrong type or number of args: {_m}."
-            raise ChildrenException(msg)
+            msg = f"Incorrectly written{_}. Wrong type or number of args: {_m}."
+            if self._matchable is None:
+                # this should only be testing
+                raise ChildrenException(msg)
+            self._matchable.raiseChildrenException(msg)
         self.validated = True
 
     def matches(self, actuals: List[Any]) -> None:
@@ -451,10 +458,14 @@ class Args:
             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 = f"{self._csvpath_id()} " if self._csvpath_id() else ""
+            # pln = (
+            #    self._csvpath.line_monitor.physical_line_number if self._csvpath else 0
+            # )
+            # 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)
+            #
             ei = ExpressionUtility.get_my_expressions_index(self._matchable)
-            pm = f"{csvpathid}Wrong value in match component {ei} at line {pln}: {pm}"
-            raise ChildrenValidationException(pm)
+            pm = f"Wrong value in match component {ei}: {pm}"
+            self._matchable.raiseChildrenException(pm)

{csvpath-0.0.484 → csvpath-0.0.485}/csvpath/matching/functions/boolean/any.py

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

{csvpath-0.0.484 → csvpath-0.0.485}/csvpath/matching/functions/boolean/empty.py

@@ -35,11 +35,11 @@ class Empty(MatchDecider):
         for s in sibs:
             # both structure / children exceptions
             if isinstance(s, Headers) and len(sibs) > 1:
-                raise ChildrenException(
+                self.raiseChildrenException(
                     "If empty() has a headers() argument it can only have 1 argument"
                 )
             if isinstance(s, Term):
-                raise ChildrenException(
+                self.raiseChildrenException(
                     "empty() arguments cannot include terms"
                 )  # pragma: no cover
 

{csvpath-0.0.484 → csvpath-0.0.485}/csvpath/matching/functions/function.py

@@ -1,6 +1,7 @@
 # pylint: disable=C0114
 import traceback
 import signal
+import time
 from typing import Any
 from ..productions.matchable import Matchable
 from ..util.exceptions import ChildrenException
@@ -39,7 +40,14 @@ class Function(Matchable):
         if not skip:
             skip = []
         if self in skip:  # pragma: no cover
-            return self._noop_value()
+            ret = self._noop_value()
+            self.valuing().result(ret).because("skip")
+            return ret
+        #
+        # experiment -- timing
+        #
+        startval = time.perf_counter_ns()
+        # exp end
         if self.do_frozen():
             # doing frozen means not doing anything else. this is the
             # inverse of onmatch and other qualifiers. but it makes sense
@@ -80,17 +88,29 @@ class Function(Matchable):
         # Term and Header, but maybe not for Function?
         if isinstance(self.value, str):
             self.value = self.value.strip()
+        #
+        # experiment - timing
+        #
+        endval = time.perf_counter_ns()
+        t = (endval - startval) / 1000000
+        self.matcher.csvpath._up_function_time_value(self.__class__, t)
+        #
+        # exp end
+        #
         return self.value
 
     def matches(self, *, skip=None) -> bool:
         if not skip:
             skip = []
         if self in skip:  # pragma: no cover
-            return self.default_match()
+            ret = self.default_match()
+            self.matching().result(ret).because("skip")
+            return ret
         #
-        # experiment: catch all exceptions within here vvvv and have the expression handle
-        # them at the end of the line.
+        # experiment -- timing
         #
+        startmatch = time.perf_counter_ns()
+        # exp end
         try:
             #
             #
@@ -101,7 +121,9 @@ class Function(Matchable):
                 # and we're not talking about a qualifier, in any case. the
                 # csvpath writer doesn't know anything about this.
                 self.matcher.csvpath.logger.debug("We're frozen in %s", self)
-                return self._noop_value()
+                ret = self._noop_value()
+                self.matching().result(ret).because("frozen")
+                return ret
             if self.match is None:
                 if self.do_onmatch():
                     #
@@ -136,9 +158,9 @@ class Function(Matchable):
                         #
                         sibs = self.sibling_values(skip=skip)
                         if Matchable.FAILED_VALUE in sibs:
-                            pln = self.matcher.csvpath.line_monitor.physical_line_number
-                            raise ChildrenException(
-                                f"Line {pln}: Cannot continue with {self.my_chain} due to an invalid child"
+                            # pln = self.matcher.csvpath.line_monitor.physical_line_number
+                            self.raiseChildrenException(
+                                f"Cannot continue with {self.my_chain} due to an invalid child"
                             )
                         #
                         # ready to run the match!
@@ -178,16 +200,27 @@ class Function(Matchable):
                         self.matcher.csvpath.logger.debug(
                             "Function.matches _decide_match returned %s", self.match
                         )
+                        self.matching().result(self.match)
                 else:
                     self.match = self.default_match()
                     self.matcher.csvpath.logger.debug(
                         f"@{self}: appling default match, {self.match}, because !do_onmatch"
                     )
+                    self.matching().result(self.match).because("onmatch")
         except Exception as e:
             e.trace = traceback.format_exc()
             e.source = self
             e.json = self.to_json()
             self.my_expression.handle_error(e)
+        #
+        # experiment - timing
+        #
+        endmatch = time.perf_counter_ns()
+        t = (endmatch - startmatch) / 1000000
+        self.matcher.csvpath._up_function_time_match(self.__class__, t)
+        #
+        # exp end
+        #
         return self.match
 
     def _produce_value(self, skip=None) -> None:

{csvpath-0.0.484 → csvpath-0.0.485}/csvpath/matching/functions/lines/first_line.py

@@ -17,12 +17,12 @@ class FirstLine(MatchDecider):
         if len(self.children) == 1 and isinstance(self.children[0], Equality):
             if not self.children[0].op == "=":
                 # correct as structure / children exception
-                raise ChildrenException(
+                self.raiseChildrenException(
                     "Child can only be either a function or a variable assignment"
                 )
         if self.name not in ["firstmatch", "firstscan", "firstline"]:
             # correct as structure / children exception
-            raise ChildrenException(f"Unknown function name: {self.name}")
+            self.raiseChildrenException(f"Unknown function name: {self.name}")
         super().check_valid()
 
     def _produce_value(self, skip=None) -> None:

{csvpath-0.0.484 → csvpath-0.0.485}/csvpath/matching/functions/math/sum.py

@@ -12,7 +12,7 @@ class Sum(ValueProducer):
     def check_valid(self) -> None:
         self.args = Args(matchable=self)
         a = self.args.argset(1)
-        a.arg(types=[Variable, Function, Term, Header], actuals=[int])
+        a.arg(types=[Variable, Function, Term, Header], actuals=[int, float])
         self.args.validate(self.siblings())
         super().check_valid()
 

{csvpath-0.0.484 → csvpath-0.0.485}/csvpath/matching/functions/misc/importf.py

@@ -1,6 +1,6 @@
 # pylint: disable=C0114
 from typing import Any
-from csvpath.matching.productions import Term
+from csvpath.matching.productions import Term, Reference
 from csvpath.matching.util.exceptions import MatchComponentException
 from csvpath.matching.util.expression_utility import ExpressionUtility
 from csvpath.matching.util.expression_encoder import ExpressionEncoder
@@ -18,7 +18,7 @@ class Import(SideEffect):
     def check_valid(self) -> None:
         self.args = Args(matchable=self)
         a = self.args.argset(1)
-        a.arg(types=[Term], actuals=[str])
+        a.arg(types=[Term, Reference], actuals=[str])
         self.args.validate(self.siblings())
         super().check_valid()
         #
@@ -43,13 +43,20 @@ class Import(SideEffect):
             if name is None:
                 raise MatchComponentException("Name of import csvpath cannot be None")
 
+            specific = None
+            if name.find("#") > -1:
+                specific = name[name.find("#") + 1 :]
+                name = name[0 : name.find("#")]
+
             self.matcher.csvpath.logger.info("Starting import from %s", name)
 
             e = ExpressionUtility.get_my_expression(self)
             if e is None:
                 raise MatchComponentException("Cannot find my expression: {self}")
 
-            amatcher = self.matcher.csvpath.parse_named_path(name=name, disposably=True)
+            amatcher = self.matcher.csvpath.parse_named_path(
+                name=name, disposably=True, specific=specific
+            )
             if (
                 amatcher is None
                 or not amatcher.expressions

{csvpath-0.0.484 → csvpath-0.0.485}/csvpath/matching/functions/stats/percent.py

@@ -21,7 +21,7 @@ class Percent(ValueProducer):
         if which not in ["scan", "match", "line"]:
             # correct structure / children exception. we could probably do this
             # in check_validate since we're requiring a Term, but this is fine.
-            raise ChildrenException(
+            self.raiseChildrenException(
                 "percent() argument must be scan, match, or line"
             )  # pragma: no cover
         if which == "line":

{csvpath-0.0.484 → csvpath-0.0.485}/csvpath/matching/functions/strings/regex.py

@@ -57,7 +57,7 @@ class Regex(MatchDecider):
             return theregex, thevalue, group
         else:
             # correct structure / children exception
-            raise ChildrenException("No regular expression available")
+            self.raiseChildrenException("No regular expression available")
 
     def _produce_value(self, skip=None) -> None:
         child = self.children[0]