yta-editor 0.0.1__tar.gz

yta_editor-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-0.0.1/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.3
+Name: yta-editor
+Version: 0.0.1
+Summary: Youtube Autonomous Main Editor
+Author: danialcala94
+Author-email: danielalcalavalera@gmail.com
+Requires-Python: ==3.9
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Requires-Dist: av (>=0.0.1,<19.0.0)
+Requires-Dist: numpy (>=0.0.1,<9.0.0)
+Requires-Dist: pillow (>=0.0.1,<99.0.0)
+Requires-Dist: quicktions (>=0.0.1,<9.0.0)
+Requires-Dist: yta_validation (>=0.0.1,<1.0.0)
+Requires-Dist: yta_video_frame_time (>=0.0.1,<1.0.0)
+Requires-Dist: yta_video_opengl (>=0.0.1,<1.0.0)
+Requires-Dist: yta_video_pyav (>=0.0.1,<1.0.0)
+Description-Content-Type: text/markdown
+
+# Youtube Autonomous Main Editor
+
+The main Editor that works using PyAv and OpenGL.

yta_editor-0.0.1/README.md

@@ -0,0 +1,3 @@
+# Youtube Autonomous Main Editor
+
+The main Editor that works using PyAv and OpenGL.

yta_editor-0.0.1/pyproject.toml

@@ -0,0 +1,32 @@
+[project]
+name = "yta-editor"
+version = "0.0.1"
+description = "Youtube Autonomous Main Editor"
+authors = [
+    {name = "danialcala94",email = "danielalcalavalera@gmail.com"}
+]
+readme = "README.md"
+requires-python = "==3.9"
+dependencies = [
+    "yta_validation (>=0.0.1,<1.0.0)",
+    "yta_video_frame_time (>=0.0.1,<1.0.0)",
+    "yta_video_opengl (>=0.0.1,<1.0.0)",
+    "yta_video_pyav (>=0.0.1,<1.0.0)",
+    "av (>=0.0.1,<19.0.0)",
+    "numpy (>=0.0.1,<9.0.0)",
+    "quicktions (>=0.0.1,<9.0.0)",
+    # I need this 'pillow' just to read an image
+    # and transform into a numpy array to be able
+    # to handle the ImageMedia
+    "pillow (>=0.0.1,<99.0.0)",
+]
+
+[tool.poetry]
+packages = [{include = "yta_editor", from = "src"}]
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.3.5"
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"

yta_editor-0.0.1/src/yta_editor/__init__.py

@@ -0,0 +1,41 @@
+"""
+Our awesome editor module in which we
+have all the classes that interact with
+it and make it possible.
+
+An editor includes a single timeline,
+built by tracks, in which we place media
+elements and we are able to apply effects
+to them.
+
+Here is a brief explanation about the
+hierarchy:
+
+- The editor has a timeline.
+- The timeline has audio and video tracks
+(that can handle when we play or not the
+audio and video).
+- The tracks have parts, that are virtual
+items to simplify the way we combine 
+tracks. Those parts include media 
+instances. The tracks have priorities
+ones against the others.
+- The media instances have a time range
+in which they must be played within the
+track (within the timeline). Those media
+instances have the start and end time
+range for the media source and can apply
+effects to the frames.
+- The media sources are just the way we
+obtain the frames for the specific media
+items (read a file, constant color, etc.).
+"""
+
+def main():
+    from yta_editor.tests import video_modified_stored
+
+    video_modified_stored()
+
+
+if __name__ == '__main__':
+    main()

yta_editor-0.0.1/src/yta_editor/decorators.py

@@ -0,0 +1,33 @@
+from functools import wraps
+
+
+def with_t_adjusted_to_media(
+    method
+):
+    """
+    Get the real 't' time moment based on the
+    video 'start' and 'end'. If they were 
+    asking for the t=0.5s but our video was
+    subclipped to [1.0, 2.0), the 0.5s must be
+    actually the 1.5s of the video because of
+    the subclipped time range.
+
+    The formula:
+    - `t + self.start`
+    """
+    @wraps(method)
+    def wrapper(
+        self,
+        t,
+        *args,
+        **kwargs
+    ):
+        t += self.start
+    
+        print(f'The video/audio real t is {str(float(t))}')
+        if t >= self.end:
+            raise Exception(f'The "t" ({str(t)}) provided is out of range. This video/audio lasts from [{str(self.start)}, {str(self.end)}).')
+        
+        return method(self, t, *args, **kwargs)
+    
+    return wrapper

