local-coze 0.0.1__py3-none-any.whl

local_coze/__init__.py

@@ -0,0 +1,110 @@
+from .core import (
+    APIError,
+    BaseClient,
+    Config,
+    ConfigurationError,
+    CozeSDKError,
+    NetworkError,
+    ValidationError,
+)
+from .image import (
+    ImageConfig,
+    ImageData,
+    ImageGenerationClient,
+    ImageGenerationRequest,
+    ImageGenerationResponse,
+    ImageSize,
+    UsageInfo,
+)
+from .llm import LLMClient, LLMConfig
+from .knowledge import (
+    ChunkConfig,
+    KnowledgeChunk,
+    KnowledgeClient,
+    KnowledgeDocument,
+    KnowledgeInsertResponse,
+    KnowledgeSearchResponse,
+)
+from .search import ImageItem, SearchClient, WebItem
+from .video import VideoGenerationClient, VideoGenerationTask
+from .voice import ASRClient, ASRRequest, ASRResponse, TTSClient, TTSConfig, TTSRequest
+
+from .database import Base, generate_models, get_session, upgrade
+
+from .memory import get_memory_saver
+
+from .s3 import S3SyncStorage
+
+from .embedding import (
+    EmbeddingClient,
+    EmbeddingConfig,
+    EmbeddingInputItem,
+    EmbeddingInputImageURL,
+    EmbeddingInputVideoURL,
+    EmbeddingRequest,
+    EmbeddingResponse,
+    EmbeddingData,
+    EmbeddingUsage,
+    MultiEmbeddingConfig,
+    SparseEmbeddingConfig,
+    SparseEmbeddingItem,
+    PromptTokensDetails,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Config",
+    "BaseClient",
+    "CozeSDKError",
+    "ConfigurationError",
+    "APIError",
+    "NetworkError",
+    "ValidationError",
+    "ImageGenerationClient",
+    "ImageConfig",
+    "ImageSize",
+    "ImageGenerationRequest",
+    "ImageGenerationResponse",
+    "ImageData",
+    "UsageInfo",
+    "TTSClient",
+    "ASRClient",
+    "TTSConfig",
+    "TTSRequest",
+    "ASRRequest",
+    "ASRResponse",
+    "LLMClient",
+    "LLMConfig",
+    "KnowledgeClient",
+    "ChunkConfig",
+    "DataSourceType",
+    "KnowledgeSearchResponse",
+    "KnowledgeChunk",
+    "KnowledgeDocument",
+    "KnowledgeInsertResponse",
+    "SearchClient",
+    "WebItem",
+    "ImageItem",
+    "VideoGenerationClient",
+    "VideoGenerationTask",
+    "Base",
+    "get_session",
+    "generate_models",
+    "upgrade",
+    "get_memory_saver",
+    "S3SyncStorage",
+    "EmbeddingClient",
+    "EmbeddingConfig",
+    "EmbeddingInputItem",
+    "EmbeddingInputImageURL",
+    "EmbeddingInputVideoURL",
+    "EmbeddingRequest",
+    "EmbeddingResponse",
+    "EmbeddingData",
+    "EmbeddingUsage",
+    "MultiEmbeddingConfig",
+    "SparseEmbeddingConfig",
+    "SparseEmbeddingItem",
+    "PromptTokensDetails",
+]

local_coze/cli/__init__.py

@@ -0,0 +1,3 @@
+"""Coze Coding CLI - Command-line interface for Coze Coding integrations."""
+
+__version__ = "0.3.0"

local_coze/cli/chat.py

