csvpath 0.0.2__py3-none-any.whl

csvpath/matching/functions/below.py

@@ -0,0 +1,36 @@
+from typing import Any
+from csvpath.matching.functions.function import Function, ChildrenException
+
+
+class Below(Function):
+    def to_value(self, *, skip=[]) -> Any:
+        if self in skip:
+            return True
+        if len(self.children) != 1:
+            self.matcher.print(
+                f"In.to_value: must have 1 equality child: {self.children}"
+            )
+            raise ChildrenException("Below function must have 1 child")
+        if self.children[0].op != ",":
+            raise ChildrenException(
+                f"Below function must have an equality with the ',' operation, not {self.children[0].op}"
+            )
+        thischild = self.children[0].children[0]
+        belowthatchild = self.children[0].children[1]
+
+        this_is = thischild.to_value(skip=skip)
+        below_that = belowthatchild.to_value(skip=skip)
+        this = -1
+        that = -1
+        try:
+            this = float(this_is)
+            that = float(below_that)
+        except Exception:
+            raise Exception(
+                f"Below.to_value: this: {this}, a {this.__class__}, and {that}, a {that.__class__}"
+            )
+        b = this < that
+        return b
+
+    def matches(self, *, skip=[]) -> bool:
+        return self.to_value(skip=skip)

csvpath/matching/functions/concat.py

@@ -0,0 +1,25 @@
+from typing import Any
+from csvpath.matching.functions.function import Function, ChildrenException
+
+
+class Concat(Function):
+    def to_value(self, *, skip=[]) -> Any:
+        if self in skip:
+            return True
+        if len(self.children) != 1:
+            self.matcher.print(
+                f"In.to_value: must have 1 equality child: {self.children}"
+            )
+            raise ChildrenException("In function must have 1 child")
+        if self.children[0].op != ",":
+            raise ChildrenException(
+                f"In function must have an equality with the ',' operation, not {self.children[0].op}"
+            )
+        left = self.children[0].children[0]
+        right = self.children[0].children[1]
+        value = f"{left.to_value(skip=skip)}{right.to_value(skip=skip)}"
+        return value
+
+    def matches(self, *, skip=[]) -> bool:
+        v = self.to_value(skip=skip)
+        return v is not None

csvpath/matching/functions/count.py

@@ -0,0 +1,44 @@
+from typing import Any
+from csvpath.matching.functions.function import Function
+
+
+class Count(Function):
+    def print(self, msg):
+        if self.matcher:
+            self.matcher.print(msg)
+
+    def to_value(self, *, skip=[]) -> Any:
+        if self in skip:
+            return True
+        if self.value is None:
+            if self._function_or_equality:
+                self.value = self._get_contained_value(skip=skip)
+            else:
+                self.value = (
+                    self._get_match_count() + 1
+                )  # we're eager to +1 because we don't
+                # contribute to if there's a match
+        return self.value  # or not. we have to act as if.
+
+    def _get_match_count(self) -> int:
+        if not self.matcher or not self.matcher.csvpath:
+            print("WARNING: no csvpath. are we testing?")
+            return -1
+        return self.matcher.csvpath.current_match_count()
+
+    def _get_contained_value(self, *, skip=[]) -> Any:
+        #
+        # need to apply this count function to the contained obj's value
+        #
+        b = self._function_or_equality.matches(skip=skip)
+        self._id = self.get_id(self._function_or_equality)
+        #
+        # to_value() is often going to be a bool based on matches().
+        # but in a case like: count(now('yyyy-mm-dd')) it would not be
+        #
+        tracked_value = self._function_or_equality.to_value(skip=skip)
+        cnt = self.matcher.get_variable(self._id, tracking=tracked_value, set_if_none=0)
+        if b:
+            cnt += 1
+        self.matcher.set_variable(self._id, tracking=tracked_value, value=cnt)
+        return cnt

csvpath/matching/functions/count_lines.py

@@ -0,0 +1,12 @@
+from typing import Any
+from csvpath.matching.functions.function import Function
+
+
+class CountLines(Function):
+    def print(self, msg):
+        if self.matcher:
+            self.matcher.print(msg)
+
+    def to_value(self, *, skip=[]) -> Any:
+        if self.matcher:
+            return self.matcher.csvpath.current_line_number()

csvpath/matching/functions/count_scans.py

@@ -0,0 +1,13 @@
+from typing import Any
+from csvpath.matching.functions.function import Function
+
+
+class CountScans(Function):
+    def print(self, msg):
+        if self.matcher:
+            self.matcher.print(msg)
+
+    def to_value(self, *, skip=[]) -> Any:
+        if self in skip:
+            return True
+        return self.matcher.csvpath.current_scan_count()

csvpath/matching/functions/divide.py

@@ -0,0 +1,30 @@
+from typing import Any
+from csvpath.matching.functions.function import Function, ChildrenException
+from csvpath.matching.productions.equality import Equality
+
+
+class Divide(Function):
+    def to_value(self, *, skip=[]) -> Any:
+        if not self.value:
+            if len(self.children) != 1:
+                raise ChildrenException("no children. there must be 1 equality child")
+            child = self.children[0]
+            if not isinstance(child, Equality):
+                raise ChildrenException("must be 1 equality child")
+
+            siblings = child.commas_to_list()
+            ret = 0
+            for i, sib in enumerate(siblings):
+                v = sib.to_value(skip=skip)
+                if i == 0:
+                    ret = v
+                else:
+                    if ret == float("nan") or v == 0:
+                        ret = float("nan")
+                    else:
+                        ret = ret / v
+            self.value = ret
+        return self.value
+
+    def matches(self, *, skip=[]) -> bool:
+        return True

csvpath/matching/functions/end.py

@@ -0,0 +1,18 @@
+from typing import Any
+from csvpath.matching.functions.function import Function, ChildrenException
+
+
+class End(Function):
+    def to_value(self, *, skip=[]) -> Any:
+        if self in skip:
+            return True
+        if self.children and len(self.children) > 0:
+            ChildrenException("end must not have a child")
+        if not self.value:
+            i = self.matcher.last_header_index()
+            if i:
+                self.value = self.matcher.line[i]
+        return self.value
+
+    def matches(self, *, skip=[]) -> bool:
+        return self.to_value(skip=skip) is not None

csvpath/matching/functions/every.py

@@ -0,0 +1,33 @@
+from typing import Any
+from csvpath.matching.functions.function import Function, ChildrenException
+from csvpath.matching.productions.equality import Equality
+
+
+class Every(Function):
+    def to_value(self, *, skip=[]) -> Any:
+        return self.matches(skip=skip)
+
+    def matches(self, *, skip=[]) -> bool:
+        if self.value is None:
+            if len(self.children) != 1:
+                raise ChildrenException("no children. there must be 1 equality child")
+            child = self.children[0]
+            if not isinstance(child, Equality):
+                raise ChildrenException("must be 1 equality child")
+
+            tracked_value = self.children[0].left.matches(skip=skip)
+            if tracked_value:
+                every = self.children[0].right.to_value()
+                self._id = self.get_id(self)
+                cnt = self.matcher.get_variable(
+                    self._id, tracking=tracked_value, set_if_none=0
+                )
+                cnt += 1
+                self.matcher.set_variable(self._id, tracking=tracked_value, value=cnt)
+                if cnt % every == 0:
+                    self.value = True
+                else:
+                    self.value = False
+            else:
+                self.value = False
+        return self.value

csvpath/matching/functions/first.py

@@ -0,0 +1,46 @@
+from typing import Any
+from csvpath.matching.functions.function import Function, ChildrenException
+from csvpath.matching.productions.equality import Equality
+
+
+class First(Function):
+    def __init__(self, matcher, name: str = None, child: Any = None):
+        super().__init__(matcher, child=child, name=name)
+        self._my_value_or_none = -9999  # when this var is None we match
+
+    def to_value(self, *, skip=[]) -> Any:
+        if len(self.children) != 1:
+            self.matcher.print(f"First.to_value: must have 1 child: {self.children}")
+            raise ChildrenException("First function must have 1 child")
+        if self._my_value_or_none == -9999:
+
+            child = self.children[0]
+            value = ""
+            if isinstance(child, Equality):
+                for _ in child.commas_to_list():
+                    value += f"{_.to_value(skip=skip)}"
+            else:
+                value = f"{child.to_value(skip=skip)}"
+
+            my_id = self.get_id()
+            v = self.matcher.get_variable(my_id, tracking=value)
+            if v is None:
+                self.matcher.set_variable(
+                    my_id,
+                    tracking=value,
+                    value=self.matcher.csvpath.current_line_number(),
+                )
+            #
+            # when we have no earlier value we are first, so we match
+            #
+            self._my_value_or_none = v
+        return self._my_value_or_none
+
+    def matches(self, *, skip=[]) -> bool:
+        #
+        # when there is no earlier value we match
+        #
+        if self._my_value_or_none == -9999:
+            self.to_value(skip=skip)
+        v = self._my_value_or_none
+        return v is None

csvpath/matching/functions/function.py

@@ -0,0 +1,31 @@
+from typing import Any
+from csvpath.matching.productions.matchable import Matchable
+
+
+class NoChildrenException(Exception):
+    pass
+
+
+class ChildrenException(Exception):
+    pass
+
+
+class Function(Matchable):
+    def __init__(self, matcher: Any, name: str, child: Matchable = None) -> None:
+        super().__init__(matcher, name=name)
+        self.matcher = matcher  # atm, circular dep
+        self._function_or_equality = child
+        if child:
+            self.add_child(child)
+
+    def __str__(self) -> str:
+        return f"""\n{self.__class__}{self.name}({self._function_or_equality})"""
+
+    def to_value(self, *, skip=[]) -> bool:
+        if self in skip:
+            return True
+        if self._function_or_equality:
+            if not self._function_or_equality.matches(skip=skip):
+                return False
+        print("WARNING: function getting to_value defaulting to True")
+        return True  # leave this for now for testing

csvpath/matching/functions/function_factory.py

@@ -0,0 +1,114 @@
+from csvpath.matching.productions.expression import Matchable
+from csvpath.matching.functions.function import Function
+from csvpath.matching.functions.count import Count
+from csvpath.matching.functions.regex import Regex
+from csvpath.matching.functions.length import Length
+from csvpath.matching.functions.notf import Not
+from csvpath.matching.functions.now import Now
+from csvpath.matching.functions.inf import In
+from csvpath.matching.functions.concat import Concat
+from csvpath.matching.functions.lower import Lower
+from csvpath.matching.functions.upper import Upper
+from csvpath.matching.functions.percent import Percent
+from csvpath.matching.functions.below import Below
+from csvpath.matching.functions.above import Above
+from csvpath.matching.functions.first import First
+from csvpath.matching.functions.count_lines import CountLines
+from csvpath.matching.functions.count_scans import CountScans
+from csvpath.matching.functions.is_instance import IsInstance
+from csvpath.matching.functions.orf import Or
+from csvpath.matching.functions.no import No
+from csvpath.matching.functions.minf import Min, Max, Average
+from csvpath.matching.functions.end import End
+from csvpath.matching.functions.random import Random
+from csvpath.matching.functions.add import Add
+from csvpath.matching.functions.subtract import Subtract
+from csvpath.matching.functions.multiply import Multiply
+from csvpath.matching.functions.divide import Divide
+from csvpath.matching.functions.tally import Tally
+from csvpath.matching.functions.every import Every
+
+
+class UnknownFunctionException(Exception):
+    pass
+
+
+class InvalidChildException(Exception):
+    pass
+
+
+class FunctionFactory:
+    @classmethod
+    def get_function(  # noqa: C901
+        cls, matcher, *, name: str, child: Matchable = None
+    ) -> Function:
+        if child and not isinstance(child, Matchable):
+            raise InvalidChildException(f"{child} is not a valid child")
+        f = None
+        if name == "count":
+            f = Count(matcher, name, child)
+        elif name == "length":
+            f = Length(matcher, name, child)
+        elif name == "regex":
+            f = Regex(matcher, name, child)
+        elif name == "not":
+            f = Not(matcher, name, child)
+        elif name == "now":
+            f = Now(matcher, name, child)
+        elif name == "in":
+            f = In(matcher, name, child)
+        elif name == "concat":
+            f = Concat(matcher, name, child)
+        elif name == "lower":
+            f = Lower(matcher, name, child)
+        elif name == "upper":
+            f = Upper(matcher, name, child)
+        elif name == "percent":
+            f = Percent(matcher, name, child)
+        elif name == "below":
+            f = Below(matcher, name, child)
+        elif name == "above":
+            f = Above(matcher, name, child)
+        elif name == "first":
+            f = First(matcher, name, child)
+        elif name == "count_lines":
+            f = CountLines(matcher, name, child)
+        elif name == "count_scans":
+            f = CountScans(matcher, name, child)
+        elif name == "isinstance":
+            f = IsInstance(matcher, name, child)
+        elif name == "or":
+            f = Or(matcher, name, child)
+        elif name == "no":
+            f = No(matcher, name, child)
+        elif name == "max":
+            f = Max(matcher, name, child)
+        elif name == "min":
+            f = Min(matcher, name, child)
+        elif name == "average":
+            f = Average(matcher, name, child, "average")
+        elif name == "median":
+            f = Average(matcher, name, child, "median")
+        elif name == "random":
+            f = Random(matcher, name, child)
+        elif name == "end":
+            f = End(matcher, name, child)
+        elif name == "length":
+            f = Length(matcher, name, child)
+        elif name == "add":
+            f = Add(matcher, name, child)
+        elif name == "subtract":
+            f = Subtract(matcher, name, child)
+        elif name == "multiply":
+            f = Multiply(matcher, name, child)
+        elif name == "divide":
+            f = Divide(matcher, name, child)
+        elif name == "tally":
+            f = Tally(matcher, name, child)
+        elif name == "every":
+            f = Every(matcher, name, child)
+        else:
+            raise UnknownFunctionException(f"{name}")
+        if child:
+            child.parent = f
+        return f

csvpath/matching/functions/inf.py

@@ -0,0 +1,38 @@
+from typing import Any
+from csvpath.matching.functions.function import Function, ChildrenException
+
+
+class In(Function):
+    def to_value(self, *, skip=[]) -> Any:
+        if self in skip:
+            return True
+        if len(self.children) != 1:
+            self.matcher.print(
+                f"In.to_value: must have 1 equality child: {self.children}"
+            )
+            raise ChildrenException("In function must have 1 child")
+        if self.children[0].op != ",":
+            raise ChildrenException(
+                f"In function must have an equality with the ',' operation, not {self.children[0].op}"
+            )
+        vchild = self.children[0].children[0]
+        lchild = self.children[0].children[1]
+
+        mylist = []
+        liststr = lchild.to_value(skip=skip)
+        # print(f"In.to_value: list str: {liststr}")
+        mylist = liststr.split("|")
+        # print(f"In.to_value: child: {vchild}, a {vchild.__class__}")
+        v = vchild.to_value()
+        # print(f"In.to_value: self.matcher.csvpath.headers: {self.matcher.csvpath.headers}")
+
+        # print(f"In.to_value: list: {mylist}, value: {v}")
+        if v in mylist:
+            return True
+        elif v.__class__ != str and f"{v}" in mylist:
+            return True
+        else:
+            return False
+
+    def matches(self, *, skip=[]) -> bool:
+        return self.to_value(skip=skip)

csvpath/matching/functions/is_instance.py

@@ -0,0 +1,95 @@
+from typing import Any
+from csvpath.matching.functions.function import Function, ChildrenException
+from csvpath.matching.productions.equality import Equality
+from dateutil import parser
+from numbers import Number
+
+
+class IsInstance(Function):
+    def to_value(self, *, skip=[]) -> Any:
+        return self.matches(skip=skip)
+
+    def matches(self, *, skip=[]) -> bool:
+        if self.value is not None:
+            return self.value
+        elif self in skip:
+            return True
+        if len(self.children) != 1:
+            raise ChildrenException(
+                "no children. there must be 1 equality child with 2 non-equality children"
+            )
+        child = self.children[0]
+        if not isinstance(child, Equality):
+            raise ChildrenException(
+                "must be 1 equality child with 2 non-equality children"
+            )
+        left = child.left
+        right = child.right
+        thevalue = left.to_value(skip=skip)
+        thetype = right.to_value(skip=skip)
+        self.value = self._get_match_value(thetype, thevalue)
+        return self.value
+
+    def _get_match_value(self, thetype, thevalue) -> bool:
+        ret = False
+        if thetype == "int":
+            try:
+                v = int(thevalue)
+                ret = f"{v}" == f"{thevalue}"
+            except Exception:
+                pass
+        elif thetype == "float":
+            try:
+                v = float(thevalue)
+                ret = f"{v}" == f"{thevalue}"
+            except Exception:
+                pass
+        elif thetype == "str":
+            v = str(thevalue)
+            ret = f"{v}" == f"{thevalue}"
+        elif thetype == "complex":
+            try:
+                v = complex(thevalue)
+                ret = f"{v}" == f"{thevalue}"
+            except Exception:
+                pass
+        elif thetype == "bool":
+            v = isinstance(thevalue, bool)
+            if not v:
+                if thevalue == 1 or thevalue == 0:
+                    v = True
+                if thevalue == "None":
+                    v = True
+            ret = v
+        elif thetype == "usd":
+            ret = self.to_usd(thevalue)
+        elif thetype == "datetime":
+            ret = self.to_datetime(thevalue)
+        else:
+            raise Exception(
+                f"""the type must one of:
+                                "int","float","str","bool",
+                                "complex","usd","datetime, not {thetype}"
+                                """
+            )
+        return ret
+
+    def to_usd(self, v) -> bool:
+        if isinstance(v, Number):
+            return False
+        try:
+            float(f"{v}".replace("$", "").replace(",", ""))
+        except Exception:
+            return False
+        v = v.strip().lower()
+        if v[0] == "$":
+            return True
+        return False
+
+    def to_datetime(self, v) -> bool:
+        try:
+            parser.parse(f"{v}")
+        except Exception as e:
+            print(e)
+            return False
+        return True

csvpath/matching/functions/length.py

@@ -0,0 +1,33 @@
+from typing import Any
+from csvpath.matching.functions.function import (
+    Function,
+    NoChildrenException,
+    ChildrenException,
+)
+
+
+class Length(Function):
+    def to_value(self, *, skip=[]) -> Any:
+        if self in skip:
+            return True
+        if not self.children:
+            NoChildrenException(
+                "length function must have a child that produces a value"
+            )
+        if not len(self.children) == 1:
+            self.matcher.print(
+                f"Length.to_value: should be 1 children: {self.children}"
+            )
+            ChildrenException(
+                "length function must have a single child that produces a value"
+            )
+        val = self.children[0].to_value(skip=skip)
+        self.matcher.print(f"Length.to_value: val: {val}")
+        ret = 0
+        if val:
+            ret = len(f"{val}")
+        self.matcher.print(f"Length.to_value: val: {val}")
+        return ret
+
+    def matches(self, *, skip=[]) -> bool:
+        return self.to_value(skip=skip) > 0

csvpath/matching/functions/lower.py

@@ -0,0 +1,21 @@
+from typing import Any
+from csvpath.matching.functions.function import Function, ChildrenException
+
+
+class Lower(Function):
+    def to_value(self, *, skip=[]) -> Any:
+        if self in skip:
+            return True
+        if len(self.children) != 1:
+            self.matcher.print(
+                f"Lower.to_value: must have 1 equality child: {self.children}"
+            )
+            raise ChildrenException("Lower function must have 1 child")
+
+        value = self.children[0].to_value(skip=skip)
+        value = f"{value}".lower()
+        return value
+
+    def matches(self, *, skip=[]) -> bool:
+        v = self.to_value(skip=skip)
+        return v is not None