yta-video-frame-time 0.0.19__py3-none-any.whl → 0.0.24__py3-none-any.whl

yta_video_frame_time/interval.py

@@ -112,6 +112,7 @@ class TimeInterval:
         end: Number,
         start_limit: Union[Number, None] = None,
         end_limit: Union[Number, None] = None,
+        duration_limit: Union[Number, None] = None,
         fps: Union[Number, None] = None
     ):
         """
@@ -129,6 +130,7 @@ class TimeInterval:
         ParameterValidator.validate_mandatory_positive_number('end', end, do_include_zero = False)
         ParameterValidator.validate_positive_number('start_limit', start_limit, do_include_zero = True)
         ParameterValidator.validate_positive_number('end_limit', end_limit, do_include_zero = False)
+        ParameterValidator.validate_positive_number('duration_limit', end_limit, do_include_zero = False)
 
         self.fps: Union[Number, None] = fps
         """
@@ -159,11 +161,23 @@ class TimeInterval:
             end_limit
         )
 
+        duration_limit = self._truncate(
+            TIME_INTERVAL_SYSTEM_LIMITS[1]
+            if duration_limit is None else
+            duration_limit
+        )
+
         if start_limit < TIME_INTERVAL_SYSTEM_LIMITS[0]:
-            raise Exception(f'The `start_limit` provided ({str(float(start_limit))}) is lower than the system limit ({str(float(TIME_INTERVAL_SYSTEM_LIMITS[0]))})')
+            raise Exception(f'The `start_limit` ({str(float(start_limit))}) is lower than the system limit ({str(float(TIME_INTERVAL_SYSTEM_LIMITS[0]))})')
         
         if end_limit > TIME_INTERVAL_SYSTEM_LIMITS[1]:
-            raise Exception(f'The `end_limit` provided ({str(float(end_limit))}) is greater than the system limit ({str(float(TIME_INTERVAL_SYSTEM_LIMITS[1]))})')
+            raise Exception(f'The `end_limit` ({str(float(end_limit))}) is greater than the system limit ({str(float(TIME_INTERVAL_SYSTEM_LIMITS[1]))})')
+        
+        if end_limit < start_limit:
+            raise Exception(f'The `end_limit` ({str(float(end_limit))}) is greater than the `start_limit` ({str(float(start_limit))})')
+        
+        if duration_limit > TIME_INTERVAL_SYSTEM_LIMITS[1]:
+            raise Exception(f'The `duration_limit` ({str(float(duration_limit))}) is greater than the system limit ({str(float(TIME_INTERVAL_SYSTEM_LIMITS[1]))})')
         
         self.start_limit: Fraction = start_limit
         """
@@ -181,6 +195,17 @@ class TimeInterval:
         will be used to raise exceptions if any of the `end`
         values goes beyond this limit.
 
+        See the `TIME_INTERVAL_SYSTEM_LIMITS[1]` variable to
+        know the limit defined by the system that will be
+        applied if the user doesn't provided his own limit.
+        """
+        self.duration_limit: Fraction = duration_limit
+        """
+        The limit for the `duration` of this time interval,
+        which will be used to raise exceptions if this
+        duration is exceeded when modifying the `start` and/or
+        `end` values of this time interval.
+
         See the `TIME_INTERVAL_SYSTEM_LIMITS[1]` variable to
         know the limit defined by the system that will be
         applied if the user doesn't provided his own limit.
@@ -195,12 +220,13 @@ class TimeInterval:
         The current `end` value of this time interval.
         """
 
-        self._validate_start(self.start)
-        self._validate_end(self.end)
+        self._validate_start()
+        self._validate_end()
+        self._validate_duration()
 
     def _validate_start(
         self,
-        start: Union[Number, None]
+        start: Union[Number, None] = None
     ) -> None:
         """
         *For internal use only*
@@ -209,18 +235,27 @@ class TimeInterval:
         time interval and the system based on the limits and the
         value of the `end` parameter also.
 
+        If the `start` parameter provided is None, the current `start`
+        value will be used instead.
+
         This method will raise an exception if the provided value is
         not valid.
         """