@@ -0,0 +1,126 @@
+import json
+import os
+from typing import Optional
+
+import click
+from langchain_core.messages import HumanMessage, SystemMessage
+from rich.console import Console
+
+from ..core.config import Config
+from ..llm import LLMClient
+
+console = Console()
+
+
+@click.command()
+@click.option("--prompt", "-p", required=True, help="User message content")
+@click.option("--system", "-s", help="System prompt for custom behavior")
+@click.option(
+    "--thinking", "-t", is_flag=True, help="Enable chain-of-thought reasoning"
+)
+@click.option(
+    "--output", "-o", type=click.Path(), help="Output file path (JSON format)"
+)
+@click.option("--stream", is_flag=True, help="Stream the response in real-time")
+@click.option(
+    "--header",
+    "-H",
+    multiple=True,
+    help="自定义 HTTP 请求头 (格式: 'Key: Value' 或 'Key=Value'，可多次使用)",
+)
+@click.option("--verbose", "-v", is_flag=True, help="显示详细的 HTTP 请求日志")
+def chat(
+    prompt: str,
+    system: Optional[str],
+    thinking: bool,
+    output: Optional[str],
+    stream: bool,
+    header: tuple,
+    verbose: bool,
+):
+    """Chat with AI using natural language."""
+    try:
+        from .utils import parse_headers
+
+        config = Config()
+        custom_headers = parse_headers(header)
+        client = LLMClient(config, custom_headers=custom_headers, verbose=verbose)
+
+        messages = []
+        if system:
+            messages.append(SystemMessage(content=system))
+        messages.append(HumanMessage(content=prompt))
+
+        thinking_mode = "enabled" if thinking else "disabled"
+
+        console.print(f"[bold cyan]Chat with AI...[/bold cyan]")
+        console.print(f"Prompt: [yellow]{prompt}[/yellow]")
+        if system:
+            console.print(f"System: [blue]{system}[/blue]")
+        if thinking:
+            console.print(f"Thinking: [green]enabled[/green]")
+        console.print()
+
+        if stream:
+            console.print("[bold green]Response:[/bold green]")
+            full_content = ""
+            response_metadata = {}
+
+            for chunk in client.stream(messages=messages, thinking=thinking_mode):
+                if chunk.content:
+                    console.print(chunk.content, end="")
+                    full_content += chunk.content
+                if chunk.response_metadata:
+                    response_metadata.update(chunk.response_metadata)
+
+            console.print("\n")
+
+            if output:
+                result = {
+                    "prompt": prompt,
+                    "system": system,
+                    "thinking": thinking,
+                    "response": full_content,
+                    "metadata": response_metadata,
+                }
+
+                output_dir = os.path.dirname(os.path.abspath(output))
+                if output_dir:
+                    os.makedirs(output_dir, exist_ok=True)
+
+                with open(output, "w", encoding="utf-8") as f:
+                    json.dump(result, f, ensure_ascii=False, indent=2)
+
+                console.print(
+                    f"[green]✓[/green] Response saved to: [bold]{output}[/bold]"
+                )
+        else:
+            response = client.invoke(messages=messages, thinking=thinking_mode)
+
+            console.print("[bold green]Response:[/bold green]")
+            console.print(response.content)
+            console.print()
+
+            if output:
+                result = {
+                    "prompt": prompt,
+                    "system": system,
+                    "thinking": thinking,
+                    "response": response.content,
+                    "metadata": response.response_metadata,
+                }
+
+                output_dir = os.path.dirname(os.path.abspath(output))
+                if output_dir:
+                    os.makedirs(output_dir, exist_ok=True)
+
+                with open(output, "w", encoding="utf-8") as f:
+                    json.dump(result, f, ensure_ascii=False, indent=2)
+
+                console.print(
+                    f"[green]✓[/green] Response saved to: [bold]{output}[/bold]"
+                )
+
+    except Exception as e:
+        console.print(f"[red]✗ Error: {str(e)}[/red]")
+        raise click.Abort()

local_coze/cli/cli.py

@@ -0,0 +1,34 @@
+import click
+
+from .chat import chat
+from .db import db
+from .embedding import embedding
+from .image import image
+from .knowledge import knowledge
+from .search import search
+from .video import video
+from .video_edit import video_edit
+from .voice import asr, tts
+
+
+@click.group()
+@click.version_option(version="0.5.0", prog_name="coze-coding-ai")
+def main():
+    """Coze Coding CLI - AI-powered tools for video generation, embedding, and more."""
+    pass
+
+
+main.add_command(video)
+main.add_command(video_edit)
+main.add_command(image)
+main.add_command(knowledge)
+main.add_command(search)
+main.add_command(tts)
+main.add_command(asr)
+main.add_command(chat)
+main.add_command(db)
+main.add_command(embedding)
+
+
+if __name__ == "__main__":
+    main()

local_coze/cli/constants.py

@@ -0,0 +1,7 @@
+"""
+CLI 常量定义
+"""
+
+RUN_MODE_HEADER = "x-run-mode"
+RUN_MODE_TEST = "test_run"
+RUN_MODE_PRODUCTION = "production"

local_coze/cli/db.py

