omlish 0.0.0.dev472__tar.gz → 0.0.0.dev473__tar.gz

{omlish-0.0.0.dev472/omlish.egg-info → omlish-0.0.0.dev473}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev472
+Version: 0.0.0.dev473
 Summary: omlish
 Author: wrmsr
 License-Expression: BSD-3-Clause

{omlish-0.0.0.dev472 → omlish-0.0.0.dev473}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev472'
-__revision__ = '78c62ff9afe49d9f0ae12b27ff595b2079e9c082'
+__version__ = '0.0.0.dev473'
+__revision__ = '9f130fc70f42b7e2117fc6530397d1bd295b37e6'
 
 
 #

{omlish-0.0.0.dev472 → omlish-0.0.0.dev473}/omlish/collections/__init__.py

@@ -8,7 +8,9 @@ with _lang.auto_proxy_init(globals()):
 
     from .attrregistry import (  # noqa
         AttrRegistry,
+
         AttrRegistryCache,
+        SimpleAttrRegistryCache,
     )
 
     from .bimap import (  # noqa
@@ -17,6 +19,8 @@ with _lang.auto_proxy_init(globals()):
         make_bi_map,
     )
 
+    from . import cache  # noqa
+
     from .coerce import (  # noqa
         abs_set,
         abs_set_of,

{omlish-0.0.0.dev472 → omlish-0.0.0.dev473}/omlish/collections/attrregistry.py

@@ -1,3 +1,7 @@
+"""
+TODO:
+ - lock?
+"""
 import dataclasses as dc
 import typing as ta
 import weakref
@@ -50,13 +54,32 @@ class AttrRegistry(ta.Generic[K, V]):
     def add_invalidate_callback(self, callback: ta.Callable[[], None]) -> None:
         self._invalidate_callbacks.append(callback)
 
+    @ta.overload
     def register(self, obj: K, val: V) -> None:
-        check.not_in(obj, self._objs)
+        ...
 
-        self._objs[obj] = val
+    @ta.overload
+    def register(self, val: V) -> ta.Callable[[T], T]:
+        ...
 
-        for iv in self._invalidate_callbacks:
-            iv()
+    def register(self, *args):
+        def inner(obj, val):
+            check.not_in(obj, self._objs)
+
+            self._objs[obj] = val
+
+            for iv in self._invalidate_callbacks:
+                iv()
+
+            return obj
+
+        if len(args) == 1:
+            return lambda obj: inner(obj, args[0])
+        elif len(args) == 2:
+            inner = inner(*args)
+            return None
+        else:
+            raise TypeError(args)
 
     def _lookup(self, obj: ta.Any) -> lang.Maybe[V]:
         if not self._identity:
@@ -180,3 +203,8 @@ class AttrRegistryCache(ta.Generic[K, V, T]):
         out = self._prepare(instance_cls, collected)
         self._cache[weakref.ref(instance_cls, self._cache_remove)] = out
         return out
+
+
+class SimpleAttrRegistryCache(AttrRegistryCache[K, V, dict[str, tuple[K, V]]], ta.Generic[K, V]):
+    def __init__(self, registry: AttrRegistry[K, V]) -> None:
+        super().__init__(registry, lambda _, dct: dct)

omlish-0.0.0.dev473/omlish/dispatch/__init__.py

@@ -0,0 +1,18 @@
+from .. import lang as _lang
+
+
+with _lang.auto_proxy_init(globals()):
+    ##
+
+    from .dispatch import (  # noqa
+        Dispatcher,
+    )
+
+    from .functions import (  # noqa
+        function,
+    )
+
+    from .methods import (  # noqa
+        install_method,
+        method,
+    )

{omlish-0.0.0.dev472 → omlish-0.0.0.dev473}/omlish/formats/json/stream/__init__.py

@@ -1,3 +1,16 @@
+"""
+A generator powered, configurable, mostly fully streaming JSON parser.
+
+Regarding the 'streamyness' of the subsystems:
+ - Lexing only buffers for string and number literals.
+ - Parsing maintains only a stack that scales by nesting depth.
+ - Building values will obviously hold everything under the topmost object it's building until it's finished.
+
+It's reasonably optimized, but performance is not a primary or even secondary goal: its goal is flexibility. If speed
+matters use a native library.
+"""
+
+
 from .building import (  # noqa
     JsonValueBuilder,
 )

{omlish-0.0.0.dev472 → omlish-0.0.0.dev473}/omlish/http/clients/asyncs.py

@@ -3,9 +3,9 @@
 import abc
 import contextlib
 import dataclasses as dc
-import io
 import typing as ta
 
+from ...io.readers import AsyncBufferedBytesReader
 from ...lite.abstract import Abstract
 from ...lite.dataclasses import dataclass_shallow_asdict
 from .base import BaseHttpClient
@@ -27,25 +27,19 @@ AsyncHttpClientT = ta.TypeVar('AsyncHttpClientT', bound='AsyncHttpClient')
 @ta.final
 @dc.dataclass(frozen=True)  # kw_only=True
 class AsyncStreamHttpResponse(BaseHttpResponse):
-    class Stream(ta.Protocol):
-        def read1(self, /, n: int = -1) -> ta.Awaitable[bytes]: ...
+    _stream: ta.Optional[AsyncBufferedBytesReader] = None
 
-    @ta.final
-    class _NullStream:
-        def read1(self, /, n: int = -1) -> ta.Awaitable[bytes]:
-            raise TypeError
-
-    stream: Stream = _NullStream()
+    @property
+    def stream(self) -> 'AsyncBufferedBytesReader':
+        if (st := self._stream) is None:
+            raise TypeError('No data')
+        return st
 
     @property
     def has_data(self) -> bool:
-        return not isinstance(self.stream, AsyncStreamHttpResponse._NullStream)
+        return self._stream is not None
 
-    async def read_all(self) -> bytes:
-        buf = io.BytesIO()
-        while (b := await self.stream.read1()):
-            buf.write(b)
-        return buf.getvalue()
+    #
 
     _closer: ta.Optional[ta.Callable[[], ta.Awaitable[None]]] = None
 
@@ -96,8 +90,8 @@ async def async_read_http_client_response(resp: BaseHttpResponse) -> HttpRespons
 
     elif isinstance(resp, AsyncStreamHttpResponse):
         return HttpResponse(**{
-            **{k: v for k, v in dataclass_shallow_asdict(resp).items() if k not in ('stream', '_closer')},
-            **({'data': await resp.read_all()} if resp.has_data else {}),
+            **{k: v for k, v in dataclass_shallow_asdict(resp).items() if k not in ('_stream', '_closer')},
+            **({'data': await resp.stream.readall()} if resp.has_data else {}),
         })
 
     else:

{omlish-0.0.0.dev472 → omlish-0.0.0.dev473}/omlish/http/clients/coro/sync.py

@@ -5,6 +5,7 @@ import socket
 import typing as ta
 import urllib.parse
 
+from ....io.buffers import ReadableListBuffer
 from ....lite.check import check
 from ...coro.client.connection import CoroHttpClientConnection
 from ...coro.client.response import CoroHttpClientResponse
@@ -92,7 +93,7 @@ class CoroHttpClient(HttpClient):
                     headers=HttpHeaders(resp._state.headers.items()),  # noqa
                     request=self._req,
                     underlying=self,
-                    stream=self,
+                    _stream=ReadableListBuffer().new_buffered_reader(self),
                     _closer=self.close,
                 )
 

