rococo 1.2.0__tar.gz → 1.3.0__tar.gz

{rococo-1.2.0 → rococo-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rococo
-Version: 1.2.0
+Version: 1.3.0
 Summary: A Python library to help build things the way we want them built
 Home-page: https://github.com/EcorRouge/rococo
 Author: Jay Grieves

{rococo-1.2.0 → rococo-1.3.0}/rococo/data/postgresql.py

@@ -160,7 +160,8 @@ class PostgreSQLAdapter(DbAdapter):
             conditions: Dict[str, Any],
             sort: List[Tuple[str, str]] = None,
             join_statements: list = None,
-            additional_fields: list = None
+            additional_fields: list = None,
+            active: bool = True
     ) -> Optional[Dict[str, Any]]:
         fields = [f'{table}.*']
         if additional_fields:
@@ -175,7 +176,8 @@ class PostgreSQLAdapter(DbAdapter):
         if conditions:
             condition_strs_values = [self._build_condition_string(
                 table, k, v) for k, v in conditions.items()]
-        condition_strs_values.append((f"{table}.active = %s", ['true']))
+        if active:
+            condition_strs_values.append((f"{table}.active = %s", ['true']))
         query += f" WHERE {' AND '.join([condition_str for condition_str, condition_value in condition_strs_values])}"
 
         if sort:

{rococo-1.2.0 → rococo-1.3.0}/rococo/data/surrealdb.py

@@ -108,7 +108,8 @@ class SurrealDbAdapter(DbAdapter):
         conditions: Dict[str, Any],
         sort: List[Tuple[str, str]] = None,
         fetch_related: list = None,
-        additional_fields: list = None
+        additional_fields: list = None,
+        active: bool = True
     ) -> Dict[str, Any]:
         fields = ['*']
         if additional_fields:
@@ -120,7 +121,8 @@ class SurrealDbAdapter(DbAdapter):
         if conditions:
             condition_strs = [
                 f"{self._build_condition_string(k, v)}" for k, v in conditions.items()]
-        condition_strs.append("active=true")
+        if active:
+            condition_strs.append("active=true")
         query += f" WHERE {' AND '.join(condition_strs)}"
 
         if sort:

{rococo-1.2.0 → rococo-1.3.0}/rococo/migrations/common/migration_runner.py

@@ -1,10 +1,8 @@
 import os
 import logging
+import importlib
 from importlib import import_module
-# Assuming migration_template.py is in the same directory or accessible in python path
-# For a common module, it would typically be:
-# from rococo.migrations.common.migration_template import get_template
-from .migration_template import get_template # This relative import is fine if it's part of a package
+from .migration_template import get_template
 
 class MigrationRunner:
     def __init__(self, migrations_dir, migration):
@@ -150,42 +148,40 @@ class MigrationRunner:
             print(f"Error creating migration file: {e}")
 
     def run_forward_migration_script(self, initial_db_version_for_run):
