cinchdb 0.1.15__py3-none-any.whl → 0.1.17__py3-none-any.whl

cinchdb/plugins/__init__.py

@@ -1,17 +1,16 @@
 """
-CinchDB Plugin System
+Simple Plugin System for CinchDB
 
-Extensible plugin architecture for CinchDB.
+Easy-to-use plugin architecture for CinchDB.
 """
 
-from .base import BasePlugin, PluginHook
+from .base import Plugin
 from .manager import PluginManager
-from .decorators import hook, plugin_method
+from .decorators import database_method, auto_extend
 
 __all__ = [
-    "BasePlugin",
-    "PluginHook", 
+    "Plugin",
     "PluginManager",
-    "hook",
-    "plugin_method",
+    "database_method", 
+    "auto_extend",
 ]

cinchdb/plugins/base.py

@@ -1,90 +1,73 @@
 """
-Base classes for CinchDB plugins.
+Simple base class for CinchDB plugins.
 """
 
-from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Callable
-from enum import Enum
+from typing import Any, Dict, Optional
 
 
-class PluginHook(Enum):
-    """Available plugin hooks."""
-    # Database lifecycle hooks
-    DATABASE_INIT = "database_init"
-    DATABASE_CONNECT = "database_connect"
-    DATABASE_DISCONNECT = "database_disconnect"
+class Plugin:
+    """Simple base class for CinchDB plugins."""
     
-    # Query hooks
-    QUERY_BEFORE = "query_before"
-    QUERY_AFTER = "query_after"
-    QUERY_ERROR = "query_error"
+    # Plugin metadata - override in subclass
+    name: str = "unnamed_plugin"
+    version: str = "1.0.0"
+    description: str = ""
     
-    # Table hooks
-    TABLE_CREATE = "table_create"
-    TABLE_DROP = "table_drop"
-    TABLE_ALTER = "table_alter"
-    
-    # Tenant hooks
-    TENANT_CREATE = "tenant_create"
-    TENANT_DROP = "tenant_drop"
-    
-    # Branch hooks
-    BRANCH_CREATE = "branch_create"
-    BRANCH_SWITCH = "branch_switch"
-    BRANCH_MERGE = "branch_merge"
-    
-    # CLI hooks
-    CLI_COMMAND_BEFORE = "cli_command_before"
-    CLI_COMMAND_AFTER = "cli_command_after"
-
-
-class BasePlugin(ABC):
-    """Base class for all CinchDB plugins."""
-    
-    def __init__(self):
-        self.name = self.__class__.__name__
-        self.version = "1.0.0"
-        self.description = ""
-        self._hooks: Dict[PluginHook, List[Callable]] = {}
-        self._methods: Dict[str, Callable] = {}
+    def extend_database(self, db) -> None:
+        """Add methods or modify the database instance.
+        
+        Override this method to add custom methods to database instances:
         
-    @abstractmethod
-    def initialize(self, cinchdb_instance) -> None:
-        """Initialize the plugin with a CinchDB instance."""
+        Example:
+            def extend_database(self, db):
+                db.my_custom_method = self.my_custom_method
+        """
         pass
     
-    def register_hook(self, hook: PluginHook, callback: Callable) -> None:
-        """Register a callback for a specific hook."""
-        if hook not in self._hooks:
-            self._hooks[hook] = []
-        self._hooks[hook].append(callback)
-    
-    def register_method(self, method_name: str, method: Callable) -> None:
-        """Register a new method to be added to CinchDB instances."""
-        self._methods[method_name] = method
+    def before_query(self, sql: str, params: Optional[tuple] = None) -> tuple:
+        """Called before executing any SQL query.
+        
+        Args:
+            sql: The SQL statement to be executed
+            params: Parameters for the SQL statement
+            
+        Returns:
+            Tuple of (modified_sql, modified_params)
+        """
+        return sql, params
     
