csvpath 0.0.478__tar.gz → 0.0.480__tar.gz

{csvpath-0.0.478 → csvpath-0.0.480}/PKG-INFO

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

{csvpath-0.0.478 → csvpath-0.0.480}/config/config.ini

@@ -5,7 +5,7 @@ extensions = txt, csvpath, csvpaths
 extensions = txt, csv, tsv, dat, tab, psv, ssv
 
 [errors]
-csvpath = raise, collect, stop, fail
+csvpath = raise, collect, stop, fail, print
 csvpaths = raise, collect
 
 [logging]

{csvpath-0.0.478 → csvpath-0.0.480}/csvpath/csvpath.py

@@ -242,7 +242,12 @@ class CsvPath(CsvPathPublic, ErrorCollector, Printer):  # pylint: disable=R0902,
         #
         # these settings determine how we report function args validation
         # errors. e.g. if print(True) the validation check fails because
-        # print() expects a string.
+        # print() expects a string. the more recent trend is to get all
+        # the errors and print statements in the same place controlled by
+        # the same properties. for now this stays because there is a minor
+        # benefit to being able to suppress runtime arg validation and only
+        # use match component rules and exceptions to generate validation
+        # info. but long term this capability may go away.
         #
         self._log_validation_errors = False
         self._print_validation_errors = True

{csvpath-0.0.478 → csvpath-0.0.480}/csvpath/managers/file_manager.py

@@ -110,7 +110,7 @@ class FileManager(CsvPathsFileManager):  # pylint: disable=C0115
 
     def set_named_files_from_json(self, filename: str) -> None:
         try:
-            with open(filename, encoding="utf-8") as f:
+            with open(filename, "r", encoding="utf-8") as f:
                 j = json.load(f)
                 self.named_files = j
         except (OSError, ValueError, TypeError, JSONDecodeError) as ex:

{csvpath-0.0.478 → csvpath-0.0.480}/csvpath/matching/functions/args.py

@@ -10,7 +10,6 @@ from csvpath.matching.productions.equality import Equality
 from csvpath.matching.util.expression_utility import ExpressionUtility
 from ..util.exceptions import ChildrenException
 from csvpath.util.config_exception import ConfigurationException
-from csvpath.util.printer import Printer
 
 #   from csvpath.util.log_utility import LogUtility
 #   LogUtility.log_brief_trace()
@@ -199,7 +198,6 @@ class ArgSet:
         b = self._validate_length(siblings)
         if b is False:
             return False
-
         self._pad_or_shrink(siblings)
         for i, s in enumerate(siblings):
             t = tuple(self._args[i].types)
@@ -263,13 +261,23 @@ class ArgSet:
             found = False
             break
         if not found:
+            self._parent._csvpath.logger.debug(
+                "%s(%s) not allowed in arg %s of argset %s",
+                type(a),
+                a,
+                i,
+                self.argset_number,
+            )
             mismatches.append(
-                f"{type(a)}({a}) not allowed in arg {i} of argset {self.argset_number}"
+                f"{type(a)}({a}) not allowed in arg {i + 1} of {len(actuals)}"
             )
         if len(actuals) < self.min_length:
-            mismatches.append(
-                f"Values received {actuals} are too few for argset {self.argset_number}"
+            self._parent._csvpath.logger.debug(
+                "Values received %s are too few for argset %s",
+                actuals,
+                self.argset_number,
             )
+            mismatches.append(f"Too few values received: {actuals}")
             found = False
         if found:
             mismatches = []
@@ -334,7 +342,8 @@ class Args:
             if aset.validate(siblings):
                 good = True
         if not good:
-            msg = "Wrong type or number of args."
+            _ = " at {self.matchable.my_chain}" if self.matchable else ""
+            msg = f"{self._csvpath_id()} Incorrectly written{_}. Wrong type or number of args."
             raise ChildrenException(msg)
         self.validated = True
 
@@ -346,7 +355,7 @@ class Args:
         if self.matchable.notnone and self._has_none(actuals):
             mismatch_count = len(self._argsets)
             mismatches = [
-                f"Cannot have None arguments in {self.matchable.name} because it has the notnone qualifier"
+                f"Cannot have None in {self.matchable.my_chain} because it has the notnone qualifier"
             ]
         else:
             for aseti, aset in enumerate(self._argsets):
@@ -368,23 +377,32 @@ class Args:
                 return True
         return False
 
+    def _csvpath_id(self) -> str:
+        cid = ""
+        if self._csvpath is None:
+            return cid
+        if self._csvpath.csvpaths:
+            cid = self._csvpath.identity
+            if not cid or cid.strip() == "":
+                cid = "<<no ID or name>>"
+            cid = f"[Csvpath {cid}]"
+        return cid
+
     def handle_errors_if(self, mismatch_count, mismatches):
         if mismatch_count == len(self._argsets):
-            c = ""
-            if mismatch_count == 1:
-                c = "all"
-            elif mismatch_count == 2:
-                c = "both"
-            else:
-                c = f"all {mismatch_count}"
-            pm = f"mismatches with args expectations in {self.matchable.name} for {c} arg sets: {mismatches}"
-            cid = ""
-            if self._csvpath:
-                cid = self._csvpath.identity
-            if not self._csvpath or not cid or cid.strip() == "":
-                cid = "<<no ID or name>>"
-                pln = self._csvpath.line_monitor.physical_line_number
-            pm = f"[In csvpath {cid}] Wrong values of args: {pm} at line {pln}"
-            self._csvpath.report_validation_errors(pm)
+            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 = self._csvpath_id()
+            pm = f"{csvpathid} Wrong value(s) at line {pln}: {pm}"
+            # self._csvpath.report_validation_errors(pm)
             if self._csvpath is None or self._csvpath.raise_validation_errors:
                 raise ChildrenException(pm)
+            # we print in-run validation errors as part of the raise handle,
+            # so this is a bit extra. We can suppress the exceptions completely
+            # but still print args validation errors. not sure that is anything
+            # more than a deep corner case. defering removing it.
+            if self._csvpath and self._csvpath.print_validation_errors:
+                self._csvpath.report_validation_errors(pm)

{csvpath-0.0.478 → csvpath-0.0.480}/csvpath/matching/functions/dates/datef.py

@@ -37,4 +37,4 @@ class Date(ValueProducer):
         self.value = d
 
     def _decide_match(self, skip=None) -> None:
-        self.match = self.default_match()  # pragma: no cover
+        self.match = self.to_value(skip=skip) is not None  # pragma: no cover

{csvpath-0.0.478 → csvpath-0.0.480}/csvpath/matching/functions/dates/now.py

@@ -15,13 +15,13 @@ class Now(ValueProducer):
     def check_valid(self) -> None:
         self.args = Args(matchable=self)
         self.args.argset(0)
-        self.args.argset(1).arg(
-            types=[None, Term, Function, Header, Variable], actuals=[str]
-        )
-        self.args.validate(self.siblings())
         if self.name in ["thisyear", "thismonth", "today"]:
-            if len(self.children) > 0:
-                raise ChildrenException(f"Function {self.name} cannot have arguments")
+            self.args.validate(self.siblings())
+        else:
+            self.args.argset(1).arg(
+                types=[None, Term, Function, Header, Variable], actuals=[str]
+            )
+            self.args.validate(self.siblings())
         super().check_valid()
 
     def _produce_value(self, skip=None) -> None:

{csvpath-0.0.478 → csvpath-0.0.480}/csvpath/matching/functions/function_factory.py

@@ -7,6 +7,7 @@ from .dates.datef import Date
 from .strings.lower import Lower
 from .strings.upper import Upper
 from .strings.substring import Substring
+from .strings.string import String
 from .strings.starts_with import StartsWith
 from .strings.strip import Strip
 from .strings.length import Length, MinMaxLength
@@ -221,6 +222,8 @@ class FunctionFactory:
             f = Length(matcher, name, child)
         elif name == "add":
             f = Add(matcher, name, child)
+        elif name == "string":
+            f = String(matcher, name, child)
         elif name in ["subtract", "minus"]:
             f = Subtract(matcher, name, child)
         elif name == "multiply":

{csvpath-0.0.478 → csvpath-0.0.480}/csvpath/matching/functions/function_finder.py

@@ -24,7 +24,7 @@ class FunctionFinder:
                 f"[functions][imports] path in {config.configpath} does not exist"
             )
             return
-        with open(path, "r") as file:
+        with open(path, "r", encoding="utf-8") as file:
             i = 0
             for line in file:
                 i += 1

{csvpath-0.0.478 → csvpath-0.0.480}/csvpath/matching/functions/lines/first_line.py

@@ -22,7 +22,7 @@ class FirstLine(MatchDecider):
         super().check_valid()
 
     def _produce_value(self, skip=None) -> None:
-        self.value = self.match(skip=skip)
+        self.value = self.matches(skip=skip)
 
     def _decide_match(self, skip=None) -> None:
         t = self.name

{csvpath-0.0.478 → csvpath-0.0.480}/csvpath/matching/functions/misc/intf.py

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

{csvpath-0.0.478 → csvpath-0.0.480}/csvpath/matching/functions/misc/nonef.py

@@ -1,6 +1,9 @@
 # pylint: disable=C0114
 from typing import Any
 from ..function_focus import ValueProducer
+from csvpath.matching.util.expression_utility import ExpressionUtility
+from csvpath.matching.productions import Variable, Header, Reference
+from csvpath.matching.functions.function import Function
 from ..args import Args
 
 
@@ -10,6 +13,8 @@ class Nonef(ValueProducer):
     def check_valid(self) -> None:
         self.args = Args(matchable=self)
         self.args.argset(0)
+        a = self.args.argset(1)
+        a.arg(types=[Variable, Header, Function, Reference], actuals=[None, Any])
         self.args.validate(self.siblings())
         super().check_valid()
 
@@ -18,4 +23,7 @@ class Nonef(ValueProducer):
         self.value = None
 
     def _decide_match(self, *, skip=None) -> None:  # pragma: no cover
-        self.match = False
+        if len(self.children) == 0:
+            self.match = True
+        else:
+            self.match = ExpressionUtility.is_none(self._value_one(skip=skip))

{csvpath-0.0.478 → csvpath-0.0.480}/csvpath/matching/functions/strings/regex.py

@@ -3,6 +3,7 @@ import re
 from csvpath.matching.util.expression_utility import ExpressionUtility
 from ..function_focus import MatchDecider
 from csvpath.matching.productions import Term, Variable, Header, Reference
+from csvpath.matching.util.exceptions import ChildrenException
 from ..function import Function
 from ..args import Args
 
@@ -13,29 +14,54 @@ class Regex(MatchDecider):
     def check_valid(self) -> None:
         self.args = Args(matchable=self)
         a = self.args.argset(3)
-        a.arg(types=[Term, Variable, Header, Function, Reference], actuals=[str])
-        a.arg(types=[Term, Variable, Header, Function, Reference], actuals=[str])
+        a.arg(
+            types=[Term, Variable, Header, Function, Reference],
+            actuals=[str, self.args.EMPTY_STRING],
+        )
+        a.arg(
+            types=[Term, Variable, Header, Function, Reference],
+            actuals=[str, self.args.EMPTY_STRING],
+        )
         a.arg(types=[None, Term, Variable, Header, Function, Reference], actuals=[int])
         self.args.validate(self.siblings())
         super().check_valid()
         left = self._function_or_equality.left
-        if isinstance(left, Term):
-            restr = left.to_value()
-            re.compile(restr)
+        self.is_regex_if(left)
+        right = self._function_or_equality.right
+        self.is_regex_if(right)
+
+    def is_regex_if(self, t):
+        if isinstance(t, Term):
+            v = t.to_value()
+            if v and len(v) > 0 and v[0] == "/":
+                re.compile(v)
+
+    def _the_regex(self, siblings, skip=None):
+        # group
+        group = 0 if len(siblings) == 2 else siblings[2].to_value(skip=skip)
+        group = int(group)
+        c1 = siblings[0]
+        c2 = siblings[1]
+        v1 = c1.to_value(skip=skip)
+        v2 = c2.to_value(skip=skip)
+
+        if v1.startswith("/"):
+            theregex = v1.lstrip("/")
+            theregex = theregex.rstrip("/")
+            thevalue = v2
+            return theregex, thevalue, group
+        elif v2.startswith("/"):
+            theregex = v2.lstrip("/")
+            theregex = theregex.rstrip("/")
+            thevalue = v1
+            return theregex, thevalue, group
+        else:
+            raise ChildrenException("No regular expression available")
 
     def _produce_value(self, skip=None) -> None:
         child = self.children[0]
         siblings = child.commas_to_list()
-        regex = siblings[0]
-        value = siblings[1]
-        group = 0 if len(siblings) == 2 else siblings[2].to_value(skip=skip)
-        group = int(group)
-        thevalue = value.to_value(skip=skip)
-        theregex = regex.to_value(skip=skip)
-        if theregex[0] == "/":
-            theregex = theregex[1:]
-        if theregex[len(theregex) - 1] == "/":
-            theregex = theregex[0 : len(theregex) - 1]
+        theregex, thevalue, group = self._the_regex(siblings, skip=skip)
         if thevalue is None:
             # this could happen if the line is blank
             pass

csvpath-0.0.480/csvpath/matching/functions/strings/string.py

@@ -0,0 +1,43 @@
+# pylint: disable=C0114
+from csvpath.matching.util.exceptions import ChildrenException
+from ..function_focus import ValueProducer
+from csvpath.matching.productions import Term, Variable, Header, Reference
+from ..function import Function
+from ..args import Args
+
+
+class String(ValueProducer):
+    def check_valid(self) -> None:
+        self.args = Args(matchable=self)
+        a = self.args.argset(1)
+        a.arg(
+            types=[Term, Variable, Function],
+            actuals=[None, str, self.args.EMPTY_STRING],
+        )
+        a = self.args.argset(3)
+        a.arg(
+            types=[Term, Variable, Function],
+            actuals=[None, str, self.args.EMPTY_STRING],
+        )
+        a.arg(types=[Term, Variable, Header, Function], actuals=[int])
+        a.arg(types=[None, Term, Variable, Header, Function], actuals=[int])
+        self.args.validate(self.siblings())
+        super().check_valid()
+
+    def _produce_value(self, skip=None) -> None:
+        self.matches(skip=skip)
+        self.value = f"{self._value_one()}" if self.match else None
+
+    def _decide_match(self, skip=None) -> None:
+        value = self._value_one(skip=skip)
+        value = f"{value}" if value is not None else None
+        if value is None:
+            self.match = False
+        else:
+            maxlen = self._value_two(skip=skip)
+            minlen = self._value_three(skip=skip)
+            if minlen is None:
+                minlen = 0
+            if maxlen is None:
+                maxlen = len(value)
+            self.match = minlen <= len(value) <= maxlen

{csvpath-0.0.478 → csvpath-0.0.480}/csvpath/matching/functions/strings/substring.py

@@ -18,6 +18,7 @@ class Substring(ValueProducer):
             actuals=[str, self.args.EMPTY_STRING],
         )
         a.arg(types=[Term, Variable, Header, Function, Reference], actuals=[int])
+        self.args.validate(self.siblings())
         super().check_valid()
 
     def _produce_value(self, skip=None) -> None:

{csvpath-0.0.478 → csvpath-0.0.480}/csvpath/matching/productions/expression.py

@@ -40,6 +40,13 @@ class Expression(Matchable):
                 e.trace = traceback.format_exc()
                 e.source = self
                 e.json = self.matcher.to_json(self)
+                #
+                # for output ErrorHandler has:
+                #   - the print() on the CsvPath
+                #   - the error_collector
+                #   - the logger on the CsvPath or CsvPaths
+                #   - exceptions dumped on system.err
+                #
                 ErrorHandler(
                     csvpath=self.matcher.csvpath, error_collector=self.matcher.csvpath
                 ).handle_error(e)

{csvpath-0.0.478 → csvpath-0.0.480}/csvpath/matching/productions/matchable.py

@@ -33,10 +33,11 @@ class Matchable(Qualified):
         don't want that info after a run completes"""
 
     def _simple_class_name(self) -> str:
-        cn = str(self.__class__)
-        name = cn[(cn.rfind(".") + 1) :]
-        name = name[0 : name.rfind("'>")]
-        return name
+        return ExpressionUtility.simple_class_name(self)
+
+    @property
+    def my_chain(self) -> str:
+        return ExpressionUtility.my_chain(self)
 
     def _noop_match(self) -> bool:
         """deprecated. use self.default_match()"""
@@ -124,6 +125,20 @@ class Matchable(Qualified):
         # with the current parse tree this shouldn't happen
         return None
 
+    def _value_three(self, skip=None):
+        c = self._child_three()
+        if c is None:
+            return None
+        return c.to_value(skip=skip)
+
+    def _child_three(self):
+        if len(self.children) == 0:
+            # validation should have already caught this, if it is a problem
+            return None
+        if len(self.children) >= 3:
+            return self.children[0].children[2]
+        return None
+
     def siblings_or_equality(self) -> list:
         if (
             len(self.children) == 1

{csvpath-0.0.478 → csvpath-0.0.480}/csvpath/matching/util/exceptions.py

@@ -2,7 +2,7 @@ class MatchException(Exception):
     """most general exception when matching"""
 
 
-class MatchComponentException(Exception):
+class MatchComponentException(MatchException):
     """most general exception for the matching part of a csvpath"""
 
 
@@ -10,7 +10,7 @@ class ChildrenException(MatchComponentException):
     """raised when the structure of a match part is incorrect"""
 
 
-class DataException(Exception):
+class DataException(MatchException):
     """raised when a datium is unexpected or incorrect"""
 
     pass

{csvpath-0.0.478 → csvpath-0.0.480}/csvpath/matching/util/expression_utility.py

@@ -363,6 +363,39 @@ class ExpressionUtility:
                 break
         return hashlib.sha256(id.encode("utf-8")).hexdigest()
 
+    @classmethod
+    def my_chain(cls, thing):
+        ancs = []
+        p = thing.parent
+        while p is not None:
+            ancs.append(p)
+            p = p.parent
+        chain = cls.name_or_class(thing)
+        for o in ancs:
+            n = cls.name_or_class(o)
+            if n != "":
+                chain = f"{n}.{chain}"
+        return chain
+
+    @classmethod
+    def name_or_class(cls, thing, show_eq_and_exp=False):
+        if not show_eq_and_exp and f"{type(thing)}".find("Equality") > -1:
+            return ""
+        if not show_eq_and_exp and f"{type(thing)}".find("Expression") > -1:
+            return ""
+        if not hasattr(thing, "name"):
+            return cls.simple_class_name(thing)
+        if f"{type(thing)}".find("Term") != -1:
+            return thing.to_value()
+        if thing.name is None:
+            return cls.simple_class_name(thing)
+        return thing.name
+
+    @classmethod
+    def simple_class_name(cls, thing):
+        ts = f"{type(thing)}"
+        return ts[ts.rfind(".") + 1 : ts.rfind("'")]
+
     @classmethod
     def get_my_expression(cls, thing):
         p = thing.parent

{csvpath-0.0.478 → csvpath-0.0.480}/csvpath/matching/util/print_parser.py

@@ -262,6 +262,7 @@ class PrintParser:
             local,
             False,
         )
+        self._set(runtime, identity, "identity", identity, local, False)
         self._set(runtime, identity, "count_matches", csvpath.match_count, local, False)
         self._set(runtime, identity, "count_scans", csvpath.scan_count, local, False)
         self._set(runtime, identity, "scan_part", csvpath.scan, local, False)

{csvpath-0.0.478 → csvpath-0.0.480}/csvpath/util/cache.py

@@ -45,5 +45,5 @@ class Cache:
     def cache_text(self, filename, strtype: str, data: str) -> None:
         cn = self._cache_name(filename)
         cachepath = os.path.join(self._cachedir(), f"{cn}.{strtype}")
-        with open(cachepath, "w") as file:
+        with open(cachepath, "w", encoding="utf-8") as file:
             file.write(str(data))

{csvpath-0.0.478 → csvpath-0.0.480}/csvpath/util/config.py

@@ -22,6 +22,7 @@ class OnError(Enum):
     COLLECT = "collect"
     STOP = "stop"
     FAIL = "fail"
+    PRINT = "print"
 
 
 class LogLevels(Enum):
@@ -134,14 +135,14 @@ class Config:
         if directory != "":
             if not path.exists(directory):
                 os.makedirs(directory)
