crewdeck 0.1.0__py3-none-any.whl

crewdeck/__init__.py

@@ -0,0 +1,43 @@
+"""
+CrewDeck Python SDK
+
+Manage your AI agent teams with CrewDeck.
+
+Quick Start:
+    from crewdeck import CrewDeck
+    
+    deck = CrewDeck(api_key="your-api-key")
+    
+    # Create a task
+    task = deck.tasks.create(
+        title="Analyze data",
+        description="Process the Q4 sales data",
+        priority="high",
+        assignees=["JARVIS"]
+    )
+    
+    # Update agent status
+    deck.agents.update_status("JARVIS", "working")
+    
+    # Send an event to the live feed
+    deck.events.send(
+        type="message",
+        agent_name="JARVIS",
+        message="Starting data analysis..."
+    )
+"""
+
+from .client import CrewDeck
+from .models import Task, Agent, Event
+from .exceptions import CrewDeckError, AuthenticationError, APIError
+
+__version__ = "0.1.0"
+__all__ = [
+    "CrewDeck",
+    "Task",
+    "Agent", 
+    "Event",
+    "CrewDeckError",
+    "AuthenticationError",
+    "APIError",
+]

crewdeck/client.py

@@ -0,0 +1,395 @@
+"""CrewDeck Python Client"""
+
+from typing import List, Optional, Dict, Any
+import httpx
+
+from .models import Task, Agent, Event
+from .exceptions import (
+    CrewDeckError,
+    AuthenticationError,
+    APIError,
+    NotFoundError,
+    RateLimitError,
+)
+
+
+DEFAULT_BASE_URL = "https://adept-jellyfish-320.convex.site"
+
+
+class TasksAPI:
+    """Tasks API wrapper"""
+    
+    def __init__(self, client: "CrewDeck"):
+        self._client = client
+    
+    def create(
+        self,
+        title: str,
+        description: str = "",
+        status: str = "INBOX",
+        priority: str = "medium",
+        assignees: Optional[List[str]] = None,
+        tags: Optional[List[str]] = None,
+    ) -> Task:
+        """
+        Create a new task.
+        
+        Args:
+            title: Task title (required)
+            description: Task description
+            status: Task status (INBOX, ASSIGNED, IN PROGRESS, REVIEW, DONE)
+            priority: Priority level (low, medium, high, critical)
+            assignees: List of agent names to assign
+            tags: List of tags
+            
+        Returns:
+            Created Task object
+        """
+        data = {
+            "title": title,
+            "description": description,
+            "status": status,
+            "priority": priority,
+            "assignees": assignees or [],
+            "tags": tags or [],
+        }
+        response = self._client._request("POST", "/api/v1/tasks", json=data)
+        return Task(
+            id=response.get("taskId", ""),
+            title=title,
+            description=description,
+            status=status,
+            priority=priority,
+            assignees=assignees or [],
+            tags=tags or [],
+        )
+    
+    def list(
+        self,
+        status: Optional[str] = None,
+        limit: int = 100,
+    ) -> List[Task]:
+        """
+        List tasks.
+        
+        Args:
+            status: Filter by status (optional)
+            limit: Maximum number of tasks to return
+            
+        Returns:
+            List of Task objects
+        """
+        params = {"limit": str(limit)}
+        if status:
+            params["status"] = status
+        response = self._client._request("GET", "/api/v1/tasks", params=params)
+        return [Task.from_dict(t) for t in response.get("tasks", [])]
+    
+    def update(
+        self,
+        task_id: str,
+        title: Optional[str] = None,
+        description: Optional[str] = None,
+        status: Optional[str] = None,
+        priority: Optional[str] = None,
+        assignees: Optional[List[str]] = None,
+        tags: Optional[List[str]] = None,
+        output: Optional[str] = None,
+    ) -> None:
+        """
+        Update a task.
+        
+        Args:
+            task_id: Task ID (required)
+            title: New title
+            description: New description
+            status: New status
+            priority: New priority
+            assignees: New assignees list
+            tags: New tags list
+            output: Task output/result
+        """
+        data: Dict[str, Any] = {"id": task_id}
+        if title is not None:
+            data["title"] = title
+        if description is not None:
+            data["description"] = description
+        if status is not None:
+            data["status"] = status
+        if priority is not None:
+            data["priority"] = priority
+        if assignees is not None:
+            data["assignees"] = assignees
+        if tags is not None:
+            data["tags"] = tags
+        if output is not None:
+            data["output"] = output
+        self._client._request("PUT", "/api/v1/tasks", json=data)
+    
+    def move(self, task_id: str, status: str) -> None:
+        """
+        Move a task to a new status.
+        
+        Args:
+            task_id: Task ID
+            status: New status (INBOX, ASSIGNED, IN PROGRESS, REVIEW, DONE)
+        """
+        self.update(task_id, status=status)
+    
+    def complete(self, task_id: str, output: Optional[str] = None) -> None:
+        """
+        Mark a task as done.
+        
+        Args:
+            task_id: Task ID
+            output: Optional output/result
+        """
+        self.update(task_id, status="DONE", output=output)
+
+
+class AgentsAPI:
+    """Agents API wrapper"""
+    
+    def __init__(self, client: "CrewDeck"):
+        self._client = client
+    
+    def create(
+        self,
+        name: str,
+        avatar: str = "🤖",
+        role: str = "AI Agent",
+        level: str = "standard",
+        status: str = "idle",
+    ) -> Agent:
+        """
+        Create a new agent.
+        
+        Args:
+            name: Agent name (required)
+            avatar: Emoji avatar
+            role: Agent role description
+            level: Agent level (standard, INT, LEAD, SPC)
+            status: Initial status (idle, working, offline)
+            
+        Returns:
+            Created Agent object
+        """
+        data = {
+            "name": name,
+            "avatar": avatar,
+            "role": role,
+            "level": level,
+            "status": status,
+        }
+        response = self._client._request("POST", "/api/v1/agents", json=data)
+        return Agent(
+            id=response.get("agentId", ""),
+            name=name,
+            avatar=avatar,
+            role=role,
+            level=level,
+            status=status,
+        )
+    
+    def list(self) -> List[Agent]:
+        """
+        List all agents.
+        
+        Returns:
+            List of Agent objects
+        """
+        response = self._client._request("GET", "/api/v1/agents")
+        return [Agent.from_dict(a) for a in response.get("agents", [])]
+    
+    def update_status(self, name: str, status: str) -> None:
+        """
+        Update an agent's status by name.
+        
+        Args:
+            name: Agent name
+            status: New status (idle, working, offline)
+        """
+        self._client._request("PUT", "/api/v1/agents", json={
+            "name": name,
+            "status": status,
+        })
+    
+    def set_working(self, name: str) -> None:
+        """Set agent status to working"""
+        self.update_status(name, "working")
+    
+    def set_idle(self, name: str) -> None:
+        """Set agent status to idle"""
+        self.update_status(name, "idle")
+    
+    def set_offline(self, name: str) -> None:
+        """Set agent status to offline"""
+        self.update_status(name, "offline")
+
+
+class EventsAPI:
+    """Events API wrapper"""
+    
+    def __init__(self, client: "CrewDeck"):
+        self._client = client
+    
+    def send(
+        self,
+        type: str,
+        agent_name: Optional[str] = None,
+        message: Optional[str] = None,
+        task_id: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """
+        Send an event to the live feed.
+        
+        Args:
+            type: Event type (message, status, log)
+            agent_name: Agent name (optional)
+            message: Message content
+            task_id: Related task ID
+            metadata: Additional metadata
+        """
+        event = Event(
+            type=type,
+            agent_name=agent_name,
+            message=message,
+            task_id=task_id,
+            metadata=metadata,
+        )
+        self._client._request("POST", "/api/v1/events", json=event.to_dict())
+    
+    def message(self, content: str, agent_name: Optional[str] = None) -> None:
+        """
+        Send a message to the live feed.
+        
+        Args:
+            content: Message content
+            agent_name: Agent name (optional)
+        """
+        self.send(type="message", message=content, agent_name=agent_name)
+    
+    def log(
+        self,
+        message: str,
+        agent_name: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """
+        Send a log event.
+        
+        Args:
+            message: Log message
+            agent_name: Agent name (optional)
+            metadata: Additional data to log
+        """
+        self.send(type="log", message=message, agent_name=agent_name, metadata=metadata)
+
+
+class CrewDeck:
+    """
+    CrewDeck Python Client
+    
+    Example:
+        deck = CrewDeck(api_key="your-api-key")
+        
+        # Create a task
+        task = deck.tasks.create(
+            title="Process data",
+            priority="high",
+            assignees=["JARVIS"]
+        )
+        
+        # Update agent status
+        deck.agents.set_working("JARVIS")
+        
+        # Send a message
+        deck.events.message("Starting work...", agent_name="JARVIS")
+        
+        # Complete the task
+        deck.tasks.complete(task.id, output="Data processed successfully")
+    """
+    
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 30.0,
+    ):
+        """
+        Initialize CrewDeck client.
+        
+        Args:
+            api_key: Your CrewDeck API key
+            base_url: API base URL (default: production)
+            timeout: Request timeout in seconds
+        """
+        if not api_key:
+            raise AuthenticationError("API key is required")
+        
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        
+        self._client = httpx.Client(
+            base_url=self.base_url,
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
+            },
+            timeout=timeout,
+        )
+        
+        # API namespaces
+        self.tasks = TasksAPI(self)
+        self.agents = AgentsAPI(self)
+        self.events = EventsAPI(self)
+    
+    def _request(
+        self,
+        method: str,
+        path: str,
+        params: Optional[Dict[str, str]] = None,
+        json: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Make an API request"""
+        try:
+            response = self._client.request(
+                method=method,
+                url=path,
+                params=params,
+                json=json,
+            )
+            
+            if response.status_code == 401:
+                raise AuthenticationError("Invalid or revoked API key")
+            
+            if response.status_code == 404:
+                raise NotFoundError("Resource not found", status_code=404)
+            
+            if response.status_code == 429:
+                raise RateLimitError("Rate limit exceeded", status_code=429)
+            
+            if response.status_code >= 400:
+                try:
+                    error_data = response.json()
+                    message = error_data.get("error", f"API error: {response.status_code}")
+                except:
+                    message = f"API error: {response.status_code}"
+                raise APIError(message, status_code=response.status_code)
+            
+            return response.json()
+            
+        except httpx.RequestError as e:
+            raise CrewDeckError(f"Request failed: {e}")
+    
+    def close(self) -> None:
+        """Close the HTTP client"""
+        self._client.close()
+    
+    def __enter__(self) -> "CrewDeck":
+        return self
+    
+    def __exit__(self, *args) -> None:
+        self.close()

crewdeck/exceptions.py

@@ -0,0 +1,35 @@
+"""CrewDeck SDK Exceptions"""
+
+
+class CrewDeckError(Exception):
+    """Base exception for CrewDeck SDK"""
+    pass
+
+
+class AuthenticationError(CrewDeckError):
+    """Raised when API key is invalid or missing"""
+    pass
+
+
+class APIError(CrewDeckError):
+    """Raised when API returns an error"""
+    
+    def __init__(self, message: str, status_code: int = None, response: dict = None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.response = response
+
+
+class ValidationError(CrewDeckError):
+    """Raised when input validation fails"""
+    pass
+
+
+class NotFoundError(APIError):
+    """Raised when a resource is not found"""
+    pass
+
+
+class RateLimitError(APIError):
+    """Raised when rate limit is exceeded"""
+    pass

crewdeck/models.py

@@ -0,0 +1,103 @@
+"""CrewDeck Data Models"""
+
+from dataclasses import dataclass, field
+from typing import List, Optional, Dict, Any
+from datetime import datetime
+
+
+@dataclass
+class Task:
+    """Represents a task in CrewDeck"""
+    id: str
+    title: str
+    description: str = ""
+    status: str = "INBOX"
+    priority: str = "medium"
+    assignees: List[str] = field(default_factory=list)
+    tags: List[str] = field(default_factory=list)
+    output: Optional[str] = None
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Task":
+        return cls(
+            id=data.get("id", ""),
+            title=data.get("title", ""),
+            description=data.get("description", ""),
+            status=data.get("status", "INBOX"),
+            priority=data.get("priority", "medium"),
+            assignees=data.get("assignees", []),
+            tags=data.get("tags", []),
+            output=data.get("output"),
+            created_at=datetime.fromtimestamp(data["createdAt"] / 1000) if data.get("createdAt") else None,
+            updated_at=datetime.fromtimestamp(data["updatedAt"] / 1000) if data.get("updatedAt") else None,
+        )
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "id": self.id,
+            "title": self.title,
+            "description": self.description,
+            "status": self.status,
+            "priority": self.priority,
+            "assignees": self.assignees,
+            "tags": self.tags,
+            "output": self.output,
+        }
+
+
+@dataclass
+class Agent:
+    """Represents an agent in CrewDeck"""
+    id: str
+    name: str
+    avatar: str = "🤖"
+    role: str = "AI Agent"
+    level: str = "standard"
+    status: str = "idle"
+    created_at: Optional[datetime] = None
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Agent":
+        return cls(
+            id=data.get("id", ""),
+            name=data.get("name", ""),
+            avatar=data.get("avatar", "🤖"),
+            role=data.get("role", "AI Agent"),
+            level=data.get("level", "standard"),
+            status=data.get("status", "idle"),
+            created_at=datetime.fromtimestamp(data["createdAt"] / 1000) if data.get("createdAt") else None,
+        )
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "id": self.id,
+            "name": self.name,
+            "avatar": self.avatar,
+            "role": self.role,
+            "level": self.level,
+            "status": self.status,
+        }
+
+
+@dataclass
+class Event:
+    """Represents an event in CrewDeck"""
+    type: str
+    agent_name: Optional[str] = None
+    message: Optional[str] = None
+    task_id: Optional[str] = None
+    metadata: Optional[Dict[str, Any]] = None
+    
+    def to_dict(self) -> Dict[str, Any]:
+        data = {"type": self.type}
+        if self.agent_name:
+            data["agentName"] = self.agent_name
+        if self.message:
+            data["message"] = self.message
+        if self.task_id:
+            data["taskId"] = self.task_id
+        if self.metadata:
+            data["metadata"] = self.metadata
+        return data

crewdeck-0.1.0.dist-info/METADATA

@@ -0,0 +1,240 @@
+Metadata-Version: 2.4
+Name: crewdeck
+Version: 0.1.0
+Summary: Python SDK for CrewDeck - AI agent management dashboard
+Project-URL: Homepage, https://crewdeck.dev
+Project-URL: Documentation, https://docs.crewdeck.dev
+Project-URL: Repository, https://github.com/crewdeck/crewdeck-python
+Author-email: CrewDeck <hello@crewdeck.dev>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,ai,autogen,crewai,dashboard,langchain,management
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Requires-Dist: httpx>=0.24.0
+Provides-Extra: async
+Requires-Dist: httpx[http2]>=0.24.0; extra == 'async'
+Provides-Extra: dev
+Requires-Dist: black>=23.0.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# CrewDeck Python SDK
+
+Official Python SDK for [CrewDeck](https://crewdeck.dev) — the AI agent management dashboard.
+
+Manage your AI crew like a real team. Assign tasks, track progress, review outputs, approve results.
+
+## Installation
+
+```bash
+pip install crewdeck
+```
+
+## Quick Start
+
+```python
+from crewdeck import CrewDeck
+
+# Initialize with your API key
+deck = CrewDeck(api_key="your-api-key")
+
+# Create a task
+task = deck.tasks.create(
+    title="Analyze Q4 sales data",
+    description="Process and summarize the quarterly sales report",
+    priority="high",
+    assignees=["JARVIS"]
+)
+
+# Update agent status
+deck.agents.set_working("JARVIS")
+
+# Send progress updates
+deck.events.message("Starting data analysis...", agent_name="JARVIS")
+
+# Complete the task with output
+deck.tasks.complete(task.id, output="Analysis complete. Revenue up 15% YoY.")
+```
+
+## API Reference
+
+### Tasks
+
+```python
+# Create a task
+task = deck.tasks.create(
+    title="Task title",
+    description="Task description",
+    status="INBOX",  # INBOX, ASSIGNED, IN PROGRESS, REVIEW, DONE
+    priority="medium",  # low, medium, high, critical
+    assignees=["JARVIS", "FRIDAY"],
+    tags=["data", "analysis"]
+)
+
+# List tasks
+tasks = deck.tasks.list()
+tasks = deck.tasks.list(status="IN PROGRESS", limit=50)
+
+# Update a task
+deck.tasks.update(
+    task_id="task-id",
+    status="IN PROGRESS",
+    output="Working on it..."
+)
+
+# Move task to a status
+deck.tasks.move(task_id, "REVIEW")
+
+# Complete a task
+deck.tasks.complete(task_id, output="Done!")
+```
+
+### Agents
+
+```python
+# Create an agent
+agent = deck.agents.create(
+    name="JARVIS",
+    avatar="🤖",
+    role="AI Assistant",
+    level="LEAD",  # standard, INT, LEAD, SPC
+    status="idle"
+)
+
+# List agents
+agents = deck.agents.list()
+
+# Update agent status
+deck.agents.update_status("JARVIS", "working")
+
+# Convenience methods
+deck.agents.set_working("JARVIS")
+deck.agents.set_idle("JARVIS")
+deck.agents.set_offline("JARVIS")
+```
+
+### Events
+
+```python
+# Send a message to the live feed
+deck.events.message("Starting work...", agent_name="JARVIS")
+
+# Send a log event
+deck.events.log(
+    message="Processing file",
+    agent_name="JARVIS",
+    metadata={"file": "data.csv", "rows": 1000}
+)
+
+# Send a custom event
+deck.events.send(
+    type="custom",
+    agent_name="JARVIS",
+    message="Custom event",
+    metadata={"key": "value"}
+)
+```
+
+## Integration Examples
+
+### CrewAI
+
+```python
+from crewai import Agent, Task, Crew
+from crewdeck import CrewDeck
+
+deck = CrewDeck(api_key="your-api-key")
+
+# Sync CrewAI agent with CrewDeck
+crewai_agent = Agent(
+    role="Researcher",
+    goal="Research topics",
+    backstory="Expert researcher"
+)
+
+# Create corresponding agent in CrewDeck
+deck.agents.create(
+    name="Researcher",
+    avatar="🔬",
+    role="Research Agent",
+    level="INT"
+)
+
+# When starting a task
+def on_task_start(task):
+    deck.agents.set_working("Researcher")
+    deck.events.message(f"Starting: {task.description}", agent_name="Researcher")
+
+# When task completes
+def on_task_complete(task, output):
+    deck.events.message(f"Completed: {task.description}", agent_name="Researcher")
+    deck.agents.set_idle("Researcher")
+```
+
+### LangChain
+
+```python
+from langchain.callbacks.base import BaseCallbackHandler
+from crewdeck import CrewDeck
+
+class CrewDeckCallback(BaseCallbackHandler):
+    def __init__(self, deck: CrewDeck, agent_name: str):
+        self.deck = deck
+        self.agent_name = agent_name
+    
+    def on_chain_start(self, serialized, inputs, **kwargs):
+        self.deck.agents.set_working(self.agent_name)
+        self.deck.events.message(f"Processing: {inputs}", agent_name=self.agent_name)
+    
+    def on_chain_end(self, outputs, **kwargs):
+        self.deck.events.message(f"Result: {outputs}", agent_name=self.agent_name)
+        self.deck.agents.set_idle(self.agent_name)
+```
+
+## Context Manager
+
+```python
+with CrewDeck(api_key="your-api-key") as deck:
+    task = deck.tasks.create(title="My task")
+    # Client automatically closes when done
+```
+
+## Error Handling
+
+```python
+from crewdeck import CrewDeck, AuthenticationError, APIError
+
+try:
+    deck = CrewDeck(api_key="invalid-key")
+    deck.tasks.list()
+except AuthenticationError:
+    print("Invalid API key")
+except APIError as e:
+    print(f"API error: {e} (status: {e.status_code})")
+```
+
+## Configuration
+
+```python
+deck = CrewDeck(
+    api_key="your-api-key",
+    base_url="https://your-convex-deployment.convex.site",  # Custom deployment
+    timeout=30.0  # Request timeout in seconds
+)
+```
+
+## License
+
+MIT

crewdeck-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+crewdeck/__init__.py,sha256=gacJzO7ee1B2wvd0oyX4VC8SFiDLnD2ophYHMgAE8Hg,905
+crewdeck/client.py,sha256=ZcrLjDcCCscoQj2rFsGMJ-FTZOmu0YeAhQF1oX7EzP4,11266
+crewdeck/exceptions.py,sha256=vOvYYdlP0wvkuuUhYE5Wj2pnuJXqmCiYcs5cobdijDM,763
+crewdeck/models.py,sha256=-2cScY_4I-0wg33S5Pa3EfKBx7tSdrCOMU2RPTXjIpw,3182
+crewdeck-0.1.0.dist-info/METADATA,sha256=I5IPqTQoAuF7A3cRwUfo1wgOTtPAtoTzh8oMRv6XFjQ,5884
+crewdeck-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+crewdeck-0.1.0.dist-info/licenses/LICENSE,sha256=z0AZu5f134PY4UJ0L_nPuqlyZa14gMPIR-4u8M-5qjI,1065
+crewdeck-0.1.0.dist-info/RECORD,,

crewdeck-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

crewdeck-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CrewDeck
+
+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 whom the Software is
+furnished 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.