{omlish-0.0.0.dev472 → omlish-0.0.0.dev473}/omlish/http/clients/executor.py

@@ -33,6 +33,12 @@ class ExecutorAsyncHttpClient(AsyncHttpClient):
         async def read1(self, /, n: int = -1) -> bytes:
             return await self.owner._run_in_executor(self.resp.stream.read1, n)  # noqa
 
+        async def read(self, /, n: int = -1) -> bytes:
+            return await self.owner._run_in_executor(self.resp.stream.read, n)  # noqa
+
+        async def readall(self) -> bytes:
+            return await self.owner._run_in_executor(self.resp.stream.readall)  # noqa
+
         async def close(self) -> None:
             return await self.owner._run_in_executor(self.resp.close)  # noqa
 
@@ -44,7 +50,7 @@ class ExecutorAsyncHttpClient(AsyncHttpClient):
             request=req,
             underlying=resp,
             **(dict(  # type: ignore
-                stream=(adapter := self._StreamAdapter(self, resp)),
+                _stream=(adapter := self._StreamAdapter(self, resp)),
                 _closer=adapter.close,
             ) if resp.has_data else {}),
         )

{omlish-0.0.0.dev472 → omlish-0.0.0.dev473}/omlish/http/clients/httpx.py

@@ -32,27 +32,12 @@ class HttpxHttpClient(HttpClient):
     @dc.dataclass(frozen=True)
     class _StreamAdapter:
         it: ta.Iterator[bytes]