@@ -0,0 +1,81 @@
+"""
+数据库 CLI 命令
+"""
+
+import os
+import click
+
+# 默认路径
+DEFAULT_MODEL_OUTPUT = "src/storage/database/shared/model.py"
+DEFAULT_MODEL_IMPORT_PATH = "storage.database.shared.model"
+DEFAULT_MODEL_PATH = "src"
+
+
+def _get_workspace_path() -> str:
+    """获取工作目录"""
+    return os.getenv("WORKSPACE_PATH", os.getcwd())
+
+
+@click.group()
+def db():
+    """Database management commands."""
+    pass
+
+
+@db.command()
+@click.argument("output_path", required=False, default=None)
+@click.option("--verbose", "-v", is_flag=True, help="Verbose output")
+def generate_models(output_path: str, verbose: bool):
+    """
+    Generate ORM models from database.
+
+    OUTPUT_PATH: Path to output model file (default: src/storage/database/shared/model.py)
+    """
+    from local_coze.database import generate_models as _generate_models
+
+    if output_path is None:
+        workspace = _get_workspace_path()
+        output_path = os.path.join(workspace, DEFAULT_MODEL_OUTPUT)
+
+    try:
+        _generate_models(output_path, verbose=verbose)
+        click.echo(f"Models generated at {output_path}")
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        raise SystemExit(1)
+
+
+@db.command()
+@click.option(
+    "--model-import-path",
+    default=DEFAULT_MODEL_IMPORT_PATH,
+    help=f"Model import path (default: {DEFAULT_MODEL_IMPORT_PATH})",
+)
+@click.option(
+    "--model-path",
+    default=None,
+    help=f"Path to add to sys.path for model import (default: $WORKSPACE_PATH/{DEFAULT_MODEL_PATH})",
+)
+@click.option("--verbose", "-v", is_flag=True, help="Verbose output")
+def upgrade(model_import_path: str, model_path: str, verbose: bool):
+    """
+    Run database migrations.
+
+    Automatically generates migration and upgrades to head.
+    """
+    from local_coze.database import upgrade as _upgrade
+
+    if model_path is None:
+        workspace = _get_workspace_path()
+        model_path = os.path.join(workspace, DEFAULT_MODEL_PATH)
+
+    try:
+        _upgrade(
+            model_import_path=model_import_path,
+            model_path=model_path,
+            verbose=verbose,
+        )
+        click.echo("Database upgraded successfully")
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        raise SystemExit(1)

local_coze/cli/embedding.py