-        # Renamed old_db_version to initial_db_version_for_run for clarity
-        current_script_filename = self._get_forward_migration_script()
-
-        if current_script_filename is None:
-            latest_db_version_after_ops = self.get_db_version()
-            if initial_db_version_for_run == latest_db_version_after_ops:
-                # This means no scripts were found that could run from initial_db_version_for_run
-                logging.info(f'No forward migration scripts found for current DB version: {initial_db_version_for_run}. Database is likely up to date.')
-            else:
-                # This means some migrations ran, and now no more are found.
-                logging.info('All pending forward migrations complete!')
-            logging.info(f'Latest DB version: {latest_db_version_after_ops}')
-            return # End of migration run
-
-        # Using os.path.basename to be platform-agnostic, though split('/') works on POSIX
-        logging.info(f'Running forward migration: {os.path.basename(current_script_filename)}.py')
-        
-        try:
-            # Dynamically import the migration module
-            # Assumes migrations_dir is in sys.path (BaseCli handles this)            
-            module_name = current_script_filename
-            migration_module = import_module(module_name) # Assumes migrations_dir is in sys.path
-            migration_module.upgrade(self.migration)
-        except Exception as e:
-            logging.error(f"Error during forward migration {current_script_filename}.py: {e}", exc_info=True)
-            # This print is for direct CLI feedback during a run
-            print(f"Error applying migration {current_script_filename}.py. Halting.")
-            # Potentially offer to show current DB version or suggest manual check
-            print(f"Current DB version after error: {self.get_db_version()}")
-            return # Stop further migrations
-
-        # Recursively run next forward migration
-        # The `initial_db_version_for_run` remains the version from the start of this `rf` command.
-        # The next call to `_get_forward_migration_script` will use the *new* current DB version
-        # (updated by the migration script that just ran).
-        return self.run_forward_migration_script(initial_db_version_for_run)
+        # Iterates one migration at a time, re-resolving the next forward script
+        # against the DB version updated by the just-applied script. Iterative to
+        # avoid stack overflow on deep migration histories.
+        while True:
+            current_script_filename = self._get_forward_migration_script()
+
+            if current_script_filename is None:
+                latest_db_version_after_ops = self.get_db_version()
+                if initial_db_version_for_run == latest_db_version_after_ops:
+                    logging.info(
+                        f'No forward migration scripts found for current DB version: '
+                        f'{initial_db_version_for_run}. Database is likely up to date.'
+                    )
+                else:
+                    logging.info('All pending forward migrations complete!')
+                logging.info(f'Latest DB version: {latest_db_version_after_ops}')
+                return
+
+            logging.info(
+                f'Running forward migration: {os.path.basename(current_script_filename)}.py'
+            )
+
+            try:
+                importlib.invalidate_caches()
+                migration_module = import_module(current_script_filename)
+                migration_module.upgrade(self.migration)
+            except Exception as e:
+                logging.error(
+                    f"Error during forward migration {current_script_filename}.py: {e}",
+                    exc_info=True,
+                )
+                print(f"Error applying migration {current_script_filename}.py. Halting.")
+                print(f"Current DB version after error: {self.get_db_version()}")
+                return
 
     def run_backward_migration_script(self):
         current_script_filename = self._get_backward_migration_script()
@@ -197,8 +193,8 @@ class MigrationRunner:
         logging.info(f'Running backward migration: {os.path.basename(current_script_filename)}.py')
         
         try:
-            module_name = current_script_filename
-            migration_module = import_module(module_name)
+            importlib.invalidate_caches()
+            migration_module = import_module(current_script_filename)
             migration_module.downgrade(self.migration)
         except Exception as e:
             logging.error(f"Error during backward migration {current_script_filename}.py: {e}", exc_info=True)

rococo-1.3.0/rococo/migrations/common/sql_migration_base.py