-        buf: ReadableListBuffer = dc.field(default_factory=ReadableListBuffer)
 
         def read1(self, /, n: int = -1) -> bytes:
-            if n < 0:
-                if (b := self.buf.read(n)) is not None:
-                    return b
-                try:
-                    return next(self.it)
-                except StopIteration:
-                    return b''
-
-            else:
-                while len(self.buf) < n:
-                    try:
-                        b = next(self.it)
-                    except StopIteration:
-                        b = b''
-                    if not b:
-                        return self.buf.read() or b''
-                    self.buf.feed(b)
-                return self.buf.read(n) or b''
+            try:
+                return next(self.it)
+            except StopIteration:
+                return b''
 
     def _stream_request(self, ctx: HttpClientContext, req: HttpRequest) -> StreamHttpResponse:
         try:
@@ -76,7 +61,7 @@ class HttpxHttpClient(HttpClient):
                 headers=HttpHeaders(resp.headers.raw),
                 request=req,
                 underlying=resp,
-                stream=self._StreamAdapter(resp.iter_bytes()),
+                _stream=ReadableListBuffer().new_buffered_reader(self._StreamAdapter(resp.iter_bytes())),
                 _closer=resp_close,  # type: ignore
             )
 
@@ -84,7 +69,7 @@ class HttpxHttpClient(HttpClient):
             resp_close()
             raise HttpClientError from e
 
-        except Exception:
+        except BaseException:
             resp_close()
             raise
 
@@ -96,27 +81,12 @@ class HttpxAsyncHttpClient(AsyncHttpClient):
     @dc.dataclass(frozen=True)
     class _StreamAdapter:
         it: ta.AsyncIterator[bytes]
-        buf: ReadableListBuffer = dc.field(default_factory=ReadableListBuffer)
 
         async def read1(self, /, n: int = -1) -> bytes:
-            if n < 0:
-                if (b := self.buf.read(n)) is not None:
-                    return b
-                try:
-                    return await anext(self.it)
-                except StopAsyncIteration:
-                    return b''
-
-            else:
-                while len(self.buf) < n:
-                    try:
-                        b = await anext(self.it)
-                    except StopAsyncIteration:
-                        b = b''
-                    if not b:
-                        return self.buf.read() or b''
-                    self.buf.feed(b)
-                return self.buf.read(n) or b''
+            try:
+                return await anext(self.it)
+            except StopAsyncIteration:
+                return b''
 
     async def _stream_request(self, ctx: HttpClientContext, req: HttpRequest) -> AsyncStreamHttpResponse:
         es = contextlib.AsyncExitStack()
@@ -132,12 +102,37 @@ class HttpxAsyncHttpClient(AsyncHttpClient):
                 timeout=req.timeout_s,
             ))
 
+            it = resp.aiter_bytes()
+
+            # FIXME:
+            #  - https://github.com/encode/httpx/discussions/2963
+            #   - Exception ignored in: <async_generator object HTTP11ConnectionByteStream.__aiter__ at 0x1325a7540>
+            #   - RuntimeError: async generator ignored GeneratorExit
+            #  - Traced to:
+            #   - HTTP11ConnectionByteStream.aclose -> await self._connection._response_closed()
+            #   - AsyncHTTP11Connection._response_closed -> async with self._state_lock
+            #   - anyio._backends._asyncio.Lock.acquire -> await AsyncIOBackend.cancel_shielded_checkpoint() -> await sleep(0)  # noqa
+            #  - Might have something to do with pycharm/pydevd's nested asyncio, doesn't seem to happen under trio ever
+            #    or asyncio outside debugger.
+            @es.push_async_callback
+            async def close_it() -> None:
+                try:
+                    # print(f'close_it.begin: {it=}', file=sys.stderr)
+                    await it.aclose()  # type: ignore[attr-defined]
+                    # print(f'close_it.end: {it=}', file=sys.stderr)
+                except BaseException as be:  # noqa
+                    # print(f'close_it.__exit__: {it=} {be=}', file=sys.stderr)
+                    raise
+                finally:
+                    # print(f'close_it.finally: {it=}', file=sys.stderr)
+                    pass
+
             return AsyncStreamHttpResponse(
                 status=resp.status_code,
                 headers=HttpHeaders(resp.headers.raw),
                 request=req,
                 underlying=resp,
-                stream=self._StreamAdapter(resp.aiter_bytes()),
+                _stream=ReadableListBuffer().new_async_buffered_reader(self._StreamAdapter(it)),
                 _closer=es.aclose,
             )
 
@@ -145,6 +140,6 @@ class HttpxAsyncHttpClient(AsyncHttpClient):
             await es.aclose()
             raise HttpClientError from e
 
-        except Exception:
+        except BaseException:
             await es.aclose()
             raise

{omlish-0.0.0.dev472 → omlish-0.0.0.dev473}/omlish/http/clients/sync.py

@@ -3,9 +3,9 @@
 import abc
 import contextlib
 import dataclasses as dc
-import io
 import typing as ta
 
+from ...io.readers import BufferedBytesReader
 from ...lite.abstract import Abstract
 from ...lite.dataclasses import dataclass_shallow_asdict
 from .base import BaseHttpClient
@@ -27,25 +27,19 @@ HttpClientT = ta.TypeVar('HttpClientT', bound='HttpClient')
 @ta.final
 @dc.dataclass(frozen=True)  # kw_only=True
 class StreamHttpResponse(BaseHttpResponse):
-    class Stream(ta.Protocol):
-        def read1(self, /, n: int = -1) -> bytes: ...
+    _stream: ta.Optional[BufferedBytesReader] = None
 
-    @ta.final
-    class _NullStream:
-        def read1(self, /, n: int = -1) -> bytes:
-            raise TypeError
-
-    stream: Stream = _NullStream()
+    @property
+    def stream(self) -> 'BufferedBytesReader':
+        if (st := self._stream) is None:
+            raise TypeError('No data')
+        return st
 
     @property
     def has_data(self) -> bool:
-        return not isinstance(self.stream, StreamHttpResponse._NullStream)
+        return self._stream is not None
 
-    def read_all(self) -> bytes:
-        buf = io.BytesIO()
-        while (b := self.stream.read1()):
-            buf.write(b)
-        return buf.getvalue()
+    #
 
     _closer: ta.Optional[ta.Callable[[], None]] = None
 
@@ -94,8 +88,8 @@ def read_http_client_response(resp: BaseHttpResponse) -> HttpResponse:
 
     elif isinstance(resp, StreamHttpResponse):
         return HttpResponse(**{
-            **{k: v for k, v in dataclass_shallow_asdict(resp).items() if k not in ('stream', '_closer')},
-            **({'data': resp.read_all()} if resp.has_data else {}),
+            **{k: v for k, v in dataclass_shallow_asdict(resp).items() if k not in ('_stream', '_closer')},
+            **({'data': resp.stream.readall()} if resp.has_data else {}),
         })
 
     else:

{omlish-0.0.0.dev472 → omlish-0.0.0.dev473}/omlish/http/clients/syncasync.py

@@ -26,6 +26,12 @@ class SyncAsyncHttpClient(AsyncHttpClient):
         async def read1(self, /, n: int = -1) -> bytes:
             return self.ul.stream.read1(n)
 
+        async def read(self, /, n: int = -1) -> bytes:
+            return self.ul.stream.read(n)
+
+        async def readall(self) -> bytes:
+            return self.ul.stream.readall()
+
         async def close(self) -> None:
             self.ul.close()
 
@@ -37,7 +43,7 @@ class SyncAsyncHttpClient(AsyncHttpClient):
             request=req,
             underlying=resp,
             **(dict(  # type: ignore
-                stream=(adapter := self._StreamAdapter(resp)),
+                _stream=(adapter := self._StreamAdapter(resp)),
                 _closer=adapter.close,
             ) if resp.has_data else {}),
         )

{omlish-0.0.0.dev472 → omlish-0.0.0.dev473}/omlish/http/clients/urllib.py

@@ -5,6 +5,7 @@ import typing as ta
 import urllib.error
 import urllib.request
 
+from ...io.buffers import ReadableListBuffer
 from ..headers import HttpHeaders
 from .base import DEFAULT_ENCODING
 from .base import HttpClientContext
@@ -72,7 +73,7 @@ class UrllibHttpClient(HttpClient):
                 headers=HttpHeaders(resp.headers.items()),
                 request=req,
                 underlying=resp,
-                stream=resp,
+                _stream=ReadableListBuffer().new_buffered_reader(resp),
                 _closer=resp.close,
             )
 

{omlish-0.0.0.dev472 → omlish-0.0.0.dev473}/omlish/io/buffers.py

@@ -1,10 +1,18 @@
 # ruff: noqa: UP006 UP007 UP043 UP045
 # @omlish-lite
+"""
+TODO:
+ - overhaul and just coro-ify pyio?
+"""
 import io
 import typing as ta
 
 from ..lite.attrops import attr_repr
 from ..lite.check import check
+from .readers import AsyncBufferedBytesReader
+from .readers import AsyncRawBytesReader
+from .readers import BufferedBytesReader
+from .readers import RawBytesReader
 
 
 ##
@@ -183,6 +191,9 @@ class ReadableListBuffer:
 
         self._lst: list[bytes] = []
 
+    def __bool__(self) -> ta.NoReturn:
+        raise TypeError("Use 'buf is not None' or 'len(buf)'.")
+
     def __len__(self) -> int:
         return sum(map(len, self._lst))
 
@@ -249,6 +260,110 @@ class ReadableListBuffer:
         r = self.read_until_(delim)
         return r if isinstance(r, bytes) else None
 
+    #
+
+    DEFAULT_BUFFERED_READER_CHUNK_SIZE: ta.ClassVar[int] = -1
+
+    @ta.final
+    class _BufferedBytesReader(BufferedBytesReader):
+        def __init__(
+                self,
+                raw: RawBytesReader,
+                buf: 'ReadableListBuffer',
+                *,
+                chunk_size: ta.Optional[int] = None,
+        ) -> None:
+            self._raw = raw
+            self._buf = buf
+            self._chunk_size = chunk_size or ReadableListBuffer.DEFAULT_BUFFERED_READER_CHUNK_SIZE
+
+        def read1(self, /, n: int = -1) -> bytes:
+            if n < 0:
+                n = self._chunk_size
+            if not n:
+                return b''
+            if 0 < n <= len(self._buf):
+                return self._buf.read(n) or b''
+            return self._raw.read1(n)
+
+        def read(self, /, n: int = -1) -> bytes:
+            if n < 0:
+                return self.readall()
+            while len(self._buf) < n:
+                if not (b := self._raw.read1(n)):
+                    break
+                self._buf.feed(b)
+            return self._buf.read(n) or b''
+
+        def readall(self) -> bytes:
+            buf = io.BytesIO()
+            buf.write(self._buf.read() or b'')
+            while (b := self._raw.read1(self._chunk_size)):
+                buf.write(b)
+            return buf.getvalue()
+
+    def new_buffered_reader(
+            self,
+            raw: RawBytesReader,
+            *,
+            chunk_size: ta.Optional[int] = None,
+    ) -> BufferedBytesReader:
+        return self._BufferedBytesReader(
+            raw,
+            self,
+            chunk_size=chunk_size,
+        )
+
+    @ta.final
+    class _AsyncBufferedBytesReader(AsyncBufferedBytesReader):
+        def __init__(
+                self,
+                raw: AsyncRawBytesReader,
+                buf: 'ReadableListBuffer',
+                *,
+                chunk_size: ta.Optional[int] = None,
+        ) -> None:
+            self._raw = raw
+            self._buf = buf
+            self._chunk_size = chunk_size or ReadableListBuffer.DEFAULT_BUFFERED_READER_CHUNK_SIZE
+
+        async def read1(self, /, n: int = -1) -> bytes:
+            if n < 0:
+                n = self._chunk_size
+            if not n:
+                return b''
+            if 0 < n <= len(self._buf):
+                return self._buf.read(n) or b''
+            return await self._raw.read1(n)
+
+        async def read(self, /, n: int = -1) -> bytes:
+            if n < 0:
+                return await self.readall()
+            while len(self._buf) < n:
+                if not (b := await self._raw.read1(n)):
+                    break
+                self._buf.feed(b)
+            return self._buf.read(n) or b''
+
+        async def readall(self) -> bytes:
+            buf = io.BytesIO()
+            buf.write(self._buf.read() or b'')
+            while b := await self._raw.read1(self._chunk_size):
+                buf.write(b)
+            return buf.getvalue()
+
+    def new_async_buffered_reader(
+            self,
+            raw: AsyncRawBytesReader,
+            *,
+            chunk_size: ta.Optional[int] = None,
+    ) -> AsyncBufferedBytesReader:
+        return self._AsyncBufferedBytesReader(
+            raw,
+            self,
+            chunk_size=chunk_size,
+        )
+
 
 ##
 

