"""
Pattern 38: Society Pattern
Complete social system with agents playing various societal roles.
"""

from typing import Dict, Any, List, Set
from dataclasses import dataclass, field
from datetime import datetime
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI


@dataclass
class SocietalRole:
    """A role in society."""
    name: str
    responsibilities: List[str]
    authority_level: int  # 1-10


@dataclass
class Citizen:
    """A member of society."""
    name: str
    role: SocietalRole
    skills: List[str]
    relationships: Set[str] = field(default_factory=set)
    contribution_score: float = 0.0


class SocietyPattern:
    """
    Society Pattern: A complete social system where agents fulfill 
    different roles and interact according to social norms.
    """
    
    def __init__(self, name: str = "AgentSociety", model_name: str = "gpt-4"):
        self.name = name
        self.llm = ChatOpenAI(model=model_name, temperature=0.7)
        self.citizens: Dict[str, Citizen] = {}
        self.roles: Dict[str, SocietalRole] = {}
        self.institutions: List[str] = []
        self.social_norms: List[str] = []
        self.events: List[Dict[str, Any]] = []
    
    def establish_role(self, role: SocietalRole):
        """Establish a societal role."""
        self.roles[role.name] = role
        print(f"👔 Role established: {role.name}")
    
    def add_citizen(self, citizen: Citizen):
        """Add a citizen to society."""
        self.citizens[citizen.name] = citizen
        print(f"👤 Citizen joined: {citizen.name} as {citizen.role.name}")
    
    def establish_institution(self, name: str):
        """Create a social institution."""
        self.institutions.append(name)
        print(f"🏛️ Institution: {name}")
    
    def add_social_norm(self, norm: str):
        """Add a social norm."""
        self.social_norms.append(norm)
        print(f"📜 Norm: {norm}")
    
    def simulate_interaction(self, citizen1_name: str, citizen2_name: str, context: str) -> str:
        """Simulate social interaction."""
        c1 = self.citizens[citizen1_name]
        c2 = self.citizens[citizen2_name]
        
        prompt = ChatPromptTemplate.from_messages([
            ("system", f"""You are simulating a society called {self.name}.
Social norms: {self.social_norms}

{c1.name} (Role: {c1.role.name})
{c2.name} (Role: {c2.role.name})"""),
            ("human", "Context: {context}\n\nDescribe their interaction:")
        ])
        
        chain = prompt | self.llm
        response = chain.invoke({"context": context})
        
        # Update relationships
        c1.relationships.add(c2.name)
        c2.relationships.add(c1.name)
        
        # Record event
        self.events.append({
            "type": "interaction",
            "participants": [c1.name, c2.name],
            "context": context,
            "timestamp": datetime.now()
        })
        
        return str(response.content)
    
    def run(self, scenario: str) -> Dict[str, Any]:
        """Run a societal scenario."""
        print(f"\n🌍 Scenario: {scenario}")
        
        # Simulate how society responds
        prompt = ChatPromptTemplate.from_messages([
            ("system", f"""Society: {self.name}
Citizens: {len(self.citizens)}
Roles: {list(self.roles.keys())}
Institutions: {self.institutions}
Norms: {self.social_norms}"""),
            ("human", "Scenario: {scenario}\n\nHow does society respond?")
        ])
        
        chain = prompt | self.llm
        response = chain.invoke({"scenario": scenario})
        
        return {
            "society": self.name,
            "citizens": len(self.citizens),
            "institutions": len(self.institutions),
            "social_norms": len(self.social_norms),
            "events": len(self.events),
            "response": str(response.content)
        }


# Example usage
if __name__ == "__main__":
    print("\n=== Society Pattern Example ===")
    
    society = SocietyPattern("TechCity")
    
    # Establish roles
    society.establish_role(SocietalRole("Mayor", ["govern", "make decisions"], 10))
    society.establish_role(SocietalRole("Engineer", ["build", "maintain"], 5))
    society.establish_role(SocietalRole("Teacher", ["educate", "guide"], 6))
    
    # Add citizens
    society.add_citizen(Citizen("Alice", society.roles["Mayor"], ["leadership", "policy"]))
    society.add_citizen(Citizen("Bob", society.roles["Engineer"], ["coding", "design"]))
    society.add_citizen(Citizen("Carol", society.roles["Teacher"], ["teaching", "mentoring"]))
    
    # Institutions
    society.establish_institution("City Hall")
    society.establish_institution("Tech School")
    
    # Norms
    society.add_social_norm("Respect others")
    society.add_social_norm("Contribute to community")
    
    result = society.run("A new technology project needs community approval")
    
    print("\n=== Results ===")
    print(f"Society: {result['society']}")
    print(f"Citizens: {result['citizens']}")
    print(f"Response:\n{result['response']}")

    

