stabilize 0.9.2__py3-none-any.whl

stabilize/tasks/result.py

@@ -0,0 +1,283 @@
+"""
+TaskResult - result of task execution.
+
+This module defines the TaskResult class that encapsulates the result
+of executing a task, including status, context updates, and outputs.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from stabilize.models.status import WorkflowStatus
+
+
+@dataclass
+class TaskResult:
+    """
+    Result of a task execution.
+
+    Tasks return a TaskResult to indicate their status and provide
+    data to downstream stages.
+
+    Attributes:
+        status: The execution status after the task runs
+        context: Data scoped to the current stage (merged into stage.context)
+        outputs: Data available to downstream stages (merged into stage.outputs)
+    """
+
+    status: WorkflowStatus
+    context: dict[str, Any] = field(default_factory=dict)
+    outputs: dict[str, Any] = field(default_factory=dict)
+
+    # ========== Factory Methods ==========
+
+    @classmethod
+    def success(
+        cls,
+        outputs: dict[str, Any] | None = None,
+        context: dict[str, Any] | None = None,
+    ) -> TaskResult:
+        """
+        Create a successful result.
+
+        Args:
+            outputs: Values available to downstream stages
+            context: Values scoped to current stage
+
+        Returns:
+            A TaskResult with SUCCEEDED status
+        """
+        return cls(
+            status=WorkflowStatus.SUCCEEDED,
+            context=context or {},
+            outputs=outputs or {},
+        )
+
+    @classmethod
+    def running(
+        cls,
+        context: dict[str, Any] | None = None,
+    ) -> TaskResult:
+        """
+        Create a running result (task will be re-executed).
+
+        Use this when a task needs to poll/wait for something.
+        The task will be re-queued and executed again after a backoff period.
+
+        Args:
+            context: Updated context values
+
+        Returns:
+            A TaskResult with RUNNING status
+        """
+        return cls(
+            status=WorkflowStatus.RUNNING,
+            context=context or {},
+        )
+
+    @classmethod
+    def terminal(
+        cls,
+        error: str,
+        context: dict[str, Any] | None = None,
+    ) -> TaskResult:
+        """
+        Create a terminal failure result.
+
+        The stage and pipeline will fail.
+
+        Args:
+            error: Error message
+            context: Additional context
+
+        Returns:
+            A TaskResult with TERMINAL status
+        """
+        ctx = context or {}
+        ctx["error"] = error
+        return cls(
+            status=WorkflowStatus.TERMINAL,
+            context=ctx,
+        )
+
+    @classmethod
+    def failed_continue(
+        cls,
+        error: str,
+        outputs: dict[str, Any] | None = None,
+        context: dict[str, Any] | None = None,
+    ) -> TaskResult:
+        """
+        Create a failed result that allows pipeline to continue.
+
+        The stage will be marked as failed but downstream stages will run.
+
+        Args:
+            error: Error message
+            outputs: Values available to downstream stages
+            context: Additional context
+
+        Returns:
+            A TaskResult with FAILED_CONTINUE status
+        """
+        ctx = context or {}
+        ctx["error"] = error
+        return cls(
+            status=WorkflowStatus.FAILED_CONTINUE,
+            context=ctx,
+            outputs=outputs or {},
+        )
+
+    @classmethod
+    def skipped(cls) -> TaskResult:
+        """
+        Create a skipped result.
+
+        Returns:
+            A TaskResult with SKIPPED status
+        """
+        return cls(status=WorkflowStatus.SKIPPED)
+
+    @classmethod
+    def canceled(
+        cls,
+        outputs: dict[str, Any] | None = None,
+    ) -> TaskResult:
+        """
+        Create a canceled result.
+
+        Args:
+            outputs: Final outputs to preserve
+
+        Returns:
+            A TaskResult with CANCELED status
+        """
+        return cls(
+            status=WorkflowStatus.CANCELED,
+            outputs=outputs or {},
+        )
+
+    @classmethod
+    def stopped(
+        cls,
+        outputs: dict[str, Any] | None = None,
+    ) -> TaskResult:
+        """
+        Create a stopped result.
+
+        Args:
+            outputs: Final outputs to preserve
+
+        Returns:
+            A TaskResult with STOPPED status
+        """
+        return cls(
+            status=WorkflowStatus.STOPPED,
+            outputs=outputs or {},
+        )
+
+    @classmethod
+    def redirect(
+        cls,
+        context: dict[str, Any] | None = None,
+    ) -> TaskResult:
+        """
+        Create a redirect result.
+
+        Indicates a decision branch should be followed.
+
+        Args:
+            context: Context for the redirect
+
+        Returns:
+            A TaskResult with REDIRECT status
+        """
+        return cls(
+            status=WorkflowStatus.REDIRECT,
+            context=context or {},
+        )
+
+    # ========== Builder Pattern ==========
+
+    @classmethod
+    def builder(cls, status: WorkflowStatus) -> TaskResultBuilder:
+        """
+        Create a builder for more complex results.
+
+        Args:
+            status: The execution status
+
+        Returns:
+            A TaskResultBuilder
+        """
+        return TaskResultBuilder(status)
+
+    # ========== Utility Methods ==========
+
+    def merge_outputs(self, other: TaskResult | None) -> TaskResult:
+        """
+        Merge outputs from another result.
+
+        Args:
+            other: Result to merge outputs from
+
+        Returns:
+            A new TaskResult with merged outputs
+        """
+        if other is None:
+            return self
+
+        merged_context = dict(self.context)
+        merged_context.update(other.context)
+
+        merged_outputs = dict(self.outputs)
+        merged_outputs.update(other.outputs)
+
+        return TaskResult(
+            status=self.status,
+            context=merged_context,
+            outputs=merged_outputs,
+        )
+
+
+class TaskResultBuilder:
+    """
+    Builder for TaskResult objects.
+
+    Provides a fluent API for constructing complex task results.
+    """
+
+    def __init__(self, status: WorkflowStatus) -> None:
+        self._status = status
+        self._context: dict[str, Any] = {}
+        self._outputs: dict[str, Any] = {}
+
+    def context(self, context: dict[str, Any]) -> TaskResultBuilder:
+        """Set the context."""
+        self._context = context
+        return self
+
+    def outputs(self, outputs: dict[str, Any]) -> TaskResultBuilder:
+        """Set the outputs."""
+        self._outputs = outputs
+        return self
+
+    def add_context(self, key: str, value: Any) -> TaskResultBuilder:
+        """Add a context value."""
+        self._context[key] = value
+        return self
+
+    def add_output(self, key: str, value: Any) -> TaskResultBuilder:
+        """Add an output value."""
+        self._outputs[key] = value
+        return self
+
+    def build(self) -> TaskResult:
+        """Build the TaskResult."""
+        return TaskResult(
+            status=self._status,
+            context=self._context,
+            outputs=self._outputs,
+        )

stabilize-0.9.2.dist-info/METADATA

@@ -0,0 +1,301 @@
+Metadata-Version: 2.4
+Name: stabilize
+Version: 0.9.2
+Summary: Highway Workflow Engine - Stabilize execution layer
+Project-URL: Homepage, https://github.com/rodmena-limited/stabilize
+Project-URL: Repository, https://github.com/rodmena-limited/stabilize
+Project-URL: Issues, https://github.com/rodmena-limited/stabilize/issues
+Author-email: Farshid Ashouri <farsheed.ashouri@gmail.com>
+License: Apache-2.0
+License-File: LICENSE
+Keywords: dag,orchestration,pipeline,task-runner,workflow
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.11
+Requires-Dist: pydantic>=2.0
+Requires-Dist: ulid-py>=1.1
+Provides-Extra: all
+Requires-Dist: psycopg[binary,pool]>=3.0; extra == 'all'
+Requires-Dist: ragit>=0.7.5; extra == 'all'
+Provides-Extra: dev
+Requires-Dist: mypy>=1.8; extra == 'dev'
+Requires-Dist: psycopg[binary,pool]>=3.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.1; extra == 'dev'
+Requires-Dist: testcontainers>=4.0; extra == 'dev'
+Provides-Extra: postgres
+Requires-Dist: psycopg[binary,pool]>=3.0; extra == 'postgres'
+Provides-Extra: rag
+Requires-Dist: ragit>=0.7.5; extra == 'rag'
+Description-Content-Type: text/markdown
+
+# Stabilize
+
+Highway Workflow Engine - Stabilize execution layer.
+
+A lightweight Python workflow execution engine with DAG-based stage orchestration.
+
+## Requirements
+
+- Python 3.11+
+- SQLite (included) or PostgreSQL 12+
+
+## Installation
+
+```bash
+pip install stabilize            # SQLite support only
+pip install stabilize[postgres]  # PostgreSQL support
+pip install stabilize[rag]       # RAG-powered pipeline generation
+pip install stabilize[all]       # All features
+```
+
+## Features
+
+- Message-driven DAG execution engine
+- Parallel and sequential stage execution
+- Synthetic stages (before/after/onFailure)
+- PostgreSQL and SQLite persistence
+- Pluggable task system
+- Retry and timeout support
+- RAG-powered pipeline generation from natural language
+
+## Quick Start
+
+```python
+from stabilize import Workflow, StageExecution, TaskExecution, WorkflowStatus
+from stabilize.persistence.sqlite import SqliteWorkflowStore
+from stabilize.queue.sqlite_queue import SqliteQueue
+from stabilize.queue.processor import QueueProcessor
+from stabilize.orchestrator import Orchestrator
+from stabilize.tasks.interface import Task
+from stabilize.tasks.result import TaskResult
+from stabilize.tasks.registry import TaskRegistry
+
+# Define a custom task
+class HelloTask(Task):
+    def execute(self, stage: StageExecution) -> TaskResult:
+        name = stage.context.get("name", "World")
+        return TaskResult.success(outputs={"greeting": f"Hello, {name}!"})
+
+# Create a workflow
+workflow = Workflow.create(
+    application="my-app",
+    name="Hello Workflow",
+    stages=[
+        StageExecution(
+            ref_id="1",
+            type="hello",
+            name="Say Hello",
+            tasks=[
+                TaskExecution.create(
+                    name="Hello Task",
+                    implementing_class="hello",
+                    stage_start=True,
+                    stage_end=True,
+                ),
+            ],
+            context={"name": "Stabilize"},
+        ),
+    ],
+)
+
+# Setup persistence and queue
+store = SqliteWorkflowStore(":memory:")
+queue = SqliteQueue(":memory:")
+
+# Register tasks
+registry = TaskRegistry()
+registry.register("hello", HelloTask)
+
+# Create processor and orchestrator
+processor = QueueProcessor.create(queue, store, registry)
+orchestrator = Orchestrator(queue)
+
+# Run workflow
+store.store(workflow)
+orchestrator.start(workflow)
+processor.process_all(timeout=10.0)
+
+# Check result
+result = store.retrieve(workflow.id)
+print(f"Status: {result.status}")  # WorkflowStatus.SUCCEEDED
+print(f"Output: {result.stages[0].outputs}")  # {'greeting': 'Hello, Stabilize!'}
+```
+
+## Parallel Stages
+
+Stages with shared dependencies run in parallel:
+
+```python
+#     Setup
+#    /     \
+#  Test   Lint
+#    \     /
+#    Deploy
+
+workflow = Workflow.create(
+    application="my-app",
+    name="CI/CD Pipeline",
+    stages=[
+        StageExecution(ref_id="setup", type="setup", name="Setup", ...),
+        StageExecution(ref_id="test", type="test", name="Test",
+                      requisite_stage_ref_ids={"setup"}, ...),
+        StageExecution(ref_id="lint", type="lint", name="Lint",
+                      requisite_stage_ref_ids={"setup"}, ...),
+        StageExecution(ref_id="deploy", type="deploy", name="Deploy",
+                      requisite_stage_ref_ids={"test", "lint"}, ...),
+    ],
+)
+```
+
+## Database Setup
+
+### SQLite
+
+No setup required. Schema is created automatically.
+
+### PostgreSQL
+
+Apply migrations using the CLI:
+
+```bash
+# Using mg.yaml in current directory
+stabilize mg-up
+
+# Using database URL
+stabilize mg-up --db-url postgres://user:pass@host:5432/dbname
+
+# Using environment variable
+MG_DATABASE_URL=postgres://user:pass@host:5432/dbname stabilize mg-up
+
+# Check migration status
+stabilize mg-status
+```
+
+Example mg.yaml:
+
+```yaml
+database:
+  host: localhost
+  port: 5432
+  user: postgres
+  password: postgres
+  dbname: stabilize
+```
+
+## RAG-Powered Pipeline Generation
+
+Stabilize includes an AI-powered assistant that generates pipeline code from natural language descriptions using RAG (Retrieval-Augmented Generation).
+
+### Requirements
+
+```bash
+pip install stabilize[rag]  # Installs ragit dependency
+```
+
+You also need:
+- **Local Ollama** (required for embeddings - ollama.com doesn't support embeddings API):
+  ```bash
+  # Install from https://ollama.com/download, then:
+  ollama serve                    # Start the server
+  ollama pull nomic-embed-text    # Download embedding model
+  ```
+- **Ollama API key** for LLM generation (uses ollama.com cloud)
+
+### Setup
+
+Create a `.env` file with your API key:
+
+```bash
+OLLAMA_API_KEY=your_api_key_here
+```
+
+Initialize the embedding cache:
+
+```bash
+# Initialize with default context (Stabilize docs + examples)
+stabilize rag init
+
+# Include your own code as additional training context
+stabilize rag init --additional-context /path/to/your/code/
+
+# Force regenerate embeddings
+stabilize rag init --force
+```
+
+### Generate Pipelines
+
+```bash
+# Generate a pipeline from natural language
+stabilize rag generate "create a pipeline that processes CSV files in parallel"
+
+# Save to file
+stabilize rag generate "build a CI/CD pipeline with test and deploy stages" > my_pipeline.py
+```
+
+### Clear Cache
+
+```bash
+stabilize rag clear
+```
+
+### Configuration
+
+Environment variables:
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `OLLAMA_API_KEY` | (required) | API key for ollama.com |
+| `OLLAMA_BASE_URL` | `https://ollama.com` | LLM endpoint URL |
+| `OLLAMA_EMBEDDING_URL` | `http://localhost:11434` | Local Ollama for embeddings |
+
+### Example
+
+```bash
+$ stabilize rag generate "create a hello world pipeline"
+
+from stabilize import Workflow, StageExecution, TaskExecution
+from stabilize.tasks.interface import Task
+from stabilize.tasks.result import TaskResult
+...
+```
+
+## CLI Reference
+
+```
+stabilize mg-up [--db-url URL]      Apply pending PostgreSQL migrations
+stabilize mg-status [--db-url URL]  Show migration status
+stabilize rag init [--force] [--additional-context PATH]  Initialize RAG embeddings
+stabilize rag generate "prompt"     Generate pipeline from natural language
+stabilize rag clear                 Clear embedding cache
+```
+
+## Naming Alignment with highway_dsl
+
+| highway_dsl | stabilize |
+|-------------|-----------|
+| Workflow | Workflow |
+| TaskOperator | Task interface |
+| RetryPolicy | RetryableTask |
+| TimeoutPolicy | OverridableTimeoutRetryableTask |
+
+## Running Tests
+
+```bash
+# All tests (requires Docker for PostgreSQL)
+pytest tests/ -v
+
+# SQLite tests only (no Docker)
+pytest tests/ -v -k sqlite
+```
+
+## License
+
+Apache 2.0

stabilize-0.9.2.dist-info/RECORD

@@ -0,0 +1,61 @@
+stabilize/__init__.py,sha256=uCpkXVvxBFFoVkifBcU8dIkzEPgtO2TpclYg-AgOLAs,784
+stabilize/cli.py,sha256=to-MY7GUZBAh_TcHhhPGh2LhuLOqR3ccJA78DTBksxM,41708
+stabilize/launcher.py,sha256=5POhM4ia1HMNoTFxfcQPB2QKbWVxlsOLadBTBteK5d4,8337
+stabilize/orchestrator.py,sha256=shpOToe4fXwjkSBjDu-k5hHlYIKNYRlwmCHsyn9gBdM,2716
+stabilize/context/__init__.py,sha256=nVL-uhufF8EPPGybnJ-Rxi0Nbm0leJjlQcWvb-IfGBo,140
+stabilize/context/stage_context.py,sha256=YsBFrzBLQwr5ymz8wszvestTi0nxPU0lVbd6ywlZolA,4900
+stabilize/dag/__init__.py,sha256=ooRWzJo4oz9P25MrQ-a-EoGKhTAxDy-tStCPYdB-WQA,352
+stabilize/dag/graph.py,sha256=n-ZQTxvOi_-XkoVoKJC6KhUFx78yYpmi4wjiG7Q4ENE,6373
+stabilize/dag/topological.py,sha256=VVhgW5JLaMM52dIpAzv7DRcLuqCCvuo97G-USRSSTX4,6069
+stabilize/handlers/__init__.py,sha256=N4D2u1FLgbEcF6A8PR1Klbv8mcE4O38Mx91im18VQbw,1651
+stabilize/handlers/base.py,sha256=KWXeK053y8g8_ktGk3DTsTRHPFKGN8mjvs1r1ElFs8Q,6726
+stabilize/handlers/complete_stage.py,sha256=UbNCIVjWfx7G4sFWgZ_WobpOV-Trq32ATLwoxuY-A40,7970
+stabilize/handlers/complete_task.py,sha256=Ps-M_8FmHrTSQexDjec0JmdP-sQq_6Gl3MCxUXUzOls,2193
+stabilize/handlers/complete_workflow.py,sha256=y_n21xEYOt20tDxKkICboOX5DXiZ_HoSyCtw2soPSjA,5293
+stabilize/handlers/run_task.py,sha256=xqBpQi_yhcB8DJBMApatkrPE5PuCkMnIFVKbVHQ1cm0,12166
+stabilize/handlers/start_stage.py,sha256=Kjfs0Anjh3nUdCU_aHwVEZChztcooR1Mlztufsa9ffM,8638
+stabilize/handlers/start_task.py,sha256=gOZaO4dg9QAfiT66nhBX-DkeK7J_JcHkVFRwNIdxfK0,2025
+stabilize/handlers/start_workflow.py,sha256=Yd-kn1K41VVHbCh0YJQRAiDMdBnGRdrQE-VUVYqI5G8,4506
+stabilize/migrations/__init__.py,sha256=oHEHbvHO3OeV4l3ggstDBz5olXHFiozcIKOZtjAf6vo,52
+stabilize/models/__init__.py,sha256=MB-4rQd7VCdoXPyb1uYsKe1eMgp3M_ibdlfGfyNmIdo,422
+stabilize/models/stage.py,sha256=9gxfZL4yCeH5zBaxCRpYflS7noCxdZZ_7nrn_zPJ2VQ,13579
+stabilize/models/status.py,sha256=DAdvzuQi_AjD37Y2SOFC5H_V5jUDKjxRj-OE3OwmOgA,4150
+stabilize/models/task.py,sha256=hOSm4l7EadfuZzINXc9GAitkyzJku1KkK_noEztble0,3812
+stabilize/models/workflow.py,sha256=qL4t-8D7kkmOyJaCPnOQDSFkv7LkgFOkLFsgIhl_MnE,9883
+stabilize/persistence/__init__.py,sha256=fArCMlwW9f00C0iU1Ew7Fwu1K3M9auOGm5kmPzKHH8Q,723
+stabilize/persistence/connection.py,sha256=j5qqHN2u0_egswU6FMXAM9HxSuvaOOCBvXQKiYPIklI,6484
+stabilize/persistence/factory.py,sha256=MVJVZuiawygKOZnNrVJcmQKlcjTWJK2V4YXmF2nhIUY,3816
+stabilize/persistence/memory.py,sha256=F_aOr5rYY0suYmfDsp__lbeW4rWkpE2erm6GyCZ1YME,7351
+stabilize/persistence/postgres.py,sha256=NzuywAb9Cw5KK1hy2Hik-83Ygmqed30XysQSBki_JdA,25775
+stabilize/persistence/sqlite.py,sha256=vrkXHQmS_XTFU08-djgA1XbkjZkn1pPCWbkGpF8lhfQ,24289
+stabilize/persistence/store.py,sha256=JhpvfYSOgR_SkAZps5yp22So2Gd4n1NUtTpWExiRfCE,5267
+stabilize/queue/__init__.py,sha256=4AlZ9ywOHhlEoGErF8F1I1HACsFRnU1KxnpPo3KIvpM,1187
+stabilize/queue/messages.py,sha256=eSQp5lK0oeLlUenwIJQiLTWRYT5JfvjLyZ-MWKqI3w0,8333
+stabilize/queue/processor.py,sha256=qPqxQlwpsC4J6mrXpeoIz1eM397696I2mNdR1V_EJmU,9073
+stabilize/queue/queue.py,sha256=-L32SLnk403ZV_qeQfFDJ1G6svX5G3IZdwrX2-RmPs0,16436
+stabilize/queue/sqlite_queue.py,sha256=7hxeI7Q317pY2JpP4GIGdYJZbDKM2LgiuCLTj3GBH5U,11538
+stabilize/rag/__init__.py,sha256=ID5zjgtzMY2zAx-VTJ1ESRqFjnA73WR-gPBsBU90xdE,378
+stabilize/rag/assistant.py,sha256=jmElT5ZgFQu3it81lvBPc81bUB0jLGIvUMdywRKn3Eg,17273
+stabilize/rag/cache.py,sha256=oXCYnX6dJRvKHtBHe3Zr5YPivumHh73Cg_4EQOOX_zo,9697
+stabilize/stages/__init__.py,sha256=cQJkyv8bkQ5Je-DNIo5oVl4YoFxHSNydC402TQk5zkg,243
+stabilize/stages/builder.py,sha256=zUu9IznW_DhYrBXiMCCX2owOgxxlBvuJ8iAaDWJuGwg,7133
+stabilize/tasks/__init__.py,sha256=Mgz08g1DYgpKy8MhmopwupNTeSL6cCbYJEvcb4F4fVo,374
+stabilize/tasks/interface.py,sha256=8cocNsfHWNHzOf9XtMTRd2ctdyJvp2AOgb4G_SXvgDM,8990
+stabilize/tasks/registry.py,sha256=wMi7IFkBGn5iweXp2QRs7a33RJjhqGd_e7yP4qHUXkc,7006
+stabilize/tasks/result.py,sha256=7U5p-pZguNvX8M1lyDkbWKTbn9-2T7qzGS7rshRz3Bc,7096
+stabilize/examples/__init__.py,sha256=8zCTqVKrDmMPslObBLBaX7TO1_yHThnvbZfyMbSR_Fk,51
+stabilize/examples/docker-example.py,sha256=s9-OKEQIaNQJvJVZ_NCoQuxBmEyDJTCJmBmZ8kpOrig,25358
+stabilize/examples/golden-standard-expected-result.txt,sha256=igeb_4YtZkO20wh91PELrDwk-BcVG4L9BZS4kp3KUj8,183
+stabilize/examples/golden-standard.py,sha256=hVq2Y0CTuNYNhJPikAjMWBQQVL5QfnrxLuW90SyRqW4,16716
+stabilize/examples/http-example.py,sha256=oUg__SrWXITzt9i11csXIgvQMUoXC_V2eb4pexh_hCc,20792
+stabilize/examples/llama-example.py,sha256=TG2PfWeDf8dtL1HzevGZTbv6vD8eI79_wG8WZ9mp8Uo,23743
+stabilize/examples/python-example.py,sha256=rIeLRntA_xoivWMf1CmwZh1-zFKd9bJFUwUkOp-317s,23061
+stabilize/examples/shell-example.py,sha256=OeHa9ZyGdbcdeCullRqFbnuChmX1V9f2NiJYTEUSvk0,13851
+stabilize/examples/ssh-example.py,sha256=m0TLyZgmcjA1i8fG-O29VY6k3DcPGHA8sT-iLyA-teU,20329
+stabilize/migrations/01KDQ4N9QPJ6Q4MCV3V9GHWPV4_initial_schema.sql,sha256=HQxEBsQ7HQZf1cSSsrHZuRaHKOuDNGHrYF71OC29ot0,3244
+stabilize/migrations/01KDRK3TXW4R2GERC1WBCQYJGG_rag_embeddings.sql,sha256=GlS7EFDb0HZ_R5aD1Uv38_zyquP-iBdaA3kDqDUbh64,720
+stabilize-0.9.2.dist-info/METADATA,sha256=fjPI_LLf6na5ZdnKk9e_5eoK09bbg52xaTSpJAxgZBY,8167
+stabilize-0.9.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+stabilize-0.9.2.dist-info/entry_points.txt,sha256=m2JqUEJIa-jJF1mljmS470__o4UnuVt__IlhhrclS8U,49
+stabilize-0.9.2.dist-info/licenses/LICENSE,sha256=2KBcAK1QM2XEtDBVt3osZV0xnwYlS_F8iFeKLtYSbM0,11345
+stabilize-0.9.2.dist-info/RECORD,,

stabilize-0.9.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

stabilize-0.9.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+stabilize = stabilize.cli:main