@@ -0,0 +1,215 @@
+import logging
+import re
+from typing import Any, Iterable, Optional
+
+from .migration_base import MigrationBase
+
+
+class SQLMigrationBase(MigrationBase):
+    """Shared SQL migration helpers for relational adapters.
+
+    Concrete subclasses (e.g. PostgresMigration, MySQLMigration) provide the
+    dialect-specific SQL via class-level templates and queries. Identifiers
+    (table, column, index, constraint names) are validated against
+    ``_IDENT_RE`` before being interpolated into SQL. Values (database name,
+    version strings) are bound through the adapter's parameterized query
+    interface, never concatenated into SQL strings.
+    """
+
+    # Parameterized queries (use %s placeholders).
+    EXISTS_COLUMN_QUERY: str = NotImplemented      # args: (database, table, column)
+    EXISTS_PK_QUERY: str = NotImplemented          # args: (database, table)
+    UPDATE_VERSION_QUERY: str = NotImplemented     # args: (version,)
+    INSERT_DB_VERSION_DATA_QUERY: str = NotImplemented  # no args
+
+    # Identifier templates (use str.format with validated names).
+    DROP_PK_TEMPLATE: str = NotImplemented         # {table}
+    ADD_PK_TEMPLATE: str = NotImplemented          # {table}, {keys}
+    ADD_COLUMN_TEMPLATE: str = NotImplemented      # {table}, {column}, {datatype}
+    DROP_COLUMN_TEMPLATE: str = NotImplemented     # {table}, {column}
+    ADD_INDEX_TEMPLATE: str = NotImplemented       # {table}, {index}, {column}
+    REMOVE_INDEX_TEMPLATE: str = NotImplemented    # {table}, {index}
+    ALTER_INDEX_TEMPLATES: tuple = NotImplemented  # tuple of templates run in order
+    ALTER_COLUMN_TEMPLATE: str = NotImplemented    # {table}, {column}, {datatype}
+    RENAME_COLUMN_TEMPLATE: str = NotImplemented   # {table}, {old}, {new}
+    RENAME_TABLE_TEMPLATE: str = NotImplemented    # {old_table}, {new_table}
+    CREATE_TABLE_TEMPLATE: str = NotImplemented    # {table}, {fields_with_type}
+    DROP_TABLE_IF_EXISTS_TEMPLATE: str = NotImplemented  # {table}
+    DROP_TABLE_TEMPLATE: str = NotImplemented      # {table}
+
+    _IDENT_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
+
+    def _validate_ident(self, name: str) -> str:
+        if not isinstance(name, str) or not self._IDENT_RE.match(name):
+            raise ValueError(f"invalid SQL identifier: {name!r}")
+        return name
+
+    def _validate_idents(self, names: Iterable[str]) -> None:
+        for n in names:
+            self._validate_ident(n)
+
+    def _validate_pk_keys(self, keys: str) -> str:
+        if not isinstance(keys, str) or not (keys.startswith("(") and keys.endswith(")")):
+            raise ValueError(
+                f"primary key keys must be wrapped in parentheses, got: {keys!r}"
+            )
+        inner = keys[1:-1]
+        for col in inner.split(","):
+            self._validate_ident(col.strip())
+        return keys
+
+    @staticmethod
+    def _extract_count(response: Any) -> int:
+        if not response:
+            return 0
+        row = response[0] if isinstance(response, list) else response
+        if not isinstance(row, dict) or not row:
+            return 0
+        value = next(iter(row.values()))
+        return int(value or 0)
+
+    def _does_column_exist(self, table_name, column_name, commit: bool = True) -> bool:
+        self._validate_idents([table_name, column_name])
+        rows = self.execute(
+            self.EXISTS_COLUMN_QUERY,
+            commit=commit,
+            args=(self.db_adapter._database, table_name, column_name),
+        )
+        return self._extract_count(rows) > 0
+
+    def _does_primary_key_constraint_exists(self, table_name, commit: bool = True) -> bool:
+        self._validate_ident(table_name)
+        rows = self.execute(
+            self.EXISTS_PK_QUERY,
+            commit=commit,
+            args=(self.db_adapter._database, table_name),
+        )
+        return self._extract_count(rows) > 0
+
+    def remove_primary_key(self, table_name, commit: bool = True):
+        self._validate_ident(table_name)
+        if self._does_primary_key_constraint_exists(table_name, commit=commit):
+            return self.execute(
+                self.DROP_PK_TEMPLATE.format(table=table_name), commit=commit
+            )
+        logging.info(
+            f"PRIMARY KEY constraint for table {table_name} does not exist. "
+            f"Skipping removal..."
+        )
+
+    def add_primary_key(self, table_name, keys: str, commit: bool = True):
+        self._validate_ident(table_name)
+        self._validate_pk_keys(keys)
+        if self._does_primary_key_constraint_exists(table_name, commit=commit):
+            self.execute(
+                self.DROP_PK_TEMPLATE.format(table=table_name), commit=commit
+            )
+        return self.execute(
+            self.ADD_PK_TEMPLATE.format(table=table_name, keys=keys), commit=commit
+        )
+
+    def add_column(self, table_name, column_name, datatype, commit: bool = True):
+        self._validate_idents([table_name, column_name])
+        if self._does_column_exist(table_name, column_name, commit=commit):
+            logging.info(
+                f"Column {column_name} for table {table_name} already exists. "
+                f"Skipping creation..."
+            )
+            return
+        query = self.ADD_COLUMN_TEMPLATE.format(
+            table=table_name, column=column_name, datatype=datatype
+        )
+        self.execute(query, commit=commit)
+
+    def drop_column(self, table_name, column_name, commit: bool = True):
+        self._validate_idents([table_name, column_name])
+        if not self._does_column_exist(table_name, column_name, commit=commit):
+            logging.info(
+                f"Column {column_name} for table {table_name} does not exist. "
+                f"Skipping deletion..."
+            )
+            return
+        query = self.DROP_COLUMN_TEMPLATE.format(
+            table=table_name, column=column_name
+        )
+        self.execute(query, commit=commit)
+
+    def alter_index(
+        self,
+        table_name,
+        new_index_name,
+        new_indexed_column,
+        old_index_name,
+        commit: bool = True,
+    ):
+        self._validate_idents(
+            [table_name, new_index_name, new_indexed_column, old_index_name]
+        )
+        for tmpl in self.ALTER_INDEX_TEMPLATES:
+            query = tmpl.format(
+                table=table_name,
+                new_index=new_index_name,
+                new_column=new_indexed_column,
+                old_index=old_index_name,
+            )
+            self.execute(query, commit=commit)
+
+    def add_index(self, table_name, index_name, indexed_column, commit: bool = True):
+        self._validate_idents([table_name, index_name, indexed_column])
+        query = self.ADD_INDEX_TEMPLATE.format(
+            table=table_name, index=index_name, column=indexed_column
+        )
+        self.execute(query, commit=commit)
+
+    def remove_index(self, table_name, index_name, commit: bool = True):
+        self._validate_idents([table_name, index_name])
+        query = self.REMOVE_INDEX_TEMPLATE.format(
+            table=table_name, index=index_name
+        )
+        self.execute(query, commit=commit)
+
+    def alter_column(self, table_name, column_name, datatype, commit: bool = True):
+        self._validate_idents([table_name, column_name])
+        query = self.ALTER_COLUMN_TEMPLATE.format(
+            table=table_name, column=column_name, datatype=datatype
+        )
+        self.execute(query, commit=commit)
+
+    def change_column_name(
+        self, table_name, old_column_name, new_column_name, commit: bool = True
+    ):
+        self._validate_idents([table_name, old_column_name, new_column_name])
+        query = self.RENAME_COLUMN_TEMPLATE.format(
+            table=table_name, old=old_column_name, new=new_column_name
+        )
+        self.execute(query, commit=commit)
+
+    def change_table_name(self, old_table, new_table, commit: bool = True):
+        self._validate_idents([old_table, new_table])
+        query = self.RENAME_TABLE_TEMPLATE.format(
+            old_table=old_table, new_table=new_table
+        )
+        self.execute(query, commit=commit)
+
+    def create_table(
+        self, table_name, fields_with_type, drop_if_exists: bool = True, commit: bool = True
+    ):
+        self._validate_ident(table_name)
+        if drop_if_exists:
+            drop_query = self.DROP_TABLE_IF_EXISTS_TEMPLATE.format(table=table_name)
+            self.execute(drop_query, commit=commit)
+        create_query = self.CREATE_TABLE_TEMPLATE.format(
+            table=table_name, fields_with_type=fields_with_type
+        )
+        self.execute(create_query, commit=commit)
+
+    def drop_table(self, table_name, commit: bool = True):
+        self._validate_ident(table_name)
+        query = self.DROP_TABLE_TEMPLATE.format(table=table_name)
+        self.execute(query, commit=commit)
+
+    def insert_db_version_data(self, commit: bool = True):
+        self.execute(self.INSERT_DB_VERSION_DATA_QUERY, commit=commit)
+
+    def update_version_table(self, version, commit: bool = True):
+        self.execute(self.UPDATE_VERSION_QUERY, commit=commit, args=(str(version),))

