fluidattacks_core_git 12.0.0__py3-none-any.whl

fluidattacks_core/git/upload_repo.py

@@ -0,0 +1,338 @@
+import logging
+import math
+import tarfile
+import tempfile
+from collections.abc import AsyncGenerator, Awaitable, Callable
+from dataclasses import dataclass
+from pathlib import Path
+
+import aiofiles
+import aiohttp
+import anyio
+
+from .constants import (
+    MAX_RETRIES_PER_PART,
+    MAX_S3_PARTS,
+    MULTIPART_PART_SIZE,
+    MULTIPART_THRESHOLD,
+    UPLOAD_CONCURRENCY,
+)
+
+LOGGER = logging.getLogger(__name__)
+
+
+def _compute_part_size(file_size: int) -> int:
+    return max(MULTIPART_PART_SIZE, math.ceil(file_size / MAX_S3_PARTS))
+
+
+@dataclass
+class UploadPartResult:
+    part_number: int
+    etag: str
+
+
+@dataclass
+class PartUploadConfig:
+    file_path: Path
+    part_number: int
+    start_byte: int
+    end_byte: int
+    upload_id: str
+
+
+@dataclass
+class MultipartCallbacks:
+    initiate_upload: Callable[[], Awaitable[str | None]]
+    get_part_url: Callable[[str, int], Awaitable[str]]
+    complete_upload: Callable[[str, list[dict[str, str | int]]], Awaitable[bool]]
+    abort_upload: Callable[[str], Awaitable[None]]
+
+
+async def _create_tar_archive(
+    repo_path: Path,
+    output_path: Path,
+    archive_name: str,
+) -> bool:
+    git_dir = repo_path / ".git"
+    if not await anyio.Path(git_dir).exists():
+        LOGGER.error("Git directory not found: %s", git_dir)
+        return False
+
+    def _create() -> None:
+        with tarfile.open(output_path, "w:gz") as tar_handler:
+            tar_handler.add(str(git_dir), arcname=f"{archive_name}/.git", recursive=True)
+
+    try:
+        await anyio.to_thread.run_sync(_create)
+    except (OSError, tarfile.TarError):
+        LOGGER.exception("Failed to create tar archive: %s", output_path)
+        return False
+    return True
+
+
+async def _file_chunks(file_path: Path) -> AsyncGenerator[bytes, None]:
+    async with aiofiles.open(file_path, "rb") as f:
+        while chunk := await f.read(65536):
+            yield chunk
+
+
+async def _single_part_upload(
+    file_path: Path,
+    upload_url: str,
+) -> bool:
+    file_stat = await anyio.Path(file_path).stat()
+    file_size = file_stat.st_size
+    timeout = aiohttp.ClientTimeout(total=3600, sock_connect=30, sock_read=600)
+
+    async with (
+        aiohttp.ClientSession(timeout=timeout) as session,
+        session.put(
+            upload_url,
+            data=_file_chunks(file_path),
+            headers={
+                "Content-Type": "application/octet-stream",
+                "Content-Length": str(file_size),
+            },
+        ) as response,
+    ):
+        if response.status != 200:
+            error_text = await response.text()
+            LOGGER.error(
+                "Single-part upload failed: HTTP %s - %s",
+                response.status,
+                error_text,
+            )
+            return False
+
+    return True
+
+
+async def _do_part_upload(
+    session: aiohttp.ClientSession,
+    part_url: str,
+    chunk_data: bytes,
+) -> str | None:
+    async with session.put(
+        part_url,
+        data=chunk_data,
+        headers={
+            "Content-Type": "application/octet-stream",
+            "Content-Length": str(len(chunk_data)),
+        },
+    ) as response:
+        if response.status == 200:
+            return response.headers.get("ETag", "")
+
+        error_text = await response.text()
+        LOGGER.warning(
+            "Part upload failed: HTTP %s - %s",
+            response.status,
+            error_text,
+        )
+        return None
+
+
+async def _upload_part_with_retry(
+    config: PartUploadConfig,
+    get_part_url: Callable[[str, int], Awaitable[str]],
+) -> UploadPartResult | None:
+    part_size = config.end_byte - config.start_byte
+    timeout = aiohttp.ClientTimeout(total=600, sock_connect=30, sock_read=300)
+
+    async with aiohttp.ClientSession(timeout=timeout) as session:
+        for attempt in range(1, MAX_RETRIES_PER_PART + 1):
+            try:
+                part_url = await get_part_url(config.upload_id, config.part_number)
+                if not part_url:
+                    LOGGER.error("Failed to get presigned URL for part %s", config.part_number)
+                    continue
+
+                async with aiofiles.open(config.file_path, "rb") as f:
+                    await f.seek(config.start_byte)
+                    chunk_data = await f.read(part_size)
+
+                etag = await _do_part_upload(session, part_url, chunk_data)
+                if etag:
+                    LOGGER.info(
+                        "Part %s uploaded successfully (attempt %s)",
+                        config.part_number,
+                        attempt,
+                    )
+                    return UploadPartResult(part_number=config.part_number, etag=etag)
+
+                LOGGER.warning(
+                    "Part %s upload failed (attempt %s/%s)",
+                    config.part_number,
+                    attempt,
+                    MAX_RETRIES_PER_PART,
+                )
+
+            except (TimeoutError, aiohttp.ClientError, OSError):
+                LOGGER.exception(
+                    "Part %s upload error (attempt %s/%s)",
+                    config.part_number,
+                    attempt,
+                    MAX_RETRIES_PER_PART,
+                )
+
+            if attempt < MAX_RETRIES_PER_PART:
+                await anyio.sleep(2**attempt)
+
+    LOGGER.error(
+        "Part %s failed after %s attempts",
+        config.part_number,
+        MAX_RETRIES_PER_PART,
+    )
+    return None
+
+
+async def _initiate_with_retry(
+    initiate_upload: Callable[[], Awaitable[str | None]],
+) -> str | None:
+    for attempt in range(1, MAX_RETRIES_PER_PART + 1):
+        upload_id = await initiate_upload()
+        if upload_id:
+            return upload_id
+        LOGGER.warning(
+            "initiate_upload failed (attempt %s/%s)",
+            attempt,
+            MAX_RETRIES_PER_PART,
+        )
+        if attempt < MAX_RETRIES_PER_PART:
+            await anyio.sleep(2**attempt)
+    LOGGER.error("Failed to initiate multipart upload after %s attempts", MAX_RETRIES_PER_PART)
+    return None
+
+
+async def _complete_with_retry(
+    upload_id: str,
+    completed_parts: list[dict[str, str | int]],
+    complete_upload: Callable[[str, list[dict[str, str | int]]], Awaitable[bool]],
+) -> bool:
+    for attempt in range(1, MAX_RETRIES_PER_PART + 1):
+        if await complete_upload(upload_id, completed_parts):
+            return True
+        LOGGER.warning(
+            "complete_upload failed (attempt %s/%s)",
+            attempt,
+            MAX_RETRIES_PER_PART,
+        )
+        if attempt < MAX_RETRIES_PER_PART:
+            await anyio.sleep(2**attempt)
+    LOGGER.error("Failed to complete multipart upload after %s attempts", MAX_RETRIES_PER_PART)
+    return False
+
+
+async def _upload_all_parts(
+    file_path: Path,
+    file_size: int,
+    upload_id: str,
+    get_part_url: Callable[[str, int], Awaitable[str]],
+    part_size: int,
+) -> list[UploadPartResult] | None:
+    num_parts = (file_size + part_size - 1) // part_size
+    LOGGER.info("Starting multipart upload: %s bytes in %s parts", file_size, num_parts)
+    results: list[UploadPartResult | None] = [None] * num_parts
+    limiter = anyio.CapacityLimiter(UPLOAD_CONCURRENCY)
+
+    async def _upload_one(part_number: int) -> None:
+        start_byte = (part_number - 1) * part_size
+        end_byte = min(part_number * part_size, file_size)
+        config = PartUploadConfig(
+            file_path=file_path,
+            part_number=part_number,
+            start_byte=start_byte,
+            end_byte=end_byte,
+            upload_id=upload_id,
+        )
+        async with limiter:
+            results[part_number - 1] = await _upload_part_with_retry(config, get_part_url)
+
+    async with anyio.create_task_group() as tg:
+        for part_number in range(1, num_parts + 1):
+            tg.start_soon(_upload_one, part_number)
+
+    parts: list[UploadPartResult] = []
+    for result in results:
+        if result is None:
+            LOGGER.error("One or more parts failed to upload")
+            return None
+        parts.append(result)
+    return parts
+
+
+async def _multipart_upload(
+    file_path: Path,
+    multipart: MultipartCallbacks,
+) -> bool:
+    file_stat = await anyio.Path(file_path).stat()
+    file_size = file_stat.st_size
+    part_size = _compute_part_size(file_size)
+
+    upload_id = await _initiate_with_retry(multipart.initiate_upload)
+    if not upload_id:
+        return False
+
+    completed = False
+    try:
+        parts = await _upload_all_parts(
+            file_path, file_size, upload_id, multipart.get_part_url, part_size
+        )
+        if parts is None:
+            return False
+
+        completed_parts: list[dict[str, str | int]] = [
+            {"ETag": part.etag, "PartNumber": part.part_number} for part in parts
+        ]
+
+        if not await _complete_with_retry(upload_id, completed_parts, multipart.complete_upload):
+            return False
+
+        LOGGER.info("Multipart upload completed successfully")
+        completed = True
+        return True
+    finally:
+        if not completed:
+            await multipart.abort_upload(upload_id)
+
+
+async def upload_repo_to_s3(
+    repo_path: Path,
+    archive_name: str,
+    *,
+    upload_url: str | None = None,
+    multipart: MultipartCallbacks | None = None,
+) -> bool:
+    if not await anyio.Path(repo_path).exists():
+        LOGGER.error("Repository path does not exist: %s", repo_path)
+        return False
+
+    with tempfile.TemporaryDirectory(
+        prefix="fluidattacks_upload_",
+        ignore_cleanup_errors=True,
+    ) as temp_dir:
+        tar_path = Path(temp_dir) / f"{archive_name}.tar.gz"
+
+        if not await _create_tar_archive(repo_path, tar_path, archive_name):
+            return False
+
+        tar_stat = await anyio.Path(tar_path).stat()
+        file_size = tar_stat.st_size
+        LOGGER.info("Created archive: %s (%s bytes)", tar_path.name, file_size)
+
+        if file_size <= MULTIPART_THRESHOLD:
+            if not upload_url:
+                LOGGER.error("upload_url required for single-part upload")
+                return False
+            LOGGER.info("Using single-part upload (file size <= 5GB)")
+            return await _single_part_upload(tar_path, upload_url)
+
+        if multipart is None:
+            LOGGER.error(
+                "Multipart callbacks required for files > 5GB (file size: %s bytes)",
+                file_size,
+            )
+            return False
+
+        LOGGER.info("Using multipart upload (file size > 5GB)")
+        return await _multipart_upload(tar_path, multipart)

