PANO - Platform for Analysis and Network Operations

System Requirements

• Operating System: Windows or Linux
• Python 3.11+
• PySide6 for GUI
• Internet connection for online features

Custom Entities

Entities are the core data structures in PANO. Each entity represents a piece of information with specific properties and behaviors. To create a custom entity:

1. Create a new file in the entities folder (e.g., entities/phone_number.py)
2. Implement your entity class:

from dataclasses import dataclass
from typing import ClassVar, Dict, Any
from .base import Entity

@dataclass
class PhoneNumber(Entity):
    name: ClassVar[str] = "Phone Number"
    description: ClassVar[str] = "A phone number entity with country code and validation"
    
    def init_properties(self):
        """Initialize phone number properties"""
        self.setup_properties({
            "number": str,
            "country_code": str,
            "carrier": str,
            "type": str,  # mobile, landline, etc.
            "verified": bool
        })
    
    def update_label(self):
        """Update the display label"""
        self.label = self.format_label(["country_code", "number"])

Custom Transforms

Transforms are operations that process entities and generate new insights or relationships. To create a custom transform:

1. Create a new file in the transforms folder (e.g., transforms/phone_lookup.py)
2. Implement your transform class:

from dataclasses import dataclass
from typing import ClassVar, List
from .base import Transform
from entities.base import Entity
from entities.phone_number import PhoneNumber
from entities.location import Location
from ui.managers.status_manager import StatusManager

@dataclass
class PhoneLookup(Transform):
    name: ClassVar[str] = "Phone Number Lookup"
    description: ClassVar[str] = "Lookup phone number details and location"
    input_types: ClassVar[List[str]] = ["PhoneNumber"]
    output_types: ClassVar[List[str]] = ["Location"]
    
    async def run(self, entity: PhoneNumber, graph) -> List[Entity]:
        if not isinstance(entity, PhoneNumber):
            return []
            
        status = StatusManager.get()
        operation_id = status.start_loading("Phone Lookup")
        
        try:
            # Your phone number lookup logic here
            # Example: query an API for phone number details
            location = Location(properties={
                "country": "Example Country",
                "region": "Example Region",
                "carrier": "Example Carrier",
                "source": "PhoneLookup transform"
            })
            
            return [location]
            
        except Exception as e:
            status.set_text(f"Error during phone lookup: {str(e)}")
            return []
            
        finally:
            status.stop_loading(operation_id)

Custom Helpers

Helpers are specialized tools that provide additional investigation capabilities through a dedicated UI interface. To create a custom helper:

1. Create a new file in the helpers folder (e.g., helpers/data_analyzer.py)
2. Implement your helper class:

from PySide6.QtWidgets import (
    QWidget, QVBoxLayout, QHBoxLayout, QPushButton,
    QTextEdit, QLabel, QComboBox
)
from .base import BaseHelper
from qasync import asyncSlot

class DummyHelper(BaseHelper):
    """A dummy helper for testing"""
    
    name = "Dummy Helper" 
    description = "A dummy helper for testing"
    
    def setup_ui(self):
        """Initialize the helper's user interface"""
        # Create input text area
        self.input_label = QLabel("Input:")
        self.input_text = QTextEdit()
        self.input_text.setPlaceholderText("Enter text to process...")
        self.input_text.setMinimumHeight(100)
        
        # Create operation selector
        operation_layout = QHBoxLayout()
        self.operation_label = QLabel("Operation:")
        self.operation_combo = QComboBox()
        self.operation_combo.addItems(["Uppercase", "Lowercase", "Title Case"])
        operation_layout.addWidget(self.operation_label)
        operation_layout.addWidget(self.operation_combo)
        
        # Create process button
        self.process_btn = QPushButton("Process")
        self.process_btn.clicked.connect(self.process_text)
        
        # Create output text area
        self.output_label = QLabel("Output:")
        self.output_text = QTextEdit()
        self.output_text.setReadOnly(True)
        self.output_text.setMinimumHeight(100)
        
        # Add widgets to main layout
        self.main_layout.addWidget(self.input_label)
        self.main_layout.addWidget(self.input_text)
        self.main_layout.addLayout(operation_layout)
        self.main_layout.addWidget(self.process_btn)
        self.main_layout.addWidget(self.output_label)
        self.main_layout.addWidget(self.output_text)
        
        # Set dialog size
        self.resize(400, 500)
        
    @asyncSlot()
    async def process_text(self):
        """Process the input text based on selected operation"""
        text = self.input_text.toPlainText()
        operation = self.operation_combo.currentText()
        
        if operation == "Uppercase":
            result = text.upper()
        elif operation == "Lowercase":
            result = text.lower()
        else:  # Title Case
            result = text.title()
            
        self.output_text.setPlainText(result)