rococo-1.3.0/rococo/migrations/mysql/migration.py

@@ -0,0 +1,40 @@
+from ..common.sql_migration_base import SQLMigrationBase
+from rococo.data.mysql import MySqlAdapter
+
+
+class MySQLMigration(SQLMigrationBase):
+    EXISTS_COLUMN_QUERY = (
+        "SELECT COUNT(*) AS count "
+        "FROM information_schema.COLUMNS "
+        "WHERE TABLE_SCHEMA = %s AND TABLE_NAME = %s AND COLUMN_NAME = %s;"
+    )
+    EXISTS_PK_QUERY = (
+        "SELECT COUNT(*) AS count "
+        "FROM information_schema.TABLE_CONSTRAINTS "
+        "WHERE TABLE_SCHEMA = %s AND TABLE_NAME = %s "
+        "AND CONSTRAINT_TYPE = 'PRIMARY KEY';"
+    )
+    UPDATE_VERSION_QUERY = "UPDATE db_version SET version = %s;"
+    INSERT_DB_VERSION_DATA_QUERY = (
+        "INSERT INTO db_version (version) VALUES ('0000000000');"
+    )
+
+    DROP_PK_TEMPLATE = "ALTER TABLE {table} DROP PRIMARY KEY;"
+    ADD_PK_TEMPLATE = "ALTER TABLE {table} ADD PRIMARY KEY {keys};"
+    ADD_COLUMN_TEMPLATE = "ALTER TABLE {table} ADD {column} {datatype};"
+    DROP_COLUMN_TEMPLATE = "ALTER TABLE {table} DROP {column};"
+    ADD_INDEX_TEMPLATE = "ALTER TABLE {table} ADD INDEX {index} ({column});"
+    REMOVE_INDEX_TEMPLATE = "ALTER TABLE {table} DROP INDEX {index};"
+    ALTER_INDEX_TEMPLATES = (
+        "ALTER TABLE {table} ADD INDEX {new_index} ({new_column}), "
+        "DROP INDEX {old_index};",
+    )
+    ALTER_COLUMN_TEMPLATE = "ALTER TABLE {table} MODIFY COLUMN {column} {datatype};"
+    RENAME_COLUMN_TEMPLATE = "ALTER TABLE {table} RENAME COLUMN {old} TO {new};"
+    RENAME_TABLE_TEMPLATE = "ALTER TABLE {old_table} RENAME TO {new_table};"
+    CREATE_TABLE_TEMPLATE = "CREATE TABLE {table} ({fields_with_type});"
+    DROP_TABLE_IF_EXISTS_TEMPLATE = "DROP TABLE IF EXISTS {table};"
+    DROP_TABLE_TEMPLATE = "DROP TABLE {table};"
+
+    def __init__(self, db_adapter: MySqlAdapter):
+        super().__init__(db_adapter)

