Inline scene launcher regex, minor type fixes, remove scene.scale in favor of .main and .resize

Author: Tremeschin

pyproject.toml

@@ -1,6 +1,3 @@
-[project.urls]
-GitHub = "https://github.com/BrokenSource/ShaderFlow"
-
 [project]
 name        = "shaderflow"
 description = "🔥 Modular shader engine designed for simplicity and speed"
@@ -35,6 +32,9 @@ dependencies = [
     "xxhash",
 ]
 
+[project.urls]
+GitHub = "https://github.com/BrokenSource/ShaderFlow"
+
 [project.scripts]
 shaderflow = "shaderflow.__main__:main"
 shader     = "shaderflow.__main__:main"

shaderflow/exporting.py

@@ -8,7 +8,7 @@
 from pathlib import Path
 from subprocess import PIPE
 from tempfile import TemporaryFile as SafePipe
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any, Optional, Union
 
 import moderngl
 import tqdm
@@ -57,9 +57,13 @@ def tcp_output(self) -> bool:
     relay: Optional[Callable[[int, int], None]] = None
     bar: Optional[tqdm.tqdm] = None
 
+    @property
+    def total_frames(self) -> int:
+        return max(1, round(self.scene.runtime * self.scene.fps))
+
     def open_bar(self) -> None:
         self.bar = tqdm.tqdm(
-            total=self.scene.total_frames,
+            total=self.total_frames,
             disable=((self.relay is False) or self.relay or self.scene.realtime),
             desc=f"Scene ({self.scene.name}) → Video",
             colour="#43BFEF",
@@ -73,14 +77,14 @@ def open_bar(self) -> None:
 
     def update(self) -> None:
         if self.relay:
-            self.relay(self.frame, self.scene.total_frames)
+            self.relay(self.frame, self.total_frames)
         if self.bar:
             self.bar.update(1)
         self.frame += 1
 
     @property
     def finished(self) -> bool:
-        return (self.frame >= self.scene.total_frames)
+        return (self.frame >= self.total_frames)
 
     # # FFmpeg configuration
 
@@ -98,7 +102,7 @@ def ffmpeg_sizes(self, width: int, height: int) -> None:
         self.ffmpeg.scale(width=width, height=height)
         self.ffmpeg.vflip()
 
-    def ffmpeg_output(self, output: str) -> None:
+    def ffmpeg_output(self, output: Union[Path, str]) -> None:
         if (output in ("pipe", "-", bytes)):
             self.type = OutputType.PIPE
             self.ffmpeg.pipe_output()

shaderflow/launcher.py

@@ -22,10 +22,7 @@ class SceneLauncher:
         help_flags=[],
     ))
 
-    tag: str = "Scene"
-    """Search classes that contains 'tag' in their inheritance"""
-
-    def common(self, package: Path=None) -> None:
+    def common(self, package: Path) -> None:
         search = deque()
 
         # Search all local files
@@ -48,16 +45,8 @@ def common(self, package: Path=None) -> None:
         for path in search:
             self.search(path)
 
-    @property
-    def regex(self) -> re.Pattern:
-        return re.compile(
-            r"^class\s+(\w+)\s*\(.*?(?:" + self.tag + r").*\):\s*(?:\"\"\"((?:\n|.)*?)\"\"\")?",
-            re.MULTILINE
-        )
-
     def search(self, script: Path) -> bool:
-        if not (script := Path(script)).exists():
-            return False
+        """Safe search classes without running script, add to cli"""
 
         def wrapper(script: Path, clsname: str):
             def run(*args: Annotated[str, Parameter(
@@ -67,13 +56,14 @@ def run(*args: Annotated[str, Parameter(
                 sys.argv[1:] = args
 
                 # Warn: Point of trust transfer to the file the user is running
-                scene: ShaderScene = runpy.run_path(script)[clsname]()
+                scene: ShaderScene = runpy.run_path(str(script))[clsname]()
                 scene.cli.meta(args)
 
             return run
 
         # Match all projects and their optional docstrings
-        matches = list(self.regex.finditer(script.read_text()))
+        pattern = re.compile(r"^class\s+(\w+)\s*\(.*?(?:Scene).*\):\s*(?:\"\"\"((?:\n|.)*?)\"\"\")?", re.MULTILINE)
+        matches = list(pattern.finditer(script.read_text()))
 
         # Add a command for each match
         for match in matches:
@@ -82,7 +72,7 @@ def run(*args: Annotated[str, Parameter(
                 wrapper(script, clsname),
                 name=clsname.lower(),
                 help=(docstring or "No description provided"),
-                group=f"📦 {self.tag}s at ({script})",
+                group=f"📦 Scenes at ({script})",
             )
 
         return bool(matches)

shaderflow/resolution.py

@@ -7,9 +7,9 @@ class Resolution:
 
     @classmethod
     def fit(cls,
-        old: Optional[tuple[int, int]] = None,
-        new: Optional[tuple[int, int]] = None,
-        max: Optional[tuple[int, int]] = None,
+        old: Optional[tuple[int | None, int | None]] = None,
+        new: Optional[tuple[int | None, int | None]] = None,
+        max: Optional[tuple[int | None, int | None]] = None,
         ar: Optional[float] = None,
         scale: float = 1.0,
         multiple: int = 2,

shaderflow/scene.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 import contextlib
 import gc
 import importlib
@@ -10,7 +8,7 @@
 from collections.abc import Iterable
 from enum import Enum
 from pathlib import Path
-from typing import TYPE_CHECKING, Annotated, Any, Optional, Self, Union
+from typing import TYPE_CHECKING, Annotated, Any, Optional, Union
 
 import moderngl
 import numpy as np
@@ -36,7 +34,7 @@
 from shaderflow.variable import ShaderVariable, Uniform
 
 if TYPE_CHECKING:
-    from moderngl_window.context.base import BaseWindow as ModernglWindow
+    from moderngl_window.context.glfw import Window as GlfwWindow
 
 # ---------------------------------------------------------------------------- #
 
@@ -45,17 +43,15 @@ class WindowBackend(Enum):
     GLFW     = "glfw"
 
     @classmethod
-    def infer(cls) -> Self:
+    def infer(cls) -> "WindowBackend":
 
         # Optional external user override
         if (option := os.getenv("WINDOW_BACKEND")):
-            if (value := cls.get(option)) is None:
-                raise ValueError(f"Invalid window backend '{option}', options are {cls.values()}")
-            return value
+            return cls(option)
 
         # Infer headless if exporting the scene via cli
         if ("main" in sys.argv) and (args := sys.argv[sys.argv.index("main"):]):
-            if any(x in args for x in ("--render", "-r", "--output", "-o")):
+            if any(x in args for x in ("--output", "-o")):
                 return cls.Headless
 
         return cls.GLFW
@@ -68,34 +64,34 @@ class ShaderScene(ShaderModule):
     backend: WindowBackend = Factory(WindowBackend.infer)
     """ModernGL Window backend, cannot be changed after creation"""
 
-    window: 'ModernglWindow' = None
+    window: 'GlfwWindow' = None # type: ignore
     """ModernGL Window class instance at `moderngl_window.context.<backend>.Window`"""
 
-    opengl: moderngl.Context = None
+    opengl: moderngl.Context = None # type: ignore
     """ModernGL Context bound to this Scene"""
 
-    quality: float = field(default=50.0, converter=lambda x: min(max(0.0, float(x)), 100.0))
+    quality: float = field(default=50.0, converter=float)
     """Global quality level, if implemented on the shader/scene"""
 
     # -------------------------------------------|
     # Modules
 
-    ffmpeg: FFmpeg = Factory(FFmpeg)
-    """FFmpeg configuration for exporting videos"""
-
     modules: list[ShaderModule] = Factory(list)
     """List of all Modules in order of addition (including self)"""
 
-    frametimer: ShaderFrametimer = None
+    ffmpeg: FFmpeg = Factory(FFmpeg)
+    """FFmpeg configuration for exporting videos"""
+
+    frametimer: ShaderFrametimer = None # type: ignore
     """Default Frametimer module"""
 
-    keyboard: ShaderKeyboard = None
+    keyboard: ShaderKeyboard = None # type: ignore
     """Default Keyboard module"""
 
-    camera: ShaderCamera = None
+    camera: ShaderCamera = None # type: ignore
     """Default Camera module"""
 
-    shader: ShaderProgram = None
+    shader: ShaderProgram = None # type: ignore
     """The main shader of the scene"""
 
     def __del__(self):
@@ -110,7 +106,7 @@ def __del__(self):
     # -------------------------------------------|
     # Super Sampling Anti-Aliasing
 
-    _final: ShaderProgram = None
+    _final: ShaderProgram = None # type: ignore
     """Internal shader used for downsampling final frames"""
 
     @property
@@ -138,7 +134,6 @@ def initialize(self) -> None:
         self.camera = ShaderCamera(scene=self)
 
         # Linux: Use EGL for creating a OpenGL context, allows true headless with GPU acceleration
-        # Note: (https://forums.developer.nvidia.com/t/81412) (https://brokensrc.dev/get/docker/)
         if (sys.platform == "linux") and (os.getenv("EGL", "1") == "1"):
             backend = "egl"
 
@@ -265,10 +260,6 @@ def frame(self) -> int:
     def frame(self, value: int):
         self.time = (value / self.fps)
 
-    @property
-    def total_frames(self) -> int:
-        return max(1, round(self.runtime * self.fps))
-
     # Total Duration
 
     @property
@@ -280,7 +271,7 @@ def max_duration(self) -> float:
         """The longest module duration"""
         return max((module.duration or 0.0) for module in self.modules)
 
-    def set_duration(self, override: float=None) -> float:
+    def set_duration(self, override: Optional[float]=None) -> float:
         """Either force the duration, find the longest module or use base duration"""
         self.runtime  = (override or self.max_duration)
         self.runtime /= self.speed
@@ -319,20 +310,6 @@ def _window_proxy(self, attribute, value) -> Any:
     # -------------------------------------------------------------------------|
     # Resolution
 
-    # # Scale
-
-    _scale: float = field(default=1.0, converter=lambda x: max(0.01, x))
-
-    @property
-    def scale(self) -> float:
-        """Resolution scale factor"""
-        return self._scale
-
-    @scale.setter
-    def scale(self, value: float):
-        logger.debug(f"Changing Resolution Scale to ({value})")
-        self.resize(scale=value)
-
     # # Width
 
     _width: int = field(default=1920)
@@ -343,7 +320,7 @@ def width(self) -> int:
 
     @width.setter
     def width(self, value: int):
-        self.resize(width=(value*self._scale))
+        self.resize(width=value)
 
     # # Height
 
@@ -355,7 +332,7 @@ def height(self) -> int:
 
     @height.setter
     def height(self, value: int):
-        self.resize(height=(value*self._scale))
+        self.resize(height=value)
 
     # # SSAA
 
@@ -396,15 +373,15 @@ def render_resolution(self) -> tuple[int, int]:
 
     # # Aspect Ratio
 
-    _aspect_ratio: float = None
+    _aspect_ratio: Optional[float] = None
 
     @property
     def aspect_ratio(self) -> float:
         """Either the forced `self._aspect_ratio` or dynamic from `self.width/self.height`"""
         return self._aspect_ratio or (self.width/self.height)
 
     @aspect_ratio.setter
-    def aspect_ratio(self, value: Union[float, str]):
+    def aspect_ratio(self, value: Optional[Union[float, str]]):
         logger.debug(f"Changing Aspect Ratio to {value}")
 
         # The aspect ratio can be sent as a fraction or "none", "false"
@@ -418,20 +395,23 @@ def aspect_ratio(self, value: Union[float, str]):
         self._aspect_ratio = value
 
         if (self.backend == WindowBackend.GLFW) and (self._aspect_ratio is not None):
-            __import__("glfw").set_window_aspect_ratio(self.window._window, 2**16, int(2**16 / self._aspect_ratio))
+            import glfw
+            glfw.set_window_aspect_ratio(
+                self.window._window,
+                2**16, int(2**16 / self._aspect_ratio)
+            )
 
     def resize(self,
-        width:  Optional[int | float] = None,
-        height: Optional[int | float] = None,
+        width:  Optional[int] = None,
+        height: Optional[int] = None,
         ratio: Optional[float | str] = None,
         bounds: Optional[tuple[int, int]] = None,
-        scale: Optional[float] = None,
         ssaa: Optional[float] = None,
+        scale: float = 1.0,
     ) -> tuple[int, int]:
 
         # Maybe update auxiliary properties
         self.aspect_ratio = (ratio or self._aspect_ratio)
-        self._scale = (scale or self._scale)
         self._ssaa = (ssaa or self._ssaa)
 
         # The parameters aren't trivial. The idea is to fit resolution from the scale-less components,
@@ -441,7 +421,7 @@ def resize(self,
             new=(width, height),
             max=bounds,
             ar=self._aspect_ratio,
-            scale=self._scale,
+            scale=scale,
         )
 
         # Optimization: Only resize if target is different
@@ -516,9 +496,9 @@ def main(self, *,
             help="Height of the rendering resolution (None to keep or find by --ar aspect ratio)",
             group="🔴 Basic", name=("height", "-h"))] = 1080,
 
-        scale: Annotated[Optional[float], Parameter(
+        scale: Annotated[float, Parameter(
             help="Post-multiply width and height by a scale factor (None to keep)",
-            group="🔴 Basic", name=("scale", "-S"))] = None,
+            group="🔴 Basic", name=("scale", "-x"))] = 1.0,
 
         ratio: Annotated[Optional[Union[float, str]], Parameter(
             help="Force resolution aspect ratio (Examples: '16:9', '16/9', '1.777') (None for dynamic)",
@@ -617,7 +597,7 @@ def main(self, *,
         if (self.exporting):
             export.ffmpeg_clean()
             export.ffmpeg_sizes(width=_width, height=_height)
-            export.ffmpeg_output(output)
+            export.ffmpeg_output(output) # type: ignore
             export.make_buffers(buffers)
             export.ffhook()
             export.popen()

shaderflow/utils.py

@@ -7,7 +7,7 @@
 class CycloUtils:
 
     @staticmethod
-    def chain(app: App) -> callable:
+    def chain(app: App):
         """Implements known commands chaining in meta app"""
         def meta(*tokens: Annotated[str, Parameter(show=False, allow_leading_hyphen=True)]):
             if (splits := [n for (n, token) in enumerate(tokens) if token in app]):

website/about/changelog.md

@@ -10,6 +10,7 @@ icon: material/file-document-edit
 !!! quote ""
     - Move website to tremeschin.com domain
     - Fix `Scene.resolution = (w, h)` using positionals in `Scene.resize`
+    - Simplify remove `scene._scale` field in favor of `.main()` or `.resize()` argument
 
 ### 📦 v0.10.0 <small>March 12, 2026</small> {#v0.10.0}