csvpath 0.0.470__tar.gz → 0.0.472__tar.gz

{csvpath-0.0.470 → csvpath-0.0.472}/PKG-INFO

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

{csvpath-0.0.470 → csvpath-0.0.472}/config/config.ini

@@ -17,3 +17,6 @@ log_file_size = 52428800
 
 [config]
 path = config/config.ini
+
+[cache]
+path = cache

{csvpath-0.0.470 → csvpath-0.0.472}/csvpath/csvpath.py

@@ -8,7 +8,7 @@ import hashlib
 from typing import List, Dict, Any
 from collections.abc import Iterator
 from abc import ABC, abstractmethod
-from csvpath.util.config import CsvPathConfig
+from csvpath.util.config import Config
 from csvpath.util.line_monitor import LineMonitor
 from csvpath.util.log_utility import LogUtility
 from .matching.matcher import Matcher
@@ -55,11 +55,7 @@ class CsvPathPublic(ABC):
 
     @abstractmethod
     def advance(self, ff: int = -1) -> None:  # pragma: no cover
-        """Advances the iteration by ff rows. The scanned rows will be
-        considered for match and variables and side effects will happen,
-        but no rows will be returned or stored. -1 means to the end of
-        the file.
-        """
+        """Advances the iteration by ff rows. -1 means to the end of the file."""
 
     @abstractmethod
     def fast_forward(self) -> None:  # pragma: no cover
@@ -175,6 +171,7 @@ class CsvPath(CsvPathPublic, ErrorCollector):  # pylint: disable=R0902, R0904
         #
         self.stopped = False
         self._advance = 0
+
         #
         # set by fail()
         #
@@ -249,6 +246,14 @@ class CsvPath(CsvPathPublic, ErrorCollector):  # pylint: disable=R0902, R0904
         self.logger = LogUtility.logger(self)
         self.logger.info("initialized CsvPath")
 
+    @property
+    def advance_count(self) -> int:  # pragma: no cover
+        return self._advance
+
+    @advance_count.setter
+    def advance_count(self, lines: int) -> None:
+        self._advance = lines
+
     @property
     def headers(self) -> List[str]:
         if self._headers is None:
@@ -311,9 +316,9 @@ class CsvPath(CsvPathPublic, ErrorCollector):  # pylint: disable=R0902, R0904
         return ""
 
     @property
-    def config(self) -> CsvPathConfig:  # pylint: disable=C0116
+    def config(self) -> Config:  # pylint: disable=C0116
         if not self._config:
-            self._config = CsvPathConfig(self)
+            self._config = Config(self)
         return self._config
 
     def has_errors(self) -> bool:  # pylint: disable=C0116
@@ -345,7 +350,7 @@ class CsvPath(CsvPathPublic, ErrorCollector):  # pylint: disable=R0902, R0904
         # here we're just collecting them if collect is
         # selected by our configuration
         #
-        if self._error_collector:
+        if self._error_collector is not None:
             self._error_collector.collect_error(e)
         else:
             if self._errors is None:
@@ -374,8 +379,7 @@ class CsvPath(CsvPathPublic, ErrorCollector):  # pylint: disable=R0902, R0904
     @property
     def collect_when_not_matched(self) -> bool:
         """when this property is True CsvPath returns the lines that do not
-        match the matcher's match components
-        """
+        match the matchers match components"""
         return self._when_not_matched
 
     @collect_when_not_matched.setter
@@ -551,14 +555,6 @@ class CsvPath(CsvPathPublic, ErrorCollector):  # pylint: disable=R0902, R0904
             metadata: {len(self.metadata)}
         """
 
-    @property
-    def advance(self) -> bool:  # pragma: no cover
-        return self._advance
-
-    @advance.setter
-    def advance(self, lines: int) -> None:
-        self._advance = lines
-
     @property
     def is_valid(self) -> bool:  # pragma: no cover
         return self._is_valid
@@ -745,11 +741,11 @@ class CsvPath(CsvPathPublic, ErrorCollector):  # pylint: disable=R0902, R0904
             self.scan_count = self.scan_count + 1
             matches = None
             self._current_match_count = self.match_count
-            if self._advance > 0:
-                self._advance -= 1
+            if self.advance_count > 0:
+                self.advance_count -= 1
                 matches = False
                 self.logger.debug(
-                    "Advancing one line with {self._advance} more skips to go"
+                    "Advancing one line with {self.advance_count} more skips to go"
                 )
             else:
                 self.logger.debug("Starting matching")