rococo-1.3.0/rococo/migrations/postgres/migration.py

@@ -0,0 +1,44 @@
+from ..common.sql_migration_base import SQLMigrationBase
+from rococo.data.postgresql import PostgreSQLAdapter
+
+
+class PostgresMigration(SQLMigrationBase):
+    EXISTS_COLUMN_QUERY = (
+        "SELECT COUNT(*) AS count "
+        "FROM information_schema.columns "
+        "WHERE table_catalog = %s AND table_name = %s AND column_name = %s;"
+    )
+    EXISTS_PK_QUERY = (
+        "SELECT COUNT(*) AS count "
+        "FROM information_schema.table_constraints "
+        "WHERE table_catalog = %s AND table_name = %s "
+        "AND constraint_type = 'PRIMARY KEY';"
+    )
+    UPDATE_VERSION_QUERY = "UPDATE db_version SET version = %s;"
+    INSERT_DB_VERSION_DATA_QUERY = (
+        "INSERT INTO db_version (version) VALUES ('0000000000');"
+    )
+
+    DROP_PK_TEMPLATE = (
+        "ALTER TABLE {table} DROP CONSTRAINT IF EXISTS {table}_pkey;"
+    )
+    ADD_PK_TEMPLATE = (
+        "ALTER TABLE {table} ADD CONSTRAINT {table}_pkey PRIMARY KEY {keys};"
+    )
+    ADD_COLUMN_TEMPLATE = "ALTER TABLE {table} ADD COLUMN {column} {datatype};"
+    DROP_COLUMN_TEMPLATE = "ALTER TABLE {table} DROP COLUMN {column};"
+    ADD_INDEX_TEMPLATE = "CREATE INDEX {index} ON {table} ({column});"
+    REMOVE_INDEX_TEMPLATE = "DROP INDEX IF EXISTS {index};"
+    ALTER_INDEX_TEMPLATES = (
+        "DROP INDEX IF EXISTS {old_index};",
+        "CREATE INDEX {new_index} ON {table} ({new_column});",
+    )
+    ALTER_COLUMN_TEMPLATE = "ALTER TABLE {table} ALTER COLUMN {column} TYPE {datatype};"
+    RENAME_COLUMN_TEMPLATE = "ALTER TABLE {table} RENAME COLUMN {old} TO {new};"
+    RENAME_TABLE_TEMPLATE = "ALTER TABLE {old_table} RENAME TO {new_table};"
+    CREATE_TABLE_TEMPLATE = "CREATE TABLE {table} ({fields_with_type});"
+    DROP_TABLE_IF_EXISTS_TEMPLATE = "DROP TABLE IF EXISTS {table} CASCADE;"
+    DROP_TABLE_TEMPLATE = "DROP TABLE {table} CASCADE;"
+
+    def __init__(self, db_adapter: PostgreSQLAdapter):
+        super().__init__(db_adapter)

