zou 0.20.38__py3-none-any.whl → 0.20.39__py3-none-any.whl

zou/app/services/budget_service.py

@@ -0,0 +1,195 @@
+from zou.app.models.budget import Budget
+from zou.app.models.budget_entry import BudgetEntry
+
+from zou.app.services.exception import (
+    BudgetNotFoundException,
+    BudgetEntryNotFoundException,
+)
+
+from zou.app.utils import events
+from zou.app.utils import fields
+
+from sqlalchemy.exc import StatementError
+
+
+def get_budget_raw(budget_id):
+    """
+    Return budget corresponding to given budget ID.
+    """
+    if budget_id is None:
+        raise BudgetNotFoundException()
+
+    try:
+        budget = Budget.get(budget_id)
+    except StatementError:
+        raise BudgetNotFoundException()
+
+    if budget is None:
+        raise BudgetNotFoundException()
+    return budget
+
+
+def get_budget(budget_id):
+    """
+    Return budget corresponding to given budget ID as a dictionary.
+    """
+    return get_budget_raw(budget_id).serialize(relations=True)
+
+
+def get_budgets(project_id):
+    """
+    Return all budgets for given project ID.
+    """
+    budgets = Budget.get_all_by(project_id=project_id)
+    return fields.present_models(budgets)
+
+
+def create_budget(project_id, name, currency=None):
+    """
+    Create a new budget for given project ID.
+    """
+    last_budget = (
+        Budget.query.filter_by(project_id=project_id)
+        .order_by(Budget.revision.desc())
+        .first()
+    )
+    last_revision = 1
+    if last_budget is not None:
+        last_revision = last_budget.revision + 1
+    budget = Budget(
+        project_id=project_id,
+        name=name,
+        currency=currency,
+        revision=last_revision,
+    )
+    budget.save()
+    events.emit(
+        "budget:create",
+        {"budget_id": str(budget.id)},
+        project_id=project_id,
+    )
+    return budget.serialize()
+
+
+def update_budget(budget_id, name=None, currency=None):
+    """
+    Update budget corresponding to given budget ID.
+    """
+    budget = get_budget_raw(budget_id)
+    if name is not None:
+        budget.name = name
+    if currency is not None:
+        budget.currency = currency
+    budget.save()
+    events.emit(
+        "budget:update",
+        {"budget_id": str(budget.id)},
+        project_id=str(budget.project_id),
+    )
+    return budget.serialize()
+
+
+def delete_budget(budget_id):
+    """
+    Delete budget corresponding to given budget ID.
+    """
+    budget = get_budget_raw(budget_id)
+    budget_entries = BudgetEntry.delete_all_by(budget_id=budget_id)
+    budget.delete()
+    events.emit(
+        "budget:delete",
+        {"budget_id": budget_id},
+        project_id=str(budget.project_id),
+    )
+    return budget.serialize()
+
+
+def get_budget_entries(budget_id):
+    """
+    Return all budget entries for given budget ID.
+    """
+    budget_entries = BudgetEntry.get_all_by(budget_id=budget_id)
+    return fields.present_models(budget_entries)
+
+
+def get_budget_entry_raw(budget_entry_id):
+    """
+    Return budget entry corresponding to given budget entry ID.
+    """
+    try:
+        budget_entry = BudgetEntry.get(budget_entry_id)
+    except StatementError:
+        raise BudgetEntryNotFoundException()
+
+    if budget_entry is None:
+        raise BudgetEntryNotFoundException()
+    return budget_entry
+
+
+def get_budget_entry(budget_entry_id):
+    """
+    Return budget entry corresponding to given budget entry ID as a dictionary.
+    """
+    return get_budget_entry_raw(budget_entry_id).serialize()
+
+
+def create_budget_entry(
+    budget_id,
+    department_id,
+    start_date,
+    months_duration,
+    daily_salary,
+    position,
+    seniority,
+    person_id=None,
+):
+    """
+    Create a new budget entry for given budget ID.
+    """
+    budget = get_budget_raw(budget_id)
+    budget_entry = BudgetEntry.create(
+        budget_id=budget_id,
+        department_id=department_id,
+        person_id=person_id,
+        start_date=start_date,
+        months_duration=months_duration,
+        daily_salary=daily_salary,
+        position=position,
+        seniority=seniority,
+    )
+    events.emit(
+        "budget-entry:create",
+        {"budget_id": str(budget_id), "budget_entry_id": str(budget_entry.id)},
+        project_id=str(budget.project_id),
+    )
+    return budget_entry.serialize()
+
+
+def update_budget_entry(budget_entry_id, data):
+    """
+    Update budget entry corresponding to given budget entry ID.
+    """
+    budget_entry = get_budget_entry_raw(budget_entry_id)
+    budget = get_budget_raw(str(budget_entry.budget_id))
+    budget_entry.update(data)
+    events.emit(
+        "budget-entry:update",
+        {"budget_id": str(budget.id), "budget_entry_id": str(budget_entry.id)},
+        project_id=str(budget.project_id),
+    )
+    return budget_entry.serialize()
+
+
+def delete_budget_entry(budget_entry_id):
+    """
+    Delete budget entry corresponding to given budget entry ID.
+    """
+    budget_entry = get_budget_entry_raw(budget_entry_id)
+    budget = get_budget_raw(str(budget_entry.budget_id))
+    budget_entry.delete()
+    events.emit(
+        "budget-entry:delete",
+        {"budget_id": str(budget.id), "budget_entry_id": budget_entry_id},
+        project_id=str(budget.project_id),
+    )
+    return budget_entry.serialize()