-        with open(self._configpath, "w") as file:
+        with open(self._configpath, "w", encoding="utf-8") as file:
             c = """
 [csvpath_files]
 extensions = txt, csvpath, csvpaths
 [csv_files]
 extensions = txt, csv, tsv, dat, tab, psv, ssv
 [errors]
-csvpath = raise, collect, stop, fail
+csvpath = raise, collect, stop, fail, print
 csvpaths = raise, collect
 [logging]
 csvpath = info

{csvpath-0.0.478 → csvpath-0.0.480}/csvpath/util/error.py

@@ -6,6 +6,7 @@ import traceback
 from csvpath.util.config import OnError
 from .exceptions import InputException
 from .log_utility import LogException
+from ..matching.util.exceptions import MatchException
 
 
 class ErrorHandlingException(Exception):
@@ -126,9 +127,9 @@ class ErrorHandler:
             raise InputException("Error handler cannot handle a None error")
         if OnError.QUIET.value in policy:
             self.logger.error(f"Quiet error: {error.exception}")
-            self.logger.error(f"Quiet class: {error.exception_class}")
-            self.logger.error(f"Quiet file: {error.filename}")
-            self.logger.error(f"Quiet line_count: {error.line_count}")
+            self.logger.error(f"Quiet error class: {error.exception_class}")
+            self.logger.error(f"Quiet error file: {error.filename}")
+            self.logger.error(f"Quiet error line_count: {error.line_count}")
         else:
             self.logger.error(f"{error}")
         if OnError.STOP.value in policy:
@@ -139,8 +140,14 @@ class ErrorHandler:
         if OnError.FAIL.value in policy:
             if self._csvpath:
                 self._csvpath.is_valid = False
+        if OnError.PRINT.value in policy:
+            msg = f"{error.error}"
+            if self._csvpath:
+                self._csvpath.print(msg)
         if OnError.RAISE.value in policy:
-            raise error.error
+            raise MatchException(
+                f"Exception triggered by error policy {policy}"
+            ) from error.error
 
     def build(self, ex: Exception) -> Error:
         error = Error()

{csvpath-0.0.478 → csvpath-0.0.480}/docs/config.md

@@ -34,8 +34,9 @@ The error settings are for when CsvPath or CsvPaths instances encounter problems
 - `raise` - Raise the exception in as noisy a way as possible
 - `quiet` - Do nothing that affects the system out; this protects command line redirection of `print()` output. Logging is also minimized such that errors that would release a lot of metadata are slimmed down.
 - `collect` - Collect the errors in the error results for the CsvPath. This option is available with and without a CsvPaths instance.
+- `print` - Prints the errors using the Printer interface to whatever printers are available. By default this goes to standard out.
 
-Multiple of these settings can be configured together. Quiet and raise do not coexist well. Raise will win because seeing problems lets you fix them.
+Multiple of these settings can be configured together.`quiet` and `raise` do not coexist well; likewise `quiet` and `print`. `raise` will win over `quiet` because seeing problems lets you fix them. `print` is most useful in getting simple inline error messages when `raise` is off.
 
 ## Logging
 

{csvpath-0.0.478 → csvpath-0.0.480}/docs/functions/string_functions.md

@@ -13,11 +13,15 @@ Same as you would expect.
 
 ### min_length(value, int) and max_length(value, int)
 
-`min_length()` and `max_length()` return True if the stringified value is more than or less than the integer provided. The functionality can also be achieved using `above()` and `below()` or `between()`, but the min and max functions are obviously simpler.
+`min_length()` and `max_length()` return True if the stringified value is more than or less than the integer provided. The functionality can also be achieved using `above()` and `below()` or `between()`, but the min and max functions are obviously simpler. Likewise, there is overlap with the newer `string()`; however, you cannot use `string()` to set a min without also setting a max; for that you would need `min_length()`.
+
+### string(value, max, min)
+
+`string()` is an evolved approach that enables a simpler declaration of a string. Think of it like a VARCHAR declaration in SQL's DDL. You can add the `notnone` qualifier to force `string()` to be not None. `string()` stringifies its value. The value of `string()` is the value it wraps. Standing alone it is an existance test that the wrapped value is not None.
 
 ### lower(value)
 
-Same as you would expect.
+Lowercases a string.
 
 ### starts_with(does_this, start_with_this)
 
@@ -25,7 +29,7 @@ Checks if the first value, stringified, starts with the second value. The values
 
 ### strip(value)
 
-Same as you would expect from the Python function.
+Trims whitespace. Same as you would expect from the Python function.
 
 ### substring(value, int)
 
@@ -33,7 +37,7 @@ Substring starting from left and including the number of characters indicated. T
 
 ### upper(value)
 
-Same as you would expect.
+Uppercases a string.
 
 ## Examples