+        start = (
+            self.start
+            if start is None else
+            start
+        )
+
         if start >= self.end:
-            raise Exception(f'The `start` value provided ({str(float(start))}) is greater or equal to the current`end` value ({str(float(self.end))}).')
+            raise Exception(f'The `start` value ({str(float(start))}) is greater or equal to the current `end` value ({str(float(self.end))}).')
         
         if start < self.start_limit:
-            raise Exception(f'The `start` value provided ({str(float(start))}) is lower than the `start_limit` ({str(float(self.start_limit))}).')
+            raise Exception(f'The `start` value ({str(float(start))}) is lower than the `start_limit` ({str(float(self.start_limit))}).')
         
     def _validate_end(
         self,
-        end: Union[Number, None]
+        end: Union[Number, None] = None
     ) -> None:
         """
         *For internal use only*
@@ -229,14 +264,49 @@ class TimeInterval:
         time interval and the system based on the limits and the
         value of the `start` parameter also.
 
+        If the `end` parameter provided is None, the current `end`
+        value will be used instead.
+
         This method will raise an exception if the provided value is
         not valid.
         """
+        end = (
+            self.end
+            if end is None else
+            end
+        )
+
         if end <= self.start:
-            raise Exception(f'The `end` value provided ({str(float(end))}) is lower or equal to the current`start` value ({str(float(self.start))}).')
+            raise Exception(f'The `end` value ({str(float(end))}) is lower or equal to the current `start` value ({str(float(self.start))}).')
         
         if end > self.end_limit:
-            raise Exception(f'The `end` value provided ({str(float(end))}) is greater than the `end_limit` ({str(float(self.end_limit))}).')
+            raise Exception(f'The `end` value ({str(float(end))}) is greater than the `end_limit` ({str(float(self.end_limit))}).')
+        
+    def _validate_duration(
+        self,
+        duration: Union[Number, None] = None
+    ) -> None:
+        """
+        *For internal use only*
+
+        Validate that the `duration` value provided is accepted by
+        the time interval and the system based on the limit set
+        when creating this instance.
+
+        If the `duration` parameter provided is None, the current
+        `duration` value will be used instead.
+
+        This method will raise an exception if the provided value is
+        not valid.
+        """
+        duration = (
+            self.duration
+            if duration is None else
+            duration
+        )
+
+        if duration > self.duration_limit:
+            raise Exception(f'The `duration` ({str(float(duration))}) is greater than the `duration_limit` ({str(float(self.duration_limit))}).')
 
     """
     Apparently, the professional video editors use always
@@ -448,6 +518,39 @@ class TimeInterval:
         )
 
     # Modifying 'start' and 'end' below
+    def shift(
+        self,
+        delta: Number
+    ) -> 'TimeInterval':
+        """
+        (!) This method will modify this instance.
+
+        Move the `start` and the `end` by applying the `delta`
+        amount (that will be forced to be a multiple of `1/fps`)
+        but modifying not the duration.
+
+        This can only be done if the new `start` and `end` values
+        are in between  the limits.
+        """
+        delta = self._truncate(delta)
+
+        if delta == 0:
+            return self
+
+        new_start = self.start + delta
+        new_end = self.end + delta
+        
+        if delta > 0:
+            self._validate_end(new_end)
+            self._validate_start(new_start)
+        else:
+            self._validate_start(new_start)
+            self._validate_end(new_end)
+        
+        self.start = new_start
+        self.end = new_end
+
+        return self
 
     def get_cuts(
         self,
@@ -533,16 +636,16 @@ class TimeInterval:
     # TODO: Rename, please
     def get_trim_starts(
         self,
-        t_variation: Number
+        delta: Number
     ) -> tuple['TimeInterval', 'TimeInterval']:
         """
         Get a tuple containing the 2 new `TimeInterval` instances
         generated by trimming this one's start the amount of seconds
