feat: Initial commit

Author: tkarabela

.github/workflows/main.yml

@@ -0,0 +1,44 @@
+# This is a basic workflow to help you get started with Actions
+
+name: CI
+
+# Controls when the workflow will run
+on:
+  # Triggers the workflow on push or pull request events but only for the "master" branch
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+jobs:
+  run-tests:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
+
+    steps:
+    - uses: actions/checkout@v5
+
+    - name: Install uv and set the python version
+      uses: astral-sh/setup-uv@v6
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Install the project
+      run: |
+        uv sync --all-extras --dev
+        uv pip install -e .
+
+    - name: Typecheck with mypy
+      run: uv run mypy
+
+    - name: Check with ruff
+      run: uv run ruff check
+
+    - name: Test with pytest
+      run: uv run pytest

.gitignore

@@ -0,0 +1,4 @@
+/.idea/
+/temp/
+
+*.py[co]

LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2025 Tomas Karabela
+
+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.

README.md

@@ -0,0 +1,3 @@
+regex-automata
+==============
+

pyproject.toml

@@ -0,0 +1,60 @@
+[project]
+name = "regex-automata"
+description = "Library for regular expressions using finite automata"
+readme = "README.md"
+authors = [{name = "Tomas Karabela", email = "tkarabela@seznam.cz"}]
+license = "MIT"
+license-files = ["LICENSE.txt"]
+requires-python = ">=3.10"
+dependencies = [
+    "graphviz~=0.21",
+]
+dynamic = ["version"]
+keywords = ["regular expressions", "regex", "finite automata"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Text Processing",
+    "Typing :: Typed",
+]
+
+[project.urls]
+Homepage = "https://github.com/tkarabela/regex-automata"
+Repository = "https://github.com/tkarabela/regex-automata.git"
+Issues = "https://github.com/tkarabela/regex-automata/issues"
+
+[dependency-groups]
+dev = [
+    "mypy~=1.18",
+    "pytest~=8.4",
+    "pytest-cov~=7.0",
+    "ruff~=0.13",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+path = "src/regex_automata/__init__.py"
+
+[tool.hatch.build.targets.sdist]
+exclude = [
+    "/.github",
+]
+
+[tool.mypy]
+strict = "True"
+mypy_path = "$MYPY_CONFIG_FILE_DIR/src"
+files = "src/**/*.py, tests/*.py"
+
+[[tool.mypy.overrides]]
+module = "tests.*"
+disallow_incomplete_defs = "False"
+disallow_untyped_defs = "False"

src/regex_automata/__init__.py

@@ -0,0 +1,19 @@
+from .pattern import Pattern
+
+__version__ = "0.1.0"
+
+
+def fullmatch(pattern: str, s: str) -> bool:
+    return Pattern(pattern).fullmatch(s)
+
+
+def match(pattern: str, s: str) -> bool:
+    return Pattern(pattern).match(s)
+
+
+def search(pattern: str, s: str) -> bool:
+    return Pattern(pattern).search(s)
+
+
+def compile(pattern: str) -> Pattern:
+    return Pattern(pattern)

src/regex_automata/automata/__init__.py

@@ -0,0 +1,118 @@
+from dataclasses import dataclass
+from typing import Self, Any, Iterable
+import json
+from abc import ABC, abstractmethod
+from itertools import count
+
+from ..common import PathOrStr
+
+
+class FiniteAutomaton(ABC):
+    """Base class for finite automata"""
+    @abstractmethod
+    def accepts(self, s: str) -> bool:
+        raise NotImplementedError
+
+    @classmethod
+    def from_file(cls, path: PathOrStr) -> Self:
+        with open(path) as fp:
+            data = json.load(fp)
+            return cls.from_dict(data)
+
+    @classmethod
+    @abstractmethod
+    def from_dict(cls, data: dict[str, Any]) -> Self:
+        raise NotImplementedError
+
+    def to_file(self, path: PathOrStr) -> None:
+        data = self.to_dict()
+        with open(path, "w") as fp:
+            json.dump(data, fp, indent=4)
+
+    @abstractmethod
+    def to_dict(self) -> dict[str, Any]:
+        raise NotImplementedError
+
+
+@dataclass
+class NFA(FiniteAutomaton):
+    """
+    Non-deterministic finite automaton
+
+    Bonus I: support epsilon transitions (transition that "reads empty string") - DONE
+    """
+    states: list[int]
+    initial_state: int
+    final_states: list[int]
+    transitions: dict[int, dict[str, set[int]]]
+
+    class Evaluator:
+        def __init__(self, nfa: "NFA") -> None:
+            self.nfa = nfa
+            self.states: set[int] = self.nfa.epsilon_closure({nfa.initial_state})
+
+        def step(self, c: str) -> None:
+            new_states = set()
+            for u in self.states:
+                new_states.update(self.nfa.transitions.get(u, {}).get(c, set()))
+
+            self.states = self.nfa.epsilon_closure(new_states)
+
+    def accepts(self, s: str) -> bool:
+        evaluator = self.Evaluator(self)
+        for c in s:
+            evaluator.step(c)
+        return len(evaluator.states.intersection(self.final_states)) > 0
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Self:
+        transitions: dict[int, dict[str, set[int]]] = {}
+        for u, c, v in data["transitions"]:
+            transitions.setdefault(u, {}).setdefault(c, set()).add(v)
+
+        return cls(
+            states=data["states"],
+            initial_state=data["initial_state"],
+            final_states=data["final_states"],
+            transitions=transitions,
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        transitions = []
+        for u, tmp in self.transitions.items():
+            for c, vs in tmp.items():
+                for v in vs:
+                    transitions.append([u, c, v])
+
+        return {
+            "states": self.states,
+            "initial_state": self.initial_state,
+            "final_states": self.final_states,
+            "transitions": transitions,
+        }
+
+    def copy(self) -> "NFA":
+        return self.from_dict(self.to_dict())
+
+    def renumber_states(self, x0: int) -> "NFA":
+        f = dict(zip(self.states, count(x0)))
+        return NFA(
+            states=[f[x] for x in self.states],
+            initial_state=f[self.initial_state],
+            final_states=[f[x] for x in self.final_states],
+            transitions={
+                f[x]: {c: {f[y] for y in ys} for c, ys in d.items()}
+                for x, d in self.transitions.items()
+            },
+        )
+
+    def epsilon_closure(self, states: Iterable[int]) -> set[int]:
+        closure = set(states)
+        while True:
+            new_closure = closure
+            for u in closure:
+                new_closure = new_closure | self.transitions.get(u, {}).get("", set())
+            if len(closure) == len(new_closure):
+                break
+            closure = new_closure
+        return closure

src/regex_automata/automata/nfa.py

@@ -0,0 +1,26 @@
+import graphviz  # type: ignore[import-untyped]
+
+from .nfa import NFA
+
+
+class NFAVisualizer:
+    def __init__(self, nfa: NFA) -> None:
+        self.nfa = nfa
+
+    def get_digraph_dot(self) -> graphviz.Digraph:
+        g = graphviz.Digraph()
+        g.attr(rankdir='LR')
+        g.node("", shape="none")
+        for u in self.nfa.states:
+            g.node(str(u), shape="doublecircle" if u in self.nfa.final_states else "circle")
+        g.edge("", str(self.nfa.initial_state))
+        for u, d in self.nfa.transitions.items():
+            for c, vs in d.items():
+                c = c or "ε"
+                for v in vs:
+                    g.edge(str(u), str(v), label=c)
+        return g
+
+    def to_png(self, output: str = "nfa.png") -> None:
+        dot = self.get_digraph_dot()
+        dot.render(output, format="png")

src/regex_automata/automata/nfa_visualizer.py

@@ -0,0 +1,4 @@
+import os
+from typing import Any
+
+PathOrStr = str | os.PathLike[Any]