soorma-core 0.3.0__py3-none-any.whl

soorma/utils/schema_utils.py

@@ -0,0 +1,209 @@
+"""
+Utility functions for converting JSON Schema to Pydantic models.
+
+This module provides helpers to dynamically generate Pydantic models from JSON Schema
+definitions stored in the event registry, enabling type-safe event payload construction
+and validation.
+"""
+from typing import Any, Dict, Optional, Tuple, Type, Union, get_args, get_origin, List
+from pydantic import create_model, Field, ValidationError
+from soorma_common import BaseDTO, EventDefinition
+
+
+def json_schema_to_pydantic(
+    schema: Dict[str, Any],
+    model_name: str = "DynamicModel",
+    base_class: Type[BaseDTO] = BaseDTO
+) -> Type[BaseDTO]:
+    """
+    Convert a JSON Schema (Draft 7) to a Pydantic model dynamically.
+    
+    This function creates a Pydantic model class that inherits from BaseDTO,
+    providing automatic camelCase JSON serialization and validation.
+    
+    Args:
+        schema: JSON Schema dictionary (must be type "object")
+        model_name: Name for the generated Pydantic model class
+        base_class: Base class to inherit from (default: BaseDTO)
+        
+    Returns:
+        A dynamically created Pydantic model class
+        
+    Raises:
+        ValueError: If schema is not of type "object" or is invalid
+        
+    Example:
+        >>> schema = {
+        ...     "type": "object",
+        ...     "properties": {
+        ...         "user_name": {"type": "string"},
+        ...         "age": {"type": "integer"}
+        ...     },
+        ...     "required": ["user_name"]
+        ... }
+        >>> UserModel = json_schema_to_pydantic(schema, "User")
+        >>> user = UserModel(user_name="Alice", age=30)
+        >>> user.model_dump_json()  # Will use camelCase: {"userName": "Alice", "age": 30}
+    """
+    if not isinstance(schema, dict):
+        raise ValueError("Schema must be a dictionary")
+    
+    schema_type = schema.get("type")
+    if schema_type != "object":
+        raise ValueError(f"Only 'object' type schemas are supported, got: {schema_type}")
+    
+    properties = schema.get("properties", {})
+    required_fields = set(schema.get("required", []))
+    
+    if not properties:
+        # Empty object schema
+        return create_model(model_name, __base__=base_class)
+    
+    # Build field definitions for Pydantic
+    field_definitions = {}
+    
+    for field_name, field_schema in properties.items():
+        field_type = _json_type_to_python_type(field_schema, f"{model_name}_{field_name}")
+        
+        # Determine if field is required
+        is_required = field_name in required_fields
+        
+        # Get field metadata
+        description = field_schema.get("description", "")
+        
+        # Set default value
+        if is_required:
+            default = ...  # Ellipsis means required in Pydantic
+        else:
+            # Optional fields default to None
+            default = None
+            # Wrap type in Optional
+            field_type = Optional[field_type]
+        
+        # Create Field with metadata
+        field_definitions[field_name] = (
+            field_type,
+            Field(default=default, description=description)
+        )
+    
+    # Create the model dynamically
+    return create_model(
+        model_name,
+        __base__=base_class,
+        **field_definitions
+    )
+
+
+def _json_type_to_python_type(
+    field_schema: Dict[str, Any],
+    nested_name: str = "NestedModel"
+) -> Type:
+    """
+    Recursively convert JSON Schema types to Python types.
+    """
+    json_type = field_schema.get("type")
+    
+    if json_type == "string":
+        return str
+    elif json_type == "integer":
+        return int
+    elif json_type == "number":
+        return float
+    elif json_type == "boolean":
+        return bool
+    elif json_type == "array":
+        item_schema = field_schema.get("items", {})
+        item_type = _json_type_to_python_type(item_schema, f"{nested_name}_Item")
+        return List[item_type]
+    elif json_type == "object":
+        # Recursive call for nested objects
+        return json_schema_to_pydantic(field_schema, nested_name)
+    else:
+        # Fallback for unknown types or 'any'
+        return Any
+
+
+def pydantic_to_json_schema(model_class: Type[BaseDTO]) -> Dict[str, Any]:
+    """
+    Convert a Pydantic model to JSON Schema.
+    
+    Args:
+        model_class: Pydantic model class
+        
+    Returns:
+        JSON Schema dictionary
+    """
+    return model_class.model_json_schema()
+
+
+def create_event_models(event_def: EventDefinition) -> Tuple[Type[BaseDTO], Optional[Type[BaseDTO]]]:
+    """
+    Create Pydantic models for an event's payload and response.
+    
+    Args:
+        event_def: Event definition from registry
+        
+    Returns:
+        Tuple of (PayloadModel, ResponseModel)
+        ResponseModel will be None if no response schema is defined.
+    """
+    # Create payload model
+    payload_model_name = f"{_snake_to_pascal(event_def.event_name)}Payload"
+    payload_model = json_schema_to_pydantic(
+        event_def.payload_schema,
+        payload_model_name
+    )
+    
+    # Create response model if exists
+    response_model = None
+    if event_def.response_schema:
+        response_model_name = f"{_snake_to_pascal(event_def.event_name)}Response"
+        response_model = json_schema_to_pydantic(
+            event_def.response_schema,
+            response_model_name
+        )
+        
+    return payload_model, response_model
+
+
+def validate_against_schema(data: Dict[str, Any], schema: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Validate a dictionary against a JSON schema using Pydantic.
+    
+    Args:
+        data: Data to validate
+        schema: JSON schema to validate against
+        
+    Returns:
+        Validated data (potentially with type coercion)
+        
+    Raises:
+        ValidationError: If validation fails
+    """
+    DynamicModel = json_schema_to_pydantic(schema)
+    model_instance = DynamicModel.model_validate(data)
+    return model_instance.model_dump(by_alias=True)
+
+
+def get_schema_field_names(schema: Dict[str, Any]) -> List[str]:
+    """Get list of field names from a schema."""
+    return list(schema.get("properties", {}).keys())
+
+
+def get_required_fields(schema: Dict[str, Any]) -> List[str]:
+    """Get list of required fields from a schema."""
+    return schema.get("required", [])
+
+
+def is_valid_json_schema(schema: Dict[str, Any]) -> bool:
+    """Check if a dictionary is a valid JSON schema object."""
+    return (
+        isinstance(schema, dict) and 
+        schema.get("type") == "object" and 
+        "properties" in schema
+    )
+
+
+def _snake_to_pascal(snake_str: str) -> str:
+    """Convert snake_case to PascalCase."""
+    return "".join(word.capitalize() for word in snake_str.replace(".", "_").split("_"))

soorma_core-0.3.0.dist-info/METADATA

@@ -0,0 +1,454 @@
+Metadata-Version: 2.4
+Name: soorma-core
+Version: 0.3.0
+Summary: The Open Source Foundation for AI Agents. Powered by the DisCo (Distributed Cognition) architecture.
+License: MIT
+License-File: LICENSE.txt
+Keywords: ai,agents,disco,distributed-systems,llm,orchestration
+Author: Soorma AI
+Author-email: founders@soorma.ai
+Requires-Python: >=3.11,<4.0
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Dist: httpx (>=0.26.0)
+Requires-Dist: pydantic (>=2.0.0,<3.0.0)
+Requires-Dist: rich (>=10.11.0)
+Requires-Dist: soorma-common (>=0.3.0,<0.4.0)
+Requires-Dist: typer (>=0.13.0)
+Project-URL: Homepage, https://soorma.ai
+Project-URL: Repository, https://github.com/soorma-ai/soorma-core
+Description-Content-Type: text/markdown
+
+# Soorma Core
+
+**The Open Source Foundation for AI Agents.**
+
+Soorma is an agentic infrastructure platform based on the **DisCo (Distributed Cognition)** architecture. It provides a standardized **Control Plane** (Gateway, Registry, Event Bus, State Tracker, Memory) for building production-grade multi-agent systems.
+
+## 🚧 Status: Pre-Alpha
+
+We are currently building the core runtime. This package provides early access to the SDK and CLI.
+
+**Join the waitlist:** [soorma.ai](https://soorma.ai)
+
+## Prerequisites
+
+- **Python 3.11+** is required.
+
+## Quick Start
+
+> **Note:** Docker images are not yet published. You must clone the repo and build locally.
+
+### 1. Clone Repository and Build Infrastructure
+
+```bash
+# Clone the repository (needed for Docker images)
+git clone https://github.com/soorma-ai/soorma-core.git
+cd soorma-core
+
+# Create and activate virtual environment
+python -m venv .venv
+source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+
+# Install the SDK from PyPI
+pip install soorma-core
+
+# Build infrastructure containers (required first time)
+soorma dev --build
+```
+
+> 💡 **Alternative:** To install SDK from local source (for development/customization):
+> ```bash
+> pip install -e sdk/python
+> ```
+
+### 2. Run the Hello World Example
+
+```bash
+# Start infrastructure
+soorma dev --infra-only
+
+# In separate terminals:
+python examples/hello-world/planner_agent.py
+python examples/hello-world/worker_agent.py
+python examples/hello-world/tool_agent.py
+python examples/hello-world/client.py
+```
+
+### 3. Create a New Agent Project
+
+```bash
+# Create a Worker agent (default)
+soorma init my-worker
+
+# Create a Planner agent (goal decomposition)
+soorma init my-planner --type planner
+
+# Create a Tool service (stateless operations)
+soorma init my-tool --type tool
+
+cd my-worker
+python -m venv .venv
+source .venv/bin/activate
+pip install -e ".[dev]"
+```
+
+### Start Local Development
+
+```bash
+# Start infrastructure and run your agent (auto-detects agent in current directory)
+soorma dev
+```
+
+Or run infrastructure separately:
+
+```bash
+# Start only infrastructure
+soorma dev --infra-only
+
+# In another terminal, run your agent manually
+python -m my_worker.agent
+```
+
+### Deploy to Soorma Cloud
+
+```bash
+soorma deploy  # Coming soon!
+```
+
+## The DisCo "Trinity"
+
+Soorma implements the **DisCo (Distributed Cognition)** architecture with three domain service types:
+
+| Type | Class | Purpose | Example Use Cases |
+|------|-------|---------|-------------------|
+| **Planner** | `Planner` | Strategic reasoning, goal decomposition | Research planning, workflow orchestration |
+| **Worker** | `Worker` | Domain-specific task execution | Data processing, analysis, content generation |
+| **Tool** | `Tool` | Atomic, stateless operations | API calls, calculations, file parsing |
+
+### Planner Agent
+
+Planners are the "brain" - they receive high-level goals and decompose them into tasks:
+
+```python
+from soorma import Planner, PlatformContext
+from soorma.agents.planner import Goal, Plan, Task
+
+planner = Planner(
+    name="research-planner",
+    description="Plans research workflows",
+    capabilities=["research_planning"],
+)
+
+@planner.on_goal("research.goal")
+async def plan_research(goal: Goal, context: PlatformContext) -> Plan:
+    # Discover available workers
+    workers = await context.registry.find_all("paper_search")
+    
+    # Decompose goal into tasks
+    return Plan(
+        goal=goal,
+        tasks=[
+            Task(name="search", assigned_to="paper_search", data=goal.data),
+            Task(name="summarize", assigned_to="summarizer", depends_on=["search"]),
+        ],
+    )
+
+planner.run()
+```
+
+### Worker Agent
+
+Workers are the "hands" - they execute domain-specific cognitive tasks:
+
+```python
+from soorma import Worker, PlatformContext
+from soorma.agents.worker import TaskContext
+
+worker = Worker(
+    name="research-worker",
+    description="Searches and analyzes papers",
+    capabilities=["paper_search", "citation_analysis"],
+)
+
+@worker.on_task("paper_search")
+async def search_papers(task: TaskContext, context: PlatformContext):
+    # Report progress
+    await task.report_progress(0.5, "Searching...")
+    
+    # Access shared memory
+    prefs = await context.memory.retrieve(f"user:{task.session_id}:prefs")
+    
+    # Your task logic
+    results = await search_academic_papers(task.data["query"], prefs)
+    
+    # Store for downstream workers
+    await context.memory.store(f"results:{task.task_id}", results)
+    
+    return {"papers": results, "count": len(results)}
+
+worker.run()
+```
+
+### Tool Service
+
+Tools are the "utilities" - stateless, deterministic operations:
+
+```python
+from soorma import Tool, PlatformContext
+from soorma.agents.tool import ToolRequest
+
+tool = Tool(
+    name="calculator",
+    description="Performs calculations",
+    capabilities=["arithmetic", "unit_conversion"],
+)
+
+@tool.on_invoke("calculate")
+async def calculate(request: ToolRequest, context: PlatformContext):
+    expression = request.data["expression"]
+    result = safe_eval(expression)
+    return {"result": result, "expression": expression}
+
+tool.run()
+```
+
+## Platform Context
+
+Every handler receives a `PlatformContext` that provides access to all platform services:
+
+```python
+@worker.on_task("my_task")
+async def handler(task: TaskContext, context: PlatformContext):
+    # Service Discovery
+    tool = await context.registry.find("calculator")
+    
+    # Shared Memory
+    data = await context.memory.retrieve(f"cache:{task.data['key']}")
+    await context.memory.store("result:123", {"value": 42})
+    
+    # Event Publishing
+    await context.bus.publish("task.completed", {"result": "done"})
+    
+    # Progress Tracking (automatic for workers, manual available)
+    await context.tracker.emit_progress(
+        plan_id=task.plan_id,
+        task_id=task.task_id,
+        status="running",
+        progress=0.75,
+    )
+```
+
+| Service | Purpose | Methods |
+|---------|---------|---------|
+| `context.registry` | Service Discovery | `find()`, `register()`, `query_schemas()` |
+| `context.memory` | Distributed State | `retrieve()`, `store()`, `search()` |
+| `context.bus` | Event Choreography | `publish()`, `subscribe()`, `request()` |
+| `context.tracker` | Observability | `start_plan()`, `emit_progress()`, `complete_task()` |
+
+## Advanced Usage
+
+### Structured Agent Registration
+
+For simple agents, you can pass a list of strings as capabilities. For more control, use `AgentCapability` objects to define schemas and descriptions.
+
+```python
+from soorma import Agent, Context
+from soorma.models import AgentCapability
+
+async def main(context: Context):
+    # Define structured capabilities
+    capabilities = [
+        AgentCapability(
+            name="analyze_sentiment",
+            description="Analyzes the sentiment of a given text",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "text": {"type": "string", "description": "Text to analyze"}
+                },
+                "required": ["text"]
+            },
+            output_schema={
+                "type": "object",
+                "properties": {
+                    "score": {"type": "number", "description": "Sentiment score (-1 to 1)"}
+                }
+            }
+        )
+    ]
+
+    # Register with structured capabilities
+    await context.register(
+        name="sentiment-analyzer",
+        capabilities=capabilities
+    )
+
+    # ... rest of agent logic
+```
+
+### Event Registration
+
+You can register custom event schemas that your agent produces or consumes.
+
+```python
+from soorma.models import EventDefinition
+
+async def main(context: Context):
+    # Register a custom event schema
+    await context.registry.register_event(
+        EventDefinition(
+            event_type="analysis.completed",
+            description="Emitted when text analysis is complete",
+            schema={
+                "type": "object",
+                "properties": {
+                    "text_id": {"type": "string"},
+                    "result": {"type": "object"}
+                },
+                "required": ["text_id", "result"]
+            }
+        )
+    )
+```
+
+### AI Integration
+
+The SDK provides specialized tools for AI agents (like LLMs) to interact with the system dynamically.
+
+#### AI Event Toolkit
+
+The `EventToolkit` allows agents to discover events and generate valid payloads without hardcoded DTOs.
+
+```python
+from soorma.ai.event_toolkit import EventToolkit
+
+async with EventToolkit() as toolkit:
+    # 1. Discover events
+    events = await toolkit.discover_events(topic="action-requests")
+    
+    # 2. Get detailed info
+    info = await toolkit.get_event_info("web.search.request")
+    
+    # 3. Create validated payload (handles schema validation)
+    payload = await toolkit.create_payload(
+        "web.search.request",
+        {"query": "AI trends 2025"}
+    )
+```
+
+#### OpenAI Function Calling
+
+You can expose Registry capabilities directly to OpenAI-compatible LLMs using `get_tool_definitions()`.
+
+```python
+from soorma.ai.tools import get_tool_definitions, execute_ai_tool
+import openai
+
+# 1. Get tool definitions
+tools = get_tool_definitions()
+
+# 2. Call LLM
+response = await openai.ChatCompletion.create(
+    model="gpt-4",
+    messages=[{"role": "user", "content": "Find events related to search"}],
+    tools=tools
+)
+
+# 3. Execute tool calls
+tool_call = response.choices[0].message.tool_calls[0]
+result = await execute_ai_tool(
+    tool_call.function.name,
+    json.loads(tool_call.function.arguments)
+)
+```
+
+## CLI Commands
+
+> **First-time setup:** Run `soorma dev --build --infra-only` to build Docker images before using other commands.
+
+| Command | Description |
+|---------|-------------|
+| `soorma init <name>` | Scaffold a new agent project |
+| `soorma init <name> --type planner` | Create a Planner agent |
+| `soorma init <name> --type worker` | Create a Worker agent (default) |
+| `soorma init <name> --type tool` | Create a Tool service |
+| `soorma dev` | Start infra + run agent with hot reload |
+| `soorma dev --build` | Build service images from source first |
+| `soorma dev --build --infra-only` | Build images without running agent (first-time setup) |
+| `soorma dev --infra-only` | Start infra without running agent |
+| `soorma dev --stop` | Stop the development stack |
+| `soorma dev --status` | Show stack status |
+| `soorma dev --logs` | View infrastructure logs |
+| `soorma deploy` | Deploy to Soorma Cloud (coming soon) |
+| `soorma version` | Show CLI version |
+
+## How `soorma dev` Works
+
+The CLI implements an **"Infra in Docker, Code on Host"** pattern for optimal DX:
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    Your Machine                             │
+├─────────────────────────────────────────────────────────────┤
+│  Docker Containers (Infrastructure)                         │
+│  ┌──────────┐  ┌──────────┐  ┌───────────────┐              │
+│  │ Registry │  │   NATS   │  │ Event Service │              │
+│  │  :8081   │  │  :4222   │  │    :8082      │              │
+│  └──────────┘  └──────────┘  └───────────────┘              │
+│        ▲            ▲               ▲                       │
+│        └────── localhost ───────────┘                       │
+│                     ▲                                       │
+│  ┌──────────────────┴──────────────────┐                    │
+│  │    Native Python (Your Agent)       │                    │
+│  │  • Hot reload on file change        │                    │
+│  │  • Full debugger support            │                    │
+│  │  • Auto-connects to Event Service   │                    │
+│  └─────────────────────────────────────┘                    │
+└─────────────────────────────────────────────────────────────┘
+```
+
+**Benefits:**
+- ⚡ **Fast iteration** - No docker build cycle, instant reload
+- 🔍 **Debuggable** - Attach VS Code/PyCharm debugger
+- 🎯 **Production parity** - Same infrastructure as prod
+
+## Event-Driven Architecture
+
+Unlike single-threaded agent loops, Soorma enables **Autonomous Choreography** via events:
+
+```
+Client                Planner              Worker              Tool
+  │                     │                    │                   │
+  │  goal.submitted     │                    │                   │
+  │────────────────────>│                    │                   │
+  │                     │  action.request    │                   │
+  │                     │───────────────────>│                   │
+  │                     │                    │  tool.request     │
+  │                     │                    │──────────────────>│
+  │                     │                    │  tool.response    │
+  │                     │                    │<──────────────────│
+  │                     │  action.result     │                   │
+  │                     │<───────────────────│                   │
+  │  goal.completed     │                    │                   │
+  │<────────────────────│                    │                   │
+```
+
+## Roadmap
+
+* [x] **v0.1.0**: Core SDK & CLI (`soorma init`, `soorma dev`)
+* [x] **v0.1.1**: Event Service & DisCo Trinity (Planner, Worker, Tool)
+* [x] **v0.2.0**: Subscriber Groups & Unified Versioning
+* [ ] **v0.3.0**: Memory Service & State Tracker
+* [ ] **v1.0.0**: Enterprise GA
+
+## License
+
+MIT

soorma_core-0.3.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+soorma/__init__.py,sha256=uJOnSx0HA_LVzNL2Xh20aU39CPqPDbEZE3vbbNZs9yE,3822
+soorma/agents/__init__.py,sha256=wG-kw7_CABdvSwRnt23xJiPfa-XFndofebk2jAO_Qh0,568
+soorma/agents/base.py,sha256=ZvAy1TV7fMS3RC7XNFqdgSbnYQ_Guk4chiHrlq8qIbE,17629
+soorma/agents/planner.py,sha256=l_1IGoX_Rq45YCAlc-bApJgtRLEQXc1W6_L6IyVBvbY,12378
+soorma/agents/tool.py,sha256=36662wVahv3xU2SMzytlY1zQ6lK-Q-XT3OwaXIbggLY,12042
+soorma/agents/worker.py,sha256=C3DiqJrA25ZQMToRP5sa15K0LU7Vy_v_YtOwQeGgMJE,12473
+soorma/ai/event_toolkit.py,sha256=DYTjacpsspc7-DEhx4_wqlv-_src3uKuKFrA6BQPmOE,9841
+soorma/ai/tools.py,sha256=M2V-mW2-VN9EC-C8ExPY1_mj3wsVn5Zn6i8iy0PhDuk,10524
+soorma/cli/__init__.py,sha256=hOZIt11jO7S0a0oaMnjqac1ImW6N-WlqroCRZogHQ9w,110
+soorma/cli/commands/__init__.py,sha256=LBGQrRtXXHuH-AJTls2ixSPdKvdniPdklE5Kg9RCQ_I,29
+soorma/cli/commands/dev.py,sha256=IveJ_mdwZd5-CHS0XyyIGoHydrrvB7GWVKMgBS-vf50,26261
+soorma/cli/commands/init.py,sha256=CYcs6Xp9eD33jtdqaeo2eGnHBPBjfVG-iphK916nqBc,18246
+soorma/cli/main.py,sha256=T8Iby9dI8qXE-rQWMCRM9jSi0tZ1TyHTM2NamMGZlSA,1192
+soorma/context.py,sha256=5XyweaidTeA-HbXERUp0MVjqLl8Diyani7l3I6V2G4U,27549
+soorma/events.py,sha256=pfJEYoBbrt0AnrzJHlkw7Aeim5M6ozfADmDsPI3MMWs,17838
+soorma/models.py,sha256=tL7y35RFAc68y2RC39otVZSYLRhKLD-vtBLM5oqG-b4,475
+soorma/registry/client.py,sha256=XVPtoY31oqM-a47_6FpmoWF-D4CQ6llPHtGums4IQWk,5846
+soorma/utils/schema_utils.py,sha256=87CKf8k6Wxaoqn31Soio9HMKqrV7QvTKAk7kbK9rITc,6696
+soorma_core-0.3.0.dist-info/METADATA,sha256=nocKehjMb4oymU5CNW07QQ8LiPwSeMzlKCReyE9AqnM,15678
+soorma_core-0.3.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+soorma_core-0.3.0.dist-info/entry_points.txt,sha256=dS70Bhj_cKGGZssAqp9cYDeq0xUPisUPOQ_x4pLrlb8,47
+soorma_core-0.3.0.dist-info/licenses/LICENSE.txt,sha256=I770PdJI7JQBfJbPw5UpEzBLIMys-xDM7xO0P_ZZG0Y,1066
+soorma_core-0.3.0.dist-info/RECORD,,

soorma_core-0.3.0.dist-info/WHEEL

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

soorma_core-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+soorma=soorma.cli.main:main
+