-        provided as the `t_variation` parameter. The first tuple is
+        provided as the `delta` parameter. The first tuple is
         the remaining, and the second one is the new time interval
         requested by the user.
 
-        (!) The `t_variation` value provided will be transformed into
+        (!) The `delta` value provided will be transformed into
         a multiple of `1/fps` of this instance, and truncated to fit
         the `start` of the time interval the new segments will belong
         to, if the `fps` is set.
@@ -552,24 +655,24 @@ class TimeInterval:
         `limit`, that must be greater than the `start` and lower
         than the time interval `end` value.
 
-        The `t_variation` must be a positive value, the amount of
+        The `delta` must be a positive value, the amount of
         seconds to be trimmed.
         """
         return self._cutter.trim_start(
             time_interval = self,
-            t_variation = self._truncate(t_variation)
+            delta = self._truncate(delta)
         )
     
     # TODO: Rename, please
     def get_trim_start(
         self,
-        t_variation: Number
+        delta: Number
     ) -> 'TimeInterval':
         """
         Get this time interval instance but trimmed from the `start`
-        the `t_variation` amount of seconds provided.
+        the `delta` amount of seconds provided.
 
-        (!) The `t_variation` value provided will be transformed into
+        (!) The `delta` value provided will be transformed into
         a multiple of `1/fps` of this instance, and truncated to fit
         the `start` of the time interval the new segments will belong
         to, if the `fps` is set.
@@ -578,65 +681,68 @@ class TimeInterval:
         returns a new one.
         """
         return self.get_trim_starts(
-            t_variation = t_variation
+            delta = delta
         )[1]
     
     def _trim_start(
         self,
-        t_variation: Number
+        delta: Number
     ) -> 'TimeInterval':
         """
         (!) This method will modify this instance.
 
         Transform this time interval into a new one in which
-        the `start` has been trimmed the `t_variation` provided
+        the `start` has been trimmed the `delta` provided
         if the result respected the also given `limit`.
 
         This method returns this same instance but modified.
         """
         cut = self.get_trim_start(
-            t_variation = t_variation
+            delta = delta
         )
 
+        self._validate_start(cut.start)
+        self._validate_duration(cut.end - cut.start)
+
         self.start = cut.start
-        self.end = cut.end
+        #self.end = cut.end
 
         return self
     
     def get_trim_ends(
         self,
-        t_variation: Number
+        delta: Number
     ) -> tuple['TimeInterval', 'TimeInterval']:
         """
         Get a tuple containing the 2 new `TimeInterval` instances
         generated by trimming this one's end the amount of seconds
-        provided as the `t_variation` parameter. The first tuple is
+        provided as the `delta` parameter. The first tuple is
         the one requested by the user, and the second one is the
         remaining.
 
-        (!) The `t_variation` value provided will be transformed into
+        (!) The `delta` value provided will be transformed into
         a multiple of `1/fps` of this instance, and truncated to fit
         the `start` of the time interval the new segments will belong
         to, if the `fps` is set.
 
-        The `t_variation` must be a positive value, the amount of
+        The `delta` must be a positive value, the amount of
         seconds to be trimmed.
         """
         return self._cutter.trim_end(
             time_interval = self,
-            t_variation = self._truncate(t_variation)
+            delta = self._truncate(delta)
         )
     
     # TODO: Rename, please
     def get_trim_end(
         self,
-        t_variation: Number
+        delta: Number
     ) -> 'TimeInterval':
         """
         Get this time interval instance but trimmed from the `end`
-        the `t_variation` amount of seconds provided.
+        the `delta` amount of seconds provided.
 
-        (!) The `t_variation` value provided will be transformed into
+        (!) The `delta` value provided will be transformed into
         a multiple of `1/fps` of this instance, and truncated to fit
         the `end` of the time interval the new segments will belong
         to, if the `fps` is set.
@@ -645,27 +751,30 @@ class TimeInterval:
         returns a new one.
         """
         return self.get_trim_ends(
-            t_variation = t_variation
+            delta = delta
         )[0]
     
     def _trim_end(
         self,
-        t_variation: Number
+        delta: Number
     ) -> 'TimeInterval':
         """
         (!) This method will modify this instance.
 
         Transform this time interval into a new one in which
