atomicguard 1.1.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

atomicguard/infrastructure/llm/huggingface.py

@@ -0,0 +1,162 @@
+"""
+HuggingFace Inference API generator implementation.
+
+Connects to HuggingFace Inference Providers via the huggingface_hub
+InferenceClient for chat completion.
+"""
+
+import os
+import re
+import uuid
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, cast
+
+from atomicguard.domain.interfaces import GeneratorInterface
+from atomicguard.domain.models import (
+    Artifact,
+    ArtifactStatus,
+    Context,
+    ContextSnapshot,
+)
+from atomicguard.domain.prompts import PromptTemplate
+
+
+@dataclass
+class HuggingFaceGeneratorConfig:
+    """Configuration for HuggingFaceGenerator.
+
+    This typed config ensures unknown fields are rejected at construction time.
+    """
+
+    model: str = "Qwen/Qwen2.5-Coder-32B-Instruct"
+    api_key: str | None = None  # Auto-detects from HF_TOKEN env var
+    provider: str | None = None  # e.g. "auto", "hf-inference", "together"
+    timeout: float = 120.0
+    temperature: float = 0.7
+    max_tokens: int = 4096
+
+
+class HuggingFaceGenerator(GeneratorInterface):
+    """Connects to HuggingFace Inference API using huggingface_hub."""
+
+    config_class = HuggingFaceGeneratorConfig
+
+    def __init__(
+        self, config: HuggingFaceGeneratorConfig | None = None, **kwargs: Any
+    ) -> None:
+        """
+        Args:
+            config: Typed configuration object (preferred)
+            **kwargs: Legacy kwargs for backward compatibility (deprecated)
+        """
+        if config is None:
+            config = HuggingFaceGeneratorConfig(**kwargs)
+
+        try:
+            from huggingface_hub import InferenceClient
+        except ImportError as err:
+            raise ImportError(
+                "huggingface_hub library required: pip install huggingface_hub"
+            ) from err
+
+        api_key = config.api_key
+        if api_key is None:
+            api_key = os.environ.get("HF_TOKEN")
+            if not api_key:
+                raise ValueError(
+                    "HuggingFace API key required: set HF_TOKEN environment "
+                    "variable or pass api_key in config"
+                )
+
+        client_kwargs: dict[str, Any] = {
+            "api_key": api_key,
+            "timeout": config.timeout,
+        }
+        if config.provider is not None:
+            client_kwargs["provider"] = config.provider
+
+        self._model = config.model
+        self._client = InferenceClient(**client_kwargs)
+        self._temperature = config.temperature
+        self._max_tokens = config.max_tokens
+        self._version_counter = 0
+
+    def generate(
+        self,
+        context: Context,
+        template: PromptTemplate,
+        action_pair_id: str = "unknown",
+        workflow_id: str = "unknown",
+        workflow_ref: str | None = None,
+    ) -> Artifact:
+        """Generate an artifact based on context."""
+        prompt = template.render(context)
+
+        messages: list[dict[str, str]] = [
+            {
+                "role": "system",
+                "content": (
+                    "You are a Python programming assistant. "
+                    "Provide complete, runnable code in a markdown block:\n"
+                    "```python\n# code\n```"
+                ),
+            },
+            {"role": "user", "content": prompt},
+        ]
+
+        response = self._client.chat_completion(
+            messages=cast(Any, messages),
+            model=self._model,
+            temperature=self._temperature,
+            max_tokens=self._max_tokens,
+        )
+
+        content = response.choices[0].message.content or ""
+        code = self._extract_code(content)
+
+        self._version_counter += 1
+
+        return Artifact(
+            artifact_id=str(uuid.uuid4()),
+            workflow_id=workflow_id,
+            content=code,
+            previous_attempt_id=None,
+            parent_action_pair_id=None,
+            action_pair_id=action_pair_id,
+            created_at=datetime.now().isoformat(),
+            attempt_number=self._version_counter,
+            status=ArtifactStatus.PENDING,
+            guard_result=None,
+            context=ContextSnapshot(
+                workflow_id=workflow_id,
+                specification=context.specification,
+                constraints=context.ambient.constraints,
+                feedback_history=(),
+                dependency_artifacts=context.dependency_artifacts,
+            ),
+            workflow_ref=workflow_ref,
+        )
+
+    def _extract_code(self, content: str) -> str:
+        """Extract Python code from response."""
+        if not content or content.isspace():
+            return ""
+
+        # Try python block
+        match = re.search(r"```python\n(.*?)\n```", content, re.DOTALL)
+        if match:
+            return match.group(1)
+
+        # Try generic block
+        match = re.search(r"```\n(.*?)\n```", content, re.DOTALL)
+        if match:
+            return match.group(1)
+
+        # Try first def/import/class
+        match = re.search(r"^(def |import |class )", content, re.MULTILINE)
+        if match:
+            return content[match.start() :]
+
+        # No code block found - return empty to trigger guard validation failure
+        return ""

