yta-editor-parameters 0.0.5__py3-none-any.whl

yta_editor_parameters/__init__.py

@@ -0,0 +1,13 @@
+"""
+Module to include the functionality related to the
+parameters and how we define them to be used in our
+'yta-editor' video editor library.
+"""
+from yta_editor_parameters.constant import ConstantVideoEditorParameter
+from yta_editor_parameters.eased import EasedVideoEditorParameter
+
+
+__all__ = [
+    'ConstantVideoEditorParameter',
+    'EasedVideoEditorParameter'
+]

yta_editor_parameters/abstract.py

@@ -0,0 +1,18 @@
+from yta_editor_parameters.context import VideoEditorEvaluationContext
+from yta_parameters.abstract import Parameter
+from abc import abstractmethod
+
+
+class VideoEditorParameter(Parameter):
+    """
+    A parameter that uses a video editor context
+    to be evaluated.
+    """
+
+    @abstractmethod
+    def evaluate(
+        self,
+        # This is mandatory, even though it is not used
+        evaluation_context: VideoEditorEvaluationContext
+    ):
+        pass

yta_editor_parameters/constant.py

@@ -0,0 +1,26 @@
+from yta_editor_parameters.context import VideoEditorEvaluationContext
+from yta_editor_parameters.abstract import VideoEditorParameter
+from yta_parameters.types import BASIC_NON_ITERABLE_TYPE
+
+
+class ConstantVideoEditorParameter(VideoEditorParameter):
+    """
+    A parameter that has always the same value and
+    is unaware of the context.
+    """
+
+    def __init__(
+        self,
+        value: BASIC_NON_ITERABLE_TYPE
+    ):
+        self.value: BASIC_NON_ITERABLE_TYPE = value
+        """
+        The constant value of this parameter.
+        """
+
+    def evaluate(
+        self,
+        # This is mandatory, even though it is not used
+        evaluation_context: VideoEditorEvaluationContext
+    ):
+        return self.value

yta_editor_parameters/context/__init__.py

@@ -0,0 +1,109 @@
+from yta_parameters.context.abstract import EvaluationContext
+from typing import Union
+
+
+class VideoEditorEvaluationContext(EvaluationContext):
+    """
+    Evaluation context that includes all the parameters
+    needed to be able to evaluate the parameter for a
+    video editor, including information about the local
+    and global time moment, the frame index and the
+    total number of frames of the local item, or the fps
+    of the video.
+    """
+
+    # We should not accept 'None' to be more strict
+    # and build always the context with all the info
+    def __init__(
+        self,
+        t_normalized: float,
+        t: Union[float, None] = None,
+        t_global_normalized: Union[float, None] = None,
+        t_global: Union[float, None] = None,
+        frame_index: Union[int, None] = None,
+        # TODO: This value is not clear at all
+        number_of_frames: Union[int, None] = None,
+        fps: Union[float, None] = None
+    ):
+        # Local time
+        self.t_normalized: float = t_normalized
+        """
+        The local normalized time moment in which the
+        parameter must be evaluated, that is based on
+        the segment or item in which the parameter is
+        being used. This can be a transition, a node,
+        etc.
+
+        A value in the `[0.0, 1.0]` range representing
+        the progress of the local item.
+        """
+        self.t: Union[float, None] = t
+        """
+        The local not normalized time moment in which
+        the parameter must be evaluated, that is based
+        on the segment or item in which the parameter
+        is being used. This can be a a transition, a
+        node, etc.
+
+        The time (in seconds) elapsed since the
+        `t_start` of the local item.
+        """
+
+        # Global (track) time
+        self.t_global_normalized: Union[float, None] = t_global_normalized
+        """
+        The global normalized time moment that is
+        useful to compare the `t` with it. This is
+        based on the global timeline in which the
+        element that includes t he parameter is placed.
+
+        A value in the `[0.0, 1.0]` range representing
+        the progress of the global track.
+        """
+        self.t_global: Union[float, None] = t_global
+        """
+        The global not normalized time moment that is
+        useful to compare the `t` with it. This is
+        based on the global timeline in which the
+        element that includes the parameter is placed.
+
+        The time (in seconds) elapsed since the
+        `t_start` of the global track.
+        """
+
+        # Frame (local) indexes
+        self.frame_index: Union[int, None] = frame_index
+        """
+        The index of the frame in which the parameter
+        is being evaluated.
+
+        The index according to the local item.
+        """
+        self.number_of_frames: Union[int, None] = number_of_frames
+        """
+        The total number of frames of the local item.
+        """
+
+        self.fps: Union[float, None] = fps
+        """
+        The number of frames per seconds that are being
+        used for the video in which the element this
+        parameter belongs to is being evaluated.
+        """
+
+"""
+Other fields that could be interesting (?):
+
+self.node_outputs = node_outputs
+self.curves = curves
+self.backend = backend
+    
+INTERESTING VALUES:
+Tiempo
+Frame index
+FPS
+Resolución
+Seed
+Flags de ejecución
+Cualquier metadata futura
+"""

yta_editor_parameters/eased.py

