# data_collector.py
from worldmonitor.collectors import NewsCollector, SocialMediaCollector

class DataCollector:
    """多源数据采集器"""
    
    def __init__(self, config):
        self.sources = {
            'news': NewsCollector(config['news_api']),
            'social': SocialMediaCollector(config['social_api']),
            'official': OfficialStatementCollector(config['gov_sources']),
            'research': ResearchPaperCollector(config['academic_db'])
        }
        self.preprocessing = DataPreprocessor()
    
    async def collect(self, keywords: list, timeframe: str) -> pd.DataFrame:
        """采集指定关键词和时间范围内的数据"""
        results = []
        
        for source_name, collector in self.sources.items():
            data = await collector.fetch(
                keywords=keywords,
                timeframe=timeframe
            )
            results.append(data)
        
        # 合并并预处理
        combined = pd.concat(results, ignore_index=True)
        return self.preprocessing.clean(combined)

# geopolitical_analyzer.py
from worldmonitor.nlp import EntityExtractor, RelationExtractor, SentimentAnalyzer

class GeopoliticalAnalyzer:
    """地缘政治 NLP 分析引擎"""
    
    def __init__(self, model_path: str):
        self.entity_extractor = EntityExtractor(model_path)
        self.relation_extractor = RelationExtractor(model_path)
        self.sentiment_analyzer = SentimentAnalyzer()
    
    def analyze(self, text: str) -> AnalysisResult:
        # 1. 命名实体识别
        entities = self.entity_extractor.extract(text)
        #   提取：国家(NORP)、组织(ORG)、人物(PERSON)、地点(LOC)
        
        # 2. 关系抽取
        relations = self.relation_extractor.extract(text, entities)
        #   提取：对抗(antagonist)、合作(cooperate)、制裁(sanction)
        
        # 3. 情感分析
        sentiment = self.sentiment_analyzer.analyze(text)
        #   输出：整体情感、实体情感、情感趋势
        
        # 4. 事件提取
        events = self.event_extractor.extract(text, relations)
        
        return AnalysisResult(
            entities=entities,
            relations=relations,
            sentiment=sentiment,
            events=events
        )

# predictor.py
from worldmonitor.ml import TimeSeriesPredictor, TrendAnalyzer

class Predictor:
    """时序预测与趋势分析"""
    
    def __init__(self, model_config: dict):
        self.ts_predictor = TimeSeriesPredictor(
            model_type=model_config['type'],  # LSTM/Transformer/ARIMA
            lookback=model_config['lookback']
        )
        self.trend_analyzer = TrendAnalyzer()
    
    def predict(self, historical_data: pd.DataFrame, 
               horizon: int = 30) -> PredictionResult:
        """预测未来 horizon 天地缘政治态势"""
        
        # 1. 时序预测
        forecast = self.ts_predictor.forecast(
            historical_data,
            horizon=horizon
        )
        
        # 2. 趋势分析
        trend = self.trend_analyzer.analyze(
            historical_data,
            confidence_level=0.95
        )
        
        # 3. 风险评估
        risk = self.assess_risk(forecast, trend)
        
        # 4. 情景模拟
        scenarios = self.simulate_scenarios(
            base_case=forecast,
            risk_factors=risk
        )
        
        return PredictionResult(
            forecast=forecast,
            trend=trend,
            risk=risk,
            scenarios=scenarios
        )

# 克隆仓库
git clone https://github.com/koala73/worldmonitor.git
cd worldmonitor

# 创建虚拟环境
python -m venv venv
source venv/bin/activate  # Linux/Mac
# or: venv\Scripts\activate  # Windows

# 安装依赖
pip install -r requirements.txt

# 或使用 Docker
docker pull koala73/worldmonitor:latest
docker run -p 8000:8000 koala73/worldmonitor

# config.py
from worldmonitor.config import Config

config = Config({
    # 数据源配置
    'data_sources': {
        'news_api': {
            'provider': 'newsapi',
            'api_key': '${NEWS_API_KEY}',
            'rate_limit': 100  # 每小时请求数
        },
        'social_media': {
            'twitter': {
                'bearer_token': '${TWITTER_BEARER_TOKEN}'
            },
            'reddit': {
                'client_id': '${REDDIT_CLIENT_ID}',
                'client_secret': '${REDDIT_CLIENT_SECRET}'
            }
        }
    },
    
    # NLP 模型配置
    'nlp': {
        'model': 'bert-base-uncased',
        'device': 'cuda',  # or 'cpu'
        'batch_size': 32
    },
    
    # 预测模型配置
    'prediction': {
        'model_type': 'LSTM',
        'lookback_days': 365,
        'forecast_horizon': 30,
        'confidence_level': 0.95
    },
    
    # 数据库配置
    'database': {
        'host': 'localhost',
        'port': 5432,
        'database': 'worldmonitor',
        'timescaledb': True  # 启用 TimescaleDB 扩展
    },
    
    # API 配置
    'api': {
        'host': '0.0.0.0',
        'port': 8000,
        'cors_origins': ['*']
    }
})

