iris-vector-graph 1.0.0__tar.gz

iris_vector_graph-1.0.0/.env.sample

@@ -0,0 +1,3 @@
+IRIS_DSN=IRIS_DEV
+IRIS_USER=_SYSTEM
+IRIS_PASS=SYS

iris_vector_graph-1.0.0/.env.test

@@ -0,0 +1,14 @@
+# Test Environment Configuration for Graph AI
+# IRIS Test Database Connection (runs on different ports to avoid conflicts)
+IRIS_DSN=IRIS_TEST
+IRIS_USER=_SYSTEM
+IRIS_PASS=SYS
+IRIS_HOST=localhost
+IRIS_PORT=1973
+IRIS_NAMESPACE=USER
+
+# Test-specific settings
+NODE_ENV=test
+LOG_LEVEL=error
+TEST_TIMEOUT=30000
+JEST_TIMEOUT=60000

iris_vector_graph-1.0.0/.gitignore

@@ -0,0 +1,111 @@
+# Dependencies
+node_modules
+dist
+
+# Environment files
+.env
+.env.local
+.env.*.local
+
+# Logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Backup files
+*.bak
+*.tmp
+*.orig
+*~
+
+# Archives
+*.zip
+*.tar.gz
+*.tar
+*.rar
+
+# Data directories (large test datasets)
+data/
+
+# License files (sensitive)
+*.key
+
+# IDE/Editor files
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# Claude configuration
+.claude/
+
+# Test coverage
+coverage/
+.nyc_output
+
+# Python cache
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# UV package manager
+.uv/
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+env/
+
+# Python testing
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+
+# Type checking
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# Test results
+test_results.json
+
+# Code assistant artifacts
+.claude-code/
+.sesskey
+*.sesskey
+IMPLEMENTATION_COMPLETE.md
+
+# Specification drafts (work in progress)
+specs/
+.specify/

iris_vector_graph-1.0.0/.python-version

@@ -0,0 +1 @@
+3.11

iris_vector_graph-1.0.0/CHANGELOG.md

