clex-py 0.1.0__tar.gz

clex_py-0.1.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: clex-py
+Version: 0.1.0
+Summary: An alternative to functional programming
+Author-email: cfarr2019@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file

clex_py-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=61.0.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "clex-py"
+version = "0.1.0"
+description = "An alternative to functional programming"
+readme = "README.md"
+requires-python = ">=3.8"
+authors = [
+    { name = "", email = "cfarr2019@gmail.com" }
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]

clex_py-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

clex_py-0.1.0/src/CLEX/engine.py

@@ -0,0 +1,42 @@
+class Engine:
+    def __init__(self, AST):
+        self.AST = AST
+    
+    def __call__(self, *inputs):
+        return self.eval(inputs)
+    
+    def eval(self, **inputs):
+        actions = {
+            'ADD': lambda x, y: [a + b for a, b in zip(x, y)],
+            'SUB': lambda x, y: [a - b for a, b in zip(x, y)],
+            'MUL': lambda x, y: [a * b for a, b in zip(x, y)],
+            'DIV': lambda x, y: [a / b for a, b in zip(x, y)],
+            'MOD': lambda x, y: [a % b for a, b in zip(x, y)],
+            
+            'EQ': lambda x, y: [a == b for a, b in zip(x, y)],
+            'GT': lambda x, y: [a > b for a, b in zip(x, y)],
+            'LT': lambda x, y: [a < b for a, b in zip(x, y)],
+            'GE': lambda x, y: [a >= b for a, b in zip(x, y)],
+            'LE': lambda x, y: [a <= b for a, b in zip(x, y)],
+            'NE': lambda x, y: [a != b for a, b in zip(x, y)],
+            
+            'IDX': lambda x, y: list(x[y]),
+            'PARSE': lambda x, y: [element for element, condition in zip(x, y) if condition],
+            'NPARSE': lambda x, y: [element for element, condition in zip(x, y) if not condition],
+            'IN': lambda x, y: list(set(x) & set(y)),
+            'NIN': lambda x, y: list(set(x) - set(y))
+        }
+        
+        _inputs = {**inputs}
+        _val_buffer = list()
+
+        for func in self.AST:
+            op, v1, v2, ret = func
+            input = _inputs[v1[1]]
+            is_v2_input = (v2[0] == 'INPUT')
+            v2_data = _inputs[v2[1]] if is_v2_input else [v2[1]] * len(input)
+
+            _val_buffer = actions[op](input, v2_data)
+            _inputs[ret] = _val_buffer
+
+        return _val_buffer

clex_py-0.1.0/src/CLEX/parser.py

@@ -0,0 +1,139 @@
+# (x + y; r)
+# () define the function
+# letters define inputs or values to be processed
+# a function is composed of 1+inputs, an operation a value, and a return value
+# (input1 op constant or input)
+# @ could retrieve the element at index v2 e.g: (x @ 2:)
+
+# {} could define the use of outside functions exposed to the engine
+
+from string import digits, ascii_letters, punctuation
+from engine import Engine
+
+class ParserError(Exception):
+    pass
+
+
+def expression(functions):
+    parser = {
+        "split_values": [c for c in ascii_letters + digits],
+        "funcs": _get_functions(functions),
+        "cursor": 0,
+        "AST": [],
+    }
+
+    while _should_parse(parser):
+        _match(parser, '(')
+        parser["AST"].append(_parse_expression(parser))
+        _match(parser, ')')
+
+    return Engine(parser["AST"]).eval
+
+
+def _parse_value_or_input(parser):
+    if _current(parser) in ascii_letters:
+        var_name = _match(parser, parser["split_values"])
+        return ('INPUT', var_name)
+
+    val = _match(parser, digits)
+    return ('VALUE', int(val))
+
+
+def _parse_return(parser):
+    match _current(parser):
+        case ':':
+            _next(parser)
+            return '_'
+        case ';':
+            _next(parser)
+            return _match(parser, ascii_letters)
+        case _:
+            raise ParserError(f"Expected ';' or ':' instead got {_current(parser)}")
+
+
+def _parse_expression(parser):
+    OP_MAP = {
+        '+': 'ADD',
+        '-': 'SUB',
+        '*': 'MUL',
+        '/': 'DIV',
+        '%': 'MOD',
+        '>': 'GT',
+        '<': 'LT',
+        '>=': 'GE',
+        '<=': 'LE',
+        '=': 'EQ',
+        '!=': 'NE',
+        '@': 'IDX',
+        '&': 'PARSE',
+        '!&': 'NPARSE',
+        '^': 'IN',
+        '!^': 'NIN',
+    }
+    sorted_ops = sorted(OP_MAP.keys(), key=len, reverse=True)
+
+    v1 = _parse_value_or_input(parser)
+    op = OP_MAP[_match(parser, sorted_ops)]
+    v2 = _parse_value_or_input(parser)
+    ret = _parse_return(parser)
+
+    return (op, v1, v2, ret)
+
+
+def _should_parse(parser):
+    return parser["cursor"] < len(parser["funcs"])
+
+
+def _next(parser):
+    parser["cursor"] += 1
+    return _current(parser)
+
+
+def _current(parser) -> str:
+    if parser["cursor"] >= len(parser["funcs"]):
+        return ""
+    return parser["funcs"][parser["cursor"]]
+
+
+def _match(parser, *expected):
+    expected_set = {i for e in expected for i in (e if isinstance(e, (list, tuple, str)) else [e])}
+
+    current_token = _current(parser)
+    if current_token in expected_set:
+        _next(parser)
+        return current_token
+
+    raise ParserError(f"Expected {expected} instead got {current_token}")
+
+
+def _get_functions(expr_input: str):
+    funcs = expr_input.split('->')
+    tokens = []
+
+    valid_operators = {"+", "-", "*", "/", "%", ">", "<", '^', '!^', ">=", "<=", "=", "!=", "@", "&", "!&"}
+    valid_prefixes = {op[:i] for op in valid_operators for i in range(1, len(op) + 1)}
+
+    for func in funcs:
+        buffer = ""
+        for c in func:
+            if not c.strip():
+                if buffer:
+                    tokens.append(buffer)
+                    buffer = ""
+                continue
+
+            if c in punctuation:
+                if buffer and (buffer + c) not in valid_prefixes:
+                    tokens.append(buffer)
+                    buffer = ""
+                buffer += c
+            else:
+                if buffer:
+                    tokens.append(buffer)
+                    buffer = ""
+                tokens.append(c)
+
+        if buffer:
+            tokens.append(buffer)
+
+    return tokens

clex_py-0.1.0/src/clex_py.egg-info/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: clex-py
+Version: 0.1.0
+Summary: An alternative to functional programming
+Author-email: cfarr2019@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file

clex_py-0.1.0/src/clex_py.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+src/CLEX/__init__.py
+src/CLEX/engine.py
+src/CLEX/parser.py
+src/clex_py.egg-info/PKG-INFO
+src/clex_py.egg-info/SOURCES.txt
+src/clex_py.egg-info/dependency_links.txt
+src/clex_py.egg-info/top_level.txt

clex_py-0.1.0/src/clex_py.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

clex_py-0.1.0/src/clex_py.egg-info/top_level.txt

@@ -0,0 +1 @@
+CLEX