| import functools |
| import warnings |
|
|
| from .error_utils import UnitxtWarning |
| from .settings_utils import get_constants, get_settings |
|
|
| constants = get_constants() |
| settings = get_settings() |
|
|
|
|
| class DeprecationError(Exception): |
| """Custom exception for deprecated versions.""" |
|
|
| pass |
|
|
|
|
| def compare_versions(version1, version2): |
| """Compare two semantic versioning strings and determine their relationship. |
| |
| Parameters: |
| version1 (str): |
| The first version string to compare. |
| version2 (str): |
| The second version string to compare. |
| |
| Returns: |
| int: -1 if version1 < version2, 1 if version1 > version2, 0 if equal. |
| |
| Example: |
| .. code-block:: text |
| |
| >>> compare_versions("1.2.0", "1.2.3") |
| -1 |
| >>> compare_versions("1.3.0", "1.2.8") |
| 1 |
| >>> compare_versions("1.0.0", "1.0.0") |
| 0 |
| |
| """ |
| parts1 = [int(part) for part in version1.split(".")] |
| parts2 = [int(part) for part in version2.split(".")] |
| length_difference = len(parts1) - len(parts2) |
| if length_difference > 0: |
| parts2.extend([0] * length_difference) |
| elif length_difference < 0: |
| parts1.extend([0] * (-length_difference)) |
| for part1, part2 in zip(parts1, parts2): |
| if part1 < part2: |
| return -1 |
| if part1 > part2: |
| return 1 |
| return 0 |
|
|
|
|
| def depraction_wrapper(obj, version, alt_text): |
| """A wrapper function for deprecation handling, issuing warnings or errors based on version comparison. |
| |
| Args: |
| obj (callable): The object to be wrapped, typically a function or class method. |
| version (str): The version at which the object becomes deprecated. |
| alt_text (str): Additional text to display, usually suggests an alternative. |
| |
| Returns: |
| callable: A wrapped version of the original object that checks for deprecation. |
| """ |
|
|
| @functools.wraps(obj) |
| def wrapper(*args, **kwargs): |
| if constants.version < version: |
| if settings.default_verbosity in ["debug", "info", "warning"]: |
| warnings.warn( |
| f"{obj.__name__} is deprecated.{alt_text}", |
| DeprecationWarning, |
| stacklevel=2, |
| ) |
| elif constants.version >= version: |
| raise DeprecationError(f"{obj.__name__} is no longer supported.{alt_text}") |
| return obj(*args, **kwargs) |
|
|
| return wrapper |
|
|
|
|
| def deprecation(version, alternative=None, msg=None): |
| """Decorator for marking functions or class methods as deprecated. |
| |
| Args: |
| version (str): The version at which the function or method becomes deprecated. |
| alternative (str, optional): Suggested alternative to the deprecated functionality. |
| msg (str, optional): Additional message regarding the deprecation reason or alternatives. |
| |
| Returns: |
| callable: A decorator that can be applied to functions or class methods. |
| """ |
|
|
| def decorator(obj): |
| alt_text = f" Use {alternative} instead." if alternative is not None else "" |
| alt_text += msg if msg is not None else "" |
| if callable(obj): |
| func = obj |
| elif hasattr(obj, "__init__"): |
| func = obj.__init__ |
| else: |
| raise ValueError("Unsupported object type for deprecation.") |
| return depraction_wrapper(func, version, alt_text) |
|
|
| return decorator |
|
|
|
|
| def init_warning(msg=""): |
| |
| def decorator(initiated_class): |
| UnitxtWarning(msg) |
| return initiated_class |
|
|
| return decorator |
|
|
|
|
| def warn_on_call(warning_type=UserWarning, msg=""): |
| def decorator(obj): |
| if isinstance(obj, type): |
| original_init = obj.__init__ |
|
|
| @functools.wraps(original_init) |
| def new_init(self, *args, **kwargs): |
| warnings.warn(msg, warning_type, stacklevel=2) |
| original_init(self, *args, **kwargs) |
|
|
| obj.__init__ = new_init |
| return obj |
|
|
| if callable(obj): |
|
|
| @functools.wraps(obj) |
| def wrapper(*args, **kwargs): |
| warnings.warn(msg, warning_type, stacklevel=2) |
| return obj(*args, **kwargs) |
|
|
| return wrapper |
|
|
| raise TypeError("This decorator can only be applied to classes or functions.") |
|
|
| return decorator |
|
|
