cinchdb 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

cinchdb/managers/table.py

@@ -95,13 +95,13 @@ class TableManager:
         for column in columns:
             if column.foreign_key:
                 fk = column.foreign_key
-                
+
                 # Validate referenced table exists
                 if not self._table_exists(fk.table):
                     raise ValueError(
                         f"Foreign key reference to non-existent table: '{fk.table}'"
                     )
-                
+
                 # Validate referenced column exists
                 ref_table = self.get_table(fk.table)
                 ref_col_names = [col.name for col in ref_table.columns]
@@ -109,9 +109,11 @@ class TableManager:
                     raise ValueError(
                         f"Foreign key reference to non-existent column: '{fk.table}.{fk.column}'"
                     )
-                
+
                 # Build foreign key constraint
-                fk_constraint = f"FOREIGN KEY ({column.name}) REFERENCES {fk.table}({fk.column})"
+                fk_constraint = (
+                    f"FOREIGN KEY ({column.name}) REFERENCES {fk.table}({fk.column})"
+                )
                 if fk.on_delete != "RESTRICT":
                     fk_constraint += f" ON DELETE {fk.on_delete}"
                 if fk.on_update != "RESTRICT":
@@ -143,7 +145,7 @@ class TableManager:
                 col_def += " UNIQUE"
 
             sql_parts.append(col_def)
-        
+
         # Add foreign key constraints
         sql_parts.extend(foreign_key_constraints)
 
@@ -201,16 +203,17 @@ class TableManager:
                 to_col = fk_row["to"]
                 on_update = fk_row["on_update"]
                 on_delete = fk_row["on_delete"]
-                
+
                 # Create ForeignKeyRef
                 from cinchdb.models import ForeignKeyRef
+
                 foreign_keys[from_col] = ForeignKeyRef(
                     table=to_table,
                     column=to_col,
                     on_update=on_update,
-                    on_delete=on_delete
+                    on_delete=on_delete,
                 )
-            
+
             # Get column information
             cursor = conn.execute(f"PRAGMA table_info({table_name})")
 
@@ -241,7 +244,7 @@ class TableManager:
                     nullable=(row["notnull"] == 0),
                     default=row["dflt_value"],
                     primary_key=(row["pk"] == 1),
-                    foreign_key=foreign_key
+                    foreign_key=foreign_key,
                 )
                 columns.append(column)
 

cinchdb/managers/tenant.py

@@ -70,7 +70,7 @@ class TenantManager:
         """
         # Validate tenant name
         validate_name(tenant_name, "tenant")
-        
+
         # Check maintenance mode
         check_maintenance_mode(self.project_root, self.database, self.branch)
 
@@ -168,7 +168,7 @@ class TenantManager:
         """
         # Validate target tenant name
         validate_name(target_tenant, "tenant")
-        
+
         # Check maintenance mode
         check_maintenance_mode(self.project_root, self.database, self.branch)
 
