enumsync 0.1.0__tar.gz

enumsync-0.1.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.3
+Name: enumsync
+Version: 0.1.0
+Summary: Add your description here
+Author: elda27
+Author-email: elda27 <kaz.birdstick@gmail.com>
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+

enumsync-0.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[project]
+name = "enumsync"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+authors = [{ name = "elda27", email = "kaz.birdstick@gmail.com" }]
+requires-python = ">=3.14"
+dependencies = []
+
+[project.scripts]
+enumsync = "enumsync:main"
+
+[build-system]
+requires = ["uv_build>=0.9.25,<0.10.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = ["jinja2>=3.1.6", "pytest>=9.0.2", "ruff>=0.15.6", "ty>=0.0.23"]

enumsync-0.1.0/src/enumsync/__init__.py

@@ -0,0 +1 @@
+from enumsync.store import FileStore

enumsync-0.1.0/src/enumsync/store.py

@@ -0,0 +1,99 @@
+from pathlib import Path
+from typing import TYPE_CHECKING, Generic, Iterable, TypeVar
+
+try:
+    from jinja2 import Template
+
+    ENABLE_JINJA2 = True
+except ImportError:
+
+    class Template:
+        pass
+
+    ENABLE_JINJA2 = False
+if TYPE_CHECKING:
+    from enum import StrEnum
+
+TEnum = TypeVar("TEnum", bound="StrEnum")
+
+
+class FileStore(Generic[TEnum]):
+    def __init__(self, path: str):
+        """Store object in file
+
+        Args:
+            path (str): Set `__file__` or its parent directory. Path to the file where the object will be stored
+
+        Example:
+            There is automatic syncing enum by the store in the file.
+            ```python
+            from enumsync import FileStore
+
+            store = FileStore(__file__)
+            ```
+        """
+        _path = Path(path)
+        if _path.is_dir():
+            folder = _path
+            file = _path / "__init__.py"
+        else:
+            folder = _path.parent
+            file = Path(path)
+        self.file = file
+        self.folder = folder
+
+    def sync(self, output: str | Path | None = None) -> None:
+        """Generate a typed module that mirrors the files in the store folder.
+
+        Args:
+            output: Optional path for the generated module. Relative paths are
+                resolved from the store folder.
+        """
+        from enumsync.sync import generate_sync_code
+
+        code = generate_sync_code(self)
+        if output is None:
+            output_path = self.file
+        else:
+            output_path = Path(output)
+            if not output_path.is_absolute():
+                output_path = self.folder / output_path
+
+        output_path.write_text(code, encoding="utf-8")
+
+    def get_text(self, value: TEnum) -> str:
+        """Get the file path
+
+        Returns:
+            str: The file path where the object is stored
+        """
+        return (self.folder / str(value)).read_text()
+
+    def get_template(self, value: TEnum) -> "Template":
+        """Get the template file path
+
+        Returns:
+            Template: The template file path where the object is stored
+        """
+        if not ENABLE_JINJA2:
+            raise ImportError(
+                "Jinja2 is not installed. Please install it to use this feature."
+            )
+
+        from jinja2 import Environment, FileSystemLoader, select_autoescape
+
+        env = Environment(
+            loader=FileSystemLoader(self.folder), autoescape=select_autoescape()
+        )
+        return env.get_template(str(value))
+
+    def glob(self, pattern: str) -> Iterable[Path]:
+        """Glob the file path
+
+        Args:
+            pattern (str): The glob pattern to match files
+
+        Returns:
+            Iterable[Path]: An iterable of file paths that match the glob pattern
+        """
+        return self.folder.glob(pattern)

enumsync-0.1.0/src/enumsync/sync.py

@@ -0,0 +1,148 @@
+import ast
+import re
+from ast import (
+    AnnAssign,
+    Assign,
+    ClassDef,
+    Constant,
+    Expr,
+    ImportFrom,
+    List,
+    Load,
+    Module,
+    Name,
+    Store,
+    Subscript,
+    alias,
+)
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from typing import TYPE_CHECKING, Iterable
+
+if TYPE_CHECKING:
+    from enumsync.store import FileStore
+else:
+    FileStore = object
+try:
+    import ruff
+except ImportError:
+    ruff = None
+
+
+def to_pascal(name: str) -> str:
+    parts = re.split(r"[^0-9A-Za-z]+", name)
+    return "".join(part.capitalize() for part in parts if part)
+
+
+IMPORT_BLOCKS = [
+    ImportFrom(module="enum", names=[alias(name="StrEnum")], level=0),
+    ImportFrom(module="typing", names=[alias(name="TypeAlias")], level=0),
+    ImportFrom(module="enumsync", names=[alias(name="FileStore")], level=0),
+]
+
+
+class ModuleBuilder:
+    def define_import_blocks(self) -> list[ImportFrom]:
+        return IMPORT_BLOCKS
+
+    def define_enum_sync_block(
+        self, store: FileStore, glob: Iterable[Path]
+    ) -> ClassDef:
+        prefix = to_pascal(store.folder.name) or "Synced"
+        enum_body = {
+            to_pascal(path.name): path.relative_to(store.folder).as_posix()
+            for path in glob
+            if path.is_file() and path.name != "__init__.py"
+        }
+        return ClassDef(
+            name=f"{prefix}Enum",
+            bases=[Name(id="StrEnum", ctx=Load())],
+            keywords=[],
+            body=[
+                *[
+                    Assign(
+                        targets=[Name(id=name, ctx=Store())],
+                        value=Constant(value=value),
+                    )
+                    for name, value in enum_body.items()
+                ]
+            ],
+            decorator_list=[],
+            type_params=[],
+        )
+
+    def define_comment_block(self) -> Expr:
+        return ast.parse(
+            '"""This file is auto-generated by enumsync. Do not edit this file directly."""'
+        ).body[
+            0
+        ]  # type: ignore
+
+    def define_sync_block(self) -> Expr:
+        return ast.parse("FileStore(__file__).sync()").body[0]  # type: ignore
+
+    def define_domain_file_sotre(self, store: FileStore) -> AnnAssign:
+        prefix = to_pascal(store.folder.name)
+
+        return AnnAssign(
+            target=Name(id=f"{prefix}FileStore", ctx=Store()),
+            annotation=Name(id="TypeAlias", ctx=Load()),
+            value=Subscript(
+                value=Name(id="FileStore", ctx=Load()),
+                slice=Name(id=f"{prefix}Enum", ctx=Load()),
+                ctx=Load(),
+            ),
+            simple=1,
+        )
+
+    def define_export_all_block(self, store: FileStore) -> Assign:
+        prefix = to_pascal(store.folder.name)
+        return Assign(
+            targets=[Name(id="__all__", ctx=Store())],
+            value=List(
+                elts=[
+                    Constant(value=f"{prefix}Enum"),
+                    Constant(value=f"{prefix}FileStore"),
+                ],
+                ctx=Load(),
+            ),
+        )
+
+    def define(self, store: FileStore) -> Module:
+        module = Module(
+            body=[
+                self.define_comment_block(),
+                *self.define_import_blocks(),
+                self.define_enum_sync_block(store, store.glob("*.*")),
+                self.define_sync_block(),
+                self.define_domain_file_sotre(store),
+                self.define_export_all_block(store),
+            ],
+            type_ignores=[],
+        )
+        return ast.fix_missing_locations(module)
+
+
+def generate_sync_code(store: FileStore) -> str:
+    builder = ModuleBuilder()
+    module = builder.define(store)
+    code = ast.unparse(module)
+    try:
+        format_code(code)
+    except Exception:
+        pass
+    return code
+
+
+def format_code(code: str) -> str:
+    if ruff is None:
+        return code
+    from ruff import find_ruff_bin
+
+    with TemporaryDirectory() as temp_dir:
+        temp_path = Path(temp_dir) / "temp.py"
+        temp_path.write_text(code, encoding="utf-8")
+        ruff_bin = find_ruff_bin()
+        subprocess.check_call([ruff_bin, "format", temp_path])
+        code = temp_path.read_text(encoding="utf-8")
+    return code