-        the `end` has been trimmed the `t_variation` provided
+        the `end` has been trimmed the `delta` provided
         if the result respected the also given `limit`.
 
         This method returns this same instance but modified.
         """
         cut = self.get_trim_end(
-            t_variation = t_variation
+            delta = delta
         )
 
-        self.start = cut.start
+        self._validate_end(cut.end)
+        self._validate_duration(cut.end - cut.start)
+
+        #self.start = cut.start
         self.end = cut.end
 
         return self
@@ -736,28 +845,34 @@ class TimeInterval:
     
     def _extend_end(
         self,
-        t_variation: Number
+        delta: Number
     ) -> 'TimeInterval':
         """
         (!) This method will modify this instance.
 
         Transform this time interval into a new one in which
-        the `end` has been extended the `t_variation` provided
+        the `end` has been extended the `delta` provided
         if the result respected the also given `limit`.
 
         This method returns this same instance but modified.
+
+        This method will raise an exception if the new duration
+        exceeds the `duration_limit`.
         """
-        ParameterValidator.validate_mandatory_positive_number('t_variation', t_variation, do_include_zero = False)
+        ParameterValidator.validate_mandatory_positive_number('delta', delta, do_include_zero = False)
 
         extended = self._extender.extend_end(
             time_interval = self,
-            t_variation = (
-                self._truncate(t_variation)
+            delta = (
+                self._truncate(delta)
                 if self.fps is not None else
-                t_variation
+                delta
             )
         )
 
+        self._validate_end(extended.end)
+        self._validate_duration(extended.end - self.start)
+
         # TODO: Is this above a bit useless (?)
         self.end = extended.end
 
@@ -765,46 +880,52 @@ class TimeInterval:
     
     def _extend_start(
         self,
-        t_variation: Number
+        delta: Number
     ) -> 'TimeInterval':
         """
         (!) This method will modify this instance.
 
         Transform this time interval into a new one in which
-        the `start` has been extended the `t_variation` provided
+        the `start` has been extended the `delta` provided
         if the result respected the also given `limit`.
 
         This method returns this same instance but modified.
+
+        This method will raise an exception if the new duration
+        exceeds the `duration_limit`.
         """
-        ParameterValidator.validate_mandatory_positive_number('t_variation', t_variation, do_include_zero = False)
+        ParameterValidator.validate_mandatory_positive_number('delta', delta, do_include_zero = False)
 
         extended = self._extender.extend_start(
             time_interval = self,
-            t_variation = (
-                self._truncate(t_variation)
+            delta = (
+                self._truncate(delta)
                 if self.fps is not None else
-                t_variation
+                delta
             )
         )
 
+        self._validate_start(extended.start)
+        self._validate_duration(self.end - extended.start)
+
         # TODO: Is this above a bit useless (?)
         self.start = extended.start
 
         return self
     
-    def modify_start(
+    def shift_start(
         self,
-        t_variation: Number
+        delta: Number
     ) -> 'TimeInterval':
         """
         (!) This method will modify this instance.
 
-        Giving a negative `t_variation` value will make the
+        Giving a negative `delta` value will make the
         time interval longer, extending the `start` value.
 
         Transform this time interval into a new one in which
         the `start` has been extended or trimmed the
-        `t_variation` value provided if the result respects 
+        `delta` value provided if the result respects 
         the also given `limit`.
 
         The new `start` can never be lower than the original
@@ -812,28 +933,28 @@ class TimeInterval:
 
         This method returns this same instance but modified.
         """
-        ParameterValidator.validate_mandatory_number(t_variation, t_variation, do_include_zero = False)
+        ParameterValidator.validate_mandatory_number(delta, delta, do_include_zero = False)
 
         return (
             self._trim_start(
-                t_variation = abs(t_variation)
+                delta = abs(delta)
             )
-            if t_variation > 0 else
+            if delta > 0 else
             self._extend_start(
-                t_variation = abs(t_variation)
+                delta = abs(delta)
             )
         )
     
-    def modify_start_to(
+    def set_start(
         self,
-        start: Number
+        t: Number
     ) -> 'TimeInterval':
         """
         (!) This method will modify this instance.
 
         Transform this time interval into a new one in which
         the `start` has been extended or trimmed until
