yta-editor-pools 0.0.1__tar.gz

yta_editor_pools-0.0.1/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

yta_editor_pools-0.0.1/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: yta-editor-pools
+Version: 0.0.1
+Summary: Youtube Autonomous Main Editor Pools Module
+License-File: LICENSE
+Author: danialcala94
+Author-email: danielalcalavalera@gmail.com
+Requires-Python: ==3.9
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Requires-Dist: moderngl (>=0.0.1,<9.0.0)
+Requires-Dist: yta_validation (>=0.0.1,<1.0.0)
+Description-Content-Type: text/markdown
+
+# Youtube Autonomous Main Editor Pools Module
+
+The pools we need to use in our editor, related to the `moderngl.Texture` instances and to our own-designed `RenderTarget` class.

yta_editor_pools-0.0.1/README.md

@@ -0,0 +1,3 @@
+# Youtube Autonomous Main Editor Pools Module
+
+The pools we need to use in our editor, related to the `moderngl.Texture` instances and to our own-designed `RenderTarget` class.

yta_editor_pools-0.0.1/pyproject.toml

@@ -0,0 +1,31 @@
+[project]
+name = "yta-editor-pools"
+version = "0.0.1"
+description = "Youtube Autonomous Main Editor Pools Module"
+authors = [
+    {name = "danialcala94", email = "danielalcalavalera@gmail.com"}
+]
+readme = "README.md"
+requires-python = "==3.9"
+dependencies = [
+    "yta_validation (>=0.0.1,<1.0.0)",
+    "moderngl (>=0.0.1,<9.0.0)",
+]
+
+[tool.poetry]
+packages = [{include = "yta_editor_pools", from = "src"}]
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.3.5"
+yta_testing = ">=0.0.1"
+yta_video_opengl = ">=0.0.1"
+
+[tool.pytest.ini_options]
+markers = [
+    "mandatory: mandatory tests for release",
+    "additional: exhaustive and demanding tests"
+]
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"

yta_editor_pools-0.0.1/src/yta_editor_pools/__init__.py

@@ -0,0 +1,5 @@
+"""
+Library to include the pools we need to operate
+properly, being able to avoid recreating
+expensive objects.
+"""

yta_editor_pools-0.0.1/src/yta_editor_pools/render_target/__init__.py

@@ -0,0 +1,159 @@
+from yta_validation.parameter import ParameterValidator
+
+import moderngl
+
+
+class RenderTarget:
+    """
+    An object that acts as a unit the system uses
+    to render content on it, attached to a texture
+    and an FBO.
+
+    The purpose of this class is to have an object
+    in which our nodes are able to write. It 
+    includes a texture but it is always attached to
+    it and it doesn't come from any pool.
+
+    The `RenderTarget` itself belongs to the pool
+    while it is not being used and to the consumer
+    after the `.acquire()` method is called.
+    """
+
+    __slots__ = (
+        'context',
+        'texture',
+        '_fbo',
+        'width',
+        'height',
+        'number_of_components',
+        'dtype',
+        '_is_in_use'
+    )
+
+    @property
+    def fbo(
+        self
+    ) -> moderngl.Framebuffer:
+        """
+        Lazy FBO.
+        """
+        if self._fbo is None:
+            self._fbo = self.context.framebuffer(
+                color_attachments = [self.texture]
+            )
+
+        return self._fbo
+
+    def __init__(
+        self,
+        context: moderngl.Context,
+        texture: moderngl.Texture,
+        width: int,
+        height: int,
+        number_of_components: int,
+        dtype: str
+    ):
+        # TODO: Add docu
+        self.context = context
+        self.texture: moderngl.Texture = texture
+        """
+        The texture of the render target, that is always
+        attached to this `RenderTarget` instance.
+        """
+        self.width = width
+        self.height = height
+        self.number_of_components = number_of_components
+        self.dtype = dtype
+
+        self._fbo: moderngl.Framebuffer | None = None
+        self._is_in_use: bool = False
+
+    def reset_state(
+        self
+    ):
+        """
+        TODO: Document
+        """
+        self.texture.filter = (moderngl.LINEAR, moderngl.LINEAR)
+
+    def use(
+        self
+    ):
+        """
+        Bind FBO and prepare viewport.
+        """
+        self.fbo.use()
+        self.context.viewport = (0, 0, self.width, self.height)
+
+    def clear(
+        self
+    ):
+        """
+        Clear the context.
+        """
+        self.context.clear(0.0, 0.0, 0.0, 0.0)
+
+    def write(
+        self,
+        data: 'np.ndarray'
+    ) -> 'RenderTarget':
+        """
+        Write the `data` numpy array provided directly in
+        the texture, which is uploading from CPU to GPU.
+        """
+        ParameterValidator.validate_mandatory_numpy_array('data', data)
+
+        """
+        The `.write()` method accepts a numpy array only,
+        if no we have to do `.tobytes()` to whatever we
+        are trying to write.
+        """
+        self.texture.write(data)
+
+        return self
+
+    def read(
+        self
+    ) -> bytes:
+        """
+        Read the information existing in the `texture` 
+        inside this `RenderTarget` instance, which is
+        downloading from GPU to CPU.
+        """
+        return self.texture.read()
+
+    def mark_in_use(
+        self
+    ) -> 'RenderTarget':
+        """
+        Set this `RenderTarget` instance as in use.
+        """
+        assert not self._is_in_use, 'RenderTarget already in use'
+        self._is_in_use = True
+
+        return self
+
+    def mark_free(
+        self
+    ) -> 'RenderTarget':
+        """
+        Set this `RenderTarget` instance as not in use.
+        """
+        assert self._is_in_use, 'RenderTarget already free'
+        self._is_in_use = False
+
+        return self
+
+    def release_gpu(
+        self
+    ):
+        """
+        Free the real GPU resources (not back to the pool).
+        """
+        if self._fbo:
+            self._fbo.release()
+            self._fbo = None
+
+        if self.texture:
+            self.texture.release()
+            self.texture = None

