csvpath 0.0.2__py3-none-any.whl

csvpath/matching/productions/equality.py

@@ -0,0 +1,158 @@
+from typing import Any, List
+from csvpath.matching.productions.variable import Variable
+from csvpath.matching.productions.matchable import Matchable
+from csvpath.matching.productions.header import Header
+from csvpath.matching.productions.term import Term
+from csvpath.matching.functions.function import Function
+
+
+class Equality(Matchable):
+    def __init__(self, matcher):
+        super().__init__(matcher)
+        self.op: str = (
+            "="  # we assume = but if a function or other containing production
+        )
+        # wants to check we might have a different op
+
+    @property
+    def left(self):
+        return self.children[0]
+
+    @left.setter
+    def left(self, o):
+        if not self.children:
+            self.children = [None, None]
+        while len(self.children) < 2:
+            self.children.append(None)
+        else:
+            self.children[0] = o
+
+    @property
+    def right(self):
+        return self.children[1]
+
+    @right.setter
+    def right(self, o):
+        if not self.children:
+            self.children = [None, None]
+        while len(self.children) < 2:
+            self.children.append(None)
+        self.children[1] = o
+
+    def other_child(self, o):
+        if self.left == o:
+            return (self.right, 1)
+        elif self.right == o:
+            return (self.left, 0)
+        else:
+            return None
+
+    def is_terminal(self, o):
+        return (
+            isinstance(o, Variable)
+            or isinstance(o, Term)
+            or isinstance(o, Header)
+            or isinstance(o, Function)
+            or o is None
+        )
+
+    def both_terminal(self):
+        return self.is_terminal(self.left) and self.is_terminal(self.right)
+
+    def commas_to_list(self) -> List[Any]:
+        ls = []
+        self._to_list(ls, self)
+        return ls
+
+    def _to_list(self, ls: List, p):
+        if isinstance(p, Equality) and p.op == ",":
+            self._to_list(ls, p.left)
+            self._to_list(ls, p.right)
+        else:
+            ls.append(p)
+
+    def set_left(self, left):
+        self.left = left
+        if self.left:
+            self.add_child(self.left)
+
+    def set_right(self, right):
+        self.right = right
+        if self.right:
+            self.add_child(self.right)
+
+    def set_operation(self, op):
+        self.op = op
+
+    # ------------------
+
+    def mathic(self):
+        return self.op != ","
+
+    def perform_math(self):
+        if self.op == "," or self.op == "=":
+            return
+        else:
+            if isinstance(self.left, Equality):
+                pass
+                # self.left.perform_math()
+            if isinstance(self.right, Equality) and self.mathic():
+                pass
+                # self.right.perform_math()
+            self.left.value = self.math(self.left.to_value(), self.right.to_value())
+            if isinstance(self.left, Variable):
+                v = self.left.value
+                self.matcher.set_variable(self.left.name, value=v)
+
+        self.value = None
+        self.to_value()
+
+    def math(self, lv, rv):
+        if self.op == "-":
+            return lv - rv
+        elif self.op == "+":
+            return lv + rv
+        elif self.op == "*":
+            return lv * rv
+        elif self.op == "/":
+            return lv / rv
+        else:
+            raise Exception(f"unknown op: {self.op}")
+
+    # ------------------
+
+    def __str__(self) -> str:
+        return f"""{self.__class__}: {self.left}={self.right}"""
+
+    def matches(self, *, skip=[]) -> bool:
+        if self in skip:
+            return True
+        if not self.left or not self.right:
+            return False
+        if not self.value:
+            b = None
+            if isinstance(self.left, Variable):
+                v = self.right.to_value(skip=skip)
+                self.matcher.set_variable(self.left.name, value=v)
+                b = True
+            else:
+                left = self.left.to_value(skip=skip)
+                right = self.right.to_value(skip=skip)
+                if left.__class__ == right.__class__:
+                    b = self.left.to_value(skip=skip) == self.right.to_value(skip=skip)
+                elif (left.__class__ == str and right.__class__ == int) or (
+                    right.__class__ == str and left.__class__ == int
+                ):
+                    b = f"{left}" == f"{right}"
+                else:
+                    b = f"{left}" == f"{right}"
+            self.value = b
+        return self.value
+
+    def to_value(self, *, skip=[]) -> Any:
+        if self.value is None:
+            if self.mathic():
+                pass
+                # self.perform_math()
+            self.value = self.matches(skip=skip)
+        return self.value

csvpath/matching/productions/expression.py

@@ -0,0 +1,16 @@
+from csvpath.matching.productions.matchable import Matchable
+
+
+class Expression(Matchable):
+    def matches(self, *, skip=[]) -> bool:
+        if not skip:
+            skip = []
+        if self in skip:
+            return True
+        if not self.value:
+            ret = True
+            for i, child in enumerate(self.children):
+                if not child.matches(skip=skip):
+                    ret = False
+            self.value = ret
+        return self.value

