dify-oapi2 0.5.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

dify_oapi/api/knowledge/v1/model/process_rule.py

@@ -6,7 +6,6 @@ from pydantic import BaseModel
 
 from .knowledge_types import ProcessingMode
 from .process_rules import ProcessRules
-from .segmentation_rule import SegmentationRule
 
 
 class ProcessRule(BaseModel):
@@ -14,7 +13,6 @@ class ProcessRule(BaseModel):
 
     mode: Optional[ProcessingMode] = None
     rules: Optional[ProcessRules] = None
-    segmentation: Optional[SegmentationRule] = None
 
     @staticmethod
     def builder() -> "ProcessRuleBuilder":
@@ -37,7 +35,3 @@ class ProcessRuleBuilder:
     def rules(self, rules: ProcessRules) -> "ProcessRuleBuilder":
         self._process_rule.rules = rules
         return self
-
-    def segmentation(self, segmentation: SegmentationRule) -> "ProcessRuleBuilder":
-        self._process_rule.segmentation = segmentation
-        return self

dify_oapi/api/knowledge/v1/model/update_document_by_file_request.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import json
 from io import BytesIO
 
 from dify_oapi.core.enum import HttpMethod
@@ -50,8 +49,7 @@ class UpdateDocumentByFileRequestBuilder:
 
     def request_body(self, request_body: UpdateDocumentByFileRequestBody) -> UpdateDocumentByFileRequestBuilder:
         self._update_document_by_file_request.request_body = request_body
-        data_dict = request_body.model_dump(exclude_none=True, mode="json")
-        self._update_document_by_file_request.body = {"data": json.dumps(data_dict)}
+        self._update_document_by_file_request.body = request_body.model_dump(exclude_none=True, mode="json")
         return self
 
     def file(self, file: BytesIO, file_name: str | None = None) -> UpdateDocumentByFileRequestBuilder:

dify_oapi/api/knowledge/v1/model/update_document_by_file_request_body.py

@@ -4,22 +4,13 @@ from __future__ import annotations
 
 from pydantic import BaseModel
 
-from .knowledge_types import IndexingTechnique
-from .process_rule import ProcessRule
-from .retrieval_model import RetrievalModel
+from .update_document_by_file_request_body_data import UpdateDocumentByFileRequestBodyData
 
 
 class UpdateDocumentByFileRequestBody(BaseModel):
     """Request body model for update document by file API."""
 
-    name: str | None = None
-    indexing_technique: IndexingTechnique | None = None
-    doc_form: str | None = None
-    doc_language: str | None = None
-    process_rule: ProcessRule | None = None
-    retrieval_model: RetrievalModel | None = None
-    embedding_model: str | None = None
-    embedding_model_provider: str | None = None
+    data: str | None = None
 
     @staticmethod
     def builder() -> UpdateDocumentByFileRequestBodyBuilder:
@@ -35,34 +26,6 @@ class UpdateDocumentByFileRequestBodyBuilder:
     def build(self) -> UpdateDocumentByFileRequestBody:
         return self._update_document_by_file_request_body
 
-    def name(self, name: str) -> UpdateDocumentByFileRequestBodyBuilder:
-        self._update_document_by_file_request_body.name = name
-        return self
-
-    def indexing_technique(self, indexing_technique: IndexingTechnique) -> UpdateDocumentByFileRequestBodyBuilder:
-        self._update_document_by_file_request_body.indexing_technique = indexing_technique
-        return self
-
-    def process_rule(self, process_rule: ProcessRule) -> UpdateDocumentByFileRequestBodyBuilder:
-        self._update_document_by_file_request_body.process_rule = process_rule
-        return self
-
-    def doc_form(self, doc_form: str) -> UpdateDocumentByFileRequestBodyBuilder:
-        self._update_document_by_file_request_body.doc_form = doc_form
-        return self
-
-    def doc_language(self, doc_language: str) -> UpdateDocumentByFileRequestBodyBuilder:
-        self._update_document_by_file_request_body.doc_language = doc_language
-        return self
-
-    def retrieval_model(self, retrieval_model: RetrievalModel) -> UpdateDocumentByFileRequestBodyBuilder:
-        self._update_document_by_file_request_body.retrieval_model = retrieval_model
-        return self
-
-    def embedding_model(self, embedding_model: str) -> UpdateDocumentByFileRequestBodyBuilder:
-        self._update_document_by_file_request_body.embedding_model = embedding_model
-        return self
-
-    def embedding_model_provider(self, embedding_model_provider: str) -> UpdateDocumentByFileRequestBodyBuilder:
-        self._update_document_by_file_request_body.embedding_model_provider = embedding_model_provider
+    def data(self, data: UpdateDocumentByFileRequestBodyData) -> UpdateDocumentByFileRequestBodyBuilder:
+        self._update_document_by_file_request_body.data = data.model_dump_json(exclude_none=True)
         return self

