Client

The main entry point for interacting with the ViewAI platform. The ViewAIClient class provides a unified interface to all ViewAI services following the Facade pattern.

Overview

The ViewAIClient class is the primary interface for all ViewAI SDK operations. It provides:

• Service-Oriented Architecture: Access to specialized services for different operations

• Convenience Methods: Simplified access to common operations

• Context Management: Support for Python's with statement

• Lazy Loading: Services are initialized only when accessed

• Configuration Management: Flexible configuration with validation

Class Reference

class ViewAIClient:
    """Enterprise-grade ViewAI SDK client with service-oriented architecture."""

Initialization

init(api_key, config, **kwargs)

Initialize the ViewAI client with authentication and configuration.

Parameters:

• api_key (str, optional): API authentication key. Required if config not provided.

• config (ClientConfiguration, optional): Configuration object with full settings.

• **kwargs: Additional configuration options used if config not provided.

  • base_url (str): API base URL

  • timeout (int): Request timeout in seconds

  • max_retries (int): Maximum retry attempts

  • default_workspace (str): Default workspace name

  • default_project (str): Default project name

  • default_model_id (str): Default model ID

Raises:

• ValueError: If neither api_key nor config is provided

Examples:

from viewai_client import ViewAIClient

# Simple initialization with API key
client = ViewAIClient(api_key="your-api-key")

# With configuration object
from viewai_client.config import ClientConfiguration

config = ClientConfiguration(
    api_key="your-key",
    timeout=60,
    max_retries=5
)
client = ViewAIClient(config=config)

# With kwargs
client = ViewAIClient(
    api_key="your-key",
    timeout=60,
    max_retries=5,
    default_workspace="production"
)

Service Properties

These properties provide access to specialized services. Services are lazy-loaded on first access.

workspace_manager

Access workspace management service.

Returns: WorkspaceManager instance

Example:

workspace = client.workspace_manager.retrieve_workspace_by_name("prod")
workspaces = client.workspace_manager.list_accessible_workspaces()

See Also: WorkspaceManager

project_manager

Access project management service.

Returns: ProjectManager instance

Example:

project = client.project_manager.retrieve_project_by_name("ml-project")
projects = client.project_manager.list_accessible_projects()

See Also: ProjectManager

prediction_service

Access prediction/inference service.

Returns: PredictionService instance

Example:

result = client.prediction_service.execute_single_point_prediction(
    data={"age": 35, "income": 50000},
    model_id="model-123"
)

See Also: PredictionService

training_service

Access model training service.

Returns: ModelTrainingService instance

Example:

job = client.training_service.initiate_training_job(
    dataset=df,
    target_column="churn",
    workspace="ws-123",
    model_name="My Model"
)

See Also: ModelTrainingService

health

Access health monitoring service.

Returns: HealthChecker instance

Example:

diagnostics = client.health.run_diagnostics()
is_healthy = client.health.check_connection()

See Also: HealthChecker

registry

Access model registry service.

Returns: ModelRegistry instance

Example:

models = client.registry.search_models(name="customer*")
comparison = client.registry.compare_models(["model-1", "model-2"])

See Also: ModelRegistry

version

Access version checking service.

Returns: VersionChecker instance

Example:

info = client.version.get_version_info()
is_compatible = client.version.check_compatibility()

schema_validator

Access schema validation service.

Returns: SchemaValidator instance

Example:

is_valid = client.schema_validator.validate_schema_structure(schema)

Convenience Methods - Workspace

retrieve_default_workspace()

Retrieve the default workspace for the authenticated user.

Returns: Workspace or None

Example:

workspace = client.retrieve_default_workspace()
if workspace:
    print(f"Default workspace: {workspace.workspace_name}")

retrieve_workspace_by_name(workspace_name)

Retrieve workspace by name.

Parameters:

• workspace_name (str): Name of workspace to retrieve

Returns: Workspace or None

Example:

workspace = client.retrieve_workspace_by_name("production")
if workspace:
    print(f"Workspace ID: {workspace.workspace_id}")