-    def get_hooks(self) -> Dict[PluginHook, List[Callable]]:
-        """Get all registered hooks."""
-        return self._hooks.copy()
+    def after_query(self, sql: str, params: Optional[tuple], result: Any) -> Any:
+        """Called after executing any SQL query.
+        
+        Args:
+            sql: The SQL statement that was executed
+            params: Parameters that were used
+            result: The query result
+            
+        Returns:
+            Modified result (or original result)
+        """
+        return result
     
-    def get_methods(self) -> Dict[str, Callable]:
-        """Get all registered methods."""
-        return self._methods.copy()
+    def on_connect(self, db_path: str, connection) -> None:
+        """Called when a database connection is established.
+        
+        Args:
+            db_path: Path to the database file
+            connection: SQLite connection object
+        """
+        pass
     
-    def call_hook(self, hook: PluginHook, *args, **kwargs) -> Any:
-        """Call all callbacks for a specific hook."""
-        results = []
-        for callback in self._hooks.get(hook, []):
-            try:
-                result = callback(*args, **kwargs)
-                results.append(result)
-            except Exception as e:
-                # Log error but don't break other plugins
-                print(f"Plugin {self.name} hook {hook} failed: {e}")
-        return results
+    def on_disconnect(self, db_path: str) -> None:
+        """Called when a database connection is closed.
+        
+        Args:
+            db_path: Path to the database file
+        """
+        pass
     
     def cleanup(self) -> None:
-        """Cleanup when plugin is unloaded."""
+        """Called when plugin is being unloaded."""
         pass
     
     @property
@@ -94,6 +77,4 @@ class BasePlugin(ABC):
             "name": self.name,
             "version": self.version,
             "description": self.description,
-            "hooks": list(self._hooks.keys()),
-            "methods": list(self._methods.keys()),
         }

cinchdb/plugins/decorators.py

@@ -1,45 +1,49 @@
 """
-Decorators for plugin development.
+Simple decorators for plugin development.
 """
 
 from typing import Callable
 
-from .base import PluginHook
 
-
-def hook(hook_type: PluginHook):
-    """Decorator to register a method as a hook callback."""
-    def decorator(func: Callable) -> Callable:
-        func._plugin_hook = hook_type
-        return func
-    return decorator
-
-
-def plugin_method(method_name: str):
-    """Decorator to register a method to be added to CinchDB instances."""
+def database_method(method_name: str):
+    """Decorator to mark a method for database extension.
+    
+    Usage:
+        class Plugin:
+            @database_method("my_method")
+            def my_custom_method(self, db):
+                return "Hello from plugin!"
+    """
     def decorator(func: Callable) -> Callable:
-        func._plugin_method_name = method_name
+        func._database_method_name = method_name
         return func
     return decorator
 
 
-class PluginDecorators:
-    """Helper class to collect decorated methods from a plugin class."""
+def auto_extend(plugin_class):
+    """Class decorator to automatically extend databases with decorated methods.
+    
+    Usage:
+        @auto_extend
+        class Plugin:
+            @database_method("custom_query")
+            def custom_query_method(self, db, query):
+                # Method will be added to db instances as db.custom_query()
+                return "Custom result"
+    """
+    original_extend = getattr(plugin_class, 'extend_database', None)
     
-    @staticmethod
-    def collect_hooks(plugin_instance) -> None:
-        """Collect and register hook methods from a plugin instance."""
-        for attr_name in dir(plugin_instance):
-            attr = getattr(plugin_instance, attr_name)
-            if callable(attr) and hasattr(attr, '_plugin_hook'):
-                hook_type = attr._plugin_hook
-                plugin_instance.register_hook(hook_type, attr)
+    def new_extend_database(self, db):
+        # Call original extend_database if it exists
+        if original_extend:
+            original_extend(self, db)
+        
+        # Auto-add decorated methods
+        for attr_name in dir(self):
+            attr = getattr(self, attr_name)
+            if callable(attr) and hasattr(attr, '_database_method_name'):
+                method_name = attr._database_method_name
+                setattr(db, method_name, lambda *args, **kwargs: attr(db, *args, **kwargs))
     