dify_oapi/api/knowledge/v1/model/update_document_by_file_request_body_data.py

@@ -0,0 +1,68 @@
+"""Update document by file request body model."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .knowledge_types import IndexingTechnique
+from .process_rule import ProcessRule
+from .retrieval_model import RetrievalModel
+
+
+class UpdateDocumentByFileRequestBodyData(BaseModel):
+    """Request body model for update document by file API."""
+
+    name: str | None = None
+    indexing_technique: IndexingTechnique | None = None
+    doc_form: str | None = None
+    doc_language: str | None = None
+    process_rule: ProcessRule | None = None
+    retrieval_model: RetrievalModel | None = None
+    embedding_model: str | None = None
+    embedding_model_provider: str | None = None
+
+    @staticmethod
+    def builder() -> UpdateDocumentByFileRequestBodyDataBuilder:
+        return UpdateDocumentByFileRequestBodyDataBuilder()
+
+
+class UpdateDocumentByFileRequestBodyDataBuilder:
+    """Builder for UpdateDocumentByFileRequestBodyData."""
+
+    def __init__(self) -> None:
+        self._update_document_by_file_request_body = UpdateDocumentByFileRequestBodyData()
+
+    def build(self) -> UpdateDocumentByFileRequestBodyData:
+        return self._update_document_by_file_request_body
+
+    def name(self, name: str) -> UpdateDocumentByFileRequestBodyDataBuilder:
+        self._update_document_by_file_request_body.name = name
+        return self
+
+    def indexing_technique(self, indexing_technique: IndexingTechnique) -> UpdateDocumentByFileRequestBodyDataBuilder:
+        self._update_document_by_file_request_body.indexing_technique = indexing_technique
+        return self
+
+    def process_rule(self, process_rule: ProcessRule) -> UpdateDocumentByFileRequestBodyDataBuilder:
+        self._update_document_by_file_request_body.process_rule = process_rule
+        return self
+
+    def doc_form(self, doc_form: str) -> UpdateDocumentByFileRequestBodyDataBuilder:
+        self._update_document_by_file_request_body.doc_form = doc_form
+        return self
+
+    def doc_language(self, doc_language: str) -> UpdateDocumentByFileRequestBodyDataBuilder:
+        self._update_document_by_file_request_body.doc_language = doc_language
+        return self
+
+    def retrieval_model(self, retrieval_model: RetrievalModel) -> UpdateDocumentByFileRequestBodyDataBuilder:
+        self._update_document_by_file_request_body.retrieval_model = retrieval_model
+        return self
+
+    def embedding_model(self, embedding_model: str) -> UpdateDocumentByFileRequestBodyDataBuilder:
+        self._update_document_by_file_request_body.embedding_model = embedding_model
+        return self
+
+    def embedding_model_provider(self, embedding_model_provider: str) -> UpdateDocumentByFileRequestBodyDataBuilder:
+        self._update_document_by_file_request_body.embedding_model_provider = embedding_model_provider
+        return self

dify_oapi/api/knowledge/v1/resource/__init__.py

@@ -1,8 +0,0 @@
-from .chunk import Chunk
-from .dataset import Dataset
-from .document import Document
-from .model import Model
-from .segment import Segment
-from .tag import Tag
-
-__all__ = ["Chunk", "Dataset", "Document", "Model", "Segment", "Tag"]

dify_oapi/api/workflow/v1/resource/workflow.py

@@ -5,12 +5,6 @@ from dify_oapi.core.http.transport import ATransport, Transport
 from dify_oapi.core.model.config import Config
 from dify_oapi.core.model.request_option import RequestOption
 
-from ..model.get_info_request import GetInfoRequest
-from ..model.get_info_response import GetInfoResponse
-from ..model.get_parameters_request import GetParametersRequest
-from ..model.get_parameters_response import GetParametersResponse
-from ..model.get_site_request import GetSiteRequest
-from ..model.get_site_response import GetSiteResponse
 from ..model.get_workflow_logs_request import GetWorkflowLogsRequest
 from ..model.get_workflow_logs_response import GetWorkflowLogsResponse
 from ..model.get_workflow_run_detail_request import GetWorkflowRunDetailRequest
@@ -19,8 +13,6 @@ from ..model.run_workflow_request import RunWorkflowRequest
 from ..model.run_workflow_response import RunWorkflowResponse
 from ..model.stop_workflow_request import StopWorkflowRequest
 from ..model.stop_workflow_response import StopWorkflowResponse
-from ..model.upload_file_request import UploadFileRequest
-from ..model.upload_file_response import UploadFileResponse
 
 
 class Workflow:
@@ -97,12 +89,6 @@ class Workflow:
     async def astop(self, request: StopWorkflowRequest, request_option: RequestOption) -> StopWorkflowResponse:
         return await ATransport.aexecute(self.config, request, unmarshal_as=StopWorkflowResponse, option=request_option)
 
-    def upload(self, request: UploadFileRequest, request_option: RequestOption) -> UploadFileResponse:
-        return Transport.execute(self.config, request, unmarshal_as=UploadFileResponse, option=request_option)
-
-    async def aupload(self, request: UploadFileRequest, request_option: RequestOption) -> UploadFileResponse:
-        return await ATransport.aexecute(self.config, request, unmarshal_as=UploadFileResponse, option=request_option)
-
     def logs(self, request: GetWorkflowLogsRequest, request_option: RequestOption) -> GetWorkflowLogsResponse:
         return Transport.execute(self.config, request, unmarshal_as=GetWorkflowLogsResponse, option=request_option)
 
@@ -110,23 +96,3 @@ class Workflow:
         return await ATransport.aexecute(
             self.config, request, unmarshal_as=GetWorkflowLogsResponse, option=request_option
         )
-
-    def info(self, request: GetInfoRequest, request_option: RequestOption) -> GetInfoResponse:
-        return Transport.execute(self.config, request, unmarshal_as=GetInfoResponse, option=request_option)
-
-    async def ainfo(self, request: GetInfoRequest, request_option: RequestOption) -> GetInfoResponse:
-        return await ATransport.aexecute(self.config, request, unmarshal_as=GetInfoResponse, option=request_option)
-
-    def parameters(self, request: GetParametersRequest, request_option: RequestOption) -> GetParametersResponse:
-        return Transport.execute(self.config, request, unmarshal_as=GetParametersResponse, option=request_option)
-
-    async def aparameters(self, request: GetParametersRequest, request_option: RequestOption) -> GetParametersResponse:
-        return await ATransport.aexecute(
-            self.config, request, unmarshal_as=GetParametersResponse, option=request_option
-        )
-
-    def site(self, request: GetSiteRequest, request_option: RequestOption) -> GetSiteResponse:
-        return Transport.execute(self.config, request, unmarshal_as=GetSiteResponse, option=request_option)
-
-    async def asite(self, request: GetSiteRequest, request_option: RequestOption) -> GetSiteResponse:
-        return await ATransport.aexecute(self.config, request, unmarshal_as=GetSiteResponse, option=request_option)

dify_oapi/api/workflow/v1/version.py

@@ -1,3 +1,7 @@
+from dify_oapi.api.dify.v1.resource.audio import Audio
+from dify_oapi.api.dify.v1.resource.feedback import Feedback
+from dify_oapi.api.dify.v1.resource.file import File
+from dify_oapi.api.dify.v1.resource.info import Info
 from dify_oapi.core.model.config import Config
 
 from .resource.workflow import Workflow
@@ -6,3 +10,8 @@ from .resource.workflow import Workflow
 class V1:
     def __init__(self, config: Config):
         self.workflow = Workflow(config)
+        # System APIs - delegate to dify module
+        self.file = File(config)
+        self.audio = Audio(config)
+        self.info = Info(config)
+        self.feedback = Feedback(config)

dify_oapi/client.py

@@ -6,7 +6,7 @@ from .api.chat.service import ChatService
 from .api.chatflow.service import ChatflowService
 from .api.completion.service import CompletionService
 from .api.dify.service import DifyService
-from .api.knowledge.service import Knowledge
+from .api.knowledge.service import KnowledgeService
 from .api.workflow.service import WorkflowService
 from .core.enum import LogLevel
 from .core.http.transport import Transport
@@ -24,7 +24,7 @@ class Client:
         self._completion: CompletionService | None = None
         self._dify: DifyService | None = None
         self._workflow: WorkflowService | None = None
-        self._knowledge: Knowledge | None = None
+        self._knowledge: KnowledgeService | None = None
 
     @property
     def chat(self) -> ChatService:
@@ -57,7 +57,7 @@ class Client:
         return self._workflow
 
     @property
-    def knowledge(self) -> Knowledge:
+    def knowledge(self) -> KnowledgeService:
         if self._knowledge is None:
             raise RuntimeError("Knowledge base service has not been initialized")
         return self._knowledge
@@ -135,7 +135,7 @@ class ClientBuilder:
         client._completion = CompletionService(self._config)
         client._dify = DifyService(self._config)
         client._workflow = WorkflowService(self._config)
-        client._knowledge = Knowledge(self._config)
+        client._knowledge = KnowledgeService(self._config)
         return client
 
     def _init_logger(self):

dify_oapi2-1.0.0.dist-info/METADATA

@@ -0,0 +1,365 @@
+Metadata-Version: 2.3
+Name: dify-oapi2
+Version: 1.0.0
+Summary: A package for interacting with the Dify Service-API
+License: MIT
+Keywords: dify,nlp,ai,language-processing
+Author: Oscaner Miao
+Author-email: oscaner1997@gmail.com
+Requires-Python: >=3.10
+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
+Requires-Dist: httpx (>=0,<1)
+Requires-Dist: pydantic (>=2,<3)
+Project-URL: Homepage, https://github.com/nodite/dify-oapi2
+Project-URL: Source, https://github.com/nodite/dify-oapi2
+Description-Content-Type: text/markdown
+
+# Dify-OAPI
+
+[![PyPI version](https://badge.fury.io/py/dify-oapi2.svg)](https://badge.fury.io/py/dify-oapi2)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+A modern Python SDK for interacting with the Dify Service-API. This library provides a fluent, type-safe interface for building AI-powered applications using Dify's comprehensive API services including chat, completion, knowledge base, workflow, and chatflow features.
+
+> This project is based on https://github.com/QiMington/dify-oapi, completely refactored with modern Python practices and full support for the latest Dify API.
+
+## ✨ Features
+
+- **Complete API Coverage**: Chat (18 APIs), Chatflow (15 APIs), Completion (10 APIs), Knowledge Base (33 APIs), Workflow (4 APIs), and Core Dify (9 APIs)
+- **Builder Pattern**: Fluent, chainable interface for constructing requests
+- **Sync & Async Support**: Both synchronous and asynchronous operations
+- **Streaming Responses**: Real-time streaming for chat and completion
+- **Type Safety**: Comprehensive type hints with Pydantic 2.x validation
+- **File Upload**: Support for images and documents
+- **Modern HTTP Client**: Built on httpx for reliable API communication
+- **Connection Pool Optimization**: Efficient TCP connection reuse to reduce resource overhead
+
+## 📦 Installation
+
+```bash
+pip install dify-oapi2
+```
+
+**Requirements**: Python 3.10+
+
+**Core Dependencies**:
+- `pydantic` (^2) - Data validation and settings management with type safety
+- `httpx` (^0) - Modern async HTTP client
+
+**Development Dependencies**:
+- `ruff` (^0) - Fast Python linter and formatter
+- `mypy` (^1) - Static type checking
+- `pytest` (^8) - Testing framework
+- `pre-commit` (^4) - Git hooks for code quality
+- `commitizen` (^4) - Semantic versioning and changelog generation
+- `poetry` - Dependency management and packaging
+
+## 🛠️ Technology Stack
+
+- **Language**: Python 3.10+
+- **HTTP Client**: httpx with connection pooling optimization
+- **Type System**: Pydantic 2.x with comprehensive type validation
+- **Architecture**: Builder pattern with fluent API design + Service layer pattern
+- **Async Support**: Full async/await support with AsyncGenerator streaming
+- **Code Quality**: Ruff (linting + formatting) + MyPy (type checking)
+- **Testing**: pytest with async support and comprehensive coverage
+- **Packaging**: Poetry with modern Python packaging standards
+- **Total Coverage**: 89 API methods across 6 services with complete examples
+
+## 🚀 Quick Start
+
+### Basic Usage
+
+```python
+from dify_oapi.client import Client
+from dify_oapi.core.model.request_option import RequestOption
+from dify_oapi.api.chat.v1.model.chat_request import ChatRequest
+
+# Initialize client with builder pattern
+client = (
+    Client.builder()
+    .domain("https://api.dify.ai")
+    .max_connections(100)
+    .keepalive_expiry(30.0)
+    .build()
+)
+
+# Create request options
+req_option = RequestOption.builder().api_key("your-api-key").build()
+
+# Use the chat API
+response = client.chat.chat(
+    request=ChatRequest.builder()
+    .query("Hello, how are you?")
+    .user("user-123")
+    .build(),
+    request_option=req_option
+)
+
+print(response.answer)
+```
+
+### Comprehensive Examples
+
+Ready to build AI-powered applications? Check out our comprehensive examples:
+
+- **[Chat Examples](./examples/chat/)** - Interactive conversations and streaming responses
+- **[Chatflow Examples](./examples/chatflow/)** - Enhanced chat with workflow events
+- **[Knowledge Base Examples](./examples/knowledge/)** - Build and query knowledge bases
+- **[Workflow Examples](./examples/workflow/)** - Automate complex AI workflows
+- **[Complete Examples Collection](./examples/)** - All API services with detailed usage patterns
+
+Each example includes complete, runnable code with detailed explanations.
+
+## 🔧 API Services
+
+### Chat API (18 APIs)
+**Resources**: annotation (6), chat (3), conversation (6), message (3)
+- **Interactive Chat**: Send messages with blocking/streaming responses
+- **Conversation Management**: Complete conversation lifecycle operations
+- **Annotation System**: Create, update, delete annotations with reply settings
+- **Message Operations**: Basic message handling and history retrieval
+- **Streaming Support**: Real-time streaming for chat responses
+- **Type Safety**: Comprehensive type hints with strict Literal types
+
+### Chatflow API (15 APIs)
+**Resources**: annotation (6), chatflow (3), conversation (6)
+- **Enhanced Chat**: Advanced chat functionality with workflow events
+- **Conversation Management**: Complete conversation operations with variables
+- **Annotation System**: Full annotation management and reply configuration
+- **Workflow Integration**: Seamless integration with workflow events
+- **Event Streaming**: Real-time streaming with comprehensive event handling
+- **Type Safety**: Strict Literal types for all predefined values
+
+### Completion API (10 APIs)
+**Resources**: annotation (6), completion (4)
+- **Text Generation**: Advanced text completion and generation
+- **Message Processing**: Send messages and control text generation
+- **Annotation Management**: Create, update, and manage annotations
+- **Generation Control**: Stop ongoing text generation processes
+- **Streaming Support**: Real-time text generation with streaming responses
+- **Type Safety**: Full type validation with Pydantic models
+
+### Knowledge Base API (33 APIs)
+**Resources**: chunk (4), dataset (6), document (10), model (1), segment (5), tag (7)
+- **Dataset Management**: Complete dataset CRUD operations and content retrieval
+- **Document Processing**: File upload, text processing, and batch management
+- **Content Organization**: Fine-grained segmentation and chunk management
+- **Tag System**: Flexible tagging and categorization system
+- **Model Integration**: Embedding model information and configuration
+- **Search & Retrieval**: Advanced search with multiple retrieval strategies
+
+### Workflow API (4 APIs)
+**Resources**: workflow (4)
+- **Workflow Execution**: Run workflows with blocking or streaming responses
+- **Execution Control**: Stop running workflows and monitor progress
+- **Log Management**: Retrieve detailed execution logs and run details
+- **Parameter Support**: Flexible workflow parameter configuration
+
+### Dify Core API (9 APIs)
+**Resources**: audio (2), feedback (2), file (1), info (4)
+- **Audio Processing**: Speech-to-text and text-to-speech conversion
+- **Feedback System**: Submit and retrieve user feedback
+- **File Management**: Unified file upload and processing
+- **Application Info**: App configuration, parameters, and metadata access
+
+## 💡 Examples
+
+Explore comprehensive examples in the [examples directory](./examples):
+
+### Chat Examples
+- [**Chat Messages**](./examples/chat/chat/) - Send messages, stop generation, get suggestions
+- [**Conversation Management**](./examples/chat/conversation/) - Complete conversation operations
+- [**Message Operations**](./examples/chat/message/) - Basic message operations
+- [**Annotation Management**](./examples/chat/annotation/) - Annotation CRUD and reply settings
+
+*Note: File upload and feedback examples are available in [Dify Core API](./examples/dify/) as shared services.*
+
+### Completion Examples
+- [**Completion Operations**](./examples/completion/completion/) - Text generation and completion
+- [**Annotation Management**](./examples/completion/annotation/) - Annotation operations
+
+### Knowledge Base Examples
+- [**Dataset Management**](./examples/knowledge/dataset/) - Complete dataset operations
+- [**Document Processing**](./examples/knowledge/document/) - File upload and text processing
+- [**Content Organization**](./examples/knowledge/segment/) - Segment and chunk management
+- [**Tag Management**](./examples/knowledge/tag/) - Metadata and tagging system
+
+### Chatflow Examples
+- [**Advanced Chat**](./examples/chatflow/chatflow/) - Enhanced chat with streaming and workflow events
+- [**Conversation Management**](./examples/chatflow/conversation/) - Complete conversation operations
+- [**Annotation Management**](./examples/chatflow/annotation/) - Annotation CRUD and reply settings
+
+### Dify Core Examples
+- [**Audio Processing**](./examples/dify/audio/) - Speech-to-text and text-to-speech
+- [**Feedback Management**](./examples/dify/feedback/) - User feedback collection
+- [**File Management**](./examples/dify/file/) - File upload and processing
+- [**Application Info**](./examples/dify/info/) - App configuration and metadata
+
+### Workflow Examples
+- [**Workflow Operations**](./examples/workflow/workflow/) - Workflow execution and management
+- [**File Upload**](./examples/workflow/file/) - File upload for workflows
+
+For detailed examples and usage patterns, see the [examples README](./examples/README.md).
+
+## 🛠️ Development
+
+### Prerequisites
+- Python 3.10+
+- Poetry (for dependency management)
+- Git (for version control)
+
+### Setup
+
+```bash
+# Clone repository
+git clone https://github.com/nodite/dify-oapi2.git
+cd dify-oapi2
+
+# Setup development environment (installs dependencies and pre-commit hooks)
+make dev-setup
+```
+
+### Code Quality Tools
+
+This project uses modern Python tooling for code quality:
+
+- **Ruff**: Fast Python linter and formatter (replaces Black + isort + flake8)
+- **MyPy**: Static type checking for type safety
+- **Pre-commit**: Git hooks for automated code quality checks
+- **Poetry**: Modern dependency management and packaging
+
+```bash
+# Format code
+make format
+
+# Lint code
+make lint
+
+# Fix linting issues
+make fix
+
+# Run all checks (lint + type check)
+make check
+
+# Install pre-commit hooks
+make install-hooks
+
+# Run pre-commit hooks manually
+make pre-commit
+```
+
+### Testing
+
+```bash
+# Set environment variables for integration tests
+export DOMAIN="https://api.dify.ai"
+export CHAT_KEY="your-chat-api-key"
+export CHATFLOW_KEY="your-chatflow-api-key"
+export COMPLETION_KEY="your-completion-api-key"
+export DIFY_KEY="your-dify-api-key"
+export WORKFLOW_KEY="your-workflow-api-key"
+export KNOWLEDGE_KEY="your-knowledge-api-key"
+
+# Run tests
+make test
+
+# Run tests with coverage
+make test-cov
+
+# Run specific test module
+poetry run pytest tests/knowledge/ -v
+```
+
+### Build & Publish
+
+```bash
+# Configure PyPI tokens (one-time setup)
+poetry config http-basic.testpypi __token__ <your-testpypi-token>
+poetry config http-basic.pypi __token__ <your-pypi-token>
+
+# Build package
+make build
+
+# Publish to TestPyPI (for testing)
+make publish-test
+
+# Publish to PyPI (maintainers only)
+make publish
+```
+
+### Project Structure
+
+```
+dify-oapi2/
+├── dify_oapi/           # Main SDK package
+│   ├── api/             # API service modules
+│   │   ├── chat/        # Chat API (18 APIs)
+│   │   │   └── v1/      # Version 1 implementation
+│   │   ├── chatflow/    # Chatflow API (15 APIs)
+│   │   │   └── v1/      # Version 1 implementation
+│   │   ├── completion/  # Completion API (10 APIs)
+│   │   │   └── v1/      # Version 1 implementation
+│   │   ├── dify/        # Core Dify API (9 APIs)
+│   │   │   └── v1/      # Version 1 implementation
+│   │   ├── knowledge/   # Knowledge Base API (33 APIs)
+│   │   │   └── v1/      # Version 1 implementation
+│   │   └── workflow/    # Workflow API (6 APIs)
+│   │       └── v1/      # Version 1 implementation
+│   ├── core/            # Core functionality
+│   │   ├── http/        # HTTP transport layer with connection pooling
+│   │   ├── model/       # Base models and configurations
+│   │   └── utils/       # Utility functions
+│   └── client.py        # Main client interface with builder pattern
+├── docs/                # Comprehensive documentation
+├── examples/            # Complete usage examples for all APIs
+├── tests/               # Comprehensive test suite
+├── pyproject.toml       # Project configuration (Poetry + tools)
+├── Makefile            # Development automation
+└── DEVELOPMENT.md      # Development guide
+```
+
+## 📖 Documentation
+
+- [**Development Guide**](./DEVELOPMENT.md) - Setup, workflow, and contribution guidelines
+- [**Project Overview**](./docs/overview.md) - Architecture and technical details
+- [**API Documentation**](./docs/) - Complete API documentation by service
+- [**Examples**](./examples/README.md) - Comprehensive usage examples and patterns
+
+
+## 🤝 Contributing
+
+Contributions are welcome! Please follow our development workflow:
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Make your changes with comprehensive tests
+4. Ensure code quality passes (`make check`)
+5. Run the full test suite (`make test`)
+6. Commit your changes (`git commit -m 'Add amazing feature'`)
+7. Push to the branch (`git push origin feature/amazing-feature`)
+8. Submit a pull request
+
+See [DEVELOPMENT.md](./DEVELOPMENT.md) for detailed development guidelines.
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](./LICENSE) file for details.
+
+## 🔗 Links
+
+- **PyPI Package**: https://pypi.org/project/dify-oapi2/
+- **Source Code**: https://github.com/nodite/dify-oapi2
+- **Dify Platform**: https://dify.ai/
+- **Dify API Docs**: https://docs.dify.ai/
+
+---
+
+**Keywords**: dify, ai, nlp, language-processing, python-sdk, async, type-safe, api-client
+