lexrpc 2.0__tar.gz → 2.2__tar.gz

{lexrpc-2.0 → lexrpc-2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lexrpc
-Version: 2.0
+Version: 2.2
 Summary: Python implementation of AT Protocol's XRPC + Lexicon
 Author-email: Ryan Barrett <lexrpc@ryanb.org>
 Project-URL: Homepage, https://github.com/snarfed/lexrpc
@@ -12,20 +12,25 @@ Classifier: Operating System :: OS Independent
 Classifier: Intended Audience :: Developers
 Classifier: Development Status :: 3 - Alpha
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.7
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: dag-cbor
+Requires-Dist: dag-cbor>=0.3
 Requires-Dist: dag-json>=0.3
-Requires-Dist: grapheme
-Requires-Dist: iterators
-Requires-Dist: libipld<4.0.0
+Requires-Dist: grapheme>=0.6.0
+Requires-Dist: iterators>=0.2.0
+Requires-Dist: libipld<4.0.0,>=3.0.0
 Requires-Dist: multiformats>=0.3.1.post4
 Requires-Dist: requests>=2.0
-Requires-Dist: simple-websocket
+Requires-Dist: simple-websocket>=0.10.0
 Provides-Extra: flask
 Requires-Dist: Flask>=2.0; extra == "flask"
-Requires-Dist: flask-sock; extra == "flask"
+Requires-Dist: flask-sock>=0.6.0; extra == "flask"
+Requires-Dist: werkzeug>=2.0; extra == "flask"
+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"
 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)
@@ -176,25 +181,26 @@ Here's how to package, test, and ship a new release.
     ```
 1. Run the unit tests.
     ```sh
-    source local/bin/activate.csh
+    source .venv/bin/activate.csh
     python -m unittest discover
     ```
 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.
-1. `git commit -am 'release vX.Y'`
+1. ```sh
+   setenv ver X.Y
+   git commit -am "release v$ver"
+   ```
 1. Upload to [test.pypi.org](https://test.pypi.org/) for testing.
     ```sh
-    python -m build
-    setenv ver X.Y
-    twine upload -r pypitest dist/lexrpc-$ver*
+    uv build
+    twine upload -r pypitest dist/lexrpc-$ver.tar.gz dist/lexrpc-$ver-py3-none-any.whl
     ```
 1. Install from test.pypi.org.
     ```sh
     cd /tmp
-    python -m venv local
-    source local/bin/activate.csh
+    python -m venv .venv
+    source .venv/bin/activate.csh
     pip uninstall lexrpc # make sure we force pip to use the uploaded version
-    pip install --upgrade pip
     pip install -i https://test.pypi.org/simple --extra-index-url https://pypi.org/simple lexrpc==$ver
     ```
 1. Smoke test that the code trivially loads and runs.
@@ -248,6 +254,39 @@ Here's how to package, test, and ship a new release.
 
 ## Changelog
 
+### 2.2 - 2026-06-29
+
+* Schema validation:
+  * Fix crash (`KeyError`) when validating a `blob` value inside an open union; now raises `ValidationError` for invalid blob refs.
+* `client`:
+  * For websocket event streams, close the websocket connection when a non-`ConnectionClosed` exception is raised.
+  * Use the lexicon method's `input.encoding` as the `Content-Type` request header.
+  * `Client.__init__`: new `requests_session` kwarg, an optional :class:`requests.Session` to use for HTTP requests.
+* `server`:
+  * `Server.call`: unknown parameters not in the lexicon are now silently ignored instead of raising `ValidationError`. [Background.](https://github.com/bluesky-social/atproto/discussions/5094)
+* `flask_server`:
+  * Close websocket connections with reason 1011 for unknown/not implemented endpoint NSIDs.
+* Update bundled lexicons:
+  * Bluesky PBC's (`app.bsky.*` etc) at [cf4843c](https://github.com/bluesky-social/atproto/commit/cf4843c339396e98fc0191b5c7ccf8db2e48da5b)
+  * [`site.standard.*`](https://standard.site/) at [549453e](https://tangled.org/standard.site/lexicons/commit/549453e37a4e15e8318f5b7655b230d0925b9e02)
+  * [`lexicon.community.*`](https://lexicon.community/) at [91c50cb](https://github.com/lexicon-community/lexicon/commit/91c50cbd84a9da8014332a6e37812c276889c8ac)
+
+
+### 2.1 - 2026-02-06
+
+* Bundle new lexicons:
+  * [`lexicon.community.*`](https://lexicon.community/), as of [2bf2cbb](https://github.com/lexicon-community/lexicon/commit/2bf2cbbfd3058d710f8c468307ef7e003bc22383).
+  * [`site.standard.*`](https://standard.site/), [from lexicon.garden](https://lexicon.garden/identity/did:plc:re3ebnp5v7ffagz6rb6xfei4), as of 2026-02-03.
+* Update bundled Bluesky PBC lexicons (`app.bsky`, `com.atproto`, etc.) as of [19ecf5f](https://github.com/bluesky-social/atproto/commit/19ecf5f76ae0d88c1963211a76920e00eecdd965).
+* `base.load_lexicons`: ignore non-lexicon files.
+* Schema validation:
+  * For the `uri` string format, handle URLs with brackets (eg `]`) in the hostname, eg `https://example.com]`.
+  * Don't require `$type` in event stream subscription payloads.
+  * Bug fixes for unions and arrays.
+  * Ignore `maxGraphemes` on non-string fields.
+  * Allow `type: permission-set`.
+
+
 ### 2.0 - 2025-09-13
 
 _Breaking changes:_