yta_editor_pools-0.0.1/src/yta_editor_pools/render_target/pool.py

@@ -0,0 +1,123 @@
+from yta_editor_pools.render_target import RenderTarget
+from yta_editor_pools.texture.utils import get_texture_key
+from collections import defaultdict
+
+import moderngl
+
+
+class RenderTargetPool:
+    """
+    A pool of `RenderTarget` instances.
+
+    These instances are built to be used by our
+    nodes that will be using the shaders, uniforms
+    and inputs to write with an specific FBO and a
+    single texture that is attached to it.
+    """
+
+    def __init__(
+        self,
+        context: moderngl.Context
+    ):
+        self.context: moderngl.Context = context
+        """
+        The `moderngl` context we need to work with.
+        """
+        self.pool = defaultdict(list)
+        """
+        The internal pool to store the `RenderTarget`
+        instances.
+        """
+
+    def acquire(
+        self,
+        width: int = 1920,
+        height: int = 1080,
+        number_of_components: int = 4,
+        dtype: str = 'f1'
+    ) -> RenderTarget:
+        """
+        Get a `RenderTarget` from the pool with the given
+        parameters, or create a new one if non existing
+        and mark in use.
+        """
+        key = get_texture_key(
+            width = width,
+            height = height,
+            number_of_components = number_of_components,
+            dtype = dtype
+        )
+
+        if self.pool[key]:
+            render_target = self.pool[key].pop()
+        else:
+            texture = self.context.texture(
+                (width, height),
+                components = number_of_components,
+                dtype = dtype
+            )
+
+            #texture.filter = (moderngl.LINEAR, moderngl.LINEAR)
+
+            render_target = RenderTarget(
+                context = self.context,
+                texture = texture,
+                width = width,
+                height = height,
+                number_of_components = number_of_components,
+                dtype = dtype
+            )
+            
+        render_target.reset_state()
+        render_target.mark_in_use()
+
+        return render_target
+    
+    def acquire_like(
+        self,
+        render_target: 'RenderTarget'
+    ) -> 'RenderTarget':
+        """
+        Get a `RenderTarget` from the pool with the same
+        parameters than the `render_target` provided, or
+        create a new one if non existing and mark in use.
+        """
+        return self.acquire(
+            width = render_target.width,
+            height = render_target.height,
+            number_of_components = render_target.number_of_components,
+            dtype = render_target.dtype
+        )
+
+    def release(
+        self,
+        render_target: RenderTarget
+    ) -> None:
+        """
+        Mark the `render_target` provided as free and
+        return it to the pool.
+        """
+        render_target.mark_free()
+
+        key = get_texture_key(
+            width = render_target.width,
+            height = render_target.height,
+            number_of_components = render_target.number_of_components,
+            dtype = render_target.dtype
+        )
+
+        self.pool[key].append(render_target)
+
+    # TODO: Is it ok like this (?)
+    def clear(
+        self
+    ):
+        """
+        Empty the whole pool by also freeing the resources
+        of each `RenderTarget` instance.
+        """
+        for render_targets in self.pool.values():
+            for render_target in render_targets:
+                render_target.release_gpu()
+
+        self.pool.clear()

