projectaria-debug-sharing 0.1.0__py3-none-any.whl

projectaria_debug_sharing/debug_sharing/flytrap.py

@@ -0,0 +1,327 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import re
+from collections.abc import Collection
+from typing import Any, Final
+
+import aiohttp
+from projectaria_commons.commons.http_helper import HttpHelper
+from projectaria_debug_sharing.debug_sharing.submitter import SubmissionError, Submitter
+from projectaria_debug_sharing.debug_sharing.types import (
+    Attachment,
+    DebugReport,
+    ERROR_CODE_KEY,
+    VRS_RECORDING_ID_KEY,
+)
+from projectaria_login import ProjectAriaLogin
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+REPORT_BUG_URL: Final[str] = "https://graph.oculus.com/report_bug"
+
+DEV_SERVER_ENV: Final[str] = "PROJECTARIA_DEV_SERVER"
+"""Names a test server to send reports to instead of production: `NAME` sends to
+`graph.NAME.oculus.com`. Unset for everyone else."""
+
+_SANDBOX_NAME: Final[re.Pattern[str]] = re.compile(r"[A-Za-z0-9-]+(\.[A-Za-z0-9-]+)*")
+
+CATEGORY_ID: Final[str] = "113915505441756"
+"""`PRODUCT_NONE_FBID`: the user had no chance to select a category, no UI being
+shown. The endpoint's only required parameter, so it cannot be omitted, but
+categories are being removed platform-wide and nothing may branch on it."""
+
+ENTRY_SOURCE: Final[str] = "projectaria_debug_sharing"
+
+CONNECT_TIMEOUT_SEC: Final[float] = 10.0
+
+READ_TIMEOUT_SEC: Final[float] = 60.0
+"""How long FlyTrap may stay silent once the whole report is sent. Longer than
+the server's own 30 s limit, so a slow ingest is not mistaken for a dead link."""
+
+TOTAL_TIMEOUT_SEC: Final[float] = 1800.0
+"""Cap on one whole submission, so an upload that trickles along without ever
+tripping `READ_TIMEOUT_SEC` still ends. Well under the spool's one-hour claim
+expiry, so a stalled upload cannot outlive its claim and be sent twice."""
+
+_PERMANENT_SERVER_ERRORS: Final[frozenset[int]] = frozenset({501, 505})
+"""501 Not Implemented and 505 HTTP Version Not Supported: a retry gets the
+same answer."""
+
+_REPORT_FIELDS: Final[frozenset[str]] = frozenset(
+    {
+        "category_id",
+        "description",
+        "source_app",
+        "entry_source",
+        "error_description",
+        "session_id",
+        "custom_app_metadata",
+        "app_id",
+        "vrs_recording_id",
+    }
+)
+
+
+class FlyTrapSubmissionError(SubmissionError):
+    """FlyTrap refused a report, or could not be reached."""
+
+
+class NotLoggedInError(FlyTrapSubmissionError):
+    """Nobody is logged in to Project Aria, so there is no token to send with."""
+
+
+class FlyTrapSubmitter(Submitter):
+    """
+    Files a `DebugReport` as a FlyTrap bug through OCGraphReportBugPost.
+    """
+
+    def __init__(self, *, login: ProjectAriaLogin) -> None:
+        """
+        Args:
+            login: Supplies the token and app ID. Resumed on every submit, so a
+                report sent hours later still uses a current token.
+        """
+        self._login = login
+
+    async def submit(self, report: DebugReport) -> str:
+        """
+        Args:
+            report: The report to file.
+
+        Returns:
+            The FlyTrap bug ID.
+
+        Raises:
+            FlyTrapSubmissionError: The report was not filed. `retryable` says
+                whether sending it again could succeed.
+        """
+        token = await self._get_current_token()
+        form = self._build_form(report)
+
+        async with HttpHelper() as http:
+            http.set_auth_token(token)
+            payload = await self._post(http.session, form)
+
+        return self._bug_id_from(payload)
+
+    async def _get_current_token(self) -> str:
+        """
+        Raises:
+            FlyTrapSubmissionError: Nobody is logged in. Retryable, because
+                logging in is what makes the next attempt succeed.
+        """
+        await self._login.resume()
+        token = self._login.current_token
+        if token is None:
+            raise NotLoggedInError(
+                "No Project Aria login, so the report cannot be sent. "
+                "Log in and submit again; the report is kept.",
+                retryable=True,
+            )
+        return token
+
+    def _build_form(self, report: DebugReport) -> aiohttp.FormData:
+        form = aiohttp.FormData()
+        for name, value in self._report_fields(report).items():
+            form.add_field(name, value)
+        for part_name, attachment in _attachments_by_part_name(
+            report.attachments
+        ).items():
+            form.add_field(
+                part_name,
+                attachment.data,
+                filename=attachment.filename or attachment.name,
+                content_type=attachment.content_type,
+            )
+        return form
+
+    def _report_fields(self, report: DebugReport) -> dict[str, str]:
+        """
+        `app_id` is the login's, so it names the app that actually filed the
+        report. `vrs_recording_id` is sent only when the report names one.
+        """
+        fields = {
+            "category_id": CATEGORY_ID,
+            "description": report.description,
+            "source_app": report.source_app,
+            "entry_source": ENTRY_SOURCE,
+            "error_description": report.metadata.get(ERROR_CODE_KEY, ""),
+            "session_id": report.report_id,
+            "custom_app_metadata": json.dumps(dict(report.metadata)),
+        }
+        app_id = self._login.current_app_id
+        if app_id is not None:
+            fields["app_id"] = app_id
+        recording_id = report.metadata.get(VRS_RECORDING_ID_KEY)
+        if recording_id:
+            fields["vrs_recording_id"] = recording_id
+        return fields
+
+    async def _post(
+        self, session: aiohttp.ClientSession, form: aiohttp.FormData
+    ) -> dict[str, Any]:
+        """
+        Sends the form and returns FlyTrap's JSON response. Status is checked
+        here rather than by HttpHelper's session, which would discard the body
+        that says why FlyTrap refused.
+
+        Raises:
+            FlyTrapSubmissionError: On an HTTP error, a malformed body or a
+                transport failure. A read timeout is not retryable: the whole
+                report had been sent, so FlyTrap may have filed it.
+        """
+        url = report_bug_url()
+        timeout = aiohttp.ClientTimeout(
+            total=TOTAL_TIMEOUT_SEC,
+            sock_connect=CONNECT_TIMEOUT_SEC,
+            sock_read=READ_TIMEOUT_SEC,
+        )
+        try:
+            async with session.post(
+                url, data=form, timeout=timeout, raise_for_status=False
+            ) as response:
+                body = await response.text()
+                if response.status >= 400:
+                    raise FlyTrapSubmissionError(
+                        f"FlyTrap returned HTTP {response.status}: {body[:500]}",
+                        retryable=_is_retryable_status(response.status),
+                    )
+                return self._parse(body)
+        except aiohttp.SocketTimeoutError as e:
+            raise FlyTrapSubmissionError(
+                f"FlyTrap did not answer within {READ_TIMEOUT_SEC:g}s. The report "
+                "may have been filed, so it is not sent again.",
+                retryable=False,
+            ) from e
+        except (aiohttp.ClientError, asyncio.TimeoutError) as e:
+            raise FlyTrapSubmissionError(
+                f"Could not reach FlyTrap: {_describe(e)}", retryable=True
+            ) from e
+
+    def _parse(self, body: str) -> dict[str, Any]:
+        """
+        Raises:
+            FlyTrapSubmissionError: The body is not a JSON object. Not retryable.
+        """
+        try:
+            payload = json.loads(body)
+        except json.JSONDecodeError as e:
+            raise FlyTrapSubmissionError(
+                f"FlyTrap returned a non-JSON body: {body[:500]}", retryable=False
+            ) from e
+        if not isinstance(payload, dict):
+            raise FlyTrapSubmissionError(
+                f"FlyTrap returned {type(payload).__name__}, expected an object",
+                retryable=False,
+            )
+        return payload
+
+    def _bug_id_from(self, payload: dict[str, Any]) -> str:
+        """
+        Raises:
+            FlyTrapSubmissionError: FlyTrap refused the report, or reported
+                success without a `bug_id`. A refusal is retryable only when
+                FlyTrap says so and did not prohibit the report; its message
+                carries the whole response, since that is where the trace ID
+                is. A success without a `bug_id` is not retried: the report
+                probably landed, and resending would file a duplicate.
+        """
+        if not payload.get("success"):
+            prohibited = bool(payload.get("is_prohibited"))
+            raise FlyTrapSubmissionError(
+                f"{payload.get('error_message') or 'FlyTrap rejected the report'} "
+                f"-- full response: {json.dumps(payload, sort_keys=True)[:1000]}",
+                retryable=bool(payload.get("is_retryable")) and not prohibited,
+            )
+
+        bug_id = payload.get("bug_id")
+        if not bug_id:
+            raise FlyTrapSubmissionError(
+                "FlyTrap reported success but returned no bug_id", retryable=False
+            )
+
+        logger.debug("Submitted debug report as FlyTrap bug %s", bug_id)
+        return str(bug_id)
+
+
+def report_bug_url() -> str:
+    """
+    Production, or the test server `PROJECTARIA_DEV_SERVER` names. Only a name made
+    of host labels is accepted, so the report and its token can only go to an
+    oculus.com host, over https.
+
+    Raises:
+        FlyTrapSubmissionError: `PROJECTARIA_DEV_SERVER` is not a server name.
+            Not retryable: a kept report does not record where it was meant to
+            go, so a later drain without the variable would send it to
+            production.
+    """
+    sandbox = os.environ.get(DEV_SERVER_ENV)
+    if not sandbox:
+        return REPORT_BUG_URL
+    if not _SANDBOX_NAME.fullmatch(sandbox):
+        raise FlyTrapSubmissionError(
+            f"{DEV_SERVER_ENV}={sandbox!r} is not a host name",
+            retryable=False,
+        )
+    url = f"https://graph.{sandbox}.oculus.com/report_bug"
+    logger.debug("Sending to %s, not production: %s is set", url, DEV_SERVER_ENV)
+    return url
+
+
+def _attachments_by_part_name(
+    attachments: Collection[Attachment],
+) -> dict[str, Attachment]:
+    """
+    Gives every attachment a multipart field name of its own, so the server
+    keeps all of them.
+    """
+    parts: dict[str, Attachment] = {}
+    for attachment in attachments:
+        parts[_unique_part_name(attachment.name, taken=parts.keys())] = attachment
+    return parts
+
+
+def _unique_part_name(name: str, *, taken: Collection[str]) -> str:
+    """
+    `name`, prefixed with `attachment_` if it is a report field's, and given a
+    numeric suffix if an earlier attachment already uses it.
+    """
+    base = f"attachment_{name}" if name in _REPORT_FIELDS else name
+    candidate = base
+    suffix = 2
+    while candidate in taken or candidate in _REPORT_FIELDS:
+        candidate = f"{base}_{suffix}"
+        suffix += 1
+    return candidate
+
+
+def _is_retryable_status(status: int) -> bool:
+    """Whether an HTTP error status is transient: 429, or any 5xx except
+    501 and 505, which reject the request itself."""
+    return status == 429 or (
+        500 <= status < 600 and status not in _PERMANENT_SERVER_ERRORS
+    )
+
+
+def _describe(error: BaseException) -> str:
+    """The error's message, or its type for one with none (a bare `TimeoutError`)."""
+    return str(error) or type(error).__name__

