Zenoo RPC

https://zenoo-rpc.readthedocs.io/en/latest
Admin
Zenoo RPC is a modern, async Python library for Odoo RPC, offering type safety, a fluent API, and...
Tokens:670,477
Snippets:3,518
Trust Score:8.3
Update:1 year ago
Show doc for...
Tokens:
Raw
### Zenoo RPC Examples - Integration Examples

Source: https://zenoo-rpc.readthedocs.io/en/latest/getting-started/installation

Provides examples of integrating Zenoo RPC with other libraries or frameworks.

```python
# Integration examples might include:
# - Connecting Zenoo RPC clients to services hosted on different platforms.
# - Using Zenoo RPC with asynchronous frameworks like asyncio or Starlette.
# - Integrating with message queues or databases.
```

--------------------------------

### Zenoo RPC Examples - Real-World Performance Metrics

Source: https://zenoo-rpc.readthedocs.io/en/latest/getting-started/installation

Example of using Zenoo RPC to collect and expose performance metrics.

```python
# Conceptual example for performance metrics
# RPC methods to retrieve system metrics, request latency, error rates.
# Caching can be used for frequently requested metrics.
```

--------------------------------

### Zenoo RPC Examples - Real-World Data Visualization

Source: https://zenoo-rpc.readthedocs.io/en/latest/getting-started/installation

Example of using Zenoo RPC to serve data for visualization tools.

```python
# Conceptual example for data visualization
# RPC methods designed to return data in formats suitable for charting libraries (e.g., JSON arrays).
# Efficient querying is key.
```

--------------------------------

### Zenoo RPC Examples - Real-World Automated Workflows

Source: https://zenoo-rpc.readthedocs.io/en/latest/getting-started/installation

Example showcasing Zenoo RPC for orchestrating automated workflows.

```python
# Conceptual example for automated workflows
# RPC methods that trigger specific actions or sequences of operations.
# Transaction management might be used for workflow steps.
```

--------------------------------

### Zenoo RPC User Guide - Client Usage

Source: https://zenoo-rpc.readthedocs.io/en/latest/getting-started/installation

Guide to using the Zenoo RPC client, covering connection, request, and response handling.

```python
from zenoo_rpc.client import Client

# Example of client usage
client = Client(url='http://localhost:8000')
result = client.call('my_method', arg1='value1')
print(result)
```

--------------------------------

### Zenoo RPC Examples - Real-World FastAPI Integration

Source: https://zenoo-rpc.readthedocs.io/en/latest/getting-started/installation

Example demonstrating integration of Zenoo RPC with FastAPI applications.

```python
# Conceptual example for FastAPI integration
# Using Zenoo RPC client within FastAPI routes or vice-versa.
# from fastapi import FastAPI
# from zenoo_rpc.client import Client

# app = FastAPI()
# rpc_client = Client(url='...')

# @app.get('/items/{item_id}')
# async def read_item(item_id: int):
#     return await rpc_client.call_async('get_item', item_id=item_id)
```

--------------------------------

### Zenoo RPC Examples - Real-World Customer Management

Source: https://zenoo-rpc.readthedocs.io/en/latest/getting-started/installation

Example demonstrating Zenoo RPC usage for a customer management system.

```python
# Conceptual example for customer management
# Models for Customer, Order, etc.
# RPC methods like create_customer, get_customer_orders, update_customer_address
```

--------------------------------

### Zenoo RPC Examples - Common Patterns

Source: https://zenoo-rpc.readthedocs.io/en/latest/getting-started/installation

Highlights common patterns and best practices when using Zenoo RPC.

```python
# Common patterns:
# - Service-oriented architecture with clear RPC interfaces.
# - Consistent use of models for data exchange.
# - Implementing robust error handling and retry logic.
# - Leveraging caching and batching for performance.
```

--------------------------------

### Zenoo RPC Examples - Real-World Sales Dashboard

Source: https://zenoo-rpc.readthedocs.io/en/latest/getting-started/installation

Example showcasing Zenoo RPC for building a sales dashboard application.

```python
# Conceptual example for sales dashboard
# RPC methods to fetch sales data, product performance, customer trends.
# Query builder used for filtering sales by date, region, product.
```

--------------------------------

### Zenoo RPC Examples - Real-World Email Automation

Source: https://zenoo-rpc.readthedocs.io/en/latest/getting-started/installation

Example demonstrating Zenoo RPC for email automation tasks.

```python
# Conceptual example for email automation
# RPC methods to send emails, manage templates, or process email events.
# Error handling for email delivery failures is crucial.
```

--------------------------------

### Zenoo RPC Contributing - Development Setup

Source: https://zenoo-rpc.readthedocs.io/en/latest/examples/real-world/data-visualization

Instructions for setting up your development environment to contribute to Zenoo RPC.

```APIDOC
Contributing Development Setup: https://zenoo-rpc.readthedocs.io/en/latest/contributing/development/
```

--------------------------------

### Zenoo RPC Examples - Real-World Scheduled Tasks

Source: https://zenoo-rpc.readthedocs.io/en/latest/getting-started/installation

Example of using Zenoo RPC to manage and execute scheduled tasks.

```python
# Conceptual example for scheduled tasks
# RPC methods that can be invoked by a scheduler to perform background jobs.
# Retry mechanisms are important for task reliability.
```

--------------------------------

### Zenoo RPC Tutorials - Production Deployment

Source: https://zenoo-rpc.readthedocs.io/en/latest/getting-started/installation

Guide to deploying Zenoo RPC applications in a production environment, covering considerations for scalability and reliability.

```python
# Deployment considerations:
# - Use a production-ready web server (e.g., Gunicorn, Uvicorn).
# - Configure appropriate logging and monitoring.
# - Implement robust error handling and retry mechanisms.
# - Ensure secure communication (e.g., HTTPS).
```

