cycls 0.0.2.78__py3-none-any.whl

cycls/web.py

@@ -0,0 +1,131 @@
+import json, inspect
+from pathlib import Path
+from pydantic import BaseModel
+from typing import Optional
+
+class Config(BaseModel):
+    public_path: str = "theme"
+    header: str = ""
+    intro: str = ""
+    title: str = ""
+    prod: bool = False
+    auth: bool = False
+    plan: str = "free"
+    analytics: bool = False
+    org: Optional[str] = None
+    pk: str = ""
+    jwks: str = ""
+
+async def openai_encoder(stream):
+    if inspect.isasyncgen(stream):
+        async for msg in stream:
+            if msg: yield f"data: {json.dumps({'choices': [{'delta': {'content': msg}}]})}\n\n"
+    else:
+        for msg in stream:
+            if msg: yield f"data: {json.dumps({'choices': [{'delta': {'content': msg}}]})}\n\n"
+    yield "data: [DONE]\n\n"
+
+def sse(item):
+    if not item: return None
+    if not isinstance(item, dict): item = {"type": "text", "text": item}
+    return f"data: {json.dumps(item)}\n\n"
+
+async def encoder(stream):
+    if inspect.isasyncgen(stream):
+        async for item in stream:
+            if msg := sse(item): yield msg
+    else:
+        for item in stream:
+            if msg := sse(item): yield msg
+    yield "data: [DONE]\n\n"
+
+class Messages(list):
+    """A list that provides text-only messages by default, with .raw for full data."""
+    def __init__(self, raw_messages):
+        self._raw = raw_messages
+        text_messages = []
+        for m in raw_messages:
+            text_content = "".join(
+                p.get("text", "") for p in m.get("parts", []) if p.get("type") == "text"
+            )
+            text_messages.append({
+                "role": m.get("role"),
+                "content": m.get("content") or text_content
+            })
+        super().__init__(text_messages)
+
+    @property
+    def raw(self):
+        return self._raw
+
+def web(func, config):
+    from fastapi import FastAPI, Request, HTTPException, status, Depends
+    from fastapi.responses import StreamingResponse
+    from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+    import jwt
+    from jwt import PyJWKClient
+    from pydantic import EmailStr
+    from typing import List, Optional, Any
+    from fastapi.staticfiles import StaticFiles
+
+    if isinstance(config, dict):
+        config = Config(**config)
+
+    jwks = PyJWKClient(config.jwks)
+
+    class User(BaseModel):
+        id: str
+        name: Optional[str] = None
+        email: EmailStr
+        org: Optional[str] = None
+        plans: List[str] = []
+
+    class Context(BaseModel):
+        messages: Any
+        user: Optional[User] = None
+
+    app = FastAPI()
+    bearer_scheme = HTTPBearer()
+
+    def validate(bearer: HTTPAuthorizationCredentials = Depends(bearer_scheme)):
+        try:
+            key = jwks.get_signing_key_from_jwt(bearer.credentials)
+            decoded = jwt.decode(bearer.credentials, key.key, algorithms=["RS256"], leeway=10)
+            return {"type": "user",
+                    "user": {"id": decoded.get("id"), "name": decoded.get("name"), "email": decoded.get("email"), "org": decoded.get("org"),
+                             "plans": decoded.get("public", {}).get("plans", [])}}
+        except:
+            raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid credentials", headers={"WWW-Authenticate": "Bearer"})
+    
+    @app.post("/")
+    @app.post("/chat/cycls")
+    @app.post("/chat/completions")
+    async def back(request: Request, jwt: Optional[dict] = Depends(validate) if config.auth else None):
+        data = await request.json()
+        messages = data.get("messages")
+        user_data = jwt.get("user") if jwt else None
+        context = Context(messages = Messages(messages), user = User(**user_data) if user_data else None)
+        stream = await func(context) if inspect.iscoroutinefunction(func) else func(context)
+        if request.url.path == "/chat/completions":
+            stream = openai_encoder(stream)
+        elif request.url.path == "/chat/cycls":
+            stream = encoder(stream)
+        return StreamingResponse(stream, media_type="text/event-stream")
+
+    @app.get("/config")
+    async def get_config():
+        return config
+
+    if Path("public").is_dir():
+        app.mount("/public", StaticFiles(directory="public", html=True))
+    app.mount("/", StaticFiles(directory=config.public_path, html=True))
+
+    return app
+
+def serve(func, config, name, port):
+    import uvicorn, logging
+    if isinstance(config, dict):
+        config = Config(**config)
+    logging.getLogger("uvicorn.error").addFilter(lambda r: "0.0.0.0" not in r.getMessage())
+    print(f"\n🔨 {name} => http://localhost:{port}\n")
+    uvicorn.run(web(func, config), host="0.0.0.0", port=port)

