libreflow.extensions.sk.export-psd-layers 1.0.0__tar.gz → 1.1.0__tar.gz

libreflow_extensions_sk_export_psd_layers-1.1.0/CHANGELOG.md

@@ -0,0 +1,54 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html)[^1].
+
+<!---
+Types of changes
+
+- Added for new features.
+- Changed for changes in existing functionality.
+- Deprecated for soon-to-be removed features.
+- Removed for now removed features.
+- Fixed for any bug fixes.
+- Security in case of vulnerabilities.
+
+-->
+
+## [Unreleased]
+
+## [1.1.0] - 2025-04-24
+
+### Added
+
+* An action to export a psd for preview
+  * Use the `psd-tools` python module
+  * Three PNGs, one in full format, one with no characters and one without a safety margin
+    * These files are not tracked in Libreflow, they remain local
+  * A specific upload to kitsu action is available for this use case
+* An action to publish and export at the same time
+* An action to export layers in batch
+  * Available at a film hierarchy level
+
+### Changed
+
+* Export layers action now uses `psd-tools` python module instead of a Adobe extend script
+    * Process can takes longer, but Photoshop is no longer required
+
+### Fixed
+
+* Hide export layers action when file has no published revisions
+
+## [1.0.1] - 2025-04-04
+
+### Fixed
+
+* including .jsx files in setup.py
+
+## [1.0.0] - 2025-03-27
+
+### Added
+
+* Extension to export the layers of a Photoshop project as png images 

