waymark-ai 0.1.2__tar.gz

waymark_ai-0.1.2/.determystic/validations/fixtures_at_top.determystic

@@ -0,0 +1,90 @@
+import ast
+
+from determystic.external import DeterministicTraverser
+
+
+class PytestFixturePlacementTraverser(DeterministicTraverser):
+    """Require pytest fixtures to live in the initial top-of-file block."""
+
+    FIXTURE_MODULES = {"pytest", "pytest_asyncio"}
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._allowed_fixture_nodes: set[int] = set()
+        self._reported_fixture_nodes: set[int] = set()
+
+    def visit_Module(self, node: ast.Module) -> None:
+        self._allowed_fixture_nodes = self._find_top_fixture_nodes(node.body)
+        self.generic_visit(node)
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
+        self._check_fixture_placement(node)
+        self.generic_visit(node)
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
+        self._check_fixture_placement(node)
+        self.generic_visit(node)
+
+    def visit_ClassDef(self, node: ast.ClassDef) -> None:
+        self._check_fixture_placement(node)
+        self.generic_visit(node)
+
+    def _find_top_fixture_nodes(self, body: list[ast.stmt]) -> set[int]:
+        allowed: set[int] = set()
+        seen_normal_code = False
+
+        for index, stmt in enumerate(body):
+            if not seen_normal_code and self._is_allowed_preamble(stmt, index):
+                continue
+
+            if self._fixture_decorator(stmt):
+                if not seen_normal_code:
+                    allowed.add(id(stmt))
+                continue
+
+            seen_normal_code = True
+
+        return allowed
+
+    def _check_fixture_placement(
+        self, node: ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef
+    ) -> None:
+        decorator = self._fixture_decorator(node)
+        if not decorator:
+            return
+        if id(node) in self._allowed_fixture_nodes:
+            return
+        if id(node) in self._reported_fixture_nodes:
+            return
+
+        self._reported_fixture_nodes.add(id(node))
+        self.add_error(
+            decorator,
+            "Move pytest fixtures to the top of the file before test/helper code.",
+        )
+
+    def _fixture_decorator(self, node: ast.AST) -> ast.AST | None:
+        decorators = getattr(node, "decorator_list", [])
+        for decorator in decorators:
+            expr = decorator.func if isinstance(decorator, ast.Call) else decorator
+            if (
+                isinstance(expr, ast.Attribute)
+                and expr.attr == "fixture"
+                and isinstance(expr.value, ast.Name)
+                and expr.value.id in self.FIXTURE_MODULES
+            ):
+                return decorator
+        return None
+
+    def _is_allowed_preamble(self, stmt: ast.stmt, index: int) -> bool:
+        if index == 0 and isinstance(stmt, ast.Expr) and isinstance(
+            stmt.value, ast.Constant
+        ) and isinstance(stmt.value.value, str):
+            return True
+        if isinstance(stmt, ast.ClassDef) and self._fixture_decorator(stmt) is None:
+            return True
+        preamble_types = (ast.Import, ast.ImportFrom, ast.Assign, ast.AnnAssign)
+        type_alias = getattr(ast, "TypeAlias", None)
+        if type_alias is not None:
+            preamble_types = (*preamble_types, type_alias)
+        return isinstance(stmt, preamble_types)

waymark_ai-0.1.2/.determystic/validations/future_annotations.determystic

@@ -0,0 +1,29 @@
+import ast
+
+from determystic.external import DeterministicTraverser
+
+
+class NoFutureAnnotationsTraverser(DeterministicTraverser):
+    """Reject `from __future__ import annotations` imports."""
+
+    def visit_ImportFrom(self, node: ast.ImportFrom) -> None:
+        """Flag postponed-annotation future imports."""
+        if self._imports_future_annotations(node):
+            self.add_error(
+                node,
+                (
+                    "Do not use 'from __future__ import annotations'; "
+                    "this project runs on a Python version where it is not needed."
+                ),
+            )
+
+        self.generic_visit(node)
+
+    @staticmethod
+    def _imports_future_annotations(node: ast.ImportFrom) -> bool:
+        """Return True for absolute `__future__.annotations` imports only."""
+        return (
+            node.level == 0
+            and node.module == "__future__"
+            and any(alias.name == "annotations" for alias in node.names)
+        )

