linkedin-post-cli 0.1.0__tar.gz

linkedin_post_cli-0.1.0/.claude/settings.local.json

@@ -0,0 +1,8 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(uv run pytest:*)",
+      "WebSearch"
+    ]
+  }
+}

linkedin_post_cli-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+.env
+__pycache__/
+*.pyc
+.venv/
+dist/
+*.egg-info/
+.pytest_cache/

linkedin_post_cli-0.1.0/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: linkedin-post-cli
+Version: 0.1.0
+Requires-Python: >=3.11
+Requires-Dist: requests

linkedin_post_cli-0.1.0/README.md

@@ -0,0 +1,50 @@
+# linkedin-post-cli
+
+CLI utility for publishing posts to LinkedIn via the official API.
+
+## Install
+
+```bash
+uvx linkedin-post-cli@latest "Hello world!"   # run directly
+uv tool install linkedin-post-cli              # install globally
+```
+
+## Prerequisites
+
+1. Create a LinkedIn app at https://www.linkedin.com/developers/apps/new (requires a Company Page)
+2. Add products: **Sign In with LinkedIn using OpenID Connect** and **Share on LinkedIn**
+3. In **Auth** → Redirect URLs, add: `http://localhost:8000/callback`
+4. Copy `Client ID` and `Client Secret` — you'll be prompted on first run
+
+## Usage
+
+```bash
+# Inline text
+linkedin-post-cli "My first post via API!"
+
+# From file
+linkedin-post-cli --from-file draft.txt
+
+# Interactive input (multiline, Ctrl+D to send)
+linkedin-post-cli
+
+# Visible to connections only
+linkedin-post-cli --connections-only "Private update"
+
+# Attach an image
+linkedin-post-cli --image photo.jpg "Check this out!"
+
+# Re-authorize (clear OAuth token)
+linkedin-post-cli --reset-auth "Hello again"
+
+# Clear all saved credentials
+linkedin-post-cli --reset-keys "Starting over"
+```
+
+On first run, you'll be prompted for Client ID and Client Secret, then a browser window opens for OAuth authorization. Credentials are saved to `~/.config/linkedin-post-cli/config.json`.
+
+## Tests
+
+```bash
+uv run pytest -v
+```

linkedin_post_cli-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "linkedin-post-cli"
+version = "0.1.0"
+requires-python = ">=3.11"
+dependencies = ["requests"]
+
+[project.scripts]
+linkedin-post-cli = "linkedin_post.cli:main"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["tests"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.2",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/linkedin_post"]

linkedin_post_cli-0.1.0/src/linkedin_post/auth.py

@@ -0,0 +1,105 @@
+"""OAuth 2.0 authentication flow for LinkedIn."""
+
+import http.server
+import sys
+import threading
+import urllib.parse
+import webbrowser
+
+import requests
+
+_AUTH_URL = "https://www.linkedin.com/oauth/v2/authorization"
+_TOKEN_URL = "https://www.linkedin.com/oauth/v2/accessToken"
+_USERINFO_URL = "https://api.linkedin.com/v2/userinfo"
+_REDIRECT_URI = "http://localhost:8000/callback"
+_SCOPES = "openid profile w_member_social"
+
+
+def is_token_valid(token: str) -> bool:
+    """Check whether *token* is still accepted by LinkedIn API."""
+    resp = requests.get(
+        _USERINFO_URL,
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=10,
+    )
+    return resp.status_code == 200
+
+
+def authenticate(client_id: str, client_secret: str) -> str:
+    """Run the full OAuth browser flow and return an access token.
+
+    Opens the default browser for user consent, starts a temporary
+    local HTTP server to capture the redirect, and exchanges the
+    authorization code for a token.
+    """
+    auth_code: str | None = None
+    error: str | None = None
+    server_ready = threading.Event()
+
+    class _CallbackHandler(http.server.BaseHTTPRequestHandler):
+        def do_GET(self) -> None:  # noqa: N802
+            nonlocal auth_code, error
+            params = urllib.parse.parse_qs(
+                urllib.parse.urlparse(self.path).query
+            )
+
+            if "code" in params:
+                auth_code = params["code"][0]
+                self._respond("Authorization successful! You can close this tab.")
+            else:
+                error = params.get("error", ["unknown"])[0]
+                self._respond(f"Authorization failed: {error}")
+
+            # Shut down server from a separate thread to avoid deadlock.
+            threading.Thread(target=self.server.shutdown, daemon=True).start()
+
+        def _respond(self, message: str) -> None:
+            self.send_response(200)
+            self.send_header("Content-Type", "text/html; charset=utf-8")
+            self.end_headers()
+            self.wfile.write(
+                f"<html><body><h2>{message}</h2></body></html>".encode()
+            )
+
+        def log_message(self, format: str, *args: object) -> None:  # noqa: A002
+            pass  # silence request logs
+
+    server = http.server.HTTPServer(("localhost", 8000), _CallbackHandler)
+
+    def _serve() -> None:
+        server_ready.set()
+        server.serve_forever()
+
+    thread = threading.Thread(target=_serve, daemon=True)
+    thread.start()
+    server_ready.wait()
+
+    params = urllib.parse.urlencode({
+        "response_type": "code",
+        "client_id": client_id,
+        "redirect_uri": _REDIRECT_URI,
+        "scope": _SCOPES,
+    })
+    authorization_url = f"{_AUTH_URL}?{params}"
+    print(f"Opening browser for authorization...\n{authorization_url}")
+    webbrowser.open(authorization_url)
+
+    thread.join()  # blocks until callback arrives
+
+    if error or auth_code is None:
+        print(f"Authorization failed: {error}", file=sys.stderr)
+        sys.exit(1)
+
+    token_resp = requests.post(
+        _TOKEN_URL,
+        data={
+            "grant_type": "authorization_code",
+            "code": auth_code,
+            "redirect_uri": _REDIRECT_URI,
+            "client_id": client_id,
+            "client_secret": client_secret,
+        },
+        timeout=30,
+    )
+    token_resp.raise_for_status()
+    return token_resp.json()["access_token"]

linkedin_post_cli-0.1.0/src/linkedin_post/cli.py