cycls-0.0.2.78.dist-info/METADATA

@@ -0,0 +1,274 @@
+Metadata-Version: 2.4
+Name: cycls
+Version: 0.0.2.78
+Summary: Distribute Intelligence
+Author: Mohammed J. AlRujayi
+Author-email: mj@cycls.com
+Requires-Python: >=3.9,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+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
+Provides-Extra: modal
+Requires-Dist: cloudpickle (>=3.1.1,<4.0.0)
+Requires-Dist: docker (>=7.1.0,<8.0.0)
+Requires-Dist: fastapi (>=0.111.0,<0.112.0)
+Requires-Dist: grpcio (>=1.76.0,<2.0.0)
+Requires-Dist: httpx (>=0.27.0,<0.28.0)
+Requires-Dist: modal (>=1.1.0,<2.0.0) ; extra == "modal"
+Requires-Dist: protobuf (>=6.0,<7.0)
+Requires-Dist: pyjwt (>=2.8.0,<3.0.0)
+Description-Content-Type: text/markdown
+
+<h3 align="center">
+Distribute Intelligence
+</h3>
+
+<h4 align="center">
+  <a href="https://cycls.com">Website</a> |
+  <a href="https://docs.cycls.com">Docs</a>
+</h4>
+
+<h4 align="center">
+  <a href="https://pypi.python.org/pypi/cycls"><img src="https://img.shields.io/pypi/v/cycls.svg?label=cycls+pypi&color=blueviolet" alt="cycls Python package on PyPi" /></a>
+  <a href="https://github.com/Cycls/cycls/actions/workflows/tests.yml"><img src="https://github.com/Cycls/cycls/actions/workflows/tests.yml/badge.svg" alt="Tests" /></a>
+  <a href="https://blog.cycls.com"><img src="https://img.shields.io/badge/newsletter-blueviolet.svg?logo=substack&label=cycls" alt="Cycls newsletter" /></a>
+  <a href="https://x.com/cyclsai">
+    <img src="https://img.shields.io/twitter/follow/CyclsAI" alt="Cycls Twitter" />
+  </a>
+</h4>
+
+---
+
+# Cycls
+
+The open-source SDK for distributing AI agents.
+
+## Distribute Intelligence
+
+Write a function. Deploy it as an API, a web interface, or both. Add authentication, analytics, and monetization with flags.
+
+```python
+import cycls
+
+cycls.api_key = "YOUR_CYCLS_API_KEY"
+
+@cycls.agent(pip=["openai"])
+async def agent(context):
+    from openai import AsyncOpenAI
+    client = AsyncOpenAI()
+
+    stream = await client.responses.create(
+        model="o3-mini",
+        input=context.messages,
+        stream=True,
+        reasoning={"effort": "medium", "summary": "auto"},
+    )
+
+    async for event in stream:
+        if event.type == "response.reasoning_summary_text.delta":
+            yield {"type": "thinking", "thinking": event.delta}  # Renders as thinking bubble
+        elif event.type == "response.output_text.delta":
+            yield event.delta
+
+agent.deploy()  # Live at https://agent.cycls.ai
+```
+
+## Installation
+
+```bash
+pip install cycls
+```
+
+Requires Docker.
+
+## What You Get
+
+- **Streaming API** - OpenAI-compatible `/chat/completions` endpoint
+- **Web Interface** - Chat UI served automatically
+- **Authentication** - `auth=True` enables JWT-based access control
+- **Analytics** - `analytics=True` tracks usage
+- **Monetization** - `plan="cycls_pass"` integrates with [Cycls Pass](https://cycls.ai) subscriptions
+- **Native UI Components** - Render thinking bubbles, tables, code blocks in responses
+
+## Running
+
+```python
+agent.local()             # Development with hot-reload (localhost:8080)
+agent.local(watch=False)  # Development without hot-reload
+agent.deploy()            # Production: https://agent.cycls.ai
+```
+
+Get an API key at [cycls.com](https://cycls.com).
+
+## Authentication & Analytics
+
+```python
+@cycls.agent(pip=["openai"], auth=True, analytics=True)
+async def agent(context):
+    # context.user available when auth=True
+    user = context.user  # User(id, email, name, plans)
+    yield f"Hello {user.name}!"
+```
+
+| Flag | Description |
+|------|-------------|
+| `auth=True` | Universal user pool via Cycls Pass (Clerk-based). You can also use your own Clerk auth. |
+| `analytics=True` | Rich usage metrics available on the Cycls dashboard. |
+| `plan="cycls_pass"` | Monetization via Cycls Pass subscriptions. Enables both auth and analytics. |
+
+## Native UI Components
+
+Yield structured objects for rich streaming responses:
+
+```python
+@cycls.agent()
+async def demo(context):
+    yield {"type": "thinking", "thinking": "Analyzing the request..."}
+    yield "Here's what I found:\n\n"
+
+    yield {"type": "table", "headers": ["Name", "Status"]}
+    yield {"type": "table", "row": ["Server 1", "Online"]}
+    yield {"type": "table", "row": ["Server 2", "Offline"]}
+
+    yield {"type": "code", "code": "result = analyze(data)", "language": "python"}
+    yield {"type": "callout", "callout": "Analysis complete!", "style": "success"}
+```
+
+| Component | Streaming |
+|-----------|-----------|
+| `{"type": "thinking", "thinking": "..."}` | Yes |
+| `{"type": "code", "code": "...", "language": "..."}` | Yes |
+| `{"type": "table", "headers": [...]}` | Yes |
+| `{"type": "table", "row": [...]}` | Yes |
+| `{"type": "status", "status": "..."}` | Yes |
+| `{"type": "callout", "callout": "...", "style": "..."}` | Yes |
+| `{"type": "image", "src": "..."}` | Yes |
+
+### Thinking Bubbles
+
+The `{"type": "thinking", "thinking": "..."}` component renders as a collapsible thinking bubble in the UI. Each yield appends to the same bubble until a different component type is yielded:
+
+```python
+# Multiple yields build one thinking bubble
+yield {"type": "thinking", "thinking": "Let me "}
+yield {"type": "thinking", "thinking": "analyze this..."}
+yield {"type": "thinking", "thinking": " Done thinking."}
+
+# Then output the response
+yield "Here's what I found..."
+```
+
+This works seamlessly with OpenAI's reasoning models - just map reasoning summaries to the thinking component.
+
+## Context Object
+
+```python
+@cycls.agent()
+async def chat(context):
+    context.messages      # [{"role": "user", "content": "..."}]
+    context.messages.raw  # Full data including UI component parts
+    context.user          # User(id, email, name, plans) when auth=True
+```
+
+## API Endpoints
+
+| Endpoint | Format |
+|----------|--------|
+| `POST chat/cycls` | Cycls streaming protocol |
+| `POST chat/completions` | OpenAI-compatible |
+
+## Streaming Protocol
+
+Cycls streams structured components over SSE:
+
+```
+data: {"type": "thinking", "thinking": "Let me "}
+data: {"type": "thinking", "thinking": "analyze..."}
+data: {"type": "text", "text": "Here's the answer"}
+data: {"type": "callout", "callout": "Done!", "style": "success"}
+data: [DONE]
+```
+
+See [docs/streaming-protocol.md](docs/streaming-protocol.md) for frontend integration.
+
+## Declarative Infrastructure
+
+Define your entire runtime in the decorator:
+
+```python
+@cycls.agent(
+    pip=["openai", "pandas", "numpy"],
+    apt=["ffmpeg", "libmagic1"],
+    copy=["./utils.py", "./models/", "/absolute/path/to/config.json"],
+    copy_public=["./assets/logo.png", "./static/"],
+)
+async def my_agent(context):
+    ...
+```
+
+### `pip` - Python Packages
+
+Install any packages from PyPI. These are installed during the container build.
+
+```python
+pip=["openai", "pandas", "numpy", "transformers"]
+```
+
+### `apt` - System Packages
+
+Install system-level dependencies via apt-get. Need ffmpeg for audio processing? ImageMagick for images? Just declare it.
+
+```python
+apt=["ffmpeg", "imagemagick", "libpq-dev"]
+```
+
+### `copy` - Bundle Files and Directories
+
+Include local files and directories in your container. Works with both relative and absolute paths. Copies files and entire directory trees.
+
+```python
+copy=[
+    "./utils.py",                    # Single file, relative path
+    "./models/",                     # Entire directory
+    "/home/user/configs/app.json",   # Absolute path
+]
+```
+
+Then import them in your function:
+
+```python
+@cycls.agent(copy=["./utils.py"])
+async def chat(context):
+    from utils import helper_function  # Your bundled module
+    ...
+```
+
+### `copy_public` - Static Files
+
+Files and directories served at the `/public` endpoint. Perfect for images, downloads, or any static assets your agent needs to reference.
+
+```python
+copy_public=["./assets/logo.png", "./downloads/"]
+```
+
+Access them at `https://your-agent.cycls.ai/public/logo.png`.
+
+---
+
+### What You Get
+
+- **One file** - Code, dependencies, configuration, and infrastructure together
+- **Instant deploys** - Unchanged code deploys in seconds from cache
+- **No drift** - What you see is what runs. Always.
+- **Just works** - Closures, lambdas, dynamic imports - your function runs exactly as written
+
+No YAML. No Dockerfiles. No infrastructure repo. The code is the deployment.
+
+## License
+
+MIT
+

cycls-0.0.2.78.dist-info/RECORD

@@ -0,0 +1,20 @@
+cycls/__init__.py,sha256=vyI1d_8VP4XW7MliFuUs_P3O9KQxyCwQu-JkxrCyhPQ,597
+cycls/auth.py,sha256=xkndHZyCfnlertMMEKerCJjf23N3fVcTRVTTSXTTuzg,247
+cycls/cli.py,sha256=AKf0z7ZLau3GvBVR_IhB7agmq4nVaHkcuUafNyvv2_A,7978
+cycls/default-theme/assets/index-B0ZKcm_V.css,sha256=wK9-NhEB8xPcN9Zv69zpOcfGTlFbMwyC9WqTmSKUaKw,6546
+cycls/default-theme/assets/index-D5EDcI4J.js,sha256=sN4qRcAXa7DBd9JzmVcCoCwH4l8cNCM-U9QGUjBvWSo,1346506
+cycls/default-theme/index.html,sha256=bM-yW_g0cGrV40Q5yY3ccY0fM4zI1Wuu5I8EtGFJIxs,828
+cycls/dev-theme/index.html,sha256=QJBHkdNuMMiwQU7o8dN8__8YQeQB45D37D-NCXIWB2Q,11585
+cycls/grpc/__init__.py,sha256=sr8UQMgJEHyBreBKV8xz8UCd0zDP5lhjXTnfkOB_yOY,63
+cycls/grpc/client.py,sha256=zDFIBABXzuv_RUVn5LllppZ38C7k01RyAS8ZURBjudQ,2270
+cycls/grpc/runtime.proto,sha256=B1AqrNIXOtr3Xsyzfc2Z1OCBepa6hsi4DJ4a3Pf33IQ,244
+cycls/grpc/runtime_pb2.py,sha256=vEJo8FGP5aWPSDqzjZldfctduA2ojiyvoody7vpf-1w,1703
+cycls/grpc/runtime_pb2_grpc.py,sha256=KFd8KqGbiNsKm8X39Q9_BPwXjeZUiDl8O_4aTlEys3k,3394
+cycls/grpc/server.py,sha256=pfb4bo06NKDv0OpknqMSMjB9f8HUR41EZau1c6_XU5A,1911
+cycls/runtime.py,sha256=8DqK14n5DLuyl3sHQrRqLOeCPzo6_zYP8iSiHbXH_yU,18038
+cycls/sdk.py,sha256=B5_ZNGvXqqKcAGAvhk-tyr0YH8kfvCJPKl01rhetvFw,6588
+cycls/web.py,sha256=_QNH8K55vTm90Z7tvcRKal5IybjkB1GY7Pf9p3qu3r8,4659
+cycls-0.0.2.78.dist-info/METADATA,sha256=C7BGrOxmY41GTVXuZldlLvarXEn6ImBzfGI0DvXm6HE,8496
+cycls-0.0.2.78.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+cycls-0.0.2.78.dist-info/entry_points.txt,sha256=vEhqUxFhhuzCKWtq02LbMnT3wpUqdfgcM3Yh-jjXom8,40
+cycls-0.0.2.78.dist-info/RECORD,,

cycls-0.0.2.78.dist-info/WHEEL

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

cycls-0.0.2.78.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+cycls=cycls.cli:main
+