python-backpack 2.0.3__py3-none-any.whl → 2.0.5__py3-none-any.whl

backpack/cache.py

@@ -1,93 +1,93 @@
-# ----------------------------------------------------------------------------------------
-# Python-Backpack - Pattern Utilities
-# Maximiliano Rocamora / maxirocamora@gmail.com
-# https://github.com/MaxRocamora/python-backpack
-# ----------------------------------------------------------------------------------------
-from datetime import datetime, timedelta, timezone
-from functools import lru_cache, wraps
-from typing import Any, Callable, Protocol, TypeVar, cast
-
-from backpack.logger import get_logger
-
-log = get_logger('Python Backpack - Cache')
-
-R = TypeVar('R', covariant=True)
-
-
-class TimedCachedCallable(Protocol[R]):
-    """Callable returned by timed_lru_cache with cache control kwargs."""
-
-    def __call__(
-        self,
-        *args: Any,
-        force_clear: bool = False,
-        show_log: bool = False,
-        **kwargs: Any,
-    ) -> R:
-        """Call the cached function, optionally forcing a cache clear first."""
-        ...
-
-
-def timed_lru_cache(
-    seconds: int,
-    maxsize: int = 128,
-) -> Callable[[Callable[..., R]], TimedCachedCallable[R]]:
-    """Lru_cache with expiration time.
-
-    Args:
-        seconds (int): expiration time in seconds
-        maxsize (int): maxsize for lru_cache
-    Note:
-        Wrapped function can be forced to clear cache with: force_clear=True
-        Wrapped function can show log on clear with: show_log=True
-    Returns:
-        function result
-
-    # * Usage:
-
-        # * Add the decorator to your function
-
-        @timed_lru_cache(seconds=60)
-        def my_function():
-            return 'Hello World'
-
-        # * to clear the cache, use force_clear=True on the function call
-        my_function(force_clear=True)
-
-    """
-
-    def wrapper_cache(func: Callable[..., R]) -> TimedCachedCallable[R]:
-        cached_func = cast(Any, lru_cache(maxsize=maxsize)(func))
-        cached_func.lifetime = timedelta(seconds=seconds)
-        cached_func.expiration = datetime.now(timezone.utc) + cached_func.lifetime
-
-        @wraps(func)
-        def wrapped_func(
-            *args: Any,
-            force_clear: bool = False,
-            show_log: bool = False,
-            **kwargs: Any,
-        ) -> R:
-            """Wrapper function for lru_cache with expiration time.
-
-            Args:
-                *args: function arguments
-                force_clear (bool): forces a clear cache
-                show_log (bool): show log on clear
-                **kwargs: function keyword arguments
-            Returns:
-                function result
-            """
-
-            if force_clear or datetime.now(timezone.utc) >= cached_func.expiration:
-                if show_log:
-                    log.debug(f'Cache cleared for {cached_func.__name__}')
-
-                cached_func.cache_clear()
-                cached_func.expiration = datetime.now(timezone.utc) + cached_func.lifetime
-
-            return cached_func(*args, **kwargs)
-
-        return cast(TimedCachedCallable[R], wrapped_func)
-
-    return wrapper_cache
+# ----------------------------------------------------------------------------------------
+# Python-Backpack - Pattern Utilities
+# Maximiliano Rocamora / maxirocamora@gmail.com
+# https://github.com/MaxRocamora/python-backpack
+# ----------------------------------------------------------------------------------------
+from datetime import datetime, timedelta, timezone
+from functools import lru_cache, wraps
+from typing import Any, Callable, Protocol, TypeVar, cast
+
+from backpack.logger import get_logger
+
+log = get_logger('Python Backpack - Cache')
+
+R = TypeVar('R', covariant=True)
+
+
+class TimedCachedCallable(Protocol[R]):
+    """Callable returned by timed_lru_cache with cache control kwargs."""
+
+    def __call__(
+        self,
+        *args: Any,
+        force_clear: bool = False,
+        show_log: bool = False,
+        **kwargs: Any,
+    ) -> R:
+        """Call the cached function, optionally forcing a cache clear first."""
+        ...
+
+
+def timed_lru_cache(
+    seconds: int,
+    maxsize: int = 128,
+) -> Callable[[Callable[..., R]], TimedCachedCallable[R]]:
+    """Lru_cache with expiration time.
+
+    Args:
+        seconds (int): expiration time in seconds
+        maxsize (int): maxsize for lru_cache
+    Note:
+        Wrapped function can be forced to clear cache with: force_clear=True
+        Wrapped function can show log on clear with: show_log=True
+    Returns:
+        function result
+
+    # * Usage:
+
+        # * Add the decorator to your function
+
+        @timed_lru_cache(seconds=60)
+        def my_function():
+            return 'Hello World'
+
+        # * to clear the cache, use force_clear=True on the function call
+        my_function(force_clear=True)
+
+    """
+
+    def wrapper_cache(func: Callable[..., R]) -> TimedCachedCallable[R]:
+        cached_func = cast(Any, lru_cache(maxsize=maxsize)(func))
+        cached_func.lifetime = timedelta(seconds=seconds)
+        cached_func.expiration = datetime.now(timezone.utc) + cached_func.lifetime
+
+        @wraps(func)
+        def wrapped_func(
+            *args: Any,
+            force_clear: bool = False,
+            show_log: bool = False,
+            **kwargs: Any,
+        ) -> R:
+            """Wrapper function for lru_cache with expiration time.
+
+            Args:
+                *args: function arguments
+                force_clear (bool): forces a clear cache
+                show_log (bool): show log on clear
+                **kwargs: function keyword arguments
+            Returns:
+                function result
+            """
+
+            if force_clear or datetime.now(timezone.utc) >= cached_func.expiration:
+                if show_log:
+                    log.debug(f'Cache cleared for {cached_func.__name__}')
+
+                cached_func.cache_clear()
+                cached_func.expiration = datetime.now(timezone.utc) + cached_func.lifetime
+
+            return cached_func(*args, **kwargs)
+
+        return cast(TimedCachedCallable[R], wrapped_func)
+
+    return wrapper_cache

backpack/custom_errors.py

@@ -1,37 +1,37 @@
-# ----------------------------------------------------------------------------------------
-# Python-Backpack - Custom Exceptions
-# Maximiliano Rocamora / maxirocamora@gmail.com
-# https://github.com/MaxRocamora/python-backpack
-# ----------------------------------------------------------------------------------------
-
-
-class EnvironmentVariableNotFoundError(Exception):
-    def __init__(self, var_name: str) -> None:
-        """Error Raised when a required environment variable is missing from os.
-
-        Args:
-            var_name (str): name of the required variable missing
-        """
-        self.var_name = var_name
-        self.message = f'Required Environment Variable [{var_name}] not found.'
-        super().__init__(self.message)
-
-    def __str__(self):
-        """Return the error message."""
-        return self.message
-
-
-class ApplicationNotFoundError(Exception):
-    def __init__(self, app_name: str) -> None:
-        """Error Raised when an Application Name required is not found.
-
-        Args:
-            app_name (str): name of the required application missing
-        """
-        self.app_name = app_name
-        self.message = f'Application ({app_name}) not found.'
-        super().__init__(self.message)
-
-    def __str__(self):
-        """Return the error message."""
-        return self.message
+# ----------------------------------------------------------------------------------------
+# Python-Backpack - Custom Exceptions
+# Maximiliano Rocamora / maxirocamora@gmail.com
+# https://github.com/MaxRocamora/python-backpack
+# ----------------------------------------------------------------------------------------
+
+
+class EnvironmentVariableNotFoundError(Exception):
+    def __init__(self, var_name: str) -> None:
+        """Error Raised when a required environment variable is missing from os.
+
+        Args:
+            var_name (str): name of the required variable missing
+        """
+        self.var_name = var_name
+        self.message = f'Required Environment Variable [{var_name}] not found.'
+        super().__init__(self.message)
+
+    def __str__(self):
+        """Return the error message."""
+        return self.message
+
+
+class ApplicationNotFoundError(Exception):
+    def __init__(self, app_name: str) -> None:
+        """Error Raised when an Application Name required is not found.
+
+        Args:
+            app_name (str): name of the required application missing
+        """
+        self.app_name = app_name
+        self.message = f'Application ({app_name}) not found.'
+        super().__init__(self.message)
+
+    def __str__(self):
+        """Return the error message."""
+        return self.message

backpack/file_utils.py