@@ -0,0 +1,193 @@
+import json
+import os
+from typing import Optional
+
+import click
+from coze_coding_utils.runtime_ctx.context import new_context
+from rich.console import Console
+
+from ..core.config import Config
+from ..embedding import EmbeddingClient
+from .constants import RUN_MODE_HEADER, RUN_MODE_TEST
+
+console = Console()
+
+
+@click.command()
+@click.option(
+    "--text",
+    "-t",
+    multiple=True,
+    help="Text to embed (can be used multiple times)",
+)
+@click.option(
+    "--image-url",
+    multiple=True,
+    help="Image URL to embed (can be used multiple times)",
+)
+@click.option(
+    "--video-url",
+    multiple=True,
+    help="Video URL to embed (can be used multiple times)",
+)
+@click.option(
+    "--dimensions",
+    "-d",
+    type=int,
+    help="Output embedding dimensions",
+)
+@click.option(
+    "--instructions",
+    help="Instructions for embedding generation",
+)
+@click.option(
+    "--multi-embedding",
+    is_flag=True,
+    help="Enable multi-embedding mode",
+)
+@click.option(
+    "--sparse-embedding",
+    is_flag=True,
+    help="Enable sparse embedding mode",
+)
+@click.option(
+    "--output",
+    "-o",
+    type=click.Path(),
+    help="Output file path for embedding JSON",
+)
+@click.option("--mock", is_flag=True, help="使用 mock 模式（测试运行）")
+@click.option(
+    "--header",
+    "-H",
+    multiple=True,
+    help="自定义 HTTP 请求头 (格式: 'Key: Value' 或 'Key=Value'，可多次使用)",
+)
+@click.option("--verbose", "-v", is_flag=True, help="显示详细的 HTTP 请求日志")
+def embedding(
+    text: tuple,
+    image_url: tuple,
+    video_url: tuple,
+    dimensions: Optional[int],
+    instructions: Optional[str],
+    multi_embedding: bool,
+    sparse_embedding: bool,
+    output: Optional[str],
+    mock: bool,
+    header: tuple,
+    verbose: bool,
+):
+    """Generate embeddings for text, images, or videos using AI."""
+    try:
+        has_text = len(text) > 0
+        has_image = len(image_url) > 0
+        has_video = len(video_url) > 0
+
+        if not has_text and not has_image and not has_video:
+            console.print(
+                "[red]Error: At least one of --text, --image-url, or --video-url is required[/red]"
+            )
+            raise click.Abort()
+
+        from .utils import parse_headers
+
+        config = Config()
+
+        ctx = None
+        custom_headers = parse_headers(header) or {}
+
+        if mock:
+            ctx = new_context(method="embedding.embed", headers=custom_headers)
+            custom_headers[RUN_MODE_HEADER] = RUN_MODE_TEST
+            console.print("[yellow]🧪 Mock 模式已启用（测试运行）[/yellow]")
+
+        client = EmbeddingClient(
+            config, ctx=ctx, custom_headers=custom_headers, verbose=verbose
+        )
+
+        console.print("[bold cyan]Generating embeddings...[/bold cyan]")
+
+        if has_text:
+            console.print(f"Texts: [yellow]{len(text)} items[/yellow]")
+        if has_image:
+            console.print(f"Images: [yellow]{len(image_url)} items[/yellow]")
+        if has_video:
+            console.print(f"Videos: [yellow]{len(video_url)} items[/yellow]")
+
+        response = client.embed(
+            texts=list(text) if has_text else None,
+            image_urls=list(image_url) if has_image else None,
+            video_urls=list(video_url) if has_video else None,
+            dimensions=dimensions,
+            instructions=instructions,
+            multi_embedding=multi_embedding,
+            sparse_embedding=sparse_embedding,
+        )
+
+        console.print(f"[green]✓[/green] Embeddings generated successfully!")
+        console.print(f"Model: [cyan]{response.model}[/cyan]")
+
+        if response.embedding:
+            console.print(
+                f"Embedding dimensions: [cyan]{len(response.embedding)}[/cyan]"
+            )
+            first_5 = response.embedding[:5]
+            console.print(f"First 5 values: [dim]{first_5}...[/dim]")
+
+        if response.multi_embeddings:
+            console.print(
+                f"Multi-embedding vectors: [cyan]{len(response.multi_embeddings)}[/cyan]"
+            )
+
+        if response.sparse_embeddings:
+            console.print(
+                f"Sparse embedding items: [cyan]{len(response.sparse_embeddings)}[/cyan]"
+            )
+
+        if response.usage:
+            console.print(f"Tokens used: [dim]{response.usage.total_tokens}[/dim]")
+
+        if output:
+            os.makedirs(os.path.dirname(os.path.abspath(output)), exist_ok=True)
+
+            output_data = {
+                "object": response.object,
+                "model": response.model,
+                "id": response.id,
+                "created": response.created,
+            }
+
+            if response.data:
+                output_data["data"] = {
+                    "object": response.data.object,
+                    "index": response.data.index,
+                }
+                if response.data.embedding:
+                    output_data["data"]["embedding"] = response.data.embedding
+                if response.data.multi_embedding:
+                    output_data["data"]["multi_embedding"] = response.data.multi_embedding
+                if response.data.sparse_embedding:
+                    output_data["data"]["sparse_embedding"] = [
+                        {"index": item.index, "value": item.value}
+                        for item in response.data.sparse_embedding
+                    ]
+
+            if response.usage:
+                output_data["usage"] = {
+                    "prompt_tokens": response.usage.prompt_tokens,
+                    "total_tokens": response.usage.total_tokens,
+                }
+                if response.usage.prompt_tokens_details:
+                    output_data["usage"]["prompt_tokens_details"] = {
+                        "image_tokens": response.usage.prompt_tokens_details.image_tokens,
+                        "text_tokens": response.usage.prompt_tokens_details.text_tokens,
+                    }
+
+            with open(output, "w", encoding="utf-8") as f:
+                json.dump(output_data, f, indent=2, ensure_ascii=False)
+
+            console.print(f"[green]✓[/green] Embedding saved to: [bold]{output}[/bold]")
+
+    except Exception as e:
+        console.print(f"[red]✗ Error: {str(e)}[/red]")
+        raise click.Abort()