selander-bridge 0.1.0__py3-none-any.whl

selander_bridge/__init__.py

@@ -0,0 +1,60 @@
+"""
+selander_bridge
+===============
+
+A reusable bridge between Python apps and Google Workspace APIs
+(Drive, Contacts, and easy to extend to more).
+
+Quick start (personal / per-developer Google accounts, no hosting needed):
+
+    from selander_bridge import GoogleAuthManager, ContactsClient, DriveClient
+
+    auth = GoogleAuthManager(
+        client_secrets_file="client_secret.json",
+        scopes=[*ContactsClient.scopes, *DriveClient.scopes],
+    )
+
+    contacts = ContactsClient(auth, account="me@gmail.com")
+    for person in contacts.list_contacts():
+        print(person.get("names"))
+
+    drive = DriveClient(auth, account="me@gmail.com")
+    for f in drive.list_files(query="mimeType='application/vnd.google-apps.folder'"):
+        print(f["name"])
+
+Quick start (Google Workspace org you administer, zero browser interaction):
+
+    from selander_bridge import ServiceAccountAuthManager, DriveClient
+
+    auth = ServiceAccountAuthManager(
+        service_account_file="service_account.json",
+        scopes=DriveClient.scopes,
+    )
+    drive = DriveClient(auth, account="someuser@yourcompany.com")
+"""
+
+from .auth import GoogleAuthManager, ServiceAccountAuthManager, TokenStore
+from .base import BaseService
+from .contacts import ContactsClient, SCOPE_CONTACTS, SCOPE_CONTACTS_READONLY
+from .drive import DriveClient
+from .exceptions import (
+    AuthenticationError,
+    MissingClientSecretsError,
+    SelanderBridgeError,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "GoogleAuthManager",
+    "ServiceAccountAuthManager",
+    "TokenStore",
+    "BaseService",
+    "ContactsClient",
+    "SCOPE_CONTACTS",
+    "SCOPE_CONTACTS_READONLY",
+    "DriveClient",
+    "SelanderBridgeError",
+    "AuthenticationError",
+    "MissingClientSecretsError",
+]

selander_bridge/auth.py