@@ -809,9 +805,7 @@ class CsvPath(CsvPathPublic, ErrorCollector):  # pylint: disable=R0902, R0904
         return ls
 
     def advance(self, ff: int = -1) -> None:
-        """Advances the iteration by ff rows. The rows will be seen and
-        variables and side effects will happen.
-        """
+        """Advances the iteration by ff rows. The rows will be seen but not matched."""
         if ff is None:
             raise InputException("Input to advance must not be None")
         if self.line_monitor.physical_end_line_number is None:
@@ -819,14 +813,18 @@ class CsvPath(CsvPathPublic, ErrorCollector):  # pylint: disable=R0902, R0904
                 "The last line number must be known (physical_end_line_number)"
             )
         if ff == -1:
-            self._advance = (
+            a = self.advance_count
+            a = (
                 self.line_monitor.physical_end_line_number
                 - self.line_monitor.physical_line_number
-                - self._advance
+                - a
             )
+            self.advance_count = a
         else:
-            self._advance += ff
-        self._advance = min(self._advance, self.line_monitor.physical_end_line_number)
+            self.advance_count += ff
+        self.advance_count = min(
+            self.advance_count, self.line_monitor.physical_end_line_number
+        )
 
     def get_total_lines(self) -> int:  # pylint: disable=C0116
         if (

{csvpath-0.0.470 → csvpath-0.0.472}/csvpath/csvpaths.py

@@ -6,7 +6,7 @@ from typing import List, Any, Tuple
 import csv
 import traceback
 from .util.error import ErrorHandler, ErrorCollector, Error
-from .util.config import CsvPathConfig
+from .util.config import Config
 from .util.log_utility import LogUtility
 from .util.line_monitor import LineMonitor
 from .util.metadata_parser import MetadataParser
@@ -107,11 +107,11 @@ class CsvPathsCoordinator(ABC):
 
     @abstractmethod
     def skip_all(self) -> None:  # pragma: no cover
-        """Fails every CsvPath instance in a run"""
+        """skips the line for every CsvPath instance in a run"""
 
     @abstractmethod
     def advance_all(self, lines: int) -> None:  # pragma: no cover
-        """Fails every CsvPath instance in a run"""
+        """advances every CsvPath instance in a run"""
 
 
 class CsvPaths(CsvPathsPublic, CsvPathsCoordinator):
@@ -132,7 +132,7 @@ class CsvPaths(CsvPathsPublic, CsvPathsCoordinator):
         self.quotechar = quotechar
         self.skip_blank_lines = skip_blank_lines
         self.current_matcher: CsvPath = None
-        self._config = CsvPathConfig(self)
+        self._config = Config(self)
         self.logger = LogUtility.logger(self)
         self.logger.info("initialized CsvPaths")
         self._errors = []
@@ -183,9 +183,9 @@ class CsvPaths(CsvPathsPublic, CsvPathsCoordinator):
         return len(self._errors) > 0
 
     @property
-    def config(self) -> CsvPathConfig:  # pylint: disable=C0116
+    def config(self) -> Config:  # pylint: disable=C0116
         if not self._config:
-            self._config = CsvPathConfig()  # pragma: no cover
+            self._config = Config()  # pragma: no cover
         return self._config
 
     def clean(self, *, paths) -> None:
@@ -287,7 +287,7 @@ class CsvPaths(CsvPathsPublic, CsvPathsCoordinator):
             "Completed fast_forward_paths %s with %s paths", pathsname, len(paths)
         )
 
-    def next_paths(self, *, pathsname, filename):
+    def next_paths(self, *, pathsname, filename, collect: bool = False):
         """appends the Result for each CsvPath to the end of
         each line it produces. this is so that the caller can easily
         interrogate the CsvPath for its path parts, file, etc."""
@@ -303,13 +303,27 @@ class CsvPaths(CsvPathsPublic, CsvPathsCoordinator):
         self.clean(paths=pathsname)
         self.logger.info("Beginning next_paths with %s paths", len(paths))
         for path in paths:
+            if self._skip_all:
+                skip_err = "Found the skip-all signal set. skip_all() is"
+                skip_err = f"{skip_err} only for breadth-first runs using the"
+                skip_err = f"{skip_err} '_by_line' methods. It has the same"
+                skip_err = f"{skip_err} effect as skip() in a"
+                skip_err = f"{skip_err} serial run like this one."
+                self.logger.error(skip_err)
             if self._stop_all:
-                self.logger.warn("Stop-all set. Shutting down run.")
+                self.logger.warning("Stop-all set. Shutting down run.")
                 break
+            if self._advance_all > 0:
+                advance_err = "Found the advance-all signal set. advance_all() is"
+                advance_err = f"{advance_err} only for breadth-first runs using the"
+                advance_err = f"{advance_err} '_by_line' methods. It has the same"
+                advance_err = f"{advance_err} effect as advance() in a"
+                advance_err = f"{advance_err} serial run like this one."
+                self.logger.error(advance_err)
             csvpath = self.csvpath()
             result = Result(csvpath=csvpath, file_name=filename, paths_name=pathsname)
             if self._fail_all:
-                self.logger.warn(
+                self.logger.warning(
                     "Fail-all set. Failing all remaining CsvPath instances in the run."
                 )
                 csvpath.is_valid = False
@@ -318,6 +332,8 @@ class CsvPaths(CsvPathsPublic, CsvPathsCoordinator):
                 self._load_csvpath(csvpath, path=path, file=file)
                 for line in csvpath.next():
                     line.append(result)
+                    if collect:
+                        result.append(line)
                     yield line
             except Exception as ex:  # pylint: disable=W0718
                 ex.trace = traceback.format_exc()
@@ -387,7 +403,7 @@ class CsvPaths(CsvPathsPublic, CsvPathsCoordinator):
         if_all_agree=False,
         collect_when_not_matched=False,
     ) -> List[Any]:
-        # re: R0912 -- absolutely does have too many branches. will refactor later.
+        # re: R0912 -- absolutely. plan to refactor.
         self.logger.info("Cleaning out any %s and %s results", filename, pathsname)
         self.clean(paths=pathsname)
         fn = self.file_manager.get_named_file(filename)
@@ -435,22 +451,40 @@ class CsvPaths(CsvPathsPublic, CsvPathsCoordinator):
                     for p in csvpath_objects:
                         self.current_matcher = p[0]
                         if self._fail_all:
-                            self.logger.warn(
+                            self.logger.warning(
                                 "Fail-all set. Setting CsvPath is_valid to False."
                             )
                             self.current_matcher.is_valid = False
                         if self._stop_all:
-                            self.logger.warn("Stop-all set. Shutting down run.")
+                            self.logger.warning("Stop-all set. Shutting down run.")
                             self.current_matcher.stopped = True
                             continue
                         if self._skip_all:
-                            self.logger.warn("Skip-all set. Continuing to next.")
+                            self.logger.warning("Skip-all set. Continuing to next.")
+                            #
+                            # all following CsvPaths must have their
+                            # line_monitors incremented
+                            #
+                            self.current_matcher.track_line(line)
                             continue
                         if self._advance_all > 0:
-                            self.logger.warn(
+                            self.logger.info(
                                 "Advance-all set. Setting advance. CsvPath and its Matcher will handle the advancing."
                             )
-                            self.current_matcher.advance = self._advance_all
+                            #
+                            # CsvPath will handle advancing so we don't need to do
+                            # anything, including track_line(line). we just need to
+                            # see if we're setting advance or increasing it.
+                            #
+                            a = self.current_matcher.advance_count
+                            if self._advance_all > a:
+                                self.current_matcher.advance_count = self._advance_all
+                            #
+                            # all following CsvPaths must have their
+                            # advance incremented -- with the advance not being simply
+                            # additive, have to be mindful of any existing advance
+                            # count!
+                            #
                         if self.current_matcher.stopped:  # pylint: disable=R1724
                             continue
 
@@ -497,26 +531,24 @@ class CsvPaths(CsvPathsPublic, CsvPathsCoordinator):
                 # we yield even if we stopped in this iteration.
                 # caller needs to see what we stopped on.
                 #
-                # !!! we only yield if keep is True
+                # ! we only yield if keep is True
                 #
                 if keep:
                     yield line
                 if sum(stopped_count) == len(csvpath_objects):
                     break
-                # note to self: we have the lines in p[1]. we could, optionally, iteratively
-                # move them to the results here. probably a future requirement.
         self.clear_run_coordination()
 
     def _load_csvpath_objects(
         self, *, paths: List[str], named_file: str, collect_when_not_matched=False
-    ) -> List[Tuple[CsvPath, List]]:
+    ):
         csvpath_objects = []
         for path in paths:
             csvpath = self.csvpath()
             csvpath.collect_when_not_matched = collect_when_not_matched
             try:
                 self._load_csvpath(csvpath, path=path, file=named_file)
-                csvpath_objects.append((csvpath, []))
+                csvpath_objects.append([csvpath, []])
             except Exception as ex:  # pylint: disable=W0718
                 ex.trace = traceback.format_exc()
                 ex.source = self
@@ -532,18 +564,21 @@ class CsvPaths(CsvPathsPublic, CsvPathsCoordinator):
         for csvpath in csvpath_objects:
             try:
                 #
-                # lines object is a shared reference between path and results.
                 # Result will set itself into its CsvPath as error collector
                 # printer, etc.
                 #
                 result = Result(
-                    csvpath=csvpath[0], file_name=filename, paths_name=pathsname
+                    csvpath=csvpath[0],
+                    file_name=filename,
+                    paths_name=pathsname,
+                    lines=csvpath[1],
                 )
+                csvpath[1] = result
                 self.results_manager.add_named_result(result)
             except Exception as ex:  # pylint: disable=W0718
                 ex.trace = traceback.format_exc()
                 ex.source = self
                 ErrorHandler(csvpaths=self, error_collector=csvpath).handle_error(ex)
                 #
-                # keep for modelines avoidance
+                # keep this comment for modelines avoidance
                 #

{csvpath-0.0.470 → csvpath-0.0.472}/csvpath/managers/file_manager.py

@@ -1,12 +1,15 @@
 # pylint: disable=C0114
 import os
 import json
+import csv
+import hashlib
 from json import JSONDecodeError
-from typing import Dict, List
+from typing import Dict, List, Tuple
 from abc import ABC, abstractmethod
 from ..util.line_counter import LineCounter
 from ..util.line_monitor import LineMonitor
 from ..util.error import ErrorHandler
+from ..util.cache import Cache
 
 
 class CsvPathsFileManager(ABC):
@@ -56,6 +59,7 @@ class FileManager(CsvPathsFileManager):  # pylint: disable=C0115
         self.named_files: Dict[str, str] = named_files
         self.csvpaths = csvpaths
         self.pathed_lines_and_headers = {}
+        self.cache = Cache(self.csvpaths)
 
     def get_new_line_monitor(self, filename: str) -> LineMonitor:
         if filename not in self.pathed_lines_and_headers:
@@ -70,10 +74,37 @@ class FileManager(CsvPathsFileManager):  # pylint: disable=C0115
         return self.pathed_lines_and_headers[filename][1][:]
 
     def _find_lines_and_headers(self, filename: str) -> None:
-        lc = LineCounter(self.csvpaths)
-        lm, headers = lc.get_lines_and_headers(filename)
+        lm, headers = self._cached_lines_and_headers(filename)
+        if lm is None or headers is None:
+            lc = LineCounter(self.csvpaths)
+            lm, headers = lc.get_lines_and_headers(filename)
+            self._cache_lines_and_headers(filename, lm, headers)
         self.pathed_lines_and_headers[filename] = (lm, headers)
 
+    # ========================================
+    # cache related
+    #
+
+    def _cached_lines_and_headers(self, filename: str) -> Tuple[LineMonitor, List[str]]:
+        lm = LineMonitor()
+        json = self.cache.cached_text(filename, "json")
+        if json is not None and not json.strip() == "":
+            lm.load(json)
+        else:
+            return (None, None)
+        headers = self.cache.cached_text(filename, "csv")
+        return (lm, headers)
+
+    def _cache_lines_and_headers(
+        self, filename, lm: LineMonitor, headers: List[str]
+    ) -> None:
+        jstr = lm.dump()
+        self.cache.cache_text(filename, "json", jstr)
+        self.cache.cache_text(filename, "csv", ",".join(headers))
+
+    #
+    # ========================================
+
     def set_named_files(self, nf: Dict[str, str]) -> None:
         self.named_files = nf
 

{csvpath-0.0.470 → csvpath-0.0.472}/csvpath/managers/result.py

@@ -57,6 +57,10 @@ class Result(ErrorCollector, Printer):  # pylint: disable=R0902
     def file_name(self, file_name: str) -> None:
         self._file_name = file_name
 
+    # ==========================
+    # lines collecting methods
+    #
+
     @property
     def lines(self) -> List[List[Any]]:  # pylint: disable=C0116
         return self._lines
@@ -65,6 +69,18 @@ class Result(ErrorCollector, Printer):  # pylint: disable=R0902
     def lines(self, ls: List[List[Any]]) -> None:
         self._lines = ls
 
+    def append(self, line: List[Any]) -> None:
+        if self._lines is None:
+            self._lines = []
+        self._lines.append(line)
+
+    def __len__(self) -> int:
+        if self._lines is None:
+            self._lines = []
+        return len(self._lines)
+
+    # ==========================
+
     @property
     def csvpath(self) -> CsvPath:  # pylint: disable=C0116
         return self._csvpath
@@ -79,15 +95,18 @@ class Result(ErrorCollector, Printer):  # pylint: disable=R0902
     def errors(self) -> List[Error]:  # pylint: disable=C0116
         return self._errors
 
+    @property
     def errors_count(self) -> int:  # pylint: disable=C0116
         return len(self._errors) if self._errors else 0
 
     def collect_error(self, error: Error) -> None:  # pylint: disable=C0116
         self._errors.append(error)
 
+    @property
     def has_errors(self) -> bool:  # pylint: disable=C0116
-        return len(self.errors) > 0
+        return len(self._errors) > 0
 
+    @property
     def is_valid(self) -> bool:  # pylint: disable=C0116
         if self._csvpath:
             return self._csvpath.is_valid
@@ -140,7 +159,7 @@ class Result(ErrorCollector, Printer):  # pylint: disable=R0902
         return i
 
     def __str__(self) -> str:
-        return f"""CsvPathResult
+        return f"""Result
                    file:{self.csvpath.scanner.filename if self.csvpath.scanner else None};
                    name of paths:{self.paths_name};
                    name of file:{self.file_name};

{csvpath-0.0.470 → csvpath-0.0.472}/csvpath/managers/results_manager.py

@@ -141,7 +141,7 @@ class ResultsManager(CsvPathsResultsManager):  # pylint: disable=C0115
     def is_valid(self, name: str) -> bool:
         results = self.get_named_results(name)
         for r in results:
-            if not r.is_valid():
+            if not r.is_valid:
                 return False
         return True
 

{csvpath-0.0.470 → csvpath-0.0.472}/csvpath/matching/functions/boolean/notf.py

@@ -16,4 +16,3 @@ class Not(MatchDecider):
         m = self.children[0].matches(skip=skip)
         m = not m
         self.match = m
-        # print(f"Not._decide_mat: self.match: {self.match} -> {self}")

{csvpath-0.0.470 → csvpath-0.0.472}/csvpath/matching/functions/counting/increment.py

@@ -66,5 +66,4 @@ class Increment(ValueProducer):
 
     def matches(self, *, skip=None) -> bool:
         self.to_value(skip=skip)
-        print(f"Increment.matches: self.match: {self.match}")
         return self.match

{csvpath-0.0.470 → csvpath-0.0.472}/csvpath/matching/functions/headers/empty_stack.py

@@ -36,14 +36,12 @@ class EmptyStack(ValueProducer):
 
     def _do_some(self, skip=None):
         siblings = self.children[0].commas_to_list()
-        print(f"emmpty_stack: do_some: sibs: {siblings}")
         self.value = []
         for s in siblings:
             v = s.to_value(skip=skip)
             b = ExpressionUtility.is_empty(v)
             if b:
                 self.value.append(s.name)
-                print(f"sib: {s}: {v} = {b}")
 
     def _do_one(self, child, skip=None):
         v = child.to_value(skip=skip)

{csvpath-0.0.470 → csvpath-0.0.472}/csvpath/matching/functions/lines/advance.py

@@ -15,7 +15,7 @@ class Advance(SideEffect):
         v = child.to_value(skip=skip)
         try:
             v = int(v)
-            self.matcher.csvpath.advance(v)
+            self.matcher.csvpath.advance_count = v
         except (TypeError, ValueError) as e:
             raise ChildrenException(
                 f"Advance must contain an int, not {type(v)}"

{csvpath-0.0.470 → csvpath-0.0.472}/csvpath/matching/functions/lines/stop.py

@@ -38,25 +38,6 @@ class Stop(Stopper):
     def _decide_match(self, skip=None) -> None:
         self.match = True
         self._stop_me(skip=skip)
-        """
-        if len(self.children) == 1:
-            b = self.children[0].matches(skip=skip)
-            if b is True:
-                self.matcher.csvpath.stop()
-                pln = self.matcher.csvpath.line_monitor.physical_line_number
-                self.matcher.csvpath.logger.info(
-                    f"stopping at {pln}. contained child matches."
-                )
-                stopped = True
-        else:
-            self.matcher.csvpath.stop()
-            pln = self.matcher.csvpath.line_monitor.physical_line_number
-            self.matcher.csvpath.logger.info(f"stopping at {pln}")
-            stopped = True
-        if stopped and self.name == "fail_and_stop":
-            self.matcher.csvpath.logger.info("setting invalid")
-            self.matcher.csvpath.is_valid = False
-        """
 
 
 class StopAll(Stopper):
@@ -103,30 +84,14 @@ class Skip(Skipper):
     def _decide_match(self, skip=None) -> None:
         if self.do_once():
             self._skip_me(skip=skip)
-            """
-            if len(self.children) == 1:
-                b = self.children[0].matches(skip=skip)
-                if b is True:
-                    self.matcher.skip = True
-                    if self.once:
-                        self._set_has_happened()
-                    pln = self.matcher.csvpath.line_monitor.physical_line_number
-                    self.matcher.csvpath.logger.info(
-                        f"skipping physical line {pln}. contained child matches."
-                    )
-            else:
-                self.matcher.skip = True
-                if self.once:
-                    self._set_has_happened()
-                pln = self.matcher.csvpath.line_monitor.physical_line_number
-                self.matcher.csvpath.logger.info(f"skipping line {pln}")
-            """
         self.match = self.default_match()
 
 
 class SkipAll(Skipper):
     """skips to the next line. tells the CsvPaths instance, if any,
     to skip all the following CsvPath instances as well.
+    Note: skip_all() is only for the parallel/breadth-first methods.
+    for the serial/paths methods skip_all() works the same as skip().
     """
 
     def check_valid(self) -> None:

{csvpath-0.0.470 → csvpath-0.0.472}/csvpath/matching/lark_transformer.py

@@ -31,7 +31,6 @@ class LarkTransformer(Transformer):  # pylint: disable=C0115
     # 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

{csvpath-0.0.470 → csvpath-0.0.472}/csvpath/matching/productions/header.py

@@ -50,7 +50,6 @@ class Header(Matchable):
                 self.value = ExpressionUtility.asbool(ret)
             else:
                 self.value = ret
-        # print(f"header.to_value: self.value: {self.value}<<<")
         return self.value
 
     def matches(self, *, skip=None) -> bool:
@@ -63,5 +62,4 @@ class Header(Matchable):
                 self.match = ExpressionUtility.asbool(v)
             else:
                 self.match = not ExpressionUtility.is_none(v)  # v is not None
-                # print(f"Header.matches: match? {self.match}")
         return self.match

{csvpath-0.0.470 → csvpath-0.0.472}/csvpath/matching/productions/matchable.py

@@ -38,6 +38,7 @@ class Matchable(Qualified):
         return name
 
     def _noop_match(self) -> bool:
+        """deprecated. use self.default_match()"""
         return self.match if self.match is not None else True
 
     def _noop_value(self) -> bool:
@@ -122,5 +123,14 @@ class Matchable(Qualified):
         # with the current parse tree this shouldn't happen
         return None
 
+    def _siblings(self) -> list:
+        if len(self.children) and hasattr(self.children[0], "op"):
+            return self.children[0].commas_to_list()
+        else:
+            self.matcher.csvpath.error(
+                "Cannot get siblings. children[0] is not an Equality"
+            )
+        return None
+
     def default_match(self) -> bool:
         return self.matcher._AND

{csvpath-0.0.470 → csvpath-0.0.472}/csvpath/matching/productions/qualified.py

@@ -259,15 +259,6 @@ class Qualified:
         by adding self to the skip list."""
         es = self.matcher.expressions  # pylint: disable=E1101
         for e in es:
-            #
-            # this fix for 1 test (test_function_last1) is blowing 11 other tests!
-            #
-            # me = ExpressionUtility.get_my_expression(self)
-            # print(f"my expression: me: {me}")
-            # if e[0] == me: # added experiment
-            # print(f"found my expression!")
-            #    continue
-            # print(f"not my expression: {e[0]}")
             m = e[1] is self.default_match() or e[0].matches(
                 skip=[self]
             )  # pylint: disable=E1101

{csvpath-0.0.470 → csvpath-0.0.472}/csvpath/matching/productions/reference.py

@@ -75,9 +75,6 @@ class Reference(Matchable):
                 """
             # else:
             self.match = self.value is not None
-            print(
-                f"\nReference.matches: self.match: {self.match}, self.value: {self.value}\n"
-            )
         return self.match  # pragma: no cover
 
     def to_value(self, *, skip=None) -> Any: