omlish 0.0.0.dev305__py3-none-any.whl → 0.0.0.dev306__py3-none-any.whl

omlish/.manifests.json

@@ -51,6 +51,20 @@
       }
     }
   },
+  {
+    "module": ".formats.edn.codec",
+    "attr": "_EDN_LAZY_CODEC",
+    "file": "omlish/formats/edn/codec.py",
+    "line": 25,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.formats.edn.codec",
+        "attr_name": "EDN_CODEC",
+        "name": "edn",
+        "aliases": null
+      }
+    }
+  },
   {
     "module": ".formats.ini.codec",
     "attr": "_INI_LAZY_CODEC",

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev305'
-__revision__ = '13f1bfc223e6af63310421aa4ac6133b3f1e0110'
+__version__ = '0.0.0.dev306'
+__revision__ = 'dda70244f84192bfce2428b682f9a5e2349fb05a'
 
 
 #
@@ -101,7 +101,7 @@ class Project(ProjectBase):
 
             'apsw ~= 3.49',
 
-            'sqlean.py ~= 3.47',
+            'sqlean.py ~= 3.49',
 
             'duckdb ~= 1.2',
         ],

omlish/formats/edn/LICENSE

@@ -0,0 +1,16 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Jorin Vogel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

omlish/formats/edn/__init__.py

@@ -0,0 +1,15 @@
+from .parsing import (  # Noqa
+    parse,
+    parse_list,
+)
+
+from .values import (  # noqa
+    Char,
+    Keyword,
+    List,
+    Map,
+    Set,
+    Symbol,
+    TaggedVal,
+    Vector,
+)

omlish/formats/edn/codec.py

@@ -0,0 +1,26 @@
+import typing as ta
+
+from ..codecs import make_object_lazy_loaded_codec
+from ..codecs import make_str_object_codec
+from .parsing import parse
+
+
+##
+
+
+def dumps(obj: ta.Any) -> str:
+    # return json.dumps(obj)
+    raise NotImplementedError
+
+
+def loads(s: str) -> ta.Any:
+    return parse(s)
+
+
+##
+
+
+EDN_CODEC = make_str_object_codec('edn', dumps, loads)
+
+# @omlish-manifest
+_EDN_LAZY_CODEC = make_object_lazy_loaded_codec(__name__, 'EDN_CODEC', EDN_CODEC)

omlish/formats/edn/parsing.py

