csvpath 0.0.2__py3-none-any.whl

csvpath/matching/functions/minf.py

@@ -0,0 +1,167 @@
+from typing import Any
+from csvpath.matching.functions.function import Function, ChildrenException
+from csvpath.matching.productions.equality import Equality
+from csvpath.matching.productions.expression import Matchable
+from statistics import mean, median
+
+
+class MinMax(Function):
+    """
+    // longest value
+    // quintile
+    // median
+    // decile
+    // std div
+    """
+
+    def __init__(self, matcher: Any, name: str, child: Matchable = None) -> None:
+        super().__init__(matcher, name, child)
+
+    def get_the_value(self) -> Any:
+        if isinstance(self.children[0], Equality):
+            return self.children[0].left.to_value()
+        else:
+            return self.children[0].to_value()
+
+    def get_the_name(self) -> Any:
+        if isinstance(self.children[0], Equality):
+            return self.children[0].left.name
+        else:
+            return self.children[0].name
+
+    def get_the_line(self) -> int:
+        if isinstance(self.children[0], Equality):
+            v = self.children[0].right.to_value()
+            v = f"{v}".strip()
+            if v == "match":
+                return self.matcher.csvpath.current_match_count()
+            elif v == "scan":
+                return self.matcher.csvpath.current_scan_count()
+            else:
+                return self.matcher.csvpath.current_line_number()
+        else:
+            return self.matcher.csvpath.current_line_number()
+
+    def is_match(self) -> bool:
+        if isinstance(self.children[0], Equality):
+            v = self.children[0].right.to_value()
+            v = f"{v}".strip()
+            return v == "match"
+        else:
+            return False
+
+    def line_matches(self):
+        es = self.matcher.expressions
+        for e in es:
+            if not e[0].matches(skip=[self]):
+                return False
+        return True
+
+
+class Min(MinMax):
+    def __init__(self, matcher: Any, name: str, child: Matchable = None) -> None:
+        super().__init__(matcher, name, child)
+
+    def to_value(self, *, skip=[]) -> Any:
+        if self in skip:
+            return True
+        if self.children and len(self.children) == 1:
+            ChildrenException("must have a child")
+        if not self.value:
+            v = self.get_the_value()
+            if (
+                self.get_the_name() in self.matcher.csvpath.headers
+                and self.matcher.csvpath.current_line_number() == 0
+            ):
+                return self.value
+            if self.is_match() and not self.line_matches():
+                return self.value
+            self.matcher.set_variable("min", tracking=f"{self.get_the_line()}", value=v)
+            all_values = self.matcher.get_variable("min")
+            m = None
+            for k, v in enumerate(all_values.items()):
+                v = v[1]
+                if not m or v < m:
+                    m = v
+
+            self.value = m
+        return self.value
+
+    def matches(self, *, skip=[]) -> bool:
+        return True
+
+
+class Max(MinMax):
+    def __init__(self, matcher: Any, name: str, child: Matchable = None) -> None:
+        super().__init__(matcher, name, child)
+
+    def to_value(self, *, skip=[]) -> Any:
+        if self in skip:
+            return True
+        if self.children and len(self.children) == 1:
+            ChildrenException("must have a child")
+        if not self.value:
+            v = self.get_the_value()
+            if (
+                self.get_the_name() in self.matcher.csvpath.headers
+                and self.matcher.csvpath.current_line_number() == 0
+            ):
+                return self.value
+            if self.is_match() and not self.line_matches():
+                return self.value
+            self.matcher.set_variable("max", tracking=f"{self.get_the_line()}", value=v)
+            all_values = self.matcher.get_variable("max")
+            m = None
+            for k, v in enumerate(all_values.items()):
+                v = v[1]
+                if not m or v > m:
+                    m = v
+
+            self.value = m
+        return self.value
+
+    def matches(self, *, skip=[]) -> bool:
+        return True
+
+
+class Average(MinMax):
+    def __init__(
+        self, matcher: Any, name: str, child: Matchable = None, ave_or_med="average"
+    ) -> None:
+        super().__init__(matcher, name, child)
+        self.ave_or_med = ave_or_med
+
+    def to_value(self, *, skip=[]) -> Any:
+        if self in skip:
+            return True
+        if self.children and len(self.children) == 1:
+            ChildrenException("must have a child")
+        if not self.value:
+            v = self.get_the_value()
+            if (
+                self.get_the_name() in self.matcher.csvpath.headers
+                and self.matcher.csvpath.current_line_number() == 0
+            ):
+                return self.value
+            if self.is_match() and not self.line_matches():
+                return self.value
+            self.matcher.set_variable(
+                self.ave_or_med, tracking=f"{self.get_the_line()}", value=v
+            )
+            all_values = self.matcher.get_variable(self.ave_or_med)
+            m = []
+            for k, v in enumerate(all_values.items()):
+                v = v[1]
+                try:
+                    v = float(v)
+                    m.append(v)
+                except Exception:
+                    return self.value
+            if self.ave_or_med == "average":
+                self.value = mean(m)
+            else:
+                self.value = median(m)
+        return self.value
+
+    def matches(self, *, skip=[]) -> bool:
+        return True

csvpath/matching/functions/multiply.py

@@ -0,0 +1,27 @@
+from typing import Any
+from csvpath.matching.functions.function import Function, ChildrenException
+from csvpath.matching.productions.equality import Equality
+
+
+class Multiply(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:
+                    ret = v * ret
+            self.value = ret
+        return self.value
+
+    def matches(self, *, skip=[]) -> bool:
+        return True

csvpath/matching/functions/no.py

@@ -0,0 +1,10 @@
+from typing import Any
+from csvpath.matching.functions.function import Function
+
+
+class No(Function):
+    def to_value(self, *, skip=[]) -> Any:
+        return False
+
+    def matches(self, *, skip=[]) -> bool:
+        return False

csvpath/matching/functions/notf.py

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

csvpath/matching/functions/now.py

@@ -0,0 +1,33 @@
+from typing import Any
+from csvpath.matching.functions.function import Function, ChildrenException
+import datetime
+
+
+class Now(Function):
+    def to_value(self, *, skip=[]) -> Any:
+        if self in skip:
+            return True
+        if len(self.children) > 1:
+            self.matcher.print(
+                f"Now.to_value: should be 0 or 1 children: {self.children}"
+            )
+            ChildrenException(
+                "now function may have only a single child that gives a format"
+            )
+        format = None
+        if self.children and len(self.children) == 1:
+            format = self.children[0].to_value(skip=skip)
+            self.matcher.print(f"Now.to_value: format: {format}")
+        x = datetime.datetime.now()
+        self.matcher.print(f"Now.to_value: x: {x}")
+        xs = None
+        if format:
+            xs = x.strftime(format)
+            self.matcher.print(f"Now.to_value: format: {format}, xs: {xs}")
+        else:
+            xs = f"{x}"
+        self.matcher.print(f"Now.to_value: returning: {xs}")
+        return xs
+
+    def matches(self, *, skip=[]) -> bool:
+        return True  # always matches because not internally matchable

csvpath/matching/functions/orf.py

@@ -0,0 +1,28 @@
+from typing import Any
+from csvpath.matching.functions.function import Function, ChildrenException
+from csvpath.matching.productions.equality import Equality
+
+
+class Or(Function):
+    def to_value(self, *, skip=[]) -> Any:
+        return self.matches(skip=skip)
+
+    def matches(self, *, skip=[]) -> bool:
+        if self in skip:
+            return True
+        else:
+            skip.append(self)
+        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 = False
+            for i, sib in enumerate(siblings):
+                if sib.matches(skip=skip):
+                    ret = True
+            self.value = ret
+        return self.value

csvpath/matching/functions/percent.py

@@ -0,0 +1,29 @@
+from typing import Any
+from csvpath.matching.functions.function import Function, ChildrenException
+
+
+class Percent(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 child: {self.children}")
+            raise ChildrenException("Lower function must have 1 child: line|scan|match")
+        which = self.children[0].to_value()
+
+        if which not in ["scan", "match", "line"]:
+            raise Exception("must be scan or match or line")
+
+        if which == "line":
+            count = self.matcher.csvpath.current_line_number()
+        elif which == "scan":
+            count = self.matcher.csvpath.current_scan_count()
+        else:
+            count = self.matcher.csvpath.current_match_count()
+        total = self.matcher.csvpath.get_total_lines()
+        value = count / total
+        return value
+
+    def matches(self, *, skip=[]) -> bool:
+        v = self.to_value(skip=skip)
+        return v is not None

csvpath/matching/functions/random.py

@@ -0,0 +1,33 @@
+from typing import Any
+from csvpath.matching.functions.function import Function, ChildrenException
+from random import randrange
+
+
+class Random(Function):
+    def to_value(self, *, skip=[]) -> Any:
+        if self in skip:
+            return True
+        if len(self.children) != 1:
+            self.matcher.print(
+                f"Random.to_value: must have 1 equality child: {self.children}"
+            )
+            raise ChildrenException("Random function must have 1 child")
+        if self.value is None:
+            lower = self.children[0].left.to_value()
+            upper = self.children[0].right.to_value()
+            if lower is None:
+                lower == 0
+            if upper is None or upper <= lower:
+                upper == 1
+            try:
+                lower = int(lower)
+                upper = int(upper)
+                # we are inclusive, but randrange is not
+                upper += 1
+                self.value = randrange(lower, upper, 1)
+            except Exception:
+                pass
+        return self.value
+
+    def matches(self, *, skip=[]) -> bool:
+        return True

csvpath/matching/functions/regex.py

@@ -0,0 +1,38 @@
+from typing import Any
+from csvpath.matching.productions.term import Term
+from csvpath.matching.functions.function import Function
+import re
+
+
+class Regex(Function):
+    def to_value(self, *, skip=[]) -> Any:
+        self.matches(skip=skip)
+
+    def matches(self, *, skip=[]) -> bool:
+        if self in skip:
+            return True
+        left = self._function_or_equality.left
+        right = self._function_or_equality.right
+
+        self.matcher.print(f"Regex.matches: equality.left: {left} .right: {right}")
+
+        regex = None
+        value = None
+        if isinstance(left, Term):
+            regex = left
+            value = right
+        else:
+            regex = right
+            value = left
+
+        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]
+
+        self.matcher.print(
+            f"regex.matches: thevalue: {thevalue}, the regex: {theregex}"
+        )
+        return re.fullmatch(theregex, thevalue)

csvpath/matching/functions/subtract.py

@@ -0,0 +1,28 @@
+from typing import Any
+from csvpath.matching.functions.function import Function, ChildrenException
+from csvpath.matching.productions.equality import Equality
+
+
+class Subtract(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)
+                print(f"Subtract.to_value: {ret} = {ret} - {v} == {ret - v}")
+                if i == 0:
+                    ret = v
+                else:
+                    ret = ret - v
+            self.value = ret
+        return self.value
+
+    def matches(self, *, skip=[]) -> bool:
+        return True

csvpath/matching/functions/tally.py

@@ -0,0 +1,36 @@
+from typing import Any
+from csvpath.matching.functions.function import Function, ChildrenException
+from csvpath.matching.productions.equality import Equality
+
+
+class Tally(Function):
+    def to_value(self, *, skip=[]) -> Any:
+        if len(self.children) != 1:
+            raise ChildrenException("Tally function must have 1 child")
+        if self not in skip and self.value is None:
+            child = self.children[0]
+            kids = child.commas_to_list() if isinstance(child, Equality) else [child]
+            tally = ""
+            for _ in kids:
+                tally += f"{_.to_value(skip=skip)}"
+                value = f"{_.to_value(skip=skip)}"
+                self._store(_.name, value)
+            if len(kids) > 1:
+                self._store("tally", tally)
+
+            self.value = "tally" if isinstance(child, Equality) else child.name
+        return self.value
+
+    def _store(self, name, value):
+        count = self.matcher.get_variable(name, tracking=value)
+        if count is None:
+            count = 0
+        count += 1
+        self.matcher.set_variable(
+            name,
+            tracking=value,
+            value=count,
+        )
+
+    def matches(self, *, skip=[]) -> bool:
+        return self.to_value(skip=skip) is not None

csvpath/matching/functions/upper.py

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