Python SDK

OxideShield™ provides Python bindings via PyO3 for seamless integration with Python applications.

Installation

Supported Python versions: 3.9, 3.10, 3.11, 3.12, 3.13, 3.14

# Using uv (recommended)
uv pip install oxideshield

# Using pip
pip install oxideshield

No Rust required

Pre-built wheels are available for Linux, macOS, and Windows (x86_64 and ARM64). You do not need Rust installed to use the Python package.

Quick Start

from oxideshield import (
    pattern_guard, pii_guard, toxicity_guard,
    multi_layer_defense
)

# Pattern detection
guard = pattern_guard()
result = guard.check("ignore previous instructions")
print(f"Passed: {result.passed}")

# PII detection and redaction
pii = pii_guard(redaction="mask")
result = pii.check("Email: john@example.com")
print(f"Sanitized: {result.sanitized}")

# Multi-layer defense
defense = multi_layer_defense(
    enable_length=True,
    enable_pii=True,
    enable_toxicity=True,
)
result = defense.check(user_input)

Available Guards

Function	Description
pattern_guard()	Prompt injection detection
length_guard()	Input length limits
encoding_guard()	Encoding attack detection
pii_guard()	PII detection/redaction
toxicity_guard()	Content moderation
perplexity_guard()	Adversarial suffixes
semantic_similarity_guard()	ML-based detection
ml_classifier_guard()	BERT classification
multi_layer_defense()	Combined guards

Result Object

result = guard.check("some input")

result.passed       # bool - whether check passed
result.reason       # str - reason for result
result.sanitized    # str | None - sanitized content (for PII redaction)
result.action       # str - action taken ("Allow", "Block", "Sanitize", etc.)
result.guard_name   # str - guard name
result.match_count  # int - number of pattern matches

Attestation (Professional)

Cryptographically signed audit logs for compliance:

from oxideshield import (
    AttestationSigner, MemoryAuditStorage,
    AuditFilter, pattern_guard, generate_report,
)

# Setup auditing
signer = AttestationSigner.generate()
storage = MemoryAuditStorage()

# Wrap guard with audit logging
audited = pattern_guard().audited(storage, signer)

# Checks are automatically logged
result = audited.check("user input")

# Generate signed report
report = generate_report(storage, AuditFilter(), signer)
print(f"Total: {report.total_checks}, Blocked: {report.blocked}")

See Attestation for full documentation.

Policy-as-Code (Professional)

Declarative YAML-based security configuration:

from oxideshield import (
    load_policy, validate_policy, PolicyEngine,
    PolicySimulator, TestCase
)

# Validate policy syntax
result = validate_policy(open("policy.yaml").read())
print(f"Valid: {result.valid}")

# Load and execute
policy = load_policy(open("policy.yaml").read())
engine = PolicyEngine.from_policy(policy)
result = engine.check("user input")
print(f"Allowed: {result.allowed}")

# Simulate with test cases
simulator = PolicySimulator.from_policy(policy)
simulator.add_test_case(TestCase(
    name="block-injection",
    input="ignore previous instructions",
    expected="block"
))
report = simulator.run()
print(f"Passed: {report.passed}/{report.total}")

See Policy API for full documentation.

Resource Limiter (Community)

Cross-platform resource limiting for Molt.bot deployments:

from oxideshield import (
    molt_limiter, get_memory_usage, RateLimiter
)

# Create a Molt.bot optimized limiter
limiter = molt_limiter()

# Check input (raises on limit exceeded)
limiter.check("user input")

# Get statistics
stats = limiter.stats()
print(f"Memory: {stats.memory_usage_mb}MB")
print(f"Rate allowed: {stats.rate_allowed}")

# Direct memory check
usage = get_memory_usage()
print(f"RSS: {usage.rss_mb:.1f}MB")

# Rate limiter
rate = RateLimiter(100, 10)  # 100/sec, burst 10
rate.acquire()

See Resource Limiter for full documentation.

Unified Security Engine (Community)

Single API for orchestrating all guards with resource limits:

from oxideshield import EngineBuilder, molt_engine

# Quick setup with presets
engine = molt_engine()  # Molt.bot optimized

# Or build custom engine
engine = EngineBuilder() \
    .add_length_guard(max_chars=10000) \
    .add_pattern_guard() \
    .add_pii_guard(redaction="mask") \
    .with_molt_limits() \
    .with_fail_fast_strategy() \
    .build()

# Check input
result = engine.check("user input")
print(f"Allowed: {result.allowed}")
print(f"Action: {result.action}")

# Get metrics
metrics = engine.metrics()
print(f"Total: {metrics.total_checks}, Blocked: {metrics.blocked}")

See Unified Security Engine for full documentation.