%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 - 0.0.30-1 - Package Spec generated