scmrepo 3.0.0__py3-none-any.whl → 3.2.0__py3-none-any.whl

scmrepo/git/backend/dulwich/__init__.py

@@ -842,7 +842,7 @@ class DulwichBackend(BaseGitBackend):  # pylint:disable=abstract-method
             if revision and revision not in rev_mapping:
                 rev_mapping[revision] = ref
         for rev in revs:
-            results[rev] = rev_mapping.get(rev, None)
+            results[rev] = rev_mapping.get(rev)
         return results
 
     def diff(self, rev_a: str, rev_b: str, binary=False) -> str:
@@ -978,3 +978,16 @@ def _parse_identity(identity: str) -> tuple[str, str]:
     if not m:
         raise SCMError("Could not parse tagger identity '{identity}'")
     return m.group("name"), m.group("email")
+
+
+def ls_remote(url: str) -> dict[str, str]:
+    from dulwich import porcelain
+    from dulwich.client import HTTPUnauthorized
+
+    try:
+        refs = porcelain.ls_remote(url)
+        return {os.fsdecode(ref): sha.decode("ascii") for ref, sha in refs.items()}
+    except HTTPUnauthorized as exc:
+        raise AuthError(url) from exc
+    except Exception as exc:  # noqa: BLE001
+        raise InvalidRemote(url) from exc

scmrepo/git/lfs/client.py

@@ -1,17 +1,22 @@
+import json
 import logging
-from collections.abc import Iterable
-from contextlib import AbstractContextManager
+import os
+import re
+import shutil
+from abc import abstractmethod
+from collections.abc import Iterable, Iterator
+from contextlib import AbstractContextManager, contextmanager, suppress
+from tempfile import NamedTemporaryFile
 from typing import TYPE_CHECKING, Any, Optional
 
 import aiohttp
-from dvc_http import HTTPFileSystem
-from dvc_objects.executors import batch_coros
-from dvc_objects.fs import localfs
-from dvc_objects.fs.utils import as_atomic
-from fsspec.asyn import sync_wrapper
+from aiohttp_retry import ExponentialRetry, RetryClient
+from fsspec.asyn import _run_coros_in_chunks, sync_wrapper
 from fsspec.callbacks import DEFAULT_CALLBACK
+from fsspec.implementations.http import HTTPFileSystem
 from funcy import cached_property
 
+from scmrepo.git.backend.dulwich import _get_ssh_vendor
 from scmrepo.git.credentials import Credential, CredentialNotFoundError
 
 from .exceptions import LFSError
@@ -25,68 +30,69 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
-# pylint: disable=abstract-method
-class _LFSFileSystem(HTTPFileSystem):
-    def _prepare_credentials(self, **config):
-        return {}
-
-
 class LFSClient(AbstractContextManager):
     """Naive read-only LFS HTTP client."""
 
     JSON_CONTENT_TYPE = "application/vnd.git-lfs+json"
 
-    def __init__(
-        self,
-        url: str,
-        git_url: Optional[str] = None,
-        headers: Optional[dict[str, str]] = None,
-    ):
+    _REQUEST_TIMEOUT = 60
+    _SESSION_RETRIES = 5
+    _SESSION_BACKOFF_FACTOR = 0.1
+
+    def __init__(self, url: str):
         """
         Args:
             url: LFS server URL.
         """
         self.url = url
-        self.git_url = git_url
-        self.headers: dict[str, str] = headers or {}
 
     def __exit__(self, *args, **kwargs):
         self.close()
 
     @cached_property
-    def fs(self) -> "_LFSFileSystem":
-        return _LFSFileSystem()
+    def _fs(self) -> HTTPFileSystem:
+        async def get_client(**kwargs):
+            return RetryClient(
+                connector=aiohttp.TCPConnector(
+                    # Force cleanup of closed SSL transports.
+                    # See https://github.com/iterative/dvc/issues/7414
+                    enable_cleanup_closed=True,
+                ),
+                timeout=aiohttp.ClientTimeout(
+                    total=None,
+                    connect=self._REQUEST_TIMEOUT,
+                    sock_connect=self._REQUEST_TIMEOUT,
+                    sock_read=self._REQUEST_TIMEOUT,
+                ),
+                retry_options=ExponentialRetry(
+                    attempts=self._SESSION_RETRIES,
+                    factor=self._SESSION_BACKOFF_FACTOR,
+                    max_timeout=self._REQUEST_TIMEOUT,
+                    exceptions={aiohttp.ClientError},
+                ),
+                **kwargs,
+            )
 
