atomicguard 0.1.0__py3-none-any.whl

atomicguard/infrastructure/llm/ollama.py

@@ -0,0 +1,132 @@
+"""
+Ollama LLM generator implementation.
+
+Connects to Ollama instances via the OpenAI-compatible API.
+"""
+
+import re
+import uuid
+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
+
+DEFAULT_OLLAMA_URL = "http://localhost:11434/v1"
+
+
+class OllamaGenerator(GeneratorInterface):
+    """Connects to Ollama instance using OpenAI-compatible API."""
+
+    def __init__(
+        self,
+        model: str = "qwen2.5-coder:7b",
+        base_url: str = DEFAULT_OLLAMA_URL,
+        timeout: float = 120.0,
+    ):
+        """
+        Args:
+            model: Ollama model name
+            base_url: Ollama API URL
+            timeout: Request timeout in seconds
+        """
+        try:
+            from openai import OpenAI
+        except ImportError as err:
+            raise ImportError("openai library required: pip install openai") from err
+
+        self._model = model
+        self._client = OpenAI(
+            base_url=base_url,
+            api_key="ollama",  # required but unused
+            timeout=timeout,
+        )
+        self._version_counter = 0
+
+    def generate(
+        self, context: Context, template: PromptTemplate | None = None
+    ) -> Artifact:
+        """Generate an artifact based on context."""
+        # Build prompt
+        if template:
+            prompt = template.render(context)
+        else:
+            prompt = self._build_basic_prompt(context)
+
+        # Call Ollama
+        messages = [
+            {
+                "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.completions.create(
+            model=self._model, messages=cast(Any, messages), temperature=0.7
+        )
+
+        content = response.choices[0].message.content or ""
+        code = self._extract_code(content)
+
+        self._version_counter += 1
+
+        return Artifact(
+            artifact_id=str(uuid.uuid4()),
+            content=code,
+            previous_attempt_id=None,
+            action_pair_id="ollama",
+            created_at=datetime.now().isoformat(),
+            attempt_number=self._version_counter,
+            status=ArtifactStatus.PENDING,
+            guard_result=None,
+            feedback="",
+            context=ContextSnapshot(
+                specification=context.specification,
+                constraints=context.ambient.constraints,
+                feedback_history=(),
+                dependency_ids=(),
+            ),
+        )
+
+    def _extract_code(self, content: str) -> str:
+        """Extract Python code from response."""
+        # 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() :]
+
+        # Fallback: full content
+        return content
+
+    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/__init__.py

@@ -0,0 +1,11 @@
+"""
+Persistence adapters for the Artifact DAG.
+"""
+
+from atomicguard.infrastructure.persistence.filesystem import FilesystemArtifactDAG
+from atomicguard.infrastructure.persistence.memory import InMemoryArtifactDAG
+
+__all__ = [
+    "InMemoryArtifactDAG",
+    "FilesystemArtifactDAG",
+]

atomicguard/infrastructure/persistence/filesystem.py

@@ -0,0 +1,232 @@
+"""
+Filesystem implementation of the Artifact DAG.
+
+Provides persistent, append-only storage for artifacts.
+Implements the Versioned Repository R from Definition 4.
+"""
+
+import json
+from pathlib import Path
+from typing import Any
+
+from atomicguard.domain.interfaces import ArtifactDAGInterface
+from atomicguard.domain.models import (
+    Artifact,
+    ArtifactStatus,
+    ContextSnapshot,
+    FeedbackEntry,
+)
+
+
+class FilesystemArtifactDAG(ArtifactDAGInterface):
+    """
+    Persistent, append-only artifact repository.
+
+    Stores artifacts as JSON files with an index for efficient lookups.
+    Implements the Versioned Repository R from Definition 4.
+    """
+
+    def __init__(self, base_dir: str):
+        self._base_dir = Path(base_dir)
+        self._objects_dir = self._base_dir / "objects"
+        self._index_path = self._base_dir / "index.json"
+        self._cache: dict[str, Artifact] = {}
+        self._index: dict[str, Any] = self._load_or_create_index()
+
+    def _load_or_create_index(self) -> dict[str, Any]:
+        """Load existing index or create new one."""
+        self._base_dir.mkdir(parents=True, exist_ok=True)
+        self._objects_dir.mkdir(parents=True, exist_ok=True)
+
+        if self._index_path.exists():
+            with open(self._index_path) as f:
+                result: dict[str, Any] = json.load(f)
+                return result
+
+        return {"version": "1.0", "artifacts": {}, "action_pairs": {}}
+
+    def _update_index_atomic(self) -> None:
+        """Atomically update index.json using write-to-temp + rename."""
+        temp_path = self._index_path.with_suffix(".tmp")
+        with open(temp_path, "w") as f:
+            json.dump(self._index, f, indent=2)
+        temp_path.rename(self._index_path)  # Atomic on POSIX
+
+    def _artifact_to_dict(self, artifact: Artifact) -> dict:
+        """Serialize artifact to JSON-compatible dict."""
+        return {
+            "artifact_id": artifact.artifact_id,
+            "content": artifact.content,
+            "previous_attempt_id": artifact.previous_attempt_id,
+            "action_pair_id": artifact.action_pair_id,
+            "created_at": artifact.created_at,
+            "attempt_number": artifact.attempt_number,
+            "status": artifact.status.value,
+            "guard_result": artifact.guard_result,
+            "feedback": artifact.feedback,
+            "context": {
+                "specification": artifact.context.specification,
+                "constraints": artifact.context.constraints,
+                "feedback_history": [
+                    {"artifact_id": fe.artifact_id, "feedback": fe.feedback}
+                    for fe in artifact.context.feedback_history
+                ],
+                "dependency_ids": list(artifact.context.dependency_ids),
+            },
+        }
+
+    def _dict_to_artifact(self, data: dict) -> Artifact:
+        """Deserialize artifact from JSON dict."""
+        context = ContextSnapshot(
+            specification=data["context"]["specification"],
+            constraints=data["context"]["constraints"],
+            feedback_history=tuple(
+                FeedbackEntry(artifact_id=fe["artifact_id"], feedback=fe["feedback"])
+                for fe in data["context"]["feedback_history"]
+            ),
+            dependency_ids=tuple(data["context"]["dependency_ids"]),
+        )
+        return Artifact(
+            artifact_id=data["artifact_id"],
+            content=data["content"],
+            previous_attempt_id=data["previous_attempt_id"],
+            action_pair_id=data["action_pair_id"],
+            created_at=data["created_at"],
+            attempt_number=data["attempt_number"],
+            status=ArtifactStatus(data["status"]),
+            guard_result=data["guard_result"],
+            feedback=data["feedback"],
+            context=context,
+        )
+
+    def _get_object_path(self, artifact_id: str) -> Path:
+        """Get filesystem path for artifact (using prefix directories)."""
+        prefix = artifact_id[:2]
+        return self._objects_dir / prefix / f"{artifact_id}.json"
+
+    def store(self, artifact: Artifact, _metadata: str = "") -> str:
+        """
+        Append artifact to DAG (immutable, append-only).
+
+        Args:
+            artifact: The artifact to store
+            metadata: Optional metadata string (for compatibility, stored in feedback)
+
+        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)),
+            "action_pair_id": artifact.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
+        )
+
+        # 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)."""
+        # Check cache first
+        if artifact_id in self._cache:
+            return self._cache[artifact_id]
+
+        # Check index
+        if artifact_id not in self._index["artifacts"]:
+            raise KeyError(f"Artifact not found: {artifact_id}")
+
+        # Load from filesystem
+        rel_path = self._index["artifacts"][artifact_id]["path"]
+        object_path = self._base_dir / rel_path
+
+        with open(object_path) as f:
+            data = json.load(f)
+
+        artifact = self._dict_to_artifact(data)
+        self._cache[artifact_id] = artifact
+        return artifact
+
+    def get_provenance(self, artifact_id: str) -> list[Artifact]:
+        """Trace retry chain via previous_attempt_id."""
+        result = []
+        current_id: str | None = artifact_id
+
+        while current_id:
+            artifact = self.get_artifact(current_id)
+            result.append(artifact)
+            current_id = artifact.previous_attempt_id
+
+        return list(reversed(result))
+
+    def get_by_action_pair(self, action_pair_id: str) -> list[Artifact]:
+        """Get all artifacts for an action pair."""
+        if action_pair_id not in self._index["action_pairs"]:
+            return []
+
+        artifact_ids = self._index["action_pairs"][action_pair_id]
+        return [self.get_artifact(aid) for aid in artifact_ids]
+
+    def get_accepted(self, action_pair_id: str) -> Artifact | None:
+        """Get the accepted artifact for an action pair (if any)."""
+        artifacts = self.get_by_action_pair(action_pair_id)
+        for artifact in artifacts:
+            if artifact.status == ArtifactStatus.ACCEPTED:
+                return artifact
+        return None
+
+    def update_status(self, artifact_id: str, new_status: ArtifactStatus) -> None:
+        """
+        Update artifact status (e.g., mark as ACCEPTED or SUPERSEDED).
+
+        Note: This creates a new file version, preserving append-only semantics.
+        """
+        artifact = self.get_artifact(artifact_id)
+
+        # Create updated artifact (immutable, so we create new instance)
+        updated = Artifact(
+            artifact_id=artifact.artifact_id,
+            content=artifact.content,
+            previous_attempt_id=artifact.previous_attempt_id,
+            action_pair_id=artifact.action_pair_id,
+            created_at=artifact.created_at,
+            attempt_number=artifact.attempt_number,
+            status=new_status,
+            guard_result=artifact.guard_result,
+            feedback=artifact.feedback,
+            context=artifact.context,
+        )
+
+        # Update file
+        artifact_dict = self._artifact_to_dict(updated)
+        object_path = self._get_object_path(artifact_id)
+        with open(object_path, "w") as f:
+            json.dump(artifact_dict, f, indent=2)
+
+        # Update index
+        self._index["artifacts"][artifact_id]["status"] = new_status.value
+        self._update_index_atomic()
+
+        # Update cache
+        self._cache[artifact_id] = updated

atomicguard/infrastructure/persistence/memory.py

@@ -0,0 +1,39 @@
+"""
+In-memory implementation of the Artifact DAG.
+
+Useful for testing and ephemeral workflows.
+"""
+
+from atomicguard.domain.interfaces import ArtifactDAGInterface
+from atomicguard.domain.models import Artifact
+
+
+class InMemoryArtifactDAG(ArtifactDAGInterface):
+    """Simple in-memory DAG for testing."""
+
+    def __init__(self) -> None:
+        self._artifacts: dict[str, Artifact] = {}
+        self._metadata: dict[str, str] = {}
+
+    def store(self, artifact: Artifact, metadata: str = "") -> str:
+        self._artifacts[artifact.artifact_id] = artifact
+        self._metadata[artifact.artifact_id] = metadata
+        return artifact.artifact_id
+
+    def get_artifact(self, artifact_id: str) -> Artifact:
+        if artifact_id not in self._artifacts:
+            raise KeyError(f"Artifact not found: {artifact_id}")
+        return self._artifacts[artifact_id]
+
+    def get_provenance(self, artifact_id: str) -> list[Artifact]:
+        result = []
+        current = self._artifacts.get(artifact_id)
+        while current:
+            result.append(current)
+            if (
+                not hasattr(current, "previous_attempt_id")
+                or current.previous_attempt_id is None
+            ):
+                break
+            current = self._artifacts.get(current.previous_attempt_id)
+        return list(reversed(result))

atomicguard-0.1.0.dist-info/METADATA

@@ -0,0 +1,137 @@
+Metadata-Version: 2.4
+Name: atomicguard
+Version: 0.1.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>
+License: MIT
+Project-URL: Homepage, https://github.com/thompsonson/atomicguard
+Project-URL: Repository, https://github.com/thompsonson/atomicguard
+Project-URL: Documentation, https://github.com/thompsonson/atomicguard#readme
+Project-URL: Issues, https://github.com/thompsonson/atomicguard/issues
+Project-URL: Changelog, https://github.com/thompsonson/atomicguard/blob/main/CHANGELOG.md
+Keywords: llm,agents,code-generation,neuro-symbolic,guards,ai,validation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.3.1
+Requires-Dist: matplotlib>=3.10.0
+Requires-Dist: openai>=2.12.0
+Requires-Dist: rich>=14.0.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.13.0; extra == "dev"
+Requires-Dist: pre-commit>=4.5.0; extra == "dev"
+Requires-Dist: ruff>=0.14.0; extra == "dev"
+Provides-Extra: test
+Requires-Dist: pytest>=8.0.0; extra == "test"
+Requires-Dist: pytest-cov>=6.0.0; extra == "test"
+Dynamic: license-file
+
+# AtomicGuard
+
+[![CI](https://github.com/thompsonson/atomicguard/actions/workflows/ci.yml/badge.svg)](https://github.com/thompsonson/atomicguard/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/thompsonson/atomicguard/branch/main/graph/badge.svg)](https://codecov.io/gh/thompsonson/atomicguard)
+[![PyPI version](https://badge.fury.io/py/atomicguard.svg)](https://badge.fury.io/py/atomicguard)
+[![Python versions](https://img.shields.io/pypi/pyversions/atomicguard.svg)](https://pypi.org/project/atomicguard/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+A Dual-State Agent Framework for reliable LLM code generation.
+
+> **New to AtomicGuard?** Start with the [Getting Started Guide](docs/getting-started.md).
+
+**Paper:** *Managing the Stochastic: Foundations of Learning in Neuro-Symbolic Systems for Software Engineering* (Thompson, 2025)
+
+## Overview
+
+AtomicGuard implements guard-validated generation loops that dramatically improve LLM reliability. The core abstraction is the **Atomic Action Pair** ⟨agen, G⟩ — coupling each generation action with a validation guard.
+
+Key results (Yi-Coder 9B, n=50):
+
+| Task | Baseline | Guarded | Improvement |
+|------|----------|---------|-------------|
+| Template | 35% | 90% | +55pp |
+| Password | 82% | 98% | +16pp |
+| LRU Cache | 94% | 100% | +6pp |
+
+## Installation
+
+```bash
+# From PyPI
+pip install atomicguard
+
+# From source
+git clone https://github.com/thompsonson/atomicguard.git
+cd atomicguard
+uv venv && source .venv/bin/activate
+uv pip install -e ".[dev,test]"
+```
+
+## Quick Start
+
+```python
+from atomicguard import (
+    OllamaGenerator, SyntaxGuard, TestGuard,
+    CompositeGuard, ActionPair, DualStateAgent,
+    InMemoryArtifactDAG
+)
+
+# Setup
+generator = OllamaGenerator(model="qwen2.5-coder:7b")
+guard = CompositeGuard([SyntaxGuard(), TestGuard("assert add(2, 3) == 5")])
+action_pair = ActionPair(generator=generator, guard=guard)
+agent = DualStateAgent(action_pair, InMemoryArtifactDAG(), rmax=3)
+
+# Execute
+artifact = agent.execute("Write a function that adds two numbers")
+print(artifact.content)
+```
+
+See [examples/](examples/) for more detailed usage, including a [mock example](examples/basic_mock.py) that works without an LLM.
+
+## Benchmarks
+
+Run the simulation from the paper:
+
+```bash
+python -m benchmarks.simulation --model yi-coder:9b --trials 50 --task all --output results/results.db --format sqlite
+
+# Generate report
+python -m benchmarks.simulation --visualize --output results/results.db --format sqlite
+```
+
+## Project Structure
+
+```
+atomicguard/
+├── src/atomicguard/     # Core library
+├── benchmarks/          # Simulation code
+├── docs/design/         # Design documents
+├── examples/            # Usage examples
+└── results/             # Generated reports & charts
+```
+
+## Citation
+
+```bibtex
+@article{thompson2025managing,
+  title={Managing the Stochastic: Foundations of Learning in Neuro-Symbolic Systems for Software Engineering},
+  author={Thompson, Matthew},
+  year={2025}
+}
+```
+
+## License
+
+MIT

atomicguard-0.1.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+atomicguard/__init__.py,sha256=kiNxqjbVSlSf6Z0U7wpus3o_eMTB7M5-Dj41qgcgUwI,2927
+atomicguard/application/__init__.py,sha256=-myJt7VuC1tMjO424NhjY6iZZuUdHGnFCJKFapFCAhw,409
+atomicguard/application/action_pair.py,sha256=pa9gw4cTb8HaZLT_VqjQaKVMGGllo0BcDf6YzqsJlnA,1959
+atomicguard/application/agent.py,sha256=uzwhrn43JkrK1xxuw8ETvjL4IAiVZ1_Jeik4tMY_2ZE,4254
+atomicguard/application/workflow.py,sha256=CPnLVaten4hN4fiC_gGMvN9-BCJIVVwYsQb3HtRTlJg,4902
+atomicguard/domain/__init__.py,sha256=z7CWqBs21XsZPLeuqLD1fNQVtl9VxIs3zkrK_1n4uD0,1061
+atomicguard/domain/exceptions.py,sha256=3L1acckIcf0XewBy8QJpzgCRBaKyYdossbIAikt1Xkw,770
+atomicguard/domain/interfaces.py,sha256=3kPXRof0a-4c225d1DgZ_66_5A6P8H1XZK-gTp9YkCI,2935
+atomicguard/domain/models.py,sha256=p9FqB9MdriV7djaGUkREGEgkcWyhGvpYmHYrLq2VX-w,4483
+atomicguard/domain/prompts.py,sha256=SMGcP0kYc9azCbGku5EG0JZZs83D80WkJO-DWiuFV58,2785
+atomicguard/guards/__init__.py,sha256=pd4H3sfnrN76vKBX3KrXWsoe27V5vNacSEUKW9uIbmM,548
+atomicguard/guards/base.py,sha256=VGydlOD4gmXdiDHvWXF5jSppXcJAoJYSCyDj7Lrbng0,1213
+atomicguard/guards/human.py,sha256=G8SstAEdcMpHR2b8ugyG9drk9aBjw4_pE6E4UrTtcUo,2960
+atomicguard/guards/syntax.py,sha256=mPVgGDY3pzwtXuulmmuEwYAQG7rNG0fgSGB1puYRI6Y,919
+atomicguard/guards/test_runner.py,sha256=dIFtyOXxu_dxKDlrsBl_G7kCR5oy5gLQESQtYGslKO4,5538
+atomicguard/infrastructure/__init__.py,sha256=98eYKEgEIzJ05Z5r82M7tB0S0QGD2PrfPR_8wapzfHA,465
+atomicguard/infrastructure/llm/__init__.py,sha256=lmr-cYVeaiAsMi_DWcoM7G1wEs6Y6GS02RZeOs4GI-U,234
+atomicguard/infrastructure/llm/mock.py,sha256=OVumDkWYe9xU8KQHdt79evpHzIJIRRxXIqeC9fgI-hQ,1840
+atomicguard/infrastructure/llm/ollama.py,sha256=jtE3SXfMSsYUDocuKXDH3H4NrR8cMwjvCpSFkn99Xlg,4019
+atomicguard/infrastructure/persistence/__init__.py,sha256=DdoD0V-uCetJDo_RJRPiCfjae3xAX5yofnQWbalBrJw,285
+atomicguard/infrastructure/persistence/filesystem.py,sha256=LpdExc9FAwB2Od8eM5zSEMx4hC4Lx2AaztJdba8_MD0,8638
+atomicguard/infrastructure/persistence/memory.py,sha256=gZo2hcpi5VOu60nscxPnyQBDg8P87MI9ZXBdaW0eebQ,1339
+atomicguard-0.1.0.dist-info/licenses/LICENSE,sha256=ROMMFVruZ18U24pKTNte9AK_YIqoMfXnMzoxqBNmKS4,1073
+atomicguard-0.1.0.dist-info/METADATA,sha256=yJlnBW1n_-4ORhWkIjTOykpD9vf6N9OHzO4mJIh39lc,4919
+atomicguard-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+atomicguard-0.1.0.dist-info/top_level.txt,sha256=J_6ENELjnacSYJ5N3FGwomp-sVeAJQohPkJBh6pu6iY,12
+atomicguard-0.1.0.dist-info/RECORD,,

atomicguard-0.1.0.dist-info/WHEEL

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

atomicguard-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Matthew Thompson
+
+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.

atomicguard-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+atomicguard