lexrpc-2.0/lexrpc.egg-info/PKG-INFO → lexrpc-2.2/README.md

@@ -1,33 +1,3 @@
-Metadata-Version: 2.4
-Name: lexrpc
-Version: 2.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
-Project-URL: Documentation, https://lexrpc.readthedocs.io/
-Keywords: XRPC,Lexicon,AT Protocol,ATP
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: Public Domain
-Classifier: Operating System :: OS Independent
-Classifier: Intended Audience :: Developers
-Classifier: Development Status :: 3 - Alpha
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: dag-cbor
-Requires-Dist: dag-json>=0.3
-Requires-Dist: grapheme
-Requires-Dist: iterators
-Requires-Dist: libipld<4.0.0
-Requires-Dist: multiformats>=0.3.1.post4
-Requires-Dist: requests>=2.0
-Requires-Dist: simple-websocket
-Provides-Extra: flask
-Requires-Dist: Flask>=2.0; extra == "flask"
-Requires-Dist: flask-sock; extra == "flask"
-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)
 ===
 
@@ -176,25 +146,26 @@ Here's how to package, test, and ship a new release.
     ```
 1. Run the unit tests.
     ```sh
-    source local/bin/activate.csh
+    source .venv/bin/activate.csh
     python -m unittest discover
     ```
 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.
-1. `git commit -am 'release vX.Y'`
+1. ```sh
+   setenv ver X.Y
+   git commit -am "release v$ver"
+   ```
 1. Upload to [test.pypi.org](https://test.pypi.org/) for testing.
     ```sh
-    python -m build
-    setenv ver X.Y
-    twine upload -r pypitest dist/lexrpc-$ver*
+    uv build
+    twine upload -r pypitest dist/lexrpc-$ver.tar.gz dist/lexrpc-$ver-py3-none-any.whl
     ```
 1. Install from test.pypi.org.
     ```sh
     cd /tmp
-    python -m venv local
-    source local/bin/activate.csh
+    python -m venv .venv
+    source .venv/bin/activate.csh
     pip uninstall lexrpc # make sure we force pip to use the uploaded version
