socx-cli 0.1.0__py3-none-any.whl

src/socx/tokenizer.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import re
+import abc
+from typing import Self
+from typing import override
+from dataclasses import dataclass
+
+from dynaconf.utils.boxing import DynaBox
+
+from .config import settings
+
+
+class Tokenizer(abc.ABC):
+    """Convert text to tokens."""
+
+    def __init__(self) -> None:
+        self._matchs = {}
+        self._token_map = {token.name: token for token in self.tokens}
+
+    @property
+    def cfg(self) -> DynaBox:
+        return settings.lang.get(self.lang)
+
+    @property
+    @abc.abstractmethod
+    def lang(self) -> DynaBox: ...
+
+    @property
+    def tokens(self) -> DynaBox:
+        return self.cfg.tokens
+
+    @property
+    def token_map(self) -> dict[str, DynaBox]:
+        return self._token_map
+
+    @abc.abstractmethod
+    def tokenize(self: Self, text: str) -> tuple[re.Match]: ...
+
+
+@dataclass(unsafe_hash=True)
+class LstTokenizer(Tokenizer):
+
+    def __init__(self) -> None:
+        super().__init__()
+
+    @override
+    @property
+    def lang(self) -> DynaBox:
+        return "lst"
+
+    @override
+    def tokenize(self, text: str) -> tuple[re.Match]:
+        matches = []
+        flags = re.MULTILINE | re.DOTALL | re.VERBOSE
+        template = "|".join(
+            "(?P<%s>%s)" % (token.name, token.expr)
+            for token in self.tokens
+        )
+        pattern = re.compile(template, flags)
+        for line in text.splitlines():
+            matches.extend(match for match in pattern.finditer(line))
+        return tuple(matches)

src/socx/validators.py

@@ -0,0 +1,57 @@
+import typing as t
+from pathlib import Path as Path
+
+__all__ = ("PathValidator",)
+
+
+class PathValidator:
+    src: t.ClassVar[Path] = None
+    target: t.ClassVar[Path] = None
+
+    @classmethod
+    def source_validator(cls, src: str | Path) -> bool:
+        if not isinstance(src, Path):
+            src = Path(src)
+        return src.exists() and src.is_dir()
+
+    @classmethod
+    def target_validator(cls, target: str | Path) -> bool:
+        if not isinstance(target, Path):
+            target = Path(target)
+        return target.is_dir() or not target.exists()
+
+    @classmethod
+    def includes_validator(
+        cls,
+        src: Path,
+        includes: list[str] | set[str] | tuple[str, ...],
+        excludes: list[str] | set[str] | tuple[str, ...],
+    ) -> bool:
+        if not includes:
+            return False
+        if not isinstance(src, Path):
+            src = Path(src)
+        if not isinstance(includes, list | set | tuple):
+            return False
+        paths = cls._extract_includes(src, includes, excludes)
+        return bool(paths) and all(path.is_file() for path in paths)
+
+    @classmethod
+    def _extract_includes(
+        cls, src: Path, includes: set[Path], excludes: set[Path]
+    ) -> set[Path]:
+        paths = set()
+        globpaths = set()
+        if not isinstance(src, Path):
+            src = Path(src)
+        for include in includes:
+            if "*" not in include:
+                paths.add(Path(src / include))
+            else:
+                globpaths = globpaths.union(set(src.glob(str(include))))
+        for exclude in excludes:
+            if "*" not in exclude:
+                paths.discard(Path(src / exclude))
+            else:
+                globpaths.difference_update(set(src.glob(str(exclude))))
+        return paths.union(globpaths)

src/socx/visitor.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from typing import Protocol
+
+
+__all__ = (
+    "Node",
+    "Visitor",
+    "Structure",
+    "Proxy",
+    "Adapter",
+    "TopDownTraversal",
+    "BottomUpTraversal",
+    "ByLevelTraversal",
+)
+
+
+class Node[NODE](Protocol):
+    def accept(self, v: Visitor[NODE]) -> None:
+        """Accept a visit from a visitor."""
+        ...
+
+
+class Visitor[NODE](Protocol):
+    def visit(self, n: NODE) -> None:
+        """Visit a node."""
+        ...
+
+
+class Structure[NODE](Protocol):
+    def children(self) -> list[NODE]:
+        """Retrieve the immediate child nodes of a structure."""
+        ...
+
+
+class Proxy[NODE](Protocol):
+    def children(self, n: NODE) -> list[NODE]:
+        """Retrieve the immediate children of a node in a structure."""
+        ...
+
+
+class Adapter[NODE](Protocol):
+    def accept(self, n: NODE, v: Visitor[NODE], p: Proxy[NODE]) -> None:
+        """Adapt a visitor to visit a structure of nodes through a proxy."""
+        ...
+
+
+class TopDownTraversal[NODE](Adapter):
+    def accept(self, n: NODE, v: Visitor[NODE], p: Proxy[NODE]) -> None:
+        n.accept(v)
+        for c in p.children(v):
+            self.accept(c, v, p)
+
+
+class BottomUpTraversal[NODE](Adapter):
+    def accept(self, n: NODE, v: Visitor[NODE], p: Proxy[NODE]) -> None:
+        for c in p.children(v):
+            self.accept(c, v, p)
+        v.visit(n)
+
+
+class ByLevelTraversal[NODE](Adapter[NODE]):
+    def accept(self, n: NODE, v: Visitor[NODE], p: Proxy[NODE]) -> None:
+        q = [n]
+        while q:
+            t = []
+            for n_ in q:
+                v.visit(n_)
+                t.extend(p.children(n_))
+            q = t

src/socx/writer.py

@@ -0,0 +1,58 @@
+import abc
+from typing import override
+from pathlib import Path
+from dataclasses import field
+from dataclasses import dataclass
+
+from .log import logger
+
+
+@dataclass
+class Writer[T](abc.ABC):
+    """Writes data to a target."""
+
+    @abc.abstractmethod
+    def write(self, data: T) -> None:
+        """Write data to a target."""
+        ...
+
+
+@dataclass
+class FileWriter[T](Writer):
+    """
+    Writes data to a file.
+
+    Members
+    -------
+    target: Path
+        Target to write to.
+
+    options: dict
+        Options for handling write requests.
+    """
+
+    target: Path
+    options: dict[str, str] = field(default_factory=dict)
+
+    @override
+    def write(self, data: str, filename: str) -> None:
+        target = Path(self.target)/filename
+        if target.exists():
+            target.replace(target.with_suffix(".backup"))
+        target.write_text(data)
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.target, Path):
+            self.target = Path(self.target)
+        if self.target.exists() and self.target.is_file():
+            self._invalid_target_err()
+        self.target.mkdir(parents=True, exist_ok=True)
+
+    def _invalid_target_err(self) -> None:
+        err = (
+            f"Invalid target: '{self.target}'"
+            "Target path must point to a directory, not a file."
+        )
+        exc = ValueError(err)
+        logger.exception(err, exc_info=exc)
+        raise exc

src/socx-tui/app.py

@@ -0,0 +1,7 @@
+from textual.app import App, ComposeResult
+from textual import on, work
+from socx import settings
+
+
+class SoCX(App):
+    pass