yta_editor_pools-0.0.1/src/yta_editor_pools/render_target/provider.py

@@ -0,0 +1,85 @@
+from yta_editor_pools.render_target.pool import RenderTargetPool
+from yta_validation.parameter import ParameterValidator
+
+import moderngl
+
+
+class RenderTargetProvider:
+    """
+    Class to provide `RenderTarget` instances by using
+    a pool internally that is unique for the context
+    provided.
+    """
+
+    _instances: dict[int, 'RenderTargetProvider'] = {}
+
+    @classmethod
+    def get(
+        cls,
+        opengl_context: moderngl.Context
+    ) -> 'RenderTargetProvider':
+        """
+        Get the singleton instance for the specific
+        `opengl_context` provided as parameter.
+        """
+        key = id(opengl_context)
+        if key not in cls._instances:
+            cls._instances[key] = cls(opengl_context)
+
+        return cls._instances[key]
+
+    def __init__(
+        self,
+        moderngl_context: 'moderngl.Context'
+    ):
+        ParameterValidator.validate_mandatory_instance_of('moderngl_context', moderngl_context, 'Context')
+        
+        self._pool: RenderTargetPool = RenderTargetPool(moderngl_context)
+        """
+        *For internal use only*
+
+        The pool of `RenderTarget` instances.
+        """
+
+    def acquire(
+        self,
+        width: int = 1920,
+        height: int = 1080,
+        number_of_components: int = 4,
+        dtype: str = 'f1'
+    ) -> 'RenderTarget':
+        """
+        Get a `RenderTarget` instance with the given `width`,
+        `height`, `number_of_components` and `dtype` from the
+        pool, that will mark it as in use.
+        """
+        return self._pool.acquire(
+            width = width,
+            height = height,
+            number_of_components = number_of_components,
+            dtype = dtype
+        )
+    
+    def acquire_like(
+        self,
+        render_target: 'RenderTarget'
+    ) -> 'RenderTarget':
+        """
+        Get the `RenderTarget` instance with the same
+        properties than the `render_target` provided as
+        parameter.
+        """
+        return self._pool.acquire_like(
+            render_target = render_target
+        )
+    
+    def release(
+        self,
+        render_target: 'RenderTarget'
+    ):
+        """
+        Release the `render_target` provided, making it
+        available again through the pool and marking it
+        as free.
+        """
+        self._pool.release(render_target)

yta_editor_pools-0.0.1/src/yta_editor_pools/texture/pool.py

@@ -0,0 +1,92 @@
+from yta_editor_pools.texture.utils import get_texture_key
+from collections import defaultdict
+
+import moderngl
+
+
+class TexturePool:
+    """
+    A pool of `TexturePool` instances.
+
+    These instances will be used to directly write
+    information on them and use, most of the times,
+    for CPU to GPU uploading.
+    """
+
+    def __init__(
+        self,
+        context: moderngl.Context
+    ):
+        self.context: moderngl.Context = context
+        """
+        The `moderngl` context we need to work with.
+        """
+        self.pool = defaultdict(list)
+        """
+        The internal pool to store the `moderngl.Texture`
+        instances.
+        """
+
+    def acquire(
+        self,
+        width: int = 1920,
+        height: int = 1080,
+        number_of_components: int = 4,
+        dtype: str = 'f1'
+    ) -> moderngl.Texture:
+        """
+        Get a `moderngl.Texture` from the pool with the
+        given parameters, or create a new one if non
+        existing and mark in use.
+        """
+        key = get_texture_key(
+            width = width,
+            height = height,
+            number_of_components = number_of_components,
+            dtype = dtype
+        )
+
+        return (
+            # Obtained from pool
+            self.pool[key].pop()
+            if self.pool[key] else
+            # Create new one
+            self.context.texture(
+                (width, height),
+                components = number_of_components,
+                dtype = dtype
+            )
+        )
+    
+    def acquire_like(
+        self,
+        texture: moderngl.Texture
+    ) -> moderngl.Texture:
+        """
+        Get a `moderngl.Texture` from the pool with the same
+        parameters than the `texture` provided, or
+        create a new one if non existing and mark in use.
+        """
+        return self.acquire(
+            width = texture.width,
+            height = texture.height,
+            number_of_components = texture.components,
+            dtype = texture.dtype
+        )
+
+    def release(
+        self,
+        texture: moderngl.Texture
+    ) -> None:
+        """
+        Mark the `texture` provided as free and return
+        it to the pool.
+        """
+        key = get_texture_key(
+            width = texture.width,
+            height = texture.height,
+            number_of_components = texture.components,
+            dtype = texture.dtype
+        )
+
+        self.pool[key].append(texture)