@@ -0,0 +1,109 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] - 2025-10-19
+
+### Added
+
+#### Core Features
+- **IRIS-Native Graph Database**: RDF-based schema (`rdf_labels`, `rdf_props`, `rdf_edges`) with native IRIS globals storage
+- **Vector Search with HNSW**: 768-dimensional embeddings with HNSW optimization (100x performance improvement)
+- **Hybrid Search**: RRF fusion combining vector similarity + text search + graph constraints
+- **Bitemporal Data Model**: Track valid time vs. system time for regulatory compliance (SOX, MiFID II, Basel III)
+- **Embedded Python**: Run ML models and graph algorithms in-database using `/usr/irissys/bin/irispython`
+
+#### Deployment Modes
+- **External Deployment (DEFAULT)**: Python app connects to IRIS via `iris.connect()` - simpler setup, easier debugging
+- **Embedded Deployment (OPTIONAL)**: Python app runs inside IRIS container - maximum performance, requires licensed IRIS
+
+#### Financial Services (Fraud Detection)
+- Real-time fraud scoring API (<10ms) with MLP models
+- Device fingerprinting and graph-based fraud ring detection
+- Bitemporal audit trails for chargeback defense
+- Tested at scale: 130M transactions (licensed IRIS), 30M transactions (community IRIS)
+- FastAPI fraud server with external and embedded deployment options
+
+#### Biomedical Research
+- **Interactive Demo Server**: http://localhost:8200/bio
+- **STRING Database Integration**: 10K proteins, 37K interactions from STRING v12.0
+- **Protein Search**: Vector similarity search with HNSW (<2ms queries)
+- **Network Expansion**: Interactive D3.js visualization with click-to-expand nodes
+- **Pathway Analysis**: BFS pathfinding between proteins with confidence scoring
+- **Contract Tests**: 20/20 passing (search 6/6, network 5/5, pathway 4/4, scenario 5/5)
+
+#### Performance Optimizations
+- **HNSW Vector Index**: 1.7ms vs 5800ms flat search (3400x improvement with ACORN-1)
+- **Partial Indexes**: 10x faster queries with `WHERE system_to IS NULL`
+- **Foreign Key Constraints**: Referential integrity with 64% performance improvement
+- **Bounded Graph Queries**: Max 500 nodes per network expansion (FR-018)
+
+#### Python SDK (`iris_vector_graph_core`)
+- `IRISGraphEngine` - Core graph operations
+- `HybridSearchFusion` - RRF fusion algorithms
+- `TextSearchEngine` - IRIS iFind integration
+- `VectorOptimizer` - HNSW optimization utilities
+- `BiomedicalClient` - Direct IRIS queries for protein data
+
+#### Documentation
+- Comprehensive README with quick start for both domains
+- Deployment mode clarity: External (DEFAULT) vs Embedded (ADVANCED)
+- `CLAUDE.md` - Development guidance and architecture
+- `TODO.md` - Project roadmap and completed milestones
+- `PYPI_CHECKLIST.md` - Publication preparation guide
+- Performance benchmarks and scale testing results
+
+### Technical Details
+
+#### Database Schema
+- **Nodes Table**: `rdf_labels` with explicit PRIMARY KEY (NodePK implementation)
+- **Properties Table**: `rdf_props` with key-value pairs
+- **Edges Table**: `rdf_edges` with confidence scores and qualifiers
+- **Embeddings Table**: `kg_NodeEmbeddings_optimized` with VECTOR(FLOAT, 768) type
+- **Documents Table**: `kg_Documents` for full-text search
+
+#### SQL Procedures
+- `kg_KNN_VEC`: Vector similarity search with HNSW
+- `kg_TXT`: Full-text search using IRIS iFind
+- `kg_RRF_FUSE`: Reciprocal Rank Fusion (Cormack & Clarke SIGIR'09)
+- `kg_GRAPH_PATH`: Graph pathfinding with bounded hops
+
+#### Performance Metrics
+- Vector search: <10ms (HNSW), <2ms (ACORN-1)
+- Graph queries: <1ms (bounded hops)
+- Fraud scoring: <10ms (130M transactions)
+- Data ingestion: 476 proteins/second (STRING DB)
+- Multi-hop queries: <50ms (100K+ proteins)
+
+### Known Limitations
+- IRIS database required (InterSystems IRIS 2025.1+)
+- HNSW optimization requires ACORN-1 or IRIS 2025.3+
+- Embedded deployment requires licensed IRIS
+- Python 3.11+ required
+
+### Dependencies
+- `intersystems-irispython>=3.2.0` - IRIS database connectivity
+- `fastapi>=0.118.0` - Web framework for APIs
+- `networkx>=3.0` - Graph algorithms
+- `torch>=2.0.0` - ML model support (optional)
+- `sentence-transformers>=2.2.0` - Embeddings (optional)
+
+### Testing
+- 20/20 biomedical contract tests passing
+- Integration tests with live IRIS database
+- Performance benchmarks at scale (10K-100K proteins, 30M-130M transactions)
+
+---
+
+## [Unreleased]
+
+### Planned Features
+- openCypher API endpoint (branch: `002-add-opencypher-endpoint`)
+- GraphQL API with DataLoader batching (merged)
+- Multi-query-engine platform (SQL, openCypher, GraphQL)
+- Production hardening (SSL/TLS, monitoring, backup procedures)
+
+[1.0.0]: https://github.com/intersystems-community/iris-vector-graph/releases/tag/v1.0.0

iris_vector_graph-1.0.0/CLAUDE.md

@@ -0,0 +1,434 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Development Commands
+
+### Environment Setup
+```bash
+# Initial setup (using uv for modern Python package management)
+uv sync                      # Install dependencies via pyproject.toml
+source .venv/bin/activate    # Activate virtual environment
+
+# Alternative (if using requirements.txt)
+cp .env.sample .env          # Edit connection details for IRIS
+uv venv
+uv pip install -r requirements.txt
+```
+
+### Database Setup
+
+**Option 1: Docker (Recommended)**
+
+```bash
+# Standard IRIS Community Edition
+docker-compose up -d
+
+# ACORN-1 (pre-release build with HNSW optimization - fastest)
+docker-compose -f docker-compose.acorn.yml up -d
+```
+
+**Option 2: Manual IRIS Installation**
+
+Requires **InterSystems IRIS 2025.1+** with Vector Search (HNSW) feature:
+
+```sql
+-- Run in IRIS SQL tool
+\i sql/schema.sql
+\i sql/operators.sql       # Use operators_fixed.sql if this fails
+\i scripts/sample_data.sql # Optional sample data
+```
+
+Access IRIS Management Portal: http://localhost:52773/csp/sys/UtilHome.csp (or port 252773 for ACORN-1)
+
+### GraphQL API Server
+```bash
+# Start GraphQL API server (FastAPI + Strawberry)
+uvicorn api.main:app --reload --port 8000
+
+# Access GraphQL Playground UI
+open http://localhost:8000/graphql
+
+# Health check
+curl http://localhost:8000/health
+```
+
+### Testing
+```bash
+# Run test suite
+uv run python tests/python/run_all_tests.py       # All tests
+uv run python tests/python/run_all_tests.py --quick  # Quick validation
+
+# GraphQL API tests
+pytest tests/integration/gql/           # GraphQL resolvers
+pytest tests/integration/test_fastapi_graphql.py  # FastAPI endpoint
+
+# Direct pytest execution
+pytest tests/                                      # All tests
+pytest tests/unit/                                 # Unit tests only
+pytest tests/integration/                          # Integration tests only
+pytest -m requires_database                        # Database-dependent tests
+pytest --cov=iris_vector_graph_core               # With coverage
+```
+
+### Development Operations
+```bash
+# Schema and data management
+python scripts/setup_schema.py                     # Initialize database schema
+python scripts/sample_data.py                      # Load sample data
+
+# Performance testing
+uv run python scripts/performance/test_vector_performance.py
+uv run python scripts/performance/string_db_scale_test.py --max-proteins 10000
+```
+
+### openCypher API Server
+```bash
+# Start openCypher API server (ASGI)
+uvicorn api.main:app --reload --port 8000
+
+# Alternative: Direct execution
+uv run uvicorn api.main:app --reload --port 8000
+
+# Access API documentation
+open http://localhost:8000/docs  # Swagger UI
+open http://localhost:8000       # API info
+
+# Health check
+curl http://localhost:8000/health
+
+# Execute Cypher query
+curl -X POST http://localhost:8000/api/cypher \
+  -H "Content-Type: application/json" \
+  -d '{
+    "query": "MATCH (p:Protein {id: \"PROTEIN:TP53\"}) RETURN p.name",
+    "timeout": 30
+  }'
+
+# Parameterized Cypher query
+curl -X POST http://localhost:8000/api/cypher \
+  -H "Content-Type: application/json" \
+  -d '{
+    "query": "MATCH (p:Protein) WHERE p.id = $proteinId RETURN p.name",
+    "parameters": {"proteinId": "PROTEIN:TP53"}
+  }'
+```
+
+### Linting and Formatting
+```bash
+# Format code (per pyproject.toml configuration)
+black .
+isort .
+
+# Lint code
+flake8 .
+mypy iris_vector_graph_core/
+```
+
+## Architecture Overview
+
+This is a **Graph + Vector Retrieval** system targeting **InterSystems IRIS** that combines:
+
+- **Vector search (HNSW)** + **lexical search** + **graph constraints**
+- **openCypher query endpoint** for graph pattern matching
+- **IRIS-native Python** integration with embedded operations
+- **REST API** via FastAPI (openCypher) and IRIS ObjectScript classes
+- **iris_vector_graph_core** Python module for high-performance operations
+- **Direct iris.connect()** for optimal performance
+
+### Query Engines
+
+The system supports multiple query interfaces on the same NodePK schema:
+
+1. **openCypher API** (`/api/cypher`) - Graph pattern matching with Cypher syntax
+   - Parser: Pattern-based MVP parser (regex-based for common queries)
+   - Translator: AST-to-SQL with label/property pushdown optimizations
+   - Endpoint: FastAPI async endpoint at http://localhost:8000/api/cypher
+
+2. **SQL Direct** - Native IRIS SQL for maximum control
+   - Direct access to `nodes`, `rdf_edges`, `rdf_labels`, `rdf_props`, `kg_NodeEmbeddings`
+   - Full IRIS SQL capabilities including VECTOR functions
+
+3. **GraphQL API** (on main branch) - Type-safe graph queries
+   - Generic core + domain-specific types (Protein, Gene, Pathway as examples)
+   - DataLoader batching for N+1 prevention
+   - Vector similarity via `similar()` field resolver
+
+### Core Components
+
+1. **SQL Layer** (`sql/`):
+   - `schema.sql` - RDF-ish tables (`rdf_labels`, `rdf_props`, `rdf_edges`) + vector embeddings table with HNSW index
+   - `operators.sql` - Stored procedures: `kg_KNN_VEC`, `kg_TXT`, `kg_RRF_FUSE`, `kg_GRAPH_PATH`
+
+2. **Python SDK** (`python/`, `iris_vector_graph_core/`):
+   - `IRISGraphEngine` - Core graph operations and vector search
+   - `HybridSearchFusion` - RRF fusion of vector + text results
+   - `TextSearchEngine` - IRIS iFind integration
+   - `VectorOptimizer` - HNSW optimization utilities
+
+3. **GraphQL API** (`api/gql/`):
+   - **Query Engines**: GraphQL + openCypher on top of generic graph database
+   - `schema.py` - Strawberry GraphQL schema composition
+   - `types.py` - Node interface, domain types (Protein, Gene, Pathway as EXAMPLES)
+   - `resolvers/` - Query, Mutation resolvers with DataLoader batching
+   - `loaders.py` - 6 DataLoaders for N+1 prevention (ProteinLoader, EdgeLoader, etc.)
+   - **FastAPI**: `/graphql` endpoint with Playground UI (port 8000)
+
+4. **IRIS REST API** (`iris/src/`):
+   - `GraphAPI.cls` - REST endpoints for graph operations
+   - `VectorSearch.cls` - Vector similarity search endpoints
+   - `HybridSearch.cls` - Multi-modal search endpoints
+
+5. **Performance Testing** (`scripts/performance/`):
+   - `test_vector_performance.py` - Vector search benchmarks
+   - `string_db_scale_test.py` - Large-scale biomedical testing
+   - `benchmark_suite.py` - Comprehensive performance analysis
+
+### Environment Configuration
+
+Configure IRIS connection in `.env`:
+- `IRIS_HOST` - IRIS server hostname (default: localhost)
+- `IRIS_PORT` - IRIS SuperServer port (default: 1972 or 21972 for ACORN-1)
+- `IRIS_NAMESPACE` - IRIS namespace (default: USER)
+- `IRIS_USER` - Database username (default: _SYSTEM)
+- `IRIS_PASSWORD` - Database password (default: SYS)
+
+### IRIS Docker Port Mapping Strategy
+
+**Standardized Port Ranges** (per constitution):
+- **Default IRIS**: `1972:1972` and `52773:52773` (docker-compose.yml)
+- **Licensed IRIS (ACORN-1)**: `21972:1972` and `252773:52773` (docker-compose.acorn.yml)
+- **Development instances**: `11972:1972` and `152773:52773` (if needed for multiple instances)
+
+**Rationale**: Predictable ports avoid conflicts, enable easy configuration, support multiple IRIS instances
+
+### Key Technical Notes
+
+- **Vector embeddings**: Configured for 768-dimensional vectors (biomedical embeddings). HNSW optimization provides ~100x performance improvement.
+- **HNSW Index**: Optimized with ACORN=1 for production performance (1.7ms vs 5800ms baseline).
+- **RRF Fusion**: Uses Reciprocal Rank Fusion (Cormack & Clarke SIGIR'09) to combine vector and text search results.
+- **Graph queries**: Performance-optimized with bounded hops and confidence filtering.
+- **iris_vector_graph_core**: Modular design for integration with other RAG systems.
+- **Cypher-to-SQL Translation**: Label pushdown and property pushdown optimizations for fast queries.
+- **Query Pattern Matching**: MVP parser supports common Cypher patterns (MATCH, WHERE, RETURN, ORDER BY, LIMIT).
+
+### File Structure
+
+- `iris_vector_graph_core/` - Core Python module for graph operations
+- `biomedical/` - Domain-specific biomedical graph operations
+- `sql/` - Database schema and stored procedures
+- `iris/src/` - IRIS ObjectScript classes for REST API
+- `scripts/` - Setup, testing, and performance scripts
+- `tests/` - Comprehensive test suite
+- `docs/` - Documentation and performance analysis
+
+## Constitutional Requirements
+
+When developing, ensure compliance with `.specify/memory/constitution.md`:
+
+### Core Principles Summary
+1. **IRIS-Native Development** - Leverage IRIS capabilities directly (embedded Python, SQL procedures, ObjectScript)
+2. **Test-First with Live Database** - TDD with running IRIS instance (no mocked database for integration tests)
+3. **Performance as a Feature** - HNSW indexing, bounded queries, tracked benchmarks
+4. **Hybrid Search by Default** - Vector + text + graph using RRF fusion
+5. **Observability & Debuggability** - Structured logging at each layer
+6. **Modular Core Library** - Database-agnostic iris_vector_graph_core
+7. **Explicit Error Handling** - No silent failures, actionable error messages
+8. **Standardized Database Interfaces** - Use proven utilities, contribute patterns back
+
+### Testing Requirements (NON-NEGOTIABLE)
+- All tests involving data storage, vector operations, or graph operations MUST use live IRIS
+- Test categories:
+  - `@pytest.mark.requires_database` - MUST connect to live IRIS
+  - `@pytest.mark.integration` - MUST use IRIS for data operations
+  - `@pytest.mark.e2e` - MUST use complete IRIS + vector workflow
+  - Unit tests MAY mock IRIS for isolated component testing
+- Performance tests MUST verify: vector search <10ms, graph queries <1ms (with HNSW)
+
+### Development Standards
+- **Package Management**: Use `uv` for all Python dependency management
+- **Code Quality**: Pass black, isort, flake8, mypy before commits
+- **Documentation**: Comprehensive docstrings for all public APIs
+- **Versioning**: Follow semantic versioning for schema/API changes
+
+### AI Development Constraints
+- Follow constraint-based architecture, not "vibecoding"
+- Constitutional validation gates prevent repeating known bugs
+- Every bug fix MUST be captured as new validation rule or enhanced guideline
+- Work within established frameworks, patterns, and validation loops
+- **Constraint Philosophy**: Less freedom = less chaos. Constraints prevent regression.
+
+## Integration with RAG Systems
+
+The `iris_vector_graph_core` module is designed for integration with RAG frameworks like `rag-templates`:
+
+```python
+# Example usage in RAG pipeline
+from iris_vector_graph_core import HybridSearchFusion, IRISGraphEngine
+
+# Initialize engine with IRIS connection
+engine = IRISGraphEngine(connection_params)
+
+# Hybrid search combining vector, text, and graph
+results = engine.hybrid_search(
+    query_vector=embeddings,
+    query_text="cancer pathway",
+    k=15,
+    use_rrf=True
+)
+```
+
+See `docs/architecture/ACTUAL_SCHEMA.md` for working patterns and integration examples.
+
+## GraphQL API Usage
+
+### Quick Start
+
+```bash
+# 1. Start IRIS database
+docker-compose up -d
+
+# 2. Start GraphQL API server
+uvicorn api.main:app --reload --port 8000
+
+# 3. Open GraphQL Playground
+open http://localhost:8000/graphql
+```
+
+### Generic Graph Queries (Works for ANY domain)
+
+```graphql
+# Query any node by ID (returns Node interface)
+query {
+  node(id: "PROTEIN:TP53") {
+    __typename          # Type name (e.g., "Protein")
+    id
+    labels              # ["Protein"]
+    properties          # {name: "Tumor protein p53", function: "..."}
+    property(key: "name")  # "Tumor protein p53"
+    createdAt
+  }
+}
+
+# Query with GraphQL fragments for type-specific fields
+query {
+  node(id: "PROTEIN:TP53") {
+    ... on Protein {
+      name
+      function
+      organism
+    }
+    ... on Gene {
+      name
+      chromosome
+    }
+  }
+}
+```
+
+### Domain-Specific Queries (Biomedical Example)
+
+```graphql
+# Query protein with nested interactions
+query {
+  protein(id: "PROTEIN:TP53") {
+    name
+    function
+    interactsWith(first: 5) {
+      name
+      function
+    }
+  }
+}
+
+# Vector similarity search (HNSW-optimized)
+query {
+  protein(id: "PROTEIN:TP53") {
+    name
+    similar(limit: 10, threshold: 0.7) {
+      protein {
+        name
+        function
+      }
+      similarity
+    }
+  }
+}
+
+# Gene encoding proteins
+query {
+  gene(id: "GENE:TP53") {
+    name
+    chromosome
+    encodes(first: 5) {
+      name
+      function
+    }
+  }
+}
+```
+
+### Mutations
+
+```graphql
+# Create protein with embedding
+mutation {
+  createProtein(input: {
+    id: "PROTEIN:NEW_PROTEIN"
+    name: "Novel Protein"
+    function: "Unknown function"
+    embedding: [0.1, 0.2, ..., 0.768]  # 768-dimensional vector
+  }) {
+    id
+    name
+    function
+  }
+}
+
+# Update protein fields (partial update)
+mutation {
+  updateProtein(
+    id: "PROTEIN:TP53"
+    input: {
+      function: "Updated function description"
+      confidence: 0.95
+    }
+  ) {
+    id
+    name
+    function
+    confidence
+  }
+}
+
+# Delete protein (cascade via FK constraints)
+mutation {
+  deleteProtein(id: "PROTEIN:OLD_PROTEIN")
+}
+```
+
+### Architecture Notes
+
+**GraphQL and openCypher are Query Engines** on top of a generic graph database:
+
+```
+┌────────────────────────────────────────┐
+│   Query Engines (User-Facing)         │
+│   GraphQL | openCypher | SQL          │
+└────────────────────────────────────────┘
+              ▼
+┌────────────────────────────────────────┐
+│   Core Graph Database (Generic)        │
+│   NodePK: nodes, rdf_edges, rdf_*     │
+│   Vector: kg_NodeEmbeddings + HNSW    │
+└────────────────────────────────────────┘
+              ▼
+┌────────────────────────────────────────┐
+│   Domain Schemas (Optional)            │
+│   Biomedical | Social | E-commerce    │
+└────────────────────────────────────────┘
+```
+
+**Design Principle**: Biomedical types (Protein, Gene, Pathway) are **EXAMPLE implementations**, not the core API. Use generic `node()` query for custom domains.
+
+See `docs/architecture/generic_graph_api_design.md` for full architecture details.

iris_vector_graph-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to do so, subject to the
+following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.