projectaria_debug_sharing/debug_sharing/submitter.py

@@ -0,0 +1,103 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""The boundary between assembling a report and delivering it."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Protocol, runtime_checkable
+
+from projectaria_debug_sharing.debug_sharing.types import DebugReport
+
+
+class SubmissionError(Exception):
+    """A report was not delivered."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        report: DebugReport | None = None,
+        retryable: bool = True,
+    ) -> None:
+        """
+        Args:
+            message: Why, in words the user can act on.
+            report: Set by whoever assembled the report, so a caller can spool it.
+            retryable: Whether sending the same report again could succeed.
+                Defaults to True: a wrong True costs one more attempt, a wrong
+                False drops a report for good.
+        """
+        super().__init__(message)
+        self.report = report
+        self.retryable = retryable
+
+
+@runtime_checkable
+class Submitter(Protocol):
+    """Delivers a report, returns the bug ID. Raises SubmissionError."""
+
+    async def submit(self, report: DebugReport) -> str: ...
+
+
+@dataclass(frozen=True)
+class Delivery:
+    """What happened to one report sent now."""
+
+    bug_id: str | None = None
+    """The filed bug's id; None when the report was not filed."""
+
+    error: SubmissionError | None = None
+    """Why the report was not filed."""
+
+    spooled: Path | None = None
+    """Where the report was kept for a later drain; None when it was filed, was
+    refused, or could not be kept."""
+
+    def __post_init__(self) -> None:
+        """
+        Raises:
+            ValueError: Not exactly one of `bug_id` and `error` is set, or a
+                filed report claims to be spooled.
+        """
+        if (self.bug_id is None) == (self.error is None):
+            raise ValueError("a Delivery has exactly one of bug_id and error")
+        if self.bug_id is not None and self.spooled is not None:
+            raise ValueError("a filed report is not spooled")
+
+    @property
+    def will_retry(self) -> bool:
+        """Whether a later drain sends the report: kept, and the failure retryable."""
+        return (
+            self.spooled is not None and self.error is not None and self.error.retryable
+        )
+
+
+@dataclass(frozen=True)
+class DrainResult:
+    """What a drain of the kept reports did."""
+
+    sent: tuple[str, ...] = ()
+    """The bug ids of the reports filed."""
+
+    waiting: int = 0
+    """How many reports this drain tried that failed and wait for the next one.
+    Reports it skipped, or that another drain was sending, are not counted."""
+
+    rejected: int = 0
+    """How many reports will never be sent: refused by the destination or
+    locally, or unreadable on disk. They are kept marked, or deleted if they
+    cannot be."""