fluidattacks_core/git/utils.py

@@ -0,0 +1,143 @@
+import asyncio
+import base64
+from contextlib import suppress
+from urllib.parse import (
+    ParseResult,
+    quote,
+    unquote,
+    urlparse,
+)
+
+
+async def run_git(
+    *args: str,
+    env: dict[str, str] | None = None,
+    cwd: str | None = None,
+    timeout: float = 20.0,  # noqa: ASYNC109
+) -> tuple[bytes, bytes, int]:
+    proc = await asyncio.create_subprocess_exec(
+        "git",
+        *args,
+        stderr=asyncio.subprocess.PIPE,
+        stdout=asyncio.subprocess.PIPE,
+        stdin=asyncio.subprocess.DEVNULL,
+        cwd=cwd,
+        env=env,
+    )
+    try:
+        stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=timeout)
+    except asyncio.exceptions.TimeoutError:
+        with suppress(ProcessLookupError):
+            proc.kill()
+        await proc.wait()
+        raise
+
+    return stdout, stderr, proc.returncode if proc.returncode is not None else -1
+
+
+def _replace_netloc_in_url(parsed_url: ParseResult, netloc: str) -> str:
+    return parsed_url._replace(netloc=netloc).geturl()
+
+
+def _format_token_for_provider(provider: str | None, token: str, host: str) -> str:
+    if provider == "BITBUCKET":
+        return f"x-token-auth:{token}@{host}"
+    if provider:
+        return f"oauth2:{token}@{host}"
+    return f"{token}@{host}"
+
+
+def _format_token(
+    parsed_url: ParseResult,
+    token: str,
+    host: str,
+    provider: str | None,
+) -> str:
+    formatted_token = _format_token_for_provider(provider, token, host)
+    return _replace_netloc_in_url(parsed_url, formatted_token)
+
+
+def _quote_if_not_none(value: str | None) -> str | None:
+    return quote(value, safe="") if value is not None else value
+
+
+def _quote_path_in_url(url: str) -> ParseResult:
+    parsed_url = urlparse(url)
+    return parsed_url._replace(path=quote(unquote(parsed_url.path)))
+
+
+def _get_host_from_url(parsed_url: ParseResult) -> str:
+    host = parsed_url.netloc
+    if "@" in host:
+        host = host.split("@")[-1]
+    return host
+
+
+def _get_url_based_on_credentials(  # noqa: PLR0913
+    *,
+    parsed_url: ParseResult,
+    token: str | None,
+    host: str,
+    provider: str | None,
+    user: str | None,
+    password: str | None,
+) -> str:
+    if token is not None:
+        return _format_token(parsed_url, token, host, provider)
+    if user is not None and password is not None:
+        return _replace_netloc_in_url(parsed_url, f"{user}:{password}@{host}")
+    return parsed_url.geturl()
+
+
+def format_url(  # noqa: PLR0913
+    *,
+    repo_url: str,
+    user: str | None = None,
+    password: str | None = None,
+    token: str | None = None,
+    provider: str | None = None,
+    is_pat: bool = False,
+) -> str:
+    parsed_url = _quote_path_in_url(repo_url)
+    if is_pat:
+        return parsed_url.geturl()
+
+    host = _get_host_from_url(parsed_url)
+    user = _quote_if_not_none(user)
+    password = _quote_if_not_none(password)
+    return _get_url_based_on_credentials(
+        parsed_url=parsed_url,
+        token=token,
+        host=host,
+        provider=provider,
+        user=user,
+        password=password,
+    )
+
+
+def get_https_git_config_args(
+    *,
+    follow_redirects: bool = False,
+    is_pat: bool = False,
+    token: str | None = None,
+    disable_credential_prompt: bool = False,
+) -> list[str]:
+    args = [
+        "-c",
+        "core.symlinks=false",
+        "-c",
+        "http.sslVerify=false",
+        "-c",
+        f"http.followRedirects={follow_redirects}",
+    ]
+    if is_pat and token is not None:
+        args.extend(
+            [
+                "-c",
+                "http.extraHeader=Authorization: Basic "
+                + base64.b64encode(f":{token}".encode()).decode(),
+            ]
+        )
+    if disable_credential_prompt:
+        args.extend(["-c", "credential.helper="])
+    return args