--------------------------------

### Development Setup Script

Source: https://zenoo-rpc.readthedocs.io/en/latest/contributing/development

This script sets up the development environment by creating a virtual environment, installing dependencies (including redis extras), installing pre-commit hooks, and running initial tests.

```bash
#!/bin/bash
set
echo"Setting up development environment..."

# Create virtual environment
python -m venv .venv
source .venv/bin/activate

# Install dependencies
pip install .[dev,redis]

# Install pre-commit hooks
pre-commit install

# Run initial tests
pytest

echo"Development environment ready!"
```

--------------------------------

### Zenoo RPC Examples - Real-World Custom Reports

Source: https://zenoo-rpc.readthedocs.io/en/latest/getting-started/installation

Example demonstrating Zenoo RPC for generating custom reports.

```python
# Conceptual example for custom reports
# RPC methods that accept complex query parameters to generate tailored reports.
# Query builder is essential here.
```

--------------------------------

### Zenoo RPC Tutorials - Performance Optimization

Source: https://zenoo-rpc.readthedocs.io/en/latest/getting-started/installation

Guide to optimizing the performance of Zenoo RPC applications, covering caching, batching, and efficient querying.

```python
# Strategies for performance optimization:
# 1. Utilize caching for frequently accessed data.
# 2. Use batch operations to reduce network overhead.
# 3. Optimize queries to fetch only necessary data.
# 4. Consider efficient serialization formats.
```

--------------------------------

### Zenoo RPC Examples - Real-World Document Processing

Source: https://zenoo-rpc.readthedocs.io/en/latest/getting-started/installation

Example showcasing Zenoo RPC for document processing workflows.

```python
# Conceptual example for document processing
# RPC methods to upload, process, or retrieve documents.
# Efficient handling of potentially large data payloads.
```

--------------------------------

### Zenoo RPC Testing Framework Setup

Source: https://zenoo-rpc.readthedocs.io/en/latest/tutorials/testing

This section covers the initial setup for the Zenoo RPC testing framework, including installing necessary dependencies and configuring basic test settings.

```python
# Installing Test Dependencies
pip install pytest pytest-asyncio httpx

# Basic Test Configuration (pytest.ini)
[pytest]
asyncio_mode = auto
```

--------------------------------

### Zenoo RPC User Guide - Configuration

Source: https://zenoo-rpc.readthedocs.io/en/latest/getting-started/installation

Guide to configuring Zenoo RPC, covering various settings for client and server operations.

```python
# Example of configuration (conceptual)
# Configuration can be done via dictionaries, files, or environment variables.
# config = {
#     'client': {
#         'timeout': 60,
#         'retries': 3
#     },
#     'server': {
#         'host': '0.0.0.0',
#         'port': 8000
#     }
# }
# Load configuration into Zenoo RPC...
```

--------------------------------

### Zenoo RPC Development Environment Setup

Source: https://zenoo-rpc.readthedocs.io/en/latest/contributing/development

This snippet details the steps required to set up the development environment for the Zenoo RPC project. It includes cloning the repository, creating and activating a virtual environment, installing project dependencies (including optional Redis support), installing pre-commit hooks, and verifying the installation.

```bash
git clone <repository_url>
cd <repository_directory>
python -m venv venv
# On Windows: venv\Scripts\activate
# On Linux/macOS: source venv/bin/activate
pip install ".[dev,redis]"
pre-commit install
python -m pytest
```

--------------------------------

### Setup Python and Install Dependencies for Docs

Source: https://zenoo-rpc.readthedocs.io/en/latest/contributing/release

Configures the Python environment and installs necessary dependencies, including MkDocs and MkDocs-Material, for building the project documentation.

```yaml
steps:
-uses:actions/checkout@v3
- name:Set up Python
uses:actions/setup-python@v4
with:
  python-version:"3.11"
- name:Install dependencies
run: |
  pip install -e ".[dev]"
  pip install mkdocs mkdocs-material
```

--------------------------------

### Zenoo RPC User Guide - Query Builder

Source: https://zenoo-rpc.readthedocs.io/en/latest/getting-started/installation

Demonstrates how to use the Zenoo RPC query builder for constructing efficient data retrieval queries.

```python
from zenoo_rpc.query import Query, Filter, Expression

# Example of building a query
query = Query()
query.filter(Filter('name', Expression.EQUALS, 'Alice'))
query.select('id', 'name')

# In a client call:
# result = client.call('get_users', query=query)
```

--------------------------------

### Zenoo RPC Development Setup

Source: https://zenoo-rpc.readthedocs.io/en/latest/contributing/development

Details the necessary steps to set up a development environment for Zenoo RPC, including prerequisites, environment configuration, and installation of development dependencies.

```markdown
## Development Setup

* [Prerequisites](#prerequisites)
* [Environment Setup](#environment-setup)
* [Development Dependencies](#development-dependencies)
```

--------------------------------

### Zenoo RPC Contributing Guidelines

Source: https://zenoo-rpc.readthedocs.io/en/latest/examples/real-world/customer-management

Outlines the process for contributing to Zenoo RPC, including development setup, testing, documentation, and release procedures.

```APIDOC
Zenoo RPC Contributing Guidelines:
  Development Setup: https://zenoo-rpc.readthedocs.io/en/latest/contributing/development/
  Testing Guidelines: https://zenoo-rpc.readthedocs.io/en/latest/contributing/testing/
  Documentation Guidelines: https://zenoo-rpc.readthedocs.io/en/latest/contributing/documentation/
  Release Process: https://zenoo-rpc.readthedocs.io/en/latest/contributing/release/
```

--------------------------------

### Zenoo RPC User Guide - Batch Operations

Source: https://zenoo-rpc.readthedocs.io/en/latest/getting-started/installation

