csvpath 0.0.482__tar.gz → 0.0.484__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: csvpath
-Version: 0.0.482
+Version: 0.0.484
 Summary: A declarative language for data extraction and validation of CSV files
 Author: David Kershaw
 Author-email: dk107dk@hotmail.com
@@ -26,6 +26,7 @@ Requires-Dist: jinja2 (>=3.1.4,<4.0.0)
 Requires-Dist: lark (>=1.2.2,<2.0.0)
 Requires-Dist: metaphone (>=0.6,<0.7)
 Requires-Dist: ply (>=3.11,<4.0)
+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
@@ -48,7 +49,6 @@ And do it all in an automation-friendly way.
 Though much simpler, it is inspired by:
 - XPath. CsvPath is to CSV files like XPath is to XML files.
 - Validation of XML using <a href='https://schematron.com/'>Schematron rules</a>
-- The way CSS selectors pick out HTML structures
 
 CsvPath is intended to fit with other DataOps and data quality tools. Files are streamed. The interface is simple. New functions are easy to create.
 

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

@@ -14,7 +14,6 @@ And do it all in an automation-friendly way.
 Though much simpler, it is inspired by:
 - XPath. CsvPath is to CSV files like XPath is to XML files.
 - Validation of XML using <a href='https://schematron.com/'>Schematron rules</a>
-- The way CSS selectors pick out HTML structures
 
 CsvPath is intended to fit with other DataOps and data quality tools. Files are streamed. The interface is simple. New functions are easy to create.
 

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

@@ -14,7 +14,7 @@ from csvpath.util.log_utility import LogUtility
 from .matching.matcher import Matcher
 from .scanning.scanner import Scanner
 from .util.metadata_parser import MetadataParser
-from .util.error import Error, ErrorCollector
+from .util.error import Error, ErrorCollector, ErrorCommsManager
 from .util.printer import StdOutPrinter
 from .util.line_counter import LineCounter
 from .util.exceptions import VariableException, InputException, ParsingException
@@ -26,6 +26,7 @@ from .util.exceptions import (
 )
 from .matching.util.exceptions import MatchException
 from csvpath.util.printer import Printer
+from csvpath.util.file_readers import CsvDataFileReader
 
 
 class CsvPathPublic(ABC):
@@ -262,6 +263,10 @@ class CsvPath(CsvPathPublic, ErrorCollector, Printer):  # pylint: disable=R0902,
         #
         self.logger = LogUtility.logger(self)
         self.logger.info("initialized CsvPath")
+        self._ecoms = ErrorCommsManager(csvpath=self)
+
+    def do_i_raise(self) -> bool:
+        return self._ecoms.do_i_raise()
 
     @property
     def advance_count(self) -> int:  # pragma: no cover
@@ -569,7 +574,7 @@ class CsvPath(CsvPathPublic, ErrorCollector, Printer):  # pylint: disable=R0902,
         #
         # settings:
         #   - logic-mode: AND | OR
-        #   - match-mode: matches | no-matches
+        #   - return-mode: matches | no-matches
         #   - print-mode: default | no-default
         #   - validation-mode: (no-)print | log | (no-)raise | quiet | (no-)match
         #
@@ -606,15 +611,15 @@ class CsvPath(CsvPathPublic, ErrorCollector, Printer):  # pylint: disable=R0902,
                 )
 
     def update_match_mode_if(self) -> None:
-        if "match-mode" in self.metadata:
-            if f"{self.metadata['match-mode']}".strip() == "matches":
+        if "return-mode" in self.metadata:
+            if f"{self.metadata['return-mode']}".strip() == "matches":
                 self.collect_when_not_matched = False
-            elif f"{self.metadata['match-mode']}".strip() == "no-matches":
+            elif f"{self.metadata['return-mode']}".strip() == "no-matches":
                 self.collect_when_not_matched = True
             else:
                 self.logger.warning(
-                    "Incorrect metadata field value 'match-mode': %s",
-                    self.metadata["match-mode"],
+                    "Incorrect metadata field value 'return-mode': %s",
+                    self.metadata["return-mode"],
                 )
 
     def update_print_mode_if(self) -> None:
@@ -891,13 +896,19 @@ class CsvPath(CsvPathPublic, ErrorCollector, Printer):  # pylint: disable=R0902,
         #
         if self.scanner.filename is None:
             raise FileException("There is no filename")
+        """
         with open(self.scanner.filename, "r", encoding="utf-8") as file:
             reader = csv.reader(
                 file, delimiter=self.delimiter, quotechar=self.quotechar
             )
             for line in reader:
-                self.track_line(line=line)
-                yield line
+        """
+        reader = CsvDataFileReader(
+            self.scanner.filename, delimiter=self.delimiter, quotechar=self.quotechar
+        )
+        for line in reader.next():
+            self.track_line(line=line)
+            yield line
         self.finalize()
 
     """

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

@@ -273,14 +273,14 @@ class CsvPaths(CsvPathsPublic, CsvPathsCoordinator, ErrorCollector):
         self.logger.info("Cleaning out any %s and %s results", filename, pathsname)
         self.clean(paths=pathsname)
         self.logger.info(
-            "Beginning fast_forward_paths %s with %s paths against file %s",
+            "Beginning FF %s with %s paths against file %s. No match results will be held.",
             pathsname,
             len(paths),
             filename,
         )
         for i, path in enumerate(paths):
             csvpath = self.csvpath()
-            self.logger.info("Beginning CsvPath instance: %s", csvpath)
+            self.logger.debug("Beginning to FF CsvPath instance: %s", csvpath)
             result = Result(csvpath=csvpath, file_name=filename, paths_name=pathsname)
             try:
                 self.results_manager.add_named_result(result)
@@ -439,6 +439,7 @@ class CsvPaths(CsvPathsPublic, CsvPathsCoordinator, ErrorCollector):
         # but we'll do it for consistency.
         #
         self.logger.info("Beginning next_by_line with %s paths", len(csvpath_objects))
+        """
         with open(fn, "r", encoding="utf-8") as file:
             reader = csv.reader(
                 file, delimiter=self.delimiter, quotechar=self.quotechar
@@ -446,105 +447,110 @@ class CsvPaths(CsvPathsPublic, CsvPathsCoordinator, ErrorCollector):
             #
             # re: R1702 -- totally agreed! deferring.
             #
-            stopped_count: List[int] = []
-            for line in reader:  # pylint: disable=R1702
-                # question to self: should this default be in a central place
-                # so that we can switch to OR, in part by changing the default?
-                keep = if_all_agree
-                self._skip_all = False
-                self._advance_all = 0
-                try:
-                    # p is a (CsvPath, List[List[str]]) where the second item is
-                    # the line-by-line results of the first item's matching
-                    for p in csvpath_objects:
-                        self.current_matcher = p[0]
-                        if self._fail_all:
-                            self.logger.warning(
-                                "Fail-all set. Setting CsvPath is_valid to False."
-                            )
-                            self.current_matcher.is_valid = False
-                        if self._stop_all:
-                            self.logger.warning("Stop-all set. Shutting down run.")
-                            self.current_matcher.stopped = True
-                            continue
-                        if self._skip_all:
-                            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:
-                            logtxt = "Advance-all set. Setting advance. "
-                            logtxt = f"{logtxt}CsvPath and its Matcher will handle the advancing."
-                            self.logger.info(logtxt)
-                            #
-                            # 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
-
+        """
+        reader = FileManager.get_reader(
+            fn, delimiter=self.delimiter, quotechar=self.quotechar
+        )
+        stopped_count: List[int] = []
+        for line in reader.next():
+            # for line in reader:  # pylint: disable=R1702
+            # question to self: should this default be in a central place
+            # so that we can switch to OR, in part by changing the default?
+            keep = if_all_agree
+            self._skip_all = False
+            self._advance_all = 0
+            try:
+                # p is a (CsvPath, List[List[str]]) where the second item is
+                # the line-by-line results of the first item's matching
+                for p in csvpath_objects:
+                    self.current_matcher = p[0]
+                    if self._fail_all:
+                        self.logger.warning(
+                            "Fail-all set. Setting CsvPath is_valid to False."
+                        )
+                        self.current_matcher.is_valid = False
+                    if self._stop_all:
+                        self.logger.warning("Stop-all set. Shutting down run.")
+                        self.current_matcher.stopped = True
+                        continue
+                    if self._skip_all:
+                        self.logger.warning("Skip-all set. Continuing to next.")
                         #
-                        # allowing the match to happen regardless of keep
-                        # because we may want side-effects or to have different
-                        # results in different named-results, as well as the
-                        # union
+                        # all following CsvPaths must have their
+                        # line_monitors incremented
                         #
-                        self.logger.debug(
-                            "considering line with csvpath identified as: %s",
-                            self.current_matcher.identity,
-                        )
-                        matched = False
                         self.current_matcher.track_line(line)
+                        continue
+                    if self._advance_all > 0:
+                        logtxt = "Advance-all set. Setting advance. "
+                        logtxt = f"{logtxt}CsvPath and its Matcher will handle the advancing."
+                        self.logger.info(logtxt)
                         #
-                        # re: W0212: treating _consider_line something like package private
+                        # 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.
                         #
-                        matched = (
-                            self.current_matcher._consider_line(  # pylint:disable=W0212
-                                line
-                            )
-                        )
-                        if self.current_matcher.stopped:
-                            stopped_count.append(1)
-                        if if_all_agree:
-                            keep = keep and matched
-                        else:
-                            keep = keep or matched
+                        a = self.current_matcher.advance_count
+                        if self._advance_all > a:
+                            self.current_matcher.advance_count = self._advance_all
                         #
-                        # not doing continue if we have if_all_agree and not keep as we
-                        # used to do allows individual results to have lines that in
-                        # aggregate we do not keep.
+                        # 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 matched and collect:
-                            line = self.current_matcher.limit_collection(line)
-                            p[1].append(line)
-                except Exception as ex:  # pylint: disable=W0718
-                    ex.trace = traceback.format_exc()
-                    ex.source = self
-                    ErrorHandler(
-                        csvpaths=self, error_collector=self.current_matcher
-                    ).handle_error(ex)
-                # we yield even if we stopped in this iteration.
-                # caller needs to see what we stopped on.
-                #
-                # ! we only yield if keep is True
-                #
-                if keep:
-                    yield line
-                if sum(stopped_count) == len(csvpath_objects):
-                    break
+                    if self.current_matcher.stopped:  # pylint: disable=R1724
+                        continue
+
+                    #
+                    # allowing the match to happen regardless of keep
+                    # because we may want side-effects or to have different
+                    # results in different named-results, as well as the
+                    # union
+                    #
+                    self.logger.debug(
+                        "considering line with csvpath identified as: %s",
+                        self.current_matcher.identity,
+                    )
+                    matched = False
+                    self.current_matcher.track_line(line)
+                    #
+                    # re: W0212: treating _consider_line something like package private
+                    #
+                    matched = (
+                        self.current_matcher._consider_line(  # pylint:disable=W0212
+                            line
+                        )
+                    )
+                    if self.current_matcher.stopped:
+                        stopped_count.append(1)
+                    if if_all_agree:
+                        keep = keep and matched
+                    else:
+                        keep = keep or matched
+                    #
+                    # not doing continue if we have if_all_agree and not keep as we
+                    # used to do allows individual results to have lines that in
+                    # aggregate we do not keep.
+                    #
+                    if matched and collect:
+                        line = self.current_matcher.limit_collection(line)
+                        p[1].append(line)
+            except Exception as ex:  # pylint: disable=W0718
+                ex.trace = traceback.format_exc()
+                ex.source = self
+                ErrorHandler(
+                    csvpaths=self, error_collector=self.current_matcher
+                ).handle_error(ex)
+            # we yield even if we stopped in this iteration.
+            # caller needs to see what we stopped on.
+            #
+            # ! we only yield if keep is True
+            #
+            if keep:
+                yield line
+            if sum(stopped_count) == len(csvpath_objects):
+                break
         self.clear_run_coordination()
 
     def _load_csvpath_objects(

{csvpath-0.0.482 → csvpath-0.0.484}/csvpath/managers/file_manager.py

@@ -3,13 +3,14 @@ import os
 import json
 import csv
 import hashlib
+from abc import ABC, abstractmethod
 from json import JSONDecodeError
 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
+from ..util.file_readers import CsvDataFileReader
 
 
 class CsvPathsFileManager(ABC):
@@ -53,7 +54,7 @@ class CsvPathsFileManager(ABC):
 
 
 class FileManager(CsvPathsFileManager):  # pylint: disable=C0115
-    def __init__(self, *, named_files: Dict[str, str] = None, csvpaths):
+    def __init__(self, *, named_files: Dict[str, str] = None, csvpaths=None):
         if named_files is None:
             named_files = {}
         self.named_files: Dict[str, str] = named_files
@@ -142,6 +143,14 @@ class FileManager(CsvPathsFileManager):  # pylint: disable=C0115
             return None
         return self.named_files[name]
 
+    def get_named_file_reader(self, name: str) -> CsvDataFileReader:
+        path = self.get_named_file(name)
+        return FileManager.get_reader(path)
+
+    @classmethod
+    def get_reader(cls, path: str, delimiter=None, quotechar=None) -> CsvDataFileReader:
+        return CsvDataFileReader(path, delimiter=delimiter, quotechar=quotechar)
+
     def remove_named_file(self, name: str) -> None:
         if name in self.named_files:
             del self.named_files[name]

{csvpath-0.0.482 → csvpath-0.0.484}/csvpath/managers/result.py

@@ -163,14 +163,22 @@ class Result(ErrorCollector, Printer):  # pylint: disable=R0902
         return i
 
     def __str__(self) -> str:
+        lastline = 0
+        endline = -1
+        try:
+            # if we haven't started yet -- common situation -- we may blow up.
+            lastline = self.csvpath.line_monitor.physical_line_number
+            endline = self.csvpath.line_monitor.physical_end_line_number
+        except Exception:
+            pass
         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};
                    valid:{self.csvpath.is_valid};
                    stopped:{self.csvpath.stopped};
-                   last line processed:{self.csvpath.line_monitor.physical_line_number};
-                   total file lines:{self.csvpath.line_monitor.physical_end_line_number};
+                   last line processed:{lastline};
+                   total file lines:{endline};
                    matches:{self.csvpath.match_count};
                    lines captured:{len(self.lines) if self.lines else 0};
                    print statements:{self.print_statements_count()};

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

@@ -16,9 +16,12 @@ from csvpath.util.config_exception import ConfigurationException
 
 
 class Arg:
-    def __init__(self, *, types: list[Type] = None, actuals: list[Type] = None):
+    def __init__(
+        self, *, name: str = None, types: list[Type] = None, actuals: list[Type] = None
+    ):
         self.is_noneable = False
         self._types = None
+        self._name = name
         self._x_actuals = None
         self.types: list[Type] = types or [None]
         self.actuals: list[Type] = actuals or []
@@ -100,8 +103,10 @@ class ArgSet:
     # setup time
     # ----------------------------
 
-    def arg(self, *, types: list[Type] = None, actuals: list[Type] = None) -> Arg:
-        arg = Arg(types=types, actuals=actuals)
+    def arg(
+        self, *, name: str = None, types: list[Type] = None, actuals: list[Type] = None
+    ) -> Arg:
+        arg = Arg(name=name, types=types, actuals=actuals)
         self._args.append(arg)
         if len(self._args) > self.max_length and self.max_length != -1:
             self.max_length = len(self._args)
@@ -194,16 +199,17 @@ class ArgSet:
             self._args = args
             self.max_length = len(self._args)
 
-    def validate_structure(self, siblings: List[Matchable]) -> None:
+    def validate_structure(self, siblings: List[Matchable]) -> None | str:
         b = self._validate_length(siblings)
         if b is False:
-            return False
+            return "incorrect number of args"
         self._pad_or_shrink(siblings)
         for i, s in enumerate(siblings):
             t = tuple(self._args[i].types)
             if not isinstance(s, t):
-                return False
-        return True
+                ii = i + 1
+                return f"type mismatch at arg {ii}"
+        return None
 
     # ----------------------------
     # match actuals line-by-line
@@ -390,11 +396,12 @@ class Args:
         #
         good = False
         for aset in self._argsets:
-            if aset.validate_structure(siblings):
+            _m = aset.validate_structure(siblings)
+            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."
+            msg = f"{self._csvpath_id()} Incorrectly written{_}. Wrong type or number of args: {_m}."
             raise ChildrenException(msg)
         self.validated = True
 

{csvpath-0.0.482 → csvpath-0.0.484}/csvpath/matching/functions/boolean/all.py

@@ -19,7 +19,9 @@ class All(MatchDecider):
         self.args = Args(matchable=self)
         self.args.argset(0)
         self.args.argset(1).arg(types=[None, Variables, Headers], actuals=[])
-        self.args.argset().arg(types=[None, Function, Variable, Header], actuals=[])
+        self.args.argset().arg(
+            types=[None, Function, Variable, Header], actuals=[None, Any]
+        )
         self.args.validate(self.siblings())
         super().check_valid()
 

{csvpath-0.0.482 → csvpath-0.0.484}/csvpath/matching/functions/boolean/andf.py

@@ -2,7 +2,7 @@
 
 from typing import Any
 from ..function_focus import MatchDecider
-from csvpath.matching.productions import Term, Variable, Header, Reference, Equality
+from csvpath.matching.productions import Matchable
 from ..function import Function
 from ..args import Args
 
@@ -15,12 +15,8 @@ class And(MatchDecider):
     def check_valid(self) -> None:  # pragma: no cover
         self.args = Args(matchable=self)
         a = self.args.argset()
-        a.arg(
-            types=[Term, Variable, Header, Function, Reference, Equality], actuals=[Any]
-        )
-        a.arg(
-            types=[Term, Variable, Header, Function, Reference, Equality], actuals=[Any]
-        )
+        a.arg(types=[Matchable], actuals=[None, Any])
+        a.arg(types=[Matchable], actuals=[None, Any])
         self.args.validate(self.siblings_or_equality())
         super().check_valid()
 

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

@@ -24,11 +24,11 @@ class Any(MatchDecider):
         a = self.args.argset(0)
 
         a = self.args.argset(2)
-        a.arg(types=[Variables, Headers], actuals=[Any])
-        a.arg(types=[typing.Any], actuals=[typing.Any])
+        a.arg(types=[Variables, Headers], actuals=[None, typing.Any])
+        a.arg(types=[typing.Any], actuals=[None, typing.Any])
 
         a = self.args.argset(1)
-        a.arg(types=[typing.Any, Variables, Headers], actuals=[typing.Any])
+        a.arg(types=[typing.Any, Variables, Headers], actuals=[None, typing.Any])
 
         self.args.validate(self.siblings())
         super().check_valid()

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

@@ -33,7 +33,7 @@ class Empty(MatchDecider):
     def _validate(self):
         sibs = self.siblings()
         for s in sibs:
-            # both definitely structure / children exceptions
+            # both structure / children exceptions
             if isinstance(s, Headers) and len(sibs) > 1:
                 raise ChildrenException(
                     "If empty() has a headers() argument it can only have 1 argument"
@@ -73,12 +73,7 @@ class Empty(MatchDecider):
         self.match = ret
 
     def _do_many(self, skip=None):
-        siblings = None
-        if isinstance(self.children[0], Equality):
-            siblings = self.children[0].commas_to_list()
-        else:
-            siblings = self.children[0]
-
+        siblings = self.siblings()
         for s in siblings:
             self._do_one(s)
             if self.match is False:
@@ -87,22 +82,3 @@ class Empty(MatchDecider):
     def _do_one(self, child, skip=None):
         v = child.to_value(skip=skip)
         self.match = ExpressionUtility.is_empty(v)
-
-    """
-    def _is_empty(self, v):
-        ret = True
-        if v is None:
-            ret = True
-        elif f"{v}".strip() == "":
-            ret = True
-        elif isinstance(v, list) or isinstance(v, tuple):
-            for item in v:
-                ret = self._is_empty(item)
-                if not ret:
-                    break
-        elif isinstance(v, dict):
-            ret = len(v) > 0
-        else:
-            ret = False
-        return ret
-    """

{csvpath-0.0.482 → csvpath-0.0.484}/csvpath/matching/functions/boolean/inf.py

@@ -13,8 +13,8 @@ class In(MatchDecider):
     def check_valid(self) -> None:
         self.args = Args(matchable=self)
         a = self.args.argset()
-        a.arg(types=[Term, Variable, Header, Function, Reference], actuals=[Any])
-        a.arg(types=[Term, Variable, Header, Function, Reference], actuals=[Any])
+        a.arg(types=[Term, Variable, Header, Function, Reference], actuals=[None, Any])
+        a.arg(types=[Term, Variable, Header, Function, Reference], actuals=[None, Any])
         self.args.validate(self.siblings())
         super().check_valid()
 

csvpath-0.0.484/csvpath/matching/functions/boolean/orf.py

@@ -0,0 +1,57 @@
+# pylint: disable=C0114
+from typing import Any
+from ..function_focus import MatchDecider
+from csvpath.matching.productions import (
+    Term,
+    Variable,
+    Header,
+    Reference,
+    Equality,
+    Matchable,
+)
+from ..function import Function
+from ..args import Args
+
+
+class Or(MatchDecider):
+    """does a logical OR of match components"""
+
+    def __init__(self, matcher: Any, name: str, child: Matchable = None) -> None:
+        super().__init__(matcher, name=name, child=child)
+        self.hold = []
+
+    def reset(self) -> None:
+        self.hold = []
+        super().reset()
+
+    def check_valid(self) -> None:
+        self.args = Args(matchable=self)
+        a = self.args.argset()
+        a.arg(types=[Matchable], actuals=[None, Any])
+        a.arg(types=[Matchable], actuals=[None, Any])
+        self.args.validate(self.siblings_or_equality())
+        super().check_valid()
+
+    def raise_if(self, e, *, cause=None) -> None:
+        # not bubbling up until we know we don't have a
+        # match on all options
+        self.hold.append((e, cause))
+
+    def _produce_value(self, skip=None) -> None:
+        self.value = self.matches(skip=skip)
+
+    def _decide_match(self, skip=None) -> None:
+        child = self.children[0]
+        siblings = child.commas_to_list()
+        for sib in siblings:
+            b = sib.matches(skip=skip)
+            if b:
+                self.match = True
+                # if we find a True we succeed and dump any errors
+                self.hold = []
+                return
+        self.match = False
+        # if we fail we progress any errors up the stack
+        for err in self.hold:
+            super().raise_if(err[0], cause=err[1])
+        self.hold = []

{csvpath-0.0.482 → csvpath-0.0.484}/csvpath/matching/functions/counting/count.py

@@ -3,7 +3,7 @@ from typing import Any
 from ..function_focus import ValueProducer
 from ..function import Function
 from ..args import Args
-from csvpath.matching.productions import Equality, Variable, Header, Term
+from csvpath.matching.productions import Matchable
 
 
 class Count(ValueProducer):
@@ -16,10 +16,7 @@ class Count(ValueProducer):
         self.args = Args(matchable=self)
         a = self.args.argset(0)
         a = self.args.argset()
-        a.arg(
-            types=[None, Variable, Function, Header, Term, Equality],
-            actuals=[None, Any],
-        )
+        a.arg(types=[None, Matchable], actuals=[None, Any])
         self.args.validate(self.siblings())
         #
         super().check_valid()  # pylint: disable=W0246