deprecated-params 0.2.0__tar.gz

deprecated_params-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Vizonex
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

deprecated_params-0.2.0/PKG-INFO

@@ -0,0 +1,87 @@
+Metadata-Version: 2.4
+Name: deprecated-params
+Version: 0.2.0
+Summary: A Wrapper for functions, class objects and methods for deprecating keyword parameters
+Author-email: Vizonex <VizonexBusiness@gmail.com>
+License-Expression: MIT
+Project-URL: homepage, https://github.com/Vizonex/deprecated-params
+Project-URL: repository, https://github.com/Vizonex/deprecated-params.git
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typing-extensions; python_version < "3.10"
+Dynamic: license-file
+
+# Deprecated Params 
+[![PyPI version](https://badge.fury.io/py/deprecated-params.svg)](https://badge.fury.io/py/deprecated-params)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/deprecated-params)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![License: Appache-2.0](https://img.shields.io/badge/License-Appache-yellow.svg)](https://opensource.org/licenses/Appache-2-0)
+
+
+Inspired after python's warning.deprecated wrapper, deprecated_params is made to serve the single purpose of deprecating parameter names to warn users
+about incoming changes as well as retaining typehinting.
+
+
+
+## How to Deprecate Parameters
+Parameters should be keyword arguments, not positional, Reason
+for this implementation is that in theory you should've already 
+planned an alternative approach to an argument you wish 
+to deprecate. Most of the times these arguments will most 
+likely be one of 3 cases.
+- misspellings
+- better functionality that replaces old arguments with better ones.
+- removed parameters but you want to warn developers
+  to move without being aggressive about it.
+
+
+```python
+from deprecated_params import deprecated_params
+
+@deprecated_params(['x'])
+def func(y, *, x:int = 0):
+    pass
+
+# DeprecationWarning: Parameter "x" is deprecated
+func(None, x=20)
+
+# NOTE: **kw is accepted but also you could put down more than one 
+# parameter if needed...
+@deprecated_params(['foo'], {"foo":"foo was removed in ... don't use it"}, display_kw=False)
+class MyClass:
+    def __init__(self, spam:object, **kw):
+        self.spam = spam
+        self.foo = kw.get("foo", None)
+
+# DeprecationWarning: foo was removed in ... don't use it
+mc = MyClass("spam", foo="X")
+```
+
+## Why I wrote Deprecated Params
+I got tired of throwing random warnings in my code and wanted something cleaner that didn't 
+interfere with a function's actual code and didn't blind anybody trying to go through it. 
+Contributors and Reviewers should be able to utilize a library that saves them from these problems
+while improving the readability of a function. After figuring out that the functionality I was 
+looking for didn't exist I took the opportunity to implement it.
+
+## Deprecated Params used in real-world Examples 
+Deprecated-params is now used with two of my own libraries by default. 
+
+- [aiothreading (up until 0.1.6)](https://github.com/Vizonex/aiothreading)
+  - Originally aiothreading had it's own wrapper but I split it off to this library along with a rewrite after finding out that
+    parameter names were not showing up ides such as vs-code. The rewrite felt a bit bigger and knowing that users would want to utilize
+    this concept in other places was how this library ultimately got started.
+  - Lots of interior changes were made and with many arguments being suddenly dropped to increase the performance, the best solution was to warn
+    developers to stop using certain parameters as they will be deleted in the future.
+  - It is planned to be dropped as many of the things we wanted to remove have been slowly removed from the library which means this library will
+    be removed from it but that doesn't mean I won't keep maintaining it, it is invented for short-use cases and can be added and removed freely
+    without needing additional dependencies. 
+
+- [aiocallback (mainly used in version 1.6)](https://github.com/Vizonex/aiocallback)
+  - Same situation as aiothreading but I decided to buy users more time due to how fast some releases were going and it also allowed
+  - Currently I removed deprecated-params from aiocallback since it wasn't needed anymore but this is what deprecated-param's purpose 
+    was for, being there only when its need. I desired nothing more or less.
+
+If you would like to add examples of your own libraries that have used this library feel free to throw me an issue or send me a pull request.
+

deprecated_params-0.2.0/README.md

@@ -0,0 +1,73 @@
+# Deprecated Params 
+[![PyPI version](https://badge.fury.io/py/deprecated-params.svg)](https://badge.fury.io/py/deprecated-params)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/deprecated-params)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![License: Appache-2.0](https://img.shields.io/badge/License-Appache-yellow.svg)](https://opensource.org/licenses/Appache-2-0)
+
+
+Inspired after python's warning.deprecated wrapper, deprecated_params is made to serve the single purpose of deprecating parameter names to warn users
+about incoming changes as well as retaining typehinting.
+
+
+
+## How to Deprecate Parameters
+Parameters should be keyword arguments, not positional, Reason
+for this implementation is that in theory you should've already 
+planned an alternative approach to an argument you wish 
+to deprecate. Most of the times these arguments will most 
+likely be one of 3 cases.
+- misspellings
+- better functionality that replaces old arguments with better ones.
+- removed parameters but you want to warn developers
+  to move without being aggressive about it.
+
+
+```python
+from deprecated_params import deprecated_params
+
+@deprecated_params(['x'])
+def func(y, *, x:int = 0):
+    pass
+
+# DeprecationWarning: Parameter "x" is deprecated
+func(None, x=20)
+
+# NOTE: **kw is accepted but also you could put down more than one 
+# parameter if needed...
+@deprecated_params(['foo'], {"foo":"foo was removed in ... don't use it"}, display_kw=False)
+class MyClass:
+    def __init__(self, spam:object, **kw):
+        self.spam = spam
+        self.foo = kw.get("foo", None)
+
+# DeprecationWarning: foo was removed in ... don't use it
+mc = MyClass("spam", foo="X")
+```
+
+## Why I wrote Deprecated Params
+I got tired of throwing random warnings in my code and wanted something cleaner that didn't 
+interfere with a function's actual code and didn't blind anybody trying to go through it. 
+Contributors and Reviewers should be able to utilize a library that saves them from these problems
+while improving the readability of a function. After figuring out that the functionality I was 
+looking for didn't exist I took the opportunity to implement it.
+
+## Deprecated Params used in real-world Examples 
+Deprecated-params is now used with two of my own libraries by default. 
+
+- [aiothreading (up until 0.1.6)](https://github.com/Vizonex/aiothreading)
+  - Originally aiothreading had it's own wrapper but I split it off to this library along with a rewrite after finding out that
+    parameter names were not showing up ides such as vs-code. The rewrite felt a bit bigger and knowing that users would want to utilize
+    this concept in other places was how this library ultimately got started.
+  - Lots of interior changes were made and with many arguments being suddenly dropped to increase the performance, the best solution was to warn
+    developers to stop using certain parameters as they will be deleted in the future.
+  - It is planned to be dropped as many of the things we wanted to remove have been slowly removed from the library which means this library will
+    be removed from it but that doesn't mean I won't keep maintaining it, it is invented for short-use cases and can be added and removed freely
+    without needing additional dependencies. 
+
+- [aiocallback (mainly used in version 1.6)](https://github.com/Vizonex/aiocallback)
+  - Same situation as aiothreading but I decided to buy users more time due to how fast some releases were going and it also allowed
+  - Currently I removed deprecated-params from aiocallback since it wasn't needed anymore but this is what deprecated-param's purpose 
+    was for, being there only when its need. I desired nothing more or less.
+
+If you would like to add examples of your own libraries that have used this library feel free to throw me an issue or send me a pull request.
+

deprecated_params-0.2.0/deprecated_params/__init__.py

@@ -0,0 +1,434 @@
+"""
+Deprecated Params
+-----------------
+
+A Library dedicated for warning users about deprecated parameter
+names and changes
+"""
+
+from __future__ import annotations
+
+import inspect
+import sys
+import warnings
+from functools import wraps
+from types import MethodType
+from typing import (
+    Any,
+    Callable,
+    Iterable,
+    Mapping,
+    Sequence,
+    TypeVar,
+    overload,
+)
+
+
+if sys.version_info < (3, 10):
+    from typing_extensions import ParamSpec
+else:
+    from typing import ParamSpec
+
+
+__version__ = "0.2.0"
+__license__ = "Apache 2.0 / MIT"
+__author__ = "Vizonex"
+
+_T = TypeVar("_T", covariant=True)
+_P = ParamSpec("_P")
+
+KEYWORD_ONLY = inspect.Parameter.KEYWORD_ONLY
+VAR_KEYWORD = inspect.Parameter.VAR_KEYWORD
+
+
+__all__ = (
+    "MissingKeywordsError",
+    "InvalidParametersError",
+    "deprecated_params",
+    "__author__",
+    "__license__",
+    "__version__",
+)
+
+# Word of Warning:
+# All functions marked with underscores should be treated as do not use
+# directly. If you want these parts of code, they are under an MIT License and you
+# are allowed to copy and paste them freely as long as it's not apart of python's
+# warnings.deprecated function which then you will need to license under an APACHE 2.0
+
+
+class _KeywordsBaseException(Exception):
+    def __init__(self, keywords: set[str], *args: Any) -> None:
+        self._keywords = frozenset(keywords)
+        super().__init__(*args)
+
+    @property
+    def keywords(self) -> frozenset[str]:
+        """tells what keywords were bad"""
+        return self._keywords
+
+    @keywords.setter
+    def keywords(self, _: frozenset[str]) -> None:
+        """Throws ValueError because keywords is an
+        immutable property that shouldn't be edited."""
+        raise ValueError("keywords property is immutable")
+
+
+class MissingKeywordsError(_KeywordsBaseException):
+    """Raised when Missing a keyword for an argument"""
+
+    def __init__(self, keywords: set[str], *args: Any) -> None:
+        """Initializes missing keywords"""
+        super().__init__(
+            keywords,
+            f"Missing Keyword arguments for: {list(keywords)!r}",
+            *args,
+        )
+
+
+class InvalidParametersError(_KeywordsBaseException):
+    """Raised when Parameters were positional arguments without defaults or keyword arguments"""
+
+    def __init__(self, keywords: set[str], *args: Any) -> None:
+        """initializes invalid keywords, deprecated parameters should not be positional arguments
+        as that would defeat the purpose of deprecating a function's parameters."""
+        super().__init__(
+            keywords,
+            f"Arguments :{list(keywords)!r} should not be positional",
+            *args,
+        )
+
+
+def join_version_if_sequence(ver: str | Sequence[int]) -> str:
+    return ".".join(map(str, ver)) if not isinstance(ver, str) else ver
+
+
+def convert_removed_in_sequences(
+    removed_in: Mapping[str, str | Sequence[int]],
+) -> dict[str, str]:
+    return {k: join_version_if_sequence(v) for k, v in removed_in.items()}
+
+
+class deprecated_params:
+    """
+    A Wrapper inspired by python's wrapper deprecated from 3.13
+    and is used to deprecate parameters.
+
+    Since version 0.1.8 this wrapper also passes along an attribute
+    called `__deprecated_params__` with a dictionary of all the
+    preloaded deprecation warnings to each given parameter. Ides
+    such as VSCode, Pycharm and more could theoretically utilize
+    `__deprecated_params__` elsewhere help to assist users and developers
+    while writing and editing code.
+    """
+
+    # __slots__ was an optimizations since subclassing deprecated_params should really be discouraged
+    # if this is not your case scenario and you must subclass this object throw me an issue.
+
+    __slots__ = (
+        "params",
+        "message",
+        "message_is_dict",
+        "display_kw",
+        "category",
+        "stacklevel",
+        "default_message",
+        "removed_in",
+        "_warning_messages",
+    )
+
+    def __init__(
+        self,
+        params: Sequence[str] | Iterable[str] | str,
+        message: str | Mapping[str, str] = "is deprecated",
+        /,
+        *,
+        # default_message should be utilized when a keyword isn't
+        # given in message if messaged is defined as a dictionary.
+        default_message: str | None = None,
+        category: type[Warning] | None = DeprecationWarning,
+        stacklevel: int = 1,
+        display_kw: bool = True,
+        # removed_in is inspired by the deprecation library
+        removed_in: str
+        | Sequence[int]
+        | Mapping[str, str | Sequence[int]]
+        | None = None,
+    ) -> None:
+        """
+        Initializes deprecated parameters to pass along to different functions
+
+        :param params: A Sequence of keyword parameters of single keyword parameter to deprecate and warn the removal of.
+        :param message: A single message for to assign to each parameter to be deprecated otherwise
+            you can deprecate multiple under different reasons::
+
+                @deprecated_params(
+                    ['mispel', 'x'],
+                    message={
+                        'mispel': 'mispel was deprecated due to misspelling the word',
+                        'x':'you get the idea...'
+                    }
+                )
+                def mispelled_func(misspelling = None, *, mispel:str, x:int): ...
+
+        :param category: Used to warrant a custom warning category if required or needed to specify what
+            Deprecation warning should appear.
+        :param stacklevel: What level should this wanring appear at? Default: 1
+        :param default_message: When a parameter doesn't have a warning message try using this message instead
+        :param display_kw: Displays which parameter is deprecated in the warning message under `Parameter "%s" ...`
+            followed by the rest of the message
+        :param removed_in: Displays which version of your library's program will remove this keyword parameter in::
+
+                @deprecated_params(
+                    ['mispel', 'x'],
+                    removed_in={
+                        'mispel':'0.1.4',
+                        'x':(0, 1, 3)
+                    } # sequences of numbers are also allowed if preferred.
+                )
+
+                def mispelled_func(misspelling = None, *, mispel:str, x:int): ...
+
+            you can also say that all parameters will be removed in one version::
+
+                @deprecated_params(
+                    ['mispel', 'x'],
+                    removed_in='0.1.5' # or (0, 1, 5)
+                )
+                def mispelled_func(misspelling = None, *, mispel:str, x:int): ...
+
+
+        """
+        if not params:
+            raise ValueError(f"params should not be empty got {params!r}")
+        if not isinstance(message, (str, dict, Mapping)):
+            raise TypeError(
+                f"Expected an object of type str or dict or Mappable type for 'message', not {type(message).__name__!r}"
+            )
+
+        self.params = (
+            set(params) if not isinstance(params, str) else set([params])
+        )
+
+        self.message = message or "is deprecated"
+        self.message_is_dict = isinstance(message, (Mapping, dict))
+        self.display_kw = display_kw
+        self.category = category
+        self.stacklevel = stacklevel
+        self.default_message = default_message or "do not use"
+
+        if removed_in:
+            if isinstance(removed_in, (dict, Mapping)):
+                # Some people might be more comfortable giving versions in tuples or lists.
+                self.removed_in = convert_removed_in_sequences(removed_in)
+            else:
+                # single removed version meaning that all parameters will be removed in this version
+                ver = join_version_if_sequence(removed_in)
+                self.removed_in = {k: ver for k in params}
+        else:
+            self.removed_in = {}
+
+        # Preloaded previews of all warning messages new in deprecated-params 0.1.8 for extra speed
+        # upon loading the message
+        self._warning_messages: dict[str, str] = {
+            p: self.__write_warning(p) for p in self.params
+        }
+
+    def __check_with_missing(
+        self,
+        fn: Callable[..., Any],
+        missing: set[str] | None = None,
+        invalid_params: set[str] | None = None,
+        skip_missing: bool | None = None,
+        allow_miss: bool = False,
+    ) -> tuple[set[str], set[str], bool]:
+        sig = inspect.signature(fn)
+
+        missing = missing if missing is not None else set(self.params)
+        invalid_params = set() if invalid_params is None else invalid_params
+
+        skip_missing = (
+            any([p.kind == VAR_KEYWORD for p in sig.parameters.values()])
+            if skip_missing is None
+            else skip_missing
+        )
+
+        for m in self.params:
+            if not allow_miss:
+                p = sig.parameters[m]
+            else:
+                p = sig.parameters.get(m)  # type: ignore
+                if p is None:
+                    continue
+
+            # Check if were keyword only or aren't carrying a default param
+            if p.kind != KEYWORD_ONLY:
+                # Anything this isn't a keyword should be considered as deprecated
+                # as were still technically using it.
+                invalid_params.add(p.name)
+
+            if not skip_missing:
+                missing.remove(p.name)
+
+        return missing, invalid_params, skip_missing
+
+    def __check_for_missing_kwds(
+        self,
+        fn: Callable[..., Any],
+        missing: set[str] | None = None,
+        invalid_params: set[str] | None = None,
+        skip_missing: bool | None = None,
+        allow_miss: bool = False,
+    ) -> None:
+        # copy sequence to check for missing parameter names
+        missing, invalid_params, skip_missing = self.__check_with_missing(
+            fn, missing, invalid_params, skip_missing, allow_miss
+        )
+
+        if invalid_params:
+            raise InvalidParametersError(invalid_params)
+
+        if missing and not skip_missing:
+            raise MissingKeywordsError(missing)
+
+    def __write_warning(self, kw_name: str) -> str:
+        msg = ""
+        if self.display_kw:
+            msg += 'Parameter "%s" ' % kw_name
+
+        if self.message_is_dict:
+            msg += self.message.get(kw_name, self.default_message)  # type: ignore
+        else:
+            msg += self.message  # type: ignore
+
+        if self.removed_in:
+            if kw_removed_in := self.removed_in.get(kw_name):
+                msg += " [Removed In: "
+                msg += kw_removed_in
+                msg += "]"
+
+        return msg
+
+    def __warn(self, kw_name: str, source: Any) -> None:
+        warnings.warn(
+            self._warning_messages[kw_name],
+            self.category,
+            stacklevel=self.stacklevel + 1,
+            source=source,
+        )
+
+    @overload
+    def __call__(self, arg: type[_T]) -> type[_T]: ...
+
+    @overload
+    def __call__(self, arg: Callable[_P, _T]) -> Callable[_P, _T]: ...
+
+    # Mirrors python's deprecated wrapper with a few changes
+    # Since 0.1.8 a new attribute is added called __deprecated_params__
+    # based off and inspired by python's __deprecated__ dunder value.
+
+    def __call__(
+        self, arg: type[_T] | Callable[_P, _T]
+    ) -> type[_T] | Callable[_P, _T]:
+        def check_kw_arguments(kw: dict[str, Any]) -> None:
+            captured = self.params.intersection(kw.keys())
+            for k in captured:
+                self.__warn(k, arg)
+
+        if isinstance(arg, type):
+            # NOTE: Combining init and new together is done to
+            # solve deprecation of both new_args and init_args
+
+            missing, invalid_params, skip_missing = self.__check_with_missing(
+                arg, allow_miss=True
+            )
+
+            original_new: Callable[..., type[_T]] = arg.__new__
+            self.__check_for_missing_kwds(
+                original_new,
+                missing,
+                invalid_params,
+                skip_missing,
+                allow_miss=True,
+            )
+
+            @wraps(original_new)
+            def __new__(
+                cls: type[_T], *args: _P.args, **kwargs: _P.kwargs
+            ) -> type[_T]:
+                check_kw_arguments(kwargs)
+                if original_new is not object.__new__:
+                    return original_new(cls, *args, **kwargs)
+                # Python Comment: Mirrors a similar check in object.__new__.
+                elif cls.__init__ is object.__init__ and (args or kwargs):
+                    raise TypeError(f"{cls.__name__}() takes no arguments")
+                else:
+                    return original_new(cls)
+
+            arg.__new__ = staticmethod(__new__)  # type: ignore
+            arg.__new__.__deprecated_params__ = self._warning_messages.copy()  # type: ignore
+
+            original_init_subclass = arg.__init_subclass__
+            # Python Comment: We need slightly different behavior if __init_subclass__
+            # is a bound method (likely if it was implemented in Python)
+            if isinstance(original_init_subclass, MethodType):
+                self.__check_for_missing_kwds(
+                    original_init_subclass,
+                    missing,
+                    invalid_params,
+                    skip_missing,
+                    allow_miss=True,
+                )
+                original_init_subclass = original_init_subclass.__func__
+
+                @wraps(original_init_subclass)
+                def __init_subclass__(
+                    *args: _P.args, **kwargs: _P.kwargs
+                ) -> Any:
+                    check_kw_arguments(kwargs)
+                    return original_init_subclass(*args, **kwargs)
+
+                arg.__init_subclass__ = classmethod(__init_subclass__)  # type: ignore
+                arg.__init_subclass__.__deprecated_params__ = (  # type: ignore[attr-defined]
+                    self._warning_messages.copy()
+                )
+
+            # Python Comment: Or otherwise, which likely means it's a builtin such as
+            # object's implementation of __init_subclass__.
+            else:
+
+                @wraps(original_init_subclass)
+                def __init_subclass__(
+                    *args: _P.args, **kwargs: _P.kwargs
+                ) -> None:
+                    check_kw_arguments(kwargs)
+                    return original_init_subclass(*args, **kwargs)
+
+                arg.__init_subclass__ = __init_subclass__  # type: ignore
+                arg.__init_subclass__.__deprecated_params__ = (  # type: ignore[attr-defined]
+                    self._warning_messages.copy()
+                )
+            return arg
+
+        elif callable(arg):
+            # Check for missing function arguments
+            self.__check_for_missing_kwds(arg)
+
+            @wraps(arg)
+            def wrapper(*args: _P.args, **kwargs: _P.kwargs) -> _T:
+                check_kw_arguments(kwargs)
+                return arg(*args, **kwargs)
+
+            if sys.version_info >= (3, 12):
+                if inspect.iscoroutinefunction(arg):
+                    wrapper = inspect.markcoroutinefunction(wrapper)
+
+            # Wrapper now contains a shadow copy of deprecated parameters
+            wrapper.__deprecated_params__ = self._warning_messages.copy()  # type: ignore
+            return wrapper
+
+        else:
+            raise TypeError(
+                "@deprecated_params decorator with non-None category must be applied to "
+                f"a class or callable, not {arg!r}"
+            )

deprecated_params-0.2.0/deprecated_params.egg-info/PKG-INFO

@@ -0,0 +1,87 @@
+Metadata-Version: 2.4
+Name: deprecated-params
+Version: 0.2.0
+Summary: A Wrapper for functions, class objects and methods for deprecating keyword parameters
+Author-email: Vizonex <VizonexBusiness@gmail.com>
+License-Expression: MIT
+Project-URL: homepage, https://github.com/Vizonex/deprecated-params
+Project-URL: repository, https://github.com/Vizonex/deprecated-params.git
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typing-extensions; python_version < "3.10"
+Dynamic: license-file
+
+# Deprecated Params 
+[![PyPI version](https://badge.fury.io/py/deprecated-params.svg)](https://badge.fury.io/py/deprecated-params)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/deprecated-params)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![License: Appache-2.0](https://img.shields.io/badge/License-Appache-yellow.svg)](https://opensource.org/licenses/Appache-2-0)
+
+
+Inspired after python's warning.deprecated wrapper, deprecated_params is made to serve the single purpose of deprecating parameter names to warn users
+about incoming changes as well as retaining typehinting.
+
+
+
+## How to Deprecate Parameters
+Parameters should be keyword arguments, not positional, Reason
+for this implementation is that in theory you should've already 
+planned an alternative approach to an argument you wish 
+to deprecate. Most of the times these arguments will most 
+likely be one of 3 cases.
+- misspellings
+- better functionality that replaces old arguments with better ones.
+- removed parameters but you want to warn developers
+  to move without being aggressive about it.
+
+
+```python
+from deprecated_params import deprecated_params
+
+@deprecated_params(['x'])
+def func(y, *, x:int = 0):
+    pass
+
+# DeprecationWarning: Parameter "x" is deprecated
+func(None, x=20)
+
+# NOTE: **kw is accepted but also you could put down more than one 
+# parameter if needed...
+@deprecated_params(['foo'], {"foo":"foo was removed in ... don't use it"}, display_kw=False)
+class MyClass:
+    def __init__(self, spam:object, **kw):
+        self.spam = spam
+        self.foo = kw.get("foo", None)
+
+# DeprecationWarning: foo was removed in ... don't use it
+mc = MyClass("spam", foo="X")
+```
+
+## Why I wrote Deprecated Params
+I got tired of throwing random warnings in my code and wanted something cleaner that didn't 
+interfere with a function's actual code and didn't blind anybody trying to go through it. 
+Contributors and Reviewers should be able to utilize a library that saves them from these problems
+while improving the readability of a function. After figuring out that the functionality I was 
+looking for didn't exist I took the opportunity to implement it.
+
+## Deprecated Params used in real-world Examples 
+Deprecated-params is now used with two of my own libraries by default. 
+
+- [aiothreading (up until 0.1.6)](https://github.com/Vizonex/aiothreading)
+  - Originally aiothreading had it's own wrapper but I split it off to this library along with a rewrite after finding out that
+    parameter names were not showing up ides such as vs-code. The rewrite felt a bit bigger and knowing that users would want to utilize
+    this concept in other places was how this library ultimately got started.
+  - Lots of interior changes were made and with many arguments being suddenly dropped to increase the performance, the best solution was to warn
+    developers to stop using certain parameters as they will be deleted in the future.
+  - It is planned to be dropped as many of the things we wanted to remove have been slowly removed from the library which means this library will
+    be removed from it but that doesn't mean I won't keep maintaining it, it is invented for short-use cases and can be added and removed freely
+    without needing additional dependencies. 
+
+- [aiocallback (mainly used in version 1.6)](https://github.com/Vizonex/aiocallback)
+  - Same situation as aiothreading but I decided to buy users more time due to how fast some releases were going and it also allowed
+  - Currently I removed deprecated-params from aiocallback since it wasn't needed anymore but this is what deprecated-param's purpose 
+    was for, being there only when its need. I desired nothing more or less.
+
+If you would like to add examples of your own libraries that have used this library feel free to throw me an issue or send me a pull request.
+

deprecated_params-0.2.0/deprecated_params.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+deprecated_params/__init__.py
+deprecated_params.egg-info/PKG-INFO
+deprecated_params.egg-info/SOURCES.txt
+deprecated_params.egg-info/dependency_links.txt
+deprecated_params.egg-info/requires.txt
+deprecated_params.egg-info/top_level.txt
+tests/test_wrapper.py

deprecated_params-0.2.0/deprecated_params.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

deprecated_params-0.2.0/deprecated_params.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[:python_version < "3.10"]
+typing-extensions

deprecated_params-0.2.0/deprecated_params.egg-info/top_level.txt

@@ -0,0 +1 @@
+deprecated_params

deprecated_params-0.2.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = [
+    "setuptools >= 47"
+]
+[project]
+name = "deprecated-params"
+version = "0.2.0"
+description = "A Wrapper for functions, class objects and methods for deprecating keyword parameters"
+readme = "README.md"
+authors = [
+    { name = "Vizonex", email="VizonexBusiness@gmail.com"},
+]
+license = "MIT"
+requires-python = ">=3.9"
+dependencies = [
+    'typing-extensions; python_version<"3.10"'
+]
+
+
+[project.urls]
+    homepage = "https://github.com/Vizonex/deprecated-params"
+    repository = "https://github.com/Vizonex/deprecated-params.git"
+
+[tool.ruff]
+line-length = 79
+indent-width = 4
+target-version = "py39"
+fix = true

deprecated_params-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

deprecated_params-0.2.0/setup.py

@@ -0,0 +1,4 @@
+from setuptools import setup
+
+if __name__ == "__main__":
+    setup()

deprecated_params-0.2.0/tests/test_wrapper.py

@@ -0,0 +1,142 @@
+import pytest
+from typing import Optional
+from deprecated_params import deprecated_params
+import sys
+import warnings
+
+
+# should carry w x y
+def test_deprecated_param() -> None:
+    @deprecated_params(["x"], "is deprecated")
+    def my_func(w: int, *, x: int = 0, y: int = 0) -> None:
+        pass
+
+    with pytest.warns(DeprecationWarning, match='Parameter "x" is deprecated'):
+        my_func(0, x=0)
+
+
+def test_single_deprecated_param() -> None:
+    @deprecated_params("x", "is deprecated")
+    def my_func(w: int, *, x: int = 0, y: int = 0) -> None:
+        pass
+
+    with pytest.warns(DeprecationWarning, match='Parameter "x" is deprecated'):
+        my_func(0, x=0)
+
+
+def test_no_warn_if_deprecated_parameter_not_passed() -> None:
+    @deprecated_params("x", "is deprecated")
+    def my_func(w: int, *, x: int = 0, y: int = 0) -> None:
+        pass
+
+    # Do not raise or print a warning when X is not passed...
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+        my_func(1, y=0)
+
+
+def test_deprecated_param_removed_in() -> None:
+    @deprecated_params(["x"], "is deprecated", removed_in={"x": (0, 1, 5)})
+    def my_func(w: int, *, x: int = 0, y: int = 0) -> None:
+        pass
+
+    with pytest.warns(
+        DeprecationWarning,
+        match=r"Parameter \"x\" is deprecated \[Removed In\: 0.1.5\]",
+    ):
+        my_func(0, x=0)
+
+
+def test_deprecated_params_dunder_attribute() -> None:
+    @deprecated_params(["x"], "is deprecated", removed_in={"x": (0, 1, 5)})
+    def my_func(w: int, *, x: int = 0, y: int = 0) -> None:
+        pass
+
+    assert getattr(my_func, "__deprecated_params__") == {
+        "x": 'Parameter "x" is deprecated [Removed In: 0.1.5]'
+    }
+
+
+# Since 0.2.0 we no longer repeat warnings once. We do it
+# so that developers are more willing to remove specific keyword parameters
+def test_deprecated_param_repeat_twice() -> None:
+    @deprecated_params(["x"], "is deprecated", removed_in={"x": (0, 1, 5)})
+    def my_func(w: int, *, x: int = 0, y: int = 0) -> None:
+        pass
+
+    with pytest.warns(
+        DeprecationWarning,
+        match=r"Parameter \"x\" is deprecated \[Removed In\: 0.1.5\]",
+    ):
+        my_func(0, x=0)
+
+    with pytest.warns(
+        DeprecationWarning,
+        match=r"Parameter \"x\" is deprecated \[Removed In\: 0.1.5\]",
+    ):
+        my_func(0, x=0)
+
+
+def test_class_wrapper_and_kw_display_disabled() -> None:
+    @deprecated_params(["foo"], "foo is deprecated", display_kw=False)
+    class MyClass:
+        def __init__(self, spam: str, *, foo: Optional[str] = None):
+            self.spam = spam
+            self.foo = foo
+
+    mc = MyClass("spam")
+    assert mc.spam == "spam"
+    assert mc.foo is None
+
+    with pytest.warns(DeprecationWarning, match="foo is deprecated"):
+        MyClass("spam", foo="foo")
+
+
+def test_class_wrapper_and_kw_display_disabled_one_param() -> None:
+    @deprecated_params("foo", "foo is deprecated", display_kw=False)
+    class MyClass:
+        def __init__(self, spam: str, *, foo: Optional[str] = None):
+            self.spam = spam
+            self.foo = foo
+
+    mc = MyClass("spam")
+    assert mc.spam == "spam"
+    assert mc.foo is None
+
+    with pytest.warns(DeprecationWarning, match="foo is deprecated"):
+        MyClass("spam", foo="foo")
+
+
+# There was nothing sillier than this...
+class TornadoWarning(DeprecationWarning):
+    pass
+
+
+@pytest.mark.skipif(sys.version_info < (3, 10), reason="kw_only not on 3.9")
+def test_dataclasses_with_wrapper_message_dicts_custom_warning() -> None:
+    from dataclasses import dataclass, field
+
+    @deprecated_params(
+        ["foo", "spam"],
+        {"foo": "got foo", "spam": "got spam"},
+        display_kw=False,
+        category=TornadoWarning,
+    )
+    @dataclass
+    class Class:
+        foo: Optional[str] = field(kw_only=True, default=None)
+        spam: Optional[str] = field(kw_only=True, default=None)
+
+    with pytest.warns(TornadoWarning, match="got foo"):
+        Class(foo="foo")
+
+    with pytest.warns(TornadoWarning, match="got spam"):
+        Class(spam="foo")
+
+    # Do Not raise if class doesn't pass a deprecated parameter
+    with warnings.catch_warnings():
+        warnings.simplefilter(action="error")
+        Class()
+
+
+# TODO: Metaclasses...