pdsx 0.0.1a1__py3-none-any.whl

pdsx/__init__.py

@@ -0,0 +1,7 @@
+"""pdsx - general-purpose cli for atproto record operations."""
+
+from __future__ import annotations
+
+__version__ = "0.0.0"
+
+__all__ = ["__version__"]

pdsx/_internal/__init__.py

@@ -0,0 +1 @@
+"""internal utilities for pdsx."""

pdsx/_internal/auth.py

@@ -0,0 +1,62 @@
+"""authentication utilities for atproto."""
+
+from __future__ import annotations
+
+import logging
+import sys
+from typing import TYPE_CHECKING
+
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+if TYPE_CHECKING:
+    from atproto import AsyncClient
+
+console = Console()
+
+# silence httpx logs
+logging.getLogger("httpx").setLevel(logging.CRITICAL)
+
+
+async def login(
+    client: AsyncClient,
+    handle: str | None = None,
+    password: str | None = None,
+    *,
+    silent: bool = False,
+    required: bool = True,
+) -> bool:
+    """authenticate with atproto.
+
+    Args:
+        client: atproto client to authenticate
+        handle: user handle
+        password: user password
+        silent: suppress authentication output
+        required: whether authentication is required
+
+    Returns:
+        True if authenticated, False if skipped (when not required)
+    """
+    if not handle or not password:
+        if required:
+            console.print(
+                "[red]error:[/red] provide --handle/--password or set ATPROTO_HANDLE/ATPROTO_PASSWORD"
+            )
+            sys.exit(1)
+        return False
+
+    if not silent:
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[dim]{task.description}"),
+            console=console,
+            transient=True,
+        ) as progress:
+            progress.add_task("authenticating...", total=None)
+            await client.login(handle, password)
+        console.print(f"[dim]✓ authenticated as[/dim] {handle}\n")
+    else:
+        await client.login(handle, password)
+
+    return True

pdsx/_internal/config.py

@@ -0,0 +1,32 @@
+"""configuration management for pdsx."""
+
+from __future__ import annotations
+
+import warnings
+from pathlib import Path
+
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+# suppress pydantic warning about Field defaults
+warnings.filterwarnings(
+    "ignore", category=UserWarning, module="pydantic._internal._generate_schema"
+)
+
+
+class Settings(BaseSettings):
+    """settings for atproto cli."""
+
+    model_config = SettingsConfigDict(
+        env_file=str(Path.cwd() / ".env"),
+        env_file_encoding="utf-8",
+        extra="ignore",
+        case_sensitive=False,
+    )
+
+    atproto_pds_url: str = Field(default="https://bsky.social")
+    atproto_handle: str = Field(default="")
+    atproto_password: str = Field(default="")
+
+
+settings = Settings()

pdsx/_internal/display.py

