Apitools

0.1.4 · abandoned · verified Fri Apr 17

Apitools (version 0.1.4) is a Python library designed to assist with JSON schema validation and interaction with REST APIs. It provides utilities for defining and validating data against JSON schemas and for creating client proxies for API interactions. The library has not seen updates since 2016, indicating it is no longer actively maintained.

Common errors

```
jsonschema.exceptions.ValidationError: ... is not valid under any of the given schemas
```
cause Data provided for validation does not conform to the defined JSON schema. This can be due to missing required properties, incorrect data types, or values outside specified constraints (e.g., `minimum`, `maxLength`).

fix Review your data against the `Schema` definition. Ensure all `required` fields are present and data types/values match the schema constraints.
```
ImportError: cannot import name 'Schema' from 'apitools.jsonschema' (or similar for other symbols)
```
cause You are trying to import a symbol from an incorrect module path, or the `apitools` library is not correctly installed or accessible in your Python environment.

fix Verify `apitools` is installed (`pip show apitools`). Ensure the import path is exact, e.g., `from apitools.jsonschema import Schema`.
```
AttributeError: 'Dataproxy' object has no attribute 'some_property'
```
cause You are trying to access a property on a `Dataproxy` object that is not defined in the JSON schema it was initialized with, or it's a misspelling.

fix Check your JSON schema definition to ensure `some_property` is correctly defined under `properties`. `Dataproxy` strictly enforces schema-defined attributes.
```
TypeError: '<' not supported between instances of 'NoneType' and 'int'
```
cause This error often occurs in older validation libraries like `jsonschema` 2.x when a schema expects a specific type (e.g., `integer`) but receives `None`, and a comparison operation (like `minimum` check) is attempted.

fix Ensure all data fields expected to be non-null are indeed populated with appropriate values before validation or `Dataproxy` usage. Add 'null' to the `type` array in your schema if `None` is an allowed value for a property (e.g., `"type": ["string", "null"]`).

Warnings

breaking Apitools has a strict dependency on an old version of `jsonschema` (`>=2.5.1`). This is incompatible with modern `jsonschema` versions (4.x+), which have significant API and behavioral changes. Installing `apitools` in an environment with a newer `jsonschema` will likely lead to dependency conflicts or runtime errors.
Fix: Use a isolated virtual environment with specific `jsonschema<3` or pin `jsonschema==2.5.1` if using `apitools`. Consider migrating to an actively maintained library for JSON schema validation.
gotcha The `apitools` library is abandoned; its last release was in 2016 and there have been no code updates since 2021. It is not maintained, meaning no bug fixes, security patches, or compatibility updates for newer Python versions or libraries will be provided.
Fix: Be aware that using this library in new projects carries significant risk. Consider modern, actively maintained alternatives for JSON schema validation and API client generation.
gotcha Due to its age and lack of maintenance, `apitools` is unlikely to be fully compatible with recent Python versions (e.g., Python 3.8+). While it targets Python 2 and early Python 3, specific language features or dependency changes in newer Python versions may cause unexpected errors.
Fix: Test thoroughly in your target Python environment. It is recommended to use `apitools` only in legacy environments (Python 3.6 or older) where it was originally designed to run.

Install

pip install apitools Install stable version

Imports

Schema
```
from apitools.jsonschema import Schema
```

validate

from apitools.jsonschema import validate

Dataproxy

from apitools.dataproxy import Dataproxy

Client
```
from apitools.client import Client
```

Quickstart

This example demonstrates defining a JSON schema, validating data against it using `apitools.jsonschema.validate`, and using `apitools.dataproxy.Dataproxy` for schema-aware access and validation when modifying data.

from apitools.jsonschema import Schema, validate
from apitools.dataproxy import Dataproxy

# Define a simple JSON schema
my_schema = Schema({
    "type": "object",
    "properties": {
        "name": {"type": "string"},
        "age": {"type": "integer", "minimum": 0}
    },
    "required": ["name", "age"]
})

# Validate data against the schema
valid_data = {"name": "Alice", "age": 30}
invalid_data = {"name": "Bob", "age": -5} # age cannot be negative

try:
    validate(valid_data, my_schema)
    print("Valid data:", valid_data)
except Exception as e:
    print("Validation error for valid_data (should not happen):", e)

try:
    validate(invalid_data, my_schema)
    print("Validation attempt for invalid_data:", invalid_data)
except Exception as e:
    print("Validation error for invalid_data (expected):", e)
    # Expected: -5 is less than the minimum of 0

# Using Dataproxy for schema-aware data access
proxy_data = Dataproxy(valid_data, my_schema)
print(f"Proxy Name: {proxy_data.name}")
print(f"Proxy Age: {proxy_data.age}")

# Trying to set an invalid value (will raise ValidationError)
try:
    proxy_data.age = -10
except Exception as e:
    print("Attempt to set invalid age via Dataproxy failed as expected:", e)

view raw JSON →