@@ -213,7 +213,7 @@ class TenantManager:
         """
         # Validate new tenant name
         validate_name(new_name, "tenant")
-        
+
         # Can't rename main tenant
         if old_name == "main":
             raise ValueError("Cannot rename the main tenant")

cinchdb/models/branch.py

@@ -22,7 +22,7 @@ class Branch(CinchDBBaseModel):
     )
     is_main: bool = Field(default=False, description="Whether this is the main branch")
 
-    @field_validator('name')
+    @field_validator("name")
     @classmethod
     def validate_name_field(cls, v: str) -> str:
         """Validate branch name meets naming requirements."""

cinchdb/models/database.py

@@ -16,7 +16,7 @@ class Database(CinchDBBaseModel):
     active_branch: str = Field(default="main", description="Currently active branch")
     description: Optional[str] = Field(default=None, description="Database description")
 
-    @field_validator('name')
+    @field_validator("name")
     @classmethod
     def validate_name_field(cls, v: str) -> str:
         """Validate database name meets naming requirements."""

cinchdb/models/table.py

@@ -14,18 +14,16 @@ ForeignKeyAction = Literal["CASCADE", "SET NULL", "RESTRICT", "NO ACTION"]
 
 class ForeignKeyRef(BaseModel):
     """Foreign key reference specification."""
-    
+
     model_config = ConfigDict(extra="forbid")
-    
+
     table: str = Field(description="Referenced table name")
     column: str = Field(default="id", description="Referenced column name")
     on_delete: ForeignKeyAction = Field(
-        default="RESTRICT", 
-        description="Action on delete of referenced row"
+        default="RESTRICT", description="Action on delete of referenced row"
     )
     on_update: ForeignKeyAction = Field(
-        default="RESTRICT",
-        description="Action on update of referenced row"
+        default="RESTRICT", description="Action on update of referenced row"
     )
 
 
@@ -47,8 +45,7 @@ class Column(BaseModel):
     )
     unique: bool = Field(default=False, description="Whether values must be unique")
     foreign_key: Optional[ForeignKeyRef] = Field(
-        default=None, 
-        description="Foreign key constraint specification"
+        default=None, description="Foreign key constraint specification"
     )
 
 

cinchdb/models/tenant.py

@@ -15,7 +15,7 @@ class Tenant(CinchDBBaseModel):
     description: Optional[str] = Field(default=None, description="Tenant description")
     is_main: bool = Field(default=False, description="Whether this is the main tenant")
 
-    @field_validator('name')
+    @field_validator("name")
     @classmethod
     def validate_name_field(cls, v: str) -> str:
         """Validate tenant name meets naming requirements."""

cinchdb/utils/__init__.py

@@ -4,13 +4,13 @@ from cinchdb.utils.sql_validator import (
     validate_sql_query,
     validate_query_safe,
     SQLValidationError,
-    SQLOperation
+    SQLOperation,
 )
 from cinchdb.utils.name_validator import (
     validate_name,
     clean_name,
     is_valid_name,
-    InvalidNameError
+    InvalidNameError,
 )
 
 __all__ = [
@@ -19,7 +19,7 @@ __all__ = [
     "SQLValidationError",
     "SQLOperation",
     "validate_name",
-    "clean_name", 
+    "clean_name",
     "is_valid_name",
-    "InvalidNameError"
-]
+    "InvalidNameError",
+]

cinchdb/utils/name_validator.py

@@ -5,55 +5,76 @@ and follow consistent naming conventions.
 """
 
 import re
-from typing import Optional
 
 
 # Regex pattern for valid names: lowercase letters, numbers, dash, underscore, period
-VALID_NAME_PATTERN = re.compile(r'^[a-z0-9][a-z0-9\-_\.]*[a-z0-9]$|^[a-z0-9]$')
+VALID_NAME_PATTERN = re.compile(r"^[a-z0-9][a-z0-9\-_\.]*[a-z0-9]$|^[a-z0-9]$")
 
 # Reserved names that cannot be used
-RESERVED_NAMES = {'con', 'prn', 'aux', 'nul', 'com1', 'com2', 'com3', 'com4',
-                  'com5', 'com6', 'com7', 'com8', 'com9', 'lpt1', 'lpt2',
-                  'lpt3', 'lpt4', 'lpt5', 'lpt6', 'lpt7', 'lpt8', 'lpt9'}
+RESERVED_NAMES = {
+    "con",
+    "prn",
+    "aux",
+    "nul",
+    "com1",
+    "com2",
+    "com3",
+    "com4",
+    "com5",
+    "com6",
+    "com7",
+    "com8",
+    "com9",
+    "lpt1",
+    "lpt2",
+    "lpt3",
+    "lpt4",
+    "lpt5",
+    "lpt6",
+    "lpt7",
+    "lpt8",
+    "lpt9",
+}
 
 
 class InvalidNameError(ValueError):
     """Raised when a name doesn't meet validation requirements."""
+
     pass
 
 
 def validate_name(name: str, entity_type: str = "entity") -> None:
     """Validate that a name meets CinchDB naming requirements.
-    
+
     Valid names must:
     - Contain only lowercase letters (a-z), numbers (0-9), dash (-), and underscore (_)
     - Start and end with alphanumeric characters
     - Be at least 1 character long
     - Not exceed 255 characters (filesystem limit)
     - Not be a reserved name
-    
+
     Args:
         name: The name to validate
         entity_type: Type of entity (branch, database, tenant) for error messages
-        
+
     Raises:
         InvalidNameError: If the name is invalid
     """
     if not name:
         raise InvalidNameError(f"{entity_type.capitalize()} name cannot be empty")
