tagify 0.0.1__py3-none-any.whl

tagify/__init__.py

@@ -0,0 +1,4 @@
+__version__ = "0.0.1"
+
+# flake8: noqa
+from .parser import *

tagify/parser.py

@@ -0,0 +1,145 @@
+import re
+
+from typing import Any, Callable
+
+# RegEx patterns
+_re_placeholder = re.compile(r"{\s*([\w\d\.]+|\w+\(.+?\))\s*}")
+_re_blocks = re.compile(r"{% elif (.+?) %}|{% else %}")
+_re_terms = re.compile(r"(\s&&\s|\s\|\|\s)")
+_re_match = re.compile(r"([\w\(\),]+)\s*(==|!=)\s*(.+)")
+_re_variables = re.compile(r"{% set ([\w\d]+)\s*=\s*(.*) %}")
+_re_conditions = re.compile(r"{% elif (.+?) %}")
+_re_conditional_pattern = re.compile(
+    r"{% if (.+?) %}(.+?){% endif %}",
+    flags=re.DOTALL
+)
+
+__all__ = (
+    "TemplateParser",
+)
+
+
+class TemplateParser:
+    def __init__(
+        self,
+        context: dict | None = None,
+        functions: dict | None = None,
+        *,
+        conditionals: bool = True,
+    ):
+        self.context: dict[str, Any] = context or {}
+        self.functions: dict[str, Callable] = functions or {}
+
+        self._conditionals = conditionals
+
+    def render(self, template: str) -> str:
+        """Render the template with placeholders, conditionals, and function calls."""
+        template = self._process_variables(template)  # Replace variables
+
+        if self._conditionals:
+            template = self._process_conditionals(template)  # Process if/else/elif blocks
+
+        template = self._process_placeholders(template)  # Replace placeholders and function calls
+        return template.strip()  # Remove any trailing whitespace
+
+    def _process_variables(self, template: str) -> str:
+        """Replace all variables in the template with their values."""
+        for match in _re_variables.finditer(template):
+            key, value = match.groups()
+            self.context[key.strip()] = value.strip()
+
+        return _re_variables.sub("", template)
+
+    def _parse_placeholder(self, key: str) -> str:
+        """Evaluate placeholders or function calls."""
+        safe_unused = "{" + str(key) + "}"
+        # Check if the placeholder is a function call
+        if "(" in key and key.endswith(")"):
+            func_name, args = self._parse_function_call(key)
+            if func_name in self.functions:
+                try:
+                    return str(self.functions[func_name](*args))
+                except Exception as e:
+                    return f"[ FUNC_ERR:{func_name}: {e} ]"
+            return safe_unused  # Return unmodified if function not found
+
+        # Split the key by dots and try to access each part as an attribute
+        parts = key.split(".")
+        value = self.context.get(parts[0], safe_unused)  # Start with the base context
+
+        try:
+            for part in parts[1:]:
+                value = value[part]  # Dig into each nested dict value
+        except KeyError:
+            return safe_unused  # Return as-is if any part is inaccessible
+
+        return str(value)
+
+    def _process_placeholders(self, template: str) -> str:
+        """Replace all placeholders in the template with their values."""
+        return _re_placeholder.sub(
+            lambda m: self._parse_placeholder(m.group(1)),
+            template
+        )
+
+    def _process_conditionals(self, template: str) -> str:
+        """Handle if, elif, else conditionals in the template."""
+        return _re_conditional_pattern.sub(
+            self._evaluate_conditional_block,
+            template
+        )
+
+    def _evaluate_conditional_block(self, match: re.Match) -> str:
+        """Evaluate if, elif, and else conditions and return the appropriate block."""
+        condition, content = match.groups()
+        blocks = _re_blocks.split(content)
+        conditions = [condition] + _re_conditions.findall(content)
+
+        for cond, block in zip(conditions, blocks):
+            if self._evaluate_condition(cond.strip()):
+                return block.strip()
+
+        return blocks[-1].strip() if "{% else %}" in content else ""
+
+    def _evaluate_condition(self, condition: str) -> bool:
+        """Evaluate conditions safely without using eval."""
+        # Split by logical operators and evaluate each subcondition
+        terms = _re_terms.split(condition)
+        result = self._evaluate_comparison(terms[0].strip())
+
+        for i in range(1, len(terms), 2):
+            operator = terms[i].strip()
+            next_term = self._evaluate_comparison(terms[i + 1].strip())
+
+            if operator == "&&":
+                result = result and next_term
+            elif operator == "||":
+                result = result or next_term
+
+        return result
+
+    def _evaluate_comparison(self, term: str) -> bool:
+        """Evaluate a single comparison expression like 'user == "Alice"'."""
+        match = _re_match.match(term)
+        if not match:
+            return False
+
+        left, operator, right = match.groups()
+        left_value = str(self.context.get(left, left))
+        right_value = right.strip('"').strip("'")
+
+        if left_value.isdigit() and right_value.isdigit():
+            left_value = int(left_value)
+            right_value = int(right_value)
+
+        if operator == "==":
+            return left_value == right_value
+        elif operator == "!=":
+            return left_value != right_value
+
+    def _parse_function_call(self, func_string: str) -> tuple[str, list[str]]:
+        """Parse function calls like 'func_name(arg1, arg2)'."""
+        func_name = func_string.split("(", 1)[0]
+        args_string = func_string[len(func_name) + 1:-1]  # Remove function name and parentheses
+        args = [arg.strip().strip('"').strip("'") for arg in args_string.split(",")]
+        return func_name, args

tagify-0.0.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 xelA
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tagify-0.0.1.dist-info/METADATA

@@ -0,0 +1,34 @@
+Metadata-Version: 2.1
+Name: tagify
+Version: 0.0.1
+Summary: Parser that converts strings with variables and functions to more advance strings
+Author-email: AlexFlipnote <root@alexflipnote.dev>
+License: MIT
+Project-URL: Repository, https://github.com/xelA/tagify
+Keywords: discord,tag,parser,template
+Requires-Python: >=3.11.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pyright; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: toml; extra == "dev"
+Provides-Extra: maintainer
+Requires-Dist: twine; extra == "maintainer"
+Requires-Dist: wheel; extra == "maintainer"
+Requires-Dist: build; extra == "maintainer"
+
+# tagify
+Parser that converts strings with variables and functions to more advance strings
+
+Style is a bit inspired by jinja2 format, but not 100% the same.
+
+This project is very early development, I might use it or not, but I'm not sure.
+
+## Requirements
+- Python >=3.11
+
+## Install
+```
+pip install tagify
+```

tagify-0.0.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+tagify/__init__.py,sha256=7EjfU5y2I9WRREjs0VbewSxcMwnOI3xTHCRukRoCopw,64
+tagify/parser.py,sha256=70nPgtVuD-ivJPQ8VI9K3rleRm2199np5DbVqqLPBgk,5630
+tagify-0.0.1.dist-info/LICENSE,sha256=XjgX6hq_173pwLEhPGC9IoSLGeHooNG0a3LHBj8tTps,1082
+tagify-0.0.1.dist-info/METADATA,sha256=1ju_8UpIMsvFxa7BSGV1qkL10Wlu_G_zlF_QEBJiQYo,1025
+tagify-0.0.1.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+tagify-0.0.1.dist-info/top_level.txt,sha256=4L8Fez5sONVYp7vZ5h-9ZXHxFwy8iPC-dOD_vDeI_2w,7
+tagify-0.0.1.dist-info/RECORD,,

tagify-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.3.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

tagify-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+tagify