lexrpc 2.2__tar.gz → 3.0__tar.gz

{lexrpc-2.2/lexrpc.egg-info → lexrpc-3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lexrpc
-Version: 2.2
+Version: 3.0
 Summary: Python implementation of AT Protocol's XRPC + Lexicon
 Author-email: Ryan Barrett <lexrpc@ryanb.org>
 Project-URL: Homepage, https://github.com/snarfed/lexrpc
@@ -31,6 +31,8 @@ Requires-Dist: wsproto>=1.0; extra == "flask"
 Provides-Extra: docs
 Requires-Dist: sphinx>=7.0.0; extra == "docs"
 Requires-Dist: sphinx-rtd-theme>=3.0.0; extra == "docs"
+Provides-Extra: tests
+Requires-Dist: hypothesis>=6.0; extra == "tests"
 Dynamic: license-file
 
 lexrpc [![Circle CI](https://circleci.com/gh/snarfed/lexrpc.svg?style=svg)](https://circleci.com/gh/snarfed/lexrpc) [![Coverage Status](https://coveralls.io/repos/github/snarfed/lexrpc/badge.svg?branch=main)](https://coveralls.io/github/snarfed/lexrpc?branch=master)
@@ -183,6 +185,7 @@ Here's how to package, test, and ship a new release.
     ```sh
     source .venv/bin/activate.csh
     python -m unittest discover
+    python -m unittest lexrpc/tests/hypothesis/*.py
     ```
 1. Bump the version number in `pyproject.toml` and `docs/conf.py`. `git grep` the old version number to make sure it only appears in the changelog. Change the current changelog entry in `README.md` for this new version from _unreleased_ to the current date.
 1. Build the docs. If you added any new modules, add them to the appropriate file(s) in `docs/source/`. Then run `./docs/build.sh`. Check that the generated HTML looks fine by opening `docs/_build/html/index.html` and looking around.
@@ -219,7 +222,10 @@ Here's how to package, test, and ship a new release.
             'main': {
                 'type': 'query',
                 'description': 'Ping the server',
-                'parameters': {'message': { 'type': 'string' }},
+                'parameters': {
+                    'type': 'params',
+                    'properties': {'message': {'type': 'string'}},
+                },
                 'output': {
                     'encoding': 'application/json',
                     'schema': {
@@ -254,6 +260,36 @@ Here's how to package, test, and ship a new release.
 
 ## Changelog
 
+### 3.0 - 2026-10-18
+
+_Breaking changes:_
+
+* `flask_server`: [ATProto-decode JSON input](https://atproto.com/specs/data-model#relationship-with-dasl-and-ipld), so methods receive native `CID` and `bytes` values instead of `$link` and `$bytes` dicts. (Also encode methods' output the same way, as ATProto JSON, but that's backward compatible. Details below.)
+
+_Non-breaking changes:_
+
+* `Client`, `Server`: new `require_lexicons` kwarg, defaults to `True`. If `False`, records with missing or unknown lexicons are skipped during validation instead of raising `NotImplementedError`.
+* Schema validation:
+  * `Base.validate`: new `ignore` kwarg, a sequence of property names to skip validating or truncating, anywhere in the record.
+  * Fix `ref` type validation to accept string values that match their `ref`, eg token refs inside arrays or unions.
+  * Fix `minimum`/`maximum` schema constraint of `0`.
+  * `truncate`: truncate string values inside arrays.
+  * Fix crash on values with unexpected types when `truncate` is on but `validate` is off, and on non-object `parameters` values.
+  * Fail on float values, which aren't in the [data model](https://atproto.com/specs/data-model)
+  * Support the new [`space` lexicon type](https://github.com/bluesky-social/proposals/tree/main/0016-permissioned-data#space-type-declarations) and [`space-ref` string format](https://github.com/bluesky-social/proposals/tree/main/0016-permissioned-data#addressing), and allow space `at://` URIs in the `at-uri` format.
+* `Base.decode_params`: decode array values using their `items` type.
+* `XrpcError`: new `status` and `headers` kwargs. `flask_server` uses them in the HTTP response.
+* `Server.method`, `Server.register`: new `override` kwarg that allows replace an existing method.
+* `flask_server`:
+  * `init_flask`: new `fallback` kwarg, a callable that handles methods the `Server` doesn't implement instead of returning `MethodNotImplemented`. Useful for [ATservice proxying](https://atproto.com/specs/xrpc#service-proxying).
+  * Serve `OPTIONS` CORS preflight requests for methods without lexicons, and for subscriptions.
+  * [ATProto-encode JSON output](https://atproto.com/specs/data-model#relationship-with-dasl-and-ipld), so methods can return native `CID` and `bytes` values, which are encoded as `$link` and `$bytes`.
+* Bundle new lexicons:
+  * [Blacksky](https://blacksky.community/) (`community.blacksky.assembly`), from [blacksky-algorithms/assembly.blacksky.community@e95bd1f](https://github.com/blacksky-algorithms/assembly.blacksky.community/commit/e95bd1f4039e004115cd31f14d928ce5708fe83f).
+  * [Grain](https://grain.social/) (`social.grain`), from [grain.social/grain@319af78](https://tangled.org/grain.social/grain@319af78544239cdb0217d032e89c52dcd8595f0e).
+  * [Spark Social](https://sprk.so/) (`so.sprk`), from [sprksocial/server@3f4728d](https://github.com/sprksocial/server@3f4728db308b82ffa63a30cb28224af5beb406f6).
+
+
 ### 2.2 - 2026-06-29
 
 * Schema validation:

{lexrpc-2.2 → lexrpc-3.0}/README.md

@@ -148,6 +148,7 @@ Here's how to package, test, and ship a new release.
     ```sh
     source .venv/bin/activate.csh
     python -m unittest discover
+    python -m unittest lexrpc/tests/hypothesis/*.py
     ```
 1. Bump the version number in `pyproject.toml` and `docs/conf.py`. `git grep` the old version number to make sure it only appears in the changelog. Change the current changelog entry in `README.md` for this new version from _unreleased_ to the current date.
 1. Build the docs. If you added any new modules, add them to the appropriate file(s) in `docs/source/`. Then run `./docs/build.sh`. Check that the generated HTML looks fine by opening `docs/_build/html/index.html` and looking around.
@@ -184,7 +185,10 @@ Here's how to package, test, and ship a new release.
             'main': {
                 'type': 'query',
                 'description': 'Ping the server',
-                'parameters': {'message': { 'type': 'string' }},
+                'parameters': {
+                    'type': 'params',
+                    'properties': {'message': {'type': 'string'}},
+                },
                 'output': {
                     'encoding': 'application/json',
                     'schema': {
@@ -219,6 +223,36 @@ Here's how to package, test, and ship a new release.
 
 ## Changelog
 
+### 3.0 - 2026-10-18
+
+_Breaking changes:_
+
+* `flask_server`: [ATProto-decode JSON input](https://atproto.com/specs/data-model#relationship-with-dasl-and-ipld), so methods receive native `CID` and `bytes` values instead of `$link` and `$bytes` dicts. (Also encode methods' output the same way, as ATProto JSON, but that's backward compatible. Details below.)
+
+_Non-breaking changes:_
+
+* `Client`, `Server`: new `require_lexicons` kwarg, defaults to `True`. If `False`, records with missing or unknown lexicons are skipped during validation instead of raising `NotImplementedError`.
+* Schema validation:
+  * `Base.validate`: new `ignore` kwarg, a sequence of property names to skip validating or truncating, anywhere in the record.
+  * Fix `ref` type validation to accept string values that match their `ref`, eg token refs inside arrays or unions.
+  * Fix `minimum`/`maximum` schema constraint of `0`.
+  * `truncate`: truncate string values inside arrays.
+  * Fix crash on values with unexpected types when `truncate` is on but `validate` is off, and on non-object `parameters` values.
+  * Fail on float values, which aren't in the [data model](https://atproto.com/specs/data-model)
+  * Support the new [`space` lexicon type](https://github.com/bluesky-social/proposals/tree/main/0016-permissioned-data#space-type-declarations) and [`space-ref` string format](https://github.com/bluesky-social/proposals/tree/main/0016-permissioned-data#addressing), and allow space `at://` URIs in the `at-uri` format.
+* `Base.decode_params`: decode array values using their `items` type.
+* `XrpcError`: new `status` and `headers` kwargs. `flask_server` uses them in the HTTP response.
+* `Server.method`, `Server.register`: new `override` kwarg that allows replace an existing method.
+* `flask_server`:
+  * `init_flask`: new `fallback` kwarg, a callable that handles methods the `Server` doesn't implement instead of returning `MethodNotImplemented`. Useful for [ATservice proxying](https://atproto.com/specs/xrpc#service-proxying).
+  * Serve `OPTIONS` CORS preflight requests for methods without lexicons, and for subscriptions.
+  * [ATProto-encode JSON output](https://atproto.com/specs/data-model#relationship-with-dasl-and-ipld), so methods can return native `CID` and `bytes` values, which are encoded as `$link` and `$bytes`.
+* Bundle new lexicons:
+  * [Blacksky](https://blacksky.community/) (`community.blacksky.assembly`), from [blacksky-algorithms/assembly.blacksky.community@e95bd1f](https://github.com/blacksky-algorithms/assembly.blacksky.community/commit/e95bd1f4039e004115cd31f14d928ce5708fe83f).
+  * [Grain](https://grain.social/) (`social.grain`), from [grain.social/grain@319af78](https://tangled.org/grain.social/grain@319af78544239cdb0217d032e89c52dcd8595f0e).
+  * [Spark Social](https://sprk.so/) (`so.sprk`), from [sprksocial/server@3f4728d](https://github.com/sprksocial/server@3f4728db308b82ffa63a30cb28224af5beb406f6).
+
+
 ### 2.2 - 2026-06-29
 
 * Schema validation:

{lexrpc-2.2 → lexrpc-3.0}/lexrpc/base.py

@@ -23,13 +23,13 @@ LEXICON_TYPES = METHOD_TYPES | frozenset((
     'permission-set',
     'record',
     'ref',
+    'space',
     'token',
 ))
 PARAMETER_TYPES = frozenset((
     'array',
     'boolean',
     'integer',
-    'number',
     'string',
 ))
 # https://atproto.com/specs/lexicon#overview-of-types
@@ -90,11 +90,15 @@ TID_RE = re.compile(rf'[{BASE32_CHARS}]{{13}}')
 CID_RE = re.compile(r'[A-Za-z0-9+]{8,}')
 
 # https://www.w3.org/TR/did-core/#did-syntax
+# https://atproto.com/specs/did
 DID_RE = re.compile(r'did:[a-z]+:[A-Za-z0-9._%:-]{1,2048}(?<!:)')
 
+# public at:// URI regexp. excludes space URIs; those have a separate regexp below.
 # https://atproto.com/specs/at-uri-scheme
+#
 # NOTE: duplicated in granary.bluesky!
 # also see arroba.util.parse_at_uri
+#
 # TODO: add query and fragment? they're currently unused in the protocol
 # https://atproto.com/specs/at-uri-scheme#structure
 _CHARS = 'a-zA-Z0-9-.'
@@ -105,6 +109,22 @@ AT_URI_RE = re.compile(rf"""
        (?:/(?P<rkey>[{_CHARS}:~_]+))?)?
     """, re.VERBOSE)
 
+# https://github.com/bluesky-social/proposals/tree/main/0016-permissioned-data#addressing
+SPACE_REF_RE = re.compile(rf"""
+    at://
+     (?P<authority>{DID_RE.pattern})
+      /space
+       /(?P<type>{NSID_RE.pattern})
+        /(?P<skey>{RKEY_RE.pattern})
+    """, re.VERBOSE)
+
+SPACE_URI_RE = re.compile(rf"""
+    {SPACE_REF_RE.pattern}
+     (?:/(?P<author>{DID_RE.pattern})
+      /(?P<collection>{NSID_RE.pattern})
+       /(?P<rkey>{RKEY_RE.pattern}))?
+    """, re.VERBOSE)
+
 # wrapper for datetime.now, lets us mock it out in tests
 now = lambda tz=timezone.utc, **kwargs: datetime.now(tz=tz, **kwargs)
 
@@ -112,13 +132,18 @@ now = lambda tz=timezone.utc, **kwargs: datetime.now(tz=tz, **kwargs)
 class XrpcError(ValueError):
     """A named error in an XRPC call.
 
-    ``name`` is the error, eg ``RepoNotFound`` in ``com.atproto.sync.getRepo``.
-    ``message`` is the human-readable string error message.
+    Args:
+      name (str) error name eg ``RepoNotFound`` in ``com.atproto.sync.getRepo``
+      message (str): human-readable string error message
+      status (int): HTTP status code to respond with
+      headers (dict, str -> str): HTTP headers to include in the response.
     """
-    def __init__(self, message, name=None, **kwargs):
+    def __init__(self, message, name=None, status=None, headers=None, **kwargs):
         super().__init__(message, **kwargs)
         self.name = name
         self.message = message
+        self.status = status
+        self.headers = headers or {}
 
 
 def load_lexicons(traversable):
@@ -150,8 +175,10 @@ class Base():
     defs = None  # dict mapping id to lexicon def
     _validate = None
     _truncate = None
+    _require_lexicons = None
 
-    def __init__(self, lexicons=None, validate=True, truncate=False):
+    def __init__(self, lexicons=None, validate=True, truncate=False,
+                 require_lexicons=True):
         """Constructor.
 
         Args:
@@ -161,13 +188,19 @@ class Base():
           validate (bool): whether to validate schemas, parameters, and input
             and output bodies
           truncate (bool): whether to truncate string values that are longer
-            than their ``maxGraphemes`` or ``maxLength`` in their lexicon
+            than their ``maxGraphemes`` in their lexicon.
+            (TODO: support ``maxLength`` too. Deceptively difficult!)
+          require_lexicons (bool): whether to require that a lexicon exists for
+            every value we validate. If False, values with missing or unknown
+            lexicons are skipped instead of raising
+            :class:`NotImplementedError`.
 
         Raises:
           ValidationError: if any schema is invalid
         """
         self._validate = validate
         self._truncate = truncate
+        self._require_lexicons = require_lexicons
         self.defs = {}
 
         if lexicons is None:
@@ -208,8 +241,13 @@ class Base():
     def _get_def(self, id):
         """Returns the given lexicon def.
 
+        Returns:
+          dict: the def, or None if it doesn't exist and this object was
+            initialized with ``require_lexicons=False``
+
         Raises:
-          NotImplementedError: if no def exists for the given id
+          NotImplementedError: if no def exists for the given id and this object
+            was initialized with ``require_lexicons=True``
         """
         # TODO: bring back once the Bluesky appview validates this too
         # https://github.com/bluesky-social/atproto/discussions/1968#discussioncomment-11195092
@@ -218,12 +256,12 @@ class Base():
         #     raise ValidationError(f'#main suffix not allowed on $type: {id}')
 
         lexicon = self.defs.get(id)
-        if not lexicon:
+        if not lexicon and self._require_lexicons:
             fail(f'{id} not found')
 
         return lexicon
 
-    def validate(self, nsid, type, obj):
+    def validate(self, nsid, type, obj, ignore=()):
         """If configured to do so, validates a ATProto value against its lexicon.
 
         Returns ``None`` if the object validates, otherwise raises an exception.
@@ -234,6 +272,8 @@ class Base():
           nsid (str): method NSID
           type (str): ``input``, ``output``, ``parameters``, or ``record``
           obj (dict): JSON object
+          ignore (sequence of str): property names to ignore and not validate or
+            truncate
 
         Returns:
           dict: obj, either unchanged, or possible a modified copy if
@@ -241,15 +281,21 @@ class Base():
 
         Raises:
           NotImplementedError: if no lexicon exists for the given NSID, or the
-            lexicon does not define a schema for the given type
+            lexicon does not define a schema for the given type, and this object
+            was initialized with ``require_lexicons=True``
           ValidationError: if the object is invalid
+
         """
         if not self._validate and not self._truncate:
             return obj
 
         assert type in ('input', 'output', 'message', 'parameters', 'record'), type
 
-        base = self._get_def(nsid).get(type, {})
+        if not (defn := self._get_def(nsid)):
+            logger.debug(f'No lexicon for {nsid}, skipping validation')
+            return obj
+
+        base = defn.get(type, {})
         encoding = base.get('encoding')
         if encoding and encoding != 'application/json':
             # binary or other non-JSON data, pass through
@@ -266,11 +312,12 @@ class Base():
             # params at all, eg utm_* tracking params
 
         self._validate_schema(name=type, val=obj, type_name=nsid, lexicon=nsid,
-                              schema=schema)
+                              schema=schema, ignore=ignore)
 
         return obj
 
-    def _validate_schema(self, *, name, val, type_name, lexicon, schema):
+    def _validate_schema(self, *, name, val, type_name, lexicon, schema,
+                         ignore=()):
         """Validates an ATProto value against a lexicon schema.
 
         Returns ``None`` if the value validates, otherwise raises an exception.
@@ -285,6 +332,8 @@ class Base():
             eg ``app.bsky.feed.post`` or ``app.bsky.feed.post#replyRef``
           schema (dict): schema to validate against if this is a compound
             object and not a primitive
+          ignore (sequence of str): property names to ignore and not validate or
+            truncate
 
         Raises:
           ValidationError: if the value is invalid
@@ -292,12 +341,16 @@ class Base():
         # logger.debug(f'@ {name} {type_name} {lexicon} {str(val)[:100]} {str(schema)[:100]}')
 
         def get_schema(lex_name):
-            """Returns (fully qualified lexicon name, lexicon) tuple."""
+            """Returns (fully qualified lexicon name, lexicon) tuple.
+
+            The lexicon is None if it's not found and ``require_lexicons`` is off.
+            """
             if lex_name.startswith('#'):
                 schema_name = lexicon.split('#')[0] + lex_name
             else:
                 schema_name = lex_name
-            schema = self._get_def(schema_name)
+            if not (schema := self._get_def(schema_name)):
+                return schema_name, None
             if schema.get('type') == 'record':
                 schema = schema.get('record')
             if not schema:
@@ -326,6 +379,8 @@ class Base():
         if type_ == 'unknown':
             if isinstance(val, dict) and val.get('$type'):
                 lexicon, schema = get_schema(val['$type'])
+                if not schema:
+                    return
                 # pass through and validate with this schema
             else:
                 return
@@ -333,6 +388,9 @@ class Base():
         if expected := FIELD_TYPES.get(type_):
             if type(val) != expected:
                 fail(f'has unexpected type {type(val).__name__}')
+                # if we're only truncating, fail is a noop, but the checks
+                # below all assume this type, so stop here
+                return
 
         if type_ in ('array', 'bytes', 'string'):
             min_length = schema.get('minLength')
@@ -359,10 +417,10 @@ class Base():
                 if max_graphemes and length > max_graphemes:
                     fail(f'is longer than maxGraphemes {max_graphemes}')
 
-        if minimum := schema.get('minimum'):
+        if (minimum := schema.get('minimum')) is not None:
             if val < minimum:
                 fail(f'is lower than minimum {minimum}')
-        if maximum := schema.get('maximum'):
+        if (maximum := schema.get('maximum')) is not None:
             if val > maximum:
                 fail(f'is higher than maximum {maximum}')
 
@@ -374,11 +432,14 @@ class Base():
 
         if type_ == 'ref':
             ref = schema['ref']
-            if isinstance(val, str) and val != ref:
-                fail(f'is not {ref}')
+            if isinstance(val, str):
+                if val != ref:
+                    fail(f'is not {ref}')
             elif not isinstance(val, dict):
                 fail('is not object')
             lexicon, schema = get_schema(ref)
+            if not schema:
+                return
 
         if type_ == 'union':
             if isinstance(val, dict):
@@ -406,6 +467,9 @@ class Base():
                 logger.debug(f'Skipping unknown type {inner_type}')
                 return
 
+            if not schema:
+                return
+
         # TODO: maybe bring back once we figure out why the AppView isn't
         # currently enforcing these:
         # https://github.com/snarfed/bridgy-fed/issues/1348#issuecomment-2381056468
@@ -419,19 +483,30 @@ class Base():
         #     self.validate_mime_type(val['mimeType'], schema.get('accept'), name=name)
 
         if type_ == 'array':
-            for item in val:
-                self._validate_schema(
-                    name=name, val=item, type_name=schema['items']['type'],
-                    lexicon=lexicon, schema=schema['items'])
+            items = schema['items']
+            for i, item in enumerate(val):
+                if (self._truncate and items['type'] == 'string'
+                        and isinstance(item, str)
+                        and (max_graphemes := items.get('maxGraphemes'))
+                        and grapheme.length(item) > max_graphemes):
+                    item = val[i] = grapheme.slice(item, end=max_graphemes - 1) + '…'
+
+                self._validate_schema(name=name, val=item,
+                                      type_name=items['type'],
+                                      lexicon=lexicon, schema=items, ignore=ignore)
 
         props = schema.get('properties', {})
-        if props and not isinstance(val, dict):
+        is_params = schema.get('type') == 'params'
+        if (props or is_params) and not isinstance(val, dict):
             fail('should be object')
+            return
 
         required = schema.get('required', [])
         nullable = schema.get('nullable', [])
         for prop_name, prop_schema in props.items():
-            if prop_name not in val:
+            if prop_name in ignore:
+                continue
+            elif prop_name not in val:
                 if prop_name in required:
                     fail(f'missing required property {prop_name}')
                 continue
@@ -445,6 +520,7 @@ class Base():
                 continue
 
             elif (self._truncate and prop_type == 'string'
+                  and isinstance(prop_val, str)
                   and (max_graphemes := prop_schema.get('maxGraphemes'))):
                 if grapheme.length(prop_val) > max_graphemes:
                     prop_val = val[prop_name] = grapheme.slice(
@@ -452,13 +528,16 @@ class Base():
 
             elif prop_type == 'ref':
                 prop_lexicon, prop_schema = get_schema(prop_schema['ref'])
+                if not prop_schema:
+                    continue
                 prop_type = prop_schema['type']
 
             self._validate_schema(name=prop_name, val=prop_val, type_name=prop_type,
-                                  lexicon=prop_lexicon, schema=prop_schema)
+                                  lexicon=prop_lexicon, schema=prop_schema,
+                                  ignore=ignore)
 
         # unknown parameters aren't allowed
-        if schema.get('type') == 'params':
+        if is_params:
             if unknown := val.keys() - props.keys():
                 fail(f'unknown parameters: {unknown}')
 
@@ -486,7 +565,7 @@ class Base():
 
         elif format == 'at-uri':
             check(len(val) < 8 * 1024)
-            check(AT_URI_RE.fullmatch(val))
+            check(AT_URI_RE.fullmatch(val) or SPACE_URI_RE.fullmatch(val))
             check('/./' not in val
                   and '/../' not in val
                   and not val.endswith('/.')
@@ -532,6 +611,10 @@ class Base():
         elif format == 'record-key':
             check(val not in ('.', '..') and RKEY_RE.fullmatch(val))
 
+        elif format == 'space-ref':
+            match = SPACE_REF_RE.fullmatch(val)
+            check(match and match['skey'] not in ('.', '..'))
+
         elif format == 'uri':
             check(len(val) < 8 * 1024)
             check(' ' not in val)
@@ -581,7 +664,7 @@ class Base():
         Based on https://atproto.com/specs/xrpc#lexicon-http-endpoints
 
         Args:
-          params (dict): maps str names to boolean, number, str, or list values
+          params (dict): maps str names to boolean, integer, str, or list values
 
         Returns:
           bytes: URL-encoded query parameter string
@@ -603,43 +686,49 @@ class Base():
           params (sequence of (str, str) tuple): name/value mappings
 
         Returns:
-          dict: maps str names to decoded boolean, number, str, and array values
+          dict: maps str names to decoded boolean, integer, str, and array values
 
         Raises:
           ValueError: if a parameter value can't be decoded
           NotImplementedError: if no method lexicon is registered for the given NSID
         """
-        lexicon = self._get_def(method_nsid)
-        params_schema = lexicon.get('parameters', {}).get('properties', {})
+        if not (lexicon := self._get_def(method_nsid)):
+            fail(f'{method_nsid} not found')
 
-        decoded = {}
-        for name, val in params:
-            type = params_schema.get(name, {}).get('type') or 'string'
-            assert type in PARAMETER_TYPES, type
+        params_schema = lexicon.get('parameters', {}).get('properties', {})
 
+        def decode(val, type, name):
             if type == 'boolean':
                 if val == 'true':
-                    decoded[name] = True
+                    return True
                 elif val == 'false':
-                    decoded[name] = False
+                    return False
                 else:
                     raise ValueError(
                         f'Got {val!r} for boolean parameter {name}, expected true or false')
 
             try:
-                if type == 'number':
-                    decoded[name] = float(val)
-                elif type in ('int', 'integer'):
-                    decoded[name] = int(val)
+                if type in ('int', 'integer'):
+                    return int(val)
             except ValueError as e:
                 e.args = [f'{e.args[0]} for {type} parameter {name}']
                 raise e
 
             if type == 'string':
-                decoded[name] = val
+                return val
+
+        decoded = {}
+        for name, val in params:
+            schema = params_schema.get(name, {})
+            type = schema.get('type') or 'string'
+            assert type in PARAMETER_TYPES, type
 
             if type == 'array':
-                decoded.setdefault(name, []).append(val)
+                item_type = schema.get('items', {}).get('type') or 'string'
+                assert item_type in PARAMETER_TYPES, item_type
+                decoded.setdefault(name, []).append(decode(val, item_type, name))
+            else:
+                decoded[name] = decode(val, type, name)
 
         return decoded
 

{lexrpc-2.2 → lexrpc-3.0}/lexrpc/client.py

@@ -77,7 +77,7 @@ class Client(Base):
 
     def __init__(self, address=None, access_token=None, refresh_token=None,
                  session_callback=None, lexicons=None, validate=True, truncate=False,
-                 requests_session=None, **requests_kwargs):
+                 require_lexicons=True, requests_session=None, **requests_kwargs):
         """Constructor.
 
         Args:
@@ -98,6 +98,10 @@ class Client(Base):
             and output bodies
           truncate (bool): whether to truncate string values that are longer
             than their ``maxGraphemes`` or ``maxLength`` in their lexicon
+          require_lexicons (bool): whether to require that a lexicon exists for
+            every value we validate. If False, values with missing or unknown
+            lexicons are skipped instead of raising
+            :class:`NotImplementedError`.
           requests_session (requests.Session): optional HTTP session to use for
             requests. Defaults to a new :class:`requests.Session`.
           requests_kwargs: passed to :func:`requests.Session.get` /
@@ -108,7 +112,8 @@ class Client(Base):
         Raises:
           ValidationError: if any lexicon schema is invalid
         """
-        super().__init__(lexicons=lexicons, validate=validate, truncate=truncate)
+        super().__init__(lexicons=lexicons, validate=validate, truncate=truncate,
+                         require_lexicons=require_lexicons)
 
         assert not ((access_token or refresh_token) and requests_kwargs.get('auth'))
 
@@ -175,8 +180,8 @@ class Client(Base):
         params = self.validate(nsid, 'parameters', params)
         params_str = self.encode_params(params)
 
-        lexicon = self._get_def(nsid)
-        type = lexicon['type']
+        lexicon = self._get_def(nsid) or {}
+        type = lexicon.get('type')
         if type == 'subscription':
             input = self.validate(nsid, 'input', input)