waymark_ai-0.1.2/.determystic/validations/inline-simple-helpers.determystic

@@ -0,0 +1,139 @@
+import ast
+
+from determystic.external import DeterministicTraverser
+
+
+MAX_SIMPLE_STATEMENTS = 4
+COMPLEX_NODES = (
+    ast.If,
+    ast.For,
+    ast.AsyncFor,
+    ast.While,
+    ast.Try,
+    ast.With,
+    ast.AsyncWith,
+    ast.Match,
+    ast.ListComp,
+    ast.SetComp,
+    ast.DictComp,
+    ast.GeneratorExp,
+)
+
+
+class SingleUseTrivialHelperTraverser(DeterministicTraverser):
+    """Flag private helpers that only add indirection to one simple caller."""
+
+    def visit_Module(self, node: ast.Module) -> None:
+        module_helpers = {
+            item.name: item
+            for item in node.body
+            if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef))
+            and self._is_private_helper(item.name)
+        }
+
+        module_calls = self._collect_module_calls(node)
+        for name, helper in module_helpers.items():
+            calls = module_calls.get(name, [])
+            if self._should_flag(helper, calls):
+                self._add_helper_error(helper, calls[0][1])
+
+        for class_node in [item for item in node.body if isinstance(item, ast.ClassDef)]:
+            self._check_class_helpers(class_node)
+
+        self.generic_visit(node)
+
+    def _check_class_helpers(self, class_node: ast.ClassDef) -> None:
+        helpers = {
+            item.name: item
+            for item in class_node.body
+            if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef))
+            and self._is_private_helper(item.name)
+        }
+
+        calls = self._collect_self_calls(class_node)
+        for name, helper in helpers.items():
+            helper_calls = calls.get(name, [])
+            if self._should_flag(helper, helper_calls):
+                self._add_helper_error(helper, helper_calls[0][1])
+
+    def _should_flag(
+        self,
+        helper: ast.FunctionDef | ast.AsyncFunctionDef,
+        calls: list[tuple[ast.Call, ast.FunctionDef | ast.AsyncFunctionDef]],
+    ) -> bool:
+        if len(calls) != 1:
+            return False
+
+        caller = calls[0][1]
+        if caller is helper:
+            return False
+
+        return self._is_simple_function(helper) and self._is_simple_function(caller)
+
+    def _add_helper_error(
+        self,
+        helper: ast.FunctionDef | ast.AsyncFunctionDef,
+        caller: ast.FunctionDef | ast.AsyncFunctionDef,
+    ) -> None:
+        self.add_error(
+            helper,
+            (
+                f"Private helper '{helper.name}' is called only by simple "
+                f"'{caller.name}'; inline it unless the helper or caller grows "
+                "real branching, error handling, or reuse."
+            ),
+        )
+
+    def _is_private_helper(self, name: str) -> bool:
+        return name.startswith("_") and not (name.startswith("__") and name.endswith("__"))
+
+    def _is_simple_function(self, node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool:
+        body = self._body_without_docstring(node)
+        if len(body) > MAX_SIMPLE_STATEMENTS:
+            return False
+        return not any(isinstance(child, COMPLEX_NODES) for stmt in body for child in ast.walk(stmt))
+
+    def _body_without_docstring(
+        self, node: ast.FunctionDef | ast.AsyncFunctionDef
+    ) -> list[ast.stmt]:
+        body = list(node.body)
+        if (
+            body
+            and isinstance(body[0], ast.Expr)
+            and isinstance(body[0].value, ast.Constant)
+            and isinstance(body[0].value.value, str)
+        ):
+            return body[1:]
+        return body
+
+    def _collect_module_calls(
+        self, node: ast.Module
+    ) -> dict[str, list[tuple[ast.Call, ast.FunctionDef | ast.AsyncFunctionDef]]]:
+        calls: dict[str, list[tuple[ast.Call, ast.FunctionDef | ast.AsyncFunctionDef]]] = {}
+        for item in node.body:
+            if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                for call in self._calls_inside(item):
+                    if isinstance(call.func, ast.Name):
+                        calls.setdefault(call.func.id, []).append((call, item))
+        return calls
+
+    def _collect_self_calls(
+        self, class_node: ast.ClassDef
+    ) -> dict[str, list[tuple[ast.Call, ast.FunctionDef | ast.AsyncFunctionDef]]]:
+        calls: dict[str, list[tuple[ast.Call, ast.FunctionDef | ast.AsyncFunctionDef]]] = {}
+        for item in class_node.body:
+            if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                for call in self._calls_inside(item):
+                    if self._is_self_attr_call(call):
+                        calls.setdefault(call.func.attr, []).append((call, item))
+        return calls
+
+    def _calls_inside(self, node: ast.FunctionDef | ast.AsyncFunctionDef) -> list[ast.Call]:
+        return [child for stmt in self._body_without_docstring(node) for child in ast.walk(stmt) if isinstance(child, ast.Call)]
+
+    def _is_self_attr_call(self, node: ast.Call) -> bool:
+        return (
+            isinstance(node.func, ast.Attribute)
+            and isinstance(node.func.value, ast.Name)
+            and node.func.value.id in {"self", "cls"}
+        )

waymark_ai-0.1.2/.env.example

@@ -0,0 +1 @@
+OPENAI_API_KEY=sk-your-key-here

waymark_ai-0.1.2/.github/workflows/ci.yml

@@ -0,0 +1,60 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+permissions:
+  contents: read
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - uses: actions/checkout@v7
+
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+
+      - name: Clone Determystic
+        run: git clone --depth 1 https://github.com/piercefreeman/deterministic.git ../deterministic
+
+      - name: Install uv
+        run: |
+          curl -LsSf https://astral.sh/uv/install.sh | sh
+          echo "$HOME/.local/bin" >> "$GITHUB_PATH"
+
+      - name: Install dependencies
+        run: uv sync --frozen
+
+      - name: Run linting
+        run: |
+          uv run ruff format --check src tests examples
+          uv run ruff check src tests examples
+          uv run ty check src tests examples
+          uv run --with-editable ../deterministic determystic validate
+
+  test:
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - uses: actions/checkout@v7
+
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+
+      - name: Install uv
+        run: |
+          curl -LsSf https://astral.sh/uv/install.sh | sh
+          echo "$HOME/.local/bin" >> "$GITHUB_PATH"
+
+      - name: Install dependencies
+        run: uv sync --frozen
+
+      - name: Run tests
+        run: uv run pytest

waymark_ai-0.1.2/.github/workflows/release.yml

@@ -0,0 +1,61 @@
+name: Release
+
+on:
+  push:
+    tags: ["v*"]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v7.0.1
+
+      - uses: actions/setup-python@v7.0.0
+        with:
+          python-version: "3.12"
+
+      - name: Install uv
+        run: |
+          curl -LsSf https://astral.sh/uv/install.sh | sh
+          echo "$HOME/.local/bin" >> "$GITHUB_PATH"
+
+      - name: Install dependencies
+        run: uv sync --frozen
+
+      - name: Run tests
+        run: uv run pytest
+
+      - name: Set package version from tag
+        run: uv version "${GITHUB_REF_NAME#v}" --frozen
+
+      - name: Build packages
+        run: |
+          uv build
+          sed -i 's/name = "pydantic-ai-waymark"/name = "waymark-ai"/' pyproject.toml
+          uv build
+
+      - uses: actions/upload-artifact@v7.0.1
+        with:
+          name: distributions
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/pydantic-ai-waymark
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v8.0.1
+        with:
+          name: distributions
+          path: dist/
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@v1.14.2
+        with:
+          print-hash: true

waymark_ai-0.1.2/.gitignore

@@ -0,0 +1,8 @@
+.venv/
+.pytest_cache/
+.ruff_cache/
+.coverage
+.env
+__pycache__/
+*.py[cod]
+dist/

waymark_ai-0.1.2/.python-version

@@ -0,0 +1 @@
+3.12