-    
+
     if len(name) > 255:
         raise InvalidNameError(
             f"{entity_type.capitalize()} name cannot exceed 255 characters"
         )
-    
+
     # Check for lowercase requirement
     if name != name.lower():
         raise InvalidNameError(
             f"{entity_type.capitalize()} name must be lowercase. "
             f"Use '{name.lower()}' instead of '{name}'"
         )
-    
+
     # Check pattern
     if not VALID_NAME_PATTERN.match(name):
         raise InvalidNameError(
@@ -62,14 +83,24 @@ def validate_name(name: str, entity_type: str = "entity") -> None:
             f"dash (-), underscore (_), and period (.). "
             f"Names must start and end with alphanumeric characters."
         )
-    
+
     # Check for consecutive special characters
-    if '--' in name or '__' in name or '-_' in name or '_-' in name or '..' in name or '.-' in name or '-.' in name or '._' in name or '_.' in name:
+    if (
+        "--" in name
+        or "__" in name
+        or "-_" in name
+        or "_-" in name
+        or ".." in name
+        or ".-" in name
+        or "-." in name
+        or "._" in name
+        or "_." in name
+    ):
         raise InvalidNameError(
             f"Invalid {entity_type} name '{name}'. "
             f"Names cannot contain consecutive special characters."
         )