Guide to performing batch operations in Zenoo RPC for efficient execution of multiple requests.

```python
from zenoo_rpc.batch import BatchRequest

# Example of creating a batch request
batch = BatchRequest()
batch.add('method1', arg1='val1')
batch.add('method2', arg2='val2')

# Sending the batch request:
# results = client.call_batch(batch)
```

--------------------------------

### Customer Management App Example

Source: https://zenoo-rpc.readthedocs.io/en/latest/examples/patterns

Demonstrates the setup and execution of a Customer Management Application using Zenoo RPC. It includes configuration, startup, sample data creation, and shutdown procedures.

```python
for failure in results["failed"]:
    logger.warning(f"- {failure['request'].name}: {failure['error']}")

async def main():
    """Main application entry point."""
    config = {
        "environment": "development",
        "host": "localhost",
        "database": "demo",
        "username": "admin",
        "password": "admin"
    }

    app = CustomerManagementApp(config)

    try:
        await app.startup()
        await app.create_sample_customers()
    finally:
        await app.shutdown()

if __name__ == "__main__":
    asyncio.run(main())
```

--------------------------------

### Docker Compose Example for Zenoo RPC

Source: https://zenoo-rpc.readthedocs.io/en/latest/getting-started/installation

Provides a sample Docker Compose configuration for setting up Zenoo RPC with other services. This is useful for orchestrating multi-container applications.

```yaml
version: '3.8'

services:
  zenoo-rpc-app:
    image: python:3.9-slim
    volumes:
      - ./app:/app
    working_dir: /app
    command: python main.py
    depends_on:
      - redis

  redis:
    image: redis:latest
```

--------------------------------

### Usage Example for Extended Client

Source: https://zenoo-rpc.readthedocs.io/en/latest/advanced/extensions

Illustrates how to use the extended Zenoo RPC client after setup. It shows how to obtain the client, middleware, and plugins from the setup function, convert a partner object to vCard format using an extended model, and retrieve current metrics using the metrics plugin.

```python
# Usage
client, middleware, plugins = await setup_extended_client()

# Use extended models
partner = ExtendedPartner(name="Test Company", is_company=True)
vcard = partner.to_vcard()

# Get metrics
metrics_plugin = plugins.get_plugin("metrics")
current_metrics = metrics_plugin.get_metrics()
```

--------------------------------

### Zenoo RPC Testing Framework Setup

Source: https://zenoo-rpc.readthedocs.io/en/latest/tutorials/testing

Details on installing test dependencies and configuring a basic test environment for Zenoo RPC projects. This is crucial for setting up automated testing workflows.

```python
# Installing Test Dependencies
# Example using pip:
pip install pytest pytest-mock

# Basic Test Configuration
# Example pytest.ini or conftest.py setup:
# [pytest]
# pythonpath = .
# addopts = --cov=zenoo_rpc --cov-report=term-missing

```

--------------------------------

### Zenoo RPC Real-world Examples

Source: https://zenoo-rpc.readthedocs.io/en/latest/examples/real-world

Examples of real-world applications using Zenoo RPC, including code structure and getting started guides.

```APIDOC
Real-world Examples:
  Code Structure: Example code structure for real-world applications.
  Getting Started: Guide to getting started with real-world examples.
  Contributing Examples: Guidelines for contributing examples.
```

--------------------------------

### Zenoo RPC Quick Start: Your First Zenoo RPC Script

Source: https://zenoo-rpc.readthedocs.io/en/latest/getting-started/quickstart

This section guides users through creating their first Zenoo RPC script. It covers importing necessary modules, setting up and configuring the client, authenticating with the server, and performing type-safe data queries.

```python
from zenoo_rpc import ZenooRPC

# 1. Import Required Modules
# (Already done above)

# 2. Create and Configure Client
client = ZenooRPC(host='localhost', port=8069, db='your_database')

# 3. Authenticate
client.authenticate('your_username', 'your_password')

# 4. Query Data with Type Safety
# Example: Fetching users
users = client.env['res.users'].search_read()
print(users)

# Example: Creating a record
# new_user_id = client.env['res.users'].create({'name': 'New User', 'login': 'newuser'})
# print(f'Created user with ID: {new_user_id}')

# Example: Updating a record
# client.env['res.users'].write(user_id_to_update, {'name': 'Updated Name'})

# Example: Deleting a record
# client.env['res.users'].unlink(user_id_to_delete)

```

--------------------------------

### Zenoo RPC Documentation Directory Structure

Source: https://zenoo-rpc.readthedocs.io/en/latest/contributing/documentation

This snippet details the file and directory structure of the Zenoo RPC documentation. It categorizes documentation into sections such as the main homepage, getting started guides, user guides, tutorials, API references, examples, and advanced topics.

```markdown
docs/
├── index.md                    # Main documentation homepage
├── getting-started/            # Getting started guides
│   ├── installation.md
│   ├── quickstart.md
│   └── migration.md
├── user-guide/                 # User guides and tutorials
│   ├── basic-usage.md
│   ├── advanced-features.md
│   ├── models-and-fields.md
│   ├── query-building.md
│   ├── caching.md
│   ├── batch-operations.md
│   ├── error-handling.md
│   ├── performance-tips.md
│   ├── configuration.md
│   └── best-practices.md
├── tutorials/                  # Step-by-step tutorials
│   ├── basic-crud.md
│   ├── advanced-queries.md
│   ├── batch-processing.md
│   ├── caching-strategies.md
│   └── integration-patterns.md
├── api-reference/              # Complete API documentation
│   ├── index.md
│   ├── client.md
│   ├── models/
│   ├── query/
│   ├── cache/
│   ├── batch/
│   ├── retry/
│   ├── transaction/
│   └── exceptions/
├── examples/                   # Practical examples
│   ├── index.md
│   ├── basic-examples.md
│   ├── advanced-examples.md
│   └── integration-examples.md
├── advanced/                   # Advanced topics
│   ├── architecture.md
```