fluidattacks_core/git/warp.py

@@ -0,0 +1,184 @@
+import asyncio
+import logging
+import re
+import socket
+
+import aiohttp
+
+LOGGER = logging.getLogger(__name__)
+
+CONFIG_DELAY: int = 5  # For WARP to apply network configurations, in seconds
+DOMAIN_TO_TEST_DNS: str = "api.ipify.org"  # Using a domain that used to fail
+
+
+class WarpError(Exception):
+    pass
+
+
+async def test_public_ip(expected_ip: str) -> bool:
+    ip_service_url = "https://api.ipify.org?format=text"
+    try:
+        async with aiohttp.ClientSession() as session:  # noqa: SIM117
+            async with session.get(ip_service_url) as response:
+                if response.status == 200:
+                    public_ip = await response.text()
+                    LOGGER.info("Current public IP: %s", public_ip)
+                    return public_ip.strip() == expected_ip
+
+                LOGGER.error("Failed to fetch public IP. Status code: %s", response.status)
+                return False
+
+    except aiohttp.ClientError:
+        LOGGER.exception("Error fetching public IP")
+        return False
+
+
+async def public_ip_ready(expected_ip: str, *, attempts: int, seconds_per_attempt: int) -> bool:
+    for attempt_number in range(1, attempts + 1):
+        LOGGER.info("Checking public IP... Attempt %s/%s", attempt_number, attempts)
+        if await test_public_ip(expected_ip):
+            LOGGER.info("Public IP test successful after %s attempts", attempt_number)
+            return True
+
+        LOGGER.info("Public IP test failed. Retrying in %s seconds", seconds_per_attempt)
+        await asyncio.sleep(seconds_per_attempt)
+
+    LOGGER.error("Public IP test failed after %s attempts", attempts)
+    return False
+
+
+async def _dns_test(host: str) -> bool:
+    try:
+        socket.gethostbyname(host)
+    except socket.gaierror:
+        return False
+    else:
+        return True
+
+
+async def is_dns_ready(
+    *,
+    host_to_test_dns: str,
+    attempts: int = 40,
+    seconds_per_attempt: int = 5,
+) -> bool:
+    for attempt_number in range(1, attempts + 1):
+        LOGGER.info("Waiting for DNS resolution... Attempt %s/%s", attempt_number, attempts)
+        if await _dns_test(host_to_test_dns):
+            LOGGER.info("DNS resolution successful after %s attempts", attempt_number)
+            return True
+        LOGGER.error("DNS resolution failed. Retrying in %s seconds...", seconds_per_attempt)
+        await asyncio.sleep(seconds_per_attempt)
+
+    LOGGER.error("DNS resolution failed after %s attempts on %s", attempts, host_to_test_dns)
+    return False
+
+
+async def warp_cli(*args: str) -> str:
+    proc = await asyncio.create_subprocess_exec(
+        "warp-cli",
+        "--accept-tos",
+        *args,
+        stderr=asyncio.subprocess.PIPE,
+        stdout=asyncio.subprocess.PIPE,
+        stdin=asyncio.subprocess.DEVNULL,
+    )
+    try:
+        stdout, stderr = await asyncio.wait_for(proc.communicate(), 30)
+    except (asyncio.exceptions.TimeoutError, OSError) as ex:
+        msg = "Failed to run command"
+        raise WarpError(msg) from ex
+
+    if proc.returncode != 0:
+        msg = stderr.decode().strip()
+        raise WarpError(msg)
+
+    return stdout.decode().strip()
+
+
+async def warp_cli_status() -> str:
+    return await warp_cli("status")
+
+
+async def warp_cli_connect() -> None:
+    response = await warp_cli("connect")
+    LOGGER.info("Connect: %s", response)
+    await asyncio.sleep(CONFIG_DELAY)
+    if not await is_dns_ready(host_to_test_dns=DOMAIN_TO_TEST_DNS):
+        msg = "Failed to resolve DNS"
+        raise WarpError(msg)
+
+    LOGGER.info("Connected. Status: %s", await warp_cli_status())
+
+
+async def warp_cli_disconnect() -> None:
+    response = await warp_cli("disconnect")
+    LOGGER.info("Disconnect: %s", response)
+    await asyncio.sleep(CONFIG_DELAY)
+    LOGGER.info("Disconnected. Status: %s", await warp_cli_status())
+
+
+async def warp_cli_get_virtual_network_id(vnet_name: str) -> str:
+    vnet_id_match = re.search(
+        f"ID: (.*)\n  Name: {vnet_name}\n",
+        await warp_cli("vnet"),
+    )
+    if not vnet_id_match:
+        msg = f"Failed to find virtual network {vnet_name}"
+        raise WarpError(msg)
+
+    return vnet_id_match.groups()[0]
+
+
+async def warp_cli_set_virtual_network(vnet_name: str) -> None:
+    vnet_id = await warp_cli_get_virtual_network_id(vnet_name)
+    await warp_cli("vnet", vnet_id)
+    await asyncio.sleep(CONFIG_DELAY)
+    LOGGER.info(
+        "Setup virtual network. Name: %s, Network ID: %s, Status: %s",
+        vnet_name,
+        vnet_id,
+        await warp_cli_status(),
+    )
+
+
+def _resolve_host(host: str) -> str:
+    try:
+        return socket.gethostbyname(host)
+    except socket.gaierror:
+        return host
+
+
+async def _ip_route_get(host: str) -> tuple[bytes, bytes]:
+    target = _resolve_host(host)
+    proc = await asyncio.create_subprocess_exec(
+        "ip",
+        "route",
+        "get",
+        target,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+        stdin=asyncio.subprocess.DEVNULL,
+    )
+    try:
+        stdout, stderr = await asyncio.wait_for(proc.communicate(), 5)
+    except asyncio.exceptions.TimeoutError as ex:
+        msg = "Timeout - Failed to retrieve route"
+        raise WarpError(msg) from ex
+
+    if proc.returncode != 0:
+        msg = stderr.decode()
+        raise WarpError(msg)
+
+    return stdout, stderr
+
+
+async def is_using_split_tunnel(host: str) -> bool:
+    try:
+        stdout, _ = await _ip_route_get(host)
+        LOGGER.info("Route command for '%s': %s", host, stdout.decode().replace("\n", " "))
+    except WarpError:
+        LOGGER.exception("Error getting IP route in split tunnel")
+        return False
+    else:
+        return b"CloudflareWARP" in stdout