-    @staticmethod
-    def collect_methods(plugin_instance) -> None:
-        """Collect and register plugin methods from a plugin instance."""
-        for attr_name in dir(plugin_instance):
-            attr = getattr(plugin_instance, attr_name)
-            if callable(attr) and hasattr(attr, '_plugin_method_name'):
-                method_name = attr._plugin_method_name
-                plugin_instance.register_method(method_name, attr)
+    plugin_class.extend_database = new_extend_database
+    return plugin_class

cinchdb/plugins/manager.py

@@ -1,43 +1,31 @@
 """
-Plugin manager for CinchDB.
+Simple plugin manager for CinchDB.
 """
 
 import importlib
 import importlib.util
 import logging
 from pathlib import Path
-from typing import Dict, List, Optional, Any
-try:
-    from importlib.metadata import entry_points
-except ImportError:
-    # Fallback for Python < 3.8
-    from importlib_metadata import entry_points
+from typing import Dict, List, Optional, Any, Union
 
-from .base import BasePlugin, PluginHook
+from .base import Plugin
 
 logger = logging.getLogger(__name__)
 
 
 class PluginManager:
-    """Manages plugin lifecycle and hooks for CinchDB."""
+    """Simple plugin manager for CinchDB."""
     
     def __init__(self):
-        self.plugins: Dict[str, BasePlugin] = {}
-        self._cinchdb_instance = None
+        self.plugins: Dict[str, Plugin] = {}
+        self._database_instances: List[Any] = []
         
-    def set_cinchdb_instance(self, instance):
-        """Set the CinchDB instance for plugins."""
-        self._cinchdb_instance = instance
-        
-        # Initialize any already loaded plugins
-        for plugin in self.plugins.values():
-            try:
-                plugin.initialize(instance)
-            except Exception as e:
-                logger.error(f"Failed to initialize plugin {plugin.name}: {e}")
-    
-    def register_plugin(self, plugin: BasePlugin) -> None:
-        """Register a plugin instance."""
+    def register_plugin(self, plugin: Union[Plugin, type]) -> None:
+        """Register a plugin instance or class."""
+        # If it's a class, instantiate it
+        if isinstance(plugin, type):
+            plugin = plugin()
+            
         plugin_name = plugin.name
         
         if plugin_name in self.plugins:
@@ -45,13 +33,12 @@ class PluginManager:
         
         self.plugins[plugin_name] = plugin
         
-        # Initialize with CinchDB instance if available
-        if self._cinchdb_instance:
+        # Apply to existing database instances
+        for db_instance in self._database_instances:
             try:
-                plugin.initialize(self._cinchdb_instance)
-                self._apply_plugin_methods(plugin)
+                plugin.extend_database(db_instance)
             except Exception as e:
-                logger.error(f"Failed to initialize plugin {plugin_name}: {e}")
+                logger.error(f"Failed to extend database with plugin {plugin_name}: {e}")
         
         logger.info(f"Plugin {plugin_name} registered successfully")
     
@@ -72,18 +59,24 @@ class PluginManager:
         try:
             module = importlib.import_module(module_name)
             
-            # Look for plugin classes
+            # Look for Plugin class first
+            if hasattr(module, 'Plugin'):
+                plugin_instance = module.Plugin()
+                self.register_plugin(plugin_instance)
+                return
+            
+            # Fallback: look for any Plugin subclass
             for attr_name in dir(module):
                 attr = getattr(module, attr_name)
                 if (isinstance(attr, type) and 
-                    issubclass(attr, BasePlugin) and 
-                    attr != BasePlugin):
+                    issubclass(attr, Plugin) and 
+                    attr != Plugin):
                     
                     plugin_instance = attr()
                     self.register_plugin(plugin_instance)
                     return
             