--------------------------------

### Setup Automated Email Workflows

Source: https://zenoo-rpc.readthedocs.io/en/latest/examples/real-world/email-automation

This function sets up various automated email workflows. It includes placeholders for setting up welcome emails and order confirmation emails, indicating a modular approach to email automation.

```python
    async defsetup_automated_workflows(self):
        """Setup automated email workflows based on customer actions."""

        # Welcome email workflow
        await self._setup_welcome_email_workflow()

        # Order confirmation workflow
        await self._setup_order_confirmation_workflow()
```

--------------------------------

### Virtual Environment Setup using venv

Source: https://zenoo-rpc.readthedocs.io/en/latest/getting-started/installation

Guides on creating and activating a virtual environment using Python's built-in `venv` module. This isolates project dependencies from the global Python installation.

```bash
# Create a virtual environment
python -m venv venv

# Activate the virtual environment (Linux/macOS)
source venv/bin/activate

# Activate the virtual environment (Windows)
.\venv\Scripts\activate
```

--------------------------------

### Documentation Navigation Structure

Source: https://zenoo-rpc.readthedocs.io/en/latest/contributing/documentation

Defines the navigation menu for the documentation, organizing content into sections like Home, Getting Started, and User Guide with links to respective pages.

```yaml
nav:
  - Home: index.md
  - Getting Started:
    - Installation: getting-started/installation.md
    - Quick Start: getting-started/quickstart.md
    - Migration: getting-started/migration.md
  - User Guide:
    - Basic Usage: user-guide/basic-usage.md
    - Advanced Features: user-guide/advanced-features.md
    - Models & Fields: user-guide/models-and-fields.md
    - Query Building: user-guide/query-building.md
    - Caching: user-guide/caching.md
    - Batch Operations: user-guide/batch-operations.md
    - Error Handling: user-guide/error-handling.md
    - Performance Tips: user-guide/performance-tips.md
    - Configuration: user-guide/configuration.md
```

--------------------------------

### Virtual Environment Setup using venv

Source: https://zenoo-rpc.readthedocs.io/en/latest/getting-started/installation

Guides on setting up a virtual environment for Zenoo RPC using Python's built-in `venv` module. This isolates project dependencies.

```bash
python -m venv venv
source venv/bin/activate
pip install zenoo-rpc
```

--------------------------------

### Django Integration with Zenoo RPC

Source: https://zenoo-rpc.readthedocs.io/en/latest/examples/integrations/django-integration

A comprehensive guide for integrating Zenoo RPC with Django applications, covering installation, settings, models, admin integration, REST API with Django REST Framework, Celery tasks, management commands, URL configuration, usage examples, best practices, and next steps.

```APIDOC
Django Integration:
  Overview
  Installation
  Django Settings
  Models
  Django Admin Integration
  REST API with Django REST Framework
  Celery Tasks
  Management Commands
  URL Configuration
  Usage Examples
  Best Practices
  Next Steps
```

--------------------------------

### Zenoo RPC Contribution Guidelines - Development Setup

Source: https://zenoo-rpc.readthedocs.io/en/latest/contributing/development

Details the development setup process for contributing to Zenoo RPC, including prerequisites, environment setup, and dependencies.

```APIDOC
Contributing - Development Setup:
  Development Setup: https://zenoo-rpc.readthedocs.io/en/latest/contributing/development/#development-setup
  Prerequisites: https://zenoo-rpc.readthedocs.io/en/latest/contributing/development/#prerequisites
  Environment Setup: https://zenoo-rpc.readthedocs.io/en/latest/contributing/development/#environment-setup
  Development Dependencies: https://zenoo-rpc.readthedocs.io/en/latest/contributing/development/#development-dependencies
```

--------------------------------

### Zenoo RPC Tutorials - Testing Strategies

Source: https://zenoo-rpc.readthedocs.io/en/latest/getting-started/installation

Discusses strategies for testing Zenoo RPC services and clients, including unit, integration, and end-to-end testing.

```python
# Example: Mocking a client for unit testing
from unittest.mock import MagicMock

# mock_client = MagicMock()
# mock_client.call.return_value = {'data': 'mocked_response'}

# # Use mock_client in your tests...
```

--------------------------------

### Zenoo RPC Tutorial - Production Deployment

Source: https://zenoo-rpc.readthedocs.io/en/latest/getting-started/quickstart

Best practices and considerations for deploying Zenoo RPC services in a production environment.

```APIDOC
Production Deployment:
  Objective: Deploy Zenoo RPC services reliably and scalably.
  Considerations:
    - Service Discovery: How clients find the RPC service endpoints.
    - Load Balancing: Distributing traffic across multiple service instances.
    - Monitoring: Tracking service health, performance, and errors.
    - Logging: Centralized logging for debugging and auditing.
    - Security: Implementing authentication, authorization, and TLS.
  Deployment Options:
    - Containerization (Docker, Kubernetes).
    - Serverless functions.
    - Traditional server deployments.
  Example (Kubernetes):
    Define Kubernetes Services and Deployments for your RPC server.
    Configure Ingress for external access and load balancing.
```

--------------------------------

### Zenoo RPC API Reference - Batch

Source: https://zenoo-rpc.readthedocs.io/en/latest/getting-started/installation

Documentation for Zenoo RPC's batch operations, covering overview and specific operations for efficient multi-request handling.

```APIDOC
Batch API:
  Overview: https://zenoo-rpc.readthedocs.io/en/latest/api-reference/batch/
  Operations: https://zenoo-rpc.readthedocs.io/en/latest/api-reference/batch/operations/
  Functionality: Allows sending multiple requests in a single batch for improved efficiency.
```

--------------------------------