-        reaching the new `start` parameter value provided (if
+        reaching the new `t` parameter value provided (if
         valid).
 
         The new `start` can never be lower than the limit
@@ -842,27 +963,28 @@ class TimeInterval:
 
         This method returns this same instance but modified.
         """
-        ParameterValidator.validate_mandatory_number(start, start, do_include_zero = True)
+        ParameterValidator.validate_mandatory_number(t, t, do_include_zero = True)
 
-        if start != self.start:
-            self._validate_start(start)
-            self.start = start
+        if t != self.start:
+            self._validate_start(t)
+            self._validate_duration(self.end - t)
+            self.start = t
 
         return self
     
-    def modify_end(
+    def shift_end(
         self,
-        t_variation: Number
+        delta: Number
     ) -> 'TimeInterval':
         """
         (!) This method will modify this instance.
 
-        Giving a positive `t_variation` value will make the
+        Giving a positive `delta` value will make the
         time interval longer, extending the `end` value.
 
         Transform this time interval into a new one in which
         the `end` has been extended or trimmed the
-        `t_variation` value provided if the result respects 
+        `delta` value provided if the result respects 
         the also given `limit`.
 
         The new `end` can never be greater than the original
@@ -870,19 +992,19 @@ class TimeInterval:
 
         This method returns this same instance but modified.
         """
-        ParameterValidator.validate_mandatory_number(t_variation, t_variation, do_include_zero = False)
+        ParameterValidator.validate_mandatory_number(delta, delta, do_include_zero = False)
 
         return (
             self._trim_end(
-                t_variation = abs(t_variation)
+                delta = abs(delta)
             )
-            if t_variation < 0 else
+            if delta < 0 else
             self._extend_end(
-                t_variation = abs(t_variation)
+                delta = abs(delta)
             )
         )
     
-    def modify_end_to(
+    def set_end(
         self,
         t: Number
     ) -> 'TimeInterval':
@@ -901,9 +1023,10 @@ class TimeInterval:
         """
         ParameterValidator.validate_mandatory_number(t, t, do_include_zero = True)
 
-        if end != self.end:
-            self._validate_end(end)
-            self.end = end
+        if t != self.end:
+            self._validate_end(t)
+            self._validate_duration(t - self.start)
+            self.end = t
 
         return self
         
@@ -1131,23 +1254,23 @@ class TimeIntervalCutter:
     @parameter_to_time_interval('time_interval')
     def trim_end(
         time_interval: TimeIntervalType,
-        t_variation: Number
+        delta: Number
     ) -> tuple['TimeInterval', 'TimeInterval']:
         """
         Get a tuple containing the 2 new `TimeInterval` instances
         generated by trimming the `time_interval` end the amount
-        of seconds provided as the `t_variation` parameter. The
+        of seconds provided as the `delta` parameter. The
         first tuple is the requested by the user, and the second one
         is the remaining.
 
-        The `t_variation` must be a positive value, the amount of
+        The `delta` must be a positive value, the amount of
         seconds to be trimmed.
         """
-        ParameterValidator.validate_mandatory_positive_number('t_variation', t_variation, do_include_zero = False)
+        ParameterValidator.validate_mandatory_positive_number('delta', delta, do_include_zero = False)
 
         return TimeIntervalCutter.trim_end_to(
             time_interval = time_interval,
-            t = time_interval.end - t_variation
+            t = time_interval.end - delta
         )
     
     @staticmethod
@@ -1188,23 +1311,23 @@ class TimeIntervalCutter:
     @parameter_to_time_interval('time_interval')
     def trim_start(
         time_interval: TimeIntervalType,
-        t_variation: Number
+        delta: Number
     ) -> tuple['TimeInterval', 'TimeInterval']:
         """
         Get a tuple containing the 2 new `TimeInterval` instances
         generated by trimming the `time_interval` start the amount
-        of seconds provided as the `t_variation` parameter. The
+        of seconds provided as the `delta` parameter. The
         first tuple is the remaining, and the second one is the
         new time interval requested by the user.
 
-        The `t_variation` must be a positive value, the amount of
+        The `delta` must be a positive value, the amount of
         seconds to be trimmed.
         """
-        ParameterValidator.validate_mandatory_positive_number('t_variation', t_variation, do_include_zero = False)
+        ParameterValidator.validate_mandatory_positive_number('delta', delta, do_include_zero = False)
 
         return TimeIntervalCutter.trim_start_to(
             time_interval = time_interval,
-            t = time_interval.start + t_variation
+            t = time_interval.start + delta
         )
     
     @staticmethod
@@ -1348,7 +1471,7 @@ class TimeIntervalCutter:
             t <= time_interval.start or
             t >= time_interval.end
         ):