@@ -0,0 +1,359 @@
+"""
+TODO:
+ - reader meta - ^:foo
+"""
+# https://github.com/jorinvo/edn-data/blob/1e5824f63803eb58f35e98839352000053d47115/test/parse.test.ts
+import datetime
+import enum
+import re
+import typing as ta
+
+from ... import check
+from .values import Char
+from .values import Keyword
+from .values import List
+from .values import Map
+from .values import Set
+from .values import Symbol
+from .values import TaggedVal
+from .values import Vector
+
+
+##
+
+
+class ListParser:
+    DEFAULT_TAG_HANDLERS: ta.ClassVar[ta.Mapping[str, ta.Callable[..., ta.Any]]] = {
+        'inst': lambda val: datetime.datetime.fromisoformat(val) if isinstance(val, str) else None,
+    }
+
+    def __init__(
+            self,
+            *,
+            keyword_maker: ta.Callable[..., ta.Any] = Keyword,
+            char_maker: ta.Callable[..., ta.Any] = Char,
+            symbol_maker: ta.Callable[..., ta.Any] = Symbol,
+
+            list_maker: ta.Callable[..., ta.Any] = List.new,
+            vector_maker: ta.Callable[..., ta.Any] = Vector.new,
+            set_maker: ta.Callable[..., ta.Any] = Set.new,
+            map_maker: ta.Callable[..., ta.Any] = Map.new,
+
+            tag_handlers: ta.Mapping[str, ta.Callable[..., ta.Any]] | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._keyword_maker = keyword_maker
+        self._char_maker = char_maker
+        self._symbol_maker = symbol_maker
+
+        self._list_maker = list_maker
+        self._vector_maker = vector_maker
+        self._set_maker = set_maker
+        self._map_maker = map_maker
+
+        self._tag_handlers = {
+            **self.DEFAULT_TAG_HANDLERS,
+            **(tag_handlers or {}),
+        }
+
+        self._stack: list[tuple[ListParser._ParseMode | ListParser._StackItem, ta.Any]] = []
+        self._mode: ListParser._ParseMode = ListParser._ParseMode.IDLE
+        self._state = ''
+        self._result: ta.Any = self._UNDEFINED
+
+    #
+
+    class _UNDEFINED:  # noqa
+        def __new__(cls, *args, **kwargs):  # noqa
+            raise TypeError
+
+    class _ParseMode(enum.Enum):
+        IDLE = 0
+        STRING = 1
+        ESCAPE = 2
+        COMMENT = 3
+
+    class _StackItem(enum.Enum):
+        VECTOR = 0
+        LIST = 1
+        MAP = 2
+        SET = 3
+        TAG = 4
+
+    #
+
+    def _update_stack(self) -> None:
+        if not self._stack or self._result is self._UNDEFINED:
+            return
+
+        stack_item, prev_state = self._stack[-1]
+
+        if stack_item == ListParser._StackItem.VECTOR:
+            prev_state.append(self._result)
+
+        elif stack_item == ListParser._StackItem.LIST:
+            prev_state.append(self._result)
+
+        elif stack_item == ListParser._StackItem.SET:
+            prev_state.append(self._result)
+
+        elif stack_item == ListParser._StackItem.MAP:
+            if len(prev_state[1]) > 0:
+                prev_state[0].append([prev_state[1].pop(), self._result])
+            else:
+                prev_state[1].append(self._result)
+
+        elif stack_item == ListParser._StackItem.TAG:
+            self._stack.pop()
+
+            if prev_state == '_':
+                self._result = self._UNDEFINED
+
+            else:
+                tag_handler = self._tag_handlers.get(prev_state)
+                if tag_handler:
+                    self._result = tag_handler(self._result)
+                else:
+                    self._result = TaggedVal(prev_state, self._result)
+
+            self._update_stack()
+            return
+
+        # TODO: else error
+        # Reset result after updating stack
+        self._result = self._UNDEFINED
+
+    #
+
+    _INT_PAT = re.compile(r'^[-+]?(0|[1-9][0-9]*)$')
+    _BIGINT_PAT = re.compile(r'^[-+]?(0|[1-9][0-9]*)N$')
+    _FLOAT_PAT = re.compile(r'^[-+]?(0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?(0|[1-9][0-9]*))?M?$')
+
+    def _match(self) -> None:
+        if self._state == 'nil':
+            self._result = None
+
+        elif self._state == 'true':
+            self._result = True
+
+        elif self._state == 'false':
+            self._result = False
+
+        elif self._state.startswith(':'):
+            # Keyword
+            self._result = self._keyword_maker(self._state[1:])
+
+        elif self._state.startswith('#'):
+            # Tag
+            self._stack.append((ListParser._StackItem.TAG, self._state[1:]))
+            self._result = self._UNDEFINED
+
+        elif self._INT_PAT.match(self._state):
+            # Int
+            self._result = int(self._state)
+
+        elif self._FLOAT_PAT.match(self._state):
+            # Float
+            self._result = float(self._state)
+
+        elif self._BIGINT_PAT.match(self._state):
+            # BigInt
+            self._result = int(self._state[:-1])  # In Python we don't need special handling for bigint
+
+        elif self._state.startswith('\\'):
+            # Char
+            check.state(len(self._state) > 1)
+            if self._state == '\\space':
+                c = ' '
+            elif self._state == '\\newline':
+                c = '\n'
+            elif self._state == '\\return':
+                c = '\r'
+            elif self._state == '\\tab':
+                c = '\t'
+            elif self._state == '\\\\':
+                c = '\\'
+            elif self._state.startswith('\\u'):
+                check.state(len(self._state) == 6)
+                c = chr(int(self._state[2:], 16))
+            else:
+                check.state(len(self._state) == 2)
+                c = self._state[1:]
+
+            self._result = self._char_maker(c)
+
+        elif self._state:
+            # Symbol
+            self._result = self._symbol_maker(self._state)
+
+        self._state = ''
+
+    #
+
+    _SPACE_CHARS: ta.ClassVar[ta.AbstractSet[str]] = frozenset([',', ' ', '\t', '\n', '\r'])
+
+    _STRING_ESCAPE_MAP: ta.ClassVar[ta.Mapping[str, str]] = {
+        't': '\t',
+        'r': '\r',
+        'n': '\n',
+        '\\': '\\',
+        '"': '"',
+    }
+
+    def parse(self, src: str) -> list[ta.Any]:
+        values = []
+
+        i = -1
+        for i in range(len(src)):
+            if not self._stack and self._result is not self._UNDEFINED:
+                values.append(self._result)
+                self._result = self._UNDEFINED
+
+            char = src[i]
+
+            if self._mode == ListParser._ParseMode.IDLE:
+                if char == '"':
+                    self._match()
+                    self._update_stack()
+                    self._mode = ListParser._ParseMode.STRING
+                    self._state = ''
+                    continue
+
+                if char == ';':
+                    self._mode = ListParser._ParseMode.COMMENT
+                    continue
+
+                if char in self._SPACE_CHARS:
+                    self._match()
+                    self._update_stack()
+                    continue
+
+                if char == '}':
+                    self._match()
+                    self._update_stack()
+
+                    if self._stack:
+                        stack_item, prev_state = self._stack.pop()
+
+                        if stack_item == ListParser._StackItem.MAP:
+                            check.empty(prev_state[1])
+                            self._result = self._map_maker(prev_state[0])
+
+                        else:  # Set
+                            # FIXME:
+                            # check.state(stack_item == ListParser._StackItem.SET)
+                            self._result = self._set_maker(prev_state)
+
+                    self._update_stack()
+                    continue
+
+                if char == ']':
+                    self._match()
+                    self._update_stack()
+                    stack_item, prev_state = self._stack.pop()
+                    self._result = self._vector_maker(tuple(prev_state))
+                    self._update_stack()
+                    continue
+
+                if char == ')':
+                    self._match()
+                    self._update_stack()
+                    stack_item, prev_state = self._stack.pop()
+                    self._result = self._list_maker(prev_state)
+                    self._update_stack()
+                    continue
+
+                if char == '[':
+                    self._match()
+                    self._update_stack()
+                    self._stack.append((ListParser._StackItem.VECTOR, []))
+                    continue
+
+                if char == '(':
+                    self._match()
+                    self._update_stack()
+                    self._stack.append((ListParser._StackItem.LIST, []))
+                    continue
+
+                state_plus_char = self._state + char
+                if state_plus_char == '#_':
+                    self._stack.append((ListParser._StackItem.TAG, char))
+                    self._result = self._UNDEFINED
+                    self._state = ''
+                    continue
+
+                if state_plus_char.endswith('#{'):
+                    self._state = self._state[:-1]  # Remove the '#'
+                    self._match()
+                    self._update_stack()
+                    self._stack.append((ListParser._StackItem.SET, []))
+                    self._state = ''
+                    continue
+
+                if char == '{':
+                    self._match()
+                    self._update_stack()
+                    self._stack.append((ListParser._StackItem.MAP, [[], []]))
+                    self._state = ''
+                    continue
+
+                self._state += char
+                continue
+
+            elif self._mode == ListParser._ParseMode.STRING:  # noqa
+                if char == '\\':
+                    self._stack.append((self._mode, self._state))
+                    self._mode = ListParser._ParseMode.ESCAPE
+                    self._state = ''
+                    continue
+
+                if char == '"':
+                    self._mode = ListParser._ParseMode.IDLE
+                    self._result = self._state
+                    self._update_stack()
+                    self._state = ''
+                    continue
+
+                self._state += char
+
+            elif self._mode == ListParser._ParseMode.ESCAPE:
+                # TODO what should happen when escaping other char
+                escaped_char = self._STRING_ESCAPE_MAP.get(char, char)
+                stack_item, prev_state = self._stack.pop()
+                self._mode = check.isinstance(stack_item, ListParser._ParseMode)
+                self._state = prev_state + escaped_char
+
+            elif self._mode == ListParser._ParseMode.COMMENT:
+                if char == '\n':
+                    self._mode = ListParser._ParseMode.IDLE
+
+            else:
+                raise RuntimeError(self._mode)
+
+        if i >= 0:
+            self._match()
+            self._update_stack()
+
+        check.state(not self._stack)
+
+        if self._result is not self._UNDEFINED:
+            values.append(self._result)
+        return values
+
+
+#
+
+
+def parse_list(src: str, **kwargs: ta.Any) -> list[ta.Any]:
+    """Parse an edn string and return the corresponding Python object."""
+
+    parser = ListParser(**kwargs)
+    return parser.parse(src)
+
+
+def parse(src: str, **kwargs: ta.Any) -> ta.Any | None:
+    values = parse_list(src, **kwargs)
+    if not values:
+        return None
+    return check.single(values)

omlish/formats/edn/values.py

@@ -0,0 +1,162 @@
+import dataclasses as dc
+import typing as ta
+
+from ... import check
+from ... import lang
+from ...lite.dataclasses import dataclass_cache_hash
+
+
+##
+
+
+_DEBUG = __debug__
+# _DEBUG = True
+
+
+@dc.dataclass(frozen=True)
+class Value(lang.Abstract, lang.Sealed):
+    pass
+
+
+#
+
+
+@dc.dataclass(frozen=True)
+class Scalar(Value, lang.Abstract):
+    pass
+
+
+@dataclass_cache_hash()
+@dc.dataclass(frozen=True)
+class Keyword(Scalar, lang.Final):
+    s: str
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.s!r})'
+
+    if _DEBUG:
+        def __post_init__(self) -> None:
+            check.isinstance(self.s, str)
+
+
+@dataclass_cache_hash()
+@dc.dataclass(frozen=True)
+class Char(Scalar, lang.Final):
+    c: str
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.c!r})'
+
+    if _DEBUG:
+        def __post_init__(self) -> None:
+            check.isinstance(self.c, str)
+            check.equal(len(self.c), 1)
+
+
+@dataclass_cache_hash()
+@dc.dataclass(frozen=True)
+class Symbol(Scalar, lang.Final):
+    n: str
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.n!r})'
+
+    if _DEBUG:
+        def __post_init__(self) -> None:
+            check.non_empty_str(self.n)
+
+
+#
+
+
+@dc.dataclass(frozen=True)
+class Collection(Value, lang.Abstract):
+    pass
+
+
+@dataclass_cache_hash()
+@dc.dataclass(frozen=True)
+class List(Collection, lang.Final):
+    items: ta.Sequence[ta.Any]
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.items!r})'
+
+    if _DEBUG:
+        def __post_init__(self) -> None:
+            check.isinstance(self.items, tuple)
+
+    @classmethod
+    def new(cls, items: ta.Iterable[ta.Any]) -> 'List':
+        return cls(tuple(items))
+
+
+@dataclass_cache_hash()
+@dc.dataclass(frozen=True)
+class Vector(Collection, lang.Final):
+    items: ta.Sequence[ta.Any]
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.items!r})'
+
+    if _DEBUG:
+        def __post_init__(self) -> None:
+            check.isinstance(self.items, tuple)
+
+    @classmethod
+    def new(cls, items: ta.Iterable[ta.Any]) -> 'Vector':
+        return cls(tuple(items))
+
+
+@dataclass_cache_hash()
+@dc.dataclass(frozen=True)
+class Set(Collection, lang.Final):
+    items: ta.Sequence[ta.Any]
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.items!r})'
+
+    if _DEBUG:
+        def __post_init__(self) -> None:
+            check.isinstance(self.items, tuple)
+
+    @classmethod
+    def new(cls, items: ta.Iterable[ta.Any]) -> 'Set':
+        return cls(tuple(items))
+
+
+@dataclass_cache_hash()
+@dc.dataclass(frozen=True)
+class Map(Collection, lang.Final):
+    items: ta.Sequence[tuple[ta.Any, ta.Any]]
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.items!r})'
+
+    if _DEBUG:
+        def __post_init__(self) -> None:
+            check.isinstance(self.items, tuple)
+            for t in self.items:
+                check.isinstance(t, tuple)
+                check.equal(len(t), 2)
+
+    @classmethod
+    def new(cls, items: ta.Iterable[ta.Iterable[ta.Any]]) -> 'Map':
+        return cls(tuple((k, v) for k, v in items))
+
+
+#
+
+
+@dataclass_cache_hash()
+@dc.dataclass(frozen=True)
+class TaggedVal(Value, lang.Final):
+    t: str
+    v: ta.Any
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.t!r}, {self.v!r})'
+
+    if _DEBUG:
+        def __post_init__(self) -> None:
+            check.non_empty_str(self.t)

