csvpath 0.0.471__tar.gz → 0.0.472__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: csvpath
-Version: 0.0.471
+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.471 → 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.471 → csvpath-0.0.472}/csvpath/util/config.py

@@ -76,7 +76,7 @@ class Config:
     def config_path(self) -> str:
         return self._configpath
 
-    def _get(self, section: str, name: str, quiet: bool = True):
+    def _get(self, section: str, name: str):
         if self._config is None:
             raise ConfigurationException("No config object available")
         try:
@@ -89,10 +89,9 @@ class Config:
                 ret = s
             return ret
         except KeyError:
-            if not quiet:
-                raise ConfigurationException(
-                    f"Check config at {self.config_path} for [{section}][{name}]"
-                )
+            raise ConfigurationException(
+                f"Check config at {self.config_path} for [{section}][{name}]"
+            )
 
     def _create_default_config(self) -> None:
         if not path.exists("config"):
@@ -137,12 +136,12 @@ path =
 
     def _assure_cache_path(self) -> None:
         dirpath = self.cache_dir_path
-        if dirpath is None:
-            dirpath == "cache"
-            self._config.add_section("cache")
-            self._config.set("cache", "path", dirpath)
         if dirpath and not path.exists(dirpath):
             os.makedirs(dirpath)
+        elif not dirpath:
+            raise ConfigurationException(
+                "No cache path available. Check config.ini [cache][path]."
+            )
 
     def _assure_config_file_path(self) -> None:
         if not self._configpath or not os.path.isfile(self._configpath):
@@ -265,11 +264,13 @@ path =
 
     @property
     def cache_dir_path(self) -> str:
-        path = self._get("cache", "path", quiet=True)
-        #
-        # for now we can let this fail silently. if there is no
-        # cache dir we just don't cache.
-        #
+        try:
+            path = self._get("cache", "path")
+        except Exception:
+            print("No cache path in config.ini at [cache][path]. Using 'cache'.")
+            path = "config"
+            self._config.add_section("cache")
+            self._config.set("cache", "path", path)
         return path
 
     @property

{csvpath-0.0.471 → csvpath-0.0.472}/docs/functions/advance.md

@@ -20,7 +20,7 @@ One way to run it looks like this, using dict objects to identify the csvpaths a
 
 ```python
     paths = CsvPaths()
-    paths.files_manager.set_named_files(nf)
+    paths.file_manager.set_named_files(nf)
     paths.paths_manager.set_named_paths(np)
     lines = paths.collect_paths(pathsname="sample", filename="survey")
 ```

csvpath-0.0.472/docs/functions/has_matches.md