-            raise Exception('The "t" value provided is not a valid value as it is a limit (or more than a limit).')
+            raise Exception('The "t" value is not a valid value as it is a limit (or more than a limit).')
         
         return (
             TimeInterval(
@@ -1379,17 +1502,17 @@ class TimeIntervalExtender:
     @parameter_to_time_interval('time_interval')
     def extend_end(
         time_interval: 'TimeInterval',
-        t_variation: Number
+        delta: Number
     ):
         """
-        Extend the end of the given `time_interval` the `t_variation`
+        Extend the end of the given `time_interval` the `delta`
         amount of seconds provided.
         """
-        ParameterValidator.validate_mandatory_positive_number('t_variation', t_variation, do_include_zero = False)
+        ParameterValidator.validate_mandatory_positive_number('delta', delta, do_include_zero = False)
 
         return TimeIntervalExtender.extend_end_to(
             time_interval = time_interval,
-            t = time_interval.end + t_variation
+            t = time_interval.end + delta
         )
     
     @staticmethod
@@ -1405,7 +1528,7 @@ class TimeIntervalExtender:
         _validate_time_interval_original_limits(time_interval, t)
         
         if t < time_interval.end:
-            raise Exception('The "t" parameter provided is lower than the current time interval `end` and this method is to extend it.')
+            raise Exception(f'The "t" value ({str(float(t))}) is lower than the current time interval `end` and this method is to extend it.')
         
         return TimeInterval(
             start = time_interval.start,
@@ -1419,19 +1542,19 @@ class TimeIntervalExtender:
     @parameter_to_time_interval('time_interval')
     def extend_start(
         time_interval: 'TimeInterval',
-        t_variation: Number
+        delta: Number
     ):
         """
-        Extend the start of the given `time_interval` the `t_variation`
+        Extend the start of the given `time_interval` the `delta`
         amount of seconds provided if the new `start` is greater than
         the `limit` provided and than the original (and min) `start`
         value of the time interval.
         """
-        ParameterValidator.validate_mandatory_positive_number('t_variation', t_variation, do_include_zero = False)
+        ParameterValidator.validate_mandatory_positive_number('delta', delta, do_include_zero = False)
 
         return TimeIntervalExtender.extend_start_to(
             time_interval = time_interval,
-            t = time_interval.start - t_variation
+            t = time_interval.start - delta
         )
     
     @staticmethod
@@ -1447,7 +1570,7 @@ class TimeIntervalExtender:
         _validate_time_interval_original_limits(time_interval, t)
         
         if t > time_interval.start:
-            raise Exception('The "t" parameter provided is greater than the current time interval `start` and this method is to extend it.')
+            raise Exception(f'The "t" value ({str(float(t))}) is greater than the current time interval `start` and this method is to extend it.')
         
         return TimeInterval(
             start = t,
@@ -1474,7 +1597,7 @@ def _validate_time_interval_original_limits(
         t < time_interval.start_limit or
         t > time_interval.end_limit
     ):
-        raise Exception(f'The "t" parameter value provided ({str(float(t))}) is out of the time interval limits (min and max) [{str(float(time_interval.start_limit))}, {str(float(time_interval.end_limit))}].')
+        raise Exception(f'The "t" value ({str(float(t))}) is out of the time interval limits (min and max) [{str(float(time_interval.start_limit))}, {str(float(time_interval.end_limit))}].')
                         
 def _validate_time_interval_current_limits(
     time_interval: TimeInterval,
@@ -1497,5 +1620,5 @@ def _validate_time_interval_current_limits(
         t < time_interval.start or
         t > time_interval.end
     ):
-        raise Exception(f'The "t" parameter value provided ({str(float(t))}) is out of the time interval current limits [{str(float(time_interval.start))}, {str(float(time_interval.end))}].')
+        raise Exception(f'The "t" value ({str(float(t))}) is out of the time interval current limits [{str(float(time_interval.start))}, {str(float(time_interval.end))}].')
     

{yta_video_frame_time-0.0.19.dist-info → yta_video_frame_time-0.0.24.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yta-video-frame-time
-Version: 0.0.19
+Version: 0.0.24
 Summary: Youtube Autonomous Video Frame Time Module
 License-File: LICENSE
 Author: danialcala94

yta_video_frame_time-0.0.24.dist-info/RECORD

@@ -0,0 +1,8 @@
+yta_video_frame_time/__init__.py,sha256=-YOa7lOKdiA3FwDEHHU1tHobnmhjFpTaVLfJQLZqoMI,22252
+yta_video_frame_time/decorators.py,sha256=FDdHvJEo93VyS7SIq6RhQ8pwKS7LMfa1MM4URDSD-yY,1453
+yta_video_frame_time/interval.py,sha256=6QVDmukDpXhp4TEm_rbcMlcwC6HGYnjiDgoKr9DM8Tk,55427
+yta_video_frame_time/t_fraction.py,sha256=YBOnH-Shs2YKSKFvm84EbFfvzXmg4AyNnyKd_hzF3Uk,29216
+yta_video_frame_time-0.0.24.dist-info/licenses/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
+yta_video_frame_time-0.0.24.dist-info/METADATA,sha256=EHaFnRbREkaCyMyqrEhkhvlpHzqBGMVMogEXMWhbBbk,538
+yta_video_frame_time-0.0.24.dist-info/WHEEL,sha256=M5asmiAlL6HEcOq52Yi5mmk9KmTVjY2RDPtO4p9DMrc,88
+yta_video_frame_time-0.0.24.dist-info/RECORD,,

yta_video_frame_time-0.0.19.dist-info/RECORD

@@ -1,8 +0,0 @@
-yta_video_frame_time/__init__.py,sha256=-YOa7lOKdiA3FwDEHHU1tHobnmhjFpTaVLfJQLZqoMI,22252
-yta_video_frame_time/decorators.py,sha256=FDdHvJEo93VyS7SIq6RhQ8pwKS7LMfa1MM4URDSD-yY,1453
-yta_video_frame_time/interval.py,sha256=btFgrGbo5Yu5AOkUisUbpk_MgIvuuGR6OtyZhUWyhiY,51866
-yta_video_frame_time/t_fraction.py,sha256=YBOnH-Shs2YKSKFvm84EbFfvzXmg4AyNnyKd_hzF3Uk,29216
-yta_video_frame_time-0.0.19.dist-info/licenses/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
-yta_video_frame_time-0.0.19.dist-info/METADATA,sha256=FYmTe64MaTE3BhToFdpssl-c_zAuP5dRdfAYl3aKDx4,538
-yta_video_frame_time-0.0.19.dist-info/WHEEL,sha256=M5asmiAlL6HEcOq52Yi5mmk9KmTVjY2RDPtO4p9DMrc,88
-yta_video_frame_time-0.0.19.dist-info/RECORD,,