@@ -0,0 +1,161 @@
+"""display utilities for rich output."""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING
+
+from atproto_client.models.dot_dict import DotDict
+from pydantic import BaseModel
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from pdsx._internal.output import OutputFormat
+
+if TYPE_CHECKING:
+    from atproto import models
+
+console = Console()
+
+
+def _value_to_dict(value: object) -> dict[str, object]:
+    """convert a record value to a dict, handling pydantic models and DotDict."""
+    if isinstance(value, BaseModel):
+        return value.model_dump(mode="json")
+    if isinstance(value, DotDict):
+        return value.to_dict()
+    if isinstance(value, dict):
+        return dict(value)
+    # fallback for unknown types
+    return {k: v for k, v in value.__dict__.items() if not k.startswith("_")}
+
+
+def display_records(
+    collection: str,
+    records: list[models.ComAtprotoRepoListRecords.Record],
+    *,
+    output_format: OutputFormat,
+) -> None:
+    """display a list of records.
+
+    Args:
+        collection: collection name
+        records: list of record objects
+        output_format: output format enum
+    """
+    if not records:
+        if output_format != OutputFormat.JSON:
+            print(f"no records in {collection}")
+        return
+
+    # json output
+    if output_format == OutputFormat.JSON:
+        output = []
+        for record in records:
+            rkey = record.uri.split("/")[-1]
+            value_dict = _value_to_dict(record.value)
+            output.append(
+                {
+                    "rkey": rkey,
+                    "uri": record.uri,
+                    "cid": record.cid,
+                    **value_dict,
+                }
+            )
+        print(json.dumps(output, indent=2))
+        return
+
+    # compact output (one line per record)
+    if output_format == OutputFormat.COMPACT:
+        count = len(records)
+        plural = "record" if count == 1 else "records"
+        print(f"{collection} ({count} {plural})")
+        for record in records:
+            rkey = record.uri.split("/")[-1]
+            value_dict = _value_to_dict(record.value)
+            print(f"{rkey}: {json.dumps(value_dict, separators=(',', ':'))}")
+        return
+
+    # rich table output (default) - show only simple fields, truncate long text
+    count = len(records)
+    plural = "record" if count == 1 else "records"
+    table = Table(
+        title=f"{collection} ({count} {plural})",
+        show_header=True,
+        header_style="bold cyan",
+        show_lines=False,
+    )
+    table.add_column("rkey", style="dim", width=13, no_wrap=True)
+
+    # only show simple (non-dict, non-list) fields in table view
+    if records:
+        first_value = records[0].value
+        value_dict = _value_to_dict(first_value)
+
+        for key, val in value_dict.items():
+            if key not in ("$type", "py_type") and not isinstance(val, dict | list):
+                # special handling for text fields - give them more width
+                width = 50 if key == "text" else 20
+                table.add_column(
+                    key,
+                    style="white",
+                    no_wrap=True,
+                    overflow="ellipsis",
+                    max_width=width,
+                )
+
+    for record in records:
+        rkey = record.uri.split("/")[-1]
+        value_dict = _value_to_dict(record.value)
+
+        row = [rkey]
+        for key, val in value_dict.items():
+            if key not in ("$type", "py_type") and not isinstance(val, dict | list):
+                cell_val = str(val) if val is not None else ""
+                row.append(cell_val)
+
+        table.add_row(*row)
+
+    console.print(table)
+
+
+def display_record(response: models.ComAtprotoRepoGetRecord.Response) -> None:
+    """display a single record in a panel.
+
+    Args:
+        response: atproto record response
+    """
+    table = Table(show_header=False, box=None)
+    table.add_column("key", style="cyan")
+    table.add_column("value", style="white")
+
+    table.add_row("uri", response.uri)
+    table.add_row("cid", response.cid)
+
+    value_dict = _value_to_dict(response.value)
+    for key, val in value_dict.items():
+        if key not in ("$type", "py_type"):
+            table.add_row(key, str(val))
+
+    console.print(Panel(table, title="[bold]record[/bold]", border_style="dim"))
+
+
+def display_success(operation: str, uri: str, cid: str, collection: str = "") -> None:
+    """display a success message.
+
+    Args:
+        operation: operation performed (created, updated, deleted)
+        uri: record uri
+        cid: record cid
+        collection: optional collection name
+    """
+    title = f"[bold]{collection}[/bold]" if collection else ""
+    content = f"[green]✓[/green] {operation}"
+
+    if uri:
+        content += f"\n\n[dim]uri:[/dim] {uri}"
+    if cid:
+        content += f"\n[dim]cid:[/dim] {cid}"
+
+    console.print(Panel(content, title=title, border_style="green"))

pdsx/_internal/operations.py