-    @property
-    def httpfs(self) -> "HTTPFileSystem":
-        return self.fs.fs
+        return HTTPFileSystem(get_client=get_client)
 
     @property
     def loop(self):
-        return self.httpfs.loop
+        return self._fs.loop
 
     @classmethod
     def from_git_url(cls, git_url: str) -> "LFSClient":
-        if git_url.endswith(".git"):
-            url = f"{git_url}/info/lfs"
-        else:
-            url = f"{git_url}.git/info/lfs"
-        return cls(url, git_url=git_url)
+        if git_url.startswith(("ssh://", "git@")):
+            return _SSHLFSClient.from_git_url(git_url)
+        if git_url.startswith("https://"):
+            return _HTTPLFSClient.from_git_url(git_url)
+        raise NotImplementedError(f"Unsupported Git URL: {git_url}")
 
     def close(self):
         pass
 
-    def _get_auth(self) -> Optional[aiohttp.BasicAuth]:
-        try:
-            creds = Credential(url=self.git_url).fill()
-            if creds.username and creds.password:
-                return aiohttp.BasicAuth(creds.username, creds.password)
-        except CredentialNotFoundError:
-            pass
-        return None
-
-    async def _set_session(self) -> aiohttp.ClientSession:
-        return await self.fs.fs.set_session()
+    @abstractmethod
+    def _get_auth_header(self, *, upload: bool) -> dict:
+        ...
 
     async def _batch_request(
         self,
@@ -105,10 +111,11 @@ class LFSClient(AbstractContextManager):
         }
         if ref:
             body["ref"] = [{"name": ref}]
-        session = await self._set_session()
-        headers = dict(self.headers)
-        headers["Accept"] = self.JSON_CONTENT_TYPE
-        headers["Content-Type"] = self.JSON_CONTENT_TYPE
+        session = await self._fs.set_session()
+        headers = {
+            "Accept": self.JSON_CONTENT_TYPE,
+            "Content-Type": self.JSON_CONTENT_TYPE,
+        }
         try:
             async with session.post(
                 url,
@@ -120,13 +127,12 @@ class LFSClient(AbstractContextManager):
         except aiohttp.ClientResponseError as exc:
             if exc.status != 401:
                 raise
-            auth = self._get_auth()
-            if auth is None:
+            auth_header = self._get_auth_header(upload=upload)
+            if not auth_header:
                 raise
             async with session.post(
                 url,
-                auth=auth,
-                headers=headers,
+                headers={**headers, **auth_header},
                 json=body,
                 raise_for_status=True,
             ) as resp:
@@ -138,14 +144,15 @@ class LFSClient(AbstractContextManager):
         storage: "LFSStorage",
         objects: Iterable[Pointer],
         callback: "Callback" = DEFAULT_CALLBACK,
+        batch_size: Optional[int] = None,
         **kwargs,
     ):
         async def _get_one(from_path: str, to_path: str, **kwargs):
-            with as_atomic(localfs, to_path, create_parents=True) as tmp_file:
+            with _as_atomic(to_path, create_parents=True) as tmp_file:
                 with callback.branched(from_path, tmp_file) as child:
-                    await self.httpfs._get_file(
+                    await self._fs._get_file(
                         from_path, tmp_file, callback=child, **kwargs
-                    )  # pylint: disable=protected-access
+                    )
                     callback.relative_update()
 
         resp_data = await self._batch_request(objects, **kwargs)
@@ -162,10 +169,107 @@ class LFSClient(AbstractContextManager):
             headers = download.get("header", {})
             to_path = storage.oid_to_path(obj.oid)
             coros.append(_get_one(url, to_path, headers=headers))
