fraiseql-confiture 0.1.0__cp311-cp311-manylinux_2_34_x86_64.whl

confiture/models/migration.py

@@ -0,0 +1,95 @@
+"""Migration base class for database migrations."""
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+import psycopg
+
+
+class Migration(ABC):
+    """Base class for all database migrations.
+
+    Each migration must:
+    - Define a version (e.g., "001", "002")
+    - Define a name (e.g., "create_users")
+    - Implement up() method for applying the migration
+    - Implement down() method for rolling back the migration
+
+    Example:
+        >>> class CreateUsers(Migration):
+        ...     version = "001"
+        ...     name = "create_users"
+        ...
+        ...     def up(self):
+        ...         self.execute('''
+        ...             CREATE TABLE users (
+        ...                 id SERIAL PRIMARY KEY,
+        ...                 username TEXT NOT NULL
+        ...             )
+        ...         ''')
+        ...
+        ...     def down(self):
+        ...         self.execute('DROP TABLE users')
+    """
+
+    # Subclasses must define these
+    version: str
+    name: str
+
+    def __init__(self, connection: psycopg.Connection):
+        """Initialize migration with database connection.
+
+        Args:
+            connection: psycopg3 database connection
+
+        Raises:
+            TypeError: If version or name not defined in subclass
+        """
+        self.connection = connection
+
+        # Ensure subclass defined version and name
+        if not hasattr(self.__class__, "version") or self.__class__.version is None:
+            raise TypeError(f"{self.__class__.__name__} must define a 'version' class attribute")
+        if not hasattr(self.__class__, "name") or self.__class__.name is None:
+            raise TypeError(f"{self.__class__.__name__} must define a 'name' class attribute")
+
+    @abstractmethod
+    def up(self) -> None:
+        """Apply the migration.
+
+        This method must be implemented by subclasses to perform
+        the forward migration (e.g., CREATE TABLE, ALTER TABLE).
+
+        Raises:
+            NotImplementedError: If not implemented by subclass
+        """
+        raise NotImplementedError(f"{self.__class__.__name__}.up() must be implemented")
+
+    @abstractmethod
+    def down(self) -> None:
+        """Rollback the migration.
+
+        This method must be implemented by subclasses to perform
+        the reverse migration (e.g., DROP TABLE, revert ALTER).
+
+        Raises:
+            NotImplementedError: If not implemented by subclass
+        """
+        raise NotImplementedError(f"{self.__class__.__name__}.down() must be implemented")
+
+    def execute(self, sql: str, params: tuple[Any, ...] | None = None) -> None:
+        """Execute a SQL statement.
+
+        Args:
+            sql: SQL statement to execute
+            params: Optional query parameters (for parameterized queries)
+
+        Example:
+            >>> self.execute("CREATE TABLE users (id INT)")
+            >>> self.execute("INSERT INTO users (name) VALUES (%s)", ("Alice",))
+        """
+        with self.connection.cursor() as cursor:
+            if params:
+                cursor.execute(sql, params)
+            else:
+                cursor.execute(sql)

confiture/models/schema.py