yta_editor-0.0.1/src/yta_editor/media/__init__.py

@@ -0,0 +1,16 @@
+"""
+Media elements, that are the ones we will
+use and place on the tracks, able to access
+to the frames, using the different sources,
+and to apply the effects we want.
+"""
+# from yta_editor.media.audio import AudioFileMedia
+# from yta_editor.media.video import VideoFileMedia, VideoColorMedia, VideoImageMedia
+
+
+# __all__ = [
+#     'AudioFileMedia',
+#     'VideoFileMedia',
+#     'VideoColorMedia',
+#     'VideoImageMedia',
+# ]

yta_editor-0.0.1/src/yta_editor/media/abstract.py

@@ -0,0 +1,160 @@
+from yta_video_opengl.effects import EffectsStack
+from yta_validation.parameter import ParameterValidator
+from quicktions import Fraction
+from typing import Union
+from abc import ABC, abstractmethod
+
+
+class _Media(ABC):
+    """
+    Abstract class to be inherited by any
+    media element.
+
+    The media element is an element that
+    includes a source and a 'start' and
+    'end' values to be able to subclip that
+    media source and use only the part we
+    want to use.
+    """
+
+    @property
+    @abstractmethod
+    def copy(
+        self
+    ) -> '_Media':
+        """
+        Get a copy of this instance with the same
+        source, time range and effects.
+        """
+        pass
+
+    @property
+    def duration(
+        self
+    ) -> Fraction:
+        """
+        The duration of the media, that can be
+        shorter than the source duration if the
+        user requested it.
+
+        The formula:
+        - `self.end - self.start`
+        """
+        return self.end - self.start
+
+    def __init__(
+        self,
+        source: Union['AudioFileSource', 'AudioNumpySource', 'VideoFileSource', 'VideoColorSource', 'VideoImageSource', 'VideoNumpySource'],
+        start: Union[int, float, Fraction] = 0.0,
+        end: Union[int, float, Fraction, None] = None,
+    ):
+        self.source: Union['AudioFileSource', 'AudioNumpySource', 'VideoFileSource', 'VideoColorSource', 'VideoImageSource', 'VideoNumpySource'] = source
+        """
+        The source of this media element that
+        is the entity from which we can obtain
+        the frames.
+        """
+        self._effects: EffectsStack = EffectsStack()
+        """
+        The effects we want to apply on the
+        media.
+        """
+        self.start: Fraction
+        """
+        The time moment 't' in which the media
+        should start being played/displayed.
+        """
+        self.end: Union[Fraction, None]
+        """
+        The time moment 't' in which the media
+        should end being played/displayed.
+        """
+        
+        # Set 'start' and 'end'
+        self.set_time_range(start, end)
+
+    def set_time_range(
+        self,
+        start: Union[int, float, Fraction],
+        end: Union[int, float, Fraction, None] = None,
+    ) -> '_Media':
+        """
+        Set the media 'start' and 'end' time
+        moments range from the original source
+        that will be played/displayed.
+
+        - If `end = None`, the source duration
+        (if available) will be set.
+        - If `end > source.duration` it will be
+        replaced by the source duration value.
+        """
+        ParameterValidator.validate_mandatory_positive_number('start', start, do_include_zero = True)
+        ParameterValidator.validate_positive_number('end', end, do_include_zero = False)
+
+        self.start: Fraction = Fraction(start)
+        self.end: Union[Fraction, None] = Fraction(
+            # TODO: Is this 'end' ok (?)
+            self.source.duration
+            if (
+                end is None or
+                end > self.source.duration
+            ) else
+            end
+        )
+
+        # If the source has a duration, the 'start'
+        # and 'end' must be valid
+        if self.source.duration is not None:
+            if (
+                self.start >= self.source.duration and
+                self.end >= self.source.duration
+            ):
+                raise Exception(f'The provided "start" and "end" are invalid values considering the real media duration of {str(float(self.source.duration))}s')
+            
+            if self.end <= self.start:
+                raise Exception('The "end" value cannot be equal or smaller than the "start" value.')
+            
+            self.end = (
+                self.source.duration
+                if self.end > self.source.duration else
+                self.end
+            )
+
+        return self
+    
+    # TODO: This method has been created
+    # to be inherited by the other classes
+    # and being able to copy the instance
+    # properly by using the same 'source'
+    # reference and creating not a new one
+    @classmethod
+    def _init_with_source(
+        cls,
+        source: Union['AudioFileSource', 'AudioNumpySource', 'VideoFileSource', 'VideoColorSource', 'VideoImageSource', 'VideoNumpySource'],
+        start: Union[int, float, Fraction] = 0.0,
+        end: Union[int, float, Fraction, None] = None
+    ):
+        """
+        *For internal use only*
+
+        Alternative '__init__' to create the
+        instance from the 'source' directly. This
+        method must be called by the specific
+        implementations of this abstract class
+        to be able to instantiate them directly
+        from the 'source' to make copies.
+
+        We created this method to avoid generating
+        a new 'source' instance but preserving the
+        same reference.
+        """
+        # Create new instance skipping '__init__'
+        instance = cls.__new__(cls)
+        super(cls, instance).__init__(
+            source = source,
+            start = start,
+            end = end
+        )
+
+        return instance
+

