Metadata-Version: 2.4
Name: eaglis
Version: 0.0.1.post0
Summary: Aggregated Communication Protocols Library
Author: Maintainers
Author-email: solubrew@solutionsbrewer.com
License: MIT
Platform: Linux
Requires-Python: >=3.7
Requires-Dist: backoff==2.2.1
Requires-Dist: click==8.3.3
Requires-Dist: memory-profiler==0.61.0
Requires-Dist: pika==1.4.0
Requires-Dist: psutil==7.2.2
Requires-Dist: pyzmq==27.1.0
Requires-Dist: six==1.17.0
Requires-Dist: uuid7==0.1.0
Requires-Dist: zmq==0.0.0
Requires-Dist: zeroconf==0.147.3
Requires-Dist: python-telegram-bot>=22,<23
Description: # OGMA
        
        Enhanced logging and messaging framework with rich console support and distributed message bus capabilities.
        
        ## Overview
        
        OGMA provides:
        - **Advanced logging capabilities** with optional rich terminal output
        - **Distributed message bus** using ZMQ for inter-process communication
        - **Subagent management** for spawning and managing background workers
        - **Channel-based messaging** for publish/subscribe patterns
        - **RPC support** for request/response communication
        - **Service discovery** for finding and connecting to agents
        
        ## Current Status
        
        - **State**: Active
        - **Version**: 0.0.1.0.1.2
        - **License**: MIT
        
        ## Key Features
        
        ### Logging (`kahndor.logma`)
        - Extended `logging.Logger` class with convenience methods
        - Rich console output (colorized, tables, markup)
        - JSON/YAML output helpers
        - Process timing and tracking
        - Diff utilities for dicts and strings
        
        ### Message Bus (`ogma.channels`, `ogma.protocols`)
        - ZMQ-based publish/subscribe channels
        - Request/response messaging
        - Dealer/router patterns for subagent communication
        - Peer-to-peer messaging support
        
        ### Subagent System (`ogma.subagent`)
        - Spawn and manage background workers
        - Subagent bus for task distribution
        - Worker pool management
        - Task timeout and retry handling
        
        ### RPC (`ogma.rpc`)
        - Remote procedure call support
        - Timeout and retry mechanisms
        - Automatic serialization
        
        ### Discovery (`ogma.discovery`)
        - Agent discovery across the network
        - Broadcast-based discovery
        - Automatic service registration
        
        ### Monitoring (`ogma.monitor`)
        - Health monitoring
        - Heartbeat system
        - Performance metrics
        
        ## Installation
        
        ```bash
        pip install ogma
        ```
        
        ## Usage
        
        ### Basic Logging
        
        ```python
        from kahndor.logma import Logma
        
        log = Logma("myapp")
        log.info("Hello world")
        
        # Rich console
        log.rich_enable()
        log.rich_print("Colored message", style="info")
        log.rich_table("Title", ["Col1", "Col2"], [["a", "b"]])
        ```
        
        ### Message Bus
        
        ```python
        from ogma.comms.channels import Channel
        import time
        
        # Create and use channels
        pub = Channel.create_publisher("test_channel")
        sub = Channel.create_subscriber("test_channel")
        
        # Publisher sends messages
        pub.publish("Hello, world!")
        
        # Subscriber receives messages
        message = sub.receive(timeout=1.0)
        print(f"Received: {message}")
        ```
        
        ### Subagent Management
        
        ```python
        from ogma.comms.subagent import SubagentBus
        
        # Create subagent bus
        bus = SubagentBus()
        
        # Spawn a subagent
        subagent_id = bus.spawn_subagent(
            task="Analyze this data",
            timeout=300
        )
        
        # Wait for completion
        result = bus.wait_for_completion(subagent_id)
        print(f"Result: {result}")
        ```
        
        ### RPC
        
        ```python
        from ogma.protocols.rpc import RPCClient
        
        client = RPCClient("localhost", port=5556)
        result = client.call("method_name", {"param": "value"})
        ```
        
        ### Discovery
        
        ```python
        from ogma.discovery import DiscoveryService
        
        discovery = DiscoveryService()
        agents = discovery.discover_agents()
        print(f"Found {len(agents)} agents")
        ```
        
        ## Configuration
        
        Create an `ogma_config.yaml` file in your project root:
        
        ```yaml
        logging:
          level: INFO
        
        channels:
          max_message_size: 10485760
          message_ttl: 60
        
        subagent:
          max_workers: 10
          worker_timeout: 300
        ```
        
        ## CLI
        
        ```bash
        # List channels
        ogma channel list
        
        # Start subagent
        ogma subagent start "Task description"
        
        # Discover agents
        ogma discover
        
        # Monitor channel
        ogma monitor --channel my_channel
        ```
        
        ## Architecture
        
        ```
        ┌─────────────────────────────────────┐
        │           Application               │
        └──────────────┬──────────────────────┘
                       │
               ┌───────┴───────┐
               │     OGMA      │
               │  (Framework)  │
               └───────┬───────┘
                       │
           ┌───────────┼───────────┐
           │           │           │
        ┌──┴──┐    ┌───┴───┐   ┌───┴───┐
        │ RPC │    │ Bus   │   │Logger │
        └─────┘    └───────┘   └───────┘
        ```
        
        ## Dependencies
        
        ### Core
        - `zmq` - ZeroMQ for messaging
        - `backoff` - Retry logic
        - `click` - CLI framework
        - `uuid7` - UUID generation
        
        ### Optional
        - `rich` - Rich console output
        - `memory_profiler` - Memory profiling
        
        ## Development
        
        ### Running Tests
        
        ```bash
        pytest tests/
        ```
        
        ### Code Quality
        
        ```bash
        # Linting
        pylint ogma/
        ruff check ogma/
        
        # Type checking
        pyright ogma/
        
        # Formatting
        black ogma/
        isort ogma/
        ```
        
        ## Contributing
        
        1. Fork the repository
        2. Create a feature branch
        3. Make your changes
        4. Run tests and linting
        5. Submit a pull request
        
        ## License
        
        MIT License - see [LICENSE](LICENSE.md) file for details.
        
        ## Support
        
        - GitHub Issues: https://github.com/solutionsbrewer/ogma/issues
        - Documentation: [CLI.md](CLI.md)
Description-Content-Type: text/markdown