config.validate()
config.save('config.yaml')

# 自定义数据源示例
from worldmonitor.collectors import BaseCollector

class CustomSourceCollector(BaseCollector):
    """添加自定义数据源"""
    
    async def fetch(self, keywords: list, 
                   timeframe: str) -> pd.DataFrame:
        # 1. 调用 API 获取数据
        raw_data = await self.api_client.fetch(
            endpoint='/events',
            params={'keywords': keywords, 'since': timeframe}
        )
        
        # 2. 转换为标准格式
        standardized = self.transform_to_standard(raw_data)
        
        # 3. 提取关键字段
        return self.extract_fields(standardized, [
            'timestamp', 'title', 'content',
            'source', 'entities', 'sentiment'
        ])

# NLP 分析示例
from worldmonitor import WorldMonitor

wm = WorldMonitor(config='config.yaml')

# 分析单条新闻
result = wm.analyze("美国宣布对俄罗斯实施新一轮制裁")
print(f"实体: {result.entities}")
# 输出: [{'text': '美国', 'type': 'NORP'}, 
#       {'text': '俄罗斯', 'type': 'NORP'}]

print(f"关系: {result.relations}")
# 输出: [{'source': '美国', 'target': '俄罗斯', 
#        'type': 'sanction', 'confidence': 0.92}]

print(f"情感: {result.sentiment}")
# 输出: {'overall': 'negative', 'score': -0.75}

# 预测分析示例
prediction = wm.predict(
    region='中东',
    topic='冲突升级风险',
    horizon=30  # 预测未来 30 天
)

print(f"预测置信区间: {prediction.confidence_interval}")
# 输出: (0.65, 0.85)

print(f"风险等级: {prediction.risk_level}")
# 输出: 'HIGH'

print(f"关键因素: {prediction.key_factors}")
# 输出: ['经济制裁', '军事部署', '外交对话中断']

# 配置预警规则
from worldmonitor.alerts import AlertRule, NotificationChannel

rules = [
    # 规则 1：军事冲突预警
    AlertRule(
        name='military_conflict',
        condition=lambda x: (
            x.event_type == 'military_action' and
            x.confidence > 0.8 and
            x.escalation_score > 0.7
        ),
        severity='CRITICAL',
        channels=[
            NotificationChannel.EMAIL,
            NotificationChannel.SLACK,
            NotificationChannel.SMS
        ]
    ),
    
    # 规则 2：经济制裁预警
    AlertRule(
        name='economic_sanction',
        condition=lambda x: (
            x.event_type == 'sanction' and
            x.affected_countries.contains('中国')
        ),
        severity='HIGH',
        channels=[NotificationChannel.EMAIL]
    ),
    
    # 规则 3：外交关系变化
    AlertRule(
        name='diplomatic_tension',
        condition=lambda x: (
            x.event_type == 'diplomatic' and
            x.sentiment_change > 0.3
        ),
        severity='MEDIUM',
        channels=[NotificationChannel.DASHBOARD]
    )
]

# 添加规则
alert_manager = AlertManager(config)
for rule in rules:
    alert_manager.add_rule(rule)

# Dashboard 配置
from worldmonitor.dashboard import DashboardConfig

dashboard_config = DashboardConfig({
    'pages': [
        {
            'name': '实时态势',
            'widgets': [
                {
                    'type': 'world_map',
                    'data_source': 'events',
                    'aggregation': 'country',
                    'color_scheme': 'risk_heatmap'
                },
                {
                    'type': 'trend_line',
                    'data_source': 'sentiment',
                    'metrics': ['positive', 'negative', 'neutral'],
                    'time_range': '7d'
                },
                {
                    'type': 'event_timeline',
                    'data_source': 'events',
                    'filters': ['region', 'event_type']
                }
            ]
        },
        {
            'name': '预测分析',
            'widgets': [
                {'type': 'forecast_chart', 'data_source': 'predictions'},
                {'type': 'risk_gauge', 'data_source': 'risk_assessment'},
                {'type': 'scenario_comparison', 'data_source': 'scenarios'}
            ]
        }
    ]
})

# 获取当前地缘政治态势
curl -X GET "http://localhost:8000/api/v1/situation" \
  -H "Authorization: Bearer ${API_TOKEN}" \
  -d "region=middle_east" \
  -d "metric=conflict_risk"