omlish-0.0.0.dev473/omlish/io/readers.py

@@ -0,0 +1,29 @@
+# ruff: noqa: UP045
+# @omlish-lite
+import typing as ta
+
+
+##
+
+
+class RawBytesReader(ta.Protocol):
+    def read1(self, /, n: int = -1) -> bytes: ...
+
+
+class BufferedBytesReader(RawBytesReader, ta.Protocol):
+    def read(self, /, n: int = -1) -> bytes: ...
+
+    def readall(self) -> bytes: ...
+
+
+#
+
+
+class AsyncRawBytesReader(ta.Protocol):
+    def read1(self, /, n: int = -1) -> ta.Awaitable[bytes]: ...
+
+
+class AsyncBufferedBytesReader(AsyncRawBytesReader, ta.Protocol):
+    def read(self, /, n: int = -1) -> ta.Awaitable[bytes]: ...
+
+    def readall(self) -> ta.Awaitable[bytes]: ...

{omlish-0.0.0.dev472 → omlish-0.0.0.dev473}/omlish/lite/contextmanagers.py

@@ -54,7 +54,7 @@ class ExitStacked:
             es.__enter__()
             try:
                 self._enter_contexts()
-            except Exception:  # noqa
+            except BaseException:  # noqa
                 es.__exit__(*sys.exc_info())
                 raise
             return self
@@ -65,7 +65,7 @@ class ExitStacked:
             return None
         try:
             self._exit_contexts()
-        except Exception:  # noqa
+        except BaseException:  # noqa
             es.__exit__(*sys.exc_info())
             raise
         return es.__exit__(exc_type, exc_val, exc_tb)
@@ -113,7 +113,7 @@ class AsyncExitStacked:
             await es.__aenter__()
             try:
                 await self._async_enter_contexts()
-            except Exception:  # noqa
+            except BaseException:  # noqa
                 await es.__aexit__(*sys.exc_info())
                 raise
             return self
@@ -124,7 +124,7 @@ class AsyncExitStacked:
             return None
         try:
             await self._async_exit_contexts()
-        except Exception:  # noqa
+        except BaseException:  # noqa
             await es.__aexit__(*sys.exc_info())
             raise
         return await es.__aexit__(exc_type, exc_val, exc_tb)

{omlish-0.0.0.dev472 → omlish-0.0.0.dev473/omlish.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev472
+Version: 0.0.0.dev473
 Summary: omlish
 Author: wrmsr
 License-Expression: BSD-3-Clause

{omlish-0.0.0.dev472 → omlish-0.0.0.dev473}/omlish.egg-info/SOURCES.txt

@@ -403,6 +403,7 @@ omlish/io/abc.py
 omlish/io/buffers.py
 omlish/io/fileno.py
 omlish/io/pyio.py
+omlish/io/readers.py
 omlish/io/compress/__init__.py
 omlish/io/compress/abc.py
 omlish/io/compress/adapters.py

{omlish-0.0.0.dev472 → omlish-0.0.0.dev473}/pyproject.toml

@@ -13,7 +13,7 @@ urls = {source = 'https://github.com/wrmsr/omlish'}
 license = 'BSD-3-Clause'
 readme = 'README.md'
 requires-python = '>=3.13'
-version = '0.0.0.dev472'
+version = '0.0.0.dev473'
 classifiers = [
     'Development Status :: 2 - Pre-Alpha',
     'Intended Audience :: Developers',