pyluxcoretools: big refactoring

- replace PySide by tkinter (bundled in Python)
- add __main__ everywhere it was lacking
- add __init__ everywhere it was lacking
- remove redundant prefixes 'pyluxcore...' in submodule names
- lint (pylint)
- move to `python` folder, along with other Python modules
- declare pyluxcoretools submodules as scripts in the wheel

Author: howetuft

CMakeLists.txt

@@ -305,7 +305,6 @@ add_subdirectory(src/luxrays)
 add_subdirectory(src/slg)
 add_subdirectory(src/luxcore)
 add_subdirectory(src/pyluxcore)
-add_subdirectory(src/pyluxcoretools)
 
 ################################################################################
 #

pyproject.toml

@@ -46,14 +46,24 @@ GitHub = "https://github.com/LuxCoreRender/LuxCore"
 
 [project.scripts]
 pyluxcoretest = "pyluxcoretest:main"
+pyluxcore-console = "pyluxcoretools.console.cmd:main"
+pyluxcore-maketx = "pyluxcoretools.maketx.cmd:main"
+pyluxcore-merge = "pyluxcoretools.merge.cmd:main"
+pyluxcore-netmenu = "pyluxcoretools.netmenu.cmd:main"
+pyluxcore-netconsole = "pyluxcoretools.netconsole.cmd:main"
+pyluxcore-netnode = "pyluxcoretools.netnode.cmd:main"
+
+[project.gui-scripts]
+pyluxcore-netconsole-ui = "pyluxcoretools.netconsole.ui:main"
+pyluxcore-netnode-ui = "pyluxcoretools.netnode.ui:main"
 
 [tool.scikit-build]
 logging.level = "DEBUG"
 build.verbose = true
 cmake.source-dir = "."
 build.targets = ["pyluxcore"]
 wheel.cmake = true
-wheel.packages = ["python/pyluxcore", "python/pyluxcoretest"]
+wheel.packages = ["python/pyluxcore", "python/pyluxcoretest", "python/pyluxcoretools"]
 build-dir = "out"
 ninja.make-fallback = false
 install.components = ["pyluxcore"]

python/pyluxcoretools/__init__.py

@@ -0,0 +1,17 @@
+###############################################################################
+# Copyright 1998-2025 by authors (see AUTHORS.txt)
+#
+#   This file is part of LuxCoreRender.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+###############################################################################

python/pyluxcoretools/_renderfarm/__init__.py

@@ -0,0 +1,20 @@
+###############################################################################
+# Copyright 1998-2025 by authors (see AUTHORS.txt)
+#
+#   This file is part of LuxCoreRender.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+###############################################################################
+
+from .renderfarm import DEFAULT_PORT, RenderFarm, NodeDiscoveryType
+from .node import RenderFarmNode

python/pyluxcoretools/_renderfarm/filmmerger.py