atomicguard/infrastructure/llm/mock.py

@@ -44,10 +44,11 @@ class MockGenerator(GeneratorInterface):
 
     def generate(
         self,
-        _context: Context,
-        _template: PromptTemplate | None = None,
+        context: Context,  # noqa: ARG002 - unused but required by interface
+        template: PromptTemplate,  # noqa: ARG002
         action_pair_id: str = "unknown",
         workflow_id: str = "unknown",
+        workflow_ref: str | None = None,
     ) -> Artifact:
         """Return the next predefined response."""
         if self._call_count >= len(self._responses):
@@ -66,8 +67,7 @@ class MockGenerator(GeneratorInterface):
             created_at=datetime.now().isoformat(),
             attempt_number=self._call_count,
             status=ArtifactStatus.PENDING,
-            guard_result=None,
-            feedback="",
+            guard_result=None,  # Guard result set after validation
             context=ContextSnapshot(
                 workflow_id=workflow_id,
                 specification="",
@@ -75,6 +75,7 @@ class MockGenerator(GeneratorInterface):
                 feedback_history=(),
                 dependency_artifacts=(),
             ),
+            workflow_ref=workflow_ref,
         )
 
     @property

atomicguard/infrastructure/llm/ollama.py

@@ -65,16 +65,14 @@ class OllamaGenerator(GeneratorInterface):
     def generate(
         self,
         context: Context,
-        template: PromptTemplate | None = None,
+        template: PromptTemplate,
         action_pair_id: str = "unknown",
         workflow_id: str = "unknown",
+        workflow_ref: str | None = None,
     ) -> Artifact:
         """Generate an artifact based on context."""
         # Build prompt
-        if template:
-            prompt = template.render(context)
-        else:
-            prompt = self._build_basic_prompt(context)
+        prompt = template.render(context)
 
         # Call Ollama
         messages = [
@@ -104,8 +102,7 @@ class OllamaGenerator(GeneratorInterface):
             created_at=datetime.now().isoformat(),
             attempt_number=self._version_counter,
             status=ArtifactStatus.PENDING,
-            guard_result=None,
-            feedback="",
+            guard_result=None,  # Guard result set after validation
             context=ContextSnapshot(
                 workflow_id=workflow_id,
                 specification=context.specification,
@@ -113,6 +110,7 @@ class OllamaGenerator(GeneratorInterface):
                 feedback_history=(),
                 dependency_artifacts=context.dependency_artifacts,
             ),
+            workflow_ref=workflow_ref,
         )
 
     def _extract_code(self, content: str) -> str:
@@ -137,19 +135,3 @@ class OllamaGenerator(GeneratorInterface):
 
         # No code block found - return empty to trigger guard validation failure
         return ""
-
-    def _build_basic_prompt(self, context: Context) -> str:
-        """Build a basic prompt from context."""
-        parts = [context.specification]
-
-        if context.current_artifact:
-            parts.append(f"\nPrevious attempt:\n{context.current_artifact}")
-
-        if context.feedback_history:
-            feedback_text = "\n".join(
-                f"Attempt {i + 1} feedback: {f}"
-                for i, (_, f) in enumerate(context.feedback_history)
-            )
-            parts.append(f"\nFeedback history:\n{feedback_text}")
-
-        return "\n".join(parts)

atomicguard/infrastructure/persistence/filesystem.py