-        for result in await batch_coros(
-            coros, batch_size=self.fs.jobs, return_exceptions=True
+        for result in await _run_coros_in_chunks(
+            coros, batch_size=batch_size, return_exceptions=True
         ):
             if isinstance(result, BaseException):
                 raise result
 
     download = sync_wrapper(_download)
+
+
+class _HTTPLFSClient(LFSClient):
+    def __init__(self, url: str, git_url: str):
+        """
+        Args:
+            url: LFS server URL.
+            git_url: Git HTTP URL.
+        """
+        super().__init__(url)
+        self.git_url = git_url
+
+    @classmethod
+    def from_git_url(cls, git_url: str) -> "_HTTPLFSClient":
+        if git_url.endswith(".git"):
+            url = f"{git_url}/info/lfs"
+        else:
+            url = f"{git_url}.git/info/lfs"
+        return cls(url, git_url=git_url)
+
+    def _get_auth_header(self, *, upload: bool) -> dict:
+        try:
+            creds = Credential(url=self.git_url).fill()
+            if creds.username and creds.password:
+                return {
+                    aiohttp.hdrs.AUTHORIZATION: aiohttp.BasicAuth(
+                        creds.username, creds.password
+                    ).encode()
+                }
+        except CredentialNotFoundError:
+            pass
+        return {}
+
+
+class _SSHLFSClient(LFSClient):
+    _URL_PATTERN = re.compile(
+        r"(?:ssh://)?git@(?P<host>\S+?)(?::(?P<port>\d+))?(?:[:/])(?P<path>\S+?)\.git"
+    )
+
+    def __init__(self, url: str, host: str, port: int, path: str):
+        """
+        Args:
+            url: LFS server URL.
+            host: Git SSH server host.
+            port: Git SSH server port.
+            path: Git project path.
+        """
+        super().__init__(url)
+        self.host = host
+        self.port = port
+        self.path = path
+        self._ssh = _get_ssh_vendor()
+
+    @classmethod
+    def from_git_url(cls, git_url: str) -> "_SSHLFSClient":
+        result = cls._URL_PATTERN.match(git_url)
+        if not result:
+            raise ValueError(f"Invalid Git SSH URL: {git_url}")
+        host, port, path = result.group("host", "port", "path")
+        url = f"https://{host}/{path}.git/info/lfs"
+        return cls(url, host, int(port or 22), path)
+
+    def _get_auth_header(self, *, upload: bool) -> dict:
+        return self._git_lfs_authenticate(
+            self.host, self.port, f"{self.path}.git", upload=upload
+        ).get("header", {})
+
+    def _git_lfs_authenticate(
+        self, host: str, port: int, path: str, *, upload: bool = False
+    ) -> dict:
+        action = "upload" if upload else "download"
+        return json.loads(
+            self._ssh.run_command(
+                command=f"git-lfs-authenticate {path} {action}",
+                host=host,
+                port=port,
+                username="git",
+            ).read()
+        )
+
+
+@contextmanager
+def _as_atomic(to_info: str, create_parents: bool = False) -> Iterator[str]:
+    parent = os.path.dirname(to_info)
+    if create_parents:
+        os.makedirs(parent, exist_ok=True)
+
+    tmp_file = NamedTemporaryFile(dir=parent, delete=False)
+    tmp_file.close()
+    try:
+        yield tmp_file.name
+    except BaseException:
+        with suppress(FileNotFoundError):
+            os.unlink(tmp_file.name)
+        raise
+    else:
+        shutil.move(tmp_file.name, to_info)

scmrepo/git/lfs/progress.py

@@ -1,11 +1,114 @@
-from typing import BinaryIO, Callable, Optional, Union
+import logging
+import sys
+from typing import Any, BinaryIO, Callable, ClassVar, Optional, Union
 
-from dvc_objects.fs.callbacks import TqdmCallback
-from fsspec.callbacks import DEFAULT_CALLBACK, Callback
+from fsspec.callbacks import DEFAULT_CALLBACK, Callback, TqdmCallback
+from tqdm import tqdm
 
 from scmrepo.progress import GitProgressEvent
 
 
+class _Tqdm(tqdm):
+    """
+    maximum-compatibility tqdm-based progressbars
+    """
+
+    BAR_FMT_DEFAULT = (
+        "{percentage:3.0f}% {desc}|{bar}|"
+        "{postfix[info]}{n_fmt}/{total_fmt}"
+        " [{elapsed}<{remaining}, {rate_fmt:>11}]"
+    )
+    # nested bars should have fixed bar widths to align nicely
+    BAR_FMT_DEFAULT_NESTED = (
+        "{percentage:3.0f}%|{bar:10}|{desc:{ncols_desc}.{ncols_desc}}"
+        "{postfix[info]}{n_fmt}/{total_fmt}"
+        " [{elapsed}<{remaining}, {rate_fmt:>11}]"
+    )
+    BAR_FMT_NOTOTAL = "{desc}{bar:b}|{postfix[info]}{n_fmt} [{elapsed}, {rate_fmt:>11}]"
+    BYTES_DEFAULTS: ClassVar[dict[str, Any]] = {
+        "unit": "B",
+        "unit_scale": True,
+        "unit_divisor": 1024,
+        "miniters": 1,
+    }
+
+    def __init__(  # noqa: PLR0913
+        self,
+        iterable=None,
+        disable=None,
+        level=logging.ERROR,
+        desc=None,
+        leave=False,
+        bar_format=None,
+        bytes=False,  # noqa: A002
+        file=None,
+        total=None,
+        postfix=None,
+        **kwargs,
+    ):
+        kwargs = kwargs.copy()
+        if bytes:
+            kwargs = {**self.BYTES_DEFAULTS, **kwargs}
+        else:
+            kwargs.setdefault("unit_scale", total > 999 if total else True)
+        if file is None:
+            file = sys.stderr
+        super().__init__(
+            iterable=iterable,
+            disable=disable,
+            leave=leave,
+            desc=desc,
+            bar_format="!",
+            lock_args=(False,),
+            total=total,
+            **kwargs,
+        )
+        self.postfix = postfix or {"info": ""}
+        if bar_format is None:
+            if self.__len__():
+                self.bar_format = (
+                    self.BAR_FMT_DEFAULT_NESTED if self.pos else self.BAR_FMT_DEFAULT
+                )
+            else:
+                self.bar_format = self.BAR_FMT_NOTOTAL
+        else:
+            self.bar_format = bar_format
+        self.refresh()
+
+    def update_to(self, current, total=None):
+        if total:
+            self.total = total
+        self.update(current - self.n)
+
+    def close(self):
+        self.postfix["info"] = ""
+        # remove ETA (either unknown or zero); remove completed bar
+        self.bar_format = self.bar_format.replace("<{remaining}", "").replace(
+            "|{bar:10}|", " "
+        )
+        super().close()
+
+    @property
+    def format_dict(self):
+        """inject `ncols_desc` to fill the display width (`ncols`)"""
+        d = super().format_dict
+        ncols = d["ncols"] or 80
+        # assumes `bar_format` has max one of ("ncols_desc" & "ncols_info")
+
+        meter = self.format_meter(  # type: ignore[call-arg]
+            ncols_desc=1, ncols_info=1, **d
+        )
+        ncols_left = ncols - len(meter) + 1
+        ncols_left = max(ncols_left, 0)
+        if ncols_left:
+            d["ncols_desc"] = d["ncols_info"] = ncols_left
+        else:
+            # work-around for zero-width description
+            d["ncols_desc"] = d["ncols_info"] = 1
+            d["prefix"] = ""
+        return d
+
+
 class LFSCallback(Callback):
     """Callback subclass to generate Git/LFS style progress."""
 
@@ -37,7 +140,11 @@ class LFSCallback(Callback):
     def branched(self, path_1: Union[str, BinaryIO], path_2: str, **kwargs):
         if self.git_progress:
             return TqdmCallback(
-                bytes=True, desc=path_1 if isinstance(path_1, str) else path_2
+                tqdm_kwargs={
+                    "desc": path_1 if isinstance(path_1, str) else path_2,
+                    "bytes": True,
+                },
+                tqdm_cls=_Tqdm,
             )
         return DEFAULT_CALLBACK
 

scmrepo/git/lfs/smudge.py

@@ -11,7 +11,10 @@ logger = logging.getLogger(__name__)
 
 
 def smudge(
-    storage: "LFSStorage", fobj: BinaryIO, url: Optional[str] = None
+    storage: "LFSStorage",
+    fobj: BinaryIO,
+    url: Optional[str] = None,
+    batch_size: Optional[int] = None,
 ) -> BinaryIO:
     """Wrap the specified binary IO stream and run LFS smudge if necessary."""
     reader = io.BufferedReader(fobj)  # type: ignore[arg-type]

scmrepo/git/lfs/storage.py

@@ -20,13 +20,14 @@ class LFSStorage:
         url: str,
         objects: Collection[Pointer],
         progress: Optional[Callable[["GitProgressEvent"], None]] = None,
+        batch_size: Optional[int] = None,
     ):
         from .client import LFSClient
 
         with LFSCallback.as_lfs_callback(progress) as cb:
             cb.set_size(len(objects))
             with LFSClient.from_git_url(url) as client:
-                client.download(self, objects, callback=cb)
+                client.download(self, objects, callback=cb, batch_size=batch_size)
 
     def oid_to_path(self, oid: str):
         return os.path.join(self.path, "objects", oid[0:2], oid[2:4], oid)
@@ -40,6 +41,7 @@ class LFSStorage:
         self,
         obj: Union[Pointer, str],
         fetch_url: Optional[str] = None,
+        batch_size: Optional[int] = None,
         **kwargs,
     ) -> BinaryIO:
         oid = obj if isinstance(obj, str) else obj.oid
@@ -50,7 +52,7 @@ class LFSStorage:
             if not fetch_url or not isinstance(obj, Pointer):
                 raise
         try:
-            self.fetch(fetch_url, [obj])
+            self.fetch(fetch_url, [obj], batch_size=batch_size)
         except BaseException as exc:  # noqa: BLE001
             raise FileNotFoundError(
                 errno.ENOENT, os.strerror(errno.ENOENT), path

{scmrepo-3.0.0.dist-info → scmrepo-3.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: scmrepo
-Version: 3.0.0
+Version: 3.2.0
 Summary: scmrepo
 Author-email: Iterative <support@dvc.org>
 License: Apache-2.0
@@ -19,13 +19,12 @@ Requires-Dist: gitpython >3
 Requires-Dist: dulwich >=0.21.6
 Requires-Dist: pygit2 >=1.14.0
 Requires-Dist: pygtrie >=2.3.2
-Requires-Dist: fsspec >=2024.2.0
+Requires-Dist: fsspec[tqdm] >=2024.2.0
 Requires-Dist: pathspec >=0.9.0
 Requires-Dist: asyncssh <3,>=2.13.1
 Requires-Dist: funcy >=1.14
-Requires-Dist: shortuuid >=0.5.0
-Requires-Dist: dvc-objects <5,>=4
-Requires-Dist: dvc-http >=2.29.0
+Requires-Dist: aiohttp-retry >=2.5.0
+Requires-Dist: tqdm
 Provides-Extra: dev
 Requires-Dist: scmrepo[tests] ; extra == 'dev'
 Provides-Extra: tests
@@ -41,6 +40,7 @@ Requires-Dist: paramiko ==3.3.1 ; extra == 'tests'
 Requires-Dist: types-certifi ==2021.10.8.3 ; extra == 'tests'
 Requires-Dist: types-mock ==5.1.0.2 ; extra == 'tests'
 Requires-Dist: types-paramiko ==3.4.0.20240120 ; extra == 'tests'
+Requires-Dist: types-tqdm ; extra == 'tests'
 Requires-Dist: pytest-docker ==2.2.0 ; (python_version < "3.10" and implementation_name != "pypy") and extra == 'tests'
 
 scmrepo

{scmrepo-3.0.0.dist-info → scmrepo-3.2.0.dist-info}/RECORD

@@ -15,23 +15,23 @@ scmrepo/git/stash.py,sha256=rnZDeOsO9P-k2e7ulCLUmZKSxSCxaRKl3XJlh97F084,2801
 scmrepo/git/backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 scmrepo/git/backend/base.py,sha256=acxuSQ0Z-UGNkGraCdLQxBxDHbTdYWi-FzXtwdb-1O8,13535
 scmrepo/git/backend/gitpython.py,sha256=6L47iX1SmqfM04_Ghwd_DEHegOKewCLu-5MTkBZO_Zo,25312
-scmrepo/git/backend/dulwich/__init__.py,sha256=aQeuLqdprJcxnk8Jkp4mlLXkLRzqMnUwiuA3wjf3_dA,34366
+scmrepo/git/backend/dulwich/__init__.py,sha256=oEajaQDbmVs5Sl90tM4F8rwdvPZagXbgx6aAAL-jvKg,34782
 scmrepo/git/backend/dulwich/asyncssh_vendor.py,sha256=OuZ_bWe5-LiZCIMwBRaX_uj03oEcrRgr1uf9i2Xv4Fk,11497
 scmrepo/git/backend/dulwich/client.py,sha256=bcDroljSvNz6s5WWv9UVvZHKkOJOVTK_zU7YCq62TN4,2360
 scmrepo/git/backend/pygit2/__init__.py,sha256=tapIRAh--nzGUcVGijaMSal2ZPscab9c1mHdqiUIxBU,37004
 scmrepo/git/backend/pygit2/callbacks.py,sha256=Ky4YmUPhv9xjU_44ypBYIcaVHJixzaGb6t9HIeUmBP4,2751
 scmrepo/git/backend/pygit2/filter.py,sha256=2NlWfQ7soXN1H7Es6-LctE74hpj3QKQTlYqXRH83VpM,2128
 scmrepo/git/lfs/__init__.py,sha256=at5blRIKnKpg_g5dLRDsGWBFi6SbucRlF_DX6aAkGtE,257
-scmrepo/git/lfs/client.py,sha256=6lqipxEflbmrE3HZSj73bA7DDZxHV27F7ICqLXKP998,5396
+scmrepo/git/lfs/client.py,sha256=I3HX3X3-2ZR3wetb6h19bGcV5rx-Wp2zLwECc-mlKhs,8926
 scmrepo/git/lfs/exceptions.py,sha256=cLlImmPXWJJUl44S4xcRBa2T9wYRkWTaKQGwJylwOhA,77
 scmrepo/git/lfs/fetch.py,sha256=ADNpskbDrvMI7ru4AiOf_c1gfw8TQ7Wct0EiN2Pq-qc,4683
 scmrepo/git/lfs/object.py,sha256=rAYY_z9EYoHPfbpF1QHwL7ecYgaETPyCl-zBx0E1oIQ,337
 scmrepo/git/lfs/pointer.py,sha256=BcVbtjoOUG9cEzyJSJDeweqehGZvq43P6NNLDYUGYEI,3181
-scmrepo/git/lfs/progress.py,sha256=GeAf5dUBVGUxY6bU3s9bD6fQlK9ttwCbOpW_THCJTmg,1532
-scmrepo/git/lfs/smudge.py,sha256=sMSatXCTHZ5cAo-gaE_6KXwCHlXGqzkF0dVgIbPwTJU,1563
-scmrepo/git/lfs/storage.py,sha256=FmdltddhyRg4jrCc1PaiC049_m8Ya9ELMikb-iOuvgw,2241
-scmrepo-3.0.0.dist-info/LICENSE,sha256=-1jhbPjoIVHR0cEgahL4Zhct75Ff4MzYCR_jOaJDPq8,11340
-scmrepo-3.0.0.dist-info/METADATA,sha256=d-N3U_p8xga7dN_6Urv5TUSiEi0cnLrp3tIzlJjGTxY,4833
-scmrepo-3.0.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-scmrepo-3.0.0.dist-info/top_level.txt,sha256=iunjod6w3GogERsAYfLRupnANXnqzX3jbIfbeIQG5cc,8
-scmrepo-3.0.0.dist-info/RECORD,,
+scmrepo/git/lfs/progress.py,sha256=ELlBs2SeXhAcnPDN23w3FTeBRgB9RGqBD2CFMS6n9Xs,4750
+scmrepo/git/lfs/smudge.py,sha256=1O_fznptWo4CKXqcJgUoWP6cgWWhvGAZ3d87kasG3cQ,1610
+scmrepo/git/lfs/storage.py,sha256=x31GQRtrZH1SBoLc_m_IaLmR-mUBw_VC01HVkWgwHvI,2371
+scmrepo-3.2.0.dist-info/LICENSE,sha256=-1jhbPjoIVHR0cEgahL4Zhct75Ff4MzYCR_jOaJDPq8,11340
+scmrepo-3.2.0.dist-info/METADATA,sha256=-sK4txnW8FAqOTeww2mbq9HMlUp_1dKSdpM3a6i3jPI,4841
+scmrepo-3.2.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+scmrepo-3.2.0.dist-info/top_level.txt,sha256=iunjod6w3GogERsAYfLRupnANXnqzX3jbIfbeIQG5cc,8
+scmrepo-3.2.0.dist-info/RECORD,,