@@ -0,0 +1,203 @@
+"""Data models for schema representation.
+
+These models represent database schema objects (tables, columns, indexes, etc.)
+in a structured format for diff detection and comparison.
+"""
+
+from dataclasses import dataclass, field
+from enum import Enum
+
+
+class ColumnType(str, Enum):
+    """PostgreSQL column types."""
+
+    # Integer types
+    SMALLINT = "SMALLINT"
+    INTEGER = "INTEGER"
+    BIGINT = "BIGINT"
+    SERIAL = "SERIAL"
+    BIGSERIAL = "BIGSERIAL"
+
+    # Numeric types
+    NUMERIC = "NUMERIC"
+    DECIMAL = "DECIMAL"
+    REAL = "REAL"
+    DOUBLE_PRECISION = "DOUBLE PRECISION"
+
+    # Text types
+    VARCHAR = "VARCHAR"
+    CHAR = "CHAR"
+    TEXT = "TEXT"
+
+    # Boolean
+    BOOLEAN = "BOOLEAN"
+
+    # Date/Time
+    DATE = "DATE"
+    TIME = "TIME"
+    TIMESTAMP = "TIMESTAMP"
+    TIMESTAMPTZ = "TIMESTAMPTZ"
+
+    # UUID
+    UUID = "UUID"
+
+    # JSON
+    JSON = "JSON"
+    JSONB = "JSONB"
+
+    # Binary
+    BYTEA = "BYTEA"
+
+    # Unknown/Custom
+    UNKNOWN = "UNKNOWN"
+
+
+@dataclass
+class Column:
+    """Represents a database column."""
+
+    name: str
+    type: ColumnType
+    nullable: bool = True
+    default: str | None = None
+    primary_key: bool = False
+    unique: bool = False
+    length: int | None = None  # For VARCHAR(n), etc.
+
+    def __eq__(self, other: object) -> bool:
+        """Compare columns for equality."""
+        if not isinstance(other, Column):
+            return NotImplemented
+        return (
+            self.name == other.name
+            and self.type == other.type
+            and self.nullable == other.nullable
+            and self.default == other.default
+            and self.primary_key == other.primary_key
+            and self.unique == other.unique
+            and self.length == other.length
+        )
+
+    def __hash__(self) -> int:
+        """Make column hashable for use in sets."""
+        return hash(
+            (
+                self.name,
+                self.type,
+                self.nullable,
+                self.default,
+                self.primary_key,
+                self.unique,
+                self.length,
+            )
+        )
+
+
+@dataclass
+class Table:
+    """Represents a database table."""
+
+    name: str
+    columns: list[Column] = field(default_factory=list)
+    indexes: list[str] = field(default_factory=list)  # Simplified for MVP
+    constraints: list[str] = field(default_factory=list)  # Simplified for MVP
+
+    def get_column(self, name: str) -> Column | None:
+        """Get column by name."""
+        for col in self.columns:
+            if col.name == name:
+                return col
+        return None
+
+    def has_column(self, name: str) -> bool:
+        """Check if table has column."""
+        return self.get_column(name) is not None
+
+    def __eq__(self, other: object) -> bool:
+        """Compare tables for equality."""
+        if not isinstance(other, Table):
+            return NotImplemented
+        return (
+            self.name == other.name
+            and self.columns == other.columns
+            and self.indexes == other.indexes
+            and self.constraints == other.constraints
+        )
+
+
+@dataclass
+class Schema:
+    """Represents a complete database schema."""
+
+    tables: list[Table] = field(default_factory=list)
+
+    def get_table(self, name: str) -> Table | None:
+        """Get table by name."""
+        for table in self.tables:
+            if table.name == name:
+                return table
+        return None
+
+    def has_table(self, name: str) -> bool:
+        """Check if schema has table."""
+        return self.get_table(name) is not None
+
+    def table_names(self) -> list[str]:
+        """Get list of all table names."""
+        return [table.name for table in self.tables]
+
+
+@dataclass
+class SchemaChange:
+    """Represents a single change between two schemas."""
+
+    type: str  # ADD_TABLE, DROP_TABLE, ADD_COLUMN, etc.
+    table: str | None = None
+    column: str | None = None
+    old_value: str | None = None
+    new_value: str | None = None
+    details: dict[str, str] | None = None
+
+    def __str__(self) -> str:
+        """String representation of change."""
+        if self.type == "ADD_TABLE":
+            return f"ADD TABLE {self.table}"
+        elif self.type == "DROP_TABLE":
+            return f"DROP TABLE {self.table}"
+        elif self.type == "RENAME_TABLE":
+            return f"RENAME TABLE {self.old_value} TO {self.new_value}"
+        elif self.type == "ADD_COLUMN":
+            return f"ADD COLUMN {self.table}.{self.column}"
+        elif self.type == "DROP_COLUMN":
+            return f"DROP COLUMN {self.table}.{self.column}"
+        elif self.type == "RENAME_COLUMN":
+            return f"RENAME COLUMN {self.table}.{self.old_value} TO {self.new_value}"
+        elif self.type == "CHANGE_COLUMN_TYPE":
+            return f"CHANGE COLUMN TYPE {self.table}.{self.column} FROM {self.old_value} TO {self.new_value}"
+        elif self.type == "CHANGE_COLUMN_NULLABLE":
+            return f"CHANGE COLUMN NULLABLE {self.table}.{self.column} FROM {self.old_value} TO {self.new_value}"
+        elif self.type == "CHANGE_COLUMN_DEFAULT":
+            return f"CHANGE COLUMN DEFAULT {self.table}.{self.column}"
+        else:
+            return f"{self.type}: {self.table}.{self.column if self.column else ''}"
+
+
+@dataclass
+class SchemaDiff:
+    """Represents the difference between two schemas."""
+
+    changes: list[SchemaChange] = field(default_factory=list)
+
+    def has_changes(self) -> bool:
+        """Check if there are any changes."""
+        return len(self.changes) > 0
+
+    def count_by_type(self, change_type: str) -> int:
+        """Count changes of a specific type."""
+        return sum(1 for c in self.changes if c.type == change_type)
+
+    def __str__(self) -> str:
+        """String representation of diff."""
+        if not self.has_changes():
+            return "No changes detected"
+        return "\n".join(str(c) for c in self.changes)

