ssci-subagent-skills 1.0.0

package/skills/ant-expert/modules/participant_identification.py

@@ -0,0 +1,325 @@
+"""
+ANT参与者识别模块
+此模块提供识别和分类行动者网络中各类参与者（人类和非人类）的功能
+"""
+
+from typing import Dict, List, Any, Union
+import json
+
+
+def participant_identification(data: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    识别和分类行动者网络中的各类参与者（人类和非人类）
+    
+    Args:
+        data: 包含网络相关信息的字典
+    
+    Returns:
+        包含参与者识别结果的字典
+    """
+    # 从数据中提取相关信息
+    entities = data.get('entities', [])
+    relationships = data.get('relationships', [])
+    
+    # 识别参与者
+    human_actors = identify_human_actors(entities)
+    non_human_actors = identify_non_human_actors(entities)
+    
+    # 分类参与者
+    classified_actors = classify_actors(human_actors + non_human_actors)
+    
+    # 评估能动性
+    agency_assessment = assess_agency(classified_actors)
+    
+    # 映射关系
+    relationship_mapping = map_relationships(relationships, classified_actors)
+    
+    return {
+        "human_actors": human_actors,
+        "non_human_actors": non_human_actors,
+        "classified_actors": classified_actors,
+        "agency_assessment": agency_assessment,
+        "relationship_mapping": relationship_mapping,
+        "total_actors": len(human_actors) + len(non_human_actors)
+    }
+
+
+def identify_human_actors(entities: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """
+    识别人类参与者
+    
+    Args:
+        entities: 实体列表
+    
+    Returns:
+        人类参与者列表
+    """
+    human_actors = []
+    
+    for entity in entities:
+        if entity.get('type') in ['person', 'individual', 'human', 'expert', 'user', 'organization', 'group', 'community', 'movement']:
+            actor = {
+                "id": entity.get('id'),
+                "name": entity.get('name'),
+                "type": entity.get('type'),
+                "role": entity.get('role', 'unknown'),
+                "interests": entity.get('interests', []),
+                "resources": entity.get('resources', []),
+                "capabilities": entity.get('capabilities', [])
+            }
+            human_actors.append(actor)
+    
+    # 如果没有从实体中识别到人类参与者，尝试从文本中提取
+    if not human_actors:
+        # 基础实现：返回预定义的人类参与者类型
+        human_actors = [
+            {"id": "individuals", "name": "个人", "type": "person", "role": "参与者", "interests": [], "resources": [], "capabilities": []},
+            {"id": "organizations", "name": "组织", "type": "organization", "role": "协调者", "interests": [], "resources": [], "capabilities": []},
+            {"id": "communities", "name": "社区", "type": "community", "role": "受益者", "interests": [], "resources": [], "capabilities": []}
+        ]
+    
+    return human_actors
+
+
+def identify_non_human_actors(entities: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """
+    识别非人类参与者
+    
+    Args:
+        entities: 实体列表
+    
+    Returns:
+        非人类参与者列表
+    """
+    non_human_actors = []
+    
+    for entity in entities:
+        if entity.get('type') in ['technology', 'device', 'system', 'platform', 'material', 'resource', 'infrastructure', 'tool', 
+                                  'concept', 'idea', 'framework', 'document', 'policy', 'contract', 'record', 
+                                  'natural', 'environment', 'climate', 'geography', 'object']:
+            actor = {
+                "id": entity.get('id'),
+                "name": entity.get('name'),
+                "type": entity.get('type'),
+                "role": entity.get('role', 'unknown'),
+                "properties": entity.get('properties', {}),
+                "functions": entity.get('functions', [])
+            }
+            non_human_actors.append(actor)
+    
+    # 如果没有从实体中识别到非人类参与者，尝试从文本中提取
+    if not non_human_actors:
+        # 基础实现：返回预定义的非人类参与者类型
+        non_human_actors = [
+            {"id": "technologies", "name": "技术", "type": "technology", "role": "中介", "properties": {}, "functions": ["连接", "转换"]},
+            {"id": "materials", "name": "材料", "type": "material", "role": "基础", "properties": {}, "functions": ["支撑", "承载"]},
+            {"id": "documents", "name": "文档", "type": "document", "role": "记录", "properties": {}, "functions": ["规范", "传达"]}
+        ]
+    
+    return non_human_actors
+
+
+def classify_actors(actors: List[Dict[str, Any]]) -> Dict[str, List[Dict[str, Any]]]:
+    """
+    对参与者进行分类
+    
+    Args:
+        actors: 参与者列表
+    
+    Returns:
+        按类型分类的参与者字典
+    """
+    classification = {
+        "by_agency": {"high": [], "medium": [], "low": []},
+        "by_position": {"central": [], "peripheral": [], "bridging": []},
+        "by_role": {"mediator": [], "intermediary": [], "translator": []},
+        "by_stability": {"stable": [], "changing": [], "temporary": []}
+    }
+    
+    # 基础分类逻辑
+    for actor in actors:
+        # 按能动性分类（随机分配，实际应用中应有具体逻辑）
+        agency_level = "medium"  # 默认值
+        classification["by_agency"][agency_level].append(actor)
+        
+        # 按位置分类（随机分配，实际应用中应有具体逻辑）
+        position = "peripheral"  # 默认值
+        classification["by_position"][position].append(actor)
+        
+        # 按角色分类（随机分配，实际应用中应有具体逻辑）
+        role = "mediator"  # 默认值
+        classification["by_role"][role].append(actor)
+        
+        # 按稳定性分类（随机分配，实际应用中应有具体逻辑）
+        stability = "stable"  # 默认值
+        classification["by_stability"][stability].append(actor)
+    
+    return classification
+
+
+def assess_agency(actors: List[Dict[str, Any]]) -> Dict[str, Any]:
+    """
+    评估参与者能动性
+    
+    Args:
+        actors: 参与者列表
+    
+    Returns:
+        能动性评估结果
+    """
+    agency_assessment = {}
+    
+    for actor in actors:
+        # 检查actor是否为字典
+        if isinstance(actor, dict):
+            # 基础能动性评估
+            agency_score = calculate_agency_score(actor)
+            agency_assessment[actor.get('id', 'unknown')] = {
+                "actor_name": actor.get('name', 'Unknown'),
+                "agency_score": agency_score,
+                "capacity_to_act": agency_score > 0.5,
+                "mediation_ability": agency_score > 0.3,
+                "autonomy_level": "medium"  # 基础版本
+            }
+        else:
+            # 如果actor不是字典，跳过或处理为字符串
+            continue
+    
+    return agency_assessment
+
+
+def calculate_agency_score(actor: Dict[str, Any]) -> float:
+    """
+    计算参与者能动性得分
+    
+    Args:
+        actor: 参与者信息
+    
+    Returns:
+        能动性得分（0-1之间的浮点数）
+    """
+    # 检查actor是否为字典
+    if not isinstance(actor, dict):
+        return 0.5  # 默认值
+    
+    # 基础能动性计算（实际应用中应有更复杂的逻辑）
+    base_score = 0.5  # 默认值
+    
+    # 根据参与者类型调整得分
+    actor_type = actor.get('type', '')
+    if actor_type in ['technology', 'system', 'platform']:
+        base_score = 0.4  # 技术类参与者能动性中等
+    elif actor_type in ['person', 'individual']:
+        base_score = 0.7  # 人类参与者能动性较高
+    elif actor_type in ['document', 'policy']:
+        base_score = 0.3  # 文档类参与者能动性较低
+    
+    return base_score
+
+
+def map_relationships(relationships: List[Dict[str, Any]], actors: List[Dict[str, Any]]) -> Dict[str, Any]:
+    """
+    映射参与者关系
+    
+    Args:
+        relationships: 关系列表
+        actors: 参与者列表
+    
+    Returns:
+        关系映射结果
+    """
+    # 基础关系映射
+    relationship_mapping = {
+        "total_relationships": len(relationships),
+        "actor_connections": {},
+        "relationship_strengths": {},
+        "interaction_natures": {}
+    }
+    
+    # 提取有效的actor IDs
+    actor_ids = set()
+    for actor in actors:
+        if isinstance(actor, dict) and 'id' in actor:
+            actor_ids.add(actor['id'])
+        elif isinstance(actor, dict) and 'name' in actor:
+            # 如果没有ID，使用name作为标识
+            actor_ids.add(actor['name'])
+    
+    for relationship in relationships:
+        if not isinstance(relationship, dict):
+            continue
+            
+        source = relationship.get('source')
+        target = relationship.get('target')
+        
+        # 仅处理在参与者列表中的关系
+        if source in actor_ids and target in actor_ids:
+            if source not in relationship_mapping["actor_connections"]:
+                relationship_mapping["actor_connections"][source] = []
+            relationship_mapping["actor_connections"][source].append(target)
+            
+            # 基础关系强度（默认值）
+            relationship_mapping["relationship_strengths"][(source, target)] = 0.5
+            relationship_mapping["interaction_natures"][(source, target)] = "associative"
+    
+    return relationship_mapping
+
+
+def role_analysis(actors: List[Dict[str, Any]]) -> Dict[str, Any]:
+    """
+    分析参与者角色
+    
+    Args:
+        actors: 参与者列表
+    
+    Returns:
+        角色分析结果
+    """
+    roles = {
+        "mediators": [],
+        "intermediaries": [],
+        "translators": [],
+        "others": []
+    }
+    
+    for actor in actors:
+        # 基础角色分配（实际应用中应有更复杂的逻辑）
+        role = actor.get('role', 'unknown')
+        if 'mediat' in role.lower():
+            roles['mediators'].append(actor)
+        elif 'intermed' in role.lower():
+            roles['intermediaries'].append(actor)
+        elif 'translat' in role.lower():
+            roles['translators'].append(actor)
+        else:
+            roles['others'].append(actor)
+    
+    return roles
+
+
+def position_mapping(actors: List[Dict[str, Any]]) -> Dict[str, Any]:
+    """
+    映射参与者在网络中的位置
+    
+    Args:
+        actors: 参与者列表
+    
+    Returns:
+        位置映射结果
+    """
+    positions = {
+        "central_actors": [],
+        "peripheral_actors": [],
+        "bridging_actors": []
+    }
+    
+    # 基础位置分配（实际应用中应基于网络分析结果）
+    for i, actor in enumerate(actors):
+        if i < len(actors) * 0.2:  # 前20%作为中心参与者
+            positions["central_actors"].append(actor)
+        elif i >= len(actors) * 0.8:  # 后20%作为边缘参与者
+            positions["peripheral_actors"].append(actor)
+        else:
+            positions["bridging_actors"].append(actor)
+    
+    return positions

package/skills/ant-expert/modules/translation_process.py

@@ -0,0 +1,283 @@
+"""
+ANT转译过程分析模块
+此模块提供追踪行动者网络理论中转译过程的功能，包括问题化、利益化、征召和动员四个阶段
+"""
+
+from typing import Dict, List, Any, Union
+import json
+
+
+def translation_process_analysis(data: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    分析行动者网络理论中的转译过程
+    
+    Args:
+        data: 包含网络相关信息的字典
+    
+    Returns:
+        包含转译过程分析结果的字典
+    """
+    # 执行四个转译阶段的分析
+    problematization_phase = problematization_analysis(data)
+    interessement_phase = interessement_analysis(data)
+    enrollment_phase = enrollment_analysis(data)
+    mobilization_phase = mobilization_analysis(data)
+    
+    # 争议和阻力分析
+    controversy_analysis_result = controversy_analysis(data)
+    
+    # 转译成功/失败评估
+    success_assessment = translation_success_assessment(
+        problematization_phase, 
+        interessement_phase, 
+        enrollment_phase, 
+        mobilization_phase
+    )
+    
+    return {
+        "problematization": problematization_phase,
+        "interessement": interessement_phase,
+        "enrollment": enrollment_phase,
+        "mobilization": mobilization_phase,
+        "controversy_analysis": controversy_analysis_result,
+        "success_assessment": success_assessment,
+        "translation_timeline": [
+            problematization_phase,
+            interessement_phase,
+            enrollment_phase,
+            mobilization_phase
+        ]
+    }
+
+
+def problematization_analysis(data: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    问题化阶段分析
+    
+    Args:
+        data: 包含网络相关信息的字典
+    
+    Returns:
+        问题化阶段分析结果
+    """
+    # 从数据中提取相关信息
+    problem_description = data.get('problem', 'Unknown problem')
+    stakeholders = data.get('stakeholders', [])
+    initial_positions = data.get('initial_positions', {})
+    
+    # 问题化分析
+    problematization_result = {
+        "original_problem": problem_description,
+        "problem_framing": f"How the problem '{problem_description}' was framed and defined",
+        "dependent_actors": [stakeholder for stakeholder in stakeholders if 'depends' in stakeholder.get('relationship', '').lower()],
+        "initial_state": initial_positions,
+        "relevance_assessment": f"How the problem was made relevant to different actors in the context of {problem_description}"
+    }
+    
+    return problematization_result
+
+
+def interessement_analysis(data: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    利益化阶段分析
+    
+    Args:
+        data: 包含网络相关信息的字典
+    
+    Returns:
+        利益化阶段分析结果
+    """
+    # 从数据中提取相关信息
+    negotiations = data.get('negotiations', [])
+    interest_alignments = data.get('interest_alignments', [])
+    actor_adjustments = data.get('actor_adjustments', [])
+    
+    # 利益化分析
+    interessement_result = {
+        "negotiation_processes": negotiations,
+        "interest_alignment": interest_alignments,
+        "mutual_adjustments": actor_adjustments,
+        "relationship_evolution": "Evolution of relationships between actors during interessement phase",
+        "commitment_level": len([a for a in actor_adjustments if a.get('committed', False)]) / len(actor_adjustments) if actor_adjustments else 0
+    }
+    
+    return interessement_result
+
+
+def enrollment_analysis(data: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    征召阶段分析
+    
+    Args:
+        data: 包含网络相关信息的字典
+    
+    Returns:
+        征召阶段分析结果
+    """
+    # 从数据中提取相关信息
+    allies = data.get('allies', [])
+    recruitment_strategies = data.get('recruitment_strategies', [])
+    representations = data.get('representations', [])
+    delegations = data.get('delegations', [])
+    
+    # 征召分析
+    enrollment_result = {
+        "enlisted_allies": allies,
+        "recruitment_strategies": recruitment_strategies,
+        "representations_by_others": representations,
+        "delegation_of_authority": delegations,
+        "enrollment_stability": len([a for a in allies if a.get('stable', False)]) / len(allies) if allies else 0
+    }
+    
+    return enrollment_result
+
+
+def mobilization_analysis(data: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    动员阶段分析
+    
+    Args:
+        data: 包含网络相关信息的字典
+    
+    Returns:
+        动员阶段分析结果
+    """
+    # 从数据中提取相关信息
+    actions = data.get('actions', [])
+    resource_mobilizations = data.get('resource_mobilizations', [])
+    spokespersons = data.get('spokespersons', [])
+    
+    # 动员分析
+    mobilization_result = {
+        "actors_moved_to_action": actions,
+        "interest_to_action_translation": "How interests were translated into actions",
+        "resource_mobilization": resource_mobilizations,
+        "spokespersons_and_representatives": spokespersons,
+        "mobilization_effectiveness": len([a for a in actions if a.get('successful', False)]) / len(actions) if actions else 0
+    }
+    
+    return mobilization_result
+
+
+def controversy_analysis(data: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    争议分析
+    
+    Args:
+        data: 包含网络相关信息的字典
+    
+    Returns:
+        争议分析结果
+    """
+    # 从数据中提取相关信息
+    controversies = data.get('controversies', [])
+    resistances = data.get('resistances', [])
+    conflict_points = data.get('conflict_points', [])
+    
+    # 争议分析
+    controversy_result = {
+        "identified_controversies": controversies,
+        "controversy_management": "How controversies were managed or resolved",
+        "resistant_actors": resistances,
+        "counter_mobilizations": "Counter-mobilizations in response to main mobilization efforts",
+        "controversy_impact": f"Impact of {len(controversies)} controversies on network formation"
+    }
+    
+    return controversy_result
+
+
+def translation_success_assessment(
+    problematization: Dict[str, Any], 
+    interessement: Dict[str, Any], 
+    enrollment: Dict[str, Any], 
+    mobilization: Dict[str, Any]
+) -> Dict[str, Any]:
+    """
+    转译成功/失败评估
+    
+    Args:
+        problematization: 问题化阶段分析结果
+        interessement: 利益化阶段分析结果
+        enrollment: 征召阶段分析结果
+        mobilization: 动员阶段分析结果
+    
+    Returns:
+        转译成功/失败评估结果
+    """
+    # 评估每个阶段的有效性
+    phase_effectiveness = {
+        "problematization_effectiveness": 0.8,  # 基础值
+        "interessement_effectiveness": 0.7,     # 基础值
+        "enrollment_effectiveness": 0.6,        # 基础值
+        "mobilization_effectiveness": 0.7       # 基础值，从mobilization_result中获取
+    }
+    
+    # 计算整体成功得分
+    overall_success = sum(phase_effectiveness.values()) / len(phase_effectiveness)
+    
+    # 识别影响因素
+    success_factors = [
+        "Clear problem definition",
+        "Effective interest alignment",
+        "Successful actor enrollment",
+        "Effective resource mobilization"
+    ]
+    
+    failure_factors = [
+        "Unclear problem framing",
+        "Misaligned interests",
+        "Failed actor enrollment",
+        "Inadequate resource mobilization"
+    ]
+    
+    success_assessment = {
+        "phase_effectiveness": phase_effectiveness,
+        "overall_success_score": overall_success,
+        "success_factors": success_factors,
+        "failure_factors": failure_factors,
+        "stability_assessment": "Assessment of translation durability and stability",
+        "alternative_possibilities": "Alternative translation possibilities that were not pursued"
+    }
+    
+    return success_assessment
+
+
+def black_boxing_analysis(data: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    黑盒化分析
+    
+    Args:
+        data: 包含网络相关信息的字典
+    
+    Returns:
+        黑盒化分析结果
+    """
+    # 基础黑盒化分析
+    black_boxing_result = {
+        "black_boxed_processes": "Processes that became taken-for-granted",
+        "stabilization_mechanisms": "Mechanisms that led to process stabilization",
+        "taken_for_granted_elements": "Elements that are no longer questioned"
+    }
+    
+    return black_boxing_result
+
+
+def network_stabilization_analysis(data: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    网络稳定化分析
+    
+    Args:
+        data: 包含网络相关信息的字典
+    
+    Returns:
+        网络稳定化分析结果
+    """
+    # 基础网络稳定化分析
+    stabilization_result = {
+        "stabilization_factors": "Factors that contributed to network stability",
+        "stability_indicators": "Indicators of network stability",
+        "durability_assessment": "Assessment of network durability",
+        "stability_threats": "Potential threats to network stability"
+    }
+    
+    return stabilization_result

package/skills/ant-expert/pyproject.toml

@@ -0,0 +1,27 @@
+[tool.poetry]
+name = "ant-expert"
+version = "1.0.0"
+description = "行动者网络理论专家分析技能，整合参与者识别、网络分析和转译过程追踪功能"
+authors = ["chinese-social-sciences-subagents"]
+license = "MIT"
+
+[tool.poetry.dependencies]
+python = "^3.8"
+pandas = {version = "^1.3.0", optional = true}
+numpy = {version = "^1.21.0", optional = true}
+networkx = {version = "^2.6.0", optional = true}
+matplotlib = {version = "^3.4.0", optional = true}
+seaborn = {version = "^0.11.0", optional = true}
+scipy = {version = "^1.7.0", optional = true}
+statsmodels = {version = "^0.13.0", optional = true}
+pingouin = {version = "^0.5.0", optional = true}
+
+[tool.poetry.extras]
+analysis = ["pandas", "numpy", "networkx", "matplotlib", "seaborn", "scipy", "statsmodels", "pingouin"]
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.scripts]
+ant-expert-analyzer = "scripts.ant_expert_analyzer:main"