### Get Zenoo RPC Client Dependency (Python)

Source: https://zenoo-rpc.readthedocs.io/en/latest/examples/real-world/fastapi-integration

Provides a FastAPI dependency to asynchronously retrieve and manage a singleton instance of the ZenooClient. It handles client initialization, connection pooling, and memory cache setup based on application settings. This ensures efficient reuse of the RPC client across requests.

```python
import asyncio
from typing import AsyncGenerator
from fastapi import Depends, HTTPException, status
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
from zenoo_rpc import ZenooClient
from zenoo_rpc.exceptions import ZenooError, AuthenticationError
from .config import settings
from .utils.auth import verify_token

security = HTTPBearer()

# Global client instance
_client_instance = None
_client_lock = asyncio.Lock()

async def get_zenoo_client() -> AsyncGenerator[ZenooClient, None]:
    """Dependency to get Zenoo RPC client instance"""
    global _client_instance

    async with _client_lock:
        if _client_instance is None:
            try:
                _client_instance = ZenooClient(
                    host=settings.odoo_host,
                    port=settings.odoo_port,
                    protocol=settings.odoo_protocol,
                    max_connections=settings.max_connections
                )

                # Setup caching
                await _client_instance.cache_manager.setup_memory_cache(
                    max_size=1000,
                    default_ttl=settings.cache_ttl
                )
            except (ZenooError, Exception) as e:
                raise HTTPException(
                    status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
                    detail=f"Failed to initialize Zenoo client: {e}"
                )

    yield _client_instance

    # Optional: Cleanup logic if needed when the client is no longer used
    # For a singleton, this might not be strictly necessary unless you want to
    # explicitly close connections on application shutdown.
    # For example:
    # if _client_instance:
    #     await _client_instance.close()
    #     _client_instance = None
```

--------------------------------

### Install Dependencies

Source: https://zenoo-rpc.readthedocs.io/en/latest/examples/real-world/fastapi-integration

Command to install project dependencies using pip. This is a standard step before running a Python application.

```bash
pip
```

--------------------------------

### Zenoo RPC Tutorials - Advanced Queries

Source: https://zenoo-rpc.readthedocs.io/en/latest/getting-started/installation

Tutorial on leveraging advanced query capabilities in Zenoo RPC for complex data filtering and selection.

```python
from zenoo_rpc.query import Query, Filter, Expression

# Example of an advanced query
query = Query()
query.filter(
    Filter.OR(
        Filter('status', Expression.EQUALS, 'active'),
        Filter('created_at', Expression.GREATER_THAN, '2023-01-01')
    )
)
query.order_by('name', ascending=True)
query.limit(10)

# result = client.call('search_items', query=query)
```

--------------------------------

### Zenoo RPC Contributing - Development Setup

Source: https://zenoo-rpc.readthedocs.io/en/latest/examples/patterns

Instructions for setting up a development environment for contributing to Zenoo RPC.

```APIDOC
Contributing - Development Setup:
  Overview: Steps to prepare your environment for contributing to Zenoo RPC.
  Prerequisites:
    - Python 3.7+ installed.
    - Git installed.
    - Virtual environment (recommended).
  Steps:
    1. Fork the repository.
    2. Clone your forked repository:
       git clone https://github.com/your-username/zenoo-rpc.git
    3. Navigate to the project directory:
       cd zenoo-rpc
    4. Create and activate a virtual environment:
       python -m venv venv
       source venv/bin/activate  # On Windows use `venv\Scripts\activate`
    5. Install dependencies:
       pip install -r requirements.txt
       pip install -r requirements-dev.txt
    6. Install Zenoo RPC in editable mode:
       pip install -e .
    7. Run tests to ensure the setup is correct:
       pytest
  Contribution Workflow:
    - Create a new branch for your feature or bug fix.
    - Make your changes and commit them.
    - Push your branch to your fork.
    - Open a Pull Request against the main repository.
```

--------------------------------

### Zenoo RPC Client Usage Example

Source: https://zenoo-rpc.readthedocs.io/en/latest/examples/real-world/email-automation

Demonstrates how to use the Zenoo RPC client to connect, log in, and perform operations. This example shows the basic setup for interacting with the Zenoo RPC service.

```python
async def main():
    """Demonstrate email automation capabilities."""

    async with ZenooClient("localhost", port=8069) as client:
        await client.login("demo", "admin", "admin")
```

--------------------------------

### Zenoo RPC Basic Usage Example

Source: https://zenoo-rpc.readthedocs.io/en/latest/api-reference

Demonstrates the fundamental steps to use the Zenoo RPC client. This includes initializing the client, logging in, configuring cache, querying data using a query builder, performing direct create operations, and utilizing batch operations for multiple record creations.

```python
import asyncio
from zenoo_rpc import ZenooClient
from zenoo_rpc.models.common import ResPartner

async def main():
    # Create and configure client
    async with ZenooClient("localhost", port=8069) as client:
        # Authenticate
        await client.login("database", "username", "password")

        # Setup cache (optional)
        await client.setup_cache_manager(
            backend="memory",
            max_size=1000,
            ttl=300
        )

        # Use query builder
        partners = await client.model(ResPartner).filter(
            is_company=True
        ).limit(10).all()

        # Direct CRUD operations
        partner_id = await client.create("res.partner", {
            "name": "Test Company",
            "email": "test@company.com",
            "is_company": True
        })

        # Batch operations (optional)
        await client.setup_batch_manager()

        async with client.batch() as batch:
            created_ids = await batch.create_many(ResPartner, [
                {"name": "Company 1", "email": "c1@test.com"},
                {"name": "Company 2", "email": "c2@test.com"}
            ])

asyncio.run(main())
```

--------------------------------

### Zenoo RPC Prerequisites and Installation