{libreflow_extensions_sk_export_psd_layers-1.0.0/src/libreflow.extensions.sk.export_psd_layers.egg-info → libreflow_extensions_sk_export_psd_layers-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: libreflow.extensions.sk.export_psd_layers
-Version: 1.0.0
+Version: 1.1.0
 Home-page: https://gitlab.com/lfs.coop/libreflow/libreflow_launcher
 Author: Thomas Thiebaut
 Author-email: autor@les-fees-speciales.coop
@@ -12,6 +12,7 @@ Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 or l
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
+Requires-Dist: psd-tools
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -20,6 +21,7 @@ Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: keywords
 Dynamic: license
+Dynamic: requires-dist
 Dynamic: requires-python
 
 # Sk Export Psd Layers
@@ -48,6 +50,34 @@ Types of changes
 
 ## [Unreleased]
 
+## [1.1.0] - 2025-04-24
+
+### Added
+
+* An action to export a psd for preview
+  * Use the `psd-tools` python module
+  * Three PNGs, one in full format, one with no characters and one without a safety margin
+    * These files are not tracked in Libreflow, they remain local
+  * A specific upload to kitsu action is available for this use case
+* An action to publish and export at the same time
+* An action to export layers in batch
+  * Available at a film hierarchy level
+
+### Changed
+
+* Export layers action now uses `psd-tools` python module instead of a Adobe extend script
+    * Process can takes longer, but Photoshop is no longer required
+
+### Fixed
+
+* Hide export layers action when file has no published revisions
+
+## [1.0.1] - 2025-04-04
+
+### Fixed
+
+* including .jsx files in setup.py
+
 ## [1.0.0] - 2025-03-27
 
 ### Added

{libreflow_extensions_sk_export_psd_layers-1.0.0 → libreflow_extensions_sk_export_psd_layers-1.1.0}/setup.py

@@ -2,19 +2,18 @@ import setuptools
 import versioneer
 import os
 
-readme = os.path.normpath(os.path.join(__file__, '..', 'README.md'))
+readme = os.path.normpath(os.path.join(__file__, "..", "README.md"))
 with open(readme, "r", encoding="utf-8") as fh:
     long_description = fh.read()
 
-long_description += '\n\n'
+long_description += "\n\n"
 
-changelog = os.path.normpath(os.path.join(__file__, '..', 'CHANGELOG.md'))
+changelog = os.path.normpath(os.path.join(__file__, "..", "CHANGELOG.md"))
 with open(changelog, "r", encoding="utf-8") as fh:
     long_description += fh.read()
 
 
 setuptools.setup(
-    
     name="libreflow.extensions.sk.export_psd_layers",
     version=versioneer.get_version(),
     cmdclass=versioneer.get_cmdclass(),
@@ -32,15 +31,11 @@ setuptools.setup(
         "Operating System :: OS Independent",
     ],
     keywords="kabaret libreflow",
-    install_requires=[],
-    python_requires='>=3.7',
+    install_requires=["psd-tools"],
+    python_requires=">=3.7",
     packages=setuptools.find_packages("src"),
     package_dir={"": "src"},
     package_data={
-        '': [
-            "*.css",
-            '*.png'
-        ],
+        "": ["*.css", "*.png", "*.jsx"],
     },
-
 )

libreflow_extensions_sk_export_psd_layers-1.1.0/src/libreflow/extensions/sk/export_psd_layers/__init__.py

@@ -0,0 +1,598 @@
+import os
+import json
+import gazu
+import time
+
+from kabaret import flow
+from libreflow.flows.default.flow.film import Film
+from libreflow.baseflow.file import (
+    GenericRunAction,
+    TrackedFile,
+    FileRevisionNameChoiceValue,
+    UploadPNGToKitsu,
+    PublishAndRenderPlayblast,
+)
+from psd_tools import PSDImage
+
+
+class ExportPSDLayers(flow.Action):
+    ICON = ("icons.flow", "photoshop")
+
+    _file = flow.Parent()
+    _files = flow.Parent(2)
+    _shot = flow.Parent(5)
+    _sequence = flow.Parent(7)
+
+    revision = flow.Param(None, FileRevisionNameChoiceValue)
+
+    def allow_context(self, context):
+        return (
+            context
+            and self._file.format.get() in ["psd", "psb"]
+            and len(
+                self._file.get_revision_names(
+                    sync_status="Available", published_only=True
+                )
+            ) > 0
+        )
+
+    def needs_dialog(self):
+        return True
+
+    def get_buttons(self):
+        self.revision.revert_to_default()
+        return ["Export", "Cancel"]
+
+    def ensure_render_folder(self):
+        folder_name = self._file.complete_name.get()
+        folder_name += "_render"
+
+        if not self._files.has_folder(folder_name):
+            self._files.create_folder_action.folder_name.set(folder_name)
+            self._files.create_folder_action.category.set("Outputs")
+            self._files.create_folder_action.tracked.set(True)
+            self._files.create_folder_action.run(None)
+
+        return self._files[folder_name]
+
+    def ensure_render_folder_revision(self):
+        folder = self.ensure_render_folder()
+        revision_name = self.revision.get()
+        source_revision = self._file.get_revision(self.revision.get())
+
+        if not folder.has_revision(revision_name):
+            revision = folder.add_revision(revision_name)
+            folder.set_current_user_on_revision(revision_name)
+        else:
+            revision = folder.get_revision(revision_name)
+
+        revision.comment.set(source_revision.comment.get())
+
+        folder.ensure_last_revision_oid()
+
+        self._files.touch()
+
+        return revision
+
+    def run(self, button):
+        if button == "Cancel":
+            return
+        
+        session = self.root().session()
+        log_format = "[EXPORT LAYERS] {message}"
+
+        # Start log message
+        session.log_info(
+            log_format.format(
+                message=f"Export started - {self._sequence.name()} {self._shot.name()} {self._file.name()} {self.revision.get()}"
+            )
+        )
+
+        # Get revisions
+        source_revision = self._file.get_revision(self.revision.get())
+        render_revision = self.ensure_render_folder_revision()
+
+        # Open photoshop file
+        psb = PSDImage.open(source_revision.get_path())
+
+        # JSON structure for layers order
+        layers_data = {
+            "from": os.path.basename(source_revision.get_path()),
+            "layers": [],
+            "hidden_layers": []
+        }
+
+        # Export image layers
+        folder_name = os.path.basename(render_revision.get_path())
+
+        for layer in reversed(psb):
+            output_path = os.path.join(
+                render_revision.get_path(),
+                "{folder}-{layer}.png".format(folder=folder_name, layer=layer.name),
+            )
+
+            session.log_info(log_format.format(message=f'Exporting layer {layer.name}'))
+
+            image = layer.composite(viewport=psb.bbox)
+            image.save(output_path)
+
+            # Push layer in correct JSON data
+            layers_data["layers" if layer.visible else "hidden_layers"].append(
+                layer.name
+            )
+        
+        # Export JSON data
+        json_object = json.dumps(layers_data)
+        json_path = os.path.join(render_revision.get_path(), "layers.json")
+        
+        session.log_info(log_format.format(message='Saving layers.json'))
+        with open(json_path, "w") as outfile:
+            outfile.write(json_object)
+        
+        session.log_info(log_format.format(message='Export complete'))
+
+        return self.get_result(close=True)
+
+
+class SequencesSelectAll(flow.values.SessionValue):
+    DEFAULT_EDITOR = "bool"
+
+    _action = flow.Parent()
+
+    def _fill_ui(self, ui):
+        super(SequencesSelectAll, self)._fill_ui(ui)
+        if self._action.sequences.choices() == []:
+            ui["hidden"] = True
+
+
+class SequencesMultiChoiceValue(flow.values.SessionValue):
+    DEFAULT_EDITOR = "multichoice"
+
+    _action = flow.Parent()
+
+    def choices(self):
+        return self._action._film.sequences.mapped_names()
+
+    def revert_to_default(self):
+        self.choices()
+        self.set([])
+
+
+class TaskChoiceValue(flow.values.SessionValue):
+    DEFAULT_EDITOR = "choice"
+
+    _action = flow.Parent()
+
+    def choices(self):
+        return ['Any', 'BG_Layout', 'BG_Color']
+
+
+class ExportPSDLayersBatch(flow.Action):
+    ICON = ("icons.flow", "photoshop")
+
+    select_all = (
+        flow.SessionParam(False, SequencesSelectAll).ui(editor="bool").watched()
+    )
+    sequences = flow.SessionParam([], SequencesMultiChoiceValue)
+    task_target = flow.SessionParam("Any", TaskChoiceValue)
+
+    _film = flow.Parent()
+
+    def allow_context(self, context):
+        user = self.root().project().get_user()
+        return user.status.get() == "Admin"
+
+    def get_buttons(self):
+        return ["Export", "Close"]
+
+    def needs_dialog(self):
+        self.message.set("<h2>Batch Export Layers</h2>")
+        return True
+
+    def child_value_changed(self, child_value):
+        if child_value is self.select_all:
+            if child_value.get():
+                self.sequences.set(self.sequences.choices())
+            else:
+                self.sequences.revert_to_default()
+
+    def run(self, button):
+        if button == "Close":
+            return
+        
+        session = self.root().session()
+        log_format = "[BATCH EXPORT LAYERS] {status} - {sequence} {shot} {file} {revision}"
+
+        for seq_name in self.sequences.get():
+            seq = self._film.sequences[seq_name]
+            for shot in seq.shots.mapped_items():
+                for task in shot.tasks.mapped_items():
+                    # Ignore if specific task parameter is used
+                    if (
+                        self.task_target.get() != "Any"
+                        and task.name() != self.task_target.get().lower()
+                    ):
+                        continue
+                    for f in task.files.mapped_items():
+                        # Get only photoshop files
+                        if (
+                            f.format.get() in ["psd", "psb"]
+                            and len(
+                                f.get_revision_names(
+                                    sync_status="Available", published_only=True
+                                )
+                            ) > 0
+                        ):
+                            # Check if revision is already exported
+                            if task.files.has_folder(f'{task.name()}_render'):
+                                render_folder = task.files[f'{task.name()}_render']
+                                render_revision = render_folder.get_head_revision(sync_status="Available")
+                                if render_revision and os.path.exists(render_revision.get_path()):
+                                    session.log_warning(
+                                        log_format.format(
+                                            status="Already exported",
+                                            sequence=seq.name(),
+                                            shot=shot.name(),
+                                            file=f.display_name.get(),
+                                            revision=render_revision.name()
+                                        )
+                                    )
+                                    continue
+                            
+                            # Start export base action
+                            f.export_layers.revision.revert_to_default()
+                            f.export_layers.run("Export")
+
+                            # Wait for base action to finish
+                            for sp in (
+                                self.root()
+                                .session()
+                                .cmds.SubprocessManager.list_runner_infos()
+                            ):
+                                if sp["is_running"] and sp["label"] == "Export Layers":
+                                    while sp["is_running"]:
+                                        time.sleep(1)
+                                        sp = (
+                                            self.root()
+                                            .session()
+                                            .cmds.SubprocessManager.get_runner_info(
+                                                sp["id"]
+                                            )
+                                        )
+                                    break
+                                    
+                            # Upload render to exchange
+                            render_folder = f.export_layers.ensure_render_folder()
+                            render_revision = render_folder.get_head_revision(sync_status="Available")
+
+                            if render_revision:
+                                render_revision.upload.run('Upload')
+        
+        session.log_info('[BATCH EXPORT LAYERS] Batch complete')
+
+
+class PublishandExportPSD(PublishAndRenderPlayblast):
+    ICON = ('icons.libreflow', 'publish')
+
+    def allow_context(self, context):
+        return (
+            context
+            and super(PublishandExportPSD, self).allow_context(context)
+            and self._file.format.get() in ["psd", "psb"]
+        )
+
+    def get_buttons(self):
+        return ["Publish and Export Preview", "Cancel"]
+
+    def _configure_and_render(self, revision_name, upload_after_publish):
+        export_preview = self._file.export_preview
+        export_preview.revision.set(revision_name)
+        export_preview.upload_to_kitsu.set(upload_after_publish)
+
+        return export_preview.run("Export")
+
+    def run(self, button):
+        if button == "Cancel":
+            return
+
+        project_settings = self.root().project().settings()
+        if (
+            self.comment.get() == ""
+            and not project_settings.optional_publish_comment.get()
+        ):
+            self.message.set(
+                "<h2>Publish</h2>Please enter a comment to describe your changes."
+            )
+            return self.get_result(close=False)
+
+        # Update parameter presets
+        self.update_presets()
+
+        # Publish
+        publish_action = self._file.publish_action
+        publish_action.publish_file(
+            self._file,
+            comment=self.comment.get(),
+            keep_editing=self.keep_editing.get(),
+            upload_after_publish=False,
+        )
+
+        # Playblast
+        ret = self._configure_and_render(
+            self._file.get_head_revision().name(), self.upload_after_publish.get()
+        )
+
+        return ret
+
+
+class ExportPSDPreview(flow.Action):
+    ICON = ("icons.flow", "photoshop")
+
+    revision = flow.Param(None, FileRevisionNameChoiceValue)
+    upload_to_kitsu = flow.BoolParam(False)
+
+    _file = flow.Parent()
+    _shot = flow.Parent(5)
+    _sequence = flow.Parent(7)
+
+    def allow_context(self, context):
+        return (
+            context
+            and self._file.format.get() in ["psd", "psb"]
+            and len(
+                self._file.get_revision_names(
+                    sync_status="Available", published_only=True
+                )
+            ) > 0
+        )
+
+    def needs_dialog(self):
+        self.revision.revert_to_default()
+        return True
+
+    def get_buttons(self):
+        return ["Export", "Cancel"]
+
+    def get_target_path(self):
+        rev = self._file.get_revision(self.revision.get())
+        return rev.get_path()
+
+    def export_full(self, psb, file_path):
+        self.root().session().log_info("Exporting full project")
+
+        output_path = f"{os.path.splitext(file_path)[0]}.png"
+
+        image = psb.composite()
+        image.save(output_path)
+
+        return output_path
+
+    def export_no_chara(self, psb, file_path):
+        self.root().session().log_info("Exporting project without characters")
+
+        output_path = f"{os.path.splitext(file_path)[0]}_no_chara.png"
+
+        image = psb.composite(
+            layer_filter=lambda layer: layer.is_visible()
+            and "character" not in layer.name
+            and "INFO" not in layer.name
+            and "REF" not in layer.name
+        )
+
+        image.save(output_path)
+
+        return output_path
+
+    def export_cropped(self, psb, file_path):
+        self.root().session().log_info("Exporting project in film format")
+
+        output_path = f"{os.path.splitext(file_path)[0]}_no_safety.png"
+
+        frame_bbox = (0, 0, 0, 0)
+
+        frame_layer = psb.find("FRAME 4096x1716")
+
+        if frame_layer is None:
+            raise Exception("FRAME LAYER NOT FOUND")
+        else:
+            frame_bbox = frame_layer.bbox
+
+            if frame_bbox == (0, 0, 0, 0):
+                raise Exception("Frame Layer has no bounding box")
+
+            # Substract by 10pixels (width and height) in order to remove border margin
+            frame_bbox = (
+                frame_bbox[0] + 5,
+                frame_bbox[1] + 5,
+                frame_bbox[2] - 5,
+                frame_bbox[3] - 5,
+            )
+
+        image = psb.composite()
+        image = image.crop(frame_bbox)
+        image.save(output_path)
+
+        return output_path
+
+    def run(self, button):
+        if button == "Cancel":
+            return
+
+        path = self.get_target_path()
+        psb = PSDImage.open(path)
+
+        full_img_path = self.export_full(psb, path)
+        no_chara_img_path = self.export_no_chara(psb, path)
+        cropped_img_path = self.export_cropped(psb, path)
+
+        if self.upload_to_kitsu.get():
+            self._file.upload_preview.full_img_path.set(full_img_path)
+            self._file.upload_preview.no_chara_img_path.set(no_chara_img_path)
+            self._file.upload_preview.cropped_img_path.set(cropped_img_path)
+            self._file.upload_preview.revision_name.set(self.revision.get())
+            return self.get_result(next_action=self._file.upload_preview.oid())
+
+
+class UploadPSDPreview(UploadPNGToKitsu):
+    _file = flow.Parent()
+
+    full_img_path = flow.Param("").ui(hidden=True)
+    no_chara_img_path = flow.Param("").ui(hidden=True)
+    cropped_img_path = flow.Param("").ui(hidden=True)
+
+    def allow_context(self, context):
+        return context and context.endswith(".details")
+
+    def upload_preview(
+        self,
+        kitsu_entity,
+        task_type_name,
+        task_status_name,
+        path_list,
+        comment="",
+        user_name=None,
+    ):
+        kitsu_api = self.root().project().kitsu_api()
+
+        # Get user
+        user = kitsu_api.get_user(user_name)
+
+        # Get task
+        task = kitsu_api.get_task(kitsu_entity, task_type_name)
+
+        if task is None or user is None:
+            return False
+
+        # Add comment with preview
+
+        # Check if preview file exists
+        for file_path in path_list:
+            if not os.path.exists(file_path):
+                self.root().session().log_error(
+                    f"Preview file '{file_path}' does not exists."
+                )
+                return False
+
+        task_status = gazu.task.get_task_status_by_name(task_status_name)
+
+        # Check if status is valid
+        if task_status is None:
+            task_statuses = gazu.task.all_task_statuses()
+            names = [ts["name"] for ts in task_statuses]
+            self.root().session().log_error(
+                (
+                    f"Invalid task status '{task_status_name}'."
+                    "Should be one of " + str(names) + "."
+                )
+            )
+            return False
+
+        comment = gazu.task.add_comment(task, task_status, comment=comment)
+
+        for file_path in path_list:
+            try:
+                gazu.task.add_preview(task, comment, file_path)
+            except json.decoder.JSONDecodeError:
+                self.root().session().log_warning(
+                    f"Invalid response from Gazu while uploading preview {file_path}"
+                )
+
+        return True
+
+    def run(self, button):
+        if button == "Cancel":
+            return
+
+        self.update_presets()
+
+        if not self._check_kitsu_params():
+            self.root().session().log_error("KITSU PARAM ERROR")
+            return self.get_result(close=False)
+
+        kitsu_api = self.root().project().kitsu_api()
+        kitsu_entity = self._ensure_kitsu_entity()
+
+        if kitsu_entity is None:
+            self.root().session().log_error(
+                "No Kitsu entity for file " + self._file.oid()
+            )
+            return self.get_result(close=False)
+
+        task_status_data = kitsu_api.get_task_status(
+            short_name=self.target_task_status.names_dict[self.target_task_status.get()]
+        )
+
+        success = self.upload_preview(
+            kitsu_entity=kitsu_entity,
+            task_type_name=self.target_task_type.get(),
+            task_status_name=task_status_data["name"],
+            path_list=[
+                self.full_img_path.get(),
+                self.no_chara_img_path.get(),
+                self.cropped_img_path.get(),
+            ],
+            comment=self.comment.get(),
+        )
+
+        if not success:
+            self.message.set(
+                (
+                    "<h2>Upload playblast to Kitsu</h2>"
+                    "<font color=#FF584D>An error occured "
+                    "while uploading the preview.</font>"
+                )
+            )
+            return self.get_result(close=False)
+
+        rev = self._file.get_revision(self.revision_name.get())
+        rev.set_status("on_kitsu")
+
+
+def publish_and_export_preview(parent):
+    if isinstance(parent, TrackedFile):
+        r = flow.Child(PublishandExportPSD)
+        r.name = "publish_and_export_preview"
+        r.index = 26
+        return r
+
+
+def upload_preview(parent):
+    if isinstance(parent, TrackedFile):
+        r = flow.Child(UploadPSDPreview)
+        r.name = "upload_preview"
+        return r
+
+
+def export_psd_layers(parent):
+    if isinstance(parent, TrackedFile):
+        r = flow.Child(ExportPSDLayers)
+        r.name = "export_layers"
+        r.index = 50
+        return r
+
+    if isinstance(parent, Film):
+        r = flow.Child(ExportPSDLayersBatch).ui(
+            label="Batch Export Layers", dialog_size=(750, 800)
+        )
+        r.name = "export_layers_batch"
+        r.index = None
+        return r
+
+
+def export_psd_preview(parent):
+    if isinstance(parent, TrackedFile):
+        r = flow.Child(ExportPSDPreview)
+        r.name = "export_preview"
+        r.index = 49
+        return r
+
+
+def install_extensions(session):
+    return {
+        "export_psd_layers": [
+            export_psd_layers,
+            export_psd_preview,
+            upload_preview,
+            publish_and_export_preview,
+        ]
+    }

{libreflow_extensions_sk_export_psd_layers-1.0.0 → libreflow_extensions_sk_export_psd_layers-1.1.0}/src/libreflow/extensions/sk/export_psd_layers/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-03-27T12:06:44+0100",
+ "date": "2025-04-24T19:49:41+0200",
  "dirty": false,
  "error": null,
- "full-revisionid": "14117b39d39bffa801addc037065b58ad52037c8",
- "version": "1.0.0"
+ "full-revisionid": "29231b33e0e266c52c6065cb665d5fbbaf827fdf",
+ "version": "1.1.0"
 }
 '''  # END VERSION_JSON
 

{libreflow_extensions_sk_export_psd_layers-1.0.0 → libreflow_extensions_sk_export_psd_layers-1.1.0/src/libreflow.extensions.sk.export_psd_layers.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: libreflow.extensions.sk.export_psd_layers
-Version: 1.0.0
+Version: 1.1.0
 Home-page: https://gitlab.com/lfs.coop/libreflow/libreflow_launcher
 Author: Thomas Thiebaut
 Author-email: autor@les-fees-speciales.coop
@@ -12,6 +12,7 @@ Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 or l
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
+Requires-Dist: psd-tools
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -20,6 +21,7 @@ Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: keywords
 Dynamic: license
+Dynamic: requires-dist
 Dynamic: requires-python
 
 # Sk Export Psd Layers
@@ -48,6 +50,34 @@ Types of changes
 
 ## [Unreleased]
 
+## [1.1.0] - 2025-04-24
+
+### Added
+
+* An action to export a psd for preview
+  * Use the `psd-tools` python module
+  * Three PNGs, one in full format, one with no characters and one without a safety margin
+    * These files are not tracked in Libreflow, they remain local
+  * A specific upload to kitsu action is available for this use case
+* An action to publish and export at the same time
+* An action to export layers in batch
+  * Available at a film hierarchy level
+
+### Changed
+
+* Export layers action now uses `psd-tools` python module instead of a Adobe extend script
+    * Process can takes longer, but Photoshop is no longer required
+
+### Fixed
+
+* Hide export layers action when file has no published revisions
+
+## [1.0.1] - 2025-04-04
+
+### Fixed
+
+* including .jsx files in setup.py
+
 ## [1.0.0] - 2025-03-27
 
 ### Added

{libreflow_extensions_sk_export_psd_layers-1.0.0 → libreflow_extensions_sk_export_psd_layers-1.1.0}/src/libreflow.extensions.sk.export_psd_layers.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ src/libreflow/__init__.py
 src/libreflow.extensions.sk.export_psd_layers.egg-info/PKG-INFO
 src/libreflow.extensions.sk.export_psd_layers.egg-info/SOURCES.txt
 src/libreflow.extensions.sk.export_psd_layers.egg-info/dependency_links.txt
+src/libreflow.extensions.sk.export_psd_layers.egg-info/requires.txt
 src/libreflow.extensions.sk.export_psd_layers.egg-info/top_level.txt
 src/libreflow/extensions/__init__.py
 src/libreflow/extensions/sk/__init__.py

libreflow_extensions_sk_export_psd_layers-1.1.0/src/libreflow.extensions.sk.export_psd_layers.egg-info/requires.txt

@@ -0,0 +1 @@
+psd-tools

libreflow_extensions_sk_export_psd_layers-1.0.0/CHANGELOG.md

@@ -1,26 +0,0 @@
-# Changelog
-
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html)[^1].
-
-<!---
-Types of changes
-
-- Added for new features.
-- Changed for changes in existing functionality.
-- Deprecated for soon-to-be removed features.
-- Removed for now removed features.
-- Fixed for any bug fixes.
-- Security in case of vulnerabilities.
-
--->
-
-## [Unreleased]
-
-## [1.0.0] - 2025-03-27
-
-### Added
-
-* Extension to export the layers of a Photoshop project as png images 

libreflow_extensions_sk_export_psd_layers-1.0.0/src/libreflow/extensions/sk/export_psd_layers/__init__.py

@@ -1,125 +0,0 @@
-import os
-
-from kabaret import flow
-from kabaret.flow.object import _Manager
-
-from libreflow.baseflow.file import GenericRunAction,TrackedFile,TrackedFolder,FileRevisionNameChoiceValue
-
-class ExportPSDLayers(GenericRunAction):
-    _MANAGER_TYPE = _Manager
-
-    ICON = ('icons.flow', 'photoshop')
-
-    _file = flow.Parent()
-    _files = flow.Parent(2)
-    _task = flow.Parent(3)
-    _shot = flow.Parent(5)
-    _sequence = flow.Parent(7)
-
-    revision = flow.Param(None, FileRevisionNameChoiceValue)
-
-    exec_path = ""
-
-    def allow_context(self, context):
-        return (
-            context
-            and self._file.format.get() in ['psd', 'psb']
-            )
-
-    def needs_dialog(self):
-        return True
-
-    def get_buttons(self):
-        self.revision.revert_to_default()
-
-        msg = ""
-
-        site_env = self.root().project().get_current_site().site_environment
-        if site_env.has_mapped_name('PHOTOSHOP_EXEC_PATH'):
-            self.exec_path = site_env['PHOTOSHOP_EXEC_PATH'].value.get()
-            self.message.set(msg)
-            return ['Export','Cancel']
-
-        else :
-            msg = "<font color = red><b>Photoshop executable not found in site environment</b></font>"
-            self.message.set(msg)
-            return ['Cancel']
-    
-    def ensure_render_folder(self):
-        folder_name = self._file.display_name.get().split('.')[0]
-        folder_name += '_render'
-
-        if not self._files.has_folder(folder_name):
-            self._files.create_folder_action.folder_name.set(folder_name)
-            self._files.create_folder_action.category.set('Outputs')
-            self._files.create_folder_action.tracked.set(True)
-            self._files.create_folder_action.run(None)
-        
-        return self._files[folder_name]
-    
-    def ensure_render_folder_revision(self):
-        folder = self.ensure_render_folder()
-        revision_name = self.revision.get()
-        revisions = folder.get_revisions()
-        source_revision = self._file.get_revision(self.revision.get())
-        
-        if not folder.has_revision(revision_name):
-            revision = folder.add_revision(revision_name)
-            folder.set_current_user_on_revision(revision_name)
-        else:
-            revision = folder.get_revision(revision_name)
-        
-        revision.comment.set(source_revision.comment.get())
-        
-        folder.ensure_last_revision_oid()
-        
-        self._files.touch()
-        
-        return revision
-    
-    def runner_name_and_tags(self):
-        return 'Photoshop', []
-    
-    def get_run_label(self):
-        return 'Export Layers'
-
-    def target_file_extension(self):
-        if self._file.format.get() == 'psb':
-            return 'psb'
-        elif self._file.format.get() == 'psd':
-            return 'psd'
-
-    def extra_argv(self):
-        rev = self._file.get_revision(self.revision.get())
-        current_dir = os.path.split(__file__)[0]
-        script_path = os.path.normpath(os.path.join(current_dir,"scripts/LFS_PSD_export_to_PNG.jsx"))
-
-        return [rev.get_path(),script_path]
-    
-    def run(self, button):
-        if button == 'Cancel':
-            return
-
-        folder_path = self.ensure_render_folder_revision().get_path()
-
-        super(ExportPSDLayers, self).run(button)
-        return self.get_result(close=True)
-
-
-def export_psd_layers(parent):
-    if isinstance(parent, TrackedFile):
-        r = flow.Child(ExportPSDLayers)
-        r.name = 'export_layers'
-        return r
-
-
-def install_extensions(session):
-    return {
-        "export_psd_layers": [
-            export_psd_layers,
-        ]
-    }
-
-
-from . import _version
-__version__ = _version.get_versions()['version']