yta_editor-0.0.1/src/yta_editor/media/audio/__init__.py

@@ -0,0 +1,140 @@
+from yta_editor.media.abstract import _Media
+from yta_editor.sources.abstract import _AudioSource
+from yta_editor.sources.audio import AudioFileSource, AudioNumpySource
+from yta_editor.decorators import with_t_adjusted_to_media
+from yta_editor.utils import apply_audio_effects_to_frame_at_t
+from yta_video_opengl.nodes import TimedNode
+from yta_validation.parameter import ParameterValidator
+from quicktions import Fraction
+from typing import Union
+
+
+class _AudioMedia(_Media):
+    """
+    Abstract class to be inherited by any
+    media element.
+
+    The media element is an element that
+    includes a source and a 'start' and
+    'end' values to be able to subclip that
+    media source and use only the part we
+    want to use.
+    """
+
+    def __init__(
+        self,
+        source: _AudioSource,
+        start: Union[int, float, Fraction] = 0.0,
+        end: Union[int, float, Fraction, None] = None,
+    ):
+        super().__init__(
+            source = source,
+            start = start,
+            end = end
+        )
+
+    def add_effect(
+        self,
+        effect: TimedNode
+    ) -> '_AudioMedia':
+        """
+        Add the provided 'effect' to the audio.
+        """
+        ParameterValidator.validate_mandatory_instance_of('effect', effect, 'TimedNode')
+
+        if not effect.is_audio_node:
+            raise Exception('The provided "effect" is not an audio effect.')
+
+        self._effects.add_effect(effect)
+        
+        return self
+    
+    @with_t_adjusted_to_media
+    def get_audio_frames_at_t(
+        self,
+        t: Union[int, float, Fraction],
+        video_fps: Union[int, float, Fraction]
+    ):
+        """
+        Get the sequence of audio frames for a 
+        given video 't' time moment, using the
+        audio cache system.
+
+        This is useful when we want to write a
+        video frame with its audio, so we obtain
+        all the audio frames associated to it
+        (remember that a video frame is associated
+        with more than 1 audio frame).
+        """
+        print(f'Getting audio frames from {str(float(t + self.start))} that is actually {str(float(t))}')
+        for frame in self.source.get_audio_frames_at_t(t, video_fps):
+            yield apply_audio_effects_to_frame_at_t(
+                effects_stack = self._effects,
+                frame = frame,
+                t = t
+            )
+
+class AudioFileMedia(_AudioMedia):
+    """
+    An audio media that is read from an audio
+    file.
+    """
+
+    @property
+    def copy(
+        self
+    ) -> 'AudioFileMedia':
+        """
+        Get a copy of this instance with the same
+        source, time range and effects.
+        """
+        copy = AudioFileMedia._init_with_source(
+            source = self.source,
+            start = self.start,
+            end = self.end
+        )
+
+        copy._effects = self._effects.copy
+
+        return copy
+
+    @property
+    def duration(
+        self
+    ) -> Fraction:
+        """
+        The duration of the video.
+        """
+        return self.end - self.start
+    
+    @property
+    def audio_fps(
+        self
+    ) -> Union[int, None]:
+        """
+        The frames per second of the audio.
+        """
+        return self.source.audio_fps
+    
+    @property
+    def audio_time_base(
+        self
+    ) -> Union[Fraction, None]:
+        """
+        The time base of the audio.
+        """
+        return self.source.audio_time_base
+    
+    def __init__(
+        self,
+        filename: str,
+        start: Union[int, float, Fraction] = 0.0,
+        end: Union[int, float, Fraction, None] = None,
+    ):
+        super().__init__(
+            source = AudioFileSource(filename),
+            start = start,
+            end = end
+        )
+
+# TODO: Create 'AudioNumpyMedia'