@@ -0,0 +1,199 @@
+"""
+Authentication for selander_bridge.
+
+The design goal here is specifically to avoid the "I need a hosted server
+just to catch an OAuth redirect" problem. Instead of the web-application
+OAuth flow (which needs a permanently running, publicly reachable callback
+URL), this uses Google's installed-app / loopback flow:
+
+    1. A browser window opens and the user logs into Google + consents.
+    2. Google redirects to http://127.0.0.1:<random free port>/...
+    3. A local HTTP server -- spun up only for this exchange, on a random
+       free port, and torn down immediately after -- receives the
+       authorization code and finishes the token exchange.
+    4. The resulting refresh token is cached to disk (via TokenStore) so
+       every later run, in any app that imports selander_bridge and uses the
+       same `account_key`, picks the cached token up and never prompts again.
+
+No server needs to be deployed or kept running anywhere for this to work.
+
+If you're building a true multi-tenant web product where strangers need to
+grant consent through your own domain, you'll still need *some* hosted
+redirect endpoint for that flow specifically -- that's a Google requirement,
+not a limitation of this library. Everything below still helps in that
+case (token storage/refresh, the service wrappers), you'd just plug in a
+different Flow object. See `GoogleAuthManager.from_web_flow` for a starting
+point.
+
+For the common Google Workspace admin case -- you control the whole
+Workspace org and want to act on behalf of users in it -- a service account
+with domain-wide delegation needs *zero* browser interaction and zero
+hosting. See `ServiceAccountAuthManager` below.
+"""
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import Optional, Sequence, Union
+
+from google.auth.exceptions import RefreshError
+from google.auth.transport.requests import Request
+from google.oauth2.credentials import Credentials
+from google.oauth2 import service_account
+from google_auth_oauthlib.flow import InstalledAppFlow
+
+from .exceptions import AuthenticationError, MissingClientSecretsError
+
+logger = logging.getLogger("selander_bridge.auth")
+
+DEFAULT_TOKEN_DIR = Path.home() / ".selander_bridge" / "tokens"
+
+
+class TokenStore:
+    """
+    Pluggable storage for cached OAuth credentials.
+
+    Default implementation is one JSON file per `account_key` under
+    ~/.selander_bridge/tokens/. Swap this out (same 3 methods) for a
+    database- or keyring-backed store in a multi-user server app.
+    """
+
+    def __init__(self, base_dir: Optional[Union[str, Path]] = None):
+        self.base_dir = Path(base_dir) if base_dir else DEFAULT_TOKEN_DIR
+        self.base_dir.mkdir(parents=True, exist_ok=True)
+
+    def _path(self, account_key: str) -> Path:
+        safe = "".join(c if c.isalnum() or c in "-_.@" else "_" for c in account_key)
+        return self.base_dir / f"{safe}.json"
+
+    def load(self, account_key: str) -> Optional[Credentials]:
+        path = self._path(account_key)
+        if not path.exists():
+            return None
+        try:
+            data = json.loads(path.read_text())
+            return Credentials.from_authorized_user_info(data)
+        except (ValueError, KeyError) as exc:
+            logger.warning("Could not parse cached token for %s: %s", account_key, exc)
+            return None
+
+    def save(self, account_key: str, creds: Credentials) -> None:
+        self._path(account_key).write_text(creds.to_json())
+
+    def delete(self, account_key: str) -> None:
+        path = self._path(account_key)
+        if path.exists():
+            path.unlink()
+
+
+class GoogleAuthManager:
+    """
+    Acquires and caches Google OAuth2 user credentials.
+
+    Usage:
+        auth = GoogleAuthManager(
+            client_secrets_file="client_secret.json",
+            scopes=ContactsClient.scopes + DriveClient.scopes,
+        )
+        creds = auth.get_credentials("someone@gmail.com")
+
+    One `GoogleAuthManager` (and its scope list) is normally shared across
+    every service wrapper in your app, so you only get one consent screen
+    covering everything you need, per account.
+    """
+
+    def __init__(
+        self,
+        client_secrets_file: Union[str, Path],
+        scopes: Sequence[str],
+        token_store: Optional[TokenStore] = None,
+    ):
+        if not Path(client_secrets_file).exists():
+            raise MissingClientSecretsError(
+                f"client_secrets_file not found: {client_secrets_file}. "
+                "Download this from Google Cloud Console > APIs & Services > "
+                "Credentials > OAuth client ID (type: Desktop app)."
+            )
+        self.client_secrets_file = str(client_secrets_file)
+        self.scopes = list(scopes)
+        self.token_store = token_store or TokenStore()
+
+    def get_credentials(self, account_key: str = "default") -> Credentials:
+        """
+        Return valid credentials for `account_key`, refreshing or running
+        the interactive consent flow only if necessary.
+        """
+        creds = self.token_store.load(account_key)
+
+        if creds and set(self.scopes) - set(creds.scopes or []):
+            # Previously cached token doesn't cover everything requested now.
+            logger.info("Cached scopes for %s are insufficient; re-authenticating", account_key)
+            creds = None
+
+        if creds and creds.valid:
+            return creds
+
+        if creds and creds.expired and creds.refresh_token:
+            try:
+                creds.refresh(Request())
+                self.token_store.save(account_key, creds)
+                return creds
+            except RefreshError as exc:
+                logger.warning("Refresh failed for %s (%s); re-authenticating", account_key, exc)
+                creds = None
+
+        creds = self._run_interactive_flow()
+        self.token_store.save(account_key, creds)
+        return creds
+
+    def _run_interactive_flow(self) -> Credentials:
+        try:
+            flow = InstalledAppFlow.from_client_secrets_file(
+                self.client_secrets_file, scopes=self.scopes
+            )
+            # port=0 -> OS picks a free local port; server shuts down right
+            # after the redirect is caught. Nothing stays running.
+            return flow.run_local_server(port=0)
+        except Exception as exc:  # pragma: no cover - surfaced to caller
+            raise AuthenticationError(f"Interactive Google sign-in failed: {exc}") from exc
+
+    def forget(self, account_key: str) -> None:
+        """Drop the cached token for an account, forcing re-auth next time."""
+        self.token_store.delete(account_key)
+
+
+class ServiceAccountAuthManager:
+    """
+    Zero-interaction, zero-hosting auth for Google Workspace admins.
+
+    Use this instead of GoogleAuthManager when every account you need to
+    touch belongs to a Workspace domain you administer. A super admin
+    enables domain-wide delegation for a service account once, and from
+    then on this manager can impersonate any user in the org with no
+    browser, no consent screen, and no token caching needed (a fresh
+    short-lived token is minted on every call).
+
+    Setup (one-time, in Google Cloud Console + Workspace Admin console):
+      1. Create a service account, generate a JSON key.
+      2. Enable domain-wide delegation on it, note its OAuth Client ID.
+      3. In admin.google.com > Security > API controls > Domain-wide
+         delegation, authorize that client ID for the scopes you need.
+    """
+
+    def __init__(self, service_account_file: Union[str, Path], scopes: Sequence[str]):
+        if not Path(service_account_file).exists():
+            raise MissingClientSecretsError(
+                f"service_account_file not found: {service_account_file}"
+            )
+        self.service_account_file = str(service_account_file)
+        self.scopes = list(scopes)
+
+    def get_credentials(self, subject: str) -> Credentials:
+        """`subject` is the email of the Workspace user to impersonate."""
+        try:
+            return service_account.Credentials.from_service_account_file(
+                self.service_account_file, scopes=self.scopes, subject=subject
+            )
+        except Exception as exc:
+            raise AuthenticationError(f"Service-account auth failed for {subject}: {exc}") from exc