@@ -1,135 +1,140 @@
-# ----------------------------------------------------------------------------------------
-# Python-Backpack - File Utilities - Ascii Files Manipulation
-# Maximiliano Rocamora / maxirocamora@gmail.com
-# https://github.com/MaxRocamora/python-backpack
-# ----------------------------------------------------------------------------------------
-
-from collections.abc import Sequence
-
-from backpack.logger import get_logger
-
-log = get_logger('Python Backpack - FileUtils')
-
-
-def replace_strings_in_file(
-    ascii_file: str,
-    strings: Sequence[str],
-    new_string: str,
-) -> None:
-    """Opens ascii file and replaces all occurrences from strings into new_string.
-
-    In this class we use a full path to avoid use of os.dirname, which
-    causes string encode problems.
-
-    Args:
-        ascii_file: (fullpath string) file to open
-        strings: (list) strings to replace
-        new_string: (string) new string or path to set
-    """
-
-    # force forward slashes
-    new_string = new_string.replace('\\', '/')
-
-    log.info(f'Replacing Strings, Opening File: {ascii_file}')
-
-    with open(ascii_file, newline='') as f:
-        file_data = f.read()
-        for i in strings:
-            log.info('Finding: %s', i)
-            log.info('Replacing for: %s', new_string)
-            log.info('-' * 50)
-            file_data = file_data.replace(i, new_string)
-
-    with open(ascii_file, 'w', newline='') as f:
-        f.write(file_data)
-        log.info(f'Closing File: {ascii_file}')
-
-
-def remove_line_from_file(
-    ascii_file: str,
-    strings: Sequence[str],
-    verbose: bool = False,
-) -> None:
-    """Removes given lines from ascii file.
-
-    Args:
-        ascii_file: (string path) ASCII file to process
-        strings: (list) match lines to remove
-        verbose: (bool) if true, prints removed lines
-    """
-
-    retained_lines = []
-    with open(ascii_file, newline='') as f:
-        file_content = f.readlines()
-
-    for line in file_content:
-        value = line.rstrip('\r\n')
-        if verbose:
-            log.info(f'Checking line: {value}')
-        if value in strings:
-            if verbose:
-                log.info(f'Removing line: {value}')
-        else:
-            retained_lines.append(line)
-
-    with open(ascii_file, 'w', newline='') as f:
-        f.writelines(retained_lines)
-
-
-def file_is_writeable(filepath: str) -> bool:
-    """Checks if a file is locked and can be overwritten.
-
-    Args:
-        filepath: (str) file to check
-    Returns:
-        bool : true if file is writeable
-    """
-    try:
-        with open(filepath, 'r+') as _:
-            return True
-    except OSError as x:
-        log.warning(f'{filepath} is locked ')
-        log.info(x.strerror)
-
-    return False
-
-
-def get_version_from_filename(filename: str) -> str:
-    """Extracts version from filename.
-
-    Args:
-        filename: (str) file name to extract version from
-    Returns:
-        str : version extracted from filename
-
-    Examples:
-        get_version_from_filename('myfile_23.txt') -> '23'
-        get_version_from_filename('myfile-9.txt') -> '9'
-        get_version_from_filename('myfile.130.txt') -> '130'
-        get_version_from_filename('myfile_v1002.txt') -> '1002'
-
-    """
-
-    filename_no_ext = filename.rsplit('.', 1)[0]
-
-    # guess is the separator is an underscore, dash, dot or v, and the version is the last part before the extension
-    separators = ['_', '-', '.', 'v']
-    if not any(sep in filename_no_ext for sep in separators):
-        log.info(f'No separator found in filename: {filename_no_ext}. Using fallback extraction.')
-    else:
-        for sep in separators:
-            if sep in filename_no_ext:
-                parts = filename_no_ext.split(sep)
-                version_part = parts[-1].split('.')[0]  # Get the last part before the extension
-                if version_part.replace('.', '').isdigit():  # Check if it's a valid version number
-                    log.info(
-                        f'Extracted version: {version_part} from filename: {filename} using separator: {sep}'
-                    )
-                    return version_part
-
-    # Fallback: extract from the entire filename
-    version = filename_no_ext.lstrip('v')
-    version = version.replace('_', '.').replace('-', '.')
-    version = version if version.replace('.', '').isdigit() else '0'
-    log.info(f'Extracted version: {version} from filename: {filename}')
-    return version
+# ----------------------------------------------------------------------------------------
+# Python-Backpack - File Utilities - Ascii Files Manipulation
+# Maximiliano Rocamora / maxirocamora@gmail.com
+# https://github.com/MaxRocamora/python-backpack
+# ----------------------------------------------------------------------------------------
+
+import re
+from collections.abc import Sequence
+
+from backpack.logger import get_logger
+
+log = get_logger('Python Backpack - FileUtils')
+
+
+def replace_strings_in_file(
+    ascii_file: str,
+    strings: Sequence[str],
+    new_string: str,
+) -> None:
+    """Opens ascii file and replaces all occurrences from strings into new_string.
+
+    In this class we use a full path to avoid use of os.dirname, which
+    causes string encode problems.
+
+    Args:
+        ascii_file: (fullpath string) file to open
+        strings: (list) strings to replace
+        new_string: (string) new string or path to set
+    """
+
+    # force forward slashes
+    new_string = new_string.replace('\\', '/')
+
+    log.info(f'Replacing Strings, Opening File: {ascii_file}')
+
+    with open(ascii_file, newline='') as f:
+        file_data = f.read()
+        for i in strings:
+            log.info('Finding: %s', i)
+            log.info('Replacing for: %s', new_string)
+            log.info('-' * 50)
+            file_data = file_data.replace(i, new_string)
+
+    with open(ascii_file, 'w', newline='') as f:
+        f.write(file_data)
+        log.info(f'Closing File: {ascii_file}')
+
+
+def remove_line_from_file(
+    ascii_file: str,
+    strings: Sequence[str],
+    verbose: bool = False,
+) -> None:
+    """Removes given lines from ascii file.
+
+    Args:
+        ascii_file: (string path) ASCII file to process
+        strings: (list) match lines to remove
+        verbose: (bool) if true, prints removed lines
+    """
+
+    retained_lines = []
+    with open(ascii_file, newline='') as f:
+        file_content = f.readlines()
+
+    for line in file_content:
+        value = line.rstrip('\r\n')
+        if verbose:
+            log.info(f'Checking line: {value}')
+        if value in strings:
+            if verbose:
+                log.info(f'Removing line: {value}')
+        else:
+            retained_lines.append(line)
+
+    with open(ascii_file, 'w', newline='') as f:
+        f.writelines(retained_lines)
+
+
+def file_is_writeable(filepath: str) -> bool:
+    """Checks if a file is locked and can be overwritten.
+
+    Args:
+        filepath: (str) file to check
+    Returns:
+        bool : true if file is writeable
+    """
+    try:
+        with open(filepath, 'r+') as _:
+            return True
+    except OSError as x:
+        log.warning(f'{filepath} is locked ')
+        log.info(x.strerror)
+
+    return False
+
+
+def get_version_from_filename(filename: str, separator: str | None = None) -> str:
+    """Extracts version from filename.
+
+    Args:
+        filename: (str) file name to extract version from
+        separator: delimiter that must precede the version; when omitted, use supported delimiters
+    Returns:
+        str : version extracted from filename
+
+    Examples:
+        get_version_from_filename('myfile_23.txt') -> '23'
+        get_version_from_filename('myfile-9.txt') -> '9'
+        get_version_from_filename('myfile.130.txt') -> '130'
+        get_version_from_filename('myfile_v1002.txt') -> '1002'
+        get_version_from_filename('XD_shot_0000.0003.ma') -> '0003'
+        get_version_from_filename('ANM_shot_0010.0003.ma') -> '0003'
+
+    """
+
+    filename_no_ext = filename.rsplit('.', 1)[0]
+
+    if separator is not None:
+        if not separator:
+            raise ValueError('separator must not be empty')
+
+        version = filename_no_ext.rsplit(separator, 1)[-1]
+        if version.isdigit():
+            log.info(
+                f'Extracted version: {version} from filename: {filename} using separator: {separator}'
+            )
+            return version
+
+        log.info(f'No numeric version found in filename: {filename} using separator: {separator}')
+        return '0'
+
+    match = re.search(r'(?:^|[_.-])v?(\d+)$', filename_no_ext)
+    if match:
+        version = match.group(1)
+        log.info(f'Extracted version: {version} from filename: {filename}')
+        return version
+
+    log.info(f'No numeric version found in filename: {filename}')
+    return '0'