list_accessible_workspaces()

List all accessible workspaces.

Returns: List[Workspace]

Example:

workspaces = client.list_accessible_workspaces()
print(f"Found {len(workspaces)} workspaces")
for ws in workspaces:
    print(f"  - {ws.workspace_name}")

Convenience Methods - Project

retrieve_project_by_name(project_name)

Retrieve project by name.

Parameters:

• project_name (str): Name of project to retrieve

Returns: Project or None

Example:

project = client.retrieve_project_by_name("ml-project")
if project:
    print(f"Project ID: {project.project_id}")

list_accessible_projects(workspace_id=None)

List all accessible projects, optionally filtered by workspace.

Parameters:

• workspace_id (str, optional): Workspace ID to filter projects

Returns: List[Project]

Example:

# All projects
projects = client.list_accessible_projects()

# Projects in specific workspace
workspace_projects = client.list_accessible_projects(workspace_id="ws-123")

Convenience Methods - Prediction

execute_prediction(data, model_id=None)

Execute prediction (automatically routes to single or batch based on data type).

Parameters:

• data (dict or list): Data to predict (dict for single, list for batch)

• model_id (str, optional): Model ID to use. Uses default if not provided.

Returns: Prediction (for single) or BatchPredictionJob (for batch) or None

Raises:

• ValueError: If model_id not provided and no default set

Examples:

# Single prediction
result = client.execute_prediction(
    data={"age": 35, "income": 50000},
    model_id="model-123"
)
print(f"Prediction: {result.prediction}")

# Batch prediction
job = client.execute_prediction(
    data=[{"age": 35}, {"age": 42}],
    model_id="model-123"
)
print(f"Job ID: {job.job_id}")

execute_single_point_prediction(data, model_id=None)

Execute prediction for a single data point.

Parameters:

• data (dict): Single data point as dictionary

• model_id (str, optional): Model ID to use

Returns: Prediction or None

Example:

result = client.execute_single_point_prediction(
    data={"age": 35, "income": 50000},
    model_id="model-123"
)

if result:
    print(f"Prediction: {result.prediction}")
    print(f"Confidence: {result.confidence}")

execute_batch_prediction(data, model_id=None, wait_for_completion=True)

Execute prediction for multiple data points (batch).

Parameters:

• data (list or DataFrame): List of data points or DataFrame

• model_id (str, optional): Model ID to use

• wait_for_completion (bool): Whether to wait for job completion

Returns: BatchPredictionJob or None

Example:

job = client.execute_batch_prediction(
    data=[{"age": 35}, {"age": 42}],
    model_id="model-123",
    wait_for_completion=True
)

if job and job.status == "completed":
    print(f"Results at: {job.dashboard_url}")

Convenience Methods - Training

initiate_training_job(...)

Initiate a model training job.

Parameters:

• dataset (DataFrame): Training data DataFrame

• target_column (str): Name of target column

• workspace (Workspace or str, optional): Workspace object/ID

• project (Project or str, optional): Optional project object/ID

• model_name (str): Name for the model (default: "Default Model")

• description (str): Model description (default: "No description provided")

• wait_for_completion (bool): Whether to wait for training completion (default: True)

Returns: TrainingJob or None

Raises:

• ValueError: If workspace not provided and no default set

Example:

import pandas as pd

df = pd.read_csv("training_data.csv")

job = client.initiate_training_job(
    dataset=df,
    target_column="churn",
    model_name="Customer Churn Model",
    wait_for_completion=True
)

if job and job.status == "training_completed":
    print(f"Training complete! View at: {job.dashboard_url}")

Model Deployment

create_deployable_model(...)

Create a deployable model object from a trained model.

Parameters:

• model (Any): Trained model object (sklearn, xgboost, etc.)

• dataset (DataFrame): Training dataset

• target_column (str): Target column name

• schema (dict, optional): Optional schema definition

• model_name (str): Name for deployed model (default: "Deployed Model")