@@ -0,0 +1,135 @@
+"""CLI entry-point for linkedin-post-cli."""
+
+import argparse
+import pathlib
+import sys
+
+from linkedin_post.auth import authenticate, is_token_valid
+from linkedin_post.client import LinkedInClient
+from linkedin_post.config import ConfigStore, JsonConfigStore, prompt_if_missing
+
+_MAX_LENGTH = 3000
+
+
+def _parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Publish a text post to LinkedIn.",
+    )
+    parser.add_argument("text", nargs="?", help="Post text (inline)")
+    parser.add_argument(
+        "--from-file", type=pathlib.Path, help="Read post text from a file",
+    )
+    parser.add_argument(
+        "--connections-only",
+        action="store_true",
+        help="Visible to 1st-degree connections only (default: public)",
+    )
+    parser.add_argument(
+        "--image",
+        type=pathlib.Path,
+        metavar="PATH",
+        help="Attach an image (jpg/png/gif, max 100 MB)",
+    )
+    parser.add_argument(
+        "--reset-auth",
+        action="store_true",
+        help="Clear saved OAuth token and re-authorize",
+    )
+    parser.add_argument(
+        "--reset-keys",
+        action="store_true",
+        help="Clear all saved credentials and re-prompt from scratch",
+    )
+    return parser.parse_args(argv)
+
+
+def _read_post_text(args: argparse.Namespace) -> str:
+    if args.text:
+        return args.text
+    if args.from_file:
+        return args.from_file.read_text(encoding="utf-8").strip()
+    print("Enter post text (Ctrl+D to send):")
+    return sys.stdin.read().strip()
+
+
+def _ensure_token(
+    config: ConfigStore,
+    client_id: str,
+    client_secret: str,
+    *,
+    force: bool,
+) -> str:
+    """Return a valid access token, running OAuth if needed."""
+    access_token = config.get("access_token")
+
+    if not force and access_token and is_token_valid(access_token):
+        return access_token
+
+    token = authenticate(client_id, client_secret)
+    config.set("access_token", token)
+    return token
+
+
+def main(argv: list[str] | None = None, *, _config: ConfigStore | None = None) -> None:
+    args = _parse_args(argv)
+    config = _config or JsonConfigStore()
+
+    if args.reset_keys:
+        config.remove(["client_id", "client_secret", "access_token"])
+    elif args.reset_auth:
+        config.remove(["access_token"])
+
+    if not config.get("client_id"):
+        print(
+            "\n"
+            "First-time setup\n"
+            "================\n"
+            "You need OAuth 2.0 credentials from the LinkedIn Developer Portal.\n"
+            "\n"
+            "1. Create an app at https://www.linkedin.com/developers/apps/new\n"
+            "   (requires a Company Page)\n"
+            "2. Add products: Sign In with LinkedIn using OpenID Connect\n"
+            "   and Share on LinkedIn\n"
+            "3. In Auth → Redirect URLs, add: http://localhost:8000/callback\n"
+            "4. Copy the Client ID and Client Secret below\n",
+        )
+
+    client_id = prompt_if_missing(config, "client_id", "Client ID")
+    client_secret = prompt_if_missing(config, "client_secret", "Client Secret")
+
+    text = _read_post_text(args)
+    if not text:
+        print("Empty post text, aborting.", file=sys.stderr)
+        sys.exit(1)
+    if len(text) > _MAX_LENGTH:
+        print(
+            f"Post too long: {len(text)}/{_MAX_LENGTH} characters.",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    access_token = _ensure_token(
+        config, client_id, client_secret,
+        force=args.reset_auth,
+    )
+
+    client = LinkedInClient(access_token)
+
+    image_urn = None
+    if args.image:
+        if not args.image.exists():
+            print(f"Image not found: {args.image}", file=sys.stderr)
+            sys.exit(1)
+        try:
+            image_urn = client.upload_image(args.image)
+        except ValueError as exc:
+            print(str(exc), file=sys.stderr)
+            sys.exit(1)
+
+    post_urn = client.create_post(
+        text, connections_only=args.connections_only, image_urn=image_urn,
+    )
+    post_url = f"https://www.linkedin.com/feed/update/{post_urn}/"
+    visibility = "connections only" if args.connections_only else "public"
+    print(f"Post published ({visibility})!")
+    print(post_url)

linkedin_post_cli-0.1.0/src/linkedin_post/client.py

@@ -0,0 +1,141 @@
+"""LinkedIn API client for creating posts."""
+
+import pathlib
+from typing import Protocol
+
+import requests
+
+_BASE_URL = "https://api.linkedin.com"
+_LINKEDIN_VERSION = "202504"
+_SUPPORTED_IMAGE_TYPES = {".jpg", ".jpeg", ".png", ".gif"}
+_MAX_IMAGE_SIZE = 100 * 1024 * 1024  # 100 MB — LinkedIn documented limit
+
+_CONTENT_TYPES = {
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".gif": "image/gif",
+}
+
+
+class LinkedInAPI(Protocol):
+    """Interface for LinkedIn API operations."""
+
+    def get_user_id(self) -> str:
+        """Return the authenticated user's person ID."""
+        ...
+
+    def upload_image(self, path: pathlib.Path) -> str:
+        """Upload an image and return the image URN."""
+        ...
+
+    def create_post(
+        self, text: str, *, connections_only: bool = False, image_urn: str | None = None
+    ) -> str:
+        """Publish a post and return the post URN."""
+        ...
+
+
+class LinkedInClient:
+    """HTTP client for LinkedIn REST API.
+
+    Usage::
+
+        client = LinkedInClient(access_token="...")
+        post_urn = client.create_post("Hello LinkedIn!")
+    """
+
+    def __init__(self, access_token: str) -> None:
+        self._token = access_token
+        self._session = requests.Session()
+        self._session.headers.update({
+            "Authorization": f"Bearer {access_token}",
+        })
+        self._user_id: str | None = None
+
+    def get_user_id(self) -> str:
+        """Return the authenticated user's person ID (``sub`` claim)."""
+        if self._user_id is None:
+            resp = self._session.get(f"{_BASE_URL}/v2/userinfo")
+            resp.raise_for_status()
+            self._user_id = resp.json()["sub"]
+        return self._user_id
+
+    def upload_image(self, path: pathlib.Path) -> str:
+        """Upload an image file and return the image URN.
+
+        Raises ``ValueError`` for unsupported formats or oversized files.
+        """
+        suffix = path.suffix.lower()
+        if suffix not in _SUPPORTED_IMAGE_TYPES:
+            raise ValueError(
+                f"Unsupported image format '{suffix}'. "
+                f"Supported: {', '.join(sorted(_SUPPORTED_IMAGE_TYPES))}"
+            )
+        file_size = path.stat().st_size
+        if file_size > _MAX_IMAGE_SIZE:
+            raise ValueError(
+                f"Image too large: {file_size} bytes "
+                f"(max {_MAX_IMAGE_SIZE} bytes / 100 MB)"
+            )
+
+        owner = f"urn:li:person:{self.get_user_id()}"
+        init_resp = self._session.post(
+            f"{_BASE_URL}/rest/images?action=initializeUpload",
+            json={"initializeUploadRequest": {"owner": owner}},
+            headers={
+                "LinkedIn-Version": _LINKEDIN_VERSION,
+                "X-Restli-Protocol-Version": "2.0.0",
+            },
+        )
+        if not init_resp.ok:
+            raise requests.HTTPError(
+                f"{init_resp.status_code}: {init_resp.text}", response=init_resp
+            )
+        data = init_resp.json()["value"]
+        upload_url = data["uploadUrl"]
+        image_urn = data["image"]
+
+        put_resp = self._session.put(
+            upload_url,
+            data=path.read_bytes(),
+            headers={"Content-Type": _CONTENT_TYPES[suffix]},
+        )
+        if not put_resp.ok:
+            raise requests.HTTPError(
+                f"{put_resp.status_code}: {put_resp.text}", response=put_resp
+            )
+        return image_urn
+
+    def create_post(
+        self, text: str, *, connections_only: bool = False, image_urn: str | None = None
+    ) -> str:
+        """Publish a post, optionally with an image. Returns the created post URN."""
+        author = f"urn:li:person:{self.get_user_id()}"
+        visibility = "CONNECTIONS" if connections_only else "PUBLIC"
+        body: dict = {
+            "author": author,
+            "lifecycleState": "PUBLISHED",
+            "visibility": visibility,
+            "commentary": text,
+            "distribution": {
+                "feedDistribution": "MAIN_FEED",
+                "targetEntities": [],
+                "thirdPartyDistributionChannels": [],
+            },
+        }
+        if image_urn is not None:
+            body["content"] = {"media": {"id": image_urn}}
+        resp = self._session.post(
+            f"{_BASE_URL}/rest/posts",
+            json=body,
+            headers={
+                "LinkedIn-Version": _LINKEDIN_VERSION,
+                "X-Restli-Protocol-Version": "2.0.0",
+            },
+        )
+        if not resp.ok:
+            raise requests.HTTPError(
+                f"{resp.status_code}: {resp.text}", response=resp
+            )
+        return resp.headers.get("x-restli-id", "")

linkedin_post_cli-0.1.0/src/linkedin_post/config.py

@@ -0,0 +1,88 @@
+"""Persistent JSON config store for credentials."""
+
+from __future__ import annotations
+
+import json
+import os
+import pathlib
+import sys
+from typing import Callable, Protocol
+
+_DEFAULT_PATH = pathlib.Path.home() / ".config" / "linkedin-post-cli" / "config.json"
+
+
+class ConfigStore(Protocol):
+    """Read/write access to persistent key-value config."""
+
+    def get(self, key: str) -> str | None: ...
+    def set(self, key: str, value: str) -> None: ...
+    def set_many(self, items: dict[str, str]) -> None: ...
+    def remove(self, keys: list[str]) -> None: ...
+
+
+class JsonConfigStore:
+    """Config store backed by a JSON file (default ``~/.config/linkedin-post-cli/config.json``).
+
+    Creates the directory and file on first write.  Sets ``0o600`` permissions
+    after each write to protect secrets.
+    """
+
+    def __init__(self, path: pathlib.Path = _DEFAULT_PATH) -> None:
+        self._path = path
+
+    def get(self, key: str) -> str | None:
+        data = self._read()
+        return data.get(key)
+
+    def set(self, key: str, value: str) -> None:
+        data = self._read()
+        data[key] = value
+        self._write(data)
+
+    def set_many(self, items: dict[str, str]) -> None:
+        data = self._read()
+        data.update(items)
+        self._write(data)
+
+    def remove(self, keys: list[str]) -> None:
+        data = self._read()
+        for k in keys:
+            data.pop(k, None)
+        self._write(data)
+
+    def _read(self) -> dict[str, str]:
+        if not self._path.exists():
+            return {}
+        return json.loads(self._path.read_text(encoding="utf-8"))
+
+    def _write(self, data: dict[str, str]) -> None:
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        self._path.write_text(
+            json.dumps(data, indent=2) + "\n", encoding="utf-8",
+        )
+        os.chmod(self._path, 0o600)
+
+
+def prompt_if_missing(
+    config: ConfigStore,
+    key: str,
+    display_name: str,
+    *,
+    prompt_fn: Callable[[str], str] | None = None,
+) -> str:
+    """Return the value for *key*, prompting the user if it's not stored yet.
+
+    Saves the prompted value into *config* for next time.
+    Exits if the user provides an empty value.
+    """
+    value = config.get(key)
+    if value:
+        return value
+    _prompt = prompt_fn or input
+    value = _prompt(f"{display_name}: ")
+    if not value or not value.strip():
+        print("Value required. Aborting.", file=sys.stderr)
+        sys.exit(1)
+    value = value.strip()
+    config.set(key, value)
+    return value

linkedin_post_cli-0.1.0/tests/helpers.py

@@ -0,0 +1,25 @@
+"""Shared test utilities."""
+
+
+class DictConfigStore:
+    """In-memory ConfigStore for tests."""
+
+    def __init__(self, data: dict[str, str] | None = None) -> None:
+        self._data: dict[str, str] = dict(data) if data else {}
+
+    def get(self, key: str) -> str | None:
+        return self._data.get(key)
+
+    def set(self, key: str, value: str) -> None:
+        self._data[key] = value
+
+    def set_many(self, items: dict[str, str]) -> None:
+        self._data.update(items)
+
+    def remove(self, keys: list[str]) -> None:
+        for k in keys:
+            self._data.pop(k, None)
+
+    @property
+    def data(self) -> dict[str, str]:
+        return self._data

linkedin_post_cli-0.1.0/tests/test_client.py

@@ -0,0 +1,333 @@
+"""Unit tests for LinkedInClient and CLI."""
+
+import pathlib
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from linkedin_post.cli import main
+from linkedin_post.client import LinkedInClient, _MAX_IMAGE_SIZE
+
+from helpers import DictConfigStore
+
+
+@pytest.fixture
+def client() -> LinkedInClient:
+    return LinkedInClient(access_token="fake-token")
+
+
+class TestGetUserId:
+    def test_returns_sub_from_userinfo(self, client: LinkedInClient) -> None:
+        with patch.object(client._session, "get") as mock_get:
+            mock_get.return_value = _ok_response({"sub": "abc123"})
+            assert client.get_user_id() == "abc123"
+
+    def test_caches_user_id(self, client: LinkedInClient) -> None:
+        with patch.object(client._session, "get") as mock_get:
+            mock_get.return_value = _ok_response({"sub": "abc123"})
+            client.get_user_id()
+            client.get_user_id()
+            mock_get.assert_called_once()
+
+    def test_raises_on_http_error(self, client: LinkedInClient) -> None:
+        with patch.object(client._session, "get") as mock_get:
+            mock_get.return_value = _error_response(401)
+            with pytest.raises(Exception):
+                client.get_user_id()
+
+
+class TestCreatePost:
+    def test_sends_correct_body(self, client: LinkedInClient) -> None:
+        with (
+            patch.object(
+                client._session, "get", return_value=_ok_response({"sub": "u1"})
+            ),
+            patch.object(client._session, "post") as mock_post,
+        ):
+            mock_post.return_value = _created_response("urn:li:share:123")
+            client.create_post("Hello!")
+
+            body = mock_post.call_args.kwargs["json"]
+            assert body["author"] == "urn:li:person:u1"
+            assert body["commentary"] == "Hello!"
+            assert body["lifecycleState"] == "PUBLISHED"
+            assert body["visibility"] == "PUBLIC"
+
+    def test_sends_required_headers(self, client: LinkedInClient) -> None:
+        with (
+            patch.object(
+                client._session, "get", return_value=_ok_response({"sub": "u1"})
+            ),
+            patch.object(client._session, "post") as mock_post,
+        ):
+            mock_post.return_value = _created_response("urn:li:share:123")
+            client.create_post("Hi")
+
+            headers = mock_post.call_args.kwargs["headers"]
+            assert headers["LinkedIn-Version"] == "202504"
+            assert headers["X-Restli-Protocol-Version"] == "2.0.0"
+
+    def test_returns_post_urn(self, client: LinkedInClient) -> None:
+        with (
+            patch.object(
+                client._session, "get", return_value=_ok_response({"sub": "u1"})
+            ),
+            patch.object(client._session, "post") as mock_post,
+        ):
+            mock_post.return_value = _created_response("urn:li:share:456")
+            assert client.create_post("test") == "urn:li:share:456"
+
+    def test_connections_only_sets_visibility(self, client: LinkedInClient) -> None:
+        with (
+            patch.object(
+                client._session, "get", return_value=_ok_response({"sub": "u1"})
+            ),
+            patch.object(client._session, "post") as mock_post,
+        ):
+            mock_post.return_value = _created_response("urn:li:share:789")
+            client.create_post("Private", connections_only=True)
+
+            body = mock_post.call_args.kwargs["json"]
+            assert body["visibility"] == "CONNECTIONS"
+
+    def test_raises_on_api_error(self, client: LinkedInClient) -> None:
+        with (
+            patch.object(
+                client._session, "get", return_value=_ok_response({"sub": "u1"})
+            ),
+            patch.object(client._session, "post") as mock_post,
+        ):
+            mock_post.return_value = _error_response(403)
+            with pytest.raises(Exception):
+                client.create_post("nope")
+
+
+class TestUploadImage:
+    def test_returns_image_urn(self, client: LinkedInClient, tmp_path: pathlib.Path) -> None:
+        img = tmp_path / "photo.png"
+        img.write_bytes(b"\x89PNG" + b"\x00" * 100)
+
+        init_resp = _ok_response({
+            "value": {
+                "uploadUrl": "https://linkedin.com/upload/xyz",
+                "image": "urn:li:image:C123",
+            }
+        })
+        put_resp = MagicMock(ok=True)
+
+        with (
+            patch.object(
+                client._session, "get", return_value=_ok_response({"sub": "u1"})
+            ),
+            patch.object(client._session, "post", return_value=init_resp),
+            patch.object(client._session, "put", return_value=put_resp),
+        ):
+            urn = client.upload_image(img)
+
+        assert urn == "urn:li:image:C123"
+
+    def test_rejects_unsupported_format(
+        self, client: LinkedInClient, tmp_path: pathlib.Path
+    ) -> None:
+        img = tmp_path / "photo.bmp"
+        img.write_bytes(b"\x00" * 10)
+
+        with pytest.raises(ValueError, match="Unsupported image format"):
+            client.upload_image(img)
+
+    def test_rejects_oversized_file(
+        self, client: LinkedInClient, tmp_path: pathlib.Path
+    ) -> None:
+        img = tmp_path / "huge.png"
+        img.write_bytes(b"\x00" * (_MAX_IMAGE_SIZE + 1))
+
+        with pytest.raises(ValueError, match="Image too large"):
+            client.upload_image(img)
+
+    def test_raises_on_init_upload_error(
+        self, client: LinkedInClient, tmp_path: pathlib.Path
+    ) -> None:
+        img = tmp_path / "photo.jpg"
+        img.write_bytes(b"\xff\xd8" + b"\x00" * 100)
+
+        with (
+            patch.object(
+                client._session, "get", return_value=_ok_response({"sub": "u1"})
+            ),
+            patch.object(
+                client._session, "post", return_value=_error_response(500)
+            ),
+        ):
+            with pytest.raises(Exception):
+                client.upload_image(img)
+
+    def test_raises_on_upload_error(
+        self, client: LinkedInClient, tmp_path: pathlib.Path
+    ) -> None:
+        img = tmp_path / "photo.jpg"
+        img.write_bytes(b"\xff\xd8" + b"\x00" * 100)
+
+        init_resp = _ok_response({
+            "value": {
+                "uploadUrl": "https://linkedin.com/upload/xyz",
+                "image": "urn:li:image:C123",
+            }
+        })
+        put_resp = _error_response(500)
+
+        with (
+            patch.object(
+                client._session, "get", return_value=_ok_response({"sub": "u1"})
+            ),
+            patch.object(client._session, "post", return_value=init_resp),
+            patch.object(client._session, "put", return_value=put_resp),
+        ):
+            with pytest.raises(Exception):
+                client.upload_image(img)
+
+
+class TestCreatePostWithImage:
+    def test_includes_image_content_in_body(self, client: LinkedInClient) -> None:
+        with (
+            patch.object(
+                client._session, "get", return_value=_ok_response({"sub": "u1"})
+            ),
+            patch.object(client._session, "post") as mock_post,
+        ):
+            mock_post.return_value = _created_response("urn:li:share:999")
+            client.create_post("With image", image_urn="urn:li:image:C123")
+
+            body = mock_post.call_args.kwargs["json"]
+            assert body["content"] == {"media": {"id": "urn:li:image:C123"}}
+
+    def test_omits_content_when_no_image(self, client: LinkedInClient) -> None:
+        with (
+            patch.object(
+                client._session, "get", return_value=_ok_response({"sub": "u1"})
+            ),
+            patch.object(client._session, "post") as mock_post,
+        ):
+            mock_post.return_value = _created_response("urn:li:share:999")
+            client.create_post("Text only")
+
+            body = mock_post.call_args.kwargs["json"]
+            assert "content" not in body
+
+
+class TestCLIValidation:
+    def test_rejects_text_over_3000_chars(self) -> None:
+        config = DictConfigStore({"client_id": "id", "client_secret": "sec"})
+        long_text = "a" * 3001
+        with pytest.raises(SystemExit):
+            main([long_text], _config=config)
+
+    def test_rejects_empty_text(self) -> None:
+        config = DictConfigStore({"client_id": "id", "client_secret": "sec"})
+        with pytest.raises(SystemExit), patch("sys.stdin") as mock_stdin:
+            mock_stdin.read.return_value = ""
+            main([], _config=config)
+
+    def test_exits_when_credentials_missing(self) -> None:
+        config = DictConfigStore()
+        with pytest.raises(SystemExit), patch("builtins.input", return_value=""):
+            main(["Hello"], _config=config)
+
+    def test_shows_setup_guide_when_credentials_missing(self, capsys: pytest.CaptureFixture[str]) -> None:
+        config = DictConfigStore()
+        with pytest.raises(SystemExit), patch("builtins.input", return_value=""):
+            main(["Hello"], _config=config)
+        assert "First-time setup" in capsys.readouterr().out
+
+
+class TestCLIImage:
+    def test_passes_image_urn_to_create_post(self, tmp_path: pathlib.Path) -> None:
+        img = tmp_path / "pic.png"
+        img.write_bytes(b"\x89PNG" + b"\x00" * 100)
+
+        mock_client = MagicMock()
+        mock_client.upload_image.return_value = "urn:li:image:ABC"
+        mock_client.create_post.return_value = "urn:li:share:999"
+
+        config = DictConfigStore({
+            "client_id": "id", "client_secret": "sec", "access_token": "tok",
+        })
+
+        with (
+            patch("linkedin_post.cli.LinkedInClient", return_value=mock_client),
+            patch("linkedin_post.cli.is_token_valid", return_value=True),
+        ):
+            main(["Hello", "--image", str(img)], _config=config)
+
+        mock_client.upload_image.assert_called_once_with(img)
+        mock_client.create_post.assert_called_once_with(
+            "Hello", connections_only=False, image_urn="urn:li:image:ABC",
+        )
+
+    def test_exits_when_image_not_found(self) -> None:
+        config = DictConfigStore({
+            "client_id": "id", "client_secret": "sec", "access_token": "tok",
+        })
+
+        with (
+            patch("linkedin_post.cli.is_token_valid", return_value=True),
+            pytest.raises(SystemExit),
+        ):
+            main(["Hello", "--image", "/nonexistent/photo.png"], _config=config)
+
+
+class TestCLIResetFlags:
+    def test_reset_keys_clears_all_credentials(self) -> None:
+        config = DictConfigStore({
+            "client_id": "id", "client_secret": "sec", "access_token": "tok",
+        })
+        with pytest.raises(SystemExit), patch("builtins.input", return_value=""):
+            main(["Hello", "--reset-keys"], _config=config)
+        assert config.get("client_id") is None
+        assert config.get("client_secret") is None
+        assert config.get("access_token") is None
+
+    def test_reset_auth_clears_token_only(self) -> None:
+        config = DictConfigStore({
+            "client_id": "id", "client_secret": "sec", "access_token": "tok",
+        })
+        mock_client = MagicMock()
+        mock_client.create_post.return_value = "urn:li:share:1"
+
+        with (
+            patch("linkedin_post.cli.authenticate", return_value="new-tok"),
+            patch("linkedin_post.cli.LinkedInClient", return_value=mock_client),
+        ):
+            main(["Hello", "--reset-auth"], _config=config)
+
+        assert config.get("client_id") == "id"
+        assert config.get("client_secret") == "sec"
+        assert config.get("access_token") == "new-tok"
+
+
+# --- helpers ---
+
+def _ok_response(json_data: dict) -> MagicMock:
+    resp = MagicMock()
+    resp.status_code = 200
+    resp.json.return_value = json_data
+    resp.raise_for_status.return_value = None
+    return resp
+
+
+def _created_response(post_urn: str) -> MagicMock:
+    resp = MagicMock()
+    resp.status_code = 201
+    resp.headers = {"x-restli-id": post_urn}
+    resp.raise_for_status.return_value = None
+    return resp
+
+
+def _error_response(status_code: int) -> MagicMock:
+    from requests.exceptions import HTTPError
+
+    resp = MagicMock()
+    resp.status_code = status_code
+    resp.ok = False
+    resp.text = "error"
+    resp.raise_for_status.side_effect = HTTPError(response=resp)
+    return resp

linkedin_post_cli-0.1.0/tests/test_config.py

@@ -0,0 +1,92 @@
+"""Tests for JsonConfigStore and prompt_if_missing."""
+
+import json
+import os
+import pathlib
+
+import pytest
+
+from linkedin_post.config import JsonConfigStore, prompt_if_missing
+
+from helpers import DictConfigStore
+
+
+# --- JsonConfigStore ---
+
+
+class TestJsonConfigStore:
+    def test_get_returns_none_when_file_missing(self, tmp_path: pathlib.Path) -> None:
+        store = JsonConfigStore(tmp_path / "missing" / "config.json")
+        assert store.get("anything") is None
+
+    def test_set_creates_file_and_dirs(self, tmp_path: pathlib.Path) -> None:
+        path = tmp_path / "sub" / "config.json"
+        store = JsonConfigStore(path)
+        store.set("key", "val")
+        assert path.exists()
+        assert json.loads(path.read_text()) == {"key": "val"}
+
+    def test_set_preserves_existing_keys(self, tmp_path: pathlib.Path) -> None:
+        path = tmp_path / "config.json"
+        store = JsonConfigStore(path)
+        store.set("a", "1")
+        store.set("b", "2")
+        assert json.loads(path.read_text()) == {"a": "1", "b": "2"}
+
+    def test_set_many_writes_multiple_keys(self, tmp_path: pathlib.Path) -> None:
+        path = tmp_path / "config.json"
+        store = JsonConfigStore(path)
+        store.set_many({"x": "10", "y": "20"})
+        assert json.loads(path.read_text()) == {"x": "10", "y": "20"}
+
+    def test_remove_deletes_keys(self, tmp_path: pathlib.Path) -> None:
+        path = tmp_path / "config.json"
+        store = JsonConfigStore(path)
+        store.set_many({"a": "1", "b": "2", "c": "3"})
+        store.remove(["a", "c"])
+        assert json.loads(path.read_text()) == {"b": "2"}
+
+    def test_remove_ignores_missing_keys(self, tmp_path: pathlib.Path) -> None:
+        path = tmp_path / "config.json"
+        store = JsonConfigStore(path)
+        store.set("a", "1")
+        store.remove(["nonexistent"])
+        assert json.loads(path.read_text()) == {"a": "1"}
+
+    def test_file_permissions(self, tmp_path: pathlib.Path) -> None:
+        path = tmp_path / "config.json"
+        store = JsonConfigStore(path)
+        store.set("secret", "value")
+        mode = os.stat(path).st_mode & 0o777
+        assert mode == 0o600
+
+
+# --- prompt_if_missing ---
+
+
+class TestPromptIfMissing:
+    def test_returns_existing_value_without_prompting(self) -> None:
+        config = DictConfigStore({"key": "existing"})
+        called = False
+
+        def fake_prompt(_msg: str) -> str:
+            nonlocal called
+            called = True
+            return "new"
+
+        result = prompt_if_missing(config, "key", "Key", prompt_fn=fake_prompt)
+        assert result == "existing"
+        assert not called
+
+    def test_prompts_and_saves_when_missing(self) -> None:
+        config = DictConfigStore()
+        result = prompt_if_missing(
+            config, "key", "Key", prompt_fn=lambda _: "user-input",
+        )
+        assert result == "user-input"
+        assert config.get("key") == "user-input"
+
+    def test_exits_on_empty_input(self) -> None:
+        config = DictConfigStore()
+        with pytest.raises(SystemExit):
+            prompt_if_missing(config, "key", "Key", prompt_fn=lambda _: "")

linkedin_post_cli-0.1.0/uv.lock

@@ -0,0 +1,198 @@
+version = 1
+revision = 3
+requires-python = ">=3.11"
+
+[[package]]
+name = "certifi"
+version = "2026.1.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e0/2d/a891ca51311197f6ad14a7ef42e2399f36cf2f9bd44752b3dc4eab60fdc5/certifi-2026.1.4.tar.gz", hash = "sha256:ac726dd470482006e014ad384921ed6438c457018f4b3d204aea4281258b2120", size = 154268, upload-time = "2026-01-04T02:42:41.825Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e6/ad/3cc14f097111b4de0040c83a525973216457bbeeb63739ef1ed275c1c021/certifi-2026.1.4-py3-none-any.whl", hash = "sha256:9943707519e4add1115f44c2bc244f782c0249876bf51b6599fee1ffbedd685c", size = 152900, upload-time = "2026-01-04T02:42:40.15Z" },
+]
+
+[[package]]
+name = "charset-normalizer"
+version = "3.4.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/13/69/33ddede1939fdd074bce5434295f38fae7136463422fe4fd3e0e89b98062/charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a", size = 129418, upload-time = "2025-10-14T04:42:32.879Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ed/27/c6491ff4954e58a10f69ad90aca8a1b6fe9c5d3c6f380907af3c37435b59/charset_normalizer-3.4.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6e1fcf0720908f200cd21aa4e6750a48ff6ce4afe7ff5a79a90d5ed8a08296f8", size = 206988, upload-time = "2025-10-14T04:40:33.79Z" },
+    { url = "https://files.pythonhosted.org/packages/94/59/2e87300fe67ab820b5428580a53cad894272dbb97f38a7a814a2a1ac1011/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f819d5fe9234f9f82d75bdfa9aef3a3d72c4d24a6e57aeaebba32a704553aa0", size = 147324, upload-time = "2025-10-14T04:40:34.961Z" },
+    { url = "https://files.pythonhosted.org/packages/07/fb/0cf61dc84b2b088391830f6274cb57c82e4da8bbc2efeac8c025edb88772/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a59cb51917aa591b1c4e6a43c132f0cdc3c76dbad6155df4e28ee626cc77a0a3", size = 142742, upload-time = "2025-10-14T04:40:36.105Z" },
+    { url = "https://files.pythonhosted.org/packages/62/8b/171935adf2312cd745d290ed93cf16cf0dfe320863ab7cbeeae1dcd6535f/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8ef3c867360f88ac904fd3f5e1f902f13307af9052646963ee08ff4f131adafc", size = 160863, upload-time = "2025-10-14T04:40:37.188Z" },
+    { url = "https://files.pythonhosted.org/packages/09/73/ad875b192bda14f2173bfc1bc9a55e009808484a4b256748d931b6948442/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d9e45d7faa48ee908174d8fe84854479ef838fc6a705c9315372eacbc2f02897", size = 157837, upload-time = "2025-10-14T04:40:38.435Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/fc/de9cce525b2c5b94b47c70a4b4fb19f871b24995c728e957ee68ab1671ea/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:840c25fb618a231545cbab0564a799f101b63b9901f2569faecd6b222ac72381", size = 151550, upload-time = "2025-10-14T04:40:40.053Z" },
+    { url = "https://files.pythonhosted.org/packages/55/c2/43edd615fdfba8c6f2dfbd459b25a6b3b551f24ea21981e23fb768503ce1/charset_normalizer-3.4.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ca5862d5b3928c4940729dacc329aa9102900382fea192fc5e52eb69d6093815", size = 149162, upload-time = "2025-10-14T04:40:41.163Z" },
+    { url = "https://files.pythonhosted.org/packages/03/86/bde4ad8b4d0e9429a4e82c1e8f5c659993a9a863ad62c7df05cf7b678d75/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d9c7f57c3d666a53421049053eaacdd14bbd0a528e2186fcb2e672effd053bb0", size = 150019, upload-time = "2025-10-14T04:40:42.276Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/86/a151eb2af293a7e7bac3a739b81072585ce36ccfb4493039f49f1d3cae8c/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:277e970e750505ed74c832b4bf75dac7476262ee2a013f5574dd49075879e161", size = 143310, upload-time = "2025-10-14T04:40:43.439Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/fe/43dae6144a7e07b87478fdfc4dbe9efd5defb0e7ec29f5f58a55aeef7bf7/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:31fd66405eaf47bb62e8cd575dc621c56c668f27d46a61d975a249930dd5e2a4", size = 162022, upload-time = "2025-10-14T04:40:44.547Z" },
+    { url = "https://files.pythonhosted.org/packages/80/e6/7aab83774f5d2bca81f42ac58d04caf44f0cc2b65fc6db2b3b2e8a05f3b3/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:0d3d8f15c07f86e9ff82319b3d9ef6f4bf907608f53fe9d92b28ea9ae3d1fd89", size = 149383, upload-time = "2025-10-14T04:40:46.018Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/e8/b289173b4edae05c0dde07f69f8db476a0b511eac556dfe0d6bda3c43384/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:9f7fcd74d410a36883701fafa2482a6af2ff5ba96b9a620e9e0721e28ead5569", size = 159098, upload-time = "2025-10-14T04:40:47.081Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/df/fe699727754cae3f8478493c7f45f777b17c3ef0600e28abfec8619eb49c/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ebf3e58c7ec8a8bed6d66a75d7fb37b55e5015b03ceae72a8e7c74495551e224", size = 152991, upload-time = "2025-10-14T04:40:48.246Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/86/584869fe4ddb6ffa3bd9f491b87a01568797fb9bd8933f557dba9771beaf/charset_normalizer-3.4.4-cp311-cp311-win32.whl", hash = "sha256:eecbc200c7fd5ddb9a7f16c7decb07b566c29fa2161a16cf67b8d068bd21690a", size = 99456, upload-time = "2025-10-14T04:40:49.376Z" },
+    { url = "https://files.pythonhosted.org/packages/65/f6/62fdd5feb60530f50f7e38b4f6a1d5203f4d16ff4f9f0952962c044e919a/charset_normalizer-3.4.4-cp311-cp311-win_amd64.whl", hash = "sha256:5ae497466c7901d54b639cf42d5b8c1b6a4fead55215500d2f486d34db48d016", size = 106978, upload-time = "2025-10-14T04:40:50.844Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/9d/0710916e6c82948b3be62d9d398cb4fcf4e97b56d6a6aeccd66c4b2f2bd5/charset_normalizer-3.4.4-cp311-cp311-win_arm64.whl", hash = "sha256:65e2befcd84bc6f37095f5961e68a6f077bf44946771354a28ad434c2cce0ae1", size = 99969, upload-time = "2025-10-14T04:40:52.272Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/85/1637cd4af66fa687396e757dec650f28025f2a2f5a5531a3208dc0ec43f2/charset_normalizer-3.4.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0a98e6759f854bd25a58a73fa88833fba3b7c491169f86ce1180c948ab3fd394", size = 208425, upload-time = "2025-10-14T04:40:53.353Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/6a/04130023fef2a0d9c62d0bae2649b69f7b7d8d24ea5536feef50551029df/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b5b290ccc2a263e8d185130284f8501e3e36c5e02750fc6b6bdeb2e9e96f1e25", size = 148162, upload-time = "2025-10-14T04:40:54.558Z" },
+    { url = "https://files.pythonhosted.org/packages/78/29/62328d79aa60da22c9e0b9a66539feae06ca0f5a4171ac4f7dc285b83688/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74bb723680f9f7a6234dcf67aea57e708ec1fbdf5699fb91dfd6f511b0a320ef", size = 144558, upload-time = "2025-10-14T04:40:55.677Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bb/b32194a4bf15b88403537c2e120b817c61cd4ecffa9b6876e941c3ee38fe/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f1e34719c6ed0b92f418c7c780480b26b5d9c50349e9a9af7d76bf757530350d", size = 161497, upload-time = "2025-10-14T04:40:57.217Z" },
+    { url = "https://files.pythonhosted.org/packages/19/89/a54c82b253d5b9b111dc74aca196ba5ccfcca8242d0fb64146d4d3183ff1/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2437418e20515acec67d86e12bf70056a33abdacb5cb1655042f6538d6b085a8", size = 159240, upload-time = "2025-10-14T04:40:58.358Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/10/d20b513afe03acc89ec33948320a5544d31f21b05368436d580dec4e234d/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11d694519d7f29d6cd09f6ac70028dba10f92f6cdd059096db198c283794ac86", size = 153471, upload-time = "2025-10-14T04:40:59.468Z" },
+    { url = "https://files.pythonhosted.org/packages/61/fa/fbf177b55bdd727010f9c0a3c49eefa1d10f960e5f09d1d887bf93c2e698/charset_normalizer-3.4.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ac1c4a689edcc530fc9d9aa11f5774b9e2f33f9a0c6a57864e90908f5208d30a", size = 150864, upload-time = "2025-10-14T04:41:00.623Z" },
+    { url = "https://files.pythonhosted.org/packages/05/12/9fbc6a4d39c0198adeebbde20b619790e9236557ca59fc40e0e3cebe6f40/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:21d142cc6c0ec30d2efee5068ca36c128a30b0f2c53c1c07bd78cb6bc1d3be5f", size = 150647, upload-time = "2025-10-14T04:41:01.754Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/1f/6a9a593d52e3e8c5d2b167daf8c6b968808efb57ef4c210acb907c365bc4/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5dbe56a36425d26d6cfb40ce79c314a2e4dd6211d51d6d2191c00bed34f354cc", size = 145110, upload-time = "2025-10-14T04:41:03.231Z" },
+    { url = "https://files.pythonhosted.org/packages/30/42/9a52c609e72471b0fc54386dc63c3781a387bb4fe61c20231a4ebcd58bdd/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5bfbb1b9acf3334612667b61bd3002196fe2a1eb4dd74d247e0f2a4d50ec9bbf", size = 162839, upload-time = "2025-10-14T04:41:04.715Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/5b/c0682bbf9f11597073052628ddd38344a3d673fda35a36773f7d19344b23/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d055ec1e26e441f6187acf818b73564e6e6282709e9bcb5b63f5b23068356a15", size = 150667, upload-time = "2025-10-14T04:41:05.827Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/24/a41afeab6f990cf2daf6cb8c67419b63b48cf518e4f56022230840c9bfb2/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af2d8c67d8e573d6de5bc30cdb27e9b95e49115cd9baad5ddbd1a6207aaa82a9", size = 160535, upload-time = "2025-10-14T04:41:06.938Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/e5/6a4ce77ed243c4a50a1fecca6aaaab419628c818a49434be428fe24c9957/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:780236ac706e66881f3b7f2f32dfe90507a09e67d1d454c762cf642e6e1586e0", size = 154816, upload-time = "2025-10-14T04:41:08.101Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/ef/89297262b8092b312d29cdb2517cb1237e51db8ecef2e9af5edbe7b683b1/charset_normalizer-3.4.4-cp312-cp312-win32.whl", hash = "sha256:5833d2c39d8896e4e19b689ffc198f08ea58116bee26dea51e362ecc7cd3ed26", size = 99694, upload-time = "2025-10-14T04:41:09.23Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/2d/1e5ed9dd3b3803994c155cd9aacb60c82c331bad84daf75bcb9c91b3295e/charset_normalizer-3.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:a79cfe37875f822425b89a82333404539ae63dbdddf97f84dcbc3d339aae9525", size = 107131, upload-time = "2025-10-14T04:41:10.467Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/d9/0ed4c7098a861482a7b6a95603edce4c0d9db2311af23da1fb2b75ec26fc/charset_normalizer-3.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:376bec83a63b8021bb5c8ea75e21c4ccb86e7e45ca4eb81146091b56599b80c3", size = 100390, upload-time = "2025-10-14T04:41:11.915Z" },
+    { url = "https://files.pythonhosted.org/packages/97/45/4b3a1239bbacd321068ea6e7ac28875b03ab8bc0aa0966452db17cd36714/charset_normalizer-3.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794", size = 208091, upload-time = "2025-10-14T04:41:13.346Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/62/73a6d7450829655a35bb88a88fca7d736f9882a27eacdca2c6d505b57e2e/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed", size = 147936, upload-time = "2025-10-14T04:41:14.461Z" },
+    { url = "https://files.pythonhosted.org/packages/89/c5/adb8c8b3d6625bef6d88b251bbb0d95f8205831b987631ab0c8bb5d937c2/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72", size = 144180, upload-time = "2025-10-14T04:41:15.588Z" },
+    { url = "https://files.pythonhosted.org/packages/91/ed/9706e4070682d1cc219050b6048bfd293ccf67b3d4f5a4f39207453d4b99/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328", size = 161346, upload-time = "2025-10-14T04:41:16.738Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/0d/031f0d95e4972901a2f6f09ef055751805ff541511dc1252ba3ca1f80cf5/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede", size = 158874, upload-time = "2025-10-14T04:41:17.923Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/83/6ab5883f57c9c801ce5e5677242328aa45592be8a00644310a008d04f922/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894", size = 153076, upload-time = "2025-10-14T04:41:19.106Z" },
+    { url = "https://files.pythonhosted.org/packages/75/1e/5ff781ddf5260e387d6419959ee89ef13878229732732ee73cdae01800f2/charset_normalizer-3.4.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1", size = 150601, upload-time = "2025-10-14T04:41:20.245Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/57/71be810965493d3510a6ca79b90c19e48696fb1ff964da319334b12677f0/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490", size = 150376, upload-time = "2025-10-14T04:41:21.398Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/d5/c3d057a78c181d007014feb7e9f2e65905a6c4ef182c0ddf0de2924edd65/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44", size = 144825, upload-time = "2025-10-14T04:41:22.583Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/8c/d0406294828d4976f275ffbe66f00266c4b3136b7506941d87c00cab5272/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133", size = 162583, upload-time = "2025-10-14T04:41:23.754Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/24/e2aa1f18c8f15c4c0e932d9287b8609dd30ad56dbe41d926bd846e22fb8d/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3", size = 150366, upload-time = "2025-10-14T04:41:25.27Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/5b/1e6160c7739aad1e2df054300cc618b06bf784a7a164b0f238360721ab86/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e", size = 160300, upload-time = "2025-10-14T04:41:26.725Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/10/f882167cd207fbdd743e55534d5d9620e095089d176d55cb22d5322f2afd/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc", size = 154465, upload-time = "2025-10-14T04:41:28.322Z" },
+    { url = "https://files.pythonhosted.org/packages/89/66/c7a9e1b7429be72123441bfdbaf2bc13faab3f90b933f664db506dea5915/charset_normalizer-3.4.4-cp313-cp313-win32.whl", hash = "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac", size = 99404, upload-time = "2025-10-14T04:41:29.95Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/26/b9924fa27db384bdcd97ab83b4f0a8058d96ad9626ead570674d5e737d90/charset_normalizer-3.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14", size = 107092, upload-time = "2025-10-14T04:41:31.188Z" },
+    { url = "https://files.pythonhosted.org/packages/af/8f/3ed4bfa0c0c72a7ca17f0380cd9e4dd842b09f664e780c13cff1dcf2ef1b/charset_normalizer-3.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2", size = 100408, upload-time = "2025-10-14T04:41:32.624Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/35/7051599bd493e62411d6ede36fd5af83a38f37c4767b92884df7301db25d/charset_normalizer-3.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd", size = 207746, upload-time = "2025-10-14T04:41:33.773Z" },
+    { url = "https://files.pythonhosted.org/packages/10/9a/97c8d48ef10d6cd4fcead2415523221624bf58bcf68a802721a6bc807c8f/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb", size = 147889, upload-time = "2025-10-14T04:41:34.897Z" },
+    { url = "https://files.pythonhosted.org/packages/10/bf/979224a919a1b606c82bd2c5fa49b5c6d5727aa47b4312bb27b1734f53cd/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e", size = 143641, upload-time = "2025-10-14T04:41:36.116Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/33/0ad65587441fc730dc7bd90e9716b30b4702dc7b617e6ba4997dc8651495/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14", size = 160779, upload-time = "2025-10-14T04:41:37.229Z" },
+    { url = "https://files.pythonhosted.org/packages/67/ed/331d6b249259ee71ddea93f6f2f0a56cfebd46938bde6fcc6f7b9a3d0e09/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191", size = 159035, upload-time = "2025-10-14T04:41:38.368Z" },
+    { url = "https://files.pythonhosted.org/packages/67/ff/f6b948ca32e4f2a4576aa129d8bed61f2e0543bf9f5f2b7fc3758ed005c9/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838", size = 152542, upload-time = "2025-10-14T04:41:39.862Z" },
+    { url = "https://files.pythonhosted.org/packages/16/85/276033dcbcc369eb176594de22728541a925b2632f9716428c851b149e83/charset_normalizer-3.4.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6", size = 149524, upload-time = "2025-10-14T04:41:41.319Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/f2/6a2a1f722b6aba37050e626530a46a68f74e63683947a8acff92569f979a/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e", size = 150395, upload-time = "2025-10-14T04:41:42.539Z" },
+    { url = "https://files.pythonhosted.org/packages/60/bb/2186cb2f2bbaea6338cad15ce23a67f9b0672929744381e28b0592676824/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c", size = 143680, upload-time = "2025-10-14T04:41:43.661Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/a5/bf6f13b772fbb2a90360eb620d52ed8f796f3c5caee8398c3b2eb7b1c60d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090", size = 162045, upload-time = "2025-10-14T04:41:44.821Z" },
+    { url = "https://files.pythonhosted.org/packages/df/c5/d1be898bf0dc3ef9030c3825e5d3b83f2c528d207d246cbabe245966808d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152", size = 149687, upload-time = "2025-10-14T04:41:46.442Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/42/90c1f7b9341eef50c8a1cb3f098ac43b0508413f33affd762855f67a410e/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828", size = 160014, upload-time = "2025-10-14T04:41:47.631Z" },
+    { url = "https://files.pythonhosted.org/packages/76/be/4d3ee471e8145d12795ab655ece37baed0929462a86e72372fd25859047c/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec", size = 154044, upload-time = "2025-10-14T04:41:48.81Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/6f/8f7af07237c34a1defe7defc565a9bc1807762f672c0fde711a4b22bf9c0/charset_normalizer-3.4.4-cp314-cp314-win32.whl", hash = "sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9", size = 99940, upload-time = "2025-10-14T04:41:49.946Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/51/8ade005e5ca5b0d80fb4aff72a3775b325bdc3d27408c8113811a7cbe640/charset_normalizer-3.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c", size = 107104, upload-time = "2025-10-14T04:41:51.051Z" },
+    { url = "https://files.pythonhosted.org/packages/da/5f/6b8f83a55bb8278772c5ae54a577f3099025f9ade59d0136ac24a0df4bde/charset_normalizer-3.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2", size = 100743, upload-time = "2025-10-14T04:41:52.122Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/4c/925909008ed5a988ccbb72dcc897407e5d6d3bd72410d69e051fc0c14647/charset_normalizer-3.4.4-py3-none-any.whl", hash = "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f", size = 53402, upload-time = "2025-10-14T04:42:31.76Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.11"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "linkedin-post-cli"
+version = "0.1.0"
+source = { editable = "." }
+dependencies = [
+    { name = "requests" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "pytest" },
+]
+
+[package.metadata]
+requires-dist = [{ name = "requests" }]
+
+[package.metadata.requires-dev]
+dev = [{ name = "pytest", specifier = ">=9.0.2" }]
+
+[[package]]
+name = "packaging"
+version = "26.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.19.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.0.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" },
+]
+
+[[package]]
+name = "requests"
+version = "2.32.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "charset-normalizer" },
+    { name = "idna" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517, upload-time = "2025-08-18T20:46:02.573Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738, upload-time = "2025-08-18T20:46:00.542Z" },
+]
+
+[[package]]
+name = "urllib3"
+version = "2.6.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556, upload-time = "2026-01-07T16:24:43.925Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" },
+]