-    pip install --upgrade pip
     pip install -i https://test.pypi.org/simple --extra-index-url https://pypi.org/simple lexrpc==$ver
     ```
 1. Smoke test that the code trivially loads and runs.
@@ -248,6 +219,39 @@ Here's how to package, test, and ship a new release.
 
 ## Changelog
 
+### 2.2 - 2026-06-29
+
+* Schema validation:
+  * Fix crash (`KeyError`) when validating a `blob` value inside an open union; now raises `ValidationError` for invalid blob refs.
+* `client`:
+  * For websocket event streams, close the websocket connection when a non-`ConnectionClosed` exception is raised.
+  * Use the lexicon method's `input.encoding` as the `Content-Type` request header.
+  * `Client.__init__`: new `requests_session` kwarg, an optional :class:`requests.Session` to use for HTTP requests.
+* `server`:
+  * `Server.call`: unknown parameters not in the lexicon are now silently ignored instead of raising `ValidationError`. [Background.](https://github.com/bluesky-social/atproto/discussions/5094)
+* `flask_server`:
+  * Close websocket connections with reason 1011 for unknown/not implemented endpoint NSIDs.
+* Update bundled lexicons:
+  * Bluesky PBC's (`app.bsky.*` etc) at [cf4843c](https://github.com/bluesky-social/atproto/commit/cf4843c339396e98fc0191b5c7ccf8db2e48da5b)
+  * [`site.standard.*`](https://standard.site/) at [549453e](https://tangled.org/standard.site/lexicons/commit/549453e37a4e15e8318f5b7655b230d0925b9e02)
+  * [`lexicon.community.*`](https://lexicon.community/) at [91c50cb](https://github.com/lexicon-community/lexicon/commit/91c50cbd84a9da8014332a6e37812c276889c8ac)
+
+
+### 2.1 - 2026-02-06
+
+* Bundle new lexicons:
+  * [`lexicon.community.*`](https://lexicon.community/), as of [2bf2cbb](https://github.com/lexicon-community/lexicon/commit/2bf2cbbfd3058d710f8c468307ef7e003bc22383).
+  * [`site.standard.*`](https://standard.site/), [from lexicon.garden](https://lexicon.garden/identity/did:plc:re3ebnp5v7ffagz6rb6xfei4), as of 2026-02-03.
+* Update bundled Bluesky PBC lexicons (`app.bsky`, `com.atproto`, etc.) as of [19ecf5f](https://github.com/bluesky-social/atproto/commit/19ecf5f76ae0d88c1963211a76920e00eecdd965).
+* `base.load_lexicons`: ignore non-lexicon files.
+* Schema validation:
+  * For the `uri` string format, handle URLs with brackets (eg `]`) in the hostname, eg `https://example.com]`.
+  * Don't require `$type` in event stream subscription payloads.
+  * Bug fixes for unions and arrays.
+  * Ignore `maxGraphemes` on non-string fields.
+  * Allow `type: permission-set`.
+
+
 ### 2.0 - 2025-09-13
 
 _Breaking changes:_

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

@@ -6,7 +6,7 @@ import json
 import logging
 import re
 import string
-from urllib.parse import urlencode, urljoin, urlparse
+from urllib.parse import urlencode, urlparse
 
 import grapheme
 from multiformats import CID
