zou 0.20.44__tar.gz → 0.20.45__tar.gz

{zou-0.20.44/zou.egg-info → zou-0.20.45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zou
-Version: 0.20.44
+Version: 0.20.45
 Summary: API to store and manage the data of your animation production
 Home-page: https://zou.cg-wire.com
 Author: CG Wire

zou-0.20.45/zou/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.20.45"

{zou-0.20.44 → zou-0.20.45}/zou/app/api.py

@@ -1,9 +1,4 @@
-import os
 import sys
-import importlib
-import traceback
-
-from pathlib import Path
 
 from zou.app.blueprints.assets import blueprint as assets_blueprint
 from zou.app.blueprints.auth import blueprint as auth_blueprint
@@ -29,7 +24,7 @@ from zou.app.blueprints.user import blueprint as user_blueprint
 from zou.app.blueprints.edits import blueprint as edits_blueprint
 from zou.app.blueprints.concepts import blueprint as concepts_blueprint
 
-from zou.app.utils.plugins import PluginManifest
+from zou.app.utils.plugins import load_plugins
 from zou.app.utils import events
 
 
@@ -92,40 +87,3 @@ def register_event_handlers(app):
         # app.logger.info("No event handlers folder is configured.")
         pass
     return app
-
-
-def load_plugins(app):
-    """
-    Load plugins from the plugin folder.
-    """
-    plugin_folder = app.config["PLUGIN_FOLDER"]
-    abs_plugin_path = os.path.abspath(plugin_folder)
-    if abs_plugin_path not in sys.path:
-        sys.path.insert(0, abs_plugin_path)
-
-    if os.path.exists(plugin_folder):
-        for plugin_id in os.listdir(plugin_folder):
-            try:
-                load_plugin(app, plugin_id)
-                app.logger.info(f"Plugin {plugin_id} loaded.")
-            except ImportError as e:
-                app.logger.error(f"Plugin {plugin_id} failed to import: {e}")
-            except Exception as e:
-                app.logger.error(
-                    f"Plugin {plugin_id} failed to initialize: {e}"
-                )
-                app.logger.debug(traceback.format_exc())
-
-    if abs_plugin_path in sys.path:
-        sys.path.remove(abs_plugin_path)
-
-
-def load_plugin(app, plugin_id):
-    plugin_path = Path(app.config["PLUGIN_FOLDER"]) / plugin_id
-    manifest = PluginManifest.from_file(plugin_path / "manifest.toml")
-
-    plugin_module = importlib.import_module(plugin_id)
-    if hasattr(plugin_module, "init_plugin"):
-        plugin_module.init_plugin(app, manifest)
-
-    return plugin_module

{zou-0.20.44 → zou-0.20.45}/zou/app/models/plugin.py

@@ -19,3 +19,4 @@ class Plugin(db.Model, BaseMixin, SerializerMixin):
     maintainer_email = db.Column(EmailType)
     website = db.Column(URLType)
     license = db.Column(db.String(80), nullable=False)
+    revision = db.Column(db.String(12), nullable=True)

zou-0.20.45/zou/app/services/plugins_service.py

@@ -0,0 +1,66 @@
+import semver
+from pathlib import Path
+
+from zou.app import config, db
+from zou.app.models.plugin import Plugin
+from zou.app.utils.plugins import (
+    PluginManifest,
+    run_plugin_migrations,
+    downgrade_plugin_migrations,
+    uninstall_plugin_files,
+    install_plugin_files,
+)
+
+
+def install_plugin(path, force=False):
+    """
+    Install a plugin.
+    """
+    path = Path(path)
+    if not path.exists():
+        raise FileNotFoundError(f"Plugin path '{path}' does not exist.")
+
+    manifest = PluginManifest.from_plugin_path(path)
+    plugin = Plugin.query.filter_by(plugin_id=manifest.id).one_or_none()
+
+    try:
+        if plugin:
+            current = semver.Version.parse(plugin.version)
+            new = semver.Version.parse(str(manifest.version))
+            if not force and new <= current:
+                raise ValueError(
+                    f"Plugin version {new} is not newer than {current}."
+                )
+            plugin.update_no_commit(manifest.to_model_dict())
+        else:
+            plugin = Plugin.create_no_commit(**manifest.to_model_dict())
+
+        plugin_path = install_plugin_files(
+            path, Path(config.PLUGIN_FOLDER) / manifest.id
+        )
+        run_plugin_migrations(plugin_path, plugin)
+    except Exception:
+        uninstall_plugin_files(manifest.id)
+        db.session.rollback()
+        db.session.remove()
+        raise
+
+    Plugin.commit()
+    return plugin.serialize()
+
+
+def uninstall_plugin(plugin_id):
+    """
+    Uninstall a plugin.
+    """
+    plugin_path = Path(config.PLUGIN_FOLDER) / plugin_id
+    downgrade_plugin_migrations(plugin_path)
+    installed = uninstall_plugin_files(plugin_path)
+    plugin = Plugin.query.filter_by(plugin_id=plugin_id).one_or_none()
+    if plugin is not None:
+        installed = True
+        plugin.delete()
+
+    if not installed:
+        raise ValueError(f"Plugin '{plugin_id}' is not installed.")
+    return True

{zou-0.20.44 → zou-0.20.45}/zou/app/utils/commands.py

@@ -865,6 +865,9 @@ def list_plugins(output_format, verbose, filter_field, filter_value):
             if verbose:
                 plugin_data["Description"] = plugin.description or "-"
                 plugin_data["Website"] = plugin.website or "-"
+                plugin_data["Revision"] = plugin.revision or "-"
+                plugin_data["Installation Date"] = plugin.created_at
+                plugin_data["Last Update"] = plugin.updated_at
             plugin_list.append(plugin_data)
 
         if output_format == "table":

zou-0.20.45/zou/app/utils/plugins.py

@@ -0,0 +1,340 @@
+import tomlkit
+import semver
+import email.utils
+import spdx_license_list
+import zipfile
+import importlib
+import importlib.util
+import sys
+import os
+import traceback
+import shutil
+
+from pathlib import Path
+from flask import current_app
+from alembic import command
+from alembic.config import Config
+
+
+from pathlib import Path
+from collections.abc import MutableMapping
+
+
+class PluginManifest(MutableMapping):
+    def __init__(self, data):
+        super().__setattr__("data", data)
+        self.validate()
+
+    @classmethod
+    def from_plugin_path(cls, path):
+        path = Path(path)
+        if path.is_dir():
+            return cls.from_file(path / "manifest.toml")
+        elif zipfile.is_zipfile(path):
+            with zipfile.ZipFile(path) as z:
+                with z.open("manifest.toml") as f:
+                    data = tomlkit.load(f)
+            return cls(data)
+        else:
+            raise ValueError(f"Invalid plugin path: {path}")
+
+    @classmethod
+    def from_file(cls, path):
+        with open(path, "rb") as f:
+            data = tomlkit.load(f)
+        return cls(data)
+
+    def write_to_path(self, path):
+        path = Path(path)
+        with open(path / "manifest.toml", "w", encoding="utf-8") as f:
+            tomlkit.dump(self.data, f)
+
+    def validate(self):
+        semver.Version.parse(str(self.data["version"]))
+        spdx_license_list.LICENSES[self.data["license"]]
+        if "maintainer" in self.data:
+            name, email_addr = email.utils.parseaddr(self.data["maintainer"])
+            self.data["maintainer_name"] = name
+            self.data["maintainer_email"] = email_addr
+
+    def to_model_dict(self):
+        return {
+            "plugin_id": self.data["id"],
+            "name": self.data["name"],
+            "description": self.data.get("description"),
+            "version": str(self.data["version"]),
+            "maintainer_name": self.data.get("maintainer_name"),
+            "maintainer_email": self.data.get("maintainer_email"),
+            "website": self.data.get("website"),
+            "license": self.data["license"],
+        }
+
+    def __getitem__(self, key):
+        return self.data[key]
+
+    def __setitem__(self, key, value):
+        self.data[key] = value
+
+    def __delitem__(self, key):
+        del self.data[key]
+
+    def __iter__(self):
+        return iter(self.data)
+
+    def __len__(self):
+        return len(self.data)
+
+    def __repr__(self):
+        return f"<PluginManifest {self.data!r}>"
+
+    def __getattr__(self, attr):
+        try:
+            return self.data[attr]
+        except KeyError:
+            raise AttributeError(f"'PluginManifest' has no attribute '{attr}'")
+
+    def __setattr__(self, attr, value):
+        if attr == "data":
+            super().__setattr__(attr, value)
+        else:
+            self.data[attr] = value
+
+
+def load_plugin(app, plugin_path, init_plugin=True):
+    """
+    Load a plugin from the plugin folder.
+    """
+    plugin_path = Path(plugin_path)
+    manifest = PluginManifest.from_plugin_path(plugin_path)
+
+    plugin_module = importlib.import_module(manifest["id"])
+    if init_plugin and hasattr(plugin_module, "init_plugin"):
+        plugin_module.init_plugin(app, manifest)
+
+    return plugin_module
+
+
+def load_plugins(app):
+    """
+    Load plugins from the plugin folder.
+    """
+    plugin_folder = Path(app.config["PLUGIN_FOLDER"])
+    if plugin_folder.exists():
+        abs_plugin_path = str(plugin_folder.absolute())
+        if abs_plugin_path not in sys.path:
+            sys.path.insert(0, abs_plugin_path)
+
+        for plugin_id in os.listdir(plugin_folder):
+            try:
+                load_plugin(app, plugin_folder / plugin_id)
+                app.logger.info(f"Plugin {plugin_id} loaded.")
+            except ImportError as e:
+                app.logger.error(f"Plugin {plugin_id} failed to import: {e}")
+            except Exception as e:
+                app.logger.error(
+                    f"Plugin {plugin_id} failed to initialize: {e}"
+                )
+                app.logger.debug(traceback.format_exc())
+
+        if abs_plugin_path in sys.path:
+            sys.path.remove(abs_plugin_path)
+
+
+def migrate_plugin_db(plugin_path, message):
+    """
+    Generates Alembic migration files in path/migrations.
+    """
+    plugin_path = Path(plugin_path).absolute()
+    models_path = plugin_path / "models.py"
+
+    if not models_path.exists():
+        raise FileNotFoundError(f"'models.py' not found in '{plugin_path}'")
+
+    manifest = PluginManifest.from_plugin_path(plugin_path)
+
+    module_name = f"_plugin_models_{manifest['id']}"
+    spec = importlib.util.spec_from_file_location(module_name, models_path)
+    if spec is None or spec.loader is None:
+        raise ImportError(f"Could not load 'models.py' from '{plugin_path}'")
+
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[module_name] = module
+    try:
+        spec.loader.exec_module(module)
+        migrations_dir = plugin_path / "migrations"
+        versions_dir = migrations_dir / "versions"
+        versions_dir.mkdir(parents=True, exist_ok=True)
+
+        alembic_cfg = Config()
+        alembic_cfg.config_file_name = str(
+            plugin_path / "migrations" / "alembic.ini"
+        )
+        alembic_cfg.set_main_option("script_location", str(migrations_dir))
+        alembic_cfg.set_main_option(
+            "sqlalchemy.url", current_app.config["SQLALCHEMY_DATABASE_URI"]
+        )
+
+        command.revision(alembic_cfg, autogenerate=True, message=message)
+    finally:
+        del sys.modules[module_name]
+
+
+def run_plugin_migrations(plugin_path, plugin):
+    """
+    Run plugin migrations.
+    """
+    plugin_path = Path(plugin_path)
+
+    alembic_cfg = Config()
+    alembic_cfg.config_file_name = str(
+        plugin_path / "migrations" / "alembic.ini"
+    )
+    alembic_cfg.set_main_option(
+        "script_location", str(plugin_path / "migrations")
+    )
+    alembic_cfg.set_main_option(
+        "sqlalchemy.url", current_app.config["SQLALCHEMY_DATABASE_URI"]
+    )
+
+    command.upgrade(alembic_cfg, "head")
+
+    script = command.ScriptDirectory.from_config(alembic_cfg)
+    head_revision = script.get_current_head()
+
+    plugin.revision = head_revision
+
+    return head_revision
+
+
+def downgrade_plugin_migrations(plugin_path):
+    """
+    Downgrade plugin migrations to base.
+    """
+    plugin_path = Path(plugin_path)
+    manifest = PluginManifest.from_plugin_path(plugin_path)
+
+    alembic_cfg = Config()
+    alembic_cfg.config_file_name = str(
+        plugin_path / "migrations" / "alembic.ini"
+    )
+    alembic_cfg.set_main_option(
+        "script_location", str(plugin_path / "migrations")
+    )
+    alembic_cfg.set_main_option(
+        "sqlalchemy.url", current_app.config["SQLALCHEMY_DATABASE_URI"]
+    )
+
+    try:
+        command.downgrade(alembic_cfg, "base")
+    except Exception as e:
+        current_app.logger.warning(
+            f"Downgrade failed for plugin {manifest.id}: {e}"
+        )
+
+
+def create_plugin_package(path, output_path, force=False):
+    """
+    Create a plugin package.
+    """
+    path = Path(path)
+    if not path.exists():
+        raise FileNotFoundError(f"Plugin path '{path}' does not exist.")
+
+    manifest = PluginManifest.from_plugin_path(path)
+
+    output_path = Path(output_path)
+    if not output_path.suffix == ".zip":
+        output_path /= f"{manifest.id}-{manifest.version}.zip"
+    if output_path.exists():
+        if force:
+            output_path.unlink()
+        else:
+            raise FileExistsError(
+                f"Output path '{output_path}' already exists."
+            )
+
+    output_path = shutil.make_archive(
+        output_path.with_suffix(""),
+        "zip",
+        path,
+    )
+    return output_path
+
+
+def create_plugin_skeleton(
+    path,
+    id,
+    name,
+    description=None,
+    version=None,
+    maintainer=None,
+    website=None,
+    license=None,
+    force=False,
+):
+    plugin_template_path = (
+        Path(__file__).parent.parent.parent / "plugin_template"
+    )
+    plugin_path = Path(path) / id
+
+    if plugin_path.exists():
+        if force:
+            shutil.rmtree(plugin_path)
+        else:
+            raise FileExistsError(
+                f"Plugin '{id}' already exists in {plugin_path}."
+            )
+
+    shutil.copytree(plugin_template_path, plugin_path)
+
+    manifest = PluginManifest.from_file(plugin_path / "manifest.toml")
+
+    manifest.id = id
+    manifest.name = name
+    if description:
+        manifest.description = description
+    if version:
+        manifest.version = version
+    if maintainer:
+        manifest.maintainer = maintainer
+    if website:
+        manifest.website = website
+    if license:
+        manifest.license = license
+
+    manifest.validate()
+    manifest.write_to_path(plugin_path)
+
+    return plugin_path
+
+
+def install_plugin_files(files_path, installation_path):
+    """
+    Install plugin files.
+    """
+    files_path = Path(files_path)
+    installation_path = Path(installation_path)
+
+    installation_path.mkdir(parents=True, exist_ok=True)
+
+    if files_path.is_dir():
+        shutil.copytree(files_path, installation_path, dirs_exist_ok=True)
+    elif zipfile.is_zipfile(files_path):
+        shutil.unpack_archive(files_path, installation_path, format="zip")
+    else:
+        raise ValueError(
+            f"Plugin path '{files_path}' is not a valid zip file or a directory."
+        )
+
+    return installation_path
+
+
+def uninstall_plugin_files(plugin_path):
+    """
+    Uninstall plugin files.
+    """
+    plugin_path = Path(plugin_path)
+    if plugin_path.exists():
+        shutil.rmtree(plugin_path)
+        return True
+    return False

{zou-0.20.44 → zou-0.20.45}/zou/cli.py

@@ -8,7 +8,7 @@ import traceback
 
 from sqlalchemy.exc import IntegrityError
 
-from zou.app.utils import dbhelpers, auth, commands
+from zou.app.utils import dbhelpers, auth, commands, plugins as plugin_utils
 from zou.app.services import persons_service, auth_service, plugins_service
 from zou.app.services.exception import (
     IsUserLimitReachedException,
@@ -738,7 +738,7 @@ def create_plugin_skeleton(
     """
     Create a plugin skeleton.
     """
-    plugin_path = plugins_service.create_plugin_skeleton(
+    plugin_path = plugin_utils.create_plugin_skeleton(
         path,
         id,
         name,
@@ -775,9 +775,7 @@ def create_plugin_package(
     """
     Create a plugin package.
     """
-    plugin_path = plugins_service.create_plugin_package(
-        path, output_path, force
-    )
+    plugin_path = plugin_utils.create_plugin_package(path, output_path, force)
     print(f"Plugin package created in '{plugin_path}'.")
 
 
@@ -811,5 +809,20 @@ def list_plugins(output_format, verbose, filter_field, filter_value):
     commands.list_plugins(output_format, verbose, filter_field, filter_value)
 
 
+@cli.command()
+@click.option(
+    "--path",
+    required=True,
+)
+@click.option("--message", default="")
+def migrate_plugin_db(path, message):
+    """
+    Migrate plugin database.
+    """
+    with app.app_context():
+        plugin_utils.migrate_plugin_db(path, message)
+    print(f"Plugin {path} database migrated.")
+
+
 if __name__ == "__main__":
     cli()

zou-0.20.45/zou/migrations/env.py

@@ -0,0 +1,64 @@
+import logging
+
+from alembic import context
+from sqlalchemy import create_engine, pool
+from logging.config import fileConfig
+from flask import current_app
+
+from zou.app import db
+
+# Database URL (passed by Alembic)
+config = context.config
+url = current_app.config.get("SQLALCHEMY_DATABASE_URI")
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+fileConfig(config.config_file_name)
+logger = logging.getLogger("alembic.env")
+
+
+def include_object(object, name, type_, reflected, compare_to):
+    if type_ == "table":
+        return not reflected or name in db.metadata.tables
+    return True
+
+
+def render_item(type_, obj, autogen_context):
+    """Apply custom rendering for selected items."""
+
+    import sqlalchemy_utils
+
+    if type_ == "type" and isinstance(
+        obj, sqlalchemy_utils.types.uuid.UUIDType
+    ):
+        autogen_context.imports.add("import sqlalchemy_utils")
+        autogen_context.imports.add("import uuid")
+        return "sqlalchemy_utils.types.uuid.UUIDType(binary=False), default=uuid.uuid4"
+
+    return False
+
+
+def process_revision_directives(context, revision, directives):
+    if getattr(config.cmd_opts, "autogenerate", False):
+        script = directives[0]
+        if script.upgrade_ops.is_empty():
+            directives[:] = []
+            logger.info("No changes in schema detected.")
+
+
+def run_migrations_online():
+    connectable = create_engine(url, poolclass=pool.NullPool)
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection,
+            target_metadata=db.metadata,
+            process_revision_directives=process_revision_directives,
+            render_item=render_item,
+            include_object=include_object,
+            **current_app.extensions["migrate"].configure_args,
+        )
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+run_migrations_online()

zou-0.20.45/zou/migrations/versions/d80f02824047_add_plugin_revision.py

@@ -0,0 +1,67 @@
+"""Add plugin.revision
+
+Revision ID: d80f02824047
+Revises: e7e633bd6fa2
+Create Date: 2025-05-02 16:08:57.078114
+
+"""
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = "d80f02824047"
+down_revision = "e7e633bd6fa2"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("plugin", schema=None) as batch_op:
+        batch_op.add_column(
+            sa.Column("revision", sa.String(length=12), nullable=True)
+        )
+
+    with op.batch_alter_table("salary_scale", schema=None) as batch_op:
+        batch_op.alter_column(
+            "position", existing_type=sa.VARCHAR(length=255), nullable=True
+        )
+        batch_op.alter_column(
+            "seniority", existing_type=sa.VARCHAR(length=255), nullable=True
+        )
+
+    with op.batch_alter_table("task", schema=None) as batch_op:
+        batch_op.alter_column(
+            "difficulty",
+            existing_type=sa.INTEGER(),
+            nullable=False,
+            existing_server_default=sa.text("3"),
+        )
+
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("task", schema=None) as batch_op:
+        batch_op.alter_column(
+            "difficulty",
+            existing_type=sa.INTEGER(),
+            nullable=True,
+            existing_server_default=sa.text("3"),
+        )
+
+    with op.batch_alter_table("salary_scale", schema=None) as batch_op:
+        batch_op.alter_column(
+            "seniority", existing_type=sa.VARCHAR(length=255), nullable=False
+        )
+        batch_op.alter_column(
+            "position", existing_type=sa.VARCHAR(length=255), nullable=False
+        )
+
+    with op.batch_alter_table("plugin", schema=None) as batch_op:
+        batch_op.drop_column("revision")
+
+    # ### end Alembic commands ###