@@ -0,0 +1,203 @@
+"""atproto record operations."""
+
+from __future__ import annotations
+
+import sys
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING
+
+if sys.version_info >= (3, 11):
+    from datetime import UTC
+else:
+    UTC = timezone.utc
+
+if TYPE_CHECKING:
+    from atproto import AsyncClient, models
+
+from pdsx._internal.types import RecordValue
+
+
+async def list_records(
+    client: AsyncClient,
+    collection: str,
+    limit: int,
+    repo: str | None = None,
+) -> list[models.ComAtprotoRepoListRecords.Record]:
+    """list records in a collection.
+
+    Args:
+        client: authenticated atproto client
+        collection: collection name
+        limit: maximum number of records
+        repo: optional repo DID (defaults to authenticated user)
+
+    Returns:
+        list of records
+    """
+    target_repo = repo or (client.me.did if client.me else None)
+    if not target_repo:
+        raise ValueError("no repo specified and not authenticated")
+
+    response = await client.com.atproto.repo.list_records(
+        {
+            "repo": target_repo,
+            "collection": collection,
+            "limit": limit,
+        }
+    )
+
+    return response.records
+
+
+async def get_record(
+    client: AsyncClient,
+    uri: str,
+) -> models.ComAtprotoRepoGetRecord.Response:
+    """get a specific record.
+
+    Args:
+        client: authenticated atproto client
+        uri: record AT-URI
+
+    Returns:
+        record response
+    """
+    parts = uri.replace("at://", "").split("/")
+    if len(parts) != 3:
+        raise ValueError(f"invalid URI format: {uri}")
+
+    repo, collection, rkey = parts
+
+    return await client.com.atproto.repo.get_record(
+        {
+            "repo": repo,
+            "collection": collection,
+            "rkey": rkey,
+        }
+    )
+
+
+async def create_record(
+    client: AsyncClient,
+    collection: str,
+    record: dict[str, RecordValue],
+) -> models.ComAtprotoRepoCreateRecord.Response:
+    """create a new record.
+
+    Args:
+        client: authenticated atproto client
+        collection: collection name
+        record: record data
+
+    Returns:
+        created record response
+    """
+    if client.me is None:
+        raise ValueError("not authenticated")
+
+    # ensure $type is set
+    if "$type" not in record:
+        record["$type"] = collection
+
+    # add createdAt if not present
+    if "createdAt" not in record:
+        record["createdAt"] = datetime.now(UTC).isoformat().replace("+00:00", "Z")
+
+    return await client.com.atproto.repo.create_record(
+        {
+            "repo": client.me.did,
+            "collection": collection,
+            "record": record,
+        }
+    )
+
+
+async def update_record(
+    client: AsyncClient,
+    uri: str,
+    updates: dict[str, RecordValue],
+) -> models.ComAtprotoRepoPutRecord.Response:
+    """update an existing record.
+
+    Args:
+        client: authenticated atproto client
+        uri: record AT-URI (can be shorthand like 'collection/rkey' if authenticated)
+        updates: fields to update
+
+    Returns:
+        updated record response
+    """
+    # strip at:// prefix if present
+    uri_without_prefix = uri.replace("at://", "")
+    parts = uri_without_prefix.split("/")
+
+    # if shorthand format (collection/rkey), use authenticated user's DID
+    if len(parts) == 2:
+        if not client.me:
+            raise ValueError("shorthand URI requires authentication")
+        repo = client.me.did
+        collection, rkey = parts
+    elif len(parts) == 3:
+        repo, collection, rkey = parts
+    else:
+        raise ValueError(f"invalid URI format: {uri}")
+
+    # get current
+    current = await client.com.atproto.repo.get_record(
+        {
+            "repo": repo,
+            "collection": collection,
+            "rkey": rkey,
+        }
+    )
+
+    # merge
+    if isinstance(current.value, dict):
+        updated_value = {**current.value, **updates}
+    else:
+        updated_value = dict(current.value)
+        updated_value.update(updates)
+
+    # put
+    return await client.com.atproto.repo.put_record(
+        {
+            "repo": repo,
+            "collection": collection,
+            "rkey": rkey,
+            "record": updated_value,
+        }
+    )
+
+
+async def delete_record(
+    client: AsyncClient,
+    uri: str,
+) -> None:
+    """delete a record.
+
+    Args:
+        client: authenticated atproto client
+        uri: record AT-URI (can be shorthand like 'collection/rkey' if authenticated)
+    """
+    # strip at:// prefix if present
+    uri_without_prefix = uri.replace("at://", "")
+    parts = uri_without_prefix.split("/")
+
+    # if shorthand format (collection/rkey), use authenticated user's DID
+    if len(parts) == 2:
+        if not client.me:
+            raise ValueError("shorthand URI requires authentication")
+        repo = client.me.did
+        collection, rkey = parts
+    elif len(parts) == 3:
+        repo, collection, rkey = parts
+    else:
+        raise ValueError(f"invalid URI format: {uri}")
+
+    await client.com.atproto.repo.delete_record(
+        {
+            "repo": repo,
+            "collection": collection,
+            "rkey": rkey,
+        }
+    )

