okb 1.0.0__py3-none-any.whl

okb/tokens.py

@@ -0,0 +1,277 @@
+"""Token management for HTTP authentication.
+
+Token format: okb_<database>_<ro|rw>_<random16hex>
+Example: okb_personal_ro_a1b2c3d4e5f6g7h8
+
+Tokens are stored hashed (SHA256) in the database for security.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import re
+import secrets
+from dataclasses import dataclass
+from datetime import datetime
+
+import psycopg
+from psycopg.rows import dict_row
+
+
+@dataclass
+class TokenInfo:
+    """Information about a token."""
+
+    token_hash: str
+    database: str
+    permissions: str  # 'ro' or 'rw'
+    description: str | None
+    created_at: datetime
+    last_used_at: datetime | None
+
+
+# Token format regex: okb_<database>_<ro|rw>_<hex16>
+TOKEN_PATTERN = re.compile(r"^okb_([a-z0-9_-]+)_(ro|rw)_([a-f0-9]{16})$")
+
+
+def generate_token(database: str, permissions: str = "rw") -> str:
+    """Generate a new token for a database.
+
+    Args:
+        database: Database name (must be alphanumeric with _ or -)
+        permissions: 'ro' for read-only, 'rw' for read-write
+
+    Returns:
+        Token string like 'okb_personal_ro_a1b2c3d4e5f6g7h8'
+    """
+    if permissions not in ("ro", "rw"):
+        raise ValueError("permissions must be 'ro' or 'rw'")
+    if not re.match(r"^[a-z0-9_-]+$", database):
+        raise ValueError("database name must be lowercase alphanumeric with _ or -")
+
+    random_part = secrets.token_hex(8)  # 16 hex chars
+    return f"okb_{database}_{permissions}_{random_part}"
+
+
+def hash_token(token: str) -> str:
+    """Hash a token using SHA256.
+
+    Args:
+        token: Full token string
+
+    Returns:
+        Hex-encoded SHA256 hash
+    """
+    return hashlib.sha256(token.encode()).hexdigest()
+
+
+def parse_token(token: str) -> tuple[str, str] | None:
+    """Parse a token to extract database and permissions.
+
+    Args:
+        token: Full token string
+
+    Returns:
+        Tuple of (database, permissions) or None if invalid format
+    """
+    if not token:
+        return None
+    match = TOKEN_PATTERN.match(token)
+    if match:
+        return (match.group(1), match.group(2))
+    return None
+
+
+def create_token(
+    db_url: str,
+    database: str,
+    permissions: str = "rw",
+    description: str | None = None,
+) -> str:
+    """Create a new token and store its hash in the database.
+
+    Args:
+        db_url: Database connection URL
+        database: Database name for the token
+        permissions: 'ro' or 'rw'
+        description: Optional description for the token
+
+    Returns:
+        The plaintext token (only returned once, not stored)
+
+    Raises:
+        RuntimeError: If token could not be saved to database
+    """
+    token = generate_token(database, permissions)
+    token_hash = hash_token(token)
+
+    try:
+        with psycopg.connect(db_url) as conn:
+            conn.execute(
+                """
+                INSERT INTO tokens (token_hash, permissions, description)
+                VALUES (%s, %s, %s)
+                """,
+                (token_hash, permissions, description),
+            )
+            conn.commit()
+    except psycopg.Error as e:
+        raise RuntimeError(f"Failed to save token to database: {e}") from e
+
+    return token
+
+
+def list_tokens(db_url: str) -> list[TokenInfo]:
+    """List all tokens in a database (without the actual token values).
+
+    Args:
+        db_url: Database connection URL
+
+    Returns:
+        List of TokenInfo objects
+
+    Raises:
+        RuntimeError: If database connection fails
+    """
+    # Extract database name from URL for display
+    from urllib.parse import urlparse
+
+    parsed = urlparse(db_url)
+    db_name = parsed.path.lstrip("/") or "default"
+
+    try:
+        with psycopg.connect(db_url, row_factory=dict_row) as conn:
+            results = conn.execute(
+                """
+                SELECT token_hash, permissions, description, created_at, last_used_at
+                FROM tokens
+                ORDER BY created_at DESC
+                """
+            ).fetchall()
+
+            return [
+                TokenInfo(
+                    token_hash=r["token_hash"],
+                    database=db_name,
+                    permissions=r["permissions"],
+                    description=r["description"],
+                    created_at=r["created_at"],
+                    last_used_at=r["last_used_at"],
+                )
+                for r in results
+            ]
+    except psycopg.OperationalError as e:
+        raise RuntimeError(
+            f"Failed to connect to database. Ensure the database is running: {e}"
+        ) from e
+
+
+def delete_token(db_url: str, token_or_prefix: str) -> bool:
+    """Delete a token by full token or prefix.
+
+    Args:
+        db_url: Database connection URL
+        token_or_prefix: Full token or token prefix (e.g., 'lkb_personal_ro')
+
+    Returns:
+        True if token was deleted, False if not found
+    """
+    with psycopg.connect(db_url) as conn:
+        # If it looks like a full token, hash and delete by hash
+        if TOKEN_PATTERN.match(token_or_prefix):
+            token_hash = hash_token(token_or_prefix)
+            result = conn.execute(
+                "DELETE FROM tokens WHERE token_hash = %s RETURNING token_hash",
+                (token_hash,),
+            ).fetchone()
+            conn.commit()
+            return result is not None
+
+        # Otherwise, delete by prefix match on the hash
+        # Since we can't reconstruct the token from the hash, we need to
+        # match by the prefix pattern in a different way.
+        # For prefix deletion, we'll use LIKE on the token_hash which won't work...
+        # Actually, we need to store a prefix or identifier separately.
+        # For now, return False for prefix-based deletion - full token required.
+
+        # Alternative: store token_prefix in the tokens table
+        # For this implementation, we'll just return False if not a full token
+        return False
+
+
+def verify_token(token: str, get_db_url_fn) -> TokenInfo | None:
+    """Verify a token and return its info if valid.
+
+    Args:
+        token: Full token string
+        get_db_url_fn: Function that takes a database name and returns its URL
+
+    Returns:
+        TokenInfo if valid, None if invalid
+    """
+    parsed = parse_token(token)
+    if not parsed:
+        return None
+
+    database, permissions = parsed
+    token_hash = hash_token(token)
+
+    try:
+        db_url = get_db_url_fn(database)
+    except ValueError:
+        return None
+
+    try:
+        with psycopg.connect(db_url, row_factory=dict_row) as conn:
+            result = conn.execute(
+                """
+                SELECT token_hash, permissions, description, created_at, last_used_at
+                FROM tokens
+                WHERE token_hash = %s
+                """,
+                (token_hash,),
+            ).fetchone()
+
+            if not result:
+                return None
+
+            # Update last_used_at
+            conn.execute(
+                "UPDATE tokens SET last_used_at = NOW() WHERE token_hash = %s",
+                (token_hash,),
+            )
+            conn.commit()
+
+            return TokenInfo(
+                token_hash=result["token_hash"],
+                database=database,
+                permissions=result["permissions"],
+                description=result["description"],
+                created_at=result["created_at"],
+                last_used_at=result["last_used_at"],
+            )
+    except Exception:
+        return None
+
+
+class OKBTokenVerifier:
+    """Token verifier for HTTP middleware integration."""
+
+    def __init__(self, get_db_url_fn):
+        """Initialize the verifier.
+
+        Args:
+            get_db_url_fn: Function that takes a database name and returns its URL
+        """
+        self.get_db_url_fn = get_db_url_fn
+
+    def verify(self, token: str) -> TokenInfo | None:
+        """Verify a token and return its info if valid.
+
+        Args:
+            token: Full token string (without 'Bearer ' prefix)
+
+        Returns:
+            TokenInfo if valid, None if invalid
+        """
+        return verify_token(token, self.get_db_url_fn)

okb-1.0.0.dist-info/METADATA

@@ -0,0 +1,397 @@
+Metadata-Version: 2.3
+Name: okb
+Version: 1.0.0
+Summary: Personal knowledge base with semantic search for LLMs
+Requires-Python: >=3.11
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Provides-Extra: all
+Provides-Extra: dev
+Provides-Extra: docx
+Provides-Extra: llm
+Provides-Extra: llm-bedrock
+Provides-Extra: pdf
+Provides-Extra: web
+Requires-Dist: PyGithub (>=2.0.0)
+Requires-Dist: anthropic (>=0.40.0) ; extra == "all"
+Requires-Dist: anthropic (>=0.40.0) ; extra == "llm"
+Requires-Dist: anthropic (>=0.40.0) ; extra == "llm-bedrock"
+Requires-Dist: boto3 (>=1.28.0) ; extra == "llm-bedrock"
+Requires-Dist: botocore (>=1.31.0) ; extra == "llm-bedrock"
+Requires-Dist: click (>=8.0.0)
+Requires-Dist: dropbox (>=12.0.0)
+Requires-Dist: einops (>=0.7.0)
+Requires-Dist: mcp (>=1.0.0)
+Requires-Dist: modal (>=1.0.0)
+Requires-Dist: pgvector (>=0.2.0)
+Requires-Dist: psycopg[binary] (>=3.1.0)
+Requires-Dist: pymupdf (>=1.23.0) ; extra == "all"
+Requires-Dist: pymupdf (>=1.23.0) ; extra == "pdf"
+Requires-Dist: pytest (>=7.0.0) ; extra == "dev"
+Requires-Dist: python-docx (>=1.1.0) ; extra == "all"
+Requires-Dist: python-docx (>=1.1.0) ; extra == "docx"
+Requires-Dist: pyyaml (>=6.0)
+Requires-Dist: ruff (>=0.1.0) ; extra == "dev"
+Requires-Dist: sentence-transformers (>=2.2.0)
+Requires-Dist: trafilatura (>=1.6.0) ; extra == "all"
+Requires-Dist: trafilatura (>=1.6.0) ; extra == "web"
+Requires-Dist: watchdog (>=3.0.0)
+Requires-Dist: yoyo-migrations (>=8.0.0)
+Description-Content-Type: text/markdown
+
+# Owned Knowledge Base (OKB)
+
+A local-first semantic search system for personal documents with Claude Code integration via MCP.
+
+## Installation
+
+```bash
+pip install okb
+```
+
+Or from source:
+```bash
+git clone https://github.com/yourusername/okb
+cd okb
+pip install -e .
+```
+
+## Quick Start
+
+```bash
+# 1. Start the database
+okb db start
+
+# 2. (Optional) Deploy Modal embedder for faster batch ingestion
+okb modal deploy
+
+# 3. Ingest your documents
+okb ingest ~/notes ~/docs
+
+# 4. Configure Claude Code MCP (see below)
+```
+
+## CLI Commands
+
+| Command | Description |
+|---------|-------------|
+| `okb db start` | Start pgvector database container |
+| `okb db stop` | Stop database container |
+| `okb db status` | Show database status |
+| `okb db destroy` | Remove container and volume (destructive) |
+| `okb ingest <paths>` | Ingest documents into knowledge base |
+| `okb ingest <paths> --local` | Ingest using CPU embedding (no Modal) |
+| `okb serve` | Start MCP server (stdio, for Claude Code) |
+| `okb serve --http` | Start HTTP MCP server with token auth |
+| `okb watch <paths>` | Watch directories for changes |
+| `okb config init` | Create default config file |
+| `okb config show` | Show current configuration |
+| `okb modal deploy` | Deploy GPU embedder to Modal |
+| `okb token create` | Create API token for HTTP server |
+| `okb token list` | List tokens for a database |
+| `okb token revoke` | Revoke an API token |
+| `okb sync list` | List available API sources (plugins) |
+| `okb sync run <sources>` | Sync data from external APIs |
+| `okb sync status` | Show last sync times |
+| `okb rescan` | Check indexed files for changes, re-ingest stale |
+| `okb rescan --dry-run` | Show what would change without executing |
+| `okb rescan --delete` | Also remove documents for missing files |
+| `okb llm status` | Show LLM config and connectivity |
+| `okb llm deploy` | Deploy Modal LLM for open model inference |
+| `okb llm clear-cache` | Clear LLM response cache |
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│                         INGESTION (Burst GPU)                       │
+│                                                                     │
+│  Local Files → Contextual Chunking → Modal (GPU T4) → pgvector     │
+│                                                                     │
+│  ~/notes/project-x/api-design.md                                   │
+│       ↓                                                             │
+│  "Document: API Design Notes                                        │
+│   Project: project-x                                                │
+│   Section: Authentication                                           │
+│   Content: Use JWT tokens with..."                                  │
+│       ↓                                                             │
+│  [0.23, -0.41, 0.87, ...]  → pgvector                              │
+└─────────────────────────────────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────────────────────────────┐
+│                      RETRIEVAL (Always-on, Local)                   │
+│                                                                     │
+│  Claude Code → MCP Server → CPU Embedding → pgvector → Results     │
+│                                                                     │
+│  "How do I handle auth?"                                            │
+│       ↓                                                             │
+│  [0.19, -0.38, 0.91, ...]  (local CPU, ~300ms)                     │
+│       ↓                                                             │
+│  Cosine similarity search → Top 5 chunks with context              │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+## Configuration
+
+Configuration is loaded from `~/.config/okb/config.yaml` (or `$XDG_CONFIG_HOME/okb/config.yaml`).
+
+Create default config:
+```bash
+okb config init
+```
+
+Example config:
+```yaml
+databases:
+  personal:
+    url: postgresql://knowledge:localdev@localhost:5433/personal_kb
+    default: true    # Used when --db not specified (only one can be default)
+    managed: true    # okb manages via Docker
+  work:
+    url: postgresql://knowledge:localdev@localhost:5433/work_kb
+    managed: true
+
+docker:
+  port: 5433
+  container_name: okb-pgvector
+
+chunking:
+  chunk_size: 512
+  chunk_overlap: 64
+```
+
+Use `--db <name>` to target a specific database with any command.
+
+Environment variables override config file settings:
+- `KB_DATABASE_URL` - Database connection string
+- `OKB_DOCKER_PORT` - Docker port mapping
+- `OKB_CONTAINER_NAME` - Docker container name
+
+### Project-Local Config
+
+Override global config per-project with `.okbconf.yaml` (searched from CWD upward):
+
+```yaml
+# .okbconf.yaml
+default_database: work  # Use 'work' db in this project
+
+extensions:
+  skip_directories:     # Extends global list
+    - test_fixtures
+```
+
+Merge: scalars replace, lists extend, dicts deep-merge.
+
+### LLM Integration (Optional)
+
+Enable LLM-based document classification and filtering:
+
+```yaml
+llm:
+  provider: claude          # "claude", "modal", or null (disabled)
+  model: claude-haiku-4-5-20251001
+  timeout: 30
+  cache_responses: true
+```
+
+**Providers:**
+| Provider | Setup | Cost |
+|----------|-------|------|
+| `claude` | `export ANTHROPIC_API_KEY=...` | ~$0.25/1M tokens |
+| `modal` | `okb llm deploy` | ~$0.02/min GPU |
+
+For Modal (no API key needed):
+```yaml
+llm:
+  provider: modal
+  model: meta-llama/Llama-3.2-3B-Instruct
+```
+
+**Pre-ingest filtering** - skip low-value content during sync:
+```yaml
+plugins:
+  sources:
+    dropbox-paper:
+      llm_filter:
+        enabled: true
+        prompt: "Skip meeting notes and drafts"
+        action_on_skip: discard  # or "archive"
+```
+
+CLI commands:
+```bash
+okb llm status              # Show config and connectivity
+okb llm deploy              # Deploy Modal LLM (for provider: modal)
+okb llm clear-cache         # Clear response cache
+```
+
+## Claude Code MCP Config
+
+### stdio mode (default)
+
+Add to your Claude Code MCP configuration:
+
+```json
+{
+  "mcpServers": {
+    "knowledge-base": {
+      "command": "okb",
+      "args": ["serve"]
+    }
+  }
+}
+```
+
+### HTTP mode (for remote/shared servers)
+
+First, start the HTTP server and create a token:
+
+```bash
+# Create a token
+okb token create --db default -d "Claude Code"
+# Output: okb_default_rw_a1b2c3d4e5f6g7h8
+
+# Start HTTP server
+okb serve --http --host 0.0.0.0 --port 8080
+```
+
+Then configure Claude Code to connect via SSE:
+
+```json
+{
+  "mcpServers": {
+    "knowledge-base": {
+      "type": "sse",
+      "url": "http://localhost:8080/sse",
+      "headers": {
+        "Authorization": "Bearer okb_default_rw_a1b2c3d4e5f6g7h8"
+      }
+    }
+  }
+}
+```
+
+## MCP Tools (Available in Claude Code)
+
+| Tool | Purpose |
+|------|---------|
+| `search_knowledge` | Semantic search with natural language queries |
+| `keyword_search` | Exact keyword/symbol matching |
+| `hybrid_search` | Combined semantic + keyword (RRF fusion) |
+| `get_document` | Retrieve full document by path |
+| `list_sources` | Show indexed document stats |
+| `list_projects` | List known projects |
+| `recent_documents` | Show recently indexed files |
+| `save_knowledge` | Save knowledge from Claude for future reference |
+| `delete_knowledge` | Delete a Claude-saved knowledge entry |
+| `get_actionable_items` | Query tasks/events with structured filters |
+
+## Contextual Chunking
+
+Documents are chunked with context for better retrieval:
+
+```
+Document: Django Performance Notes
+Project: student-app          ← inferred from path or frontmatter
+Section: Query Optimization   ← extracted from markdown headers
+Topics: django, performance   ← from frontmatter tags
+Content: Use `select_related()` to avoid N+1 queries...
+```
+
+### Frontmatter Example
+
+```markdown
+---
+tags: [django, postgresql, performance]
+project: student-app
+category: backend
+---
+
+# Query Optimization
+
+Use `select_related()` for foreign keys...
+```
+
+## Cost Estimate
+
+| Component | Local | Cloud Alternative |
+|-----------|-------|-------------------|
+| pgvector | $0 | ~$15-30/mo (CloudSQL) |
+| MCP Server | $0 | ~$5/mo (small VM) |
+| Modal embedding | ~$0.50-2/mo | N/A |
+| **Total** | **~$1-2/mo** | **~$20-35/mo** |
+
+## Development
+
+```bash
+# Install dev dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Lint and format
+ruff check . && ruff format .
+```
+
+## Plugin System
+
+OKB supports plugins for custom file parsers and API data sources (GitHub, Todoist, etc).
+
+### Creating a Plugin
+
+```python
+# File parser plugin
+from okb.plugins import FileParser, Document
+
+class EpubParser:
+    extensions = ['.epub']
+    source_type = 'epub'
+
+    def can_parse(self, path): return path.suffix.lower() == '.epub'
+    def parse(self, path, extra_metadata=None) -> Document: ...
+
+# API source plugin
+from okb.plugins import APISource, SyncState, Document
+
+class GitHubSource:
+    name = 'github'
+    source_type = 'github-issue'
+
+    def configure(self, config): ...
+    def fetch(self, state: SyncState | None) -> tuple[list[Document], SyncState]: ...
+```
+
+### Registering Plugins
+
+In your plugin's `pyproject.toml`:
+```toml
+[project.entry-points."okb.parsers"]
+epub = "okb_epub:EpubParser"
+
+[project.entry-points."okb.sources"]
+github = "okb_github:GitHubSource"
+```
+
+### Configuring API Sources
+
+```yaml
+# ~/.config/okb/config.yaml
+plugins:
+  sources:
+    github:
+      enabled: true
+      token: ${GITHUB_TOKEN}  # Resolved from environment
+      repos: [owner/repo1, owner/repo2]
+    dropbox-paper:
+      enabled: true
+      token: ${DROPBOX_TOKEN}
+      folders: [/]            # Optional: filter to specific folders
+```
+
+## License
+
+MIT
+

okb-1.0.0.dist-info/RECORD

@@ -0,0 +1,36 @@
+okb/__init__.py,sha256=2yaWIYQbho7N2O2zwTn3ZH11b8b3SaoDVlxluVTqwy4,92
+okb/cli.py,sha256=KZ8LmzHYiD19NZtrTx7UoFeiH4MMFZX621gs5JElLc4,43663
+okb/config.py,sha256=DKmX2fgteGdh0QMsA-Immu-mZcvLjHWeB8HIf9rcM5o,22898
+okb/data/init.sql,sha256=QpsicUN7PQ7d8zyOCRNChOu5XKdUVC3xySlRDPyKSN8,2728
+okb/http_server.py,sha256=H8AvsRiStxupr-KnXrIlHnoRtqeA-2SgphVgGAOnqmQ,18673
+okb/ingest.py,sha256=D5plxCC2tQXZenMNUa482dUDqsyuaq2APAQqaIgRAqU,54505
+okb/llm/__init__.py,sha256=4jelqgXvF-eEPyLCuAmcxagN0H923wI9pBJJZKv4r0E,2368
+okb/llm/base.py,sha256=gOm7zBiNdHrj7xxJfpb-4qZdYxWM0lA0vKfrBStO60E,2279
+okb/llm/cache.py,sha256=rxRPMNBtP336MSpGWA8F7rDZnF0O2RM3rEsNtoxS0Zk,6142
+okb/llm/filter.py,sha256=y20bc3vHtp5gj7T7AhsJ45ZkAkBgztj6WPjsVAmvEeo,5447
+okb/llm/providers.py,sha256=AdVw9FFgv58-KJEfXv9JqWlkxBl-LcRWOao95CsjqWA,9718
+okb/local_embedder.py,sha256=zzjBUFp4IH2xsvKyKjKZyX9dJuE_3PDMHMwpyRYSISQ,2098
+okb/mcp_server.py,sha256=95e1wEtan0UrzQveCNNyhHXvtpZ18nDsxfaCKYJeX1I,50701
+okb/migrate.py,sha256=2faYL-SHiQCkGXpTUlBFMCj0B-6JYCHqZl9u6vOlui8,1693
+okb/migrations/0001.initial-schema.sql,sha256=0s5pj9Ad6f0u_mxODAM_-DbDI3aI37Wdu5XMPAzAIqw,2577
+okb/migrations/0002.sync-state.sql,sha256=w34dOA9sPg60NMS1aHvOhORff1k_Di9cO2ghwVQSPHU,696
+okb/migrations/0003.structured-fields.sql,sha256=rPCSrdtotCoRpOfjHf1Ifx0pfizpYS9n4MD4CHxrv_c,1225
+okb/migrations/0004.tokens.sql,sha256=VtcLfA1_SVVQLkEKZ-av_93Fg0ksVWLm1tlR7nJXoaQ,448
+okb/migrations/0005.database-metadata.sql,sha256=0X4LyuUUX34s3ph2C70FnBBau5HEBwR4xyY-hwPEX90,709
+okb/migrations/0006.llm-cache.sql,sha256=azjPpj00WH_8tx4JI8PJKZ1AOAJEhbkneVvYa3ZRZ1w,493
+okb/modal_embedder.py,sha256=V1cpGWrtEo1MGkrD9Nc-5wRmf9e7IwKPsQj7nVuLlyg,3469
+okb/modal_llm.py,sha256=4rYE3VZ_T09HXCgTIYFLu1s_C2FRC9y4dgMUGqJuO2M,5368
+okb/plugins/__init__.py,sha256=50LNAH4bvfIw5CHT82sknGjdCldQ-4ds0wxo1zM9E2k,324
+okb/plugins/base.py,sha256=6TIN1UIItmuIsP4NDJhuRMH0ngKkQiGmtHTeYj1K8OU,3171
+okb/plugins/registry.py,sha256=fN7NfoOaRnMyXSWT2srd6vEr4riJjmncQFfberf0IE8,3741
+okb/plugins/sources/__init__.py,sha256=CTqgfRXCHWjKiQS0dpx2jRXj98ogcBClNORfVQwzL0I,143
+okb/plugins/sources/dropbox_paper.py,sha256=YdNDkMEsaKz7pDfwfirwApg2v3Ub-GsbgWkSm9E4Yi0,6144
+okb/plugins/sources/github.py,sha256=ozdTZPkU8h2-ZIx5o1FB58QBZ6P0eoVntluWL3vG87I,16309
+okb/rescan.py,sha256=dVdQEkVUjsrtOKAGZc0LC2uwcnkjB8hn2SOVWHnY-R8,8396
+okb/scripts/__init__.py,sha256=HPp8YCtIeo9XMOtOGCtntiwYr9eCxAJ1MF9Lo9WVzUA,53
+okb/scripts/watch.py,sha256=b8oGPTN3flNdNQJETeqQ1RNZ8U1LiKvHntLwvHRIviA,6354
+okb/tokens.py,sha256=JJ1C-mvtnT2O0cmjSu57PI9Nt53Sl9DqbmPuLnHlN6g,8043
+okb-1.0.0.dist-info/METADATA,sha256=NVrVwX-U0Nj5qYks0w-UJNoDsiBPFth_J6oxzwftCBM,12002
+okb-1.0.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+okb-1.0.0.dist-info/entry_points.txt,sha256=P2XvigL7DxPy8F5KvgRilX2G_rRh14bI9hyJpGgi80Y,180
+okb-1.0.0.dist-info/RECORD,,