Source: https://zenoo-rpc.readthedocs.io/en/latest/getting-started/quickstart

Details the necessary software and installation steps to begin using Zenoo RPC. Requires Python 3.9+ and a running Odoo server.

```bash
pip install zenoo-rpc
```

--------------------------------

### Python Client Search Example

Source: https://zenoo-rpc.readthedocs.io/en/latest/contributing/documentation

Demonstrates how to use the Zenoo RPC client to search for partners. This example requires proper client initialization and setup to function correctly.

```python
partners = client.search("res.partner", [])
```

--------------------------------

### FastAPI Integration Example

Source: https://zenoo-rpc.readthedocs.io/en/latest/examples/real-world/fastapi-integration

Demonstrates how to integrate Zenoo RPC with FastAPI, covering setup, Pydantic models, API routers, and running the application in development and production.

```python
from fastapi import FastAPI
from zenoo_rpc.fastapi import ZenooRPCRouter

app = FastAPI()
rpc_router = ZenooRPCRouter()

# Add your RPC services to the router
# app.include_router(rpc_router, prefix="/rpc")

# Example of a simple RPC service (assuming you have defined it elsewhere)
# @rpc_router.service
# class MyService:
#     async def greet(self, name: str) -> str:
#         return f"Hello, {name}!"
```

--------------------------------

### Celery Integration Example

Source: https://zenoo-rpc.readthedocs.io/en/latest/examples/integrations/celery-integration

Demonstrates how to integrate Zenoo RPC with Celery for asynchronous task execution. This example shows the setup and usage of Zenoo RPC within a Celery worker environment.

```python
from celery import Celery
from zenoo_rpc.client import ZenooClient

# Celery configuration
celery_app = Celery('tasks', broker='redis://localhost:6379/0')

# Zenoo RPC client initialization
# Assuming your RPC server is running on localhost:8000
zenoo_client = ZenooClient(host='localhost', port=8000)

@celery_app.task
def call_rpc_method(model_name: str, method_name: str, *args, **kwargs):
    """Calls a Zenoo RPC method as a Celery task."""
    try:
        # Dynamically get the model and call the method
        model = zenoo_client.get_model(model_name)
        result = getattr(model, method_name)(*args, **kwargs)
        return {"status": "success", "result": result}
    except Exception as e:
        return {"status": "error", "message": str(e)}

# Example of how to call this task:
# result = call_rpc_method.delay('MyModel', 'my_method', arg1='value1', kwarg1=123)
# print(result.get())

```

--------------------------------

### Zenoo RPC Examples

Source: https://zenoo-rpc.readthedocs.io/en/latest/examples

This section offers various examples of Zenoo RPC usage, categorized by real-world scenarios, common patterns, integration, quick starts, learning paths, and use cases.

```APIDOC
Examples:
  Example Categories: https://zenoo-rpc.readthedocs.io/en/latest/examples/#example-categories
  Real-World Examples: https://zenoo-rpc.readthedocs.io/en/latest/examples/#real-world-examples
  Common Patterns: https://zenoo-rpc.readthedocs.io/en/latest/examples/#common-patterns
  Integration Examples: https://zenoo-rpc.readthedocs.io/en/latest/examples/#integration-examples
  Quick Start Examples: https://zenoo-rpc.readthedocs.io/en/latest/examples/#quick-start-examples
    Basic CRUD Operations: https://zenoo-rpc.readthedocs.io/en/latest/examples/#basic-crud-operations
    Async Batch Operations: https://zenoo-rpc.readthedocs.io/en/latest/examples/#async-batch-operations
    Caching and Performance: https://zenoo-rpc.readthedocs.io/en/latest/examples/#caching-and-performance
    Transaction Management: https://zenoo-rpc.readthedocs.io/en/latest/examples/#transaction-management
  Learning Path: https://zenoo-rpc.readthedocs.io/en/latest/examples/#learning-path
    1. Start with Basics: https://zenoo-rpc.readthedocs.io/en/latest/examples/#1-start-with-basics
    2. Explore Core Features: https://zenoo-rpc.readthedocs.io/en/latest/examples/#2-explore-core-features
    3. Advanced Patterns: https://zenoo-rpc.readthedocs.io/en/latest/examples/#3-advanced-patterns
    4. Production Deployment: https://zenoo-rpc.readthedocs.io/en/latest/examples/#4-production-deployment
  Use Case Examples: https://zenoo-rpc.readthedocs.io/en/latest/examples/#use-case-examples
    Web Applications: https://zenoo-rpc.readthedocs.io/en/latest/examples/#web-applications
    Data Processing: https://zenoo-rpc.readthedocs.io/en/latest/examples/#data-processing
    Microservices: https://zenoo-rpc.readthedocs.io/en/latest/examples/#microservices
  External Resources: https://zenoo-rpc.readthedocs.io/en/latest/examples/#external-resources
  Contributing Examples: https://zenoo-rpc.readthedocs.io/en/latest/examples/#contributing-examples
```

--------------------------------

### Install All Zenoo RPC Dependencies

Source: https://zenoo-rpc.readthedocs.io/en/latest/getting-started/installation

Installs Zenoo RPC with all available dependencies, including development, Redis, and documentation packages.

```bash
pip install zenoo-rpc[dev,redis,docs]
```

--------------------------------

### Setup Welcome Email Workflow

Source: https://zenoo-rpc.readthedocs.io/en/latest/examples/real-world/email-automation

Configures the workflow for sending welcome emails to new customers. It fetches customers created within the last hour who have a positive customer rank and a valid email address, then sends them a personalized welcome email.