pdsx/_internal/output.py

@@ -0,0 +1,20 @@
+"""output formatting utilities."""
+
+from __future__ import annotations
+
+import sys
+from enum import Enum
+
+
+class OutputFormat(str, Enum):
+    """output format options following kubectl/gh conventions."""
+
+    JSON = "json"
+    YAML = "yaml"
+    TABLE = "table"  # rich table (default for TTY)
+    COMPACT = "compact"  # one-line per record
+
+
+def is_tty() -> bool:
+    """check if stdout is a terminal."""
+    return sys.stdout.isatty()

pdsx/_internal/parsing.py

@@ -0,0 +1,47 @@
+"""argument parsing utilities."""
+
+from __future__ import annotations
+
+import sys
+from typing import Any
+
+from rich.console import Console
+
+console = Console()
+
+
+def parse_key_value_args(args: list[str]) -> dict[str, Any]:
+    """parse key=value arguments into a dict.
+
+    Args:
+        args: list of key=value strings
+
+    Returns:
+        parsed dictionary
+
+    Examples:
+        >>> parse_key_value_args(["name=test", "count=5", "active=true"])
+        {'name': 'test', 'count': 5, 'active': True}
+    """
+    result: dict[str, Any] = {}
+    for arg in args:
+        if "=" not in arg:
+            console.print(f"[red]error:[/red] invalid argument format: {arg}")
+            console.print("[dim]use key=value format[/dim]")
+            sys.exit(1)
+        key, value = arg.split("=", 1)
+        # try to parse as json primitives
+        if value.lower() == "true":
+            result[key] = True
+        elif value.lower() == "false":
+            result[key] = False
+        elif value.lower() == "null":
+            result[key] = None
+        elif value.isdigit():
+            result[key] = int(value)
+        else:
+            try:
+                result[key] = float(value)
+            except ValueError:
+                result[key] = value
+    return result

pdsx/_internal/types.py

@@ -0,0 +1,5 @@
+"""type aliases for pdsx."""
+
+from __future__ import annotations
+
+RecordValue = str | int | float | bool | None

pdsx/cli.py