@@ -0,0 +1,65 @@
+from yta_editor_parameters.abstract import VideoEditorParameter
+from yta_editor_parameters.context import VideoEditorEvaluationContext
+from yta_math_easings.abstract import EasingFunctionName
+from yta_math_easings.animated.abstract import EasingAnimatedFunction
+from typing import Union
+
+
+class EasedVideoEditorParameter(VideoEditorParameter):
+    """
+    A parameter to be used within a video editor context
+    that uses easing functions to calculate the values.
+    """
+
+    @property
+    def start_value(
+        self
+    ) -> float:
+        """
+        The start value of this eased parameter.
+        """
+        return self._easing_animated_function.start_value
+    
+    @property
+    def end_value(
+        self
+    ) -> float:
+        """
+        The end value of this eased parameter.
+        """
+        return self._easing_animated_function.end_value
+
+    def __init__(
+        self,
+        start_value: float,
+        end_value: float,
+        easing_function_name: Union[EasingFunctionName, str] = 'linear'
+    ):
+        easing_function_name = EasingFunctionName.to_enum(easing_function_name)
+
+        self._easing_animated_function: EasingAnimatedFunction = EasingAnimatedFunction.get(easing_function_name)(
+            start_value = start_value,
+            end_value = end_value
+            # By now the 'duration' is not important at all
+        )
+        """
+        *For internal use only*
+
+        The internal easing animated function that will be
+        able to calculate the values.
+        """
+
+    def evaluate(
+        self,
+        evaluation_context: VideoEditorEvaluationContext,
+    ) -> float:
+        """
+        Get the value using the `evaluation_context`
+        provided.
+
+        This method will return the real not normalized
+        value.
+        """
+        return self._easing_animated_function.get_value_from_t_normalized(
+            t_normalized = evaluation_context.t_normalized
+        )

yta_editor_parameters/utils.py

@@ -0,0 +1,39 @@
+from yta_editor_parameters.abstract import VideoEditorParameter
+from yta_editor_parameters import ConstantVideoEditorParameter
+from yta_validation import PythonValidator
+
+
+def parse_parameters(
+    parameters: dict
+) -> dict[str, 'VideoEditorParameter']:
+    """
+    Parse the `parameters` provided and raise an exception
+    if some of them is unaccepted. It will transform the
+    basic types into `ConstantVideoEditorParameter`
+    instances, and return the new dict with the values
+    transformed.
+
+    These types will be transformed into constant values:
+    - `int`
+    - `float`
+    - `bool`
+    - `str`
+    - `None`
+    """
+    parameters_parsed = {}
+
+    for name, value in parameters.items():
+        if PythonValidator.is_instance_of(value, VideoEditorParameter):
+            parameters_parsed[name] = value
+            continue
+
+        if (
+            PythonValidator.is_basic_non_iterable_type(value) or
+            value is None
+        ):
+            parameters_parsed[name] = ConstantVideoEditorParameter(value)
+            continue
+        
+        raise Exception(f'The "{name}" parameter is not a "VideoEditorParameter" nor a basic and non iterable type')
+
+    return parameters_parsed

yta_editor_parameters-0.0.5.dist-info/METADATA

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: yta-editor-parameters
+Version: 0.0.5
+Summary: Youtube Autonomous Editor Parameters 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: yta_parameters (>=0.0.1,<1.0.0)
+Requires-Dist: yta_validation (>=0.0.1,<1.0.0)
+Description-Content-Type: text/markdown
+
+# Youtube Autonomous Editor Parameters Module
+
+The module related to the parameters and how we define them to be used in the video editor 'yta-editor'.

yta_editor_parameters-0.0.5.dist-info/RECORD

@@ -0,0 +1,10 @@
+yta_editor_parameters/__init__.py,sha256=XGakjObV8mHolgzdmjKaIMyUb0O4teMe77lur7nWZUI,379
+yta_editor_parameters/abstract.py,sha256=1JytolMQYj6ZOWSvu1g11etTbCcMTpP7VHImEgYZJkA,477
+yta_editor_parameters/constant.py,sha256=SwnoFnlRFru9P8wNqJQhKbH5zt4204vjqBMCMopOuh8,754
+yta_editor_parameters/context/__init__.py,sha256=ibjdlSGd01UwkWvXytXKhZEDorfKbVNj_-gDUARbCNo,3525
+yta_editor_parameters/eased.py,sha256=-e-dSeBR6Q0AQIt9hlTTZjBwqC30ATMA8mM8SwySQXI,2003
+yta_editor_parameters/utils.py,sha256=Bt059pyYBYXQW-__aD1UQV60kDxxNIOuqAdbsWlB4Rg,1246
+yta_editor_parameters-0.0.5.dist-info/licenses/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
+yta_editor_parameters-0.0.5.dist-info/METADATA,sha256=FnpGlvRadqXpAEKfi1KXinNuvHb0biW2xl-VC2wbVlo,613
+yta_editor_parameters-0.0.5.dist-info/WHEEL,sha256=M5asmiAlL6HEcOq52Yi5mmk9KmTVjY2RDPtO4p9DMrc,88
+yta_editor_parameters-0.0.5.dist-info/RECORD,,

yta_editor_parameters-0.0.5.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.2.0
+Root-Is-Purelib: true
+Tag: py3-none-any

yta_editor_parameters-0.0.5.dist-info/licenses/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.