{rococo-1.2.0 → rococo-1.3.0}/rococo/repositories/postgresql/postgresql_repository.py

@@ -79,7 +79,8 @@ class PostgreSQLRepository(BaseRepository):
             conditions = self._adjust_conditions(conditions)
 
         data = self._execute_within_context(
-            self.adapter.get_one, self.table_name, conditions
+            self.adapter.get_one, self.table_name, conditions,
+            active=self._is_versioned_model()
         )
 
         if not data:
@@ -118,7 +119,8 @@ class PostgreSQLRepository(BaseRepository):
             conditions = self._adjust_conditions(conditions)
         # Fetch the records
         records = self._execute_within_context(
-            self.adapter.get_many, self.table_name, conditions, sort, limit, offset
+            self.adapter.get_many, self.table_name, conditions, sort, limit, offset,
+            active=self._is_versioned_model()
         )
 
         # If the adapter returned a single dictionary, wrap it in a list
@@ -164,8 +166,11 @@ class PostgreSQLRepository(BaseRepository):
             int: The count of matching records.
         """
         # Prepare the actual conditions for the database query
-        # Default conditions from BaseRepository
-        db_conditions = {'latest': True, 'active': True}
+        # Only add versioning filters for VersionedModel
+        if self._is_versioned_model():
+            db_conditions = {'latest': True, 'active': True}
+        else:
+            db_conditions = {}
         if query:  # Ensure query is not None before updating
             actual_query = self._adjust_conditions(
                 query.copy())  # Adjust UUIDs in query

{rococo-1.2.0 → rococo-1.3.0}/rococo/repositories/surrealdb/surreal_db_repository.py

@@ -197,7 +197,8 @@ class SurrealDbRepository(BaseRepository):
             self.table_name,
             conditions,
             fetch_related=fetch_related,
-            additional_fields=additional_fields
+            additional_fields=additional_fields,
+            active=self._is_versioned_model()
         )
         # prep model context
         self.model()
@@ -265,7 +266,8 @@ class SurrealDbRepository(BaseRepository):
             sort=sort,
             limit=limit,
             fetch_related=fetch_related,
-            additional_fields=additional_fields
+            additional_fields=additional_fields,
+            active=self._is_versioned_model()
         )
         if isinstance(raw, dict):
             raw = [raw]

{rococo-1.2.0 → rococo-1.3.0}/rococo.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rococo
-Version: 1.2.0
+Version: 1.3.0
 Summary: A Python library to help build things the way we want them built
 Home-page: https://github.com/EcorRouge/rococo
 Author: Jay Grieves

{rococo-1.2.0 → rococo-1.3.0}/rococo.egg-info/SOURCES.txt

@@ -42,6 +42,7 @@ rococo/migrations/common/cli_base.py
 rococo/migrations/common/migration_base.py
 rococo/migrations/common/migration_runner.py
 rococo/migrations/common/migration_template.py
+rococo/migrations/common/sql_migration_base.py
 rococo/migrations/mongo/__init__.py
 rococo/migrations/mongo/cli.py
 rococo/migrations/mongo/migration.py
@@ -95,11 +96,13 @@ tests/__init__.py
 tests/base_repository_test.py
 tests/config_test.py
 tests/dynamodb_repository_test.py
+tests/migration_cli_base_test.py
 tests/migration_runner_test.py
 tests/model_test.py
 tests/mongodb_repository_test.py
 tests/mysql_repository_test.py
 tests/postgre_repository_test.py
+tests/sql_migration_base_test.py
 tests/surrealdb_repository_test.py
 tests/test_calculated_properties_fix.py
 tests/test_faxing.py

{rococo-1.2.0 → rococo-1.3.0}/setup.py

@@ -64,7 +64,7 @@ extras_require["all"] = [
 
 setup(
     name='rococo',
-    version='1.2.0',
+    version='1.3.0',
     packages=find_packages(),
     url='https://github.com/EcorRouge/rococo',
     license='MIT',