projectaria_debug_sharing/debug_sharing/types.py

@@ -0,0 +1,172 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import uuid
+from collections.abc import Awaitable, Callable, Mapping
+from dataclasses import dataclass, field
+from enum import Enum
+from types import MappingProxyType
+from typing import Final
+
+VRS_RECORDING_ID_KEY: Final[str] = "vrs_recording_id"
+"""`DebugReport.metadata` key naming the VRS recording the report is about. One
+recording only."""
+
+ERROR_CODE_KEY: Final[str] = "error_code"
+"""`DebugReport.metadata` key for the error code that prompted the report."""
+
+
+class CollectionScope(Enum):
+    """
+    A category of data a collector gathers, and the unit consent is given in.
+    """
+
+    LOGS = "logs"
+    ENVIRONMENT = "environment"
+    DIAGNOSTICS = "diagnostics"
+    RECORDING = "recording"
+
+
+@dataclass(frozen=True)
+class Attachment:
+    """One file we upload."""
+
+    name: str
+    """Short label, sent as the form field name."""
+
+    data: bytes
+
+    content_type: str = "application/octet-stream"
+
+    filename: str | None = None
+    """Filename sent with the part. When None, callers fall back to `name`."""
+
+
+@dataclass(frozen=True, kw_only=True)
+class DebugReport:
+    """
+    Everything we send for one bug.
+    """
+
+    description: str
+    source_app: str
+    attachments: tuple[Attachment, ...] = ()
+
+    metadata: Mapping[str, str] = field(default_factory=lambda: MappingProxyType({}))
+    """Read-only copy: `frozen=True` alone would still let a caller mutate their
+    own dict, or the dict behind their `MappingProxyType`, after the consent
+    prompt described it. Values become strings, and `None` values are dropped
+    rather than sent as `"None"`."""
+
+    report_id: str = field(default_factory=lambda: str(uuid.uuid4()))
+    """Correlates the PC and device halves. Sent as `session_id`, which the
+    endpoint copies into `client_server_join_key`."""
+
+    def __post_init__(self) -> None:
+        object.__setattr__(
+            self,
+            "metadata",
+            MappingProxyType(
+                {str(k): str(v) for k, v in self.metadata.items() if v is not None}
+            ),
+        )
+
+
+class SpooledReportError(Exception):
+    """
+    A spooled report could not be read. A drain marks it refused, so it is
+    never sent, and goes on to the next one.
+    """
+
+
+class ConsentSource(Enum):
+    """Where a report's consent came from, recorded on the report."""
+
+    PROMPTED = "prompted"
+    """The user answered the tool's consent prompt."""
+
+    CALLER = "caller"
+    """The calling tool obtained consent itself, for example its own question."""
+
+
+@dataclass(frozen=True)
+class OfferedCollector:
+    """One line of the consent prompt, and the collector it speaks for."""
+
+    name: str
+    scope: CollectionScope
+    disclosure: str
+
+
+@dataclass(frozen=True)
+class ConsentRequest:
+    """What a front end needs to render an accurate consent prompt."""
+
+    source_app: str
+
+    offered: tuple[OfferedCollector, ...]
+    """Every collector that would run, with the sentence to show for it. Taken
+    from the list that does the collecting, so the prompt cannot describe
+    something that will not run, or omit something that will."""
+
+    @property
+    def scopes(self) -> frozenset[CollectionScope]:
+        """The categories on offer, which is what the user chooses between."""
+        return frozenset(o.scope for o in self.offered)
+
+
+RequestConsent = Callable[
+    [ConsentRequest], Awaitable["frozenset[CollectionScope] | None"]
+]
+"""Returns the granted scopes. None means the user declined outright; an empty
+set still sends the description and caller metadata, with no attachments."""
+
+
+@dataclass(frozen=True)
+class CollectorFailure:
+    """A collector that raised. Collection is best effort, so these are reported."""
+
+    collector_name: str
+
+    error: str
+    """The exception's message, or its class name when the message is empty."""
+
+    error_type: str = ""
+    """The exception's class name. Empty when the failure was built without one."""
+
+
+@dataclass(frozen=True)
+class ShareOutcome:
+    """Everything the caller needs to tell the user what happened."""
+
+    bug_id: str
+    report_id: str
+
+    failures: tuple[CollectorFailure, ...] = field(default_factory=tuple)
+    """Collectors that failed. The report was still submitted; the caller should
+    say so, so the user knows the bundle is incomplete."""
+
+
+class ConsentDeclinedError(Exception):
+    """The user declined to share. Nothing was collected or sent."""
+
+
+class NoConsentBasisError(Exception):
+    """
+    Nothing says the user agreed to this. Raised rather than assuming a grant:
+    a missing prompt is far more likely a caller that forgot one than a caller
+    that meant to collect everything.
+    """

