omdev 0.0.0.dev416__py3-none-any.whl → 0.0.0.dev500__py3-none-any.whl

omdev/manifests/building.py

@@ -39,7 +39,7 @@ from omlish.lite.cached import cached_nullary
 from omlish.lite.check import check
 from omlish.lite.imports import import_attr
 from omlish.lite.json import json_dumps_pretty
-from omlish.lite.logs import log
+from omlish.logs.modules import get_module_logger
 from omlish.manifests.base import ModAttrManifest
 from omlish.manifests.globals import GlobalManifestLoader
 from omlish.manifests.types import Manifest
@@ -53,6 +53,9 @@ T = ta.TypeVar('T')
 ManifestDumperTarget = ta.Union['InlineManifestDumperTarget', 'AttrManifestDumperTarget']  # ta.TypeAlias
 
 
+log = get_module_logger(globals())  # noqa
+
+
 ##
 
 
@@ -407,7 +410,7 @@ class ManifestBuilder:
         ])))
 
         if write:
-            with open(os.path.join(pkg_dir, '.manifests.json'), 'w') as f:  # noqa
+            with open(os.path.join(pkg_dir, '.omlish-manifests.json'), 'w') as f:  # noqa
                 f.write(json_dumps_pretty([dc.asdict(m) for m in manifests]))
                 f.write('\n')
 
@@ -425,7 +428,7 @@ def check_package_manifests(
     if not os.path.isdir(pkg_dir) or not os.path.isfile(os.path.join(pkg_dir, '__init__.py')):
         raise Exception(pkg_dir)
 
-    manifests_file = os.path.join(pkg_dir, '.manifests.json')
+    manifests_file = os.path.join(pkg_dir, '.omlish-manifests.json')
     if not os.path.isfile(manifests_file):
         raise Exception(f'No manifests file: {manifests_file}')
 

omdev/manifests/main.py

@@ -5,7 +5,7 @@ import multiprocessing as mp
 import os.path
 
 from omlish.lite.json import json_dumps_pretty
-from omlish.logs.standard import configure_standard_logging
+from omlish.logs.std.standard import configure_standard_logging
 
 from .building import ManifestBuilder
 from .building import check_package_manifests

omdev/markdown/incparse.py

@@ -0,0 +1,116 @@
+import dataclasses as dc
+import typing as ta
+
+from omlish import lang
+
+
+with lang.auto_proxy_import(globals()):
+    import markdown_it as md
+    import markdown_it.token  # noqa
+
+
+##
+
+
+class IncrementalMarkdownParser:
+    def __init__(
+            self,
+            *,
+            parser: ta.Optional['md.MarkdownIt'] = None,
+    ) -> None:
+        super().__init__()
+
+        if parser is None:
+            parser = md.MarkdownIt()
+        self._parser = parser
+
+        self._stable_tokens: list[md.token.Token] = []
+        self._buffer = ''
+        self._num_stable_lines = 0  # Number of lines in stable tokens
+
+    class FeedOutput(ta.NamedTuple):
+        stable: ta.Sequence['md.token.Token']
+        new_stable: ta.Sequence['md.token.Token']
+        unstable: ta.Sequence['md.token.Token']
+
+    def feed2(self, chunk: str) -> FeedOutput:
+        self._buffer += chunk
+
+        # Parse the current buffer
+        new_tokens = self._parser.parse(self._buffer)
+
+        # Adjust ALL tokens to account for stable lines from previous parses (new_tokens have line numbers relative to
+        # current buffer)
+        adjusted_tokens = self._adjust_token_line_numbers(new_tokens, self._num_stable_lines)
+
+        # Find stable tokens (all but the last parent and its children)
+        stable_count = self._find_stable_token_count(adjusted_tokens)
+
+        newly_stable: ta.Sequence[md.token.Token]
+        if stable_count > 0:
+            # Extract newly stable tokens (already have adjusted line numbers)
+            newly_stable = adjusted_tokens[:stable_count]
+
+            # Calculate how many lines these stable tokens cover
+            max_line = 0
+            for token in newly_stable:
+                if token.map:
+                    max_line = max(max_line, token.map[1])
+
+            # Update buffer to only contain unstable content
+            if max_line > self._num_stable_lines:
+                # max_line is absolute, num_stable_lines is the current buffer offset
+                lines_to_remove = max_line - self._num_stable_lines
+                lines = self._buffer.split('\n')
+                self._buffer = '\n'.join(lines[lines_to_remove:])
+
+                # Store newly stable tokens (with adjusted line numbers)
+                self._stable_tokens.extend(newly_stable)
+                self._num_stable_lines = max_line
+
+        else:
+            newly_stable = ()
+
+        return IncrementalMarkdownParser.FeedOutput(
+            stable=self._stable_tokens,
+            new_stable=newly_stable,
+            unstable=adjusted_tokens[stable_count:],
+        )
+
+    def feed(self, chunk: str) -> list['md.token.Token']:
+        out = self.feed2(chunk)
+        return [*out.stable, *out.unstable]
+
+    def _find_stable_token_count(self, tokens: list['md.token.Token']) -> int:
+        if not tokens:
+            return 0
+
+        # Find indices of all parent-level tokens (nesting = 0)
+        parent_indices = []
+        for i, token in enumerate(tokens):
+            if token.nesting in (1, 0) and token.level == 0:
+                parent_indices.append(i)
+
+        if len(parent_indices) < 2:
+            # Need at least 2 parent tokens to have stable content
+            return 0
+
+        # The last parent and everything after it is unstable. Everything before the second-to-last parent is stable.
+        return parent_indices[-2]
+
+    def _adjust_token_line_numbers(
+            self,
+            tokens: list['md.token.Token'],
+            line_offset: int,
+    ) -> list['md.token.Token']:
+        adjusted = []
+        for token in tokens:
+            if token.map:
+                token = dc.replace(
+                    token,
+                    map=[token.map[0] + line_offset, token.map[1] + line_offset],
+                )
+
+            adjusted.append(token)
+
+        return adjusted

omdev/markdown/tokens.py

@@ -0,0 +1,51 @@
+# ruff: noqa: TC002
+import typing as ta
+
+from omlish import lang
+
+
+with lang.auto_proxy_import(globals()):
+    import markdown_it as md
+    import markdown_it.token  # noqa
+
+
+##
+
+
+def token_repr(t: 'md.token.Token') -> str:
+    return ''.join([
+        'Token(',
+        f'type={t.type!r}',
+        *([f', tag={t.tag!r}'] if t.tag else []),
+        *([f', nesting={t.nesting!r}'] if t.nesting else []),
+        *([f', attrs={t.attrs!r}'] if t.attrs else []),
+        *([f', map={t.map!r}'] if t.map else []),
+        *([f', level={t.level!r}'] if t.level else []),
+        *([f', children={t.children!r}'] if t.children else []),
+        *([f', content={t.content!r}'] if t.content else []),
+        *([f', markup={t.markup!r}'] if t.markup else []),
+        *([f', info={t.info!r}'] if t.info else []),
+        *([f', meta={t.meta!r}'] if t.meta else []),
+        *([f', block={t.block!r}'] if t.block else []),
+        *([f', hidden={t.hidden!r}'] if t.hidden else []),
+        ')',
+    ])
+
+
+##
+
+
+def flatten_tokens(
+        tokens: ta.Iterable['md.token.Token'],
+        *,
+        filter: ta.Callable[['md.token.Token'], bool] | None = None,  # noqa
+) -> ta.Iterable['md.token.Token']:
+    def rec(tks: ta.Iterable['md.token.Token']) -> ta.Iterator['md.token.Token']:
+        for tk in tks:
+            if tk.children and not (filter is not None and not filter(tk)):
+                yield from rec(tk.children)
+
+            else:
+                yield tk
+
+    return rec(tokens)

omdev/oci/data.py

@@ -1,10 +1,10 @@
 # ruff: noqa: UP006 UP007 UP045
 # @omlish-lite
-import abc
 import dataclasses as dc
 import enum
 import typing as ta
 
+from omlish.lite.abstract import Abstract
 from omlish.lite.check import check
 from omlish.lite.marshal import OBJ_MARSHALER_FIELD_KEY
 from omlish.lite.marshal import OBJ_MARSHALER_OMIT_IF_NONE
@@ -17,7 +17,7 @@ from .datarefs import OciDataRef
 
 
 @dc.dataclass()
-class OciDataclass(abc.ABC):  # noqa
+class OciDataclass(Abstract):
     pass
 
 

omdev/oci/datarefs.py

@@ -1,6 +1,5 @@
 # ruff: noqa: UP006 UP007 UP045
 # @omlish-lite
-import abc
 import dataclasses as dc
 import functools
 import hashlib
@@ -10,6 +9,7 @@ import shutil
 import tarfile
 import typing as ta
 
+from omlish.lite.abstract import Abstract
 from omlish.lite.cached import cached_nullary
 from omlish.lite.check import check
 
@@ -18,7 +18,7 @@ from omlish.lite.check import check
 
 
 @dc.dataclass(frozen=True)
-class OciDataRef(abc.ABC):  # noqa
+class OciDataRef(Abstract):
     pass
 
 

omdev/oci/media.py

@@ -1,9 +1,9 @@
 # ruff: noqa: UP006 UP007 UP045
 # @omlish-lite
-import abc
 import dataclasses as dc
 import typing as ta
 
+from omlish.lite.abstract import Abstract
 from omlish.lite.check import check
 from omlish.lite.marshal import OBJ_MARSHALER_FIELD_KEY
 from omlish.lite.marshal import OBJ_MARSHALER_OMIT_IF_NONE
@@ -23,7 +23,7 @@ OCI_MEDIA_FIELDS: ta.Collection[str] = frozenset([
 
 
 @dc.dataclass()
-class OciMediaDataclass(abc.ABC):  # noqa
+class OciMediaDataclass(Abstract):
     SCHEMA_VERSION: ta.ClassVar[int]
 
     @property

omdev/oci/repositories.py

@@ -5,6 +5,7 @@ import os.path
 import tarfile
 import typing as ta
 
+from omlish.lite.abstract import Abstract
 from omlish.lite.check import check
 from omlish.os.paths import is_path_in_dir
 
@@ -17,7 +18,7 @@ from .datarefs import TarFileOciDataRef
 ##
 
 
-class OciRepository(abc.ABC):
+class OciRepository(Abstract):
     @abc.abstractmethod
     def contains_blob(self, digest: str) -> bool:
         raise NotImplementedError
@@ -57,7 +58,7 @@ class OciRepository(abc.ABC):
             raise TypeError(obj)
 
 
-class FileOciRepository(OciRepository, abc.ABC):
+class FileOciRepository(OciRepository, Abstract):
     @abc.abstractmethod
     def read_file(self, path: str) -> bytes:
         raise NotImplementedError

omdev/packaging/marshal.py

@@ -8,7 +8,6 @@ import typing as ta
 from omlish import lang
 from omlish import marshal as msh
 from omlish import reflect as rfl
-from omlish.funcs import match as mfs
 
 from .requires import RequiresMarkerItem
 from .requires import RequiresMarkerList
@@ -43,12 +42,13 @@ class RequiresMarkerListMarshaler(msh.Marshaler):
         return [inner(e) for e in o]
 
 
-class RequiresMarkerListMarshalerFactory(msh.MarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: rty is MarshalRequiresMarkerList)
-    def _build(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
-        return RequiresMarkerListMarshaler(
-            ctx.make(RequiresMarkerItem),
-            ctx.make(RequiresNode),
+class RequiresMarkerListMarshalerFactory(msh.MarshalerFactory):
+    def make_marshaler(self, ctx: msh.MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
+        if rty is not MarshalRequiresMarkerList:
+            return None
+        return lambda: RequiresMarkerListMarshaler(
+            ctx.make_marshaler(RequiresMarkerItem),
+            ctx.make_marshaler(RequiresNode),
         )
 
 
@@ -56,7 +56,7 @@ class RequiresMarkerListMarshalerFactory(msh.MarshalerFactoryMatchClass):
 
 
 @lang.static_init
-def _install_standard_marshalling() -> None:
+def _install_standard_marshaling() -> None:
     requires_node_poly = msh.Polymorphism(
         RequiresNode,
         [
@@ -75,7 +75,7 @@ def _install_standard_marshalling() -> None:
         RequiresMarkerListMarshalerFactory(),
     )
 
-    msh.register_global(
+    msh.register_global_config(
         RequiresMarkerList,
         msh.ReflectOverride(MarshalRequiresMarkerList),
         identity=True,

omdev/packaging/requires.py

@@ -33,6 +33,12 @@ from omlish.lite.check import check
 from .specifiers import Specifier
 
 
+RequiresMarkerVar = ta.Union['RequiresVariable', 'RequiresValue']  # ta.TypeAlias
+
+RequiresMarkerAtom = ta.Union['RequiresMarkerItem', ta.Sequence['RequiresMarkerAtom']]  # ta.TypeAlias
+RequiresMarkerList = ta.Sequence[ta.Union['RequiresMarkerList', 'RequiresMarkerAtom', str]]  # ta.TypeAlias
+
+
 ##
 
 
@@ -229,12 +235,6 @@ class RequiresOp(RequiresNode):
         return str(self)
 
 
-RequiresMarkerVar = ta.Union['RequiresVariable', 'RequiresValue']
-
-RequiresMarkerAtom = ta.Union['RequiresMarkerItem', ta.Sequence['RequiresMarkerAtom']]
-RequiresMarkerList = ta.Sequence[ta.Union['RequiresMarkerList', 'RequiresMarkerAtom', str]]
-
-
 class RequiresMarkerItem(ta.NamedTuple):
     l: ta.Union[RequiresVariable, RequiresValue]
     op: RequiresOp

omdev/packaging/revisions.py

@@ -14,13 +14,16 @@ import zipfile
 
 from omlish.lite.cached import cached_nullary
 from omlish.lite.check import check
-from omlish.lite.logs import log
-from omlish.logs.standard import configure_standard_logging
+from omlish.logs.modules import get_module_logger
+from omlish.logs.std.standard import configure_standard_logging
 
 from ..git.revisions import get_git_revision
 from .wheelfile import WheelFile
 
 
+log = get_module_logger(globals())  # noqa
+
+
 ##
 
 

omdev/packaging/specifiers.py

@@ -1,3 +1,4 @@
+# ruff: noqa: UP006 UP007 UP045
 # @omlish-lite
 # Copyright (c) Donald Stufft and individual contributors.
 # All rights reserved.
@@ -20,8 +21,7 @@
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. This file is dual licensed under the terms of the
 # Apache License, Version 2.0, and the BSD License. See the LICENSE file in the root of this repository for complete
 # details.
-# https://github.com/pypa/packaging/blob/2c885fe91a54559e2382902dce28428ad2887be5/src/packaging/specifiers.py
-# ruff: noqa: UP006 UP007 UP045
+# https://github.com/pypa/packaging/blob/48125006684bb2d7d28c50af48a03176da45942d/src/packaging/specifiers.py
 import abc
 import itertools
 import re
@@ -31,9 +31,9 @@ from .versions import Version
 from .versions import canonicalize_version
 
 
-UnparsedVersion = ta.Union['Version', str]
+UnparsedVersion = ta.Union['Version', str]  # ta.TypeAlias
 UnparsedVersionVar = ta.TypeVar('UnparsedVersionVar', bound=UnparsedVersion)
-CallableVersionOperator = ta.Callable[['Version', str], bool]
+CallableVersionOperator = ta.Callable[['Version', str], bool]  # ta.TypeAlias
 
 
 ##
@@ -181,7 +181,7 @@ class Specifier(BaseSpecifier):
     ) -> None:
         match = self._regex.search(spec)
         if not match:
-            raise InvalidSpecifier(f"Invalid specifier: '{spec}'")
+            raise InvalidSpecifier(f'Invalid specifier: {spec!r}')
 
         self._spec: ta.Tuple[str, str] = (
             match.group('operator').strip(),
@@ -196,7 +196,7 @@ class Specifier(BaseSpecifier):
             return self._prereleases
 
         operator, version = self._spec
-        if operator in ['==', '>=', '<=', '~=', '===']:
+        if operator in ['==', '>=', '<=', '~=', '===', '>', '<']:
             if operator == '==' and version.endswith('.*'):
                 version = version[:-2]
 
@@ -322,40 +322,38 @@ class Specifier(BaseSpecifier):
         return self.contains(item)
 
     def contains(self, item: UnparsedVersion, prereleases: ta.Optional[bool] = None) -> bool:
-        if prereleases is None:
-            prereleases = self.prereleases
-
-        normalized_item = _coerce_version(item)
-
-        if normalized_item.is_prerelease and not prereleases:
-            return False
-
-        operator_callable: CallableVersionOperator = self._get_operator(self.operator)
-        return operator_callable(normalized_item, self.version)
+        return bool(list(self.filter([item], prereleases=prereleases)))
 
     def filter(
             self,
             iterable: ta.Iterable[UnparsedVersionVar],
             prereleases: ta.Optional[bool] = None,
     ) -> ta.Iterator[UnparsedVersionVar]:
-        yielded = False
-        found_prereleases = []
+        prereleases_versions = []
+        found_non_prereleases = False
+
+        include_prereleases = (
+            prereleases if prereleases is not None else self.prereleases
+        )
 
-        kw = {'prereleases': prereleases if prereleases is not None else True}
+        operator_callable = self._get_operator(self.operator)
 
         for version in iterable:
             parsed_version = _coerce_version(version)
 
-            if self.contains(parsed_version, **kw):
-                if parsed_version.is_prerelease and not (prereleases or self.prereleases):
-                    found_prereleases.append(version)
-                else:
-                    yielded = True
+            if operator_callable(parsed_version, self.version):
+                if not parsed_version.is_prerelease or include_prereleases:
+                    found_non_prereleases = True
                     yield version
+                elif prereleases is None and self._prereleases is not False:
+                    prereleases_versions.append(version)
 
-        if not yielded and found_prereleases:
-            for version in found_prereleases:
-                yield version
+        if (
+                not found_non_prereleases and
+                prereleases is None and
+                self._prereleases is not False
+        ):
+            yield from prereleases_versions
 
 
 _version_prefix_regex = re.compile(r'^([0-9]+)((?:a|b|c|rc)[0-9]+)$')
@@ -406,12 +404,15 @@ def _pad_version(left: ta.List[str], right: ta.List[str]) -> ta.Tuple[ta.List[st
 class SpecifierSet(BaseSpecifier):
     def __init__(
             self,
-            specifiers: str = '',
+            specifiers: ta.Union[str, ta.Iterable['Specifier']] = '',
             prereleases: ta.Optional[bool] = None,
     ) -> None:
-        split_specifiers = [s.strip() for s in specifiers.split(',') if s.strip()]
+        if isinstance(specifiers, str):
+            split_specifiers = [s.strip() for s in specifiers.split(',') if s.strip()]
+            self._specs = frozenset(map(Specifier, split_specifiers))
+        else:
+            self._specs = frozenset(specifiers)
 
-        self._specs = frozenset(map(Specifier, split_specifiers))
         self._prereleases = prereleases
 
     @property
@@ -422,7 +423,10 @@ class SpecifierSet(BaseSpecifier):
         if not self._specs:
             return None
 
-        return any(s.prereleases for s in self._specs)
+        if any(s.prereleases for s in self._specs):
+            return True
+
+        return None
 
     @prereleases.setter
     def prereleases(self, value: bool) -> None:
@@ -447,7 +451,7 @@ class SpecifierSet(BaseSpecifier):
         if isinstance(other, str):
             other = SpecifierSet(other)
         elif not isinstance(other, SpecifierSet):
-            return NotImplemented  # type: ignore
+            return NotImplemented
 
         specifier = SpecifierSet()
         specifier._specs = frozenset(self._specs | other._specs)
@@ -467,6 +471,7 @@ class SpecifierSet(BaseSpecifier):
         if isinstance(other, (str, Specifier)):
             other = SpecifierSet(str(other))
         elif not isinstance(other, SpecifierSet):
+
             return NotImplemented
 
         return self._specs == other._specs
@@ -489,28 +494,22 @@ class SpecifierSet(BaseSpecifier):
         if not isinstance(item, Version):
             item = Version(item)
 
-        if prereleases is None:
-            prereleases = self.prereleases
-
-        if not prereleases and item.is_prerelease:
-            return False
-
         if installed and item.is_prerelease:
-            item = Version(item.base_version)
+            prereleases = True
 
-        return all(s.contains(item, prereleases=prereleases) for s in self._specs)
+        return bool(list(self.filter([item], prereleases=prereleases)))
 
     def filter(
             self,
             iterable: ta.Iterable[UnparsedVersionVar],
             prereleases: ta.Optional[bool] = None,
     ) -> ta.Iterator[UnparsedVersionVar]:
-        if prereleases is None:
+        if prereleases is None and self.prereleases is not None:
             prereleases = self.prereleases
 
         if self._specs:
             for spec in self._specs:
-                iterable = spec.filter(iterable, prereleases=bool(prereleases))
+                iterable = spec.filter(iterable, prereleases=prereleases)
             return iter(iterable)
 
         else:

omdev/packaging/versions.py

@@ -27,13 +27,13 @@ import re
 import typing as ta
 
 
-VersionLocalType = ta.Tuple[ta.Union[int, str], ...]
+VersionLocalType = ta.Tuple[ta.Union[int, str], ...]  # ta.TypeAlias
 
-VersionCmpPrePostDevType = ta.Union['InfinityVersionType', 'NegativeInfinityVersionType', ta.Tuple[str, int]]
-_VersionCmpLocalType0 = ta.Tuple[ta.Union[ta.Tuple[int, str], ta.Tuple['NegativeInfinityVersionType', ta.Union[int, str]]], ...]  # noqa
-VersionCmpLocalType = ta.Union['NegativeInfinityVersionType', _VersionCmpLocalType0]
-VersionCmpKey = ta.Tuple[int, ta.Tuple[int, ...], VersionCmpPrePostDevType, VersionCmpPrePostDevType, VersionCmpPrePostDevType, VersionCmpLocalType]  # noqa
-VersionComparisonMethod = ta.Callable[[VersionCmpKey, VersionCmpKey], bool]
+VersionCmpPrePostDevType = ta.Union['InfinityVersionType', 'NegativeInfinityVersionType', ta.Tuple[str, int]]  # ta.TypeAlias  # noqa
+_VersionCmpLocalType0 = ta.Tuple[ta.Union[ta.Tuple[int, str], ta.Tuple['NegativeInfinityVersionType', ta.Union[int, str]]], ...]  # ta.TypeAlias  # noqa
+VersionCmpLocalType = ta.Union['NegativeInfinityVersionType', _VersionCmpLocalType0]  # ta.TypeAlias
+VersionCmpKey = ta.Tuple[int, ta.Tuple[int, ...], VersionCmpPrePostDevType, VersionCmpPrePostDevType, VersionCmpPrePostDevType, VersionCmpLocalType]  # ta.TypeAlias  # noqa
+VersionComparisonMethod = ta.Callable[[VersionCmpKey, VersionCmpKey], bool]  # ta.TypeAlias
 
 
 ##
@@ -121,12 +121,12 @@ class _BaseVersion:
 
     def __lt__(self, other: '_BaseVersion') -> bool:
         if not isinstance(other, _BaseVersion):
-            return NotImplemented  # type: ignore
+            return NotImplemented
         return self._key < other._key
 
     def __le__(self, other: '_BaseVersion') -> bool:
         if not isinstance(other, _BaseVersion):
-            return NotImplemented  # type: ignore
+            return NotImplemented
         return self._key <= other._key
 
     def __eq__(self, other: object) -> bool:
@@ -136,12 +136,12 @@ class _BaseVersion:
 
     def __ge__(self, other: '_BaseVersion') -> bool:
         if not isinstance(other, _BaseVersion):
-            return NotImplemented  # type: ignore
+            return NotImplemented
         return self._key >= other._key
 
     def __gt__(self, other: '_BaseVersion') -> bool:
         if not isinstance(other, _BaseVersion):
-            return NotImplemented  # type: ignore
+            return NotImplemented
         return self._key > other._key
 
     def __ne__(self, other: object) -> bool:

omdev/packaging/wheelfile.py

@@ -1,6 +1,5 @@
-# @omlish-lite
 # ruff: noqa: UP006 UP007 UP045
-# https://github.com/pypa/wheel/blob/7bb46d7727e6e89fe56b3c78297b3af2672bbbe2/src/wheel/wheelfile.py
+# @omlish-lite
 # MIT License
 #
 # Copyright (c) 2012 Daniel Holth <dholth@fastmail.fm> and contributors
@@ -17,6 +16,7 @@
 # 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.
+# https://github.com/pypa/wheel/blob/7bb46d7727e6e89fe56b3c78297b3af2672bbbe2/src/wheel/wheelfile.py
 import base64
 import csv
 import hashlib
@@ -116,11 +116,13 @@ class WheelFile(zipfile.ZipFile):
     @staticmethod
     def _urlsafe_b64encode(data: bytes) -> bytes:
         """urlsafe_b64encode without padding"""
+
         return base64.urlsafe_b64encode(data).rstrip(b'=')
 
     @staticmethod
     def _urlsafe_b64decode(data: bytes) -> bytes:
         """urlsafe_b64decode without padding"""
+
         pad = b'=' * (4 - (len(data) & 3))
         return base64.urlsafe_b64decode(data + pad)