```python
async def _setup_welcome_email_workflow(self):
    """Setup welcome email workflow for new customers."""
    # This would typically be triggered by a webhook or event
    # For demonstration, we'll check for new customers periodically

    # Get customers created in the last hour
    one_hour_ago = datetime.now() - timedelta(hours=1)

    new_customers = await (
        self.client.model(ResPartner)
        .filter(
            Q(create_date__gte=one_hour_ago) &
            Q(customer_rank__gt=0) &
            Q(email__ne=False)
        )
        .only("name", "email")
        .all()
    )

    for customer in new_customers:
        try:
            await self.send_transactional_email(
                template_id="welcome_email",
                recipient_email=customer.email,
                recipient_name=customer.name,
                variables={
                    "customer_name": customer.name,
                    "company_name": "Your Company"
                }
            )
        except Exception as e:
            # Log the error or handle it appropriately
            print(f"Error sending welcome email to {customer.email}: {e}")
```

--------------------------------

### Zenoo RPC Retry Mechanisms - User Guide

Source: https://zenoo-rpc.readthedocs.io/en/latest/user-guide/retry-mechanisms

User guide detailing how to configure and utilize retry mechanisms in Zenoo RPC, including basic setup, strategies, circuit breakers, and conditional retries.

```APIDOC
User Guide - Retry Mechanisms:
  Overview: Introduction to retry mechanisms for handling transient failures.
  Basic Retry Configuration:
    - Client-Level Retry Setup: Configuring retries for all client operations.
    - Operation-Level Retries: Setting up retries for specific operations.
  Retry Strategies:
    - Exponential Backoff: Implementing exponential backoff for retries.
    - Linear Backoff: Using linear backoff for retry delays.
    - Fixed Delay: Configuring a fixed delay between retries.
    - Custom Retry Strategy: Defining custom logic for retry attempts.
  Circuit Breaker Pattern:
    - Basic Circuit Breaker: Implementing a simple circuit breaker.
    - Advanced Circuit Breaker: Advanced configuration for circuit breakers.
    - Circuit Breaker States: Understanding the states of a circuit breaker.
  Conditional Retries:
    - Retry on Specific Exceptions: Retrying only on certain types of exceptions.
    - Conditional Retry Logic: Implementing custom conditions for retries.
  Retry with Context: Using context information during retry attempts.
  Links:
    - Overview: https://zenoo-rpc.readthedocs.io/en/latest/user-guide/retry-mechanisms/#overview
    - Basic Retry Configuration: https://zenoo-rpc.readthedocs.io/en/latest/user-guide/retry-mechanisms/#basic-retry-configuration
    - Client-Level Retry Setup: https://zenoo-rpc.readthedocs.io/en/latest/user-guide/retry-mechanisms/#client-level-retry-setup
    - Operation-Level Retries: https://zenoo-rpc.readthedocs.io/en/latest/user-guide/retry-mechanisms/#operation-level-retries
    - Retry Strategies: https://zenoo-rpc.readthedocs.io/en/latest/user-guide/retry-mechanisms/#retry-strategies
    - Exponential Backoff: https://zenoo-rpc.readthedocs.io/en/latest/user-guide/retry-mechanisms/#exponential-backoff
    - Linear Backoff: https://zenoo-rpc.readthedocs.io/en/latest/user-guide/retry-mechanisms/#linear-backoff
    - Fixed Delay: https://zenoo-rpc.readthedocs.io/en/latest/user-guide/retry-mechanisms/#fixed-delay
    - Custom Retry Strategy: https://zenoo-rpc.readthedocs.io/en/latest/user-guide/retry-mechanisms/#custom-retry-strategy
    - Circuit Breaker Pattern: https://zenoo-rpc.readthedocs.io/en/latest/user-guide/retry-mechanisms/#circuit-breaker-pattern
    - Basic Circuit Breaker: https://zenoo-rpc.readthedocs.io/en/latest/user-guide/retry-mechanisms/#basic-circuit-breaker
    - Advanced Circuit Breaker: https://zenoo-rpc.readthedocs.io/en/latest/user-guide/retry-mechanisms/#advanced-circuit-breaker
    - Circuit Breaker States: https://zenoo-rpc.readthedocs.io/en/latest/user-guide/retry-mechanisms/#circuit-breaker-states
    - Conditional Retries: https://zenoo-rpc.readthedocs.io/en/latest/user-guide/retry-mechanisms/#conditional-retries
    - Retry on Specific Exceptions: https://zenoo-rpc.readthedocs.io/en/latest/user-guide/retry-mechanisms/#retry-on-specific-exceptions
    - Conditional Retry Logic: https://zenoo-rpc.readthedocs.io/en/latest/user-guide/retry-mechanisms/#conditional-retry-logic
    - Retry with Context: https://zenoo-rpc.readthedocs.io/en/latest/user-guide/retry-mechanisms/#retry-with-context
```

--------------------------------

### Demonstrate Sales Dashboard Initialization (Python)

Source: https://zenoo-rpc.readthedocs.io/en/latest/examples/real-world/sales-dashboard

Demonstrates the initialization and basic usage of the SalesDashboard with Zenoo RPC. It shows how to establish a client connection, log in, create a dashboard instance, and set a date range for analysis.

```python
async def main():
    """Demonstrate sales dashboard functionality."""
    async with ZenooClient("localhost", port=8069) as client:
        await client.login("demo", "admin", "admin")
        dashboard = SalesDashboard(client)
        end_date = date.today()
        start_date = end_date - timedelta(days=30)
```

--------------------------------

### Zenoo RPC Tutorials - Advanced Queries

Source: https://zenoo-rpc.readthedocs.io/en/latest/getting-started/migration

Guide to constructing and executing advanced queries with Zenoo RPC.