@@ -0,0 +1,17 @@
+
+# Has matches
+
+`has_matches()` returns `True` when there have been previous matches. It is a convenience function, since you can achieve the same result with `count()` and other functions; although not quite as simply.
+
+## Examples
+
+    $people.csv[*][
+        ~ Apply three rules to check if a CSV file is invalid ~
+            missing(headers())
+            too_long(#lastname, 30)
+            not.nocontrib( header_name(0, "firstname") ) -> fail()
+            has_matches.nocontrib() -> fail()
+    ]
+
+This csvpath fails a file if any of the other match components match on any line.
+

csvpath-0.0.472/docs/functions/implementing_functions.md

@@ -0,0 +1,107 @@
+
+# How to create a function
+
+You can easily create your own function, register it for use, and use it in your csvpaths.
+
+Functions are descendants of the Function class. Most of the built-ins extend one of:
+- ValueProducer - for functions that mainly generate information
+- MatchDecider - for functions that mainly do a true/false response to information
+- SideEffect - for functions that don't add or consider information in the current line, but rather have some side effect such as printing, setting validity, advancing lines, etc.
+
+These three classes are only indicators. You can extend Function directly.
+
+    from csvpath.matching.functions.function import Function
+    class MyFunction(Function):
+        ...
+
+Function implementations override three methods:
+
+- `_produce_value(self, skip=[])` - produces the value of the function
+- `_decide_match(self, skip=[])` - determines if the function contributes to a row matching the csvpath
+- `check_valid(self)` - raises an exception if the function is configured incorrectly
+
+The first two methods may be called multiple times per row due to checking qualifier constraints, principally `onmatch`, or for other reasons. When a function checks to see if the other csvpath components all match it passes itself in the skip list. The skip list is a list of match components that should not perform their usual calculations if they find themselves in the list. If your function finds itself in the skip list it should immediately return. The return value should be:
+
+- `self.value` for `_produce_value`
+- `self.default_match()` for `matches`
+
+Usually you want to cache the result of calculating `to_value` and `matches`. Two variables are provided for caching. It is important to set them to a non-None value in order to prevent your function running multiple times.
+
+- self.value
+- self.match
+
+## Qualifiers
+
+Qualifiers are available to your function. They are accessed using the methods in the Qualified class. Qualified is an ancestor of Function. The most relevant capabilities are:
+
+- first_non_term_qualifier()
+- qualifiers
+
+The former will get you a non-built-in qualifier. The `qualifiers` property gives you access to all qualifiers.
+
+All match components support the `onmatch` qualifier. All components support the `nocontrib` when they are on the left-hand side of a when/do (`->`) operation.
+
+## Arguments Validation
+
+Validation is an important step that happens before any rows are considered. It allows for structural csvpath problems to be discovered before you start processing files. The validity checks only address the number of children and the type of children. You cannot check types or values ofdata provided by child match components because the match components are not setup yet and there is no data at the time validation happens.
+
+The most common validations are methods available on the `Validation` class. `Validation` is an ancestor class of Function.
+
+
+## Example
+
+A very simple function might look like:
+
+```python
+    class MyFunction(Function):
+        def _produce_value(self, skip=[]) -> None:
+            v = self.calculate_stuff()
+            self.value = v
+
+        def _decide_match(self, skip=[]) -> None:
+            m = self.calculate_stuff()
+            self.match = result
+
+        def check_valid(self) -> None:
+            self.validate_zero_args()
+            # you must call check_valid so that your
+            # function's children are validated.
+            super().check_valid()
+```
+
+When your function's match depends on its value, or its value depends on its match, it needs to call the appropriate method:
+- To get the value, call self.to_value(skip=skip)
+- To check the match, call self.matches(skip=skip)
+
+When your function needs its arguments you can call:
+- self._child_one()
+- self._value_one(skip=skip)
+- self._child_two()
+- self._value_two(skip=skip)
+- self._siblings()
+
+When you need to get a value or a match from a child object you use `to_value()` or `matches()`. Remember to pass the skip list as a named argument "skip".
+
+## Registering
+
+To register your function for use, add it to the FunctionFactory like this:
+
+```python
+    from csvpath.matching.functions.function_factory import FunctionFactory
+    FunctionFactory.add_function(name='iamafunction', function=my_function_instance)
+```
+
+To use your function do something like:
+
+```bash
+    "$test[*][ @t = iamafunction() ]"
+```
+
+Behind the scenes an instance of your function will be retrieved with:
+
+```python
+    f = FunctionFactory.get_function(matcher=None, name="iamafunction")
+```
+
+The name you set on FunctionFactory must match the name passed in when a function is requested.
+

{csvpath-0.0.471 → csvpath-0.0.472}/docs/functions/import.md

@@ -17,7 +17,7 @@ Let's set up the Python to run the simplest import test:
 
 ```python
     cs = CsvPaths()
-    cs.files_manager.add_named_files_from_dir("./csvs")
+    cs.file_manager.add_named_files_from_dir("./csvs")
     cs.paths_manager.add_named_paths_from_dir("./csvpaths")
     cs.fast_forward_by_line(filename="food", pathsname="import")
     vars = cs.results_manager.get_variables("import")

{csvpath-0.0.471 → csvpath-0.0.472}/docs/functions/metaphone.md

@@ -25,7 +25,7 @@ To set up a canonicalization match component takes a bit more effort, but not to
 
 ```python
     paths = CsvPaths()
-    paths.files_manager.add_named_file(
+    paths.file_manager.add_named_file(
         name="lookups", path="tests/test_resources/named_files/lookup_names.csv"
     )
     paths.paths_manager.add_named_paths_from_file(

{csvpath-0.0.471 → csvpath-0.0.472}/docs/functions.md

@@ -85,6 +85,7 @@ There are lots more simple examples on the individual function pages.
 <tr><td> count_lines()      </td><td> count the lines of data to this point in the file. </td></tr>
 <tr><td> count_scans()      </td><td> count lines we checked for match   </td></tr>
 <tr><td> <a href='https://github.com/dk107dk/csvpath/blob/main/docs/functions/has_dups.md'>count_dups(header, ...)</a>   </td><td> Returns the number of duplicate lines.   </td></tr>
+<tr><td> <a href='https://github.com/dk107dk/csvpath/blob/main/docs/functions/has_matches.md'>has_matches(header, ...)</a>   </td><td> Matches when any other match component matched anywhere in the file.   </td></tr>
 <tr><td> <a href='https://github.com/dk107dk/csvpath/blob/main/docs/functions/line_number.md'>line_number()</a>  </td><td> Gives the physical line number.    </td></tr>
 <tr><td> <a href='https://github.com/dk107dk/csvpath/blob/main/docs/functions/increment.md'>increment(value, n)</a> </td><td> Increments a variable by n each time seen.   </td></tr>
 <tr><td> <a href='https://github.com/dk107dk/csvpath/blob/main/docs/functions/every.md'>every(value, number)</a> </td><td> Matches every Nth time a value is seen.  </td></tr>

{csvpath-0.0.471 → csvpath-0.0.472}/docs/paths.md

@@ -60,7 +60,7 @@ A named path can reference a named file. To extend our example with named files:
     }
 
     paths = CsvPaths()
-    paths.files_manager.set_named_files(nf)
+    paths.file_manager.set_named_files(nf)
     paths.paths_manager.set_named_paths(np)
 
     path = paths.csvpath()
@@ -105,7 +105,7 @@ We can apply them breadth-first using this code:
 
 ```python
     cs = CsvPaths()
-    cs.files_manager.set_named_files(FILES)
+    cs.file_manager.set_named_files(FILES)
     cs.paths_manager.add_named_paths_from_dir(NAMED_PATHS_DIR)
     for line in cs.next_by_line(filename="food", pathsname="many"):
         valid = cs.results_manager.is_valid("many")

{csvpath-0.0.471 → csvpath-0.0.472}/docs/references.md

@@ -40,7 +40,7 @@ This reference points to the `total` variable resulting from the most recent Csv
 
 ```python
         cs = CsvPaths()
-        cs.files_manager.add_named_files_from_dir(NAMED_FILES_DIR)
+        cs.file_manager.add_named_files_from_dir(NAMED_FILES_DIR)
         cs.paths_manager.add_named_paths_from_dir(NAMED_PATHS_DIR)
         cs.fast_forward_paths(filename="orders", pathsname="shipping-validations")
         #

{csvpath-0.0.471 → csvpath-0.0.472}/pyproject.toml

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

csvpath-0.0.471/docs/functions/implementing_functions.md

@@ -1,85 +0,0 @@
-
-# How to create a function
-
-You can easily create your own function, register it for use, and use it in your csvpaths.
-
-Functions extend the Function class using:
-
-    from csvpath.matching.functions.function import Function
-    class MyFunction(Function):
-        ...
-
-Function implementations override three methods:
-
-- `to_value(self, skip=[])` - produces the value of the function
-- `matches(self, skip=[])` - determines if the function contributes to a row matching the csvpath
-- `check_valid(self)` - raises an exception if the function is configured incorrectly
-
-The first two methods may be called multiple times per row due to checking qualifier constraints, principally `onmatch`, or for other reasons. When a function checks to see if the other csvpath components all match it passes itself in the skip list. The skip list is a list of match components that should not perform their usual calculations if they find themselves in the list. If your function finds itself in the skip list it should return:
-
-- `self.value` for `to_value`
-- `True` for `matches` - this makes sure your function isn't asking itself if it matches
-
-Usually you want to cache the result of calculating `to_value` and `matches`. Two variables are provided for caching:
-
-- self.value
-- self.match
-
-Validation is an important step that happens before any rows are considered. It allows for structural csvpath problems to be discovered before you start processing files. The most common validations are available on the Validation class within Function's class hierarchy.
-
-Your function must inherit from Function. It may implement `__init__` and take a `Matcher` object and a string name.
-
-## Example
-
-A very simple function might look like:
-
-```python
-    class MyFunction(Function):
-        def to_value(self, skip=[]):
-            if self in skip:
-                return self._noop_value()
-
-            if self.value is None:
-                #
-                self.calculate_stuff()
-                #
-            return self.value
-
-        def matches(self, skip=[]):
-            if self in skip:
-                return self._noop_match()
-            if self.match is None:
-                #
-                self.calculate_stuff()
-                #
-            return self.match
-
-        def check_valid(self) -> None:
-            self.validate_zero_args()
-            super().check_valid()
-```
-
-In the common case the match depends on the value. In some cases, however, the value depends on the match. When the value is dependent and your function finds itself in the skip list return a call to `self.match()`; otherwise, call `self._noop_value()`. In either case when the match finds `self` in the skip list it should return `self._noop_match()`.
-
-## Registering
-
-To register your function for use, add it to the FunctionFactory like this:
-
-```python
-    FunctionFactory.add_function(name='iamafunction', function=my_function_instance)
-```
-
-To use your function do something like:
-
-```bash
-    "$test[*][ @t = iamafunction() ]"
-```
-
-Behind the scenes an instance of your function will be retrieved with:
-
-```python
-    f = FunctionFactory.get_function(matcher=None, name="iamafunction")
-```
-
-The name you set on FunctionFactory must match the name passed in when a function is requested.
-