csvpath/matching/productions/header.py

@@ -0,0 +1,30 @@
+from typing import Any
+from csvpath.matching.productions.matchable import Matchable
+
+
+class Header(Matchable):
+    def __str__(self) -> str:
+        return f"""{self.__class__}: {self.name} """
+
+    def to_value(self, *, skip=[]) -> Any:
+        if self in skip:
+            return True
+        if isinstance(self.name, int):
+            if self.name >= len(self.matcher.line):
+                return None
+            else:
+                return self.matcher.line[self.name]
+        else:
+            n = self.matcher.header_index(self.name)
+            # print(f"Header.to_value: n: {n}, a {n.__class__}")
+            if n is None:
+                # print(f"Header.to_value: no such header {self.name}")
+                return None
+            # print(f"Header: header index: {self.name} = {n}, line: {self.matcher.line}")
+            ret = None
+            if self.matcher.line and len(self.matcher.line) > n:
+                ret = self.matcher.line[n]
+            return ret
+
+    def matches(self, *, skip=[]) -> bool:
+        return not self.to_value(skip=skip) is None

csvpath/matching/productions/matchable.py

@@ -0,0 +1,41 @@
+from typing import Any, Self
+from csvpath.matching.expression_utility import ExpressionUtility
+
+
+class Matchable:
+    def __init__(self, matcher, *, value: Any = None, name: str = None):
+        self.parent = None
+        self.children = []
+        self.matcher = matcher
+        self.value = value
+        self.name = name
+        self._id: str = None
+        if self.name and self.name.__class__ == str:
+            self.name = self.name.strip()
+
+    def __str__(self) -> str:
+        return f"""{self.__class__}"""
+
+    def matches(self, *, skip=[]) -> bool:
+        return True  # leave this for now for testing
+
+    def to_value(self, *, skip=[]) -> Any:
+        return None
+
+    def index_of_child(self, o) -> int:
+        return self.children.index(o)
+
+    def set_parent(self, parent: Self) -> None:
+        self.parent = parent
+
+    def add_child(self, child: Self) -> None:
+        if child:
+            child.set_parent(self)
+            if child not in self.children:
+                self.children.append(child)
+
+    def get_id(self, child: Self = None) -> str:
+        if not self._id:
+            thing = self if not child else child
+            self._id = ExpressionUtility.get_id(thing=thing)
+        return self._id

csvpath/matching/productions/term.py

@@ -0,0 +1,11 @@
+from typing import Any
+from csvpath.matching.productions.matchable import Matchable
+
+
+class Term(Matchable):
+    def __str__(self) -> str:
+        return f"""{self.__class__}: {self.value} """
+
+    def to_value(self, *, skip=[]) -> Any:
+        v = self.value
+        return v

csvpath/matching/productions/variable.py

@@ -0,0 +1,15 @@
+from typing import Any
+from csvpath.matching.productions.matchable import Matchable
+
+
+class Variable(Matchable):
+    def __str__(self) -> str:
+        return f"""{self.__class__}: {self.name}"""
+
+    def matches(self, *, skip=[]) -> bool:
+        return self.value is not None
+
+    def to_value(self, *, skip=[]) -> Any:
+        if not self.value:
+            self.value = self.matcher.get_variable(self.name)
+        return self.value

csvpath/parser_utility.py

@@ -0,0 +1,39 @@
+from ply.yacc import YaccProduction
+
+
+class ParserUtility:
+    def __init__(self, quiet=True):
+        self._quiet = quiet
+
+    def error(self, parser, p: YaccProduction) -> None:
+        if self._quiet and False:
+            return
+        # print(f"ParserUtility.error: {p}")
+        if p:
+            print(
+                f"syntax error at token {p.type}, line {p.lineno}, position {p.lexpos}"
+            )
+            print(f"unexpected token: {p.value}")
+            stack = parser.symstack
+            print(f"symbol stack: {stack}")
+        else:
+            print("syntax error at EOF")
+
+    def print_production(
+        self, p: YaccProduction, label: str = None, override=True
+    ) -> None:
+        if self._quiet and not override:
+            return
+        if label:
+            label = f" at {label}"
+        print(f"production array{label} is:")
+        for _ in p:
+            print(f"\t{_} \t-> {_.__class__}")
+
+    @classmethod
+    def enumerate_p(self, message, p, quiet=True):
+        if quiet:
+            return
+        print(f"Enumerate {p}: {message}:")
+        for i, _ in enumerate(p):
+            print(f"   p[{i}]: {_}")

csvpath/scanning/__init__.py

@@ -0,0 +1 @@
+

csvpath/scanning/parser.out

@@ -0,0 +1 @@
+Created by PLY version 3.11 (http://www.dabeaz.com/ply)

csvpath/scanning/parsetab.py

@@ -0,0 +1,231 @@
+# parsetab.py
+# This file is automatically generated. Do not edit.
+# pylint: disable=W,C,R
+_tabversion = "3.10"
+
+_lr_method = "LALR"
+
+_lr_signature = "pathALL_LINES ANY FILENAME LEFT_BRACKET MINUS NAME NUMBER PLUS RIGHT_BRACKET ROOTroot : ROOT filenamefilename : FILENAMEpath : root LEFT_BRACKET expression RIGHT_BRACKETexpression : expression PLUS term\n        | expression MINUS term\n        | termterm : NUMBER\n        | NUMBER ALL_LINES\n        | ALL_LINES"
+
+_lr_action_items = {
+    "ROOT": (
+        [
+            0,
+        ],
+        [
+            3,
+        ],
+    ),
+    "$end": (
+        [
+            1,
+            11,
+        ],
+        [
+            0,
+            -3,
+        ],
+    ),
+    "LEFT_BRACKET": (
+        [
+            2,
+            5,
+            6,
+        ],
+        [
+            4,
+            -1,
+            -2,
+        ],
+    ),
+    "FILENAME": (
+        [
+            3,
+        ],
+        [
+            6,
+        ],
+    ),
+    "NUMBER": (
+        [
+            4,
+            12,
+            13,
+        ],
+        [
+            9,
+            9,
+            9,
+        ],
+    ),
+    "ALL_LINES": (
+        [
+            4,
+            9,
+            12,
+            13,
+        ],
+        [
+            10,
+            14,
+            10,
+            10,
+        ],
+    ),
+    "RIGHT_BRACKET": (
+        [
+            7,
+            8,
+            9,
+            10,
+            14,
+            15,
+            16,
+        ],
+        [
+            11,
+            -6,
+            -7,
+            -9,
+            -8,
+            -4,
+            -5,
+        ],
+    ),
+    "PLUS": (
+        [
+            7,
+            8,
+            9,
+            10,
+            14,
+            15,
+            16,
+        ],
+        [
+            12,
+            -6,
+            -7,
+            -9,
+            -8,
+            -4,
+            -5,
+        ],
+    ),
+    "MINUS": (
+        [
+            7,
+            8,
+            9,
+            10,
+            14,
+            15,
+            16,
+        ],
+        [
+            13,
+            -6,
+            -7,
+            -9,
+            -8,
+            -4,
+            -5,
+        ],
+    ),
+}
+
+_lr_action = {}
+for _k, _v in _lr_action_items.items():
+    for _x, _y in zip(_v[0], _v[1]):
+        if not _x in _lr_action:
+            _lr_action[_x] = {}
+        _lr_action[_x][_k] = _y
+del _lr_action_items
+
+_lr_goto_items = {
+    "path": (
+        [
+            0,
+        ],
+        [
+            1,
+        ],
+    ),
+    "root": (
+        [
+            0,
+        ],
+        [
+            2,
+        ],
+    ),
+    "filename": (
+        [
+            3,
+        ],
+        [
+            5,
+        ],
+    ),
+    "expression": (
+        [
+            4,
+        ],
+        [
+            7,
+        ],
+    ),
+    "term": (
+        [
+            4,
+            12,
+            13,
+        ],
+        [
+            8,
+            15,
+            16,
+        ],
+    ),
+}
+
+_lr_goto = {}
+for _k, _v in _lr_goto_items.items():
+    for _x, _y in zip(_v[0], _v[1]):
+        if not _x in _lr_goto:
+            _lr_goto[_x] = {}
+        _lr_goto[_x][_k] = _y
+del _lr_goto_items
+_lr_productions = [
+    ("S' -> path", "S'", 1, None, None, None),
+    ("root -> ROOT filename", "root", 2, "p_root", "scanner.py", 64),
+    ("filename -> FILENAME", "filename", 1, "p_filename", "scanner.py", 67),
+    (
+        "path -> root LEFT_BRACKET expression RIGHT_BRACKET",
+        "path",
+        4,
+        "p_path",
+        "scanner.py",
+        71,
+    ),
+    (
+        "expression -> expression PLUS term",
+        "expression",
+        3,
+        "p_expression",
+        "scanner.py",
+        77,
+    ),
+    (
+        "expression -> expression MINUS term",
+        "expression",
+        3,
+        "p_expression",
+        "scanner.py",
+        78,
+    ),
+    ("expression -> term", "expression", 1, "p_expression", "scanner.py", 79),
+    ("term -> NUMBER", "term", 1, "p_term", "scanner.py", 90),
+    ("term -> NUMBER ALL_LINES", "term", 2, "p_term", "scanner.py", 91),
+    ("term -> ALL_LINES", "term", 1, "p_term", "scanner.py", 92),
+]