diff options
| -rw-r--r-- | www/py-requests-cache93/Makefile | 2 | ||||
| -rw-r--r-- | www/py-requests-cache93/files/patch-cattrs | 186 |
2 files changed, 187 insertions, 1 deletions
diff --git a/www/py-requests-cache93/Makefile b/www/py-requests-cache93/Makefile index 33f06ea80c69..cc4bd10f93cc 100644 --- a/www/py-requests-cache93/Makefile +++ b/www/py-requests-cache93/Makefile @@ -13,7 +13,7 @@ LICENSE_FILE= ${WRKSRC}/LICENSE RUN_DEPENDS= ${PYTHON_PKGNAMEPREFIX}appdirs>=1.4.4<2.0.0:devel/py-appdirs@${PY_FLAVOR} \ ${PYTHON_PKGNAMEPREFIX}attrs>=21.2<22.0:devel/py-attrs@${PY_FLAVOR} \ - ${PYTHON_PKGNAMEPREFIX}cattrs>=1.8<2.0:devel/py-cattrs@${PY_FLAVOR} \ + ${PYTHON_PKGNAMEPREFIX}cattrs>=1.8<22.2:devel/py-cattrs@${PY_FLAVOR} \ ${PYTHON_PKGNAMEPREFIX}requests>=2.22<3.0:www/py-requests@${PY_FLAVOR} \ ${PYTHON_PKGNAMEPREFIX}url-normalize>=1.4<2.0:net/py-url-normalize@${PY_FLAVOR} \ ${PYTHON_PKGNAMEPREFIX}urllib3>=1.25.5,1<2.0.0,1:net/py-urllib3@${PY_FLAVOR} diff --git a/www/py-requests-cache93/files/patch-cattrs b/www/py-requests-cache93/files/patch-cattrs new file mode 100644 index 000000000000..c94d37779c38 --- /dev/null +++ b/www/py-requests-cache93/files/patch-cattrs @@ -0,0 +1,186 @@ +Obtained from: https://github.com/requests-cache/requests-cache/commit/66550b5355f4a4f063b4b22c3139a2f941c91eb4 + +--- requests_cache/serializers/preconf.py.orig 2022-02-23 03:10:56 UTC ++++ requests_cache/serializers/preconf.py +@@ -1,9 +1,10 @@ ++# flake8: noqa: F841 + """The ``cattrs`` library includes a number of `pre-configured converters + <https://cattrs.readthedocs.io/en/latest/preconf.html>`_ that perform some pre-serialization steps + required for specific serialization formats. + + This module wraps those converters as serializer :py:class:`.Stage` objects. These are then used as +-a stage in a :py:class:`.SerializerPipeline`, which runs after the base converter and before the ++stages in a :py:class:`.SerializerPipeline`, which runs after the base converter and before the + format's ``dumps()`` (or equivalent) method. + + For any optional libraries that aren't installed, the corresponding serializer will be a placeholder +@@ -13,70 +14,95 @@ class that raises an ``ImportError`` at initialization + :nosignatures: + """ + import pickle ++from datetime import timedelta ++from decimal import Decimal + from functools import partial ++from importlib import import_module + +-from cattr.preconf import bson as bson_preconf +-from cattr.preconf import json as json_preconf +-from cattr.preconf import msgpack, orjson, pyyaml, tomlkit, ujson ++from cattr import GenConverter + + from .._utils import get_placeholder_class + from .cattrs import CattrStage + from .pipeline import SerializerPipeline, Stage + +-base_stage = ( +- CattrStage() +-) #: Base stage for all serializer pipelines (or standalone dict serializer) +-dict_serializer = base_stage #: Partial serializer that unstructures responses into dicts +-bson_preconf_stage = CattrStage(bson_preconf.make_converter) #: Pre-serialization steps for BSON +-json_preconf_stage = CattrStage(json_preconf.make_converter) #: Pre-serialization steps for JSON +-msgpack_preconf_stage = CattrStage(msgpack.make_converter) #: Pre-serialization steps for msgpack +-orjson_preconf_stage = CattrStage(orjson.make_converter) #: Pre-serialization steps for orjson +-yaml_preconf_stage = CattrStage(pyyaml.make_converter) #: Pre-serialization steps for YAML +-toml_preconf_stage = CattrStage(tomlkit.make_converter) #: Pre-serialization steps for TOML +-ujson_preconf_stage = CattrStage(ujson.make_converter) #: Pre-serialization steps for ultrajson +-pickle_serializer = SerializerPipeline( +- [base_stage, pickle], is_binary=True +-) #: Complete pickle serializer ++ ++def make_stage(preconf_module: str, **kwargs): ++ """Create a preconf serializer stage from a module name, if dependencies are installed""" ++ try: ++ factory = import_module(preconf_module).make_converter ++ return CattrStage(factory, **kwargs) ++ except ImportError as e: ++ return get_placeholder_class(e) ++ ++ ++# Pre-serialization stages ++base_stage = CattrStage() #: Base stage for all serializer pipelines + utf8_encoder = Stage(dumps=str.encode, loads=lambda x: x.decode()) #: Encode to bytes ++bson_preconf_stage = make_stage('cattr.preconf.bson') #: Pre-serialization steps for BSON ++json_preconf_stage = make_stage('cattr.preconf.json') #: Pre-serialization steps for JSON ++msgpack_preconf_stage = make_stage('cattr.preconf.msgpack') #: Pre-serialization steps for msgpack ++orjson_preconf_stage = make_stage('cattr.preconf.orjson') #: Pre-serialization steps for orjson ++toml_preconf_stage = make_stage('cattr.preconf.tomlkit') #: Pre-serialization steps for TOML ++ujson_preconf_stage = make_stage('cattr.preconf.ujson') #: Pre-serialization steps for ultrajson ++yaml_preconf_stage = make_stage('cattr.preconf.pyyaml') #: Pre-serialization steps for YAML + ++# Basic serializers with no additional dependencies ++dict_serializer = SerializerPipeline( ++ [base_stage], is_binary=False ++) #: Partial serializer that unstructures responses into dicts ++pickle_serializer = SerializerPipeline( ++ [base_stage, Stage(pickle)], is_binary=True ++) #: Pickle serializer + + # Safe pickle serializer +-try: ++def signer_stage(secret_key=None, salt='requests-cache') -> Stage: ++ """Create a stage that uses ``itsdangerous`` to add a signature to responses on write, and ++ validate that signature with a secret key on read. Can be used in a ++ :py:class:`.SerializerPipeline` in combination with any other serialization steps. ++ """ + from itsdangerous import Signer + +- def signer_stage(secret_key=None, salt='requests-cache') -> Stage: +- """Create a stage that uses ``itsdangerous`` to add a signature to responses on write, and +- validate that signature with a secret key on read. Can be used in a +- :py:class:`.SerializerPipeline` in combination with any other serialization steps. +- """ +- return Stage(Signer(secret_key=secret_key, salt=salt), dumps='sign', loads='unsign') ++ return Stage( ++ Signer(secret_key=secret_key, salt=salt), ++ dumps='sign', ++ loads='unsign', ++ ) + +- def safe_pickle_serializer( +- secret_key=None, salt='requests-cache', **kwargs +- ) -> SerializerPipeline: +- """Create a serializer that uses ``pickle`` + ``itsdangerous`` to add a signature to +- responses on write, and validate that signature with a secret key on read. +- """ +- return SerializerPipeline( +- [base_stage, pickle, signer_stage(secret_key, salt)], is_binary=True +- ) + ++def safe_pickle_serializer(secret_key=None, salt='requests-cache', **kwargs) -> SerializerPipeline: ++ """Create a serializer that uses ``pickle`` + ``itsdangerous`` to add a signature to ++ responses on write, and validate that signature with a secret key on read. ++ """ ++ return SerializerPipeline( ++ [base_stage, Stage(pickle), signer_stage(secret_key, salt)], ++ is_binary=True, ++ ) ++ ++ ++try: ++ import itsdangerous # noqa: F401 + except ImportError as e: + signer_stage = get_placeholder_class(e) + safe_pickle_serializer = get_placeholder_class(e) + + + # BSON serializer +-try: ++def _get_bson_functions(): ++ """Handle different function names between pymongo's bson and standalone bson""" + try: +- from bson import decode as _bson_loads +- from bson import encode as _bson_dumps ++ import pymongo # noqa: F401 ++ ++ return {'dumps': 'encode', 'loads': 'decode'} + except ImportError: +- from bson import dumps as _bson_dumps +- from bson import loads as _bson_loads ++ return {'dumps': 'dumps', 'loads': 'loads'} + ++ ++try: ++ import bson ++ + bson_serializer = SerializerPipeline( +- [bson_preconf_stage, Stage(dumps=_bson_dumps, loads=_bson_loads)], is_binary=True ++ [bson_preconf_stage, Stage(bson, **_get_bson_functions())], ++ is_binary=True, + ) #: Complete BSON serializer; uses pymongo's ``bson`` if installed, otherwise standalone ``bson`` codec + except ImportError as e: + bson_serializer = get_placeholder_class(e) +@@ -94,7 +120,8 @@ except ImportError: + + _json_stage = Stage(dumps=partial(json.dumps, indent=2), loads=json.loads) + json_serializer = SerializerPipeline( +- [_json_preconf_stage, _json_stage], is_binary=False ++ [_json_preconf_stage, _json_stage], ++ is_binary=False, + ) #: Complete JSON serializer; uses ultrajson if available + + +@@ -102,11 +129,9 @@ json_serializer = SerializerPipeline( + try: + import yaml + ++ _yaml_stage = Stage(yaml, loads='safe_load', dumps='safe_dump') + yaml_serializer = SerializerPipeline( +- [ +- yaml_preconf_stage, +- Stage(yaml, loads='safe_load', dumps='safe_dump'), +- ], ++ [yaml_preconf_stage, _yaml_stage], + is_binary=False, + ) #: Complete YAML serializer + except ImportError as e: +--- setup.py.orig 1970-01-01 00:00:00 UTC ++++ setup.py +@@ -13,7 +13,7 @@ package_data = \ + install_requires = \ + ['appdirs>=1.4.4,<2.0.0', + 'attrs>=21.2,<22.0', +- 'cattrs>=1.8,<2.0', ++ 'cattrs>=1.8,<22.2', + 'requests>=2.22,<3.0', + 'url-normalize>=1.4,<2.0', + 'urllib3>=1.25.5,<2.0.0'] |