```python
from zenoo_rpc.query import Query, Filter, Field, OrderBy

# Assuming 'Product' is a defined Model
query = Query(Product)

# Complex filtering: price > 100 AND category IN ('Electronics', 'Books')
query = query.filter(
    Filter.and_(
        Filter.gt(Field('price'), 100),
        Filter.in_(Field('category'), ['Electronics', 'Books'])
    )
)

# Sorting: order by price descending, then by name ascending
query = query.order_by(
    OrderBy(Field('price'), desc=True),
    OrderBy(Field('name'), desc=False)
)

# Limiting results
query = query.limit(10)

# Executing the query (conceptual)
# results = client.execute_query(query)
# print(results)
```

--------------------------------

### Zenoo RPC Troubleshooting

Source: https://zenoo-rpc.readthedocs.io/en/latest/examples/real-world/fastapi-integration

Guides users through common issues and debugging techniques for Zenoo RPC.

```APIDOC
Zenoo RPC Troubleshooting:

Common Issues:
  - Connection problems
  - Serialization/deserialization errors
  - Service discovery failures

Debugging Guide:
  - Techniques for diagnosing and resolving issues, including logging and tracing.

Monitoring:
  - Strategies for monitoring RPC service health and performance.
```

--------------------------------

### CacheManager Setup with LRUCache

Source: https://zenoo-rpc.readthedocs.io/en/latest/api-reference/cache

Example of setting up a memory cache using the LRUCache strategy via the CacheManager, specifying the maximum size.

```python
# Used automatically by CacheManager
await cache_manager.setup_memory_cache(strategy="lru", max_size=1000)
```

--------------------------------

### CacheManager Setup with TTLCache

Source: https://zenoo-rpc.readthedocs.io/en/latest/api-reference/cache

Example of setting up a memory cache using the TTLCache strategy via the CacheManager, specifying the default TTL.

```python
# Used automatically by CacheManager
await cache_manager.setup_memory_cache(strategy="ttl", default_ttl=300)
```

--------------------------------

### Update Zenoo RPC Examples

Source: https://zenoo-rpc.readthedocs.io/en/latest/contributing/release

Instructions for updating the examples section in the Zenoo RPC documentation.

```markdown
# Update examples
# docs/examples/
```

--------------------------------

### Zenoo RPC Troubleshooting - Common Issues

Source: https://zenoo-rpc.readthedocs.io/en/latest/examples/real-world/data-visualization

A guide to common issues encountered with Zenoo RPC and their resolutions.

```APIDOC
Troubleshooting Common Issues: https://zenoo-rpc.readthedocs.io/en/latest/troubleshooting/common-issues/
```

--------------------------------

### Setup Extended Zenoo RPC Client

Source: https://zenoo-rpc.readthedocs.io/en/latest/advanced/extensions

Demonstrates the complete setup of a Zenoo RPC client with all available extensions. This includes initializing the client, setting up middleware (Logging, Security, Caching), registering plugins (AuditLog, Metrics), initializing plugins, registering a file cache backend, and defining a custom validation hook for the BEFORE_CREATE event. The function returns the configured client, middleware manager, and plugin manager.

```python
async def setup_extended_client():
    """Setup client with all extensions."""

    # Create client
    client = ZenooClient("localhost", port=8069)

    # Setup middleware
    middleware_manager = MiddlewareManager()
    middleware_manager.add_middleware(LoggingMiddleware())
    middleware_manager.add_middleware(SecurityMiddleware())
    middleware_manager.add_middleware(CachingMiddleware(client.cache_manager))

    # Setup plugins
    plugin_manager = PluginManager()
    plugin_manager.register_plugin(AuditLogPlugin())
    plugin_manager.register_plugin(MetricsPlugin())

    await plugin_manager.initialize_all(client)

    # Register custom backends
    await client.cache_manager.register_backend("file", FileCacheBackend())

    # Setup hooks
    @hook(HookEvent.BEFORE_CREATE)
    async def custom_validation(model: str, data: Dict[str, Any]):
        """Custom validation logic."""
        # Your validation logic here
        pass

    return client, middleware_manager, plugin_manager
```

--------------------------------

### Zenoo RPC Cache Manager Setup

Source: https://zenoo-rpc.readthedocs.io/en/latest/api-reference

Provides examples for setting up the cache manager for Zenoo RPC, including memory cache with specified size and TTL, and Redis cache with URL, fallback, size, and TTL. Also shows manual setup for Redis cache with namespace.

```python
# Setup memory cache (recommended)
cache_manager = await client.setup_cache_manager(
    backend="memory",
    max_size=1000,
    ttl=300
)
```

```python
# Setup Redis cache
cache_manager = await client.setup_cache_manager(
    backend="redis",
    url="redis://localhost:6379/0",
    enable_fallback=True,
    max_size=1000,
    ttl=300
)
```

```python
# Manual cache manager setup
if client.cache_manager:
    await client.cache_manager.setup_redis_cache(
        name="redis",
        url="redis://localhost:6379/0",
        namespace="zenoo_rpc",
        enable_fallback=True
    )
```

--------------------------------

### Zenoo RPC User Guide - Client Usage

Source: https://zenoo-rpc.readthedocs.io/en/latest/getting-started/migration

Instructions on how to use the Zenoo RPC client to interact with services.

```python
from zenoo_rpc.client import ZenooClient

# Initialize the client with server address
client = ZenooClient(host='127.0.0.1', port=8000)

# Example: Calling a remote procedure
try:
    response = client.call_procedure('my_remote_method', arg1='value1', arg2=123)
    print("Response received:", response)
except Exception as e:
    print(f"An error occurred: {e}")

# Close the client connection when done
client.close()
```

--------------------------------

### Zenoo RPC Contributing - Development Setup

Source: https://zenoo-rpc.readthedocs.io/en/latest/advanced

Instructions for setting up the development environment for Zenoo RPC.

```APIDOC
Contributing:
  Development Setup:
    - Description: Guide to setting up your development environment.
    - URL: https://zenoo-rpc.readthedocs.io/en/latest/contributing/development/
```
Tokens:
Raw