@@ -20,6 +20,7 @@ METHOD_TYPES = frozenset((
 ))
 LEXICON_TYPES = METHOD_TYPES | frozenset((
     'object',
+    'permission-set',
     'record',
     'ref',
     'token',
@@ -54,7 +55,7 @@ BLOB_DEF = {
         'required': ['ref', 'mimeType', 'size'],
         'properties': {
             'ref': {
-                'type': 'ref',
+                'type': 'cid-link',
             },
             'mimeType': {
                 'type': 'string',
@@ -68,43 +69,41 @@ BLOB_DEF = {
     },
 }
 
-# duplicated in bridgy-fed/common.py
-DOMAIN_PATTERN = r'([a-z0-9][a-z0-9-]{0,62}(?<!-)\.){1,}[a-z][a-z0-9-]*(?<!-)'
-DOMAIN_RE = re.compile(f'^{DOMAIN_PATTERN}$')
+# duplicated in bridgy-fed/domains.py
+DOMAIN_RE = re.compile(r'([a-z0-9][a-z0-9-]{0,62}(?<!-)\.){1,}[a-z][a-z0-9-]*(?<!-)')
 
 # https://atproto.com/specs/nsid
-NSID_SEGMENT = '[a-zA-Z0-9-]+'
-NSID_SEGMENT_RE = re.compile(f'^{NSID_SEGMENT}$')
-NSID_PATTERN = r'(?![0-9])((?!-)[a-z0-9-]{1,63}(?<!-)\.){2,}[a-zA-Z][a-zA-Z0-9]{0,62}'
-NSID_RE = re.compile(f'^{NSID_PATTERN}$')
+NSID_SEGMENT_RE = re.compile('[a-zA-Z0-9-]+')
+NSID_RE = re.compile(r'(?![0-9])((?!-)[a-z0-9-]{1,63}(?<!-)\.){2,}[a-zA-Z][a-zA-Z0-9]{0,62}')
 
 # https://atproto.com/specs/lexicon#string-formats
 # https://datatracker.ietf.org/doc/html/rfc5646#section-2.1
-LANG_RE = re.compile(r'^(i|[a-z]{2,3})(-[A-Za-z0-9-]+)?$')
+LANG_RE = re.compile(r'(i|[a-z]{2,3})(-[A-Za-z0-9-]+)?')
 
 # https://atproto.com/specs/record-key
-RKEY_RE = re.compile(r'^[A-Za-z0-9._:~-]{1,512}$')
+RKEY_RE = re.compile(r'[A-Za-z0-9._:~-]{1,512}')
 
 # https://atproto.com/specs/record-key#record-key-type-tid
 BASE32_CHARS = string.ascii_lowercase + "234567"
-TID_RE = re.compile(rf'^[{BASE32_CHARS}]{{13}}$')
+TID_RE = re.compile(rf'[{BASE32_CHARS}]{{13}}')
 
-CID_RE = re.compile(r'^[A-Za-z0-9+]{8,}$')
+CID_RE = re.compile(r'[A-Za-z0-9+]{8,}')
 
 # https://www.w3.org/TR/did-core/#did-syntax
-DID_PATTERN = r'did:[a-z]+:[A-Za-z0-9._%:-]{1,2048}(?<!:)'
-DID_RE = re.compile(f'^{DID_PATTERN}$')
+DID_RE = re.compile(r'did:[a-z]+:[A-Za-z0-9._%:-]{1,2048}(?<!:)')
 
 # 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-.'
 AT_URI_RE = re.compile(rf"""
-    ^at://
-     (?P<repo>{DID_PATTERN}|{DOMAIN_PATTERN})
-      (?:/(?P<collection>{NSID_PATTERN})
+    at://
+     (?P<repo>{DID_RE.pattern}|{DOMAIN_RE.pattern})
+      (?:/(?P<collection>{NSID_RE.pattern})
        (?:/(?P<rkey>[{_CHARS}:~_]+))?)?
-    $""", re.VERBOSE)
+    """, re.VERBOSE)
 
 # wrapper for datetime.now, lets us mock it out in tests
 now = lambda tz=timezone.utc, **kwargs: datetime.now(tz=tz, **kwargs)
@@ -123,13 +122,12 @@ class XrpcError(ValueError):
 
 
 def load_lexicons(traversable):
-    if traversable.is_file():
-        lexicons = [json.loads(traversable.read_text())]
+    if traversable.is_file() and traversable.suffix == '.json':
+        return [json.loads(traversable.read_text())]
     elif traversable.is_dir():
-        lexicons = sum((load_lexicons(item) for item in traversable.iterdir()),
-                       start=[])
+        return sum((load_lexicons(item) for item in traversable.iterdir()), start=[])
 
-    return lexicons
+    return []
 
 _bundled_lexicons = load_lexicons(files('lexrpc').joinpath('lexicons'))
 logger.info(f'{len(_bundled_lexicons)} lexicons loaded')
@@ -267,12 +265,12 @@ class Base():
             # we'd fail if a query with no params gets requested with any query
             # params at all, eg utm_* tracking params
 
-        self._validate_schema(name=type, val=obj, type_=nsid, lexicon=nsid,
+        self._validate_schema(name=type, val=obj, type_name=nsid, lexicon=nsid,
                               schema=schema)
 
         return obj
 
-    def _validate_schema(self, *, name, val, type_, lexicon, schema):
+    def _validate_schema(self, *, name, val, type_name, lexicon, schema):
         """Validates an ATProto value against a lexicon schema.
 
         Returns ``None`` if the value validates, otherwise raises an exception.
@@ -282,7 +280,7 @@ class Base():
         Args:
           name (str): field name
           val: value
-          type_ (str): name of type, eg ``integer`` or ``app.bsky.feed.post#replyRef``
+          type_name (str): name of type, eg ``integer`` or ``app.bsky.feed.post#replyRef``
           lexicon (str): fully qualified lexicon name that contains this schema,
             eg ``app.bsky.feed.post`` or ``app.bsky.feed.post#replyRef``
           schema (dict): schema to validate against if this is a compound
@@ -291,11 +289,14 @@ class Base():
         Raises:
           ValidationError: if the value is invalid
         """
-        # logger.debug(f'@ {name} {type_} {lexicon} {str(val)[:100]} {str(schema)[:100]}')
+        # 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."""
-            schema_name = urljoin(lexicon, lex_name)
+            if lex_name.startswith('#'):
+                schema_name = lexicon.split('#')[0] + lex_name
+            else:
+                schema_name = lex_name
             schema = self._get_def(schema_name)
             if schema.get('type') == 'record':
                 schema = schema.get('record')
@@ -308,9 +309,11 @@ class Base():
                 val_str = repr(val)
                 if len(val_str) > 50:
                     val_str = val_str[:50] + '…'
-                prefix = f'in {lexicon}, ' if lexicon != type_ else ''
+                prefix = f'in {lexicon}, ' if lexicon != type_name else ''
                 raise ValidationError(
-                    f'{prefix}{type_} {name} with value `{val_str}`: {msg}')
+                    f'{prefix}{type_name} {name} with value `{val_str}`: {msg}')
+
+        type_ = schema.get('type') or type_name
 
         if const := schema.get('const'):
             if val != const:
@@ -379,8 +382,11 @@ class Base():
 
         if type_ == 'union':
             if isinstance(val, dict):
-                inner_type = val.get('$type')
-                if not inner_type:
+                if not (inner_type := val.get('$type')):
+                    if name == 'message':
+                        # event stream subscription messages (payloads) don't
+                        # require $type, it's in the header
+                        return
                     fail('missing $type')
             elif isinstance(val, str):
                 inner_type = val
@@ -388,7 +394,7 @@ class Base():
                 fail("is invalid")
 
             if schema.get('closed'):
-                refs = [urljoin(lexicon, ref) for ref in schema['refs']]
+                refs = [get_schema(ref)[0] for ref in schema['refs']]
                 if inner_type not in refs:
                     fail(f"{inner_type} isn't one of {refs}")
 
@@ -415,7 +421,7 @@ class Base():
         if type_ == 'array':
             for item in val:
                 self._validate_schema(
-                    name=name, val=item, type_=schema['items']['type'],
+                    name=name, val=item, type_name=schema['items']['type'],
                     lexicon=lexicon, schema=schema['items'])
 
         props = schema.get('properties', {})
@@ -438,7 +444,8 @@ class Base():
                     fail(f'property {prop_name} is not nullable')
                 continue
 
-            elif self._truncate and (max_graphemes := prop_schema.get('maxGraphemes')):
+            elif (self._truncate and prop_type == 'string'
+                  and (max_graphemes := prop_schema.get('maxGraphemes'))):
                 if grapheme.length(prop_val) > max_graphemes:
                     prop_val = val[prop_name] = grapheme.slice(
                         prop_val, end=max_graphemes - 1) + '…'
@@ -447,7 +454,7 @@ class Base():
                 prop_lexicon, prop_schema = get_schema(prop_schema['ref'])
                 prop_type = prop_schema['type']
 
-            self._validate_schema(name=prop_name, val=prop_val, type_=prop_type,
+            self._validate_schema(name=prop_name, val=prop_val, type_name=prop_type,
                                   lexicon=prop_lexicon, schema=prop_schema)
 
         # unknown parameters aren't allowed
@@ -475,11 +482,11 @@ class Base():
 
         # TODO: switch to match once we require Python 3.10+
         if format == 'at-identifier':
-            check(DID_RE.match(val) or DOMAIN_RE.match(val.lower()))
+            check(DID_RE.fullmatch(val) or DOMAIN_RE.fullmatch(val.lower()))
 
         elif format == 'at-uri':
             check(len(val) < 8 * 1024)
-            check(AT_URI_RE.match(val))
+            check(AT_URI_RE.fullmatch(val))
             check('/./' not in val
                   and '/../' not in val
                   and not val.endswith('/.')
@@ -488,7 +495,7 @@ class Base():
         elif format == 'cid':
             # ideally I'd use CID.decode here, but it doesn't support CIDv5,
             # it's too strict about padding, etc.
-            check(CID_RE.match(val))
+            check(CID_RE.fullmatch(val))
 
         elif format == 'datetime':
             check('T' in val)
@@ -507,35 +514,38 @@ class Base():
                 check(False)
 
         elif format == 'did':
-            check(DID_RE.match(val))
+            check(DID_RE.fullmatch(val))
 
         elif format == 'nsid':
             check(len(val) <= 317)
-            check(NSID_RE.match(val) and '.' in val)
+            check(NSID_RE.fullmatch(val) and '.' in val)
 
         elif format in 'handle':
             check(len(val) <= 253)
-            check(DOMAIN_RE.match(val.lower()))
+            check(DOMAIN_RE.fullmatch(val.lower()))
 
         elif format == 'tid':
-            check(TID_RE.match(val))
+            check(TID_RE.fullmatch(val))
             # high bit, big-endian, can't be 1
             check(not ord(val[0]) & 0x40)
 
         elif format == 'record-key':
-            check(val not in ('.', '..') and RKEY_RE.match(val))
+            check(val not in ('.', '..') and RKEY_RE.fullmatch(val))
 
         elif format == 'uri':
             check(len(val) < 8 * 1024)
             check(' ' not in val)
-            parsed = urlparse(val)
+            try:
+                parsed = urlparse(val)
+            except ValueError as e:
+                raise ValidationError(f"Couldn't parse URI {val}")
             check(parsed.scheme
                   and parsed.scheme[0].lower() in string.ascii_lowercase
                   and (parsed.netloc or parsed.path or parsed.query
                        or parsed.fragment))
 
         elif format == 'language':
-            check(LANG_RE.match(val))
+            check(LANG_RE.fullmatch(val))
 
         else:
             raise ValidationError(f'unknown format {format}')

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

@@ -48,7 +48,7 @@ class _NsidClient():
 
     def __getattr__(self, attr):
         segment = attr.replace('_', '-')
-        if NSID_SEGMENT_RE.match(segment):
+        if NSID_SEGMENT_RE.fullmatch(segment):
             return _NsidClient(self.client, f'{self.nsid}.{segment}')
 
         return getattr(super(), attr)
@@ -70,12 +70,14 @@ class Client(Base):
       address (str): base URL of XRPC server, eg ``https://bsky.social/``
       session (dict): ``createSession`` response with ``accessJwt``,
         `refreshJwt``, ``handle``, and ``did``
-      requests_kwargs (dict): passed to :func:`requests.get`/:func:`requests.post`
+      requests_kwargs (dict): passed to :func:`requests.Session.get` /
+        :func:`requests.Session.post`
+      requests_session (requests.Session): HTTP session to use for requests
     """
 
     def __init__(self, address=None, access_token=None, refresh_token=None,
                  session_callback=None, lexicons=None, validate=True, truncate=False,
-                 **requests_kwargs):
+                 requests_session=None, **requests_kwargs):
         """Constructor.
 
         Args:
@@ -96,9 +98,12 @@ class Client(Base):
             and output bodies
           truncate (bool): whether to truncate string values that are longer
             than their ``maxGraphemes`` or ``maxLength`` in their lexicon
-          requests_kwargs: passed to :func:`requests.get`/:func:`requests.post`, eg
-            ``auth`` (:class:`requests.auth.AuthBase`), ``headers`` (dict),
-            ``timeout`` (int, seconds), etc.
+          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` /
+            :func:`requests.Session.post`, eg ``auth``
+            (:class:`requests.auth.AuthBase`), ``headers`` (dict), ``timeout``
+            (int seconds), etc.
 
         Raises:
           ValidationError: if any lexicon schema is invalid
@@ -115,6 +120,7 @@ class Client(Base):
             self.address = DEFAULT_PDS
         # logger.debug(f'Using server at {address}')
 
+        self.requests_session = requests_session or requests.Session()
         self.requests_kwargs = copy.copy(requests_kwargs)
         headers = self.requests_kwargs.setdefault('headers', {})
         for name, val in DEFAULT_HEADERS.items():
@@ -129,7 +135,7 @@ class Client(Base):
         self.session_callback = session_callback
 
     def __getattr__(self, attr):
-        if NSID_SEGMENT_RE.match(attr):
+        if NSID_SEGMENT_RE.fullmatch(attr):
             return _NsidClient(self, attr)
 
         return getattr(super(), attr)
@@ -158,6 +164,7 @@ class Client(Base):
             loaded lexicons
           ValidationError: if the parameters, input, or returned output don't
             validate against the method's schemas
+          requests.HTTPError: if the remote server returned an error
           requests.RequestException: if the connection or HTTP request to the
             remote server failed
         """
@@ -168,13 +175,15 @@ class Client(Base):
         params = self.validate(nsid, 'parameters', params)
         params_str = self.encode_params(params)
 
-        type = self._get_def(nsid)['type']
+        lexicon = self._get_def(nsid)
+        type = lexicon['type']
         if type == 'subscription':
             input = self.validate(nsid, 'input', input)
 
         requests_kwargs = copy.copy(self.requests_kwargs)
+        content_type = lexicon.get('input', {}).get('encoding', 'application/json')
         headers = {
-            'Content-Type': 'application/json',
+            'Content-Type': content_type,
             **requests_kwargs.pop('headers'),
             **headers,
         }
@@ -195,7 +204,8 @@ class Client(Base):
             return self._subscribe(url, nsid, decode=decode)
 
         # query or procedure
-        fn = requests.get if type == 'query' else requests.post
+        fn = (self.requests_session.get if type == 'query'
+              else self.requests_session.post)
 
         # buffer binary inputs in memory. ideally we'd stream instead, but if we
         # have to refresh our token below, we need to seek the stream back to the
@@ -203,7 +213,7 @@ class Client(Base):
         if isinstance(input, IOBase) or hasattr(input, 'read'):
             input = input.read()
 
-        logger.debug(f'requests.{getattr(fn, "__name__", fn)} {url} {params_str} {self.loggable(input)} {headers} {requests_kwargs}')
+        logger.debug(f'requests.{"get" if type == "query" else "post"} {url} {params_str} {self.loggable(input)} {headers} {requests_kwargs}')
 
         if auth := requests_kwargs.get('auth'):
             orig_token = getattr(auth, 'token', None)
@@ -275,7 +285,7 @@ class Client(Base):
           ValidationError: if ``decode`` is True and an output payload doesn't
             validate gainst the subscription method's lexicon
         """
-        ws = simple_websocket.Client(url, headers={
+        ws = simple_websocket.Client.connect(url, headers={
             **DEFAULT_HEADERS,
             **self.requests_kwargs.get('headers', {}),
         })
@@ -291,3 +301,6 @@ class Client(Base):
                     yield msg
         except simple_websocket.ConnectionClosed as cc:
             logger.debug(cc)
+        finally:
+            if ws.connected:
+                ws.close()

{lexrpc-2.0 → lexrpc-2.2}/lexrpc/flask_server.py

@@ -4,13 +4,11 @@ from datetime import datetime, timedelta
 import logging
 
 import dag_cbor
-import dag_json
 from flask import after_this_request, make_response, request
 from flask.json import jsonify
 from flask.views import View
 from flask_sock import Sock
 from iterators import TimeoutIterator
-import libipld
 from multiformats import CID
 from simple_websocket import ConnectionClosed
 from werkzeug.exceptions import TooManyRequests
@@ -69,7 +67,7 @@ class XrpcEndpoint(View):
         self.server = server
 
     def dispatch_request(self, nsid):
-        if not NSID_RE.match(nsid):
+        if not NSID_RE.fullmatch(nsid):
             return {
                 'error': 'InvalidRequest',
                 'message': f'{nsid} is not a valid NSID',
@@ -155,6 +153,10 @@ def subscription(xrpc_server, nsid, limit_ips=False):
         # while we block waiting for results from the XRPC server method, and
         # we'll eventually exhaust the WSGI worker thread pool. background:
         # https://github.com/miguelgrinberg/flask-sock/issues/78
+        #
+        # TODO: put the client IP and maybe user agent into the thread name. (can
+        # assign to Thread.name directly.) would need to modify TimeoutIterator to
+        # support that.
         iter = TimeoutIterator(xrpc_server.call(nsid, **params),
                                timeout=SUBSCRIPTION_ITERATOR_TIMEOUT.total_seconds())
         for result in iter:
@@ -166,7 +168,7 @@ def subscription(xrpc_server, nsid, limit_ips=False):
                 continue
 
             header, payload = result
-            # TODO: validate header, payload?
+            # payload was validated in Server.call; header has no schema
 
             # log
             seq = payload.get('seq')
@@ -216,6 +218,11 @@ def subscription(xrpc_server, nsid, limit_ips=False):
 
         try:
             handle(ws)
+        except NotImplementedError as e:
+            msg = str(e)
+            logger.info(msg)
+            # WebSocket closure code 1011 is for "unexpected conditions"
+            ws.close(reason=1011, message=msg)
         finally:
             # ideally I'd use Flask's after_this_request instead, but it doesn't
             # guarantee that it'll run if the request raises an uncaught