# 获取事件列表
curl -X GET "http://localhost:8000/api/v1/events" \
  -H "Authorization: Bearer ${API_TOKEN}" \
  -d "start_date=2026-03-01" \
  -d "end_date=2026-03-31" \
  -d "event_type=sanction"

# 获取预测结果
curl -X POST "http://localhost:8000/api/v1/predict" \
  -H "Authorization: Bearer ${API_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "region": "east_asia",
    "topic": "trade_tension",
    "horizon": 30
  }'

from worldmonitor.sdk import WorldMonitorSDK

# 初始化 SDK
sdk = WorldMonitorSDK(api_key='your_api_key')

# 获取地缘政治态势
situation = sdk.get_situation(
    region='中东',
    metric='conflict_risk'
)
print(f"冲突风险指数: {situation.conflict_risk}")
print(f"趋势: {situation.trend}")

# 搜索事件
events = sdk.search_events(
    keywords=['制裁', '军事', '外交'],
    date_range=('2026-03-01', '2026-03-31'),
    sentiment='negative'
)

# 创建预警
alert = sdk.create_alert(
    name='台海局势预警',
    condition={
        'metric': 'tension_score',
        'operator': '>',
        'threshold': 0.8
    },
    callback='https://your-server.com/webhook'
)

# docker-compose.yml
version: '3.8'

services:
  worldmonitor:
    image: koala73/worldmonitor:latest
    ports:
      - "8000:8000"
      - "8501:8501"  # Streamlit Dashboard
    environment:
      - CONFIG_PATH=/app/config.yaml
      - DATABASE_URL=postgresql://user:pass@db:5432/worldmonitor
    volumes:
      - ./data:/app/data
      - ./logs:/app/logs
    depends_on:
      - postgres
      - redis

  postgres:
    image: timescale/timescaledb:latest-pg15
    environment:
      - POSTGRES_USER=worldmonitor
      - POSTGRES_PASSWORD=secret
      - POSTGRES_DB=worldmonitor
    volumes:
      - postgres_data:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

volumes:
  postgres_data:

# worldmonitor-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: worldmonitor
spec:
  replicas: 3
  selector:
    matchLabels:
      app: worldmonitor
  template:
    metadata:
      labels:
        app: worldmonitor
    spec:
      containers:
      - name: worldmonitor
        image: koala73/worldmonitor:latest
        ports:
        - containerPort: 8000
        resources:
          requests:
            memory: "4Gi"
            cpu: "2000m"
          limits:
            memory: "8Gi"
            cpu: "4000m"
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: worldmonitor-secrets
              key: database_url
---
apiVersion: v1
kind: Service
metadata:
  name: worldmonitor-service
spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 8000
  selector:
    app: worldmonitor

# custom_analyzer.py
from worldmonitor.analyzers import BaseAnalyzer
from worldmonitor.core import AnalysisResult

class CustomAnalyzer(BaseAnalyzer):
    """自定义分析模块"""
    
    def __init__(self, config: dict):
        super().__init__(config)
        self.model = self.load_model(config['model_path'])
    
    def analyze(self, text: str) -> AnalysisResult:
        # 1. 预处理
        processed = self.preprocess(text)
        
        # 2. 执行自定义分析
        result = self.model.predict(processed)
        
        # 3. 转换为标准格式
        return self.format_result(result)
    
    def preprocess(self, text: str) -> np.ndarray:
        # 实现自定义预处理逻辑
        return self.tokenizer(text, return_tensors='pt')

# worldmonitor/extensions.py
from worldmonitor import WorldMonitor
from custom_analyzer import CustomAnalyzer

# 创建 WorldMonitor 实例
wm = WorldMonitor(config='config.yaml')

# 注册自定义分析器
wm.register_analyzer(
    name='custom',
    analyzer=CustomAnalyzer(config={'model_path': '/models/custom.pt'}),
    replace_existing=False  # 保留原有分析器
)

# 使用
result = wm.analyze_with('custom', text)

# 数据质量检查
from worldmonitor.data import DataQualityChecker

checker = DataQualityChecker()

# 检查数据完整性
quality_report = checker.check({
    'completeness': {'min_coverage': 0.95},
    'freshness': {'max_age_hours': 24},
    'accuracy': {'confidence_threshold': 0.8}
})

if not quality_report.passed:
    logger.warning(f"数据质量问题: {quality_report.issues}")

# 配置实时数据流
from worldmonitor.stream import DataStream

stream = DataStream(
    sources=['twitter', 'news'],
    batch_size=100,
    interval_seconds=60
)

stream.on_data(lambda event: wm.process(event))
stream.start()