selander_bridge/base.py

@@ -0,0 +1,52 @@
+"""Shared plumbing for every wrapped Google API."""
+from __future__ import annotations
+
+from typing import Any, Sequence
+
+from googleapiclient.discovery import build, Resource
+from googleapiclient.errors import HttpError
+
+from .exceptions import SelanderBridgeError
+
+
+class BaseService:
+    """
+    Base class every service wrapper (ContactsClient, DriveClient, ...)
+    inherits from. Handles lazily building + caching the underlying
+    googleapiclient Resource object the first time it's actually used.
+
+    Works with either GoogleAuthManager (pass an account_key/email for
+    `account`) or ServiceAccountAuthManager (pass the subject email to
+    impersonate for `account`) -- both expose a one-argument
+    `get_credentials(account)` method.
+    """
+
+    api_name: str
+    api_version: str
+    scopes: Sequence[str] = ()
+
+    def __init__(self, auth_manager: Any, account: str = "default"):
+        self._auth_manager = auth_manager
+        self._account = account
+        self._service: Resource | None = None
+
+    @property
+    def service(self) -> Resource:
+        if self._service is None:
+            creds = self._auth_manager.get_credentials(self._account)
+            self._service = build(self.api_name, self.api_version, credentials=creds)
+        return self._service
+
+
+def wrap_http_errors(func):
+    """Decorator that turns raw googleapiclient HttpError into a SelanderBridgeError."""
+
+    def _wrapped(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except HttpError as exc:
+            raise SelanderBridgeError(f"Google API call failed: {exc}") from exc
+
+    _wrapped.__name__ = func.__name__
+    _wrapped.__doc__ = func.__doc__
+    return _wrapped

selander_bridge/contacts.py

@@ -0,0 +1,123 @@
+"""Wrapper around the Google People API (Contacts)."""
+from __future__ import annotations
+
+from typing import Any, Iterator, Optional
+
+from .base import BaseService, wrap_http_errors
+
+# Read-only is the safer default. Write operations need the full "contacts"
+# scope, so callers can opt in only when they need CRUD.
+SCOPE_CONTACTS_READONLY = "https://www.googleapis.com/auth/contacts.readonly"
+SCOPE_CONTACTS = "https://www.googleapis.com/auth/contacts"
+
+DEFAULT_PERSON_FIELDS = "names,emailAddresses,phoneNumbers,organizations"
+
+
+class ContactsClient(BaseService):
+    """
+    Example:
+        contacts = ContactsClient(auth, account="me@gmail.com")
+        for person in contacts.list_contacts():
+            print(person.get("names"))
+
+    By default this client is read-only. To use create/update/delete methods,
+    include `SCOPE_CONTACTS` in the auth manager's scope list.
+    """
+
+    api_name = "people"
+    api_version = "v1"
+    scopes = (SCOPE_CONTACTS_READONLY,)
+
+    @wrap_http_errors
+    def list_contacts(
+        self,
+        page_size: int = 100,
+        person_fields: str = DEFAULT_PERSON_FIELDS,
+    ) -> Iterator[dict]:
+        """Yield every contact connection for the authenticated user, handling pagination."""
+        request = self.service.people().connections().list(
+            resourceName="people/me",
+            pageSize=page_size,
+            personFields=person_fields,
+        )
+        while request is not None:
+            response = request.execute()
+            yield from response.get("connections", [])
+            request = self.service.people().connections().list_next(request, response)
+
+    @wrap_http_errors
+    def get_contact(
+        self, resource_name: str, person_fields: str = DEFAULT_PERSON_FIELDS
+    ) -> dict:
+        """resource_name looks like 'people/c1234567890123456789'."""
+        return (
+            self.service.people()
+            .get(resourceName=resource_name, personFields=person_fields)
+            .execute()
+        )
+
+    @wrap_http_errors
+    def search_contacts(self, query: str, page_size: int = 10) -> Iterator[dict]:
+        """
+        Search the authenticated user's "other contacts" + contacts by name,
+        nickname, email, or phone number substring.
+        """
+        response = (
+            self.service.people()
+            .searchContacts(query=query, pageSize=page_size, readMask=DEFAULT_PERSON_FIELDS)
+            .execute()
+        )
+        for result in response.get("results", []):
+            yield result.get("person", {})
+
+    @wrap_http_errors
+    def create_contact(
+        self,
+        *,
+        body: Optional[dict[str, Any]] = None,
+        given_name: Optional[str] = None,
+        family_name: str = "",
+        email: Optional[str] = None,
+    ) -> dict:
+        """
+        Create a new contact.
+
+        You can pass a raw People API `body`, or use the simple name/email
+        helpers for common cases.
+        """
+        if body is None:
+            if not given_name:
+                raise ValueError("Either body or given_name must be provided")
+            body = {"names": [{"givenName": given_name, "familyName": family_name}]}
+            if email:
+                body["emailAddresses"] = [{"value": email}]
+        return self.service.people().createContact(body=body).execute()
+
+    @wrap_http_errors
+    def update_contact(
+        self,
+        resource_name: str,
+        *,
+        body: dict[str, Any],
+        update_person_fields: str,
+    ) -> dict:
+        """
+        Update an existing contact.
+
+        `update_person_fields` should be a comma-separated field mask such as
+        "names,emailAddresses".
+        """
+        return (
+            self.service.people()
+            .updateContact(
+                resourceName=resource_name,
+                updatePersonFields=update_person_fields,
+                body=body,
+            )
+            .execute()
+        )
+
+    @wrap_http_errors
+    def delete_contact(self, resource_name: str) -> None:
+        """Delete a contact by People API resource name."""
+        self.service.people().deleteContact(resourceName=resource_name).execute()

selander_bridge/drive.py

@@ -0,0 +1,98 @@
+"""Wrapper around the Google Drive API."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Iterator, Optional, Union
+
+from googleapiclient.http import MediaFileUpload, MediaIoBaseDownload
+
+from .base import BaseService, wrap_http_errors
+
+SCOPE_DRIVE_READONLY = "https://www.googleapis.com/auth/drive.readonly"
+SCOPE_DRIVE_FILE = "https://www.googleapis.com/auth/drive.file"  # files the app created/opened
+SCOPE_DRIVE = "https://www.googleapis.com/auth/drive"  # full access
+
+DEFAULT_FIELDS = "nextPageToken, files(id, name, mimeType, modifiedTime, size, webViewLink)"
+
+
+class DriveClient(BaseService):
+    """
+    Example:
+        drive = DriveClient(auth, account="me@gmail.com")
+        for f in drive.list_files(query="mimeType='application/pdf'"):
+            print(f["name"])
+    """
+
+    api_name = "drive"
+    api_version = "v3"
+    scopes = (SCOPE_DRIVE,)
+
+    @wrap_http_errors
+    def list_files(
+        self,
+        query: Optional[str] = None,
+        page_size: int = 100,
+        fields: str = DEFAULT_FIELDS,
+    ) -> Iterator[dict]:
+        """Yield files matching an optional Drive query string, handling pagination."""
+        page_token = None
+        while True:
+            response = (
+                self.service.files()
+                .list(q=query, pageSize=page_size, fields=fields, pageToken=page_token)
+                .execute()
+            )
+            yield from response.get("files", [])
+            page_token = response.get("nextPageToken")
+            if not page_token:
+                break
+
+    @wrap_http_errors
+    def upload_file(
+        self,
+        local_path: Union[str, Path],
+        parent_id: Optional[str] = None,
+        name: Optional[str] = None,
+    ) -> dict:
+        local_path = Path(local_path)
+        metadata: dict = {"name": name or local_path.name}
+        if parent_id:
+            metadata["parents"] = [parent_id]
+        media = MediaFileUpload(str(local_path), resumable=True)
+        return (
+            self.service.files()
+            .create(body=metadata, media_body=media, fields="id, name, webViewLink")
+            .execute()
+        )
+
+    @wrap_http_errors
+    def download_file(self, file_id: str, destination: Union[str, Path]) -> Path:
+        destination = Path(destination)
+        request = self.service.files().get_media(fileId=file_id)
+        with destination.open("wb") as fh:
+            downloader = MediaIoBaseDownload(fh, request)
+            done = False
+            while not done:
+                _, done = downloader.next_chunk()
+        return destination
+
+    @wrap_http_errors
+    def create_folder(self, name: str, parent_id: Optional[str] = None) -> dict:
+        metadata: dict = {"name": name, "mimeType": "application/vnd.google-apps.folder"}
+        if parent_id:
+            metadata["parents"] = [parent_id]
+        return self.service.files().create(body=metadata, fields="id, name").execute()
+
+    @wrap_http_errors
+    def delete_file(self, file_id: str) -> None:
+        self.service.files().delete(fileId=file_id).execute()
+
+    @wrap_http_errors
+    def share_file(self, file_id: str, email: str, role: str = "reader") -> dict:
+        """role: 'reader', 'commenter', or 'writer'."""
+        permission = {"type": "user", "role": role, "emailAddress": email}
+        return (
+            self.service.permissions()
+            .create(fileId=file_id, body=permission, fields="id")
+            .execute()
+        )

selander_bridge/exceptions.py

@@ -0,0 +1,13 @@
+"""Exceptions raised by selander_bridge."""
+
+
+class SelanderBridgeError(Exception):
+    """Base class for every error raised by this library."""
+
+
+class AuthenticationError(SelanderBridgeError):
+    """Raised when acquiring or refreshing Google credentials fails."""
+
+
+class MissingClientSecretsError(SelanderBridgeError):
+    """Raised when no client_secrets file/dict was supplied and none can be found."""

selander_bridge-0.1.0.dist-info/METADATA

@@ -0,0 +1,131 @@
+Metadata-Version: 2.4
+Name: selander-bridge
+Version: 0.1.0
+Summary: Reusable bridge between Python apps and Google Workspace APIs (Drive, Contacts, and more)
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: google-api-python-client>=2.100.0
+Requires-Dist: google-auth>=2.23.0
+Requires-Dist: google-auth-oauthlib>=1.1.0
+Requires-Dist: google-auth-httplib2>=0.1.1
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+
+# selander_bridge
+
+A small, reusable Python library that bridges your apps to Google accounts
+and Google Workspace services (Drive, Contacts, more to come) - built once,
+imported everywhere, with **no server you have to host** for auth.
+
+## Why this exists
+
+The standard "web app" OAuth flow needs a permanently running, publicly
+reachable URL to catch Google's redirect. That's the "too much hosting"
+problem. `selander_bridge` defaults to Google's **installed-app / loopback
+flow** instead: a browser opens, you log in, Google redirects to a local
+port that only exists for a few seconds, and the resulting refresh token is
+cached to disk. Every app that imports this library and reuses the same
+`account` key skips the login screen after the first time.
+
+If every account you need belongs to a Workspace domain you administer,
+you can skip browser login entirely with `ServiceAccountAuthManager`
+(domain-wide delegation) — zero hosting, zero interaction.
+
+## Install
+
+```bash
+pip install -e .
+```
+
+(Once you're happy with it, `pip install build twine` and publish it to
+your own PyPI-compatible index or a private Git URL so other projects can
+`pip install` it directly.)
+
+## One-time Google Cloud setup
+
+Before running your code, you must configure a Google Cloud project to get your `client_secret.json` and enable the APIs you plan to use. **If you skip enabling the APIs, your code will crash.**
+
+Please follow our detailed step-by-step guide:
+👉 **[Google Cloud Setup Guide](docs/cloud_setup.md)**
+
+## Usage
+
+```python
+from selander_bridge import (
+    ContactsClient,
+    DriveClient,
+    GoogleAuthManager,
+    SCOPE_CONTACTS,
+)
+
+auth = GoogleAuthManager(
+    client_secrets_file="client_secret.json",
+    scopes=[*ContactsClient.scopes, *DriveClient.scopes, SCOPE_CONTACTS],
+)
+
+# First call opens a browser once; after that, the cached token is reused.
+contacts = ContactsClient(auth, account="me@gmail.com")
+for person in contacts.list_contacts():
+    print(person.get("names"))
+
+created = contacts.create_contact(
+    given_name="Ada",
+    family_name="Lovelace",
+    email="ada@example.com",
+)
+
+contacts.update_contact(
+    created["resourceName"],
+    body={"names": [{"givenName": "Ada", "familyName": "Byron"}]},
+    update_person_fields="names",
+)
+
+contacts.delete_contact(created["resourceName"])
+
+drive = DriveClient(auth, account="me@gmail.com")
+drive.upload_file("report.pdf", name="Q2 Report.pdf")
+```
+
+Use a different `account` string per Google account you need to talk to —
+each gets its own cached token under `~/.selander_bridge/tokens/`.
+
+## Extending to more Workspace APIs
+
+Every wrapper follows the same shape. To add Calendar, Sheets, Gmail, etc.,
+copy `drive.py` as a template:
+
+```python
+from .base import BaseService, wrap_http_errors
+
+class CalendarClient(BaseService):
+    api_name = "calendar"
+    api_version = "v3"
+    scopes = ("https://www.googleapis.com/auth/calendar.readonly",)
+
+    @wrap_http_errors
+    def list_events(self, calendar_id="primary", max_results=50):
+        resp = self.service.events().list(
+            calendarId=calendar_id, maxResults=max_results
+        ).execute()
+        return resp.get("items", [])
+```
+
+Then export it from `selander_bridge/__init__.py`.
+
+## Project layout
+
+```
+selander_bridge/
+├── pyproject.toml
+├── README.md
+├── src/selander_bridge/
+│   ├── __init__.py     # public exports
+│   ├── auth.py         # GoogleAuthManager, ServiceAccountAuthManager, TokenStore
+│   ├── base.py         # BaseService (shared plumbing), wrap_http_errors
+│   ├── contacts.py     # ContactsClient (People API)
+│   ├── drive.py        # DriveClient
+│   └── exceptions.py
+└── tests/
+    └── test_imports.py
+```

selander_bridge-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+selander_bridge/__init__.py,sha256=tHhIZHlBREiooEMT25Z3TK8-zgnSInxfZfxBfLXMXl0,1750
+selander_bridge/auth.py,sha256=Vu-gfAI5_R7bmqtXrJ0HU8qs_ubayFYeW0_Oll989gg,8319
+selander_bridge/base.py,sha256=c1kHQB2LUxoxEzyhBKvDYTQ4RrO8u7tcnO-4n9pkYBI,1705
+selander_bridge/contacts.py,sha256=aCNaYB9w6VstrGYk3BsaHBvv-gynSaW1Ya-sRPMX3SU,4142
+selander_bridge/drive.py,sha256=CHLMh2JkmObk6fa11vaae87T50dQih-DSa2QI284Zzs,3467
+selander_bridge/exceptions.py,sha256=LzJ6tbRtc4W1V4T_INIsafnXRUgHeXUqb12JxtVNmQM,409
+selander_bridge-0.1.0.dist-info/METADATA,sha256=TOoKzuzQ7Y8KY8naHUtLAXSzg_BPwfbqJpDwz3nPAKs,4232
+selander_bridge-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+selander_bridge-0.1.0.dist-info/top_level.txt,sha256=PItKrMh-i4H6JzfBUkHJQn9hzf1BrXfzzSD7SsBRPMI,16
+selander_bridge-0.1.0.dist-info/RECORD,,

selander_bridge-0.1.0.dist-info/WHEEL

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

selander_bridge-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+selander_bridge