yta-video-opengl 0.0.24__py3-none-any.whl → 0.0.26__py3-none-any.whl

yta_video_opengl/{editor.py → effects.py}

@@ -1,6 +1,6 @@
 from yta_video_opengl.nodes.video.opengl import WavingNode
 from yta_video_opengl.nodes.audio import ChorusNode
-from yta_video_opengl.nodes import Node, TimedNode
+from yta_video_opengl.nodes import TimedNode
 from yta_validation.parameter import ParameterValidator
 from yta_programming.decorators import singleton_old
 from typing import Union
@@ -20,9 +20,9 @@ class _AudioEffects:
 
     def __init__(
         self,
-        effects: '_Effects'
+        effects: 'Effects'
     ):
-        self._effects: _Effects = effects
+        self._effects: Effects = effects
         """
         The parent instance that includes this
         class instance as a property.
@@ -66,9 +66,9 @@ class _VideoEffects:
 
     def __init__(
         self,
-        effects: '_Effects'
+        effects: 'Effects'
     ):
-        self._effects: _Effects = effects
+        self._effects: Effects = effects
         """
         The parent instance that includes this
         class instance as a property.
@@ -101,7 +101,7 @@ class _VideoEffects:
         """
         return _create_node(
             WavingNode(
-                context = self._effects._opengl_editor.context,
+                context = self._effects.opengl_context,
                 size = size,
                 amplitude = amplitude,
                 frequency = frequency,
@@ -114,45 +114,8 @@ class _VideoEffects:
     # TODO: Include definitive and tested video
     # effects here below
 
-class _Effects:
-    """
-    *For internal use only*
-
-    Class to be used within the OpenglEditor
-    as a property to simplify the access to
-    the effect nodes and also to have the
-    single context always available through
-    the OpenglEditor instance that is a 
-    singleton one.
-
-    Even though we can have more effects,
-    this class is also the way we expose only
-    the ones we actually want to expose to 
-    the user.
-    """
-    
-    def __init__(
-        self,
-        opengl_editor: 'OpenglEditor'
-    ):
-        self._opengl_editor: OpenglEditor = opengl_editor
-        """
-        The parent instance that includes this
-        class instance as a property.
-        """
-        self.audio: _AudioEffects = _AudioEffects(self)
-        """
-        Shortcut to the audio effects that are
-        available.
-        """
-        self.video: _VideoEffects = _VideoEffects(self)
-        """
-        Shortcut to the video effects that are
-        available.
-        """
-
 @singleton_old
-class OpenglEditor:
+class Effects:
     """
     Singleton instance.
 
@@ -163,6 +126,15 @@ class OpenglEditor:
     the nodes we have available for the
     user.
 
+    This class is to simplify the access to
+    the effect nodes and also to have the
+    single context always available.
+
+    Even though we can have more effects,
+    this class is also the way we expose only
+    the ones we actually want to expose to 
+    the user.
+
     The GPU will make the calculations in
     parallel by itself, so we can handle a
     single context to make the nodes share
@@ -172,32 +144,33 @@ class OpenglEditor:
     def __init__(
         self
     ):
-        self.context = moderngl.create_context(standalone = True)
+        self.opengl_context = moderngl.create_context(standalone = True)
         """
-        The context that will be shared by all
-        the nodes.
+        The opengl context that will be shared
+        by all the opengl nodes.
         """
-        self.effects: _Effects = _Effects(self)
+        self.audio: _AudioEffects = _AudioEffects(self)
         """
-        Shortcut to the effects.
+        Shortcut to the audio effects that are
+        available.
+        """
+        self.video: _VideoEffects = _VideoEffects(self)
+        """
+        Shortcut to the video effects that are
+        available.
         """
-        # TODO: I should do something like
-        # editor.effects.waving_node() to create
-        # an instance of that effect node
-
 
 def _create_node(
     node: Union['_AudioNode', '_VideoNode'],
     start: Union[int, float, 'Fraction'],
     end: Union[int, float, 'Fraction', None]
 ):