fraiseql_confiture-0.1.0.dist-info/METADATA

@@ -0,0 +1,350 @@
+Metadata-Version: 2.4
+Name: fraiseql-confiture
+Version: 0.1.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT 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: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: typer>=0.12.0
+Requires-Dist: rich>=13.7.0
+Requires-Dist: pydantic>=2.5.0
+Requires-Dist: pyyaml>=6.0.1
+Requires-Dist: psycopg[binary]>=3.1.0
+Requires-Dist: sqlparse>=0.5.0
+Requires-Dist: pytest>=8.0.0 ; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23.0 ; extra == 'dev'
+Requires-Dist: pytest-cov>=4.1.0 ; extra == 'dev'
+Requires-Dist: pytest-watch>=4.2.0 ; extra == 'dev'
+Requires-Dist: ruff>=0.6.0 ; extra == 'dev'
+Requires-Dist: mypy>=1.11.0 ; extra == 'dev'
+Requires-Dist: pre-commit>=3.5.0 ; extra == 'dev'
+Requires-Dist: types-pyyaml>=6.0.0 ; extra == 'dev'
+Requires-Dist: maturin>=1.7.0 ; extra == 'dev'
+Provides-Extra: dev
+Provides-Extra: fraiseql
+License-File: LICENSE
+Summary: PostgreSQL migrations, sweetly done 🍓
+Keywords: postgresql,migration,database,schema,ddl
+Home-Page: https://github.com/fraiseql/confiture
+Author-email: evoludigit <lionel@fraiseql.com>
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/fraiseql/confiture
+Project-URL: Documentation, https://github.com/fraiseql/confiture
+Project-URL: Repository, https://github.com/fraiseql/confiture
+Project-URL: Issues, https://github.com/fraiseql/confiture/issues
+Project-URL: FraiseQL, https://github.com/fraiseql/fraiseql
+
+# Confiture 🍓
+
+**PostgreSQL migrations, sweetly done**
+
+Confiture is the official migration tool for [FraiseQL](https://github.com/fraiseql/fraiseql), designed with a **build-from-scratch philosophy** and **4 migration strategies** to handle every scenario from local development to zero-downtime production deployments.
+
+> **Part of the FraiseQL ecosystem** - While Confiture works standalone for any PostgreSQL project, it's designed to integrate seamlessly with FraiseQL's GraphQL-first approach.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
+[![PostgreSQL 12+](https://img.shields.io/badge/PostgreSQL-12%2B-blue?logo=postgresql&logoColor=white)](https://www.postgresql.org/)
+[![CI](https://img.shields.io/github/actions/workflow/status/fraiseql/confiture/ci.yml?branch=main&label=CI&logo=github)](https://github.com/fraiseql/confiture/actions/workflows/ci.yml)
+[![Code style: ruff](https://img.shields.io/badge/code%20style-ruff-000000.svg)](https://github.com/astral-sh/ruff)
+[![Type checked: mypy](https://img.shields.io/badge/type%20checked-mypy-blue.svg)](https://github.com/python/mypy)
+[![Made with Rust](https://img.shields.io/badge/Made%20with-Rust-orange?logo=rust)](https://www.rust-lang.org/)
+[![Part of FraiseQL](https://img.shields.io/badge/Part%20of-FraiseQL-ff69b4)](https://github.com/fraiseql/fraiseql)
+[![Status: Beta](https://img.shields.io/badge/status-beta-orange)](https://github.com/fraiseql/confiture)
+
+---
+
+## Why Confiture?
+
+Traditional migration tools (Alembic, Django migrations) **replay migration history** to build databases. This is slow and brittle.
+
+Confiture treats **DDL source files as the single source of truth**:
+
+- ✅ **Fresh databases in <1 second** (not minutes)
+- ✅ **4 migration strategies** (simple ALTER to zero-downtime FDW)
+- ✅ **Production data sync** built-in (with PII anonymization)
+- ✅ **Python + Rust performance** (10-50x faster than pure Python)
+- ✅ **Perfect with FraiseQL**, useful for everyone
+
+---
+
+## The Four Mediums
+
+### 1️⃣ Build from DDL
+```bash
+confiture build --env production
+```
+Build fresh database from `db/schema/` DDL files in <1 second.
+
+### 2️⃣ Incremental Migrations (ALTER)
+```bash
+confiture migrate up
+```
+Apply migrations to existing database (simple schema changes).
+
+### 3️⃣ Production Data Sync
+```bash
+confiture sync --from production --anonymize users.email
+```
+Copy production data to local/staging with PII anonymization.
+
+### 4️⃣ Schema-to-Schema Migration (Zero-Downtime)
+```bash
+confiture migrate schema-to-schema --strategy fdw
+```
+Complex migrations via FDW with 0-5 second downtime.
+
+---
+
+## Quick Start
+
+### Installation
+
+```bash
+pip install fraiseql-confiture
+
+# Or with FraiseQL integration
+pip install fraiseql-confiture[fraiseql]
+```
+
+### Initialize Project
+
+```bash
+confiture init
+```
+
+Creates:
+```
+db/
+├── schema/           # DDL: CREATE TABLE, views, functions
+│   ├── 00_common/
+│   ├── 10_tables/
+│   └── 20_views/
+├── seeds/            # INSERT: Environment-specific test data
+│   ├── common/
+│   ├── development/
+│   └── test/
+├── migrations/       # Generated migration files
+└── environments/     # Environment configurations
+    ├── local.yaml
+    ├── test.yaml
+    └── production.yaml
+```
+
+### Build Schema
+
+```bash
+# Build local database
+confiture build --env local
+
+# Build production schema
+confiture build --env production
+```
+
+### Create Migration
+
+```bash
+# Edit schema
+vim db/schema/10_tables/users.sql
+
+# Generate migration
+confiture migrate generate --name "add_user_bio"
+
+# Apply migration
+confiture migrate up
+```
+
+---
+
+## Documentation
+
+### 📖 User Guides
+- **[Medium 1: Build from DDL](docs/guides/medium-1-build-from-ddl.md)** - Fresh databases in <1 second
+- **[Medium 2: Incremental Migrations](docs/guides/medium-2-incremental-migrations.md)** - ALTER-based changes
+- **[Medium 3: Production Data Sync](docs/guides/medium-3-production-sync.md)** - Copy and anonymize data
+- **[Medium 4: Zero-Downtime Migrations](docs/guides/medium-4-schema-to-schema.md)** - Schema-to-schema via FDW
+- **[Migration Decision Tree](docs/guides/migration-decision-tree.md)** - Choose the right strategy
+
+### 📚 API Reference
+- **[CLI Reference](docs/reference/cli.md)** - All commands documented
+- **[Configuration Reference](docs/reference/configuration.md)** - Environment configuration
+- **[Schema Builder API](docs/api/builder.md)** - Building schemas programmatically
+- **[Migrator API](docs/api/migrator.md)** - Migration execution
+- **[Syncer API](docs/api/syncer.md)** - Production data sync
+- **[Schema-to-Schema API](docs/api/schema-to-schema.md)** - Zero-downtime migrations
+
+### 💡 Examples
+- **[Examples Overview](examples/)** - 5 complete production examples
+- **[Basic Migration](examples/01-basic-migration/)** - Learn the fundamentals (15 min)
+- **[FraiseQL Integration](examples/02-fraiseql-integration/)** - GraphQL workflow (20 min)
+- **[Zero-Downtime](examples/03-zero-downtime-migration/)** - Production deployment (30 min)
+- **[Production Sync](examples/04-production-sync-anonymization/)** - PII anonymization (25 min)
+- **[Multi-Environment Workflow](examples/05-multi-environment-workflow/)** - Complete CI/CD (30 min)
+
+---
+
+## Features
+
+### ✅ Complete (Phases 1-3)
+
+**Core Migration System**:
+- ✅ Build from DDL (Medium 1) - Fresh databases in <1 second
+- ✅ Incremental migrations (Medium 2) - Simple ALTER-based changes
+- ✅ Production data sync (Medium 3) - Copy with PII anonymization
+- ✅ Zero-downtime migrations (Medium 4) - Schema-to-schema via FDW
+
+**Performance & Distribution**:
+- ✅ **Rust performance layer** (10-50x speedup) 🚀
+- ✅ **Binary wheels** for Linux, macOS, Windows
+- ✅ Parallel migration execution
+- ✅ Progress tracking with resumability
+
+**Developer Experience**:
+- ✅ Environment-specific seed data (development/test/production)
+- ✅ Schema diff detection with auto-generation
+- ✅ CLI with rich terminal output and colors
+- ✅ Comprehensive documentation (5 guides, 4 API docs)
+- ✅ Production-ready examples (5 complete scenarios)
+
+**Integration & Safety**:
+- ✅ FraiseQL GraphQL integration
+- ✅ Multi-environment configuration
+- ✅ Transaction safety with rollback support
+- ✅ PII anonymization with compliance tools
+- ✅ CI/CD pipeline examples (GitHub Actions)
+
+### 🚧 Coming Soon (Phase 4)
+- Advanced migration hooks (before/after)
+- Custom anonymization strategies
+- Interactive migration wizard
+- Migration dry-run mode
+- Database schema linting
+
+---
+
+## Comparison
+
+| Feature | Alembic | pgroll | **Confiture** |
+|---------|---------|--------|---------------|
+| **Philosophy** | Migration replay | Multi-version schema | **Build-from-DDL** |
+| **Fresh DB setup** | Minutes | Minutes | **<1 second** |
+| **Zero-downtime** | ❌ No | ✅ Yes | **✅ Yes (FDW)** |
+| **Production sync** | ❌ No | ❌ No | **✅ Built-in** |
+| **Language** | Python | Go | **Python + Rust** |
+
+---
+
+## Development Status
+
+**Current Version**: 0.1.0 (Initial PyPI Release) 🎉
+
+**Milestone Progress**:
+- ✅ Phase 1: Python MVP (Complete - Oct 2025)
+- ✅ Phase 2: Rust Performance Layer (Complete - Oct 2025)
+- ✅ Phase 3: Production Features (Complete - Oct 2025)
+  - ✅ Zero-downtime migrations (FDW)
+  - ✅ Production data sync with PII anonymization
+  - ✅ Comprehensive documentation (5 guides, 4 API references)
+  - ✅ Production examples (5 complete scenarios)
+- ⏳ Phase 4: Advanced Features (Q1 2026)
+  - Migration hooks, wizards, dry-run mode
+
+**Statistics**:
+- 📦 4 migration strategies implemented
+- 📖 5 comprehensive user guides
+- 📚 4 API reference pages
+- 💡 5 production-ready examples
+- 🧪 95% test coverage
+- ⚡ 10-50x performance with Rust
+
+See [PHASES.md](PHASES.md) for detailed roadmap.
+
+---
+
+## Contributing
+
+Contributions welcome! We'd love your help making Confiture even better.
+
+**Quick Start**:
+```bash
+# Clone repository
+git clone https://github.com/fraiseql/confiture.git
+cd confiture
+
+# Install dependencies (includes Rust build)
+uv sync --all-extras
+
+# Build Rust extension
+uv run maturin develop
+
+# Run tests
+uv run pytest --cov=confiture
+
+# Format code
+uv run ruff format .
+
+# Type checking
+uv run mypy python/confiture/
+```
+
+**Resources**:
+- **[CONTRIBUTING.md](CONTRIBUTING.md)** - Contributing guidelines
+- **[CLAUDE.md](CLAUDE.md)** - AI-assisted development guide
+- **[PHASES.md](PHASES.md)** - Detailed roadmap
+
+**What to contribute**:
+- 🐛 Bug fixes
+- ✨ New features
+- 📖 Documentation improvements
+- 💡 New examples
+- 🧪 Test coverage improvements
+
+---
+
+## Author
+
+**Vibe-engineered by [Lionel Hamayon](https://github.com/LionelHamayon)** 🍓
+
+Confiture was crafted with care as the migration tool for the FraiseQL ecosystem, combining the elegance of Python with the performance of Rust, and the sweetness of strawberry jam.
+
+---
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+Copyright (c) 2025 Lionel Hamayon
+
+---
+
+## Acknowledgments
+
+- Inspired by printoptim_backend's build-from-scratch approach
+- Built for [FraiseQL](https://github.com/fraiseql/fraiseql) GraphQL framework
+- Influenced by pgroll, Alembic, and Reshape
+- Developed with AI-assisted vibe engineering ✨
+
+---
+
+## FraiseQL Ecosystem
+
+Confiture is part of the FraiseQL family:
+
+- **[FraiseQL](https://github.com/fraiseql/fraiseql)** - Modern GraphQL framework for Python
+- **[Confiture](https://github.com/fraiseql/confiture)** - PostgreSQL migration tool (you are here)
+
+---
+
+*Making jam from strawberries, one migration at a time.* 🍓→🍯
+
+*Vibe-engineered with ❤️ by Lionel Hamayon*
+
+**[Documentation](https://github.com/fraiseql/confiture)** • **[GitHub](https://github.com/fraiseql/confiture)** • **[PyPI](https://pypi.org/project/fraiseql-confiture/)**
+

fraiseql_confiture-0.1.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+confiture/__init__.py,sha256=tCAHIJRp5S5JI_5rzwmI_jqOSJKy0QuOuSzPv3l2lhI,1162
+confiture/_core.cpython-311-x86_64-linux-gnu.so,sha256=YNx1x-t6ulDeH03S5qK9V3LyycIPJE86Rru_GU7Hj34,504496
+confiture/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+confiture/cli/main.py,sha256=iYFN2hgkK6a_sbKrkpq6rMmdQvi58EOW7ojOaTfs0g4,22479
+confiture/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+confiture/config/environment.py,sha256=8o2Dt6fko6Ovvn1GBW76l_zjaZABIHk5DKqBbfGcMTA,6229
+confiture/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+confiture/core/builder.py,sha256=PlFiyD1T81briS25LkYm0EbQjo34VDBKcAGlmn7H4rc,11388
+confiture/core/connection.py,sha256=s6ZACflypVRYUc9MZ9KNZuFObbtYjLWQbcGN5ebisaw,3397
+confiture/core/differ.py,sha256=etICDfHY9wOvqxFkiwuVIbHS7N8gmKG04qhbfWtB2t0,18024
+confiture/core/migration_generator.py,sha256=-vOzZO8ENjJqDUOaNsE6s28SgxQXP9NYDwgV_7RiYW4,9732
+confiture/core/migrator.py,sha256=m-__eQ-ArzZ_Vgd0Vo0kFkjb9G6EQl-QRhmcw0ocFoQ,13352
+confiture/core/schema_to_schema.py,sha256=ZilXOhK4O_SStqzqG3oztNpakskF2BW74bA4buZnKz8,22292
+confiture/core/syncer.py,sha256=d1b4u1QjrRaw2jia37wiNVZYZ51GaKoJ1E7dJ3vCeM0,18393
+confiture/exceptions.py,sha256=wuSzE-XpX5QeZEqNQqi85efKu5l2-QUhmBbjDLKm02w,3339
+confiture/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+confiture/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+confiture/models/migration.py,sha256=KcTY2EUCrsFOqogoAzVDpZAoQAKFFaH13-Zyjf-yYfg,3106
+confiture/models/schema.py,sha256=9zQzyyw35HR0T1b0T9hI9xoripdTeWLDFTnO_ibcrMI,5909
+fraiseql_confiture-0.1.0.dist-info/METADATA,sha256=t_i1-h4Bq0oSaWT6zDX25vwwfCrPjnbRsk30CA5X1us,11826
+fraiseql_confiture-0.1.0.dist-info/WHEEL,sha256=OVlAaljgWPhfhJRVM6VsLWLOev5VbYFkuMRMXaOVkcY,108
+fraiseql_confiture-0.1.0.dist-info/entry_points.txt,sha256=nRq8YKFFl7Pr0462GxN2Y1PAe77UJVXC0xrw92qnZks,51
+fraiseql_confiture-0.1.0.dist-info/licenses/LICENSE,sha256=c6fKI61h1Rn-8ZkldOQxeyxEQYfzjpXpu_HgVjSu1ZI,1071
+fraiseql_confiture-0.1.0.dist-info/RECORD,,

fraiseql_confiture-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.9.6)
+Root-Is-Purelib: false
+Tag: cp311-cp311-manylinux_2_34_x86_64

fraiseql_confiture-0.1.0.dist-info/entry_points.txt

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