tagify 0.0.1__tar.gz

tagify-0.0.1/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,14 @@
+# 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/pyproject.toml

@@ -0,0 +1,61 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.pdm.source]
+name = "public"
+url = "https://github.com/xelA/tagify"
+
+[project]
+name = "tagify"
+description = "Parser that converts strings with variables and functions to more advance strings"
+requires-python = ">=3.11.0"
+license = {text = "MIT"}
+
+dynamic = ["version"]
+readme = "README.md"
+keywords = ["discord", "tag", "parser", "template"]
+authors = [{name = "AlexFlipnote", email = "root@alexflipnote.dev"}]
+
+dependencies = []
+
+[project.urls]
+Repository = "https://github.com/xelA/tagify"
+
+[project.optional-dependencies]
+dev = ["pyright", "flake8", "toml"]
+maintainer = ["twine", "wheel", "build"]
+
+[tool.setuptools]
+packages = [
+  "tagify",
+]
+
+[tool.setuptools.dynamic]
+version = {attr = "tagify.__version__"}
+readme = {file = ["README.md"]}
+
+[tool.flake8]
+max-line-length = 128
+ignore = [
+  "D210", "D400", "D401", "D100", "D202", "D413", "D107",
+  "D101", "D103", "D102", "E121", "D205", "D209", "D105",
+  "E252", "W605", "W504", "E128", "E124", "E999", "W504"
+]
+
+[tool.pyright]
+reportOptionalOperand = "none"
+reportOptionalSubscript = "none"
+reportOptionalMemberAccess = "none"
+reportUnnecessaryTypeIgnoreComment = "warning"
+typeCheckingMode = "basic"
+pythonVersion = "3.11"
+
+include = [
+  "tagify",
+]
+
+exclude = [
+  "**/__pycache__", "**/*.pyc", "*.egg-info",
+  ".venv", "build", "docs", "dist",
+]

tagify-0.0.1/setup.cfg

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

tagify-0.0.1/tagify/__init__.py

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

tagify-0.0.1/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/tagify.egg-info/PKG-INFO

@@ -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/tagify.egg-info/SOURCES.txt

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

tagify-0.0.1/tagify.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tagify-0.0.1/tagify.egg-info/requires.txt

@@ -0,0 +1,10 @@
+
+[dev]
+pyright
+flake8
+toml
+
+[maintainer]
+twine
+wheel
+build

tagify-0.0.1/tagify.egg-info/top_level.txt

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