-    # The class we pass has to inherit from this
-    # 'Node' class, but could be other classes
-    # in the middle, because an OpenglNode 
-    # inherits from other class
-    ParameterValidator.validate_mandatory_subclass_of('node', node, ['_AudioNode', '_VideoNode'])
+    # We could be other classes in the middle,
+    # because an OpenglNode inherits from
+    # other class
+    ParameterValidator.validate_mandatory_subclass_of('node', node, ['_AudioNode', '_VideoNode', 'OpenglNodeBase'])
 
-    # We have to create a Node wrapper with the
+    # We have to create a node wrapper with the
     # time range in which it has to be applied
     # to all the frames.
     return TimedNode(
@@ -215,6 +188,26 @@ class _EffectStacked:
     and lower when higher value.
     """
 
+    @property
+    def is_audio_effect(
+        self
+    ) -> bool:
+        """
+        Flag to indicate if it is an audio effect
+        or not.
+        """
+        return self.effect.is_audio_node
+
+    @property
+    def is_video_effect(
+        self
+    ) -> bool:
+        """
+        Flag to indicate if it is a video effect
+        or not.
+        """
+        return self.effect.is_video_node
+
     def __init__(
         self,
         effect: TimedNode,
@@ -243,34 +236,66 @@ class EffectsStack:
     """
 
     @property
-    def effects(
+    def video_effects(
         self
     ) -> list[_EffectStacked]:
         """
-        The effects but ordered from their 'start'
-        time moment.
+        The video effects but ordered by 'priority'
+        and 'start' time moment.
         """
-        return sorted(self._effects, key = lambda effect: (effect.priority, effect.effect.start))
+        return sorted(
+            [
+                effect
+                for effect in self._effects
+                if effect.is_video_effect
+            ],
+            key = lambda effect: (effect.priority, effect.effect.start)
+        )
     
     @property
-    def most_priority_effect(
+    def audio_effects(
         self
-    ) -> _EffectStacked:
+    ) -> list[_EffectStacked]:
         """
-        The effect with the highest priority,
-        that is the lower priority value.
+        The audio effects but ordered by 'priority'
+        and 'start' time moment.
         """
-        return min(self._effects, key = lambda effect: effect.priority)
+        return sorted(
+            [
+                effect
+                for effect in self._effects
+                if effect.is_audio_effect
+            ],
+            key = lambda effect: (effect.priority, effect.effect.start)
+        )
+    
+    @property
+    def lowest_audio_priority(
+        self
+    ) -> int:
+        """
+        The priority of the audio effect with the
+        lowest one, or 0 if no audio effects.
+        """
+        return min(
+            self.audio_effects,
+            key = lambda effect: effect.priority,
+            default = 0
+        )
 
     @property
-    def less_priority_effect(
+    def lowest_video_priority(
         self
-    ) -> _EffectStacked:
+    ) -> int:
         """
-        The effect with the lowest priority,
-        that is the biggest priority value.
+        The priority of the video effect with the
+        lowest one, or 0 if no video effects.
         """
-        return max(self._effects, key = lambda effect: effect.priority)
+        return min(
+            self.video_effects,
+            key = lambda effect: effect.priority,
+            default = 0
+        )
     
     def __init__(
         self
@@ -281,20 +306,35 @@ class EffectsStack:
         have been added to this stack, unordered.
         """
 
-    def get_effects_for_t(
+    def get_audio_effects_for_t(
+        self,
+        t: Union[int, float, 'Fraction']
+    ) -> list[TimedNode]:
+        """
+        Get the audio effects, ordered by priority
+        and the 'start' field, that must be applied
+        within the 't' time moment provided because
+        it is within the [start, end) time range.
+        """
+        return [
+            effect.effect
+            for effect in self.audio_effects
+            if effect.effect.is_within_time(t)
+        ]
+
+    def get_video_effects_for_t(
         self,
         t: Union[int, float, 'Fraction']
     ) -> list[TimedNode]:
         """
-        Get the effects, ordered by priority
-        and the 'start' field, that must be
-        applied within the 't' time moment 
-        provided because it is within the
-        [start, end) time range.
+        Get the video effects, ordered by priority
+        and the 'start' field, that must be applied
+        within the 't' time moment provided because
+        it is within the [start, end) time range.
         """
         return [
             effect.effect
-            for effect in self.effects
+            for effect in self.video_effects
             if effect.effect.is_within_time(t)
         ]
 
@@ -307,6 +347,7 @@ class EffectsStack:
         Add the provided 'effect' to the stack.
         """
         ParameterValidator.validate_mandatory_instance_of('effect', effect, TimedNode)
+        ParameterValidator.validate_positive_int('priority', priority, do_include_zero = True)
 
         # TODO: What about the same effect added
         # twice during the same time range? Can we
@@ -318,8 +359,16 @@ class EffectsStack:
         # Should we let some effects have the same
         # priority (?)
         priority = (
-            self.less_priority_effect.priority + 1
-            if priority is None else
+            self.lowest_audio_priority + 1
+            if (
+                priority is None and
+                effect.is_audio_node
+            ) else
+            self.lowest_video_priority + 1
+            if (
+                priority is None and
+                effect.is_video_node
+            ) else
             priority
         )
 
@@ -330,4 +379,6 @@ class EffectsStack:
 
         return self
     
+    # TODO: Maybe create an 'apply_video_effects' (?)
+    # TODO: Maybe create an 'apply_audio_effects' (?)
     # TODO: Create 'remove_effect'

yta_video_opengl/nodes/__init__.py

@@ -1,6 +1,7 @@
 from yta_video_opengl.nodes.video import _VideoNode
 from yta_video_opengl.nodes.audio import _AudioNode
 from yta_validation.parameter import ParameterValidator
+from yta_validation import PythonValidator
 from typing import Union
 
 import moderngl
@@ -32,6 +33,30 @@ class TimedNode:
     The 'start' and 'end' values by default
     """
 
+    @property
+    def is_audio_node(
+        self
+    ) -> bool:
+        """
+        Flag to indicate if the node (or effect)
+        is an audio effect or not.
+        """
+        # TODO: Is this checking not only the
+        # first level (?)
+        return PythonValidator.is_subclass_of(self.node, _AudioNode)
+    
+    @property
+    def is_video_node(
+        self
+    ) -> bool:
+        """
+        Flag to indicate if the node (or effect)
+        is a video effect or not.
+        """
+        # TODO: Is this checking not only the
+        # first level (?)
+        return PythonValidator.is_subclass_of(self.node, _VideoNode)
+
     def __init__(
         self,
         node: Union[_VideoNode, _AudioNode],
@@ -47,7 +72,7 @@ class TimedNode:
         ):
             raise Exception('The "end" parameter provided must be greater or equal to the "start" parameter.')
 
-        self.node: Node = node
+        self.node: Union[_VideoNode, _AudioNode] = node
         """
         The node we are wrapping and we want to
         apply as a modification of the frame in

yta_video_opengl/nodes/audio/__init__.py

@@ -16,7 +16,6 @@ working in GPU. Doing this below most of the
 changes would work:
 - `import numpy as np` → `import cupy as np`
 """
-from yta_video_opengl.nodes import TimedNode
 from abc import abstractmethod
 from typing import Union
 
@@ -33,9 +32,9 @@ class _AudioNode:
     @abstractmethod
     def process(
         self,
-        input: Union['AudioFrame', 'np.ndarray'],
+        input: np.ndarray,
         t: float
-    ) -> Union['AudioFrame', 'np.ndarray']:
+    ) -> np.ndarray:
         """
         Process the provided audio 'input' that
         is played on the given 't' time moment.
@@ -60,20 +59,13 @@ class VolumeNode(_AudioNode):
 
     def process(
         self,
-        input: Union['AudioFrame', 'np.ndarray'],
+        input: np.ndarray,
         t: float
-    ) -> Union['AudioFrame', 'np.ndarray']:
+    ) -> np.ndarray:
         """
         Process the provided audio 'input' that
         is played on the given 't' time moment.
         """
-        # if PythonValidator.is_instance_of(input, 'AudioFrame'):
-        #     input = input.to_ndarray().astype(np.float32)
-
-        # TODO: I think we should receive only 
-        # numpy arrays and the AudioFrame should
-        # be handled outside, but I'm not sure
-
         factor = self.factor_fn(t, 0)
 
         samples = input
@@ -87,15 +79,6 @@ class VolumeNode(_AudioNode):
         #     samples.astype(np.float32)
         # )
 
-        # new_frame = AudioFrame.from_ndarray(
-        #     samples,
-        #     format = input.format.name,
-        #     layout = input.layout.name
-        # )
-        # new_frame.sample_rate = input.sample_rate
-        # new_frame.pts = input.pts
-        # new_frame.time_base = input.time_base
-
         return samples
     
 class ChorusNode(_AudioNode):
@@ -122,17 +105,13 @@ class ChorusNode(_AudioNode):
 
     def process(
         self,
-        input: Union['AudioFrame', 'np.ndarray'],
+        input: Union[np.ndarray],
         t: float
-    ) -> Union['AudioFrame', 'np.ndarray']:
+    ) -> np.ndarray:
         """
         Process the provided audio 'input' that
         is played on the given 't' time moment.
         """
-        # TODO: I think we should receive only 
-        # numpy arrays and the AudioFrame should
-        # be handled outside, but I'm not sure
-
         n_samples = input.shape[0]
         t = np.arange(n_samples) / self.rate
 
@@ -144,81 +123,11 @@ class ChorusNode(_AudioNode):
 
         for i in range(n_samples):
             d = delay[i]
-            if i - d >= 0:
-                output[i] = 0.7 * input[i] + 0.7 * input[i - d]
-            else:
-                output[i] = input[i]
 
-        return output
+            output[i]= (
+                0.7 * input[i] + 0.7 * input[i - d]
+                if (i - d) >= 0 else
+                input[i]
+            )
 
-# TODO: Remove this below
-"""
-Here you have an example. The 'private'
-node class is the modifier, that we don't
-want to expose, and the 'public' class is
-the one that inherits from TimedNode and
-wraps the 'private' class to build the
-functionality.
-"""
-# class VolumeAudioNode(TimedNode):
-#     """
-#     TimedNode to set the audio volume of a video
-#     in a specific frame.
-#     """
-
-#     def __init__(
-#         self,
-#         factor_fn,
-#         start: float = 0.0,
-#         end: Union[float, None] = None
-#     ):
-#         super().__init__(
-#             node = _SetVolumeAudioNode(factor_fn),
-#             start = start,
-#             end = end
-#         )
-
-# class _SetVolumeAudioNode(AudioNode):
-#     """
-#     Audio node to change the volume of an
-#     audio frame.
-#     """
-
-#     def __init__(
-#         self,
-#         factor_fn
-#     ):
-#         """
-#         factor_fn: function (t, index) -> factor volumen
-#         """
-#         self.factor_fn = factor_fn
-
-#     def process(
-#         self,
-#         frame: av.AudioFrame,
-#         t: float,
-#     ) -> av.AudioFrame:
-#         # TODO: Why index (?) Maybe 'total_frames'
-#         factor = self.factor_fn(t, 0)
-
-#         samples = frame.to_ndarray().astype(np.float32)
-#         samples *= factor
-
-#         # Determine dtype according to format
-#         samples = (
-#             samples.astype(np.int16)
-#             # 'fltp', 's16', 's16p'
-#             if 's16' in frame.format.name else
-#             samples.astype(np.float32)
-#         )
-
-#         new_frame = av.AudioFrame.from_ndarray(
-#             samples,
-#             format = frame.format.name,
-#             layout = frame.layout.name
-#         )
-#         new_frame.sample_rate = frame.sample_rate
-#         new_frame.pts = frame.pts
-#         new_frame.time_base = frame.time_base
-
-#         return new_frame
+        return output

yta_video_opengl/nodes/video/__init__.py

@@ -8,6 +8,10 @@ from abc import ABC, abstractmethod
 
 import moderngl
 
+
+# TODO: Expose all the nodes here and move
+# this abstract to an abstract file (?)
+
 class _VideoNode(ABC):
     """
     Base abstract class to represent a video

yta_video_opengl/nodes/video/opengl/__init__.py

@@ -199,7 +199,7 @@ class OpenglNodeBase(_VideoNode):
 
     def process(
         self,
-        input: Union[moderngl.Texture, 'VideoFrame', 'np.ndarray']
+        input: Union[moderngl.Texture, np.ndarray]
     ) -> moderngl.Texture:
         """
         Apply the shader to the 'input', that
@@ -209,7 +209,7 @@ class OpenglNodeBase(_VideoNode):
         We use and return textures to maintain
         the process in GPU and optimize it.
         """
-        if PythonValidator.is_instance_of(input, ['VideoFrame', 'ndarray']):
+        if PythonValidator.is_instance_of(input, np.ndarray):
             # TODO: What about the numpy format (?)
             input = frame_to_texture(input, self.context)
 
@@ -293,7 +293,7 @@ class WavingNode(OpenglNodeBase):
     # processed by the code
     def process(
         self,
-        input: Union[moderngl.Texture, 'VideoFrame', 'np.ndarray'],
+        input: Union[moderngl.Texture, 'np.ndarray'],
         t: float = 0.0,
     ) -> moderngl.Texture:
         """

yta_video_opengl/nodes/video/opengl/experimental.py

@@ -65,7 +65,7 @@ class BreathingFrame(OpenglNodeBase):
     
     def process(
         self,
-        input: Union[moderngl.Texture, 'VideoFrame', 'np.ndarray'],
+        input: Union[moderngl.Texture, 'np.ndarray'],
         t: float = 0.0,
     ) -> moderngl.Texture:
         """
@@ -165,7 +165,7 @@ class HandheldFrame(OpenglNodeBase):
     
     def process(
         self,
-        input: Union[moderngl.Texture, 'VideoFrame', 'np.ndarray'],
+        input: Union[moderngl.Texture, np.ndarray],
         t: float = 0.0,
     ) -> moderngl.Texture:
         """
@@ -351,7 +351,7 @@ class OrbitingFrame(OpenglNodeBase):
     
     def process(
         self,
-        input: Union[moderngl.Texture, 'VideoFrame', 'np.ndarray'],
+        input: Union[moderngl.Texture, np.ndarray],
         t: float = 0.0,
     ) -> moderngl.Texture:
         """
@@ -446,7 +446,7 @@ class RotatingInCenterFrame(OpenglNodeBase):
 
     def process(
         self,
-        input: Union[moderngl.Texture, 'VideoFrame', 'np.ndarray'],
+        input: Union[moderngl.Texture, np.ndarray],
         t: float = 0.0,
     ) -> moderngl.Texture:
         """
@@ -636,7 +636,7 @@ class StrangeTvFrame(OpenglNodeBase):
 
     def process(
         self,
-        input: Union[moderngl.Texture, 'VideoFrame', 'np.ndarray'],
+        input: Union[moderngl.Texture, np.ndarray],
         t: float = 0.0,
     ) -> moderngl.Texture:
         """
@@ -744,7 +744,7 @@ class GlitchRgbFrame(OpenglNodeBase):
 
     def process(
         self,
-        input: Union[moderngl.Texture, 'VideoFrame', 'np.ndarray'],
+        input: Union[moderngl.Texture, np.ndarray],
         t: float = 0.0,
     ) -> moderngl.Texture:
         """

yta_video_opengl/tests.py

@@ -606,9 +606,9 @@ def video_modified_stored():
     #     size = video.size,
     #     first_frame = video.next_frame
     # )
-    from yta_video_opengl.editor import OpenglEditor
+    from yta_video_opengl.effects import Effects
 
-    editor = OpenglEditor()
+    editor = Effects()
     # waving_node_effect = editor.effects.video.waving_node(video.size, amplitude = 0.2, frequency = 9, speed = 3)
     # chorus_effect = editor.effects.audio.chorus(audio.sample_rate)
     # print(waving_node_effect)

{yta_video_opengl-0.0.24.dist-info → yta_video_opengl-0.0.26.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: yta-video-opengl
-Version: 0.0.24
+Version: 0.0.26
 Summary: Youtube Autonomous Video OpenGL Module
 Author: danialcala94
 Author-email: danielalcalavalera@gmail.com

yta_video_opengl-0.0.26.dist-info/RECORD

@@ -0,0 +1,13 @@
+yta_video_opengl/__init__.py,sha256=ycAx_XYMVDfkuObSvtW6irQ0Wo-fgxEz3fjIRMe8PpY,205
+yta_video_opengl/effects.py,sha256=BqXN3dKw63MB-1eTpQm3TjoPYogX3TkVMBt__AqBa_4,10599
+yta_video_opengl/nodes/__init__.py,sha256=mDqQBfOjDKqPqp_CNY38ROM_5lhyzQ9AgT0pRswpYUY,4464
+yta_video_opengl/nodes/audio/__init__.py,sha256=LnGes6u1K0pa4CXP0LrHftLwv0zi-JYvHmYEkJqw_J8,3302
+yta_video_opengl/nodes/video/__init__.py,sha256=I6F4JRNFKsj1jjy-nXoD9hj7rA47DtAIhAk6-m6vgjY,948
+yta_video_opengl/nodes/video/opengl/__init__.py,sha256=nqe803cLoxE0NVMadYU8fgdEXrocDjoD-NEZvs1lERw,8542
+yta_video_opengl/nodes/video/opengl/experimental.py,sha256=9MPudKhl_mDjOyVj89GGLJUVW2esc0PK15EsRpijtzI,22064
+yta_video_opengl/tests.py,sha256=OPD1Caxt-VYHOtgjIhSfG8pqu8YMREgNsEUBZ22kd3o,24256
+yta_video_opengl/utils.py,sha256=w6jYnZcBYPNAsTolkAlA6dxph0u_8-mcUzKvADlIlW8,3098
+yta_video_opengl-0.0.26.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
+yta_video_opengl-0.0.26.dist-info/METADATA,sha256=d5l55MFB2wrIC4roMkkGyY0I8_LqyRw54WPQeQoL258,589
+yta_video_opengl-0.0.26.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+yta_video_opengl-0.0.26.dist-info/RECORD,,

yta_video_opengl-0.0.24.dist-info/RECORD

@@ -1,13 +0,0 @@
-yta_video_opengl/__init__.py,sha256=ycAx_XYMVDfkuObSvtW6irQ0Wo-fgxEz3fjIRMe8PpY,205
-yta_video_opengl/editor.py,sha256=ILzeGAe6uO5IptwrplbvnFu8e0j8v9AOaAmuvFH4YjI,9218
-yta_video_opengl/nodes/__init__.py,sha256=Rbh6HxWpKrdF_qlcGVKYBGW6i10NodoExa5qGEMcmIM,3738
-yta_video_opengl/nodes/audio/__init__.py,sha256=upKsYZrrNW2DxP77RyMCw2I16Lj9JsHbXGALw5grxbQ,6143
-yta_video_opengl/nodes/video/__init__.py,sha256=Nf1CnUaz6m7mOvVsuoTKMsq5QIVqEqZaiGseNOre8_k,859
-yta_video_opengl/nodes/video/opengl/__init__.py,sha256=bVPdS_wpz4HNurmLRDEHUmNZU7Qz8LptKfJ9yN_2PJM,8587
-yta_video_opengl/nodes/video/opengl/experimental.py,sha256=XuriXcOuJU5P0FruKffudCpMuO-ht8weJud88Qn8GKk,22158
-yta_video_opengl/tests.py,sha256=uvTU1_cvz5r7fETd4X8hvsYw4jViMDA0x-LsDNplFPM,24265
-yta_video_opengl/utils.py,sha256=w6jYnZcBYPNAsTolkAlA6dxph0u_8-mcUzKvADlIlW8,3098
-yta_video_opengl-0.0.24.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
-yta_video_opengl-0.0.24.dist-info/METADATA,sha256=WKcDQFnZS0TvesGJM9N-bbPjOx0DdTNZb6yU-4nzUqY,589
-yta_video_opengl-0.0.24.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-yta_video_opengl-0.0.24.dist-info/RECORD,,