yta-video-frame-time 0.0.6__tar.gz → 0.0.7__tar.gz

{yta_video_frame_time-0.0.6 → yta_video_frame_time-0.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: yta-video-frame-time
-Version: 0.0.6
+Version: 0.0.7
 Summary: Youtube Autonomous Video Frame Time Module
 Author: danialcala94
 Author-email: danielalcalavalera@gmail.com

{yta_video_frame_time-0.0.6 → yta_video_frame_time-0.0.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "yta-video-frame-time"
-version = "0.0.6"
+version = "0.0.7"
 description = "Youtube Autonomous Video Frame Time Module"
 authors = [
     {name = "danialcala94",email = "danielalcalavalera@gmail.com"}

{yta_video_frame_time-0.0.6 → yta_video_frame_time-0.0.7}/src/yta_video_frame_time/t_fraction.py

@@ -302,6 +302,9 @@ class _T:
         None, we will not make any conversion
         and the value received could be useless
         because it is in the middle of a range.
+
+        The formula:
+        - `pts * time_base`
         """
         pts = (
             self._t_handler.pts.truncated(pts)
@@ -322,8 +325,47 @@ class _T:
         Transform the given 't' to a 'pts' value
         truncating, rounding or applying no 
         variation.
+
+        The formula:
+        - `int(t / time_base)`
         """
         return self._t_handler.pts.from_t(t, do_truncate)
+    
+    def to_index(
+        self,
+        t: Union[int, float, Fraction],
+        do_truncate: Union[bool, None] = True
+    ) -> int:
+        """
+        Transform the given 't' to a index value
+        truncating, rounding or applying no
+        variation.
+
+        The formula:
+        - `int(t * fps)`
+        """
+        t = (
+            self.truncated(t)
+            if do_truncate is True else
+            self.rounded(t)
+            if do_truncate is False else
+            t
+        )
+
+        return frame_t_to_index(t, self.fps)
+    
+    def from_index(
+        self,
+        index: int
+    ) -> Fraction:
+        """
+        Transform the given index to a 't' time
+        moment value.
+
+        The formula:
+        - `frame_index * (1 / fps)`
+        """
+        return frame_index_to_t(index, self.fps)
 
     def truncated(
         self,
@@ -367,6 +409,9 @@ class _T:
 
         Useful when you need the next value for a
         range in an iteration or similar.
+
+        The formula:
+        - `t + n * (1 / fps)`
         """
         t = (
             self.truncated(t)
@@ -374,7 +419,7 @@ class _T:
             self.rounded(t)
         )
 
-        return t + n * self._t_handler.time_base
+        return t + n * (1 / self._t_handler.fps)
     
     def previous(
         self,
@@ -395,6 +440,9 @@ class _T:
         Be careful, if the 'truncated' value is 0
         this will give you an unexpected negative
         value.
+
+        The formula:
+        - `t - n * (1 / fps)`
         """
         t = (
             self.truncated(t)
@@ -402,7 +450,7 @@ class _T:
             self.rounded(t)
         )
 
-        return t - n * self._t_handler.time_base
+        return t - n * (1 / self._t_handler.fps)
     
 class _Pts:
     """
@@ -442,6 +490,9 @@ class _Pts:
         None, we will not make any conversion
         and the value received could be useless
         because it is in the middle of a range.
+
+        The formula:
+        - `int(t / time_base)`
         """
         t = (
             self._t_handler.t.truncated(t)
@@ -462,8 +513,45 @@ class _Pts:
         Transform the given 'pts' to a 't' value
         truncating, rounding or applying no 
         variation.
+
+        The formula:
+        - `pts * time_base`
         """
         return self._t_handler.t.from_pts(pts, do_truncate)
+    
+    def to_index(
+        self,
+        pts: int,
+        do_truncate: Union[bool, None] = True
+    ) -> int:
+        """
+        Transform the given 'pts' to a index value
+        truncating, rounding or applying no
+        variation.
+
+        The formula:
+        - `int((pts * time_base) * fps)`
+        """
+        return self._t_handler.t.to_index(
+            self.to_t(pts, do_truncate = None),
+            do_truncate = do_truncate
+        )
+    
+    def from_index(
+        self,
+        index: int
+    ) -> Fraction:
+        """
+        Transform the given index to a 't' time
+        moment value.
+
+        The formula:
+        - `int((frame_index * (1 / fps)) * time_base)`
+        """
+        return self.from_t(
+            t = self._t_handler.t.from_index(index),
+            do_truncate = True
+        )
 
     def truncated(
         self,
@@ -517,6 +605,9 @@ class _Pts:
 
         Useful when you need the next value for a
         range in an iteration or similar.
+
+        The formula:
+        - `pts + n * ticks_per_frame`
         """
         pts = (
             self.truncated(pts)
@@ -545,6 +636,9 @@ class _Pts:
         Be careful, if the 'truncated' value is 0
         this will give you an unexpected negative
         value.
+
+        The formula:
+        - `pts - n * ticks_per_frame`
         """
         pts = (
             self.truncated(pts)
@@ -680,6 +774,9 @@ def get_ticks_per_frame(
     tick is the minimum amount of time we
     spend from one frame to the next.
 
+    (!) This is only valid for video
+    apparently.
+
     The formula:
     - `1 / (fps * time_base)`
     """