-            logger.warning(f"No plugin class found in module {module_name}")
+            logger.warning(f"No Plugin class found in module {module_name}")
             
         except ImportError as e:
             logger.error(f"Failed to import plugin module {module_name}: {e}")
@@ -98,69 +91,108 @@ class PluginManager:
                 module = importlib.util.module_from_spec(spec)
                 spec.loader.exec_module(module)
                 
-                # Look for plugin classes
-                for attr_name in dir(module):
-                    attr = getattr(module, attr_name)
-                    if (isinstance(attr, type) and 
-                        issubclass(attr, BasePlugin) and 
-                        attr != BasePlugin):
-                        
-                        plugin_instance = attr()
-                        self.register_plugin(plugin_instance)
-                        return
+                # Look for Plugin class
+                if hasattr(module, 'Plugin'):
+                    plugin_instance = module.Plugin()
+                    self.register_plugin(plugin_instance)
+                    return
                 
-                logger.warning(f"No plugin class found in file {file_path}")
+                logger.warning(f"No Plugin class found in file {file_path}")
         
         except Exception as e:
             logger.error(f"Failed to load plugin from file {file_path}: {e}")
     
+    def load_plugins_from_directory(self, plugins_dir: Path) -> None:
+        """Load all plugins from a directory."""
+        if not plugins_dir.exists():
+            logger.info(f"Plugins directory {plugins_dir} does not exist")
+            return
+            
+        for plugin_file in plugins_dir.glob("*.py"):
+            if plugin_file.name == "__init__.py":
+                continue
+            self.load_plugin_from_file(plugin_file)
+    
     def discover_plugins(self) -> None:
-        """Discover plugins using entry points."""
+        """Discover plugins using entry points and plugins directory."""
+        # Try entry points for installed plugins
         try:
+            try:
+                from importlib.metadata import entry_points
+            except ImportError:
+                from importlib_metadata import entry_points
+                
             eps = entry_points()
-            # Handle both old and new entry_points API
             if hasattr(eps, 'select'):
-                # New API (Python 3.10+)
                 plugin_eps = eps.select(group='cinchdb.plugins')
             else:
-                # Old API
                 plugin_eps = eps.get('cinchdb.plugins', [])
             
             for entry_point in plugin_eps:
                 try:
                     plugin_class = entry_point.load()
-                    if issubclass(plugin_class, BasePlugin):
-                        plugin_instance = plugin_class()
-                        self.register_plugin(plugin_instance)
+                    self.register_plugin(plugin_class)
                 except Exception as e:
                     logger.error(f"Failed to load plugin {entry_point.name}: {e}")
         except Exception as e:
-            logger.error(f"Failed to discover plugins: {e}")
+            logger.debug(f"Entry points not available: {e}")
+        
+        # Also check for local plugins directory
+        plugins_dir = Path("plugins")
+        if plugins_dir.exists():
+            self.load_plugins_from_directory(plugins_dir)
     
-    def _apply_plugin_methods(self, plugin: BasePlugin) -> None:
-        """Apply plugin methods to the CinchDB instance."""
-        if not self._cinchdb_instance:
-            return
-            
-        for method_name, method in plugin.get_methods().items():
-            # Bind method to the instance
-            bound_method = method.__get__(self._cinchdb_instance, type(self._cinchdb_instance))
-            setattr(self._cinchdb_instance, method_name, bound_method)
-    
-    def call_hook(self, hook: PluginHook, *args, **kwargs) -> List[Any]:
-        """Call all plugin hooks for a specific event."""
-        results = []
+    def register_database(self, db_instance) -> None:
+        """Register a database instance with all plugins."""
+        self._database_instances.append(db_instance)
         
+        # Apply all plugins to this database instance
         for plugin in self.plugins.values():
             try:
-                plugin_results = plugin.call_hook(hook, *args, **kwargs)
-                results.extend(plugin_results)
+                plugin.extend_database(db_instance)
             except Exception as e:
-                logger.error(f"Plugin {plugin.name} hook {hook} failed: {e}")
-        
-        return results
+                logger.error(f"Failed to extend database with plugin {plugin.name}: {e}")
+    
+    def unregister_database(self, db_instance) -> None:
+        """Unregister a database instance."""
+        if db_instance in self._database_instances:
+            self._database_instances.remove(db_instance)
+    
+    def before_query(self, sql: str, params: Optional[tuple] = None) -> tuple:
+        """Call before_query on all plugins."""
+        for plugin in self.plugins.values():
+            try:
+                sql, params = plugin.before_query(sql, params)
+            except Exception as e:
+                logger.error(f"Plugin {plugin.name} before_query failed: {e}")
+        return sql, params
+    
+    def after_query(self, sql: str, params: Optional[tuple], result: Any) -> Any:
+        """Call after_query on all plugins."""
+        for plugin in self.plugins.values():
+            try:
+                result = plugin.after_query(sql, params, result)
+            except Exception as e:
+                logger.error(f"Plugin {plugin.name} after_query failed: {e}")
+        return result
+    
+    def on_connect(self, db_path: str, connection) -> None:
+        """Call on_connect on all plugins."""
+        for plugin in self.plugins.values():
+            try:
+                plugin.on_connect(db_path, connection)
+            except Exception as e:
+                logger.error(f"Plugin {plugin.name} on_connect failed: {e}")
+    
+    def on_disconnect(self, db_path: str) -> None:
+        """Call on_disconnect on all plugins."""
+        for plugin in self.plugins.values():
+            try:
+                plugin.on_disconnect(db_path)
+            except Exception as e:
+                logger.error(f"Plugin {plugin.name} on_disconnect failed: {e}")
     
-    def get_plugin(self, name: str) -> Optional[BasePlugin]:
+    def get_plugin(self, name: str) -> Optional[Plugin]:
         """Get a plugin by name."""
         return self.plugins.get(name)
     

