pywats-api 0.1.0b35

Python API library for WATS (Web-based Automated Test System) - manufacturing test data management

PyWATS

A Python library for interacting with the WATS (Web-based Test Data Management Platform) API.

⚠️ Beta Release: This is a beta version. The API is stabilizing but may have changes before 1.0.

Requirements

• Python 3.10 or later
• WATS Server 2025.3.9.824 or later

Features

• PyWATS Library - Core API library for WATS integration

  • Async-First Architecture - Built on httpx with native async support
  • Sync Compatibility - Full sync API via thin wrappers (no code changes needed)
  • 9 Domain Services: Product, Asset, Report, Production, Analytics, Software, RootCause, Process, SCIM
  • 170+ API Endpoints - Centralized route management
  • Report creation and submission with comprehensive step types
  • OData filtering and pagination support
  • Structured logging with configurable verbosity

• PyWATS Client - Desktop and headless client application

  • Connection management
  • Converter configuration
  • Report queue management
  • GUI Mode: Qt-based desktop application (Windows, macOS, Linux)
  • Headless Mode: CLI and HTTP API for servers, Raspberry Pi, embedded systems

Installation

From PyPI (Recommended)

# Install core API library only
pip install pywats-api

# Install with GUI client (requires Qt)
pip install pywats-api[client]

# Install headless client (no Qt - for Raspberry Pi, servers)
pip install pywats-api[client-headless]

# Install with MCP server (for AI assistant integration)
pip install pywats-api[mcp]

From Source (Development)

# Clone the repository
git clone https://github.com/olreppe/pyWATS.git
cd pyWATS

# Create virtual environment
python -m venv .venv
.venv\Scripts\activate  # Windows
source .venv/bin/activate  # Linux/Mac

# Install in development mode
pip install -e ".[dev]"

Configuration

Create a configuration with your WATS credentials:

from pywats import pyWATS

api = pyWATS(
    base_url="https://your-server.wats.com",
    token="your_base64_encoded_token"
)

Or use environment variables:

WATS_BASE_URL=https://your-server.wats.com
WATS_AUTH_TOKEN=your_base64_encoded_token

Quick Start

from pywats import pyWATS, WATSFilter

# Initialize API
api = pyWATS(
    base_url="https://your-server.wats.com",
    token="your_token"
)

# Test connection
if api.test_connection():
    print(f"Connected! Server version: {api.get_version()}")

# Get products (sync)
products = api.product.get_products()
for p in products:
    print(f"{p.part_number}: {p.name}")

Async Quick Start

For high-performance applications with concurrent requests:

import asyncio
from pywats import AsyncWATS

async def main():
    async with AsyncWATS(
        base_url="https://your-server.wats.com",
        token="your_token"
    ) as api:
        # Concurrent requests - much faster!
        products, assets, version = await asyncio.gather(
            api.product.get_products(),
            api.asset.get_assets(top=10),
            api.analytics.get_version()
        )
        print(f"Fetched {len(products)} products, {len(assets)} assets")

asyncio.run(main())

Query Reports

# Query recent reports (OData filter)
headers = api.report.query_uut_headers(
    odata_filter="partNumber eq 'WIDGET-001'",
    top=10
)

# Or use helper methods
headers = api.report.get_headers_by_serial("SN-12345")
headers = api.report.get_todays_headers()

Enable Debug Logging

from pywats import pyWATS, enable_debug_logging

# Quick debug mode - shows all library operations
enable_debug_logging()

# Or configure logging your way
import logging
logging.basicConfig(level=logging.INFO)
logging.getLogger('pywats').setLevel(logging.DEBUG)

# Now use the API with detailed logging
api = pyWATS(base_url="...", token="...")

See LOGGING_STRATEGY.md for comprehensive logging documentation.

Running the GUI Client

python -m pywats_client

GUI Configuration

The GUI supports modular tab configuration and logging control:

• Tab Visibility: Show/hide tabs (Software, SN Handler, etc.) based on your needs
• Logging Integration: Automatic PyWATS library logging when debug mode is enabled
• Multiple Instances: Run multiple client instances with separate configurations

See GUI Configuration Guide for detailed setup instructions.

Running Headless (Raspberry Pi, Servers)

For systems without display or Qt support:

# Initialize configuration
pywats-client config init

# Test connection
pywats-client test-connection

# Run service with HTTP control API
pywats-client start --api --api-port 8765

# Run as daemon (Linux)
pywats-client start --daemon

CLI Commands

pywats-client config show          # Show configuration
pywats-client config set key value # Set config value
pywats-client status               # Show service status
pywats-client converters list      # List converters

HTTP Control API

When running with --api, manage the service remotely:

curl http://localhost:8765/status    # Get status
curl http://localhost:8765/config    # Get configuration
curl -X POST http://localhost:8765/restart  # Restart services

See Headless Operation Guide for complete documentation.

Project Structure

pyWATS/
├── src/
│   ├── pywats/              # Core library
│   │   ├── domains/         # Domain services (async + sync wrappers)
│   │   │   ├── analytics/   # Statistics, yield, Unit Flow
│   │   │   ├── asset/       # Equipment tracking, calibration
│   │   │   ├── process/     # Operation types, caching
│   │   │   ├── product/     # Products, revisions, BOMs
│   │   │   ├── production/  # Serial numbers, unit lifecycle
│   │   │   ├── report/      # Test reports, measurements
│   │   │   ├── rootcause/   # Issue tracking, defects
│   │   │   ├── scim/        # User provisioning
│   │   │   └── software/    # Package distribution
│   │   ├── core/            # HTTP client, routes, sync_runner
│   │   ├── models/          # Report models (UUT/UUR)
│   │   ├── async_wats.py    # AsyncWATS main class
│   │   └── sync_wats.py     # SyncWATS wrapper (pyWATS alias)
│   └── pywats_client/       # Client application
│       ├── core/            # Core client functionality
│       ├── gui/             # Qt GUI components (optional)
│       ├── control/         # Headless control (CLI, HTTP API)
│       └── services/        # Background services
├── converters/              # User converter plugins
├── docs/                    # Documentation
├── examples/                # Usage examples by domain
└── pyproject.toml           # Project configuration

Documentation

Official Documentation

Complete guides shipped with the package:

• Documentation Index - Complete documentation overview

Domain API Reference

• Product Domain - Products, revisions, BOMs, box build templates
• Asset Domain - Equipment tracking, calibration, maintenance
• Production Domain - Unit lifecycle, serial numbers, assembly
• Report Domain - Test reports, measurements, step types
• Analytics Domain - Yield analysis, measurements, Unit Flow
• Software Domain - Package management, versioning, distribution
• RootCause Domain - Issue tracking, defect management
• Process Domain - Operation types, caching

Client Documentation

• GUI Configuration - Configure GUI tabs, logging
• Headless Operation - Raspberry Pi, servers, embedded

Additional Resources

Documentation available in the GitHub repository (not shipped with package):

• Internal Documentation - Architecture, design docs, AI agent knowledge
• Internal: Architecture Overview - System design and architecture
• Internal: WATS Domain Knowledge - Core WATS concepts
• Logging Strategy - Logging configuration and best practices

Testing

# Run all tests
pytest

# Run with coverage
pytest --cov=src --cov-report=html

Contributing

This project is maintained by Virinco AS.

For Maintainers: Releasing a New Beta Version

There is only ONE command to release:

.\scripts\bump.ps1

See RELEASE.md for complete details. Never manually edit versions or create tags.

License

MIT License - see LICENSE for details.

Links

• WATS Website
• Virinco
• GitHub Repository
• Changelog