fluidattacks_core_git-12.0.0.dist-info/METADATA

@@ -0,0 +1,22 @@
+Metadata-Version: 2.5
+Name: fluidattacks_core_git
+Version: 12.0.0
+Summary: Fluid Attacks Core Git Library
+Author-email: Development <development@fluidattacks.com>
+License: MPL-2.0
+Classifier: Development Status :: 1 - Planning
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.11
+Requires-Dist: aiofiles>=23.2.1
+Requires-Dist: aiohttp>=3.10.0
+Requires-Dist: anyio>=4.7.0
+Requires-Dist: boto3>=1.34
+Requires-Dist: botocore>=1.40.18
+Requires-Dist: fluidattacks-core-http>=12.0.0
+Requires-Dist: gitpython>=3.1.41
+Requires-Dist: pathspec>=0.12.1
+Requires-Dist: urllib3>=2.6.1

fluidattacks_core_git-12.0.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+fluidattacks_core/git/__init__.py,sha256=Z3ABS9a3nxJG2WJq8IurFenzcwPlOZAGc8GGSs9fZws,10055
+fluidattacks_core/git/classes.py,sha256=vgCVOUF6tqeW0lKtD9giCNFQtzRit44bnu5qOAx7qCI,579
+fluidattacks_core/git/clone.py,sha256=hmCAhqE-hNX7KOSJahmEmnFqrhrD_WMf_7PEUZ6SO-U,6866
+fluidattacks_core/git/codecommit_utils.py,sha256=P9vTk9wj0sdubOSZvfFodLJYPOMJmXQkd9T8jw-jU5k,3212
+fluidattacks_core/git/constants.py,sha256=ntIdf_zQDGZfjahUpjASS-Ry9ZE8iDaEURCPBhEPebk,204
+fluidattacks_core/git/delete_files.py,sha256=_8Cn9izhCc70RKBgFa1TBU9oTVtggg10mexxHn3IkIE,1547
+fluidattacks_core/git/download_file.py,sha256=hPuZhDQaYoG0ROF__CSGVV0UUWOK3771AnU1xXtu-4o,1450
+fluidattacks_core/git/download_repo.py,sha256=US4z1px9zUc33JDBaAxl85Ily6Ut4kMsbrrH0UFfv5k,4424
+fluidattacks_core/git/https_utils.py,sha256=6dRDwaRyDVd3WDm0-XFYJUZMh3lCo1sQjcHcoP0Yekw,6615
+fluidattacks_core/git/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fluidattacks_core/git/remote.py,sha256=cPuyBMHeGrzRkEjroB6zlRLMA-QH2gIyIkGJNyf8wZc,1255
+fluidattacks_core/git/show_file.py,sha256=zKsFH2JexD1gyeb4fPrPnUebnmc58b8eq2tPuhto7bQ,10902
+fluidattacks_core/git/ssh_utils.py,sha256=3EdkRfWKIbb1-i2zgMogueTSZxAb8Ft7kQb4MbNcfg8,6178
+fluidattacks_core/git/upload_repo.py,sha256=p2FGyDykHhY3Be1youwmfOmsf7M6a9pjGPJGtCWp5mo,10475
+fluidattacks_core/git/utils.py,sha256=E614OPPkGowFjQpvm-pnmRPztnYm6xJQzNkjegkb5P0,3765
+fluidattacks_core/git/warp.py,sha256=SzDtyYG3TM--Nrv2nl1DM23NmSQ1o-Pc26LOvwGIb4k,5651
+fluidattacks_core_git-12.0.0.dist-info/METADATA,sha256=5uiUhLuWS0_lySl7cEgBpX46d2r_Dr7h80UE_aZTbrE,817
+fluidattacks_core_git-12.0.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+fluidattacks_core_git-12.0.0.dist-info/RECORD,,