zou/app/services/comments_service.py

@@ -333,7 +333,7 @@ def new_comment(
         {
             "comment_id": comment["id"],
             "task_id": task_id,
-            "task_status_id": task_status_id
+            "task_status_id": task_status_id,
         },
         project_id=task["project_id"],
     )

zou/app/services/exception.py

@@ -149,6 +149,14 @@ class MetadataDescriptorNotFoundException(NotFound):
     pass
 
 
+class BudgetNotFoundException(NotFound):
+    pass
+
+
+class BudgetEntryNotFoundException(NotFound):
+    pass
+
+
 class MalformedFileTreeException(Exception):
     pass
 

zou/app/services/plugin_service.py

@@ -0,0 +1,195 @@
+import zipfile
+import semver
+import spdx_license_list
+import shutil
+import email.utils
+import tomlkit
+
+from pathlib import Path
+
+from zou.app import config, db
+from zou.app.models.plugin import Plugin
+
+
+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.")
+
+    try:
+        manifest_file = None
+        if path.is_dir():
+            manifest_file = open(path.joinpath("manifest.toml"), "rb")
+        elif zipfile.is_zipfile(path):
+            with zipfile.ZipFile(path) as zip_file:
+                manifest_file = zip_file.open("manifest.toml", "rb")
+        else:
+            raise ValueError(
+                f"Plugin path '{path}' is not a valid zip file or a directory."
+            )
+
+        # Read the plugin metadatas
+        manifest = tomlkit.load(manifest_file)
+    finally:
+        if manifest_file is not None:
+            manifest_file.close()
+
+    version = str(semver.Version.parse(manifest["version"]))
+    spdx_license_list.LICENSES[manifest["license"]]
+    if manifest.get("maintainer") is not None:
+        manifest["maintainer_name"], manifest["maintainer_email"] = (
+            email.utils.parseaddr(manifest["maintainer"])
+        )
+
+    new_plugin_info = {
+        "plugin_id": manifest["id"],
+        "name": manifest["name"],
+        "description": manifest.get("description"),
+        "version": version,
+        "maintainer_name": manifest["maintainer_name"],
+        "maintainer_email": manifest.get("maintainer_email"),
+        "website": manifest.get("website"),
+        "license": manifest["license"],
+    }
+
+    # Check if the plugin is already installed
+    plugin = Plugin.query.filter_by(
+        plugin_id=new_plugin_info["plugin_id"]
+    ).one_or_none()
+
+    already_installed = False
+    try:
+        if plugin is not None:
+            existing_plugin_version = semver.Version.parse(plugin.version)
+
+            if not force:
+                if existing_plugin_version == version:
+                    raise ValueError(
+                        f"Plugin '{manifest['name']}' version {version} is already installed."
+                    )
+                elif existing_plugin_version > version:
+                    raise ValueError(
+                        f"Plugin '{manifest['name']}' version {version} is older than the installed version {existing_plugin_version}."
+                    )
+            already_installed = True
+            plugin.update_no_commit(new_plugin_info)
+        else:
+            plugin = Plugin.create_no_commit(**new_plugin_info)
+
+        install_plugin_files(
+            new_plugin_info["plugin_id"],
+            path,
+            already_installed=already_installed,
+        )
+    except:
+        db.session.rollback()
+        db.session.remove()
+        raise
+    Plugin.commit()
+
+    return plugin.serialize()
+
+
+def install_plugin_files(plugin_id, path, already_installed=False):
+    """
+    Install the plugin files.
+    """
+    path = Path(path)
+    plugin_path = Path(config.PLUGIN_FOLDER).joinpath(plugin_id)
+    if already_installed:
+        shutil.rmtree(plugin_path)
+
+    plugin_path.mkdir(parents=True, exist_ok=True)
+
+    if path.is_dir():
+        shutil.copytree(path, plugin_path, dirs_exist_ok=True)
+    elif zipfile.is_zipfile(path):
+        shutil.unpack_archive(path, plugin_path, format="zip")
+    else:
+        raise ValueError(
+            f"Plugin path '{path}' is not a valid zip file or a directory."
+        )
+
+    return plugin_path
+
+
+def uninstall_plugin_files(plugin_id):
+    """
+    Uninstall the plugin files.
+    """
+    plugin_path = Path(config.PLUGIN_FOLDER).joinpath(plugin_id)
+    if plugin_path.exists():
+        shutil.rmtree(plugin_path)
+        return True
+    return False
+
+
+def uninstall_plugin(plugin_id):
+    """
+    Uninstall a plugin.
+    """
+    installed = uninstall_plugin_files(plugin_id)
+    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
+
+
+def create_plugin_skeleton(
+    path,
+    id,
+    name,
+    description=None,
+    version=None,
+    maintainer=None,
+    website=None,
+    license=None,
+    force=False,
+):
+    """
+    Create a plugin skeleton.
+    """
+    plugin_template_path = Path(__file__).parent.parent.parent.joinpath(
+        "plugin_template"
+    )
+    plugin_path = Path(path).joinpath(id)
+    if plugin_path.exists():
+        if force:
+            shutil.rmtree(plugin_path)
+        else:
+            raise ValueError(f"Plugin '{id}' already exists in {plugin_path}.")
+
+    shutil.copytree(plugin_template_path, plugin_path)
+
+    manifest_path = plugin_path.joinpath("manifest.toml")
+    with open(manifest_path, "r") as manifest_file:
+        manifest = tomlkit.load(manifest_file)
+
+    manifest["id"] = id
+    if name is not None:
+        manifest["name"] = name
+    if description is not None:
+        manifest["description"] = description
+    if version is not None:
+        manifest["version"] = version
+        semver.Version.parse(manifest["version"])
+    if maintainer is not None:
+        manifest["maintainer"] = maintainer
+        email.utils.parseaddr(manifest["maintainer"])
+    if website is not None:
+        manifest["website"] = website
+    if license is not None:
+        manifest["license"] = license
+        spdx_license_list.LICENSES[manifest["license"]]
+
+    with open(manifest_path, "w") as manifest_file:
+        tomlkit.dump(manifest, manifest_file)
+
+    return plugin_path