• workspace (Workspace or str, optional): Workspace object/ID

• project (Project or str, optional): Optional project object/ID

Returns: Model object ready for deployment

Raises:

• ValueError: If workspace not provided and no default set

Example:

from sklearn.ensemble import RandomForestClassifier

# Train model
rf_model = RandomForestClassifier()
rf_model.fit(X_train, y_train)

# Create deployable model
deployable = client.create_deployable_model(
    model=rf_model,
    dataset=df,
    target_column="target",
    model_name="RF Classifier"
)

# Deploy
dashboard_id = deployable.deploy()
print(f"Model deployed: {dashboard_id}")

See Also: Model Class

Configuration & Info

configure_logging_level(level)

Configure logging level for the SDK.

Parameters:

• level (int): Logging level (e.g., logging.DEBUG, logging.INFO)

Example:

import logging
client.configure_logging_level(logging.DEBUG)

retrieve_client_configuration()

Retrieve current client configuration.

Returns: Dictionary with configuration details

Example:

config = client.retrieve_client_configuration()
print(f"Base URL: {config['base_url']}")
print(f"Timeout: {config['read_timeout']}s")

retrieve_version_information()

Retrieve SDK and server version information.

Returns: Dictionary with version details

Example:

info = client.retrieve_version_information()
print(f"SDK: {info['sdk_version']}")
print(f"Server: {info['server_version']}")

Health & Diagnostics

execute_comprehensive_diagnostics()

Execute comprehensive health diagnostics.

Returns: Dictionary with diagnostic results

Example:

diagnostics = client.execute_comprehensive_diagnostics()
print(f"Connection: {diagnostics['connection'].healthy}")
print(f"Latency: {diagnostics['connection'].response_time_ms}ms")

verify_api_connectivity()

Verify API connectivity.

Returns: Dictionary with connection status

Example:

status = client.verify_api_connectivity()
if status['healthy']:
    print("API is reachable")

Context Management

set_current_workspace(workspace)

Set current workspace context.

Parameters:

• workspace (Workspace or str): Workspace object or name

Example:

client.set_current_workspace("production")

# Now training jobs will use this workspace by default

set_current_project(project)

Set current project context.

Parameters:

• project (Project or str): Project object or name

Example:

client.set_current_project("ml-project")

Resource Cleanup

cleanup_resources()

Cleanup all resources held by the client.

Example:

client.cleanup_resources()

Note: Automatically called when using context manager.

Context Manager Support

The ViewAIClient supports Python's context manager protocol for automatic resource cleanup.

Example:

with ViewAIClient(api_key="your-key") as client:
    workspace = client.retrieve_default_workspace()
    result = client.execute_prediction(data, model_id="model-123")

# Resources automatically cleaned up here

Complete Usage Example

from viewai_client import ViewAIClient
from viewai_client.config import ClientConfiguration
import pandas as pd

# Initialize client
config = ClientConfiguration(
    api_key="your-api-key",
    timeout=60,
    max_retries=5,
    default_workspace="production"
)

with ViewAIClient(config=config) as client:
    # Check health
    diagnostics = client.execute_comprehensive_diagnostics()
    print(f"API Health: {diagnostics['connection'].healthy}")

    # Get workspace
    workspace = client.retrieve_default_workspace()
    print(f"Using workspace: {workspace.workspace_name}")

    # Train model
    df = pd.read_csv("training_data.csv")
    training_job = client.initiate_training_job(
        dataset=df,
        target_column="target",
        model_name="My Model",
        wait_for_completion=True
    )

    # Make prediction
    prediction = client.execute_single_point_prediction(
        data={"age": 35, "income": 50000},
        model_id=training_job.job_id
    )
    print(f"Prediction: {prediction}")

    # List all models
    models = client.registry.list_models()
    print(f"Total models: {len(models)}")

See Also

• Service Classes - Detailed service class documentation

• Model Classes - Model deployment and prediction classes

• Configuration - Configuration options and validation

• Exceptions - Exception handling