@@ -6,6 +6,7 @@ Implements the Versioned Repository R from Definition 4.
 """
 
 import json
+import threading
 from pathlib import Path
 from typing import Any
 
@@ -15,6 +16,8 @@ from atomicguard.domain.models import (
     ArtifactStatus,
     ContextSnapshot,
     FeedbackEntry,
+    GuardResult,
+    SubGuardOutcome,
 )
 
 
@@ -31,6 +34,7 @@ class FilesystemArtifactDAG(ArtifactDAGInterface):
         self._objects_dir = self._base_dir / "objects"
         self._index_path = self._base_dir / "index.json"
         self._cache: dict[str, Artifact] = {}
+        self._lock = threading.Lock()  # Thread safety for concurrent writes
         self._index: dict[str, Any] = self._load_or_create_index()
 
     def _load_or_create_index(self) -> dict[str, Any]:
@@ -52,9 +56,52 @@ class FilesystemArtifactDAG(ArtifactDAGInterface):
             json.dump(self._index, f, indent=2)
         temp_path.rename(self._index_path)  # Atomic on POSIX
 
+    def _guard_result_to_dict(self, guard_result: GuardResult | None) -> dict | None:
+        """Serialize GuardResult to JSON-compatible dict."""
+        if guard_result is None:
+            return None
+        return {
+            "passed": guard_result.passed,
+            "feedback": guard_result.feedback,
+            "fatal": guard_result.fatal,
+            "guard_name": guard_result.guard_name,
+            "sub_results": [
+                {
+                    "guard_name": sr.guard_name,
+                    "passed": sr.passed,
+                    "feedback": sr.feedback,
+                    "execution_time_ms": sr.execution_time_ms,
+                }
+                for sr in guard_result.sub_results
+            ],
+        }
+
+    def _dict_to_guard_result(self, data: dict | None) -> GuardResult | None:
+        """Deserialize GuardResult from JSON dict."""
+        if data is None:
+            return None
+        # Handle legacy format where guard_result was just a boolean
+        if isinstance(data, bool):
+            return GuardResult(passed=data, feedback="")
+        return GuardResult(
+            passed=data["passed"],
+            feedback=data.get("feedback", ""),
+            fatal=data.get("fatal", False),
+            guard_name=data.get("guard_name"),
+            sub_results=tuple(
+                SubGuardOutcome(
+                    guard_name=sr["guard_name"],
+                    passed=sr["passed"],
+                    feedback=sr["feedback"],
+                    execution_time_ms=sr.get("execution_time_ms", 0.0),
+                )
+                for sr in data.get("sub_results", [])
+            ),
+        )
+
     def _artifact_to_dict(self, artifact: Artifact) -> dict:
         """Serialize artifact to JSON-compatible dict."""
-        return {
+        result = {
             "artifact_id": artifact.artifact_id,
             "workflow_id": artifact.workflow_id,
             "content": artifact.content,
@@ -64,8 +111,7 @@ class FilesystemArtifactDAG(ArtifactDAGInterface):
             "created_at": artifact.created_at,
             "attempt_number": artifact.attempt_number,
             "status": artifact.status.value,
-            "guard_result": artifact.guard_result,
-            "feedback": artifact.feedback,
+            "guard_result": self._guard_result_to_dict(artifact.guard_result),
             "context": {
                 "workflow_id": artifact.context.workflow_id,
                 "specification": artifact.context.specification,
@@ -78,6 +124,10 @@ class FilesystemArtifactDAG(ArtifactDAGInterface):
                 "dependency_artifacts": dict(artifact.context.dependency_artifacts),
             },
         }
+        # Include metadata if present
+        if artifact.metadata:
+            result["metadata"] = dict(artifact.metadata)
+        return result
 
     def _dict_to_artifact(self, data: dict) -> Artifact:
         """Deserialize artifact from JSON dict."""
@@ -98,6 +148,25 @@ class FilesystemArtifactDAG(ArtifactDAGInterface):
             # Deserialize dict → tuple for immutability
             dependency_artifacts=tuple(dep_data.items()),
         )
+        # Get metadata if present
+        metadata = data.get("metadata", {})
+
+        # Handle legacy format: guard_result was bool, feedback was separate field
+        guard_result_data = data.get("guard_result")
+        if guard_result_data is None and "feedback" in data:
+            # Legacy artifact with no guard_result but has feedback
+            # This shouldn't happen often, but handle gracefully
+            pass
+        elif isinstance(guard_result_data, bool):
+            # Legacy format: convert bool + feedback to GuardResult
+            guard_result_data = {
+                "passed": guard_result_data,
+                "feedback": data.get("feedback", ""),
+                "fatal": False,
+                "guard_name": None,
+                "sub_results": [],
+            }
+
         return Artifact(
             artifact_id=data["artifact_id"],
             workflow_id=data.get("workflow_id", "unknown"),
@@ -108,9 +177,9 @@ class FilesystemArtifactDAG(ArtifactDAGInterface):
             created_at=data["created_at"],
             attempt_number=data["attempt_number"],
             status=ArtifactStatus(data["status"]),
-            guard_result=data["guard_result"],
-            feedback=data["feedback"],
+            guard_result=self._dict_to_guard_result(guard_result_data),
             context=context,
+            metadata=metadata,  # Will be converted to MappingProxyType in __post_init__
         )
 
     def _get_object_path(self, artifact_id: str) -> Path:
@@ -122,52 +191,55 @@ class FilesystemArtifactDAG(ArtifactDAGInterface):
         """
         Append artifact to DAG (immutable, append-only).
 