-    
+
     # Check reserved names
     if name.lower() in RESERVED_NAMES:
         raise InvalidNameError(
@@ -79,46 +110,46 @@ def validate_name(name: str, entity_type: str = "entity") -> None:
 
 def clean_name(name: str) -> str:
     """Clean a name to make it valid if possible.
-    
+
     This performs basic cleaning:
     - Convert to lowercase
     - Replace spaces with dashes
     - Remove invalid characters
-    
+
     Args:
         name: The name to clean
-        
+
     Returns:
         Cleaned name
-        
+
     Note:
         This is a best-effort cleaning. The result should still be validated
         with validate_name() before use.
     """
     # Convert to lowercase
     cleaned = name.lower()
-    
+
     # Replace spaces with dashes
-    cleaned = cleaned.replace(' ', '-')
-    
+    cleaned = cleaned.replace(" ", "-")
+
     # Remove invalid characters
-    cleaned = re.sub(r'[^a-z0-9\-_\.]', '', cleaned)
-    
+    cleaned = re.sub(r"[^a-z0-9\-_\.]", "", cleaned)
+
     # Remove consecutive special characters
-    cleaned = re.sub(r'[-_\.]{2,}', '-', cleaned)
-    
+    cleaned = re.sub(r"[-_\.]{2,}", "-", cleaned)
+
     # Remove leading/trailing special characters
-    cleaned = cleaned.strip('-_.')
-    
+    cleaned = cleaned.strip("-_.")
+
     return cleaned
 
 
 def is_valid_name(name: str) -> bool:
     """Check if a name is valid without raising an exception.
-    
+
     Args:
         name: The name to check
-        
+
     Returns:
         True if valid, False otherwise
     """
@@ -126,4 +157,4 @@ def is_valid_name(name: str) -> bool:
         validate_name(name)
         return True
     except InvalidNameError:
-        return False
+        return False

cinchdb/utils/sql_validator.py

@@ -11,6 +11,7 @@ from enum import Enum
 
 class SQLOperation(Enum):
     """Allowed SQL operations."""
+
     SELECT = "SELECT"
     INSERT = "INSERT"
     UPDATE = "UPDATE"
@@ -19,37 +20,63 @@ class SQLOperation(Enum):
 
 # List of restricted DDL operations and keywords
 RESTRICTED_OPERATIONS = {
-    'CREATE', 'ALTER', 'DROP', 'TRUNCATE', 'RENAME',
-    'GRANT', 'REVOKE', 'ANALYZE', 'VACUUM', 'ATTACH',
-    'DETACH', 'PRAGMA', 'REINDEX', 'SAVEPOINT', 'RELEASE'
+    "CREATE",
+    "ALTER",
+    "DROP",
+    "TRUNCATE",
+    "RENAME",
+    "GRANT",
+    "REVOKE",
+    "ANALYZE",
+    "VACUUM",
+    "ATTACH",
+    "DETACH",
+    "PRAGMA",
+    "REINDEX",
+    "SAVEPOINT",
+    "RELEASE",
 }
 
 # Additional restricted keywords that could modify schema
 RESTRICTED_KEYWORDS = {
-    'ADD COLUMN', 'DROP COLUMN', 'MODIFY COLUMN',
-    'ADD CONSTRAINT', 'DROP CONSTRAINT', 'ADD INDEX',
-    'DROP INDEX', 'CREATE INDEX', 'CREATE UNIQUE',
-    'CREATE VIEW', 'DROP VIEW', 'CREATE TRIGGER',
-    'DROP TRIGGER', 'CREATE PROCEDURE', 'DROP PROCEDURE',
-    'CREATE FUNCTION', 'DROP FUNCTION'
+    "ADD COLUMN",
+    "DROP COLUMN",
+    "MODIFY COLUMN",
+    "ADD CONSTRAINT",
+    "DROP CONSTRAINT",
+    "ADD INDEX",
+    "DROP INDEX",
+    "CREATE INDEX",
+    "CREATE UNIQUE",
+    "CREATE VIEW",
+    "DROP VIEW",
+    "CREATE TRIGGER",
+    "DROP TRIGGER",
+    "CREATE PROCEDURE",
+    "DROP PROCEDURE",
+    "CREATE FUNCTION",
+    "DROP FUNCTION",
 }
 
 
 class SQLValidationError(Exception):
     """Raised when SQL query validation fails."""
+
     pass
 
 
-def validate_sql_query(query: str, allow_multiple_statements: bool = False) -> Tuple[bool, Optional[str], Optional[SQLOperation]]:
+def validate_sql_query(
+    query: str, allow_multiple_statements: bool = False
+) -> Tuple[bool, Optional[str], Optional[SQLOperation]]:
     """Validate a SQL query to ensure it only contains allowed operations.
-    
+
     Allowed operations: SELECT, INSERT, UPDATE, DELETE
     Blocked operations: All DDL operations (CREATE, ALTER, DROP, etc.)
-    
+
     Args:
         query: The SQL query to validate
         allow_multiple_statements: Whether to allow multiple SQL statements (default: False)
-        
+
     Returns:
         Tuple of (is_valid, error_message, operation)
         - is_valid: True if query is valid
@@ -58,80 +85,103 @@ def validate_sql_query(query: str, allow_multiple_statements: bool = False) -> T
     """
     if not query or not query.strip():
         return False, "Query cannot be empty", None
-    
+
     # Normalize the query - remove comments and extra whitespace
     normalized_query = query
     # Remove single-line comments
-    normalized_query = re.sub(r'--.*$', '', normalized_query, flags=re.MULTILINE)
+    normalized_query = re.sub(r"--.*$", "", normalized_query, flags=re.MULTILINE)
     # Remove multi-line comments
-    normalized_query = re.sub(r'/\*[\s\S]*?\*/', '', normalized_query)
+    normalized_query = re.sub(r"/\*[\s\S]*?\*/", "", normalized_query)
     # Replace multiple spaces with single space
-    normalized_query = re.sub(r'\s+', ' ', normalized_query)
+    normalized_query = re.sub(r"\s+", " ", normalized_query)
     normalized_query = normalized_query.strip().upper()
-    
+
     if not normalized_query:
         return False, "Query cannot be empty after removing comments", None
-    
+
     # Check for multiple statements (security risk)
     if not allow_multiple_statements:
         # Count semicolons that are not at the end
-        semicolon_pos = normalized_query.find(';')
+        semicolon_pos = normalized_query.find(";")
         if semicolon_pos != -1 and semicolon_pos < len(normalized_query) - 1:
             # Check if there's non-whitespace after the semicolon
-            remaining = normalized_query[semicolon_pos + 1:].strip()
+            remaining = normalized_query[semicolon_pos + 1 :].strip()
             if remaining:
-                return False, "Multiple statements are not allowed. Please execute one query at a time.", None
-    
+                return (
+                    False,
+                    "Multiple statements are not allowed. Please execute one query at a time.",
+                    None,
+                )
+
     # Extract the first word (operation)
-    first_word = normalized_query.split()[0].rstrip(';')
-    
+    first_word = normalized_query.split()[0].rstrip(";")
+
     # Check if it's an allowed operation
     try:
         operation = SQLOperation(first_word)
-        
+
         # Additional validation for UPDATE and DELETE
         if operation in (SQLOperation.UPDATE, SQLOperation.DELETE):
             # Warning if no WHERE clause (we don't block it, just log)
-            if 'WHERE' not in normalized_query:
+            if "WHERE" not in normalized_query:
                 import logging
-                logging.warning(f"{operation.value} statement without WHERE clause detected")
-        
+
+                logging.warning(
+                    f"{operation.value} statement without WHERE clause detected"
+                )
+
         return True, None, operation
     except ValueError:
         # Not a recognized allowed operation
         pass
-    
+
     # Check for restricted operations
     for restricted in RESTRICTED_OPERATIONS:
         if normalized_query.startswith(restricted):
-            return False, f"{restricted} operations are not allowed. Only SELECT, INSERT, UPDATE, and DELETE queries are permitted.", None
-    
+            return (
+                False,
+                f"{restricted} operations are not allowed. Only SELECT, INSERT, UPDATE, and DELETE queries are permitted.",
+                None,
+            )
+
     # Check for restricted keywords anywhere in the query
     for keyword in RESTRICTED_KEYWORDS:
         if keyword in normalized_query:
-            return False, f"Query contains restricted operation: {keyword}. Only SELECT, INSERT, UPDATE, and DELETE queries are permitted.", None
-    
+            return (
+                False,
+                f"Query contains restricted operation: {keyword}. Only SELECT, INSERT, UPDATE, and DELETE queries are permitted.",
+                None,
+            )
+
     # Check for WITH statements that might contain DDL
-    if normalized_query.startswith('WITH'):
+    if normalized_query.startswith("WITH"):
         # Check if the CTE contains any DDL operations
         for restricted in RESTRICTED_OPERATIONS:
             if restricted in normalized_query:
-                return False, f"CTE (WITH clause) containing {restricted} operations is not allowed.", None
-    
+                return (
+                    False,
+                    f"CTE (WITH clause) containing {restricted} operations is not allowed.",
+                    None,
+                )
+
     # If we get here, it's an unrecognized operation
-    return False, "Unrecognized or restricted SQL operation. Only SELECT, INSERT, UPDATE, and DELETE queries are permitted.", None
+    return (
+        False,
+        "Unrecognized or restricted SQL operation. Only SELECT, INSERT, UPDATE, and DELETE queries are permitted.",
+        None,
+    )
 
 
 def validate_query_safe(query: str, allow_multiple_statements: bool = False) -> None:
     """Validate a SQL query and raise an exception if invalid.
-    
+
     Args:
         query: The SQL query to validate
         allow_multiple_statements: Whether to allow multiple SQL statements
-        
+
     Raises:
         SQLValidationError: If the query is invalid
     """
     is_valid, error_message, _ = validate_sql_query(query, allow_multiple_statements)
     if not is_valid:
-        raise SQLValidationError(error_message)
+        raise SQLValidationError(error_message)

{cinchdb-0.1.3.dist-info → cinchdb-0.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cinchdb
-Version: 0.1.3
+Version: 0.1.5
 Summary: A Git-like SQLite database management system with branching and multi-tenancy
 Project-URL: Homepage, https://github.com/russellromney/cinchdb
 Project-URL: Documentation, https://russellromney.github.io/cinchdb
@@ -31,7 +31,7 @@ Description-Content-Type: text/markdown
 
 NOTE: CinchDB is in early alpha. This is project to test out an idea. Do not use this in production.
 
-CinchDB is for projects that need fast queries, data isolated data per-tenant [or even per-user](https://turso.tech/blog/give-each-of-your-users-their-own-sqlite-database-b74445f4), and a branchable database.
+CinchDB is for projects that need fast queries, data isolated data per-tenant [or even per-user](https://turso.tech/blog/give-each-of-your-users-their-own-sqlite-database-b74445f4), and a branchable database that makes it easy to merge changes between branches.
 
 On a meta level, I made this because I wanted a database structure that I felt comfortable letting AI agents take full control over, safely, and I didn't want to run my own Postgres instance somewhere or pay for it on e.g. Neon - I don't need hyperscaling, I just need super fast queries.
 

cinchdb-0.1.5.dist-info/RECORD

@@ -0,0 +1,54 @@
+cinchdb/__init__.py,sha256=NZdSzfhRguSBTjJ2dcESOQYy53OZEuBndlB7U08GMY0,179
+cinchdb/__main__.py,sha256=OpkDqn9zkTZhhYgvv_grswWLAHKbmxs4M-8C6Z5HfWY,85
+cinchdb/config.py,sha256=gocjMnYKLWhgvnteo6zprgwtK6Oevoxq547J_v-C9Ns,5265
+cinchdb/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cinchdb/cli/main.py,sha256=Icr_uhe_zXPAuhM9NB7evR5b1ZP7f_N40HQcC1JFhQ0,4706
+cinchdb/cli/utils.py,sha256=NREFxN9k53FnPbDoPt4SXmdZzlzw9zUMv5ICQwTT8gk,5679
+cinchdb/cli/commands/__init__.py,sha256=gQ6tnU0Rvm0-ESWFUBU-KDl5dpNOpUTG509hXOQQjwY,27
+cinchdb/cli/commands/branch.py,sha256=Nz8YQYJ7lizSXEAv0usTx85TDOC-N5Ul9KIxN8JQtKc,17973
+cinchdb/cli/commands/codegen.py,sha256=WsRWmXNTDuaLPyECW5psXM9zOQnKHpUiv8BJnBAjMII,6189
+cinchdb/cli/commands/column.py,sha256=ISHRmcoLf1fAbPqC2MaAYH7Fc6xZWtzCMSRh7_9o-lY,11757
+cinchdb/cli/commands/database.py,sha256=-UCOnn3VatdNog-fX5pguJ2GKdSSXQN99-LSVwkvinY,6857
+cinchdb/cli/commands/query.py,sha256=XW_YL6M5IYHHHMpVB5p-M01kawFxwDOK5B5hGIy_BA8,5044
+cinchdb/cli/commands/remote.py,sha256=i07hfiAxgrROB9lVJVaKK_nWxT1SGiSbtFb4jvEwxEo,4445
+cinchdb/cli/commands/table.py,sha256=NxfOTCd9beaujffiAPiW0Vko0--HS1JVeCwBMp_khx4,10518
+cinchdb/cli/commands/tenant.py,sha256=cOWs9Gf13ZE4KTKJZ_AvDwFDdXBUn5i-Av4MoUsc8Go,6199
+cinchdb/cli/commands/view.py,sha256=ZmS1IW7idzzHAXmgVyY3C4IQRo7toHb6fHNFY_tQJjI,6385
+cinchdb/cli/handlers/__init__.py,sha256=f2f-Cc96rSBLbVsiIbf-b4pZCKZoHfmhNEvnZ0OurRs,131
+cinchdb/cli/handlers/codegen_handler.py,sha256=i5we_AbiUW3zfO6pIKWxvtO8OvOqz3H__4xPmTLEuQM,6524
+cinchdb/core/__init__.py,sha256=iNlT0iO9cM0HLoYwzBavUBoXRh1Tcnz1l_vfbwVxK_Q,246
+cinchdb/core/connection.py,sha256=SlKyEfIpeaDws8M6SfEbvCEVnt26zBY1RYwHtTXj0kY,5110
+cinchdb/core/database.py,sha256=g-QH8NOWvegajAwplNHcooPPpvZEr7L7NfrTIqlqJN8,18591
+cinchdb/core/initializer.py,sha256=CjnJSMuR1NrHobyFfwL44tUeH8VE62q02bijEtVH3p4,6922
+cinchdb/core/maintenance.py,sha256=PAgrSL7Cj9p3rKHV0h_L7gupN6nLD0-5eQpJZNiqyEs,2097
+cinchdb/core/path_utils.py,sha256=J2UEu1X_NFOqDamcsrPrC7ZitGTg9Y-HFjmx4sHf5j8,3806
+cinchdb/managers/__init__.py,sha256=ic61ZUdsg-muq0ETYO6fuZRQWF4j7l920PthTkt2QrE,808
+cinchdb/managers/branch.py,sha256=FkF2i5vZ8ifldGm9tLcgPNymifFdBbpCrfLorIBYCiE,5330
+cinchdb/managers/change_applier.py,sha256=cHPhPgbJ9jeyrb6lkfRyumS8IHat0HiWfwZh-n7ButA,14310
+cinchdb/managers/change_comparator.py,sha256=08pwybpSt36cFwhZRSIkHynvFMUaLKEVwa8Ajn_R9yQ,6862
+cinchdb/managers/change_tracker.py,sha256=U93BPnuGv8xSaO5qr_y5Q8ppKrVXygozdp5zUvLUqwg,5054
+cinchdb/managers/codegen.py,sha256=1CfIwjgHnNDdjrq4SzQ9VE7DFgnWfk7RtpupBFUTqxk,21804
+cinchdb/managers/column.py,sha256=YhYq-hnH0o2BqZkyihnsY5KIWEztzs-_iLJNZMdVUkk,20807
+cinchdb/managers/data.py,sha256=zS1HkMGf436m6f8VdFAqQbQFgo4sL5yKJRcRf4A6lIc,16253
+cinchdb/managers/merge_manager.py,sha256=R8S2hLkLJg4hLDpeJTzjVkduZgqPOjXtYgOSJhTXXrE,15690
+cinchdb/managers/query.py,sha256=pBlbqoovnFsZ36pB7nv8NtzcTFwtT26hp8IlwjIx29Q,7301
+cinchdb/managers/table.py,sha256=KWSAfZCJafKZPx-dRG7KwQUGVqVQ56ARMVBllb3VBig,13114
+cinchdb/managers/tenant.py,sha256=QONC5R8tW5CJoGUxECJmQyiSP12mz3rZBmRqxCsKjmM,8726
+cinchdb/managers/view.py,sha256=v9gYtRufZyxywPKLGvIjvlUXcxYh9CLRArefu9QX6zk,7809
+cinchdb/models/__init__.py,sha256=382OuS0BaKPA71GjqNW5lfVhtUYqmcMlLRin7HPi6XI,602
+cinchdb/models/base.py,sha256=7j4rlFTP5K9ZuF8vxwC7lMFEaL7O90NJ47Ig5i7ubcw,1320
+cinchdb/models/branch.py,sha256=gRgLpRFkMC3fxf9ZigVOkS6wdkBERWqlLk0_gOYjqNk,1180
+cinchdb/models/change.py,sha256=YpBWdI6yMT3uucd8duET9s75xr5JUWJqurkkyTlXPlk,1449
+cinchdb/models/database.py,sha256=QrWd_SkE1G8TMWflO4sXRUbSdbqcrfGOt2e-PS7OW7A,971
+cinchdb/models/project.py,sha256=6GMXUZUsEIebqQJgRXIthWzpWKuNNmJ3drgI1vFDrMo,644
+cinchdb/models/table.py,sha256=k2_nnyW1E6-UM2Zw49K5njP_fxySW3HVWymcR_a0e_0,2759
+cinchdb/models/tenant.py,sha256=UKYTKM4mQH3IqEjI_tOU5CszwBWH4cXa3lI0mpMFF_4,967
+cinchdb/models/view.py,sha256=q6j-jYzFJuhRJO87rKt6Uv8hOizHQx8xwoPKoH6XnNY,530
+cinchdb/utils/__init__.py,sha256=yQQhEjndDiB2SUJybUmp9dvEOQKiR-GySe-WiCius5E,490
+cinchdb/utils/name_validator.py,sha256=dyGX5bjlTFRA9EGrWRQKp6kR__HSV04hLV5VueJs4IQ,4027
+cinchdb/utils/sql_validator.py,sha256=aWOGlPX0gBkuR6R1EBP2stbP4PHZuI6FUBi2Ljx7JUI,5815
+cinchdb-0.1.5.dist-info/METADATA,sha256=pnIHIDE116wBD3rp7oNJ_45l9NVxV0Qg7V0QyarGZvo,5855
+cinchdb-0.1.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cinchdb-0.1.5.dist-info/entry_points.txt,sha256=VBOIzvnGbkKudMCCmNORS3885QSyjZUVKJQ-Syqa62w,47
+cinchdb-0.1.5.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+cinchdb-0.1.5.dist-info/RECORD,,