zou 0.19.15__py3-none-any.whl → 0.20.11__py3-none-any.whl

zou/app/services/playlists_service.py

@@ -4,6 +4,7 @@ import orjson as json
 import os
 import zlib
 
+from flask import current_app
 from operator import itemgetter
 from pathlib import Path
 from shutil import copyfile
@@ -781,13 +782,13 @@ def remove_build_job(playlist, build_job_id):
     movie_file_path = get_playlist_movie_file_path(job.serialize())
     if os.path.exists(movie_file_path):
         os.remove(movie_file_path)
-    # stop removing files for now
-    # try:
-    #     file_store.remove_movie("playlists", build_job_id)
-    # except Exception:
-    #     current_app.logger.error(
-    #         "Playlist file can't be deleted: %s" % build_job_id
-    #     )
+    if config.REMOVE_FILES:
+        try:
+            file_store.remove_movie("playlists", build_job_id)
+        except Exception:
+            current_app.logger.error(
+                "Playlist file can't be deleted: %s" % build_job_id
+            )
     job.delete()
     events.emit(
         "build-job:delete",

zou/app/services/preview_files_service.py

@@ -4,6 +4,7 @@ import re
 import time
 
 import ffmpeg
+import shutil
 
 from sqlalchemy.orm import aliased
 from sqlalchemy.orm.exc import ObjectDeletedError
@@ -33,7 +34,7 @@ from zou.app.utils import (
     thumbnail as thumbnail_utils,
 )
 from zou.app.services.exception import (
-    ArgumentsException,
+    WrongParameterException,
     PreviewFileNotFoundException,
     ProjectNotFoundException,
     EpisodeNotFoundException,
@@ -88,7 +89,7 @@ def _is_valid_partial_resolution(resolution):
     return resolution is not None and bool(re.match(r"x\d{3,4}", resolution))
 
 
-def get_preview_file_fps(project):
+def get_preview_file_fps(project, entity=None):
     """
     Return fps set at project level or default fps if the dimensions are not
     set.
@@ -96,6 +97,12 @@ def get_preview_file_fps(project):
     fps = "25.00"
     if project.get("fps", None) is not None:
         fps = project["fps"].replace(",", ".")
+
+    if entity is not None:
+        entity_data = entity.get("data", {}) or {}
+        if entity_data.get("fps", None):
+            fps = str(entity_data["fps"]).replace(",", ".")
+
     return "%.3f" % float(fps)
 
 
@@ -162,7 +169,10 @@ def set_preview_file_as_ready(preview_file_id):
 
 
 def prepare_and_store_movie(
-    preview_file_id, uploaded_movie_path, normalize=True
+    preview_file_id,
+    uploaded_movie_path,
+    normalize=True,
+    add_source_to_file_store=True,
 ):
     """
     Prepare movie preview, normalize the movie as a .mp4, build the thumbnails
@@ -171,6 +181,10 @@ def prepare_and_store_movie(
     from zou.app import app as current_app
 
     with current_app.app_context():
+        if add_source_to_file_store:
+            file_store.add_movie(
+                "source", preview_file_id, uploaded_movie_path
+            )
         preview_file_raw = files_service.get_preview_file_raw(preview_file_id)
         normalized_movie_low_path = None
         try:
@@ -189,7 +203,7 @@ def prepare_and_store_movie(
                 preview_file = set_preview_file_as_broken(preview_file_id)
                 return preview_file
 
-        fps = get_preview_file_fps(project)
+        fps = get_preview_file_fps(project, entity)
         (width, height) = get_preview_file_dimensions(project, entity)
 
         if normalize:
@@ -199,9 +213,6 @@ def prepare_and_store_movie(
                     config.ENABLE_JOB_QUEUE_REMOTE
                     and len(config.JOB_QUEUE_NOMAD_NORMALIZE_JOB) > 0
                 ):
-                    file_store.add_movie(
-                        "source", preview_file_id, uploaded_movie_path
-                    )
                     result = _run_remote_normalize_movie(
                         current_app, preview_file_id, fps, width, height
                     )
@@ -556,7 +567,7 @@ def get_running_preview_files():
         result = preview_file.serialize()
         result["project_id"] = fields.serialize_value(project_id)
         result["task_type_id"] = fields.serialize_value(task_type_id)
-        (result["full_entity_name"], _) = names_service.get_full_entity_name(
+        result["full_entity_name"], _, _ = names_service.get_full_entity_name(
             entity_id
         )
         results.append(result)
@@ -614,7 +625,9 @@ def extract_frame_from_preview_file(preview_file, frame_number):
     else:
         raise PreviewFileNotFoundException
 
-    fps = get_preview_file_fps(project)
+    fps = get_preview_file_fps(
+        project, get_entity_from_preview_file(preview_file["id"])
+    )
     extracted_frame_path = movie.extract_frame_from_movie(
         preview_file_path, frame_number, fps
     )
@@ -645,7 +658,7 @@ def extract_tile_from_preview_file(preview_file):
         extracted_tile_path = movie.generate_tile(preview_file_path)
         return extracted_tile_path
     else:
-        return ArgumentsException("Preview file is not a movie")
+        raise WrongParameterException("Preview file is not a movie")
 
 
 def reset_movie_files_metadata():
@@ -940,3 +953,117 @@ def _reset_preview_file_metadata(
         print(
             f"Failed to store information for preview file {preview_file.id}: {e}.",
         )
+
+
+def copy_preview_file_on_storage(
+    get_path_func,
+    exists_func,
+    copy_func,
+    prefix,
+    original_preview_file_id,
+    preview_file_to_update_id,
+):
+    if config.FS_BACKEND == "local":
+        file_path = get_path_func(prefix, original_preview_file_id)
+        other_file_path = get_path_func(prefix, preview_file_to_update_id)
+        if os.path.exists(file_path):
+            os.makedirs(os.path.dirname(other_file_path), exist_ok=True)
+            shutil.copyfile(file_path, other_file_path)
+    elif exists_func(prefix, original_preview_file_id):
+        copy_func(
+            prefix, original_preview_file_id, prefix, preview_file_to_update_id
+        )
+
+
+def copy_preview_file_in_another_one(
+    original_preview_file_id, preview_file_to_update_id
+):
+    """
+    Copy preview file data/files from one preview file to another one.
+    """
+    original_preview_file = files_service.get_preview_file(
+        original_preview_file_id
+    )
+    is_movie = original_preview_file["extension"] == "mp4"
+    is_picture = original_preview_file["extension"] == "png"
+
+    if is_movie:
+        prefixes = ["previews", "lowdef"]
+        for prefix in prefixes:
+            copy_preview_file_on_storage(
+                file_store.get_local_movie_path,
+                file_store.exists_movie,
+                file_store.copy_movie,
+                prefix,
+                original_preview_file_id,
+                preview_file_to_update_id,
+            )
+
+    if is_movie or is_picture:
+        prefixes = [
+            "previews",
+            "original",
+            "thumbnails",
+            "thumbnails-square",
+        ]
+        if is_movie:
+            prefixes.append("tiles")
+
+        for prefix in prefixes:
+            copy_preview_file_on_storage(
+                file_store.get_local_picture_path,
+                file_store.exists_picture,
+                file_store.copy_picture,
+                prefix,
+                original_preview_file_id,
+                preview_file_to_update_id,
+            )
+    else:
+        copy_preview_file_on_storage(
+            file_store.get_local_file_path,
+            file_store.exists_file,
+            file_store.copy_file,
+            "previews",
+            original_preview_file_id,
+            preview_file_to_update_id,
+        )
+
+    preview_file_to_update = update_preview_file(
+        preview_file_to_update_id,
+        {
+            "extension": original_preview_file["extension"],
+            "original_name": original_preview_file["original_name"],
+            "status": original_preview_file["status"],
+            "file_size": original_preview_file["file_size"],
+            "width": original_preview_file["width"],
+            "height": original_preview_file["height"],
+            "duration": original_preview_file["duration"],
+        },
+    )
+    tasks_service.update_preview_file_info(preview_file_to_update)
+    comment = tasks_service.get_comment_by_preview_file_id(
+        preview_file_to_update_id
+    )
+    task = tasks_service.get_task(preview_file_to_update["task_id"])
+    comment_id = None
+    if comment is not None:
+        comment_id = comment["id"]
+        events.emit(
+            "comment:update",
+            {"comment_id": comment_id},
+            project_id=task["project_id"],
+        )
+        events.emit(
+            "preview-file:add-file",
+            {
+                "comment_id": comment_id,
+                "task_id": preview_file_to_update["task_id"],
+                "preview_file_id": preview_file_to_update["id"],
+                "revision": preview_file_to_update["revision"],
+                "extension": preview_file_to_update["extension"],
+                "status": preview_file_to_update["status"],
+            },
+            project_id=task["project_id"],
+        )
+
+    return preview_file_to_update

zou/app/services/projects_service.py

@@ -38,7 +38,7 @@ from sqlalchemy import or_
 
 def clear_project_cache(project_id):
     cache.cache.delete_memoized(get_project, project_id)
-    cache.cache.delete_memoized(get_project_with_relations, project_id)
+    cache.cache.delete_memoized(get_project, project_id, True)
     cache.cache.delete_memoized(get_project_by_name)
     cache.cache.delete_memoized(open_projects)
 
@@ -259,21 +259,12 @@ def get_project_raw(project_id):
 
 
 @cache.memoize_function(240)
-def get_project(project_id):
+def get_project(project_id, relations=False):
     """
     Get project matching given id, as a dict. Raises an exception if project is
     not found.
     """
-    return get_project_raw(project_id).serialize()
-
-
-@cache.memoize_function(240)
-def get_project_with_relations(project_id):
-    """
-    Get project matching given id, as a dict. Raises an exception if project is
-    not found.
-    """
-    return get_project_raw(project_id).serialize(relations=True)
+    return get_project_raw(project_id).serialize(relations=relations)
 
 
 @cache.memoize_function(120)
@@ -487,7 +478,7 @@ def add_metadata_descriptor(
             field_name=slugify.slugify(name, separator="_"),
         )
     except Exception:
-        raise WrongParameterException
+        raise WrongParameterException("Metadata descriptor already exists.")
     events.emit(
         "metadata-descriptor:new",
         {"metadata_descriptor_id": str(descriptor.id)},
@@ -687,7 +678,7 @@ def get_project_fps(project_id):
     Return fps set at project level or default fps if it not set.
     """
     project = get_project(project_id)
-    return float(project["fps"] or "24.00")
+    return float(project["fps"] or "25.00")
 
 
 def get_task_type_priority_map(project_id, for_entity="Asset"):