magickmind 0.1.1__py3-none-any.whl

magickmind-0.1.1.dist-info/METADATA

@@ -0,0 +1,593 @@
+Metadata-Version: 2.4
+Name: magickmind
+Version: 0.1.1
+Summary: Official Python SDK for the MagickMind AI platform.
+Project-URL: Homepage, https://magickmind.ai/
+Project-URL: Documentation, https://docs.magickmind.ai/
+Project-URL: Repository, https://github.com/General-Magick-Industries/py-magickmind
+Project-URL: Issues, https://github.com/General-Magick-Industries/py-magickmind/issues
+Project-URL: Changelog, https://github.com/General-Magick-Industries/py-magickmind/blob/main/CHANGELOG.md
+Author-email: Adrian <adrian@magickmind.ai>, Minnie <minnie@magickmind.ai>, Turtle <turtle@magickmind.ai>
+License-Expression: MIT
+Keywords: ai,api,client,magickmind,sdk
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: centrifuge-python>=0.4.2
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: jwt>=1.4.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pytest-asyncio>=1.3.0
+Requires-Dist: python-dotenv>=1.2.1
+Provides-Extra: dev
+Requires-Dist: openapi-core>=0.19.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest-mock>=3.12.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Magick Mind SDK
+
+Python SDK for seamless integration with the Magick Mind platform (Bifrost). This SDK provides type-safe, validated access to Bifrost's chat, mindspace, and realtime features.
+
+> [!IMPORTANT]
+> **Backend-Only SDK**  
+> This SDK is designed for **server-side applications only** and requires service-level authentication. It cannot be used directly by end users in browsers or mobile apps.
+> 
+> **Architecture:** End Users → Your Backend (+ SDK) → Bifrost  
+> See [Backend Architecture Guide](docs/architecture/backend_architecture.md) for details.
+
+## Features
+
+- 🔐 **Authentication**: Secure login with email/password
+- 💬 **Chat**: Type-safe chat resource with Pydantic validation
+- 🧠 **Mindspaces**: Manage AI reasoning contexts and conversations  
+- 📡 **Realtime**: WebSocket client for live AI responses with deduplication
+- 🔑 **Typed Resources**: Mindspaces, Projects, Corpus, API Keys, Artifacts, End Users, History
+- ✅ **Validation**: Automatic request/response validation with Pydantic
+- 🎯 **Developer Experience**: Clean, intuitive API design
+- Desktop applications (PyQt, Tkinter, wxPython)
+- CLI tools and automation scripts
+- Server-side scripts
+- **Robotics/IoT (Self-Service)**: Single device authenticates and subscribes to its own channel
+
+**For web/mobile frontends:** If you're building browser-based apps or native mobile apps, you would need JavaScript, Swift, or Kotlin SDKs (not yet available). This Python SDK is for your backend.
+
+**Common architecture:**
+```
+[Your Frontend/App] ←→ [Your Backend + This SDK] ←→ [Bifrost SaaS]
+```
+
+**Robotics/IoT (Self-Service):**
+```
+[Robot/Device with SDK] ←→ [Bifrost SaaS]
+```
+In this pattern, the device authenticates as itself and subscribes to its own channel. See [Event-Driven Patterns](docs/architecture/event_driven_patterns.md#self-service-pattern-roboticsiot) for details.
+
+
+## Installation
+
+Using `uv` (recommended):
+
+```bash
+cd AGD_Magick_Mind_SDK
+uv sync
+```
+
+Using pip:
+
+```bash
+cd AGD_Magick_Mind_SDK
+pip install -e .
+```
+
+## Core Concepts
+
+### Mindspaces: The Central Hub
+
+**Mindspace is the central organizing concept in Bifrost** - it's where conversations, knowledge, and collaboration converge. When designing your application architecture, start by thinking about mindspaces:
+
+- **All chat conversations happen within a mindspace**
+- **Knowledge (corpus) attaches to mindspaces** to provide context for AI responses  
+- **Users collaborate through mindspaces** (private for individuals, group for teams)
+- **Everything connects through mindspaces** - projects, messages, artifacts
+
+```mermaid
+graph LR
+    U[Users] --> MS[Mindspace]
+    C[Corpus/Knowledge] --> MS
+    MS --> Chat[Conversations]
+    MS --> History[Message History]
+    P[Projects] -.organize.-> MS
+    
+    style MS fill:#4CAF50,stroke:#2E7D32,stroke-width:2px,color:#fff
+```
+
+**Architectural Implication**: When building with Bifrost, most operations reference a `mindspace_id`. This is by design - mindspaces provide the context and scope for AI interactions.
+
+📖 **Learn more:** [Mindspace Resource Guide](docs/resources/mindspace.md)
+
+## Quick Start
+
+### Authentication
+
+The SDK uses **email/password authentication** which calls bifrost's `/v1/auth/login` endpoint:
+
+```python
+from magick_mind import MagickMind
+
+# Create client with email/password
+client = MagickMind(
+    email="user@example.com",
+    password="your_password",
+    base_url="https://bifrost.example.com"
+)
+
+# Authentication happens automatically on first API call
+# Tokens are automatically refreshed when needed
+print(f"Authenticated: {client.is_authenticated()}")
+```
+
+> **Note**: The `api_key` you might see in chat requests is **not for SDK authentication**. 
+> It's a parameter you pass when calling LLM endpoints (for tracking/billing). 
+> The SDK itself authenticates with JWT tokens from `/v1/auth/login`.
+
+### Making API Calls
+
+```python
+# Once authenticated, use the HTTP client to make requests
+# The client automatically adds authentication headers
+
+# POST request
+response = client.http.post(
+    "/v1/magickmind/chat",
+    json={
+        "api_key": "sk-your-llm-key",
+        "message": "Hello!",
+        "chat_id": "chat-123",
+        "sender_id": "user-456"
+    }
+)
+
+# GET request
+response = client.http.get("/v1/some-endpoint")
+```
+
+### Context Manager
+
+```python
+# Use as context manager for automatic cleanup
+with MagickMind(email="user@example.com", password="pass", base_url="...") as client:
+    response = client.http.get("/v1/endpoint")
+    # Client automatically closes when exiting context
+```
+
+## HTTP Client for Power Users
+
+The `client.http` property provides direct access to the authenticated HTTP client. This is intended for:
+
+**Bifrost Developers:**
+- Testing new endpoints before implementing resources
+- Experimenting with beta/experimental features
+- Quick prototyping
+
+**Power Users:**
+- Direct API access without waiting for typed resources
+- One-off calls or custom integrations
+
+```python
+# Test experimental endpoint
+response = client.http.post(
+    "/beta/new-feature",
+    json={"test": "data"}
+)
+
+# Mix versions in same app
+v1_response = client.http.post("/v1/magickmind/chat", json={...})
+beta_response = client.http.post("/beta/magickmind/chat", json={...})
+```
+
+The HTTP client automatically handles:
+- ✅ Authentication token injection
+- ✅ Token refresh when expired
+- ✅ Error mapping to SDK exceptions
+- ✅ Same configuration as main client
+
+## Authentication
+
+The SDK uses **email/password authentication** with JWT tokens:
+
+Uses bifrost's `/v1/auth/login` endpoint. Automatically handles:
+- Initial login
+- Token caching
+- Automatic token refresh using refresh_token
+- Re-authentication when refresh token expires
+
+```python
+client = MagickMind(
+    email="your@email.com",
+    password="your_password",
+    base_url="https://bifrost.example.com"
+)
+```
+
+### About API Keys
+
+If you see `api_key` in documentation or code examples, note that this is **NOT for authenticating the SDK**. 
+The `api_key` is a parameter you pass when calling specific endpoints (like chat) for LLM access:
+
+```python
+# SDK authenticates with email/password (JWT)
+client = MagickMind(email="...", password="...", base_url="...")
+
+# api_key is passed as a parameter to LLM endpoints
+# response = client.chat(api_key="your-llm-api-key", message="Hello")
+```
+
+
+## Examples
+
+See the `examples/` directory for complete working examples:
+
+- `examples/email_password_auth.py` - Email/password with auto-refresh
+- `examples/backend_service.py` - Production-ready backend service pattern
+- `examples/chat_example.py` - Using the typed chat resource
+
+Run example:
+
+```bash
+# Set environment variables
+export BIFROST_BASE_URL="http://localhost:8888"
+export BIFROST_EMAIL="user@example.com"
+export BIFROST_PASSWORD="your_password"
+
+# Run example
+uv run python examples/email_password_auth.py
+```
+
+## Backend Integration
+
+If you're building a **backend service** that uses this SDK as middleware (e.g., your backend receives data from Bifrost and manages state for your own frontend), see:
+
+📖 **[Backend Integration Guide](docs/guides/backend_integration.md)**
+
+Covers production patterns for:
+- Message deduplication
+- Hybrid realtime + HTTP sync
+- Recovery from disconnects
+- Reliable message processing
+
+Example backend service:
+```python
+from magick_mind import MagickMind
+from examples.backend_service import ChatBackendService
+
+client = MagickMind(email="...", password="...", base_url="...")
+service = ChatBackendService(client)
+
+# Handles realtime events + periodic sync for reliability
+await service.start(mindspace_id="mind-123", user_id="service-user")
+```
+
+## Event-Driven Architecture
+
+The SDK supports event-driven patterns with both realtime WebSocket events and HTTP APIs.
+
+📖 **[Event-Driven Patterns Guide](docs/architecture/event_driven_patterns.md)**
+
+Learn about:
+- Events as source of truth (current Bifrost)
+- Events as notifications (industry standard)
+- Hybrid approaches for production
+- Migration paths
+
+## Realtime WebSocket Client
+
+The SDK provides a powerful realtime client for receiving live updates via WebSocket. This is essential for building reactive applications that need instant notifications.
+
+### Quick Example
+
+```python
+import asyncio
+from magick_mind import MagickMind
+from magick_mind.realtime.handler import RealtimeEventHandler
+
+class MyHandler(RealtimeEventHandler):
+    async def on_message(self, user_id: str, payload):
+        # Automatically receives parsed messages
+        print(f"Update for {user_id}: {payload}")
+
+async def main():
+    client = MagickMind(
+        email="user@example.com",
+        password="password", 
+        base_url="https://bifrost.example.com",
+        ws_endpoint="wss://bifrost.example.com/connection/websocket"
+    )
+    
+    # Connect with handler
+    await client.realtime.connect(events=MyHandler())
+    
+    # Subscribe to users (creates per-user channels)
+    await client.realtime.subscribe_many(["user-1", "user-2", "user-3"])
+    
+    # Keep listening...
+    await asyncio.sleep(60)
+
+asyncio.run(main())
+```
+
+### Key Features
+
+- **Per-User Subscriptions** - Each user gets their own secure channel
+- **Bulk Operations** - `subscribe_many()` for handling 100s of users efficiently  
+- **Auto-Reconnect** - Centrifugo handles connection recovery automatically
+- **Type-Safe Handlers** - `RealtimeEventHandler` provides clean callback interface
+
+### Architecture: Per-User Pattern
+
+When building relay services or multi-user applications, the SDK uses a **per-user subscription model**:
+
+- **500 users = 500 subscriptions** (not 1 room channel)
+- Each user has an isolated subscription
+- Ensures privacy, security, and efficient server-side filtering
+- Single WebSocket connection multiplexes all subscriptions
+
+**Why 500 subscriptions is correct:**
+- 🔒 Security: Users can't see each other's data
+- 📊 Efficiency: Server only sends relevant messages
+- 📈 Scalable: Centrifugo handles millions of channels
+
+📖 **[Complete Realtime Guide](docs/realtime_guide.md)** - Covers subscription patterns, bulk operations, error handling, and relay service architecture.
+
+## Extending the SDK
+
+The SDK currently provides authentication and HTTP client foundation. Want to add typed resource clients (e.g., `client.chat.send(...)`)?
+
+See **[docs/contributing/resource_implementation_guide/](docs/contributing/resource_implementation_guide/)** for a complete reference implementation showing:
+
+- ✅ Pydantic models for request/response validation
+- ✅ Version-aware resource classes (v1, v2)  
+- ✅ Clean namespace pattern (`client.v1.chat`, `client.v2.chat`)
+- ✅ Working usage examples
+
+This serves as a template for adding chat, history, users, or any other resources to the SDK.
+
+## Future Plans
+
+### Versioned Resources
+
+When resources are implemented, they will follow a namespace pattern:
+
+```python
+client = MagickMind(...)
+
+# Explicit version access
+client.v1.chat.send(...)       # Always v1 (stable)
+client.v2.chat.send(...)       # Always v2 (new features)
+client.beta.chat.send(...)     # Beta/experimental
+
+# Mix and match versions
+client.v1.history.list(...)    # Use stable for some endpoints
+client.beta.chat.send(...)     # Test beta for others
+```
+
+**Key principles:**
+- **Explicit over implicit** - Users choose exact version
+- **Type safe** - Each version has different request/response types
+- **Mix-and-match** - Can use different versions for different endpoints
+- **Sparse coverage** - Only implement resources that exist in bifrost
+  - Example: If `/beta/chat` exists but `/beta/history` doesn't, `client.beta` only has `chat`
+
+**Why this approach:**
+- Safe gradual migration (v1 → v2)
+- Test breaking changes before full adoption
+- Clear which version you're using
+- No surprises when SDK updates
+
+### Example Usage Scenarios
+
+**Scenario 1: Production app using stable v1**
+```python
+client = MagickMind(...)
+
+# All endpoints use v1
+response = client.v1.chat.send(...)
+history = client.v1.history.list(...)
+user = client.v1.users.get(...)
+```
+
+**Scenario 2: Testing beta chat, keeping others stable**
+```python
+client = MagickMind(...)
+
+# Test new chat features
+response = client.beta.chat.send(
+    message="...",
+    temperature=0.8,  # New parameter in beta
+    context={...}      # New context support
+)
+
+# Keep other endpoints stable
+history = client.v1.history.list(...)
+user = client.v1.users.get(...)
+```
+
+**Scenario 3: Gradual migration v1 → v2**
+```python
+# Week 1: Start migrating chat to v2
+response = client.v2.chat.send(...)  # Migrated
+history = client.v1.history.list(...)  # Still v1
+
+# Week 2: Migrate more endpoints
+history = client.v2.history.list(...)  # Migrated
+user = client.v1.users.get(...)  # Still v1
+
+# Week 3: Fully migrated
+# All endpoints now use v2
+```
+
+**Scenario 4: Bifrost dev testing experimental endpoint**
+```python
+client = MagickMind(...)
+
+# Test endpoint that doesn't have resource yet
+response = client.http.post(
+    "/experimental/ai-agents",
+    json={"task": "analyze data"}
+)
+
+# Use typed resources for stable endpoints
+chat = client.v1.chat.send(...)
+```
+
+### Default Shortcuts (Future)
+
+For convenience, SDK may add `client.chat` shortcuts that point to a default version:
+
+**SDK 1.x series:**
+```python
+client = MagickMind(...)
+
+# Shortcuts point to v1 (stable)
+client.chat.send(...)      # → client.v1.chat.send(...)
+client.history.list(...)   # → client.v1.history.list(...)
+
+# Explicit always available
+client.v1.chat.send(...)   # Explicit v1
+client.v2.chat.send(...)   # Explicit v2 (when available)
+```
+
+**SDK 2.x series (breaking change):**
+```python
+client = MagickMind(...)
+
+# Shortcuts now point to v2 (BREAKING!)
+client.chat.send(...)      # → client.v2.chat.send(...)
+
+# Explicit v1 still works
+client.v1.chat.send(...)   # Pin to v1 for stability
+```
+
+**Best practice:** Use explicit versions (`client.v1.chat`) for production code that needs stability.
+
+### Deprecation and Migration
+
+When bifrost deprecates an API version, SDK will follow this pattern:
+
+**Phase 1: Deprecation Warning**
+```python
+# SDK 1.5: v1 still works but warns
+response = client.v1.chat.send(...)
+# Warning: v1 chat API is deprecated, migrate to v2 by 2025-06-01
+```
+
+**Phase 2: Both Versions Co-exist**
+```python
+# SDK 1.x: Both v1 and v2 available
+client.v1.chat.send(...)  # Deprecated but works
+client.v2.chat.send(...)  # Recommended
+```
+
+**Phase 3: Removal in Next Major Version**
+```python
+# SDK 2.0: v1 removed
+client.v1.chat.send(...)  # ❌ AttributeError
+client.v2.chat.send(...)  # ✅ Works
+```
+
+**Migration guide provided in CHANGELOG for each breaking change.**
+
+## Error Handling
+
+The SDK provides specific exceptions for different error scenarios:
+
+```python
+from magick_mind import (
+    MagickMind,
+    AuthenticationError,
+    TokenExpiredError,
+    ProblemDetailsException,
+    ValidationError,
+    RateLimitError
+)
+
+try:
+    client = MagickMind(email="user@example.com", password="wrong", base_url="...")
+    response = client.http.get("/v1/endpoint")
+except AuthenticationError as e:
+    print(f"Authentication failed: {e}")
+except TokenExpiredError as e:
+    print(f"Token expired: {e}")
+except RateLimitError as e:
+    print(f"Rate limited: {e}")
+except ValidationError as e:
+    # Handle field-level validation errors (400 Bad Request)
+    print(f"Validation error: {e.detail}")
+    for field, errors in e.get_field_errors().items():
+        print(f"  {field}: {', '.join(errors)}")
+except ProblemDetailsException as e:
+    # Handle other API errors (RFC 7807 Problem Details)
+    print(f"API error: {e.title} - {e.detail}")
+    print(f"Request ID: {e.request_id}")  # For support tickets
+```
+
+### Error Quick Reference
+
+| Exception | Typical Cause | Key Attributes | Recovery Action |
+|-----------|---------------|----------------|-----------------|
+| `AuthenticationError` | Invalid credentials | `message`, `status_code` | Check email/password and re-authenticate |
+| `TokenExpiredError` | Token expired | `message` | Auto-refreshed by SDK transparently |
+| `ValidationError` | Bad request data | `get_field_errors()`, `request_id` | Fix input using field error details |
+| `ProblemDetailsException` | API error (4xx, 5xx) | `status`, `title`, `detail`, `request_id` | Check detail message and request_id |
+| `RateLimitError` | Rate limit exceeded | `status_code` (429) | Retry with exponential backoff |
+
+> [!IMPORTANT]
+> **Always log `request_id`** from `ProblemDetailsException` - it's essential for support tickets and debugging with the Bifrost team.
+
+📖 **[Complete Error Handling Guide](docs/guides/error_handling.md)** - Comprehensive guide with error catalog, retry patterns, and production examples.
+
+
+## Configuration
+
+Customize SDK behavior:
+
+```python
+client = MagickMind(
+    email="user@example.com",
+    password="password",
+    base_url="https://bifrost.example.com",
+    timeout=60.0,        # Request timeout in seconds (default: 30.0)
+    verify_ssl=True      # Verify SSL certificates (default: True)
+)
+```
+
+## Development
+
+### Install development dependencies
+
+```bash
+uv sync --all-extras
+```
+
+### Run tests
+
+```bash
+uv run pytest tests/ -v
+```
+
+## License
+
+MIT License - see LICENSE file for details.
+
+## Authors
+
+- Adrian (minoak@globalmagicko.com)
+- Turtle (turtle@globalmagicko.com)
+- Min Thu Wai (minthu@globalmagicko.com)

magickmind-0.1.1.dist-info/RECORD

@@ -0,0 +1,43 @@
+magick_mind/__init__.py,sha256=fz_qJ7sdA12ve_pD2ARooKa6Prr4fi8YSRoLDcOsfZA,846
+magick_mind/client.py,sha256=onfrxVP57McbZ5liJnHKNtDUIrDwqhikZxEJeBkN-3c,5980
+magick_mind/config.py,sha256=qpDvHpiySxdpNK_IMYphFgo5CIDHVmrbFksVN_MW5r8,734
+magick_mind/exceptions.py,sha256=V2-sG12wFSWCEgL09_6fNeNRYGd3YaiPx3CzwHewwXY,3357
+magick_mind/routes.py,sha256=0_qQFe5U0z28EL26HpugtzTYJ0hfz-OP6Da-ZTDIWwk,2129
+magick_mind/auth/__init__.py,sha256=KFVQgzRKOFQMet4xuWRDoz3olOxT2cBPGaHergrvBpk,219
+magick_mind/auth/base.py,sha256=hOv7pIkGJWIyTTNiETi9tZUeSJNVgeaaWbKGpCwmIdg,1069
+magick_mind/auth/email_password.py,sha256=Hp7PsyLTBzJ0DsVCq22TBwLZfpjGHO0LuZ7RRp6NugU,10084
+magick_mind/http/__init__.py,sha256=_1xtQBZQ9JX-T3Bqauwr57ujHbW5xrXjnmWdAZ5UG44,120
+magick_mind/http/client.py,sha256=-TIPzYclS8OZbUWxFPW5epli870z7I9shahq_hJN4Fw,10072
+magick_mind/models/__init__.py,sha256=zXmYoh8-LC10d7sWcWBC2DtBGvP3_dy7Z64NDqwyBvE,393
+magick_mind/models/auth.py,sha256=O23zq-mWRIHVznxkUmSoGQjUSAecdF7wpUbQ8ITESCk,618
+magick_mind/models/common.py,sha256=BGnziCXSimYNvfB9rtkhhK4xjKkqeWuCq2vmo9o1LaA,940
+magick_mind/models/errors.py,sha256=CL31vPvULvv_Jc1p0PMIAizGIw7zP9NozoK-bMic1l0,2312
+magick_mind/models/v1/__init__.py,sha256=HH19PeDY1TRDPYMz_qQjQ3ngCdqKBlylY9CXdaU_VeM,2064
+magick_mind/models/v1/api_keys.py,sha256=31n8HZc1VDd2esnO4r-1LNY2WGod6oyk8Qqe2xvx2rs,4015
+magick_mind/models/v1/artifact.py,sha256=dE1O6H2bDaGRz_nTDZw8ssBlzPDXZCuVMrKLO6wKzAE,6040
+magick_mind/models/v1/chat.py,sha256=UuGs66LBeVh_Vpdga0XX72Wsx42MS7YuuX1VK-CC0aI,3408
+magick_mind/models/v1/corpus.py,sha256=71YhJd173b2XuPAD9Av3KNXWsuGHFyjB8oOd3n4bRRE,2522
+magick_mind/models/v1/end_user.py,sha256=PmRn5Frhg-QZnhH5--eqgivk8uzskk5Cdea1pIZm7UE,2379
+magick_mind/models/v1/history.py,sha256=Z32rCzSIpyoBUN1siYPfoLyR5Di__1uZoZQAuFmqeJE,2831
+magick_mind/models/v1/mindspace.py,sha256=Hw-zjUif36a4RAhZZxXfHdjUHa9qGd0jBDf5U4fp_yk,4101
+magick_mind/models/v1/model.py,sha256=7lBcyxwupGVkmeJ_5qWdMi4n8cTMMOtoSiIIXBcXkR4,876
+magick_mind/models/v1/project.py,sha256=J0MhVOjqnGXA8waC1tTaZ2JzVqin_cHP_n1GSK3Qiuw,2215
+magick_mind/realtime/__init__.py,sha256=AXxK__ZqHX0iaCQnkPsmpmuTkWQnqBm8JAx8gAUbjoQ,132
+magick_mind/realtime/client.py,sha256=RoUW65df2y28V6T3klBIqrAtrWKI8xq8dqo9pDzT2JY,6817
+magick_mind/realtime/handler.py,sha256=ovq35YrKHyAGrEFdGBSqvEpP4JfCAiXzDmXyPyXMAuU,3932
+magick_mind/resources/README.md,sha256=idxTiaQWJW1o3hC6WBIoeTlX6nDr4AsqzE6ELppJuy8,5712
+magick_mind/resources/__init__.py,sha256=6JUxgJQFUFvzMLADCPp1kQV9UJBT87z8oXnxkgBsrvc,1609
+magick_mind/resources/base.py,sha256=UYyddfgGFbdv9m8dljBNeKOIbj1zT1h9L8kQKrJ43Fg,850
+magick_mind/resources/v1/__init__.py,sha256=YloUAmuSFWH26cyv5y-QFdqeHYNTKuXsG_oNwrxh4EY,655
+magick_mind/resources/v1/api_keys.py,sha256=AfVA9DFCnmen7Py-g5KOo1ILNuxbBY8ZX8WM9ll_liw,5078
+magick_mind/resources/v1/artifact.py,sha256=XZ-vEPGilG88xZUjkPApa2fXfGDiSfs_Z3KDPfcVAz4,9145
+magick_mind/resources/v1/chat.py,sha256=L38T85eypvosau4zZU3s4_fXcB4wdwGAjnO3f7ZOApM,4030
+magick_mind/resources/v1/corpus.py,sha256=bn3bwh2eUbswksFX5-3uX6gOBOmfn5FrtcREo9SqouQ,3732
+magick_mind/resources/v1/end_user.py,sha256=26IVghTh-1ChLICU_ymEE8RBeGNyWFnY0H_qUSUiwnk,5259
+magick_mind/resources/v1/history.py,sha256=LYMZshDRxrOnMeIOKfikHxyetVQta-LIfEcCmxky-Hw,2791
+magick_mind/resources/v1/mindspace.py,sha256=NiGsu-Rei9pXrxHN_Gp3-AkoVK2W4zwjja1H2inn2cg,10358
+magick_mind/resources/v1/model.py,sha256=b7sIfm8uciE3C6rjWWaLJltgmdbfgIWB09Kra3gzCoY,549
+magick_mind/resources/v1/project.py,sha256=kYcGMYyrjxj_nOcmt0ldNXneNct47CfJrFD25EhB6-g,4522
+magickmind-0.1.1.dist-info/METADATA,sha256=XWjHK_hEnH6Wx6V90N5BIMLsaCDWaDu2Q9m-SCf-h-w,18864
+magickmind-0.1.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+magickmind-0.1.1.dist-info/RECORD,,

magickmind-0.1.1.dist-info/WHEEL

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