projectaria_debug_sharing-0.1.0.dist-info/METADATA

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: projectaria-debug-sharing
+Version: 0.1.0
+Summary: Project Aria Debug Sharing Library
+Home-page: https://www.projectaria.com
+Author: Meta Reality Labs Research
+License: Apache-2.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.10
+Requires-Dist: projectaria-commons~=0.1.0
+Requires-Dist: projectaria-login~=0.2.0
+Dynamic: author
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+Shared debug-sharing library for Project Aria tools.
+
+Collects diagnostic logs and environment details, captures the user's consent,
+and submits a correlated bug report, so MPS CLI, Client SDK and Aria Studio can
+offer one consistent reporting experience.
+
+For more information, visit [Project Aria](https://www.projectaria.com).

projectaria_debug_sharing-0.1.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+projectaria_debug_sharing/__init__.py,sha256=zsf453g7MRWide6tT4tf_CzY-Wr6i-pOiS4C6CZaRb0,749
+projectaria_debug_sharing/debug_sharing/__init__.py,sha256=6xZPTzPtzy-lDojjgRGorJj9GQd2pzDdlt3gzc8rgAU,614
+projectaria_debug_sharing/debug_sharing/cli.py,sha256=8dMxP-NqlfS3IaD3C6aIp8gO8lQuKSa77ElusGBA5Bw,6107
+projectaria_debug_sharing/debug_sharing/collectors.py,sha256=bGtxY0BVuUUDdJXPTXcUrPnwTzg_p-L64Ug3AfD0Vjg,16547
+projectaria_debug_sharing/debug_sharing/command.py,sha256=ObUYs5be8AXKTy9JaB4LNjwmSSe7Ahtvk-4SKg0fQd4,1070
+projectaria_debug_sharing/debug_sharing/facade.py,sha256=kvxa0DUTVX9xE_HdWL5wacVgHlKrpO9-KwFit6Mhn3I,16775
+projectaria_debug_sharing/debug_sharing/flytrap.py,sha256=yjYMp9_T0IZOHKBcviAvA5rpylKtuMYhwxc3dg-EPK8,12081
+projectaria_debug_sharing/debug_sharing/submitter.py,sha256=Yks6KZt5uTLaPWJ9aFHU1wojFJEy4mzdolXDlXg16rQ,3453
+projectaria_debug_sharing/debug_sharing/types.py,sha256=j5LnuyoSPbw3d3VkwEuEzUqBafLbKPVrnaqwiFCt2iA,5269
+projectaria_debug_sharing/debug_sharing/_internal/__init__.py,sha256=ATD5Za7LwP-bGqN8PQsTyTzFrl7ER2QgIs_8NoIhZiU,599
+projectaria_debug_sharing/debug_sharing/_internal/delivery.py,sha256=cJu28RWV9PW3yLocgnfoWDhRVbTQw20N5IyMWrCsclc,9731
+projectaria_debug_sharing/debug_sharing/_internal/file_access.py,sha256=UwrhBTm3DnTtPmytCFGgbIkUYhNIl858PF4l25ysq5Y,4090
+projectaria_debug_sharing/debug_sharing/_internal/manifest.py,sha256=pi91XZmjQEecmUrB5UhSQUsQS-46hOQVd_isCZaWoZg,4836
+projectaria_debug_sharing/debug_sharing/_internal/plain_files.py,sha256=FOnRuOyxQheUE0pf5Q0rgF4x0WMRn2_w7QTCy8fnjxc,6761
+projectaria_debug_sharing/debug_sharing/_internal/report_command.py,sha256=pPkhZD7DLgJfbbXDik3l-PjLoV7P4zKxealdHSHV7tE,21287
+projectaria_debug_sharing/debug_sharing/_internal/spool.py,sha256=Te3lOGj0ltbXvujA4j5gSGJ6cpfdk41YhlaN0OZaenw,25615
+projectaria_debug_sharing-0.1.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+projectaria_debug_sharing-0.1.0.dist-info/METADATA,sha256=ZnkwrCQaxNJehUnRIB-BzkhDeEeku44LeMPWmUZErkM,929
+projectaria_debug_sharing-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+projectaria_debug_sharing-0.1.0.dist-info/entry_points.txt,sha256=6RgKvfI0LpOPLv42y9CnY4lCEa--GqA_i7NEzPxdrVo,87
+projectaria_debug_sharing-0.1.0.dist-info/top_level.txt,sha256=SsQLlgUmT4TeA3KS5pq2MuLtJO6yMW-HKlIWC6cxd8c,26
+projectaria_debug_sharing-0.1.0.dist-info/RECORD,,

projectaria_debug_sharing-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

projectaria_debug_sharing-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+aria-debug-report = projectaria_debug_sharing.debug_sharing.cli:main