yta_editor_pools-0.0.1/src/yta_editor_pools/texture/provider.py

@@ -0,0 +1,84 @@
+from yta_editor_pools.texture.pool import TexturePool
+from yta_validation.parameter import ParameterValidator
+
+import moderngl
+
+
+class TextureProvider:
+    """
+    Class to provide `moderngl.Texture` instances by
+    using a pool internally that is unique for the
+    context provided.
+    """
+
+    _instances: dict[int, 'TextureProvider'] = {}
+
+    @classmethod
+    def get(
+        cls,
+        opengl_context: moderngl.Context
+    ) -> 'TextureProvider':
+        """
+        Get the singleton instance for the specific
+        `opengl_context` provided as parameter.
+        """
+        key = id(opengl_context)
+        if key not in cls._instances:
+            cls._instances[key] = cls(opengl_context)
+
+        return cls._instances[key]
+
+    def __init__(
+        self,
+        moderngl_context: 'moderngl.Context'
+    ):
+        ParameterValidator.validate_mandatory_instance_of('moderngl_context', moderngl_context, 'Context')
+        
+        self._pool: TexturePool = TexturePool(moderngl_context)
+        """
+        *For internal use only*
+
+        The pool of `moderngl.Texture` instances.
+        """
+
+    def acquire(
+        self,
+        width: int = 1920,
+        height: int = 1080,
+        number_of_components: int = 4,
+        dtype: str = 'f1'
+    ) -> moderngl.Texture:
+        """
+        Get a `moderngl.Texture` instance with the given `width`,
+        `height`, `number_of_components` and `dtype` from the
+        pool.
+        """
+        return self._pool.acquire(
+            width = width,
+            height = height,
+            number_of_components = number_of_components,
+            dtype = dtype
+        )
+    
+    def acquire_like(
+        self,
+        texture: moderngl.Texture
+    ) -> moderngl.Texture:
+        """
+        Get the `moderngl.Texture` instance with the same
+        properties than the `texture` provided as
+        parameter.
+        """
+        return self._pool.acquire_like(
+            texture = texture
+        )
+    
+    def release(
+        self,
+        texture: 'moderngl.Texture'
+    ):
+        """
+        Release the `texture` provided, making it available
+        again through the pool.
+        """
+        self._pool.release(texture)

yta_editor_pools-0.0.1/src/yta_editor_pools/texture/utils.py

@@ -0,0 +1,29 @@
+def get_texture_key(
+    width: int = 1920,
+    height: int = 1080,
+    number_of_components: int = 4,
+    dtype: str = 'f1'
+) -> tuple[int, int, int, str]:
+    """
+    *For internal use only*
+
+    Get the key for the texture with the provided
+    specifications.
+    """
+    return (width, height, number_of_components, dtype)
+
+def get_texture_key_from_texture(
+    texture: 'moderngl.Texture'
+) -> tuple[int, int, int, str]:
+    """
+    *For internal use only*
+
+    Get the key for the texture based on the data
+    that the `texture` provided has.
+    """
+    return get_texture_key(
+        width = texture.width,
+        height = texture.height,
+        number_of_components = texture.components,
+        dtype = texture.dtype
+    )