diff options
Diffstat (limited to 'python-pyre-extensions.spec')
| -rw-r--r-- | python-pyre-extensions.spec | 317 |
1 files changed, 317 insertions, 0 deletions
diff --git a/python-pyre-extensions.spec b/python-pyre-extensions.spec new file mode 100644 index 0000000..8115eaf --- /dev/null +++ b/python-pyre-extensions.spec @@ -0,0 +1,317 @@ +%global _empty_manifest_terminate_build 0 +Name: python-pyre-extensions +Version: 0.0.30 +Release: 1 +Summary: Type system extensions for use with the pyre type checker +License: MIT License +URL: https://pyre-check.org +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/5e/9f/ef13dd193dbf2e36bfe7fa96b72a2fc23fc0b24b18fb1998c79056e77bdc/pyre-extensions-0.0.30.tar.gz +BuildArch: noarch + +Requires: python3-typing-inspect +Requires: python3-typing-extensions + +%description +# Pyre Extensions +This module defines extensions to the standard “typing” module that are supported by the [Pyre typechecker](https://pypi.org/project/pyre-check/). + +## `none_throws` +Function to make assumptions about `Optional`s explicit. The function will raise an +assertion error if passed `None` and return the value otherwise. + +## ParameterSpecification +`ParameterSpecification`s are a special kind of type variable that captures callable parameter +specifications (known as argspecs in the runtime and inspect library) instead of types, allowing +the typing of decorators which transform the return type of the given callable. +For example: +``` +from typing import TypeVar, Callable, List +from pyre_extensions import ParameterSpecification +TParams = ParameterSpecification("TParams") +TReturn = TypeVar("TReturn") +def unwrap(f: Callable[TParams, List[TReturn]]) -> Callable[TParams, TReturn]: + def inner(*args: TParams.args, **kwargs: TParams.kwargs) -> TReturn: + return f(*args, **kwargs)[0] + + return inner +@unwrap +def foo(x: int, y: str, z: bool = False) -> List[int]: + return [1, 2, 3] +``` +decorates foo into a callable that returns int, but still has the same parameters, including their +names and whether they are required. + +These `ParameterSpecification` variables also have two special properties, `args` and `kwargs`, +which correspond to the positional and keyword arguments for a specific call to the +`ParameterSpecification` function. Because the division of parameters into these two argument +collections can be different each invocation, these special annotations can only be used in one +manner: together, in a function definition, as `*args` and `**kwargs` with no other parameters +listed. + +## Safe JSON +The `safe_json` module provides a type-safe way to parse JSON. It is meant as a drop-in replacement +for the builtin `json` module but instead of returning an object of undefined shape (i.e. `Any`) +allows you to specify the shape of the JSON you're expecting. The parser will validate whether the +input matches the expected type and raise an exception if it does not. + +### Examples +For trivial JSON structures you can use builtin types: + +```python +>>> from pyre_extensions import safe_json +>>> from typing import List, Dict +>>> safe_json.loads("[1, 2, 3]", List[int]) +[1, 2, 3] +>>> safe_json.loads("[1, 2, 3]", List[str]) +# Raises `pyre_extensions.safe_json.InvalidJson` +>>> safe_json.loads('{"key": "value"}', Dict[str, str]) +{'key': 'value'} +>>> safe_json.loads('{"key": "value"}', Dict[str, int]) +# Raises `pyre_extensions.safe_json.InvalidJson` +``` + +For more complicated, nested structures, typed dictionaries are the way to go: +```python +>>> from typing import TypedDict +>>> class Movie(TypedDict): +... name: str +... year: int +... +>>> safe_json.loads('{"name": "Blade Runner", "year": 1982 }', Movie) +{'name': 'Blade Runner', 'year': 1982} +>>> safe_json.loads('{"name": "Blade Runner", "year": "1982" }', Movie) +# Raises `pyre_extensions.safe_json.InvalidJson` +``` + +Validate if data is expected type: +```python +>>> from pyre_extensions import safe_json +>>> from typing import List, Dict +>>> data = {"foo": 23} +>>> safe_json.validate(data, Dict[str, str]) +# Raises `pyre_extensions.safe_json.InvalidJson` +>>> safe_json.validate(data, Dict[str, int]) +{"foo": 23} +``` + + +%package -n python3-pyre-extensions +Summary: Type system extensions for use with the pyre type checker +Provides: python-pyre-extensions +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-pyre-extensions +# Pyre Extensions +This module defines extensions to the standard “typing” module that are supported by the [Pyre typechecker](https://pypi.org/project/pyre-check/). + +## `none_throws` +Function to make assumptions about `Optional`s explicit. The function will raise an +assertion error if passed `None` and return the value otherwise. + +## ParameterSpecification +`ParameterSpecification`s are a special kind of type variable that captures callable parameter +specifications (known as argspecs in the runtime and inspect library) instead of types, allowing +the typing of decorators which transform the return type of the given callable. +For example: +``` +from typing import TypeVar, Callable, List +from pyre_extensions import ParameterSpecification +TParams = ParameterSpecification("TParams") +TReturn = TypeVar("TReturn") +def unwrap(f: Callable[TParams, List[TReturn]]) -> Callable[TParams, TReturn]: + def inner(*args: TParams.args, **kwargs: TParams.kwargs) -> TReturn: + return f(*args, **kwargs)[0] + + return inner +@unwrap +def foo(x: int, y: str, z: bool = False) -> List[int]: + return [1, 2, 3] +``` +decorates foo into a callable that returns int, but still has the same parameters, including their +names and whether they are required. + +These `ParameterSpecification` variables also have two special properties, `args` and `kwargs`, +which correspond to the positional and keyword arguments for a specific call to the +`ParameterSpecification` function. Because the division of parameters into these two argument +collections can be different each invocation, these special annotations can only be used in one +manner: together, in a function definition, as `*args` and `**kwargs` with no other parameters +listed. + +## Safe JSON +The `safe_json` module provides a type-safe way to parse JSON. It is meant as a drop-in replacement +for the builtin `json` module but instead of returning an object of undefined shape (i.e. `Any`) +allows you to specify the shape of the JSON you're expecting. The parser will validate whether the +input matches the expected type and raise an exception if it does not. + +### Examples +For trivial JSON structures you can use builtin types: + +```python +>>> from pyre_extensions import safe_json +>>> from typing import List, Dict +>>> safe_json.loads("[1, 2, 3]", List[int]) +[1, 2, 3] +>>> safe_json.loads("[1, 2, 3]", List[str]) +# Raises `pyre_extensions.safe_json.InvalidJson` +>>> safe_json.loads('{"key": "value"}', Dict[str, str]) +{'key': 'value'} +>>> safe_json.loads('{"key": "value"}', Dict[str, int]) +# Raises `pyre_extensions.safe_json.InvalidJson` +``` + +For more complicated, nested structures, typed dictionaries are the way to go: +```python +>>> from typing import TypedDict +>>> class Movie(TypedDict): +... name: str +... year: int +... +>>> safe_json.loads('{"name": "Blade Runner", "year": 1982 }', Movie) +{'name': 'Blade Runner', 'year': 1982} +>>> safe_json.loads('{"name": "Blade Runner", "year": "1982" }', Movie) +# Raises `pyre_extensions.safe_json.InvalidJson` +``` + +Validate if data is expected type: +```python +>>> from pyre_extensions import safe_json +>>> from typing import List, Dict +>>> data = {"foo": 23} +>>> safe_json.validate(data, Dict[str, str]) +# Raises `pyre_extensions.safe_json.InvalidJson` +>>> safe_json.validate(data, Dict[str, int]) +{"foo": 23} +``` + + +%package help +Summary: Development documents and examples for pyre-extensions +Provides: python3-pyre-extensions-doc +%description help +# Pyre Extensions +This module defines extensions to the standard “typing” module that are supported by the [Pyre typechecker](https://pypi.org/project/pyre-check/). + +## `none_throws` +Function to make assumptions about `Optional`s explicit. The function will raise an +assertion error if passed `None` and return the value otherwise. + +## ParameterSpecification +`ParameterSpecification`s are a special kind of type variable that captures callable parameter +specifications (known as argspecs in the runtime and inspect library) instead of types, allowing +the typing of decorators which transform the return type of the given callable. +For example: +``` +from typing import TypeVar, Callable, List +from pyre_extensions import ParameterSpecification +TParams = ParameterSpecification("TParams") +TReturn = TypeVar("TReturn") +def unwrap(f: Callable[TParams, List[TReturn]]) -> Callable[TParams, TReturn]: + def inner(*args: TParams.args, **kwargs: TParams.kwargs) -> TReturn: + return f(*args, **kwargs)[0] + + return inner +@unwrap +def foo(x: int, y: str, z: bool = False) -> List[int]: + return [1, 2, 3] +``` +decorates foo into a callable that returns int, but still has the same parameters, including their +names and whether they are required. + +These `ParameterSpecification` variables also have two special properties, `args` and `kwargs`, +which correspond to the positional and keyword arguments for a specific call to the +`ParameterSpecification` function. Because the division of parameters into these two argument +collections can be different each invocation, these special annotations can only be used in one +manner: together, in a function definition, as `*args` and `**kwargs` with no other parameters +listed. + +## Safe JSON +The `safe_json` module provides a type-safe way to parse JSON. It is meant as a drop-in replacement +for the builtin `json` module but instead of returning an object of undefined shape (i.e. `Any`) +allows you to specify the shape of the JSON you're expecting. The parser will validate whether the +input matches the expected type and raise an exception if it does not. + +### Examples +For trivial JSON structures you can use builtin types: + +```python +>>> from pyre_extensions import safe_json +>>> from typing import List, Dict +>>> safe_json.loads("[1, 2, 3]", List[int]) +[1, 2, 3] +>>> safe_json.loads("[1, 2, 3]", List[str]) +# Raises `pyre_extensions.safe_json.InvalidJson` +>>> safe_json.loads('{"key": "value"}', Dict[str, str]) +{'key': 'value'} +>>> safe_json.loads('{"key": "value"}', Dict[str, int]) +# Raises `pyre_extensions.safe_json.InvalidJson` +``` + +For more complicated, nested structures, typed dictionaries are the way to go: +```python +>>> from typing import TypedDict +>>> class Movie(TypedDict): +... name: str +... year: int +... +>>> safe_json.loads('{"name": "Blade Runner", "year": 1982 }', Movie) +{'name': 'Blade Runner', 'year': 1982} +>>> safe_json.loads('{"name": "Blade Runner", "year": "1982" }', Movie) +# Raises `pyre_extensions.safe_json.InvalidJson` +``` + +Validate if data is expected type: +```python +>>> from pyre_extensions import safe_json +>>> from typing import List, Dict +>>> data = {"foo": 23} +>>> safe_json.validate(data, Dict[str, str]) +# Raises `pyre_extensions.safe_json.InvalidJson` +>>> safe_json.validate(data, Dict[str, int]) +{"foo": 23} +``` + + +%prep +%autosetup -n pyre-extensions-0.0.30 + +%build +%py3_build + +%install +%py3_install +install -d -m755 %{buildroot}/%{_pkgdocdir} +if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi +if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi +if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi +if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi +pushd %{buildroot} +if [ -d usr/lib ]; then + find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/lib64 ]; then + find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/bin ]; then + find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/sbin ]; then + find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst +fi +touch doclist.lst +if [ -d usr/share/man ]; then + find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst +fi +popd +mv %{buildroot}/filelist.lst . +mv %{buildroot}/doclist.lst . + +%files -n python3-pyre-extensions -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Tue Apr 11 2023 Python_Bot <Python_Bot@openeuler.org> - 0.0.30-1 +- Package Spec generated |