yta-video-frame-time 0.0.1__tar.gz → 0.0.14__tar.gz

{yta_video_frame_time-0.0.1 → yta_video_frame_time-0.0.14}/PKG-INFO

@@ -1,12 +1,14 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: yta-video-frame-time
-Version: 0.0.1
+Version: 0.0.14
 Summary: Youtube Autonomous Video Frame Time 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: quicktions (>=0.0.1,<9.0.0)
 Requires-Dist: yta_validation (>=0.0.1,<1.0.0)
 Description-Content-Type: text/markdown
 

{yta_video_frame_time-0.0.1 → yta_video_frame_time-0.0.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "yta-video-frame-time"
-version = "0.0.1"
+version = "0.0.14"
 description = "Youtube Autonomous Video Frame Time Module"
 authors = [
     {name = "danialcala94",email = "danielalcalavalera@gmail.com"}
@@ -9,6 +9,7 @@ readme = "README.md"
 requires-python = "==3.9"
 dependencies = [
     "yta_validation (>=0.0.1,<1.0.0)",
+    "quicktions (>=0.0.1,<9.0.0)"
 ]
 
 [tool.poetry]
@@ -16,6 +17,7 @@ packages = [{include = "yta_video_frame_time", from = "src"}]
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^8.3.5"
+yta_testing = ">=0.0.1"
 
 [build-system]
 requires = ["poetry-core>=2.0.0,<3.0.0"]

{yta_video_frame_time-0.0.1 → yta_video_frame_time-0.0.14}/src/yta_video_frame_time/__init__.py

@@ -2,6 +2,7 @@
 Module to handle frame indexes and times.
 """
 from yta_validation.parameter import ParameterValidator
+from typing import Union
 
 
 SMALL_AMOUNT_TO_FIX = 0.0000000001
@@ -14,7 +15,6 @@ be 10 frames and it is happening due to a minimal
 floating point difference.
 """
 
-
 class T:
     """
     Class to wrap the functionality related
@@ -36,11 +36,13 @@ class T:
         ParameterValidator.validate_mandatory_positive_number('t', t, do_include_zero = True)
         ParameterValidator.validate_mandatory_positive_number('fps', fps, do_include_zero = False)
 
-        return T.frame_time_to_frame_index(t, fps) / fps + SMALL_AMOUNT_TO_FIX
-
+        return T.video_frame_time_to_video_frame_index(t, fps) / fps + SMALL_AMOUNT_TO_FIX
+    
     def get_frame_indexes(
         duration: float,
         fps: float,
+        start: Union[float, None] = None,
+        end: Union[float, None] = None,
         do_invert_order: bool = False
     ):
         """
@@ -59,6 +61,28 @@ class T:
         # If you remove 'list' you get a generator instead
         frame_indexes = list(range(get_number_of_frames(duration, fps)))
 
+        # TODO: Maybe move this to a helper (?)
+        # Limit to ['start', 'end'] range
+        if (
+            start is not None or
+            end is not None
+        ):
+            start = (
+                T.video_frame_time_to_video_frame_index(start, fps)
+                if start is not None else
+                0.0
+            )
+            end = (
+                T.video_frame_time_to_video_frame_index(end, fps)
+                if end is not None else
+                9999999999
+            )
+            frame_indexes = [
+                frame_index
+                for frame_index in frame_indexes
+                if start <= frame_index < end
+            ]
+
         return (
             frame_indexes[::-1]
             if do_invert_order else
@@ -286,6 +310,8 @@ class T:
     def get_frame_time_moments(
         duration: float,
         fps: float,
+        start: Union[float, None] = None,
+        end: Union[float, None] = None,
         do_invert_order: bool = False
     ):
         """
@@ -313,6 +339,28 @@ class T:
             for i in range(get_number_of_frames(duration, fps) + 1)
         ][:-1]
 
+        # TODO: Maybe move this to a helper (?)
+        # Limit to ['start', 'end'] range
+        if (
+            start is not None or
+            end is not None
+        ):
+            start = (
+                start
+                if start is not None else
+                0.0
+            )
+            end = (
+                end
+                if end is not None else
+                9999999999
+            )
+            frame_time_moments = [
+                frame_time_moment
+                for frame_time_moment in frame_time_moments
+                if start <= frame_time_moment < end
+            ]
+
         return (
             frame_time_moments[::-1]
             if do_invert_order else
@@ -409,19 +457,20 @@ class T:
         ParameterValidator.validate_mandatory_positive_number('audio_fps', audio_fps, do_include_zero = False)
         ParameterValidator.validate_mandatory_bool('do_invert_order', do_invert_order)
 
-        from yta_general_utils.math.progression import Progression
-
         audio_frames_per_video_frame = int(audio_fps / video_fps)
         audio_frame_duration = 1 / audio_fps
         video_frame_duration = 1 / video_fps
 
         t = T.get_frame_time_base(video_t, video_fps)
 
-        audio_time_moments = Progression(
-            start = t, 
+        # This is replacing a 'Progression' from
+        # the 'yta_general_utils' library because
+        # it has many imports we don't want here...
+        audio_time_moments = _linspace(
+            start = t,
             end = t + video_frame_duration - audio_frame_duration,
             n = audio_frames_per_video_frame
-        ).values
+        )
 
         return (
             audio_time_moments[::-1]
@@ -540,4 +589,29 @@ def get_number_of_frames(
     The formula is:
     - `int(duration * fps + SMALL_AMOUNT)`
     """
-    return int(duration * fps + SMALL_AMOUNT_TO_FIX)
+    return int(duration * fps + SMALL_AMOUNT_TO_FIX)
+
+def _linspace(
+    start: float,
+    end: float,
+    n: int,
+):
+    """
+    *For internal use only*
+
+    A simplified version of the 'Progression'
+    class we have in 'yta_general_utils', to
+    avoid importing that library that has other
+    dependencies I don't need here.
+
+    This method should be removed when the
+    Progression class is refactored and all 
+    those dependencies are removed.
+    """
+    if n < 2:
+        raise Exception('The "n" parameter must be greater or equal than 2.')
+
+    return [
+        start + i * ((end - start) / (n - 1))
+        for i in range(n)
+    ]

yta_video_frame_time-0.0.14/src/yta_video_frame_time/decorators.py

@@ -0,0 +1,52 @@
+"""
+TODO: I think this module should not be here, or maybe
+yes, but I need this decorator.
+"""
+from functools import wraps
+
+
+def parameter_to_time_interval(
+    param_name: str
+):
+    """
+    Force the parameter with the given `param_name` to
+    be a `TimeInterval` instance.
+
+    Values accepted:
+    - `TimeInterval` instance
+    - `tuple[float, float]` that will be `(start, end)`
+    """
+    def decorator(
+        func
+    ):
+        @wraps(func)
+        def wrapper(
+            *args,
+            **kwargs
+        ):
+            from inspect import signature
+            from yta_validation import PythonValidator
+            from yta_video_frame_time.interval import TimeInterval
+
+            sig = signature(func)
+            bound = sig.bind(*args, **kwargs)
+            bound.apply_defaults()
+
+            value = bound.arguments[param_name]
+
+            if PythonValidator.is_instance_of(value, TimeInterval):
+                pass
+            elif (
+                PythonValidator.is_tuple(value) and
+                len(value) == 2
+            ):
+                value = TimeInterval(*value)
+                bound.arguments[param_name] = value
+            else:
+                raise Exception(f'The "{param_name}" parameter must be a TimeInterval or a tuple[float, float].')
+
+            return func(*bound.args, **bound.kwargs)
+        
+        return wrapper
+    
+    return decorator