{cinchdb-0.1.15.dist-info → cinchdb-0.1.17.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cinchdb
-Version: 0.1.15
+Version: 0.1.17
 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,6 +31,10 @@ Description-Content-Type: text/markdown
 
 **Git-like SQLite database management with branching and multi-tenancy**
 
+[![PyPI version](https://badge.fury.io/py/cinchdb.svg)](https://badge.fury.io/py/cinchdb)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+
+
 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, 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.

{cinchdb-0.1.15.dist-info → cinchdb-0.1.17.dist-info}/RECORD

@@ -1,6 +1,6 @@
 cinchdb/__init__.py,sha256=qnBv5kpL4GJjNbQkp-nBcOgrsskwDr7WTnUPCGwg3zs,603
 cinchdb/__main__.py,sha256=OpkDqn9zkTZhhYgvv_grswWLAHKbmxs4M-8C6Z5HfWY,85
-cinchdb/config.py,sha256=gocjMnYKLWhgvnteo6zprgwtK6Oevoxq547J_v-C9Ns,5265
+cinchdb/config.py,sha256=hYcT91mMcV0NEvJMAgtJkihfaxHJ97qqGOetnlaNZjI,4889
 cinchdb/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cinchdb/cli/main.py,sha256=x2bF19e0lY_0V3_tx6CO9M3AaFlII75bAdWaOg0ne_A,4587
 cinchdb/cli/utils.py,sha256=InAGuo7uENvsfBQu6EKIbbiNXqmvg-BecLmhLvOz5qg,6485
@@ -19,27 +19,28 @@ cinchdb/cli/commands/view.py,sha256=ZmS1IW7idzzHAXmgVyY3C4IQRo7toHb6fHNFY_tQJjI,
 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=FdYVQuoFYo7B0JSHfCTZFTq3DkM_NWHF4ei-fMyyEMI,5171
-cinchdb/core/database.py,sha256=K5zPG8wXdh9-jAg69QZ7ImE0u3qAuvCDulfAx1fOq5U,33307
+cinchdb/core/connection.py,sha256=_Yt0ki4IbNQJ6lwvloDZ58CCA7SBJwHaB1SU1Yy-rpI,5186
+cinchdb/core/database.py,sha256=4jZwJE4UMpPv77wyQbn0FaTB1MMJv0BHl3umLJzO0q4,33680
 cinchdb/core/initializer.py,sha256=CAzq947plgEF-KXV-PD-ycJ8Zy4zXCQqCrmQ0-pV0i4,14474
-cinchdb/core/maintenance.py,sha256=PAgrSL7Cj9p3rKHV0h_L7gupN6nLD0-5eQpJZNiqyEs,2097
-cinchdb/core/path_utils.py,sha256=Va4y2Dkd5QI6FI5h1ePyVH5pwr7tzRpYZLA4KEpDV0Q,4874
+cinchdb/core/maintenance_utils.py,sha256=FYEZK2FybghuGxo37QeTd1DLsuId0p3rKGIlpPTFJZw,1852
+cinchdb/core/path_utils.py,sha256=xcclmafzETDtivr-Qoi2gP6xZh5C49EoR6duc6YY4gw,4698
+cinchdb/core/tenant_activation.py,sha256=56FaxgZJ2IGYcF6arJfr0gc63wBpyQ4E9ssJDghlPmA,7290
 cinchdb/infrastructure/metadata_connection_pool.py,sha256=PeVsyuZKdI3Y7_InWMOn9HcSNhE0MVcP7I7wAj9esmI,4859
-cinchdb/infrastructure/metadata_db.py,sha256=t3WDyE9SjWhTB2S0-v82AmWKXfl1571V_dv4Bv1-u10,15894
+cinchdb/infrastructure/metadata_db.py,sha256=gP-UORs2Ec33p9_64L2xPTZ51PQDYrmfHlofJfQUM2M,19933
 cinchdb/managers/__init__.py,sha256=ic61ZUdsg-muq0ETYO6fuZRQWF4j7l920PthTkt2QrE,808
 cinchdb/managers/branch.py,sha256=bEzl83mN9a9KW8AHC_w50QHtVdVPHUzEY-j9T2EAyR4,9445
-cinchdb/managers/change_applier.py,sha256=cCgjUL6SJvrgVCCHAw0mAbGqZqKmMsLa0QbziSiuW68,15576
+cinchdb/managers/change_applier.py,sha256=JWfK-B42fCc5ANGvIIogzF5SeSCkSO16y67RCNsPu08,15602
 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=i0EzDKavMvZeeaVrY9OVRNHOW60v0rUEkDjMtIs3PaE,20749
-cinchdb/managers/data.py,sha256=9JAcJ1bxTKb15s0Zb0ATH4YW-6O03iSvyJnk1SsDq80,23170
+cinchdb/managers/column.py,sha256=JyBIu372ExMppvqklhtVAc-eZzikIqedB_8uoJtFu-Y,20755
+cinchdb/managers/data.py,sha256=zAtVLR4GaiY7ijIbWAXC7JN701KtX2zgcg4ZUlGpyts,23176
 cinchdb/managers/index.py,sha256=55_fafWd4lSju4Nw32B_1Fi1c2DPHxOgAhdsqcTR404,10343
 cinchdb/managers/merge_manager.py,sha256=R8S2hLkLJg4hLDpeJTzjVkduZgqPOjXtYgOSJhTXXrE,15690
 cinchdb/managers/query.py,sha256=hgNHda20PWMijbVRnjTKFGFBvBthep2fulkJEK1gkqU,8562
-cinchdb/managers/table.py,sha256=GgwW_lVl9qmbr5x6JXDdvTBL_Ylkk4AzAD2HXQAOH0E,15246
-cinchdb/managers/tenant.py,sha256=Oy60CKWTgDetF_SpbTFcS8bjumlNjEInd_APRg86f5M,31628
-cinchdb/managers/view.py,sha256=v9gYtRufZyxywPKLGvIjvlUXcxYh9CLRArefu9QX6zk,7809
+cinchdb/managers/table.py,sha256=mv5p5WCXy1VXKRyaAZquZofdKR0gEth7It82j6p7j0E,15252
+cinchdb/managers/tenant.py,sha256=gk3Nn68n4avl2mcMcPB5HuKOsOPsMhnvgxHyK8Uwuik,31634
+cinchdb/managers/view.py,sha256=uXcRnZxF4TCcycbwH7cTje_QU3NO47fmOzJULQHHeVI,7815
 cinchdb/models/__init__.py,sha256=cZ-ailJ6qu44Iap5Rq555iB-_w9ufXVDBH3rDH-ojk0,622
 cinchdb/models/base.py,sha256=7j4rlFTP5K9ZuF8vxwC7lMFEaL7O90NJ47Ig5i7ubcw,1320
 cinchdb/models/branch.py,sha256=gRgLpRFkMC3fxf9ZigVOkS6wdkBERWqlLk0_gOYjqNk,1180
@@ -49,15 +50,15 @@ cinchdb/models/project.py,sha256=6GMXUZUsEIebqQJgRXIthWzpWKuNNmJ3drgI1vFDrMo,644
 cinchdb/models/table.py,sha256=nxf__C_YvDOW-6-vdOQ4xKmwWPZwgEdYw1I4mO_C44o,2955
 cinchdb/models/tenant.py,sha256=wTvGoO_tQdtueVB0faZFVIhSjh_DNJzywflrUpngWTM,1072
 cinchdb/models/view.py,sha256=q6j-jYzFJuhRJO87rKt6Uv8hOizHQx8xwoPKoH6XnNY,530
-cinchdb/plugins/__init__.py,sha256=cpqB9y9sY6b9N5Gy9f78Zd2LJ-VpRnwEMS6GpQeW-KY,301
-cinchdb/plugins/base.py,sha256=f0WOTVOLAqWLOSKI6GSNLhHN-wziBGWJza7z1QH0_MY,3038
-cinchdb/plugins/decorators.py,sha256=vSTDC3TDywqDi8Da5aoKe7rRVA2EbTuJXAk6VV4BosM,1533
-cinchdb/plugins/manager.py,sha256=1GcDhCwJvdkXSrgYe-jGA7g8NJNyYk0037_tMNugijE,6807
+cinchdb/plugins/__init__.py,sha256=jZtwwY0t_dhFKz-uR2V3KWBmAGknWnoLkiDWSzULdc8,293
+cinchdb/plugins/base.py,sha256=Upfgw78eOhTAfQd9FwcgGZLIT0zefPDgD4LlpzXgOBg,2232
+cinchdb/plugins/decorators.py,sha256=vY9Zh5nhGiSM6kO55srGHSP32gnyMq77UtJSO3lULq4,1550
+cinchdb/plugins/manager.py,sha256=vetdsiwTkadp3BrhjUIp2vkmCpqfuXqy-3yQBdlxruQ,8143
 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.15.dist-info/METADATA,sha256=LdviGmMLfCUhko3Y6v9ViCFPVaX9KtiXv_ZwGhKwwlo,5958
-cinchdb-0.1.15.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cinchdb-0.1.15.dist-info/entry_points.txt,sha256=VBOIzvnGbkKudMCCmNORS3885QSyjZUVKJQ-Syqa62w,47
-cinchdb-0.1.15.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-cinchdb-0.1.15.dist-info/RECORD,,
+cinchdb-0.1.17.dist-info/METADATA,sha256=cTeJ-n2bL2mqALrAZt9yPES_Xt6uC_suDB8HJmNTFTo,6155
+cinchdb-0.1.17.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cinchdb-0.1.17.dist-info/entry_points.txt,sha256=VBOIzvnGbkKudMCCmNORS3885QSyjZUVKJQ-Syqa62w,47
+cinchdb-0.1.17.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+cinchdb-0.1.17.dist-info/RECORD,,