Agentic Architecture Pattern: Society

Pattern 38: 38 Society – Line-by-Line Explanation

Overview

Pattern 38: Society Pattern Complete social system with agents playing various societal roles.

Code Structure Analysis

File Information

• Pattern Number: 38
• Pattern Name: 38 Society
• File Path: patterns\organizational\38_society.py
• Total Lines: 154

Detailed Code Explanation

Module Docstring

"""
Pattern 38: Society Pattern
Complete social system with agents playing various societal roles.
"""

Explanation: This module docstring describes the purpose and key features of the 38 Society pattern.

Imports Section

from typing import Dict, Any, List, Set
from dataclasses import dataclass, field
from datetime import datetime
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI  # First 20 imports shown

Explanation: The module imports necessary dependencies: – from typing import Dict, Any, List, Set: Type hints for better code documentation – from dataclasses import dataclass, field: Data class decorators for clean data structures – from datetime import datetime: Date and time utilities – from langchain_core.prompts import ChatPromptTemplate: LangChain framework integration – from langchain_openai import ChatOpenAI: LangChain framework integration

Classes

SocietalRole (Line 14)

Description: A role in society.

Citizen (Line 22)

Description: A member of society.

SocietyPattern (Line 31)

Description: Society Pattern: A complete social system where agents fulfill different roles and interact according to social norms.

Methods:

__init__ (Line 37)

def __init__(self, name, model_name):
    """No method docstring."""

Purpose: No method docstring.

Parameters: – self: Instance reference – name: Identifier or label – model_name: LLM model to use (e.g., “gpt-4”)

establish_role (Line 46)

def establish_role(self, role):
    """Establish a societal role."""

Purpose: Establish a societal role.

Parameters: – self: Instance reference – role: Parameter for role

add_citizen (Line 51)

def add_citizen(self, citizen):
    """Add a citizen to society."""

Purpose: Add a citizen to society.

Parameters: – self: Instance reference – citizen: Parameter for citizen

establish_institution (Line 56)

def establish_institution(self, name):
    """Create a social institution."""

Purpose: Create a social institution.

Parameters: – self: Instance reference – name: Identifier or label

add_social_norm (Line 61)

def add_social_norm(self, norm):
    """Add a social norm."""

Purpose: Add a social norm.

Parameters: – self: Instance reference – norm: Parameter for norm

simulate_interaction (Line 66)

def simulate_interaction(self, citizen1_name, citizen2_name, context):
    """Simulate social interaction."""

Purpose: Simulate social interaction.

Parameters: – self: Instance reference – citizen1_name: Parameter for citizen1_name – citizen2_name: Parameter for citizen2_name – context: Parameter for context

run (Line 97)

def run(self, scenario):
    """Run a societal scenario."""

Purpose: Run a societal scenario.

Parameters: – self: Instance reference – scenario: Parameter for scenario

Design Patterns Used

• Strategy Pattern: Different execution strategies for various scenarios
• State Pattern: Managing different states in the workflow
• Chain of Responsibility: Sequential processing through workflow nodes
• Observer Pattern: Tracking and monitoring pattern execution
• Factory Pattern: Creating instances with proper configuration

Usage Example

# Initialize the pattern
pattern = SocietalRole(name="example", model_name="gpt-4")

# Configure and execute
result = pattern.execute(data={"key": "value"})

# Check results
print(result)

Key Concepts

• LLM Integration: Uses LangChain/OpenAI for intelligent decision-making
• Workflow Orchestration: LangGraph manages execution flow through nodes
• State Management: TypedDict defines workflow state structure
• Error Handling: Comprehensive error handling and fallback mechanisms
• Extensibility: Designed for easy customization and extension

Extension Points

This pattern can be extended by: 1. Adding custom workflow nodes 2. Implementing additional validation logic 3. Integrating with external services 4. Customizing LLM prompts and responses 5. Adding monitoring and logging capabilities