@@ -0,0 +1,220 @@
+###############################################################################
+# Copyright 1998-2025 by authors (see AUTHORS.txt)
+#
+#   This file is part of LuxCoreRender.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+###############################################################################
+
+import os
+import time
+import logging
+import threading
+import functools
+
+import pyluxcore
+from .._utils import loghandler
+
+logger = logging.getLogger(loghandler.loggerName + "._renderfarm")
+
+
+class RenderFarmFilmMerger:
+    def __init__(self, renderFarmJob):
+        self.renderFarmJob = renderFarmJob
+        self.filmMergeThread = None
+        self.filmMergeThreadEvent = threading.Event()
+        self.previousFilmSampleCount = 0
+        self.filmMergeThreadEventForceFilmMerge = None
+        self.filmMergeThreadEventForceFilmMergePeriod = None
+        self.filmMergeThreadEventStop = None
+
+    # -------------------------------------------------------------------------
+    # Start/Stop the work
+    # -------------------------------------------------------------------------
+
+    def Start(self):
+        # Start the film merge thread
+        self.filmMergeThread = threading.Thread(
+            target=functools.partial(
+                RenderFarmFilmMerger.__FilmMergeThread, self
+            )
+        )
+        self.filmMergeThread.name = "FilmMergeThread"
+
+        self.filmMergeThreadEvent.clear()
+        self.filmMergeThreadEventStop = False
+        self.filmMergeThreadEventForceFilmMerge = False
+        self.filmMergeThreadEventForceFilmMergePeriod = False
+
+        self.filmMergeThread.start()
+
+    def Stop(self):
+        # Stop the merge film thread
+        self.filmMergeThreadEventStop = True
+        self.filmMergeThreadEvent.set()
+        self.filmMergeThread.join()
+
+    def ForceFilmMerge(self):
+        self.filmMergeThreadEventForceFilmMerge = True
+        self.filmMergeThreadEvent.set()
+
+    def ForceFilmMergePeriod(self):
+        self.filmMergeThreadEventForceFilmMergePeriod = True
+        self.filmMergeThreadEvent.set()
+
+    # -----------------------------------------------------------------------
+    # Film merge related methods
+    # -----------------------------------------------------------------------
+
+    def MergeAllFilms(self):
+        # Merge all NodeThreadFilms
+        film = None
+
+        # Check if I have a previous film to use
+        if self.renderFarmJob.previousFilmFileName:
+            logger.info(
+                "Loaded previous film: %s",
+                self.renderFarmJob.previousFilmFileName,
+            )
+            film = pyluxcore.Film(self.renderFarmJob.previousFilmFileName)
+
+            stats = film.GetStats()
+            self.previousFilmSampleCount = stats.Get(
+                "stats.film.total.samplecount"
+            ).GetFloat()
+        else:
+            self.previousFilmSampleCount = 0
+            logger.info("No previous film to load")
+
+        # Get a copy of nodeThreads in order to be thread safe
+        nodeThreadsCopy = self.renderFarmJob.GetNodeThreadsList()
+
+        logger.info("Number of films to merge: %s", str(len(nodeThreadsCopy)))
+        for nodeThread in nodeThreadsCopy:
+            with nodeThread.lock:
+                filmThreadFileName = nodeThread.GetNodeFilmFileName()
+                # Check if the file exist
+                if not os.path.isfile(filmThreadFileName):
+                    logger.info(
+                        "Film file not yet available: %s (%s)",
+                        nodeThread.thread.nam,
+                        filmThreadFileName,
+                    )
+                    continue
+
+                logger.info(
+                    "Merging film: %s (%s)",
+                    nodeThread.thread.name,
+                    filmThreadFileName,
+                )
+                if filmThread := pyluxcore.Film(filmThreadFileName):
+                    stats = filmThread.GetStats()
+                    spp = stats.Get("stats.film.spp").GetFloat()
+                    logger.info("  Samples per pixel: %.1f", spp)
+
+                if film:
+                    # Merge the film
+                    film.AddFilm(filmThread)
+                else:
+                    # Read the first film
+                    film = filmThread
+
+        return film
+
+    def SaveMergedFilm(self, film):
+        # Save the merged film
+        filmName = self.renderFarmJob.GetFilmFileName()
+        logger.info("Saving merged film: %s", filmName)
+        # TODO add SafeSave
+        film.SaveFilm(filmName)
+
+        # Save the image output
+        imageName = self.renderFarmJob.GetImageFileName()
+        logger.info("Saving merged image output: %s", imageName)
+        film.SaveOutput(
+            imageName,
+            pyluxcore.FilmOutputType.RGB_IMAGEPIPELINE,
+            pyluxcore.Properties(),
+        )
+
+        # Get the halt conditions
+        filmHaltSPP = self.renderFarmJob.GetFilmHaltSPP()
+        filmHaltTime = self.renderFarmJob.GetFilmHaltTime()
+
+        # Print some film statistics
+        stats = film.GetStats()
+        logger.info("Merged film statistics:")
+        spp = stats.Get("stats.film.spp").GetFloat()
+        logger.info("  Samples per pixel: %.1f / %s", spp, str(filmHaltSPP))
+        self.renderFarmJob.SetSamplesPixel(spp)
+
+        dt = time.time() - self.renderFarmJob.GetStartTime()
+        logger.info(
+            "  Rendering time: %s/%s",
+            time.strftime("%H:%M:%S", time.gmtime(dt)),
+            time.strftime("%H:%M:%S", time.gmtime(filmHaltTime)),
+        )
+
+        totalSamples = stats.Get("stats.film.total.samplecount").GetFloat()
+        samplesSec = (
+            0.0
+            if dt <= 0.0
+            else (totalSamples - self.previousFilmSampleCount) / dt
+        )
+        logger.info(
+            "  Samples/sec: %.1fM samples/sec", (samplesSec / 1000000.0)
+        )
+        self.renderFarmJob.SetSamplesSec(samplesSec)
+
+        return (spp > filmHaltSPP > 0) or (dt > filmHaltTime > 0)
+
+    def __FilmMergeThread(self):
+        logger.info("Film merge thread started")
+
+        while True:
+            doMerge = False
+            if not self.filmMergeThreadEvent.wait(
+                self.renderFarmJob.filmUpdatePeriod
+            ):
+                # Time out, time to do a merge
+                doMerge = True
+            self.filmMergeThreadEvent.clear()
+
+            if self.filmMergeThreadEventStop:
+                break
+
+            if self.filmMergeThreadEventForceFilmMergePeriod:
+                self.filmMergeThreadEventForceFilmMergePeriod = False
+                doMerge = True
+
+            if self.filmMergeThreadEventForceFilmMerge:
+                self.filmMergeThreadEventForceFilmMerge = False
+                doMerge = True
+
+            if len(self.renderFarmJob.GetNodeThreadsList()) == 0:
+                continue
+
+            if doMerge:
+                logger.info("Merging node films")
+
+                # Merge all NodeThreadFilms
+                if film := self.MergeAllFilms():
+                    # Save the merged film
+                    if self.SaveMergedFilm(film):
+                        self.renderFarmJob.Stop(
+                            stopFilmMerger=False, lastUpdate=True
+                        )
+                        self.renderFarmJob.renderFarm.CurrentJobDone()
+                        break
+
+        logger.info("Film merge thread done")