+        Thread-safe: uses lock to ensure atomic index updates.
+
         Args:
             artifact: The artifact to store
 
         Returns:
             The artifact_id
         """
-        # 1. Serialize to JSON
-        artifact_dict = self._artifact_to_dict(artifact)
-
-        # 2. Write to objects/{prefix}/{artifact_id}.json
-        object_path = self._get_object_path(artifact.artifact_id)
-        object_path.parent.mkdir(parents=True, exist_ok=True)
-        with open(object_path, "w") as f:
-            json.dump(artifact_dict, f, indent=2)
-
-        # 3. Update index
-        self._index["artifacts"][artifact.artifact_id] = {
-            "path": str(object_path.relative_to(self._base_dir)),
-            "workflow_id": artifact.workflow_id,
-            "action_pair_id": artifact.action_pair_id,
-            "parent_action_pair_id": artifact.parent_action_pair_id,
-            "status": artifact.status.value,
-            "created_at": artifact.created_at,
-        }
-
-        # Track by action pair
-        if artifact.action_pair_id not in self._index["action_pairs"]:
-            self._index["action_pairs"][artifact.action_pair_id] = []
-        self._index["action_pairs"][artifact.action_pair_id].append(
-            artifact.artifact_id
-        )
-
-        # Track by workflow
-        if "workflows" not in self._index:
-            self._index["workflows"] = {}
-        if artifact.workflow_id not in self._index["workflows"]:
-            self._index["workflows"][artifact.workflow_id] = []
-        self._index["workflows"][artifact.workflow_id].append(artifact.artifact_id)
-
-        # 4. Atomically update index
-        self._update_index_atomic()
-
-        # 5. Add to cache
-        self._cache[artifact.artifact_id] = artifact
-
-        return artifact.artifact_id
+        with self._lock:
+            # 1. Serialize to JSON
+            artifact_dict = self._artifact_to_dict(artifact)
+
+            # 2. Write to objects/{prefix}/{artifact_id}.json
+            object_path = self._get_object_path(artifact.artifact_id)
+            object_path.parent.mkdir(parents=True, exist_ok=True)
+            with open(object_path, "w") as f:
+                json.dump(artifact_dict, f, indent=2)
+
+            # 3. Update index
+            self._index["artifacts"][artifact.artifact_id] = {
+                "path": str(object_path.relative_to(self._base_dir)),
+                "workflow_id": artifact.workflow_id,
+                "action_pair_id": artifact.action_pair_id,
+                "parent_action_pair_id": artifact.parent_action_pair_id,
+                "status": artifact.status.value,
+                "created_at": artifact.created_at,
+            }
+
+            # Track by action pair
+            if artifact.action_pair_id not in self._index["action_pairs"]:
+                self._index["action_pairs"][artifact.action_pair_id] = []
+            self._index["action_pairs"][artifact.action_pair_id].append(
+                artifact.artifact_id
+            )
+
+            # Track by workflow
+            if "workflows" not in self._index:
+                self._index["workflows"] = {}
+            if artifact.workflow_id not in self._index["workflows"]:
+                self._index["workflows"][artifact.workflow_id] = []
+            self._index["workflows"][artifact.workflow_id].append(artifact.artifact_id)
+
+            # 4. Atomically update index
+            self._update_index_atomic()
+
+            # 5. Add to cache
+            self._cache[artifact.artifact_id] = artifact
+
+            return artifact.artifact_id
 
     def get_artifact(self, artifact_id: str) -> Artifact:
         """Retrieve artifact by ID (cache-first)."""
@@ -238,8 +310,8 @@ class FilesystemArtifactDAG(ArtifactDAGInterface):
             attempt_number=artifact.attempt_number,
             status=new_status,
             guard_result=artifact.guard_result,
-            feedback=artifact.feedback,
             context=artifact.context,
+            metadata=artifact.metadata,
         )
 
         # Update file
@@ -294,3 +366,18 @@ class FilesystemArtifactDAG(ArtifactDAGInterface):
         # Sort by created_at descending and return the latest
         candidates.sort(key=lambda x: x[1], reverse=True)
         return self.get_artifact(candidates[0][0])
+
+    def get_all(self) -> list[Artifact]:
+        """Return all artifacts in the DAG.
+
+        Returns:
+            List of all artifacts, sorted by created_at.
+        """
+        # Get all artifact IDs from index and sort by created_at
+        artifact_ids_with_times = [
+            (aid, info.get("created_at", ""))
+            for aid, info in self._index.get("artifacts", {}).items()
+        ]
+        artifact_ids_with_times.sort(key=lambda x: x[1])
+
+        return [self.get_artifact(aid) for aid, _ in artifact_ids_with_times]

atomicguard/infrastructure/persistence/memory.py

@@ -59,3 +59,13 @@ class InMemoryArtifactDAG(ArtifactDAGInterface):
         # Sort by created_at descending and return the latest
         candidates.sort(key=lambda a: a.created_at, reverse=True)
         return candidates[0]
+
+    def get_all(self) -> list[Artifact]:
+        """Return all artifacts in the DAG.
+
+        Returns:
+            List of all artifacts, sorted by created_at.
+        """
+        artifacts = list(self._artifacts.values())
+        artifacts.sort(key=lambda a: a.created_at)
+        return artifacts

{atomicguard-1.1.0.dist-info → atomicguard-2.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atomicguard
-Version: 1.1.0
+Version: 2.0.0
 Summary: A Dual-State Agent Framework for reliable LLM code generation with guard-validated loops
 Author-email: Matthew Thompson <thompsonson@gmail.com>
 Maintainer-email: Matthew Thompson <thompsonson@gmail.com>
@@ -93,6 +93,67 @@ print(artifact.content)
 
 See [examples/](examples/) for more detailed usage, including a [mock example](examples/basic_mock.py) that works without an LLM.
 
+## LLM Backends
+
+AtomicGuard supports multiple LLM backends. Each generator implements `GeneratorInterface` and can be swapped in with no other code changes.
+
+### Ollama (local or cloud)
+
+Uses the OpenAI-compatible API. Works with any Ollama-served model:
+
+```python
+from atomicguard.infrastructure.llm import OllamaGenerator
+
+# Local instance (default: http://localhost:11434/v1)
+generator = OllamaGenerator(model="qwen2.5-coder:7b")
+```
+
+### HuggingFace Inference API
+
+Connects to HuggingFace Inference Providers via `huggingface_hub`. Supports any model available through the HF Inference API, including third-party providers like Together AI.
+
+```bash
+# Install the optional dependency
+pip install huggingface_hub
+
+# Set your API token
+export HF_TOKEN="hf_your_token_here"
+```
+
+```python
+from atomicguard.infrastructure.llm import HuggingFaceGenerator
+from atomicguard.infrastructure.llm.huggingface import HuggingFaceGeneratorConfig
+
+# Default: Qwen/Qwen2.5-Coder-32B-Instruct
+generator = HuggingFaceGenerator()
+
+# Custom model and provider
+generator = HuggingFaceGenerator(HuggingFaceGeneratorConfig(
+    model="Qwen/Qwen2.5-Coder-32B-Instruct",
+    provider="together",       # or "auto", "hf-inference"
+    temperature=0.7,
+    max_tokens=4096,
+))
+```
+
+Drop-in replacement in any workflow:
+
+```python
+from atomicguard import (
+    SyntaxGuard, TestGuard, CompositeGuard,
+    ActionPair, DualStateAgent, InMemoryArtifactDAG
+)
+from atomicguard.infrastructure.llm import HuggingFaceGenerator
+
+generator = HuggingFaceGenerator()
+guard = CompositeGuard([SyntaxGuard(), TestGuard("assert add(2, 3) == 5")])
+action_pair = ActionPair(generator=generator, guard=guard)
+agent = DualStateAgent(action_pair, InMemoryArtifactDAG(), rmax=3)
+
+artifact = agent.execute("Write a function that adds two numbers")
+print(artifact.content)
+```
+
 ## Benchmarks
 
 Run the simulation from the paper:
@@ -122,15 +183,16 @@ If you use this framework in your research, please cite the paper:
 > Thompson, M. (2025). Managing the Stochastic: Foundations of Learning in Neuro-Symbolic Systems for Software Engineering. arXiv preprint arXiv:2512.20660.
 
 ```bibtex
-@article{thompson2025managing,
+@misc{thompson2025managing,
   title={Managing the Stochastic: Foundations of Learning in Neuro-Symbolic Systems for Software Engineering},
   author={Thompson, Matthew},
-  journal={arXiv preprint arXiv:2512.20660},
   year={2025},
-  url={[https://arxiv.org/abs/2512.20660](https://arxiv.org/abs/2512.20660)}
+  eprint={2512.20660},
+  archivePrefix={arXiv},
+  primaryClass={cs.LG},
+  url={https://arxiv.org/abs/2512.20660}
 }
-
-``` 
+```
 
 ## License
 

atomicguard-2.0.0.dist-info/RECORD

@@ -0,0 +1,42 @@
+atomicguard/__init__.py,sha256=x11KrkPPhOTMy1ZALeVGMRjpNB8x6EukvdngV9e3_hk,3207
+atomicguard/application/__init__.py,sha256=ttnQx0Jd_G2EsSoc2TNq8VdeoY2k4Q0LK3iRpe0O8Ck,643
+atomicguard/application/action_pair.py,sha256=e-yilKIY1TNDn1JBbMq3fM0IDP82lIwHCDuMRog8fnc,2206
+atomicguard/application/agent.py,sha256=DpK-ZtXp-DhPYkziI9c0hucIw4LZRPWCMlRhOS2oCfc,5912
+atomicguard/application/checkpoint_service.py,sha256=F4EoWmWWIonwc4HAre01EPk9rwTWpLL-gDp-Vvcfs6c,4580
+atomicguard/application/resume_service.py,sha256=H6fvIm8b3BuyF9d8lscVIHi9En37xlmSOkURbrmWpO8,8143
+atomicguard/application/workflow.py,sha256=v6jQOPx-kzFFNvA98hSqCgor8gzP2eE8_Ng--WZ91kE,24992
+atomicguard/domain/__init__.py,sha256=HGPu98AL_HgN2nWdiZU_r3fJq6kD8FNfauQSSMVcocM,1193
+atomicguard/domain/exceptions.py,sha256=Zj1iz31AiksyWnyKR8KfnNLRGhZdetrYhCIwFOapBtY,1376
+atomicguard/domain/extraction.py,sha256=O7ZG9pXTA11kT4n8fQIbV0FA73Ui2boveIbwB5dZ0OY,7660
+atomicguard/domain/interfaces.py,sha256=44JDQ7XF7sXhf3ReWJUEJS4vJXdR_qbR9lfQ_beCTuM,7054
+atomicguard/domain/models.py,sha256=Bjh8VTx7SQ8K0UxjN3lUfNunNPJ-90IZjtTv77KaU-g,11652
+atomicguard/domain/multiagent.py,sha256=Id1DphL_HuxodlIFeaBl_kOny7sadotlJsvYsc4xd6Y,8707
+atomicguard/domain/prompts.py,sha256=QtyBgOFldW9RmfvNAwFeyP2mKE-kFjDn758KmrxMq8Q,3328
+atomicguard/domain/workflow.py,sha256=bVIZmYI3lxHOKuxtX3E3DkFQBBrsU0S73AMqrpdfrIo,21883
+atomicguard/guards/__init__.py,sha256=OzpOjwmyHGpTQSDVSDeGEuXUJNOyiNpZxZVnTVMIOyg,956
+atomicguard/guards/composite/__init__.py,sha256=AedlMBxFw4uTFExVWL6RJRR7vRwMOK3sgjhutkXz838,217
+atomicguard/guards/composite/base.py,sha256=VGydlOD4gmXdiDHvWXF5jSppXcJAoJYSCyDj7Lrbng0,1213
+atomicguard/guards/dynamic/__init__.py,sha256=pjBBeD_yYavvn-I7s5I3nTDOlZtPTq1Hqmim_RgW5cE,321
+atomicguard/guards/dynamic/test_runner.py,sha256=d5cPb5cCM-UnfZjTYGOHn4XoS-N66nr5EBHqPoDGwNM,7196
+atomicguard/guards/interactive/__init__.py,sha256=PlP5LNB4CMZ4fJ7Xr8gjjpn8VwLnB3zs5M2Em9xyVCc,226
+atomicguard/guards/interactive/human.py,sha256=G8SstAEdcMpHR2b8ugyG9drk9aBjw4_pE6E4UrTtcUo,2960
+atomicguard/guards/static/__init__.py,sha256=KANeEg_yhrKGzSmA0yf2SewOE9qkUwnJly4mWkBzsm4,305
+atomicguard/guards/static/imports.py,sha256=nWS3FNNqle7YWU5_tgRgYMRAXwEcWlxee8Q4MdomN5w,6292
+atomicguard/guards/static/syntax.py,sha256=mPVgGDY3pzwtXuulmmuEwYAQG7rNG0fgSGB1puYRI6Y,919
+atomicguard/infrastructure/__init__.py,sha256=Y3Ot6sRgTind-8s5kCnNtRYJGN3uq84QmbAUESx8Pio,581
+atomicguard/infrastructure/registry.py,sha256=XilDY2sUedwm5z1Xrp39HfQ9e3paixyJxL_hwGaVbqs,3662
+atomicguard/infrastructure/llm/__init__.py,sha256=wQg_FCAHmwbDXWm0bF5WX-9v7sutAS7RabhHCGiZZzo,338
+atomicguard/infrastructure/llm/huggingface.py,sha256=fGC3uQu0AwM_WzfyJKTe8aNJHTA92wecSiaxo01pOHU,5130
+atomicguard/infrastructure/llm/mock.py,sha256=z_NTiPwzc7zPYN4RbzkhQEldzrdhYy7Pb9ai_pFQ_gQ,2782
+atomicguard/infrastructure/llm/ollama.py,sha256=RMWct-DiY5noLu0dCM3j-7sybB5QJJGL2ZL9pMjRwZ8,4243
+atomicguard/infrastructure/persistence/__init__.py,sha256=KS95wmO_qVF6It63_884lWDoa-IB0WvRma_nXS2uTq4,483
+atomicguard/infrastructure/persistence/checkpoint.py,sha256=MS4qpJ_jcl6Ibw7h3KncWgDqz7CEIlFJdrpFcu2vEgs,13966
+atomicguard/infrastructure/persistence/filesystem.py,sha256=ZLudEu0HvhnicciGZzOG_xX85UptfcawJGg-5V1LU1Q,14988
+atomicguard/infrastructure/persistence/memory.py,sha256=r-vTR9GdThLV4EGMNM_LAxO7KhXZvh11W-Jdfp6hmk0,2342
+atomicguard/schemas/__init__.py,sha256=9z3gWBHsq8FHD2qE_TPy31wkTa_qXPfVgJrNdIu8p4g,3735
+atomicguard-2.0.0.dist-info/licenses/LICENSE,sha256=ROMMFVruZ18U24pKTNte9AK_YIqoMfXnMzoxqBNmKS4,1073
+atomicguard-2.0.0.dist-info/METADATA,sha256=dNW8Oae14_d_ujCJgSfwb87L23STUibFEH_WU8PaW58,6831
+atomicguard-2.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+atomicguard-2.0.0.dist-info/entry_points.txt,sha256=MMVrkEyWFFCMoNIlpSWRY9FJYlEMGmaauvzMxEjwzTI,226
+atomicguard-2.0.0.dist-info/top_level.txt,sha256=J_6ENELjnacSYJ5N3FGwomp-sVeAJQohPkJBh6pu6iY,12
+atomicguard-2.0.0.dist-info/RECORD,,

{atomicguard-1.1.0.dist-info → atomicguard-2.0.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any