{omlish-0.0.0.dev305.dist-info → omlish-0.0.0.dev306.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev305
+Version: 0.0.0.dev306
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause
@@ -40,7 +40,7 @@ Requires-Dist: aiomysql~=0.2; extra == "all"
 Requires-Dist: aiosqlite~=0.21; extra == "all"
 Requires-Dist: asyncpg~=0.30; extra == "all"
 Requires-Dist: apsw~=3.49; extra == "all"
-Requires-Dist: sqlean.py~=3.47; extra == "all"
+Requires-Dist: sqlean.py~=3.49; extra == "all"
 Requires-Dist: duckdb~=1.2; extra == "all"
 Requires-Dist: markupsafe~=3.0; extra == "all"
 Requires-Dist: jinja2~=3.1; extra == "all"
@@ -88,7 +88,7 @@ Requires-Dist: aiomysql~=0.2; extra == "sqldrivers"
 Requires-Dist: aiosqlite~=0.21; extra == "sqldrivers"
 Requires-Dist: asyncpg~=0.30; extra == "sqldrivers"
 Requires-Dist: apsw~=3.49; extra == "sqldrivers"
-Requires-Dist: sqlean.py~=3.47; extra == "sqldrivers"
+Requires-Dist: sqlean.py~=3.49; extra == "sqldrivers"
 Requires-Dist: duckdb~=1.2; extra == "sqldrivers"
 Provides-Extra: templates
 Requires-Dist: markupsafe~=3.0; extra == "templates"

{omlish-0.0.0.dev305.dist-info → omlish-0.0.0.dev306.dist-info}/RECORD

@@ -1,5 +1,5 @@
-omlish/.manifests.json,sha256=pjGUyLHaoWpPqRP3jz2u1fC1qoRc2lvrEcpU_Ax2tdg,8253
-omlish/__about__.py,sha256=LvSNEgc-zfbkykExJmNhbtQkXdEXRqPSJufulYnCjfw,3478
+omlish/.manifests.json,sha256=orgsRvtpHu8tdhaCvlP9v3P495OJopYYiHKjK68WtWg,8587
+omlish/__about__.py,sha256=GhIrDhTYihc0evLBX7furXS9SiYupCmrYNe-MrlOL0w,3478
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/c3.py,sha256=rer-TPOFDU6fYq_AWio_AmA-ckZ8JDY5shIzQ_yXfzA,8414
 omlish/cached.py,sha256=MLap_p0rdGoDIMVhXVHm1tsbcWobJF0OanoodV03Ju8,542
@@ -319,6 +319,11 @@ omlish/formats/props.py,sha256=auCv-Jx79KGlWfyG1-Qo0ou-Ex0W_mF3r_lDFdsVkWI,18920
 omlish/formats/repr.py,sha256=kYrNs4o-ji8nOdp6u_L3aMgBMWN1ZAZJSAWgQQfStSQ,414
 omlish/formats/xml.py,sha256=VJfqHR60dhAtjeG8WXFMozFqesTBSGvv264d67eDFXc,3514
 omlish/formats/yaml.py,sha256=jGPQlTE0vSV-p0O7TJRNlf6o1uq4gx8PrHZe1ApJ_o8,7386
+omlish/formats/edn/LICENSE,sha256=EUHM_e21AO5QuuMYXhDE81wmeBxbxeEk_i8oToZhiJo,1078
+omlish/formats/edn/__init__.py,sha256=JXHN8RlPAl-l2OnOQOQgYO8-f2zrYy-bGS2uaHiD9x0,183
+omlish/formats/edn/codec.py,sha256=k6-Ra3P3Rlv6JA69-jPLI4nCe5XVes_QJbcsj5DYzMM,454
+omlish/formats/edn/parsing.py,sha256=EtpFdeU1DPAh9pvPjEQSBwZJ9OESeonRkUFQdjmIh2Y,11212
+omlish/formats/edn/values.py,sha256=m2mDkX0BP63-e81cBbZnB-S5zPzc-J-tYrFzycqL7AI,3488
 omlish/formats/ini/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/formats/ini/codec.py,sha256=omuFg0kiDksv8rRlWd_v32ebzEcKlgmiPgGID3bRi2M,631
 omlish/formats/ini/sections.py,sha256=7wYyZdVTQbMPFpjQEACKJfAEPzUBrogINsrvFgxJoZ0,1015
@@ -847,9 +852,9 @@ omlish/typedvalues/holder.py,sha256=ZTnHiw-K38ciOBLEdwgrltr7Xp8jjEs_0Lp69DH-G-o,
 omlish/typedvalues/marshal.py,sha256=hWHRLcrGav7lvXJDtb9bNI0ickl4SKPQ6F4BbTpqw3A,4219
 omlish/typedvalues/reflect.py,sha256=Ih1YgU-srUjsvBn_P7C66f73_VCvcwqE3ffeBnZBgt4,674
 omlish/typedvalues/values.py,sha256=ym46I-q2QJ_6l4UlERqv3yj87R-kp8nCKMRph0xQ3UA,1307
-omlish-0.0.0.dev305.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev305.dist-info/METADATA,sha256=xv6KDihpZe0TCjJOQAtfs6Yld4oOHnwCwhVuHNkBYR4,4416
-omlish-0.0.0.dev305.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
-omlish-0.0.0.dev305.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev305.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev305.dist-info/RECORD,,
+omlish-0.0.0.dev306.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev306.dist-info/METADATA,sha256=GvMQ6j9pDWhBIlo-FffGTPzRwn6QSfgLdBRQ62RIshY,4416
+omlish-0.0.0.dev306.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
+omlish-0.0.0.dev306.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev306.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev306.dist-info/RECORD,,