zou/app/services/user_service.py

@@ -1460,9 +1460,7 @@ def get_last_notifications(
                 )
             else:
                 reply_mentions = []
-                reply_department_mentions = (
-                    []
-                )
+                reply_department_mentions = []
 
         if role == "client" and is_current_user_artist:
             comment_text = ""

zou/app/utils/fields.py

@@ -92,6 +92,13 @@ def serialize_models(models, relations=False, milliseconds=False):
     ]
 
 
+def present_models(models):
+    """
+    Present a list of models (useful for json dumping)
+    """
+    return [model.present() for model in models if model is not None]
+
+
 def gen_uuid():
     """
     Generate a unique identifier (useful for json dumping).
@@ -123,6 +130,9 @@ def get_default_date_object(date_string):
 
 
 def is_valid_id(uuid):
+    """
+    Check if a given string is a valid UUID.
+    """
     _UUID_RE = re.compile(
         "([a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}){1}"
     )

zou/cli.py

@@ -9,7 +9,7 @@ import traceback
 from sqlalchemy.exc import IntegrityError
 
 from zou.app.utils import dbhelpers, auth, commands
-from zou.app.services import persons_service, auth_service
+from zou.app.services import persons_service, auth_service, plugin_service
 from zou.app.services.exception import (
     IsUserLimitReachedException,
     PersonNotFoundException,
@@ -643,5 +643,113 @@ def renormalize_movie_preview_files(
     )
 
 
+@cli.command()
+@click.option(
+    "--path",
+    required=True,
+)
+@click.option(
+    "--force",
+    is_flag=True,
+    default=False,
+    show_default=True,
+)
+def install_plugin(path, force=False):
+    """
+    Install a plugin.
+    """
+    with app.app_context():
+        plugin_service.install_plugin(path, force)
+    print(f"Plugin {path} installed. Restart the server to apply changes.")
+
+
+@cli.command()
+@click.option(
+    "--id",
+    required=True,
+)
+def uninstall_plugin(id):
+    """
+    Uninstall a plugin.
+    """
+    with app.app_context():
+        plugin_service.uninstall_plugin(id)
+    print(f"Plugin {id} uninstalled.")
+
+
+@cli.command()
+@click.option(
+    "--path",
+    required=True,
+)
+@click.option(
+    "--id",
+    help="Plugin ID (must be unique).",
+    required=True,
+)
+@click.option(
+    "--name", help="Plugin name.", default="MyPlugin", show_default=True
+)
+@click.option(
+    "--description",
+    help="Plugin description.",
+    default="My plugin description.",
+    show_default=True,
+)
+@click.option(
+    "--version", help="Plugin version.", default="0.1.0", show_default=True
+)
+@click.option(
+    "--maintainer",
+    help="Plugin maintainer.",
+    default="Author <author@author.com>",
+    show_default=True,
+)
+@click.option(
+    "--website",
+    help="Plugin website.",
+    default="mywebsite.com",
+    show_default=True,
+)
+@click.option(
+    "--license",
+    help="Plugin license.",
+    default="GPL-3.0-only",
+    show_default=True,
+)
+@click.option(
+    "--force",
+    is_flag=True,
+    default=False,
+    show_default=True,
+)
+def create_plugin_skeleton(
+    path,
+    id,
+    name,
+    description,
+    version,
+    maintainer,
+    website,
+    license,
+    force=False,
+):
+    """
+    Create a plugin skeleton.
+    """
+    plugin_path = plugin_service.create_plugin_skeleton(
+        path,
+        id,
+        name,
+        description,
+        version,
+        maintainer,
+        website,
+        license,
+        force,
+    )
+    print(f"Plugin skeleton created in '{plugin_path}'.")
+
+
 if __name__ == "__main__":
     cli()

zou/event_stream.py

@@ -35,6 +35,9 @@ def _get_empty_room(current_frame=0):
         "current_preview_file_index": None,
         "current_frame": current_frame,
         "is_repeating": None,
+        "is_annotations_displayed": False,
+        "is_zoom_enabled": False,
+        "is_waveform_displayed": False,
         "is_laser_mode": None,
         "handle_in": None,
         "handle_out": None,
@@ -59,7 +62,7 @@ def _leave_room(room_id, user_id):
     room["people"] = list(set(room["people"]) - {user_id})
     if len(room["people"]) > 0:
         rooms_data[room_id] = room
-    else:
+    elif room_id in rooms_data:
         del rooms_data[room_id]
     _emit_people_updated(room_id, room["people"])
     return room
@@ -81,10 +84,17 @@ def _update_room_playing_status(data, room):
     room["is_playing"] = data.get("is_playing", False)
     room["is_repeating"] = data.get("is_repeating", False)
     room["is_laser_mode"] = data.get("is_laser_mode", False)
+    room["is_annotations_displayed"] = data.get(
+        "is_annotations_displayed", False
+    )
+    room["is_zoom_enabled"] = data.get("is_zoom_enabled", False)
+    room["is_waveform_displayed"] = data.get("is_waveform_displayed", False)
     room["current_entity_id"] = data.get("current_entity_id", None)
     room["current_entity_index"] = data.get("current_entity_index", None)
     room["current_preview_file_id"] = data.get("current_preview_file_id", None)
-    room["current_preview_file_index"] = data.get("current_preview_file_index", None)
+    room["current_preview_file_index"] = data.get(
+        "current_preview_file_index", None
+    )
     room["handle_in"] = data.get("handle_in", None)
     room["handle_out"] = data.get("handle_out", None)
     if "current_frame" in data:
@@ -193,19 +203,20 @@ def on_join(data):
     room["playlist_id"] = room_id
     rooms_data[room_id] = room
     _emit_people_updated(room_id, room["people"])
+    emit("preview-room:room-updated", room, room=room_id)
 
 
 @socketio.on("preview-room:leave", namespace="/events")
 @jwt_required()
 def on_leave(data):
     user_id = get_jwt_identity()
-    room_id = data["playlist_id"]
+    room_id = data.get("playlist_id", "")
     _leave_room(room_id, user_id)
 
 
-@socketio.on("preview-room:update-playing-status", namespace="/events")
+@socketio.on("preview-room:room-updated", namespace="/events")
 @jwt_required()
-def on_playing_status_updated(data, only_newcomer=False):
+def on_room_updated(data, only_newcomer=False):
     room, room_id = _get_room_from_data(data)
     rooms_data[room_id] = _update_room_playing_status(data, room)
     event_data = {"only_newcomer": only_newcomer, **rooms_data[room_id]}
@@ -240,6 +251,13 @@ def on_change_version(data):
     emit("preview-room:change-version", data, room=room_id)
 
 
+@socketio.on("preview-room:panzoom-changed", namespace="/events")
+@jwt_required()
+def on_change_version(data):
+    room_id = data["playlist_id"]
+    emit("preview-room:panzoom-changed", data, room=room_id)
+
+
 if __name__ == "__main__":
     socketio.run(
         app,

zou/migrations/versions/2762a797f1f9_add_people_salary_information.py

@@ -0,0 +1,52 @@
+"""add people salary information
+
+Revision ID: 2762a797f1f9
+Revises: 307edd8c639d
+Create Date: 2025-04-01 18:02:39.343857
+
+"""
+
+from alembic import op
+import sqlalchemy as sa
+import sqlalchemy_utils
+
+
+# revision identifiers, used by Alembic.
+revision = "2762a797f1f9"
+down_revision = "307edd8c639d"
+branch_labels = None
+depends_on = None
+
+from zou.app.models.person import POSITION_TYPES, SENIORITY_TYPES
+
+
+def upgrade():
+    with op.batch_alter_table("person", schema=None) as batch_op:
+        batch_op.add_column(
+            sa.Column(
+                "position",
+                sqlalchemy_utils.types.choice.ChoiceType(POSITION_TYPES),
+                nullable=True,
+            )
+        )
+        batch_op.add_column(
+            sa.Column(
+                "seniority",
+                sqlalchemy_utils.types.choice.ChoiceType(SENIORITY_TYPES),
+                nullable=True,
+            )
+        )
+        batch_op.add_column(
+            sa.Column("daily_salary", sa.Integer(), nullable=True)
+        )
+
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("person", schema=None) as batch_op:
+        batch_op.drop_column("daily_salary")
+        batch_op.drop_column("seniority")
+        batch_op.drop_column("position")
+    # ### end Alembic commands ###