@@ -0,0 +1,223 @@
+"""general-purpose cli for atproto record operations."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import sys
+import warnings
+from typing import NoReturn
+
+# suppress pydantic warnings from atproto library
+warnings.filterwarnings("ignore", category=UserWarning, module="pydantic")
+
+from atproto import AsyncClient  # noqa: E402
+
+from pdsx._internal.auth import login  # noqa: E402
+from pdsx._internal.config import settings  # noqa: E402
+from pdsx._internal.display import (  # noqa: E402
+    console,
+    display_record,
+    display_records,
+    display_success,
+)
+from pdsx._internal.operations import (  # noqa: E402
+    create_record,
+    delete_record,
+    get_record,
+    list_records,
+    update_record,
+)
+from pdsx._internal.output import OutputFormat  # noqa: E402
+from pdsx._internal.parsing import parse_key_value_args  # noqa: E402
+from pdsx._internal.types import RecordValue  # noqa: E402
+
+
+async def cmd_list(
+    client: AsyncClient,
+    collection: str,
+    limit: int,
+    repo: str | None = None,
+    output_format: OutputFormat | None = None,
+) -> None:
+    """list records in a collection."""
+    records = await list_records(client, collection, limit, repo)
+
+    # determine output format - default to compact (most readable for most data)
+    fmt = output_format or OutputFormat.COMPACT
+
+    display_records(collection, records, output_format=fmt)
+
+
+async def cmd_get(client: AsyncClient, uri: str) -> None:
+    """get a specific record."""
+    response = await get_record(client, uri)
+    display_record(response)
+
+
+async def cmd_create(
+    client: AsyncClient,
+    collection: str,
+    record: dict[str, RecordValue],
+) -> None:
+    """create a new record."""
+    response = await create_record(client, collection, record)
+    display_success("created", response.uri, response.cid, collection)
+
+
+async def cmd_update(
+    client: AsyncClient,
+    uri: str,
+    updates: dict[str, RecordValue],
+) -> None:
+    """update an existing record."""
+    response = await update_record(client, uri, updates)
+    display_success("updated", response.uri, response.cid)
+
+
+async def cmd_delete(client: AsyncClient, uri: str) -> None:
+    """delete a record."""
+    await delete_record(client, uri)
+    display_success("deleted", "", "")
+
+
+async def async_main() -> int:
+    """main entry point."""
+    parser = argparse.ArgumentParser(
+        description="atproto record operations",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+
+    # version flag
+    parser.add_argument(
+        "-v",
+        "--version",
+        action="version",
+        version=f"pdsx {__import__('pdsx').__version__}",
+    )
+
+    # global identity flag - can be handle or DID
+    parser.add_argument(
+        "-r",
+        "--repo",
+        help="handle or DID to operate on (for reads without auth, or to specify target repo)",
+    )
+
+    # auth options (only needed for writes to your own repo)
+    parser.add_argument("--handle", help="atproto handle for authentication")
+    parser.add_argument("--password", help="atproto password for authentication")
+    parser.add_argument("--pds", help="pds url (default: https://bsky.social)")
+
+    subparsers = parser.add_subparsers(dest="command", help="command")
+
+    # list (ls alias)
+    list_parser = subparsers.add_parser("list", aliases=["ls"], help="list records")
+    list_parser.add_argument(
+        "collection", help="collection name (e.g., app.bsky.feed.post)"
+    )
+    list_parser.add_argument("--limit", type=int, default=50, help="max records")
+    list_parser.add_argument(
+        "-o",
+        "--output",
+        choices=["json", "yaml", "table", "compact"],
+        help="output format (default: compact)",
+    )
+
+    # get (cat alias)
+    get_parser = subparsers.add_parser("get", aliases=["cat"], help="get record")
+    get_parser.add_argument("uri", help="record AT-URI")
+
+    # create (touch/add aliases)
+    create_parser = subparsers.add_parser(
+        "create", aliases=["touch", "add"], help="create record"
+    )
+    create_parser.add_argument("collection", help="collection name")
+    create_parser.add_argument(
+        "fields",
+        nargs="+",
+        help="record fields as key=value pairs (e.g., title='My Song' artist='Artist')",
+    )
+
+    # update (edit alias)
+    update_parser = subparsers.add_parser(
+        "update", aliases=["edit"], help="update record"
+    )
+    update_parser.add_argument("uri", help="record AT-URI")
+    update_parser.add_argument(
+        "fields", nargs="+", help="fields to update as key=value pairs"
+    )
+
+    # delete (rm alias)
+    delete_parser = subparsers.add_parser(
+        "delete", aliases=["rm"], help="delete record"
+    )
+    delete_parser.add_argument("uri", help="record AT-URI")
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        return 1
+
+    # update pds if provided
+    if args.pds:
+        settings.atproto_pds_url = args.pds
+
+    try:
+        client = AsyncClient(base_url=settings.atproto_pds_url)
+
+        # determine if auth is needed
+        # reads with --repo don't need auth, writes always need auth
+        read_commands = ("list", "ls", "get", "cat")
+        is_read = args.command in read_commands
+        has_repo_target = args.repo is not None
+
+        # auth required if: doing a write operation OR doing a read without --repo
+        auth_needed = not is_read or not has_repo_target
+
+        await login(
+            client,
+            args.handle or settings.atproto_handle,
+            args.password or settings.atproto_password,
+            silent=True,
+            required=auth_needed,
+        )
+
+        if args.command in ("list", "ls"):
+            output_fmt = OutputFormat(args.output) if args.output else None
+            await cmd_list(
+                client,
+                args.collection,
+                args.limit,
+                args.repo,
+                output_format=output_fmt,
+            )
+
+        elif args.command in ("get", "cat"):
+            await cmd_get(client, args.uri)
+
+        elif args.command in ("create", "touch", "add"):
+            record = parse_key_value_args(args.fields)
+            await cmd_create(client, args.collection, record)
+
+        elif args.command in ("update", "edit"):
+            updates = parse_key_value_args(args.fields)
+            await cmd_update(client, args.uri, updates)
+
+        elif args.command in ("delete", "rm"):
+            await cmd_delete(client, args.uri)
+
+        return 0
+
+    except Exception as e:
+        console.print(f"[red]error:[/red] {e}")
+        import os
+
+        if os.getenv("DEBUG"):
+            raise
+        return 1
+
+
+def main() -> NoReturn:
+    """synchronous entry point."""
+    sys.exit(asyncio.run(async_main()))

pdsx-0.0.1a1.dist-info/METADATA

@@ -0,0 +1,201 @@
+Metadata-Version: 2.4
+Name: pdsx
+Version: 0.0.1a1
+Summary: general-purpose cli for atproto record operations
+Author-email: zzstoatzz <thrast36@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: atproto,bluesky,cli,pds,records
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: atproto>=0.0.63
+Requires-Dist: pydantic-settings>=2.7.0
+Requires-Dist: rich>=13.0.0
+Description-Content-Type: text/markdown
+
+# pdsx
+
+general-purpose cli for atproto record operations
+
+## installation
+
+```bash
+uv add pdsx
+# or
+uvx pdsx --help
+```
+
+## quick start
+
+set your credentials:
+
+```bash
+export ATPROTO_HANDLE=your.handle
+export ATPROTO_PASSWORD=your-password
+```
+
+list posts (compact format by default):
+
+```bash
+pdsx ls app.bsky.feed.post --limit 10
+```
+
+json output for jq:
+
+```bash
+pdsx ls app.bsky.feed.post -o json | jq '.[].text'
+```
+
+table view:
+
+```bash
+pdsx ls app.bsky.feed.post -o table
+```
+
+## features
+
+- crud operations for atproto records (list, get, create, update, delete)
+- multiple output formats: compact (default), json, yaml, table
+- unix-style command aliases: `ls`, `cat`, `rm`, `edit`, `touch`/`add`
+- clean json output for jq/pipe interoperability
+- tty-aware formatting
+- type-safe with strict typing
+- python 3.10+ support
+
+## usage
+
+### list records
+
+```bash
+# using full command
+pdsx list app.bsky.feed.post --limit 5
+
+# using alias
+pdsx ls app.bsky.feed.post --limit 5 -o json
+```
+
+### get a record
+
+```bash
+# using full command
+pdsx get at://did:plc:example/app.bsky.feed.post/123
+
+# using alias
+pdsx cat at://did:plc:example/app.bsky.feed.post/123
+```
+
+### create a record
+
+```bash
+pdsx create app.bsky.feed.like subject='at://...' createdAt='2024-01-01T00:00:00Z'
+
+# using alias
+pdsx touch app.bsky.feed.like subject='at://...' createdAt='2024-01-01T00:00:00Z'
+```
+
+### update a record
+
+```bash
+pdsx update at://did:plc:example/app.bsky.feed.post/123 text='updated text'
+
+# using alias
+pdsx edit at://did:plc:example/app.bsky.feed.post/123 text='updated text'
+```
+
+### delete a record
+
+```bash
+pdsx delete at://did:plc:example/app.bsky.feed.post/123
+
+# using alias
+pdsx rm at://did:plc:example/app.bsky.feed.post/123
+```
+
+## output formats
+
+### compact (default)
+
+one line per record with json:
+
+```
+app.bsky.feed.post (3 records)
+3m4ryxwq5dt2i: {"created_at":"2025-11-04T07:25:17.061883+00:00","text":"..."}
+3m4ryxvw4l32z: {"created_at":"2025-11-04T07:25:16.201083+00:00","text":"..."}
+```
+
+### json
+
+clean json for piping to jq:
+
+```bash
+pdsx ls app.bsky.feed.post -o json | jq '.[].text'
+```
+
+### table
+
+pretty table for terminal viewing:
+
+```bash
+pdsx ls app.bsky.feed.post -o table
+```
+
+## examples
+
+<details>
+<summary>click to see real-world examples</summary>
+
+### read anyone's bio
+```bash
+uvx pdsx --repo did:plc:o53crari67ge7bvbv273lxln list app.bsky.actor.profile -o json | \
+  jq -r '.[0].description'
+```
+
+### update your bio
+```bash
+export ATPROTO_HANDLE=your.handle ATPROTO_PASSWORD=your-password
+uvx pdsx edit app.bsky.actor.profile/self description='new bio'
+```
+
+### read anyone's posts
+```bash
+uvx pdsx -r did:plc:o53crari67ge7bvbv273lxln list app.bsky.feed.post --limit 5 -o json | \
+  jq -r '.[] | .text'
+```
+
+**atproto gives you full read access to anyone's public data. auth only required for writes.**
+
+</details>
+
+## development
+
+```bash
+# clone repo
+git clone https://github.com/zzstoatzz/pdsx
+cd pdsx
+
+# install with dev dependencies
+uv sync
+
+# run tests
+uv run pytest
+
+# run type checker
+uv run ty check
+
+# run pre-commit hooks
+uv run prek run --all-files
+```
+
+## license
+
+mit

pdsx-0.0.1a1.dist-info/RECORD

@@ -0,0 +1,16 @@
+pdsx/__init__.py,sha256=gqc9TP1TpNH5uqkHqkQXIHZ4Sr10buEXAz4Onu5MD6A,150
+pdsx/cli.py,sha256=xxxlWebKrBDHeiZ-ZACb-EEPk1-BNZDrWIPYbZiOlB4,6754
+pdsx/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pdsx/_internal/__init__.py,sha256=jx0usJBkEhxakUqVLoMuqqe-eiFWaDFjIP0Q34eNpdk,35
+pdsx/_internal/auth.py,sha256=dhyV4VJ_JWVtEZMwHbk4thvs12dV6fK9n8pUYmqxNtg,1610
+pdsx/_internal/config.py,sha256=rWUPBiOWGzKkm66zvohDmXAqFCf4DXDLA1FvBwyoKsM,793
+pdsx/_internal/display.py,sha256=9SWRu9cNfBGNfFkwqI_lwYm2ZJclm6_ysbxuuuSdFq4,4987
+pdsx/_internal/operations.py,sha256=_JpqLJd2x6S-rgPwmZfqaH5k5BweRJN0A6O839_oArg,5107
+pdsx/_internal/output.py,sha256=Z10r3NplKpa4Zh5KRfJcjdZYuihmpGyYZfB5-F6mWqk,436
+pdsx/_internal/parsing.py,sha256=47zjcR2w1_HBRX-fRc6PxoN3VkOAUoDPd_yj2zYF9So,1268
+pdsx/_internal/types.py,sha256=tXvphASiX0H0_4HGYImQnQs8G7Q-Z2javBKQiOk_Ieg,112
+pdsx-0.0.1a1.dist-info/METADATA,sha256=2e2mXPh6d15tOTzhuhH-5JIC9qTUOdykefAjUtrQNPE,4070
+pdsx-0.0.1a1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pdsx-0.0.1a1.dist-info/entry_points.txt,sha256=FaACMWIJsfvwWA-vu7N-C0gaQ1BMR0IbMMxGpL3s9LA,39
+pdsx-0.0.1a1.dist-info/licenses/LICENSE,sha256=EB-ZSyrRfegHEfc5eLZQLlQhaD7AL9nsrMoR1D8iIGo,1066
+pdsx-0.0.1a1.dist-info/RECORD,,

pdsx-0.0.1a1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pdsx-0.0.1a1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pdsx = pdsx.cli:main

pdsx-0.0.1a1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 zzstoatzz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.