# filter_stock.py 示例：多因子选股
def filter_stock(factors):
    """
    factors: dict，包含以下参数
    - pe_ratio: 市盈率范围 (min, max)
    - turnover: 换手率范围
    - holder_count: 股东数范围
    - fund_holding: 基金持股比例
    """
    stocks = fetch_all_stocks()
    filtered = []
    for stock in stocks:
        if (factors['pe_ratio'][0] <= stock.pe <= factors['pe_ratio'][1]
            and factors['turnover'][0] <= stock.turnover <= factors['turnover'][1]
            and stock.holder_count >= factors['holder_count']
            and stock.fund_holding_ratio >= factors['fund_holding']):
            filtered.append(stock)
    return filtered

# ark_funds.py 示例：获取ARK ETF持仓
def get_ark_daily_holdings():
    """获取ARK ETF每日持仓数据并存入MongoDB"""
    import requests
    from datetime import datetime
    from pymongo import MongoClient
    
    url = "https://arkfunds.com/api/holdings"
    headers = {"User-Agent": "Mozilla/5.0"}
    response = requests.get(url, headers=headers)
    data = response.json()
    
    client = MongoClient('mongodb://user:pass@host:27017')
    db = client['ark_funds']
    collection = db['daily_holdings']
    
    for etf_name, holdings in data.items():
        doc = {
            'etf': etf_name,
            'date': datetime.now().strftime('%Y-%m-%d'),
            'holdings': holdings
        }
        collection.insert_one(doc)

# jisilu.py 示例：获取集思录可转债数据
def fetch_jisilu_bonds():
    """从集思录获取可转债行情数据"""
    import requests
    import pandas as pd
    
    url = "https://www.jisilu.com/data/cbnew/cb_list_new"
    headers = {
        "User-Agent": "Mozilla/5.0",
        "X-Requested-With": "XMLHttpRequest"
    }
    response = requests.post(url, headers=headers)
    
    if response.status_code == 200:
        data = response.json()
        df = pd.DataFrame(data['rows'])
        return df
    return None

# recognize_form.py 示例：识别K线形态
import talib
import numpy as np

def recognize_pattern(prices):
    """
    识别常见K线形态：三只乌鸦、锤子线、吞没形态等
    prices: dict，包含 'open', 'high', 'low', 'close'
    """
    open_prices = np.array(prices['open'])
    high_prices = np.array(prices['high'])
    low_prices = np.array(prices['low'])
    close_prices = np.array(prices['close'])
    
    patterns = {}
    
    # 锤子线 (Hammer)
    patterns['HAMMER'] = talib.CDLHAMMER(
        open_prices, high_prices, low_prices, close_prices
    )
    
    # 三只乌鸦 (Three Black Crows)
    patterns['TRISTAR'] = talib.CDL3WHITESOLDIERS(
        open_prices, high_prices, low_prices, close_prices
    )
    
    # 吞没形态 (Engulfing)
    patterns['ENGULFING'] = talib.CDLENGULFING(
        open_prices, high_prices, low_prices, close_prices
    )
    
    return {k: v[-1] for k, v in patterns.items() if v[-1] != 0}

# machine_learning/bayes_predict.py 示例
from sklearn.naive_bayes import GaussianNB
from sklearn.model_selection import train_test_split
import numpy as np

def train_stock_predictor(features, labels):
    """
    使用贝叶斯分类器预测股票涨跌
    features: 特征矩阵 (n_samples, n_features)
    labels: 标签 (涨/跌)
    """
    X_train, X_test, y_train, y_test = train_test_split(
        features, labels, test_size=0.2
    )
    
    model = GaussianNB()
    model.fit(X_train, y_train)
    
    accuracy = model.score(X_test, y_test)
    return model, accuracy

# push_msn.py 示例：价格提醒
def check_and_notify(stock_code, target_price, condition='above'):
    """
    检查股价，达到条件时发送通知
    condition: 'above' 或 'below'
    """
    current_price = get_realtime_price(stock_code)
    
    if condition == 'above' and current_price >= target_price:
        send_notification(f"{stock_code} 达到 {target_price}")
    elif condition == 'below' and current_price <= target_price:
        send_notification(f"{stock_code} 跌破 {target_price}")

# configure/setting.py
class Config:
    def __init__(self):
        self.json_data = self.load_config()
    
    def load_config(self):
        import json
        with open('configure/config.json', 'r', encoding='utf-8') as f:
            return json.load(f)
    
    def config(self, db_type='mysql', local='ubuntu'):
        """获取数据库连接配置"""
        db_dict = self.json_data[db_type][local]
        return (
            db_dict['user'],
            db_dict['password'],
            db_dict['host'],
            db_dict['port']
        )
    
    def get_engine(self, db, type_='ubuntu'):
        """获取SQLAlchemy引擎"""
        from sqlalchemy import create_engine
        user, password, host, port = self.config('mysql', type_)
        engine = create_engine(
            f'mysql+pymysql://{user}:{password}@{host}:{port}/{db}?charset=utf8'
        )
        return engine
    
    def get_mysql_conn(self, db, type_='ubuntu'):
        """获取PyMySQL连接"""
        import pymysql
        user, password, host, port = self.config('mysql', type_)
        conn = pymysql.connect(
            host=host, port=port, user=user,
            password=password, db=db, charset='utf8'
        )
        return conn
    
    def mongo(self, location_type='ubuntu', async_type=False):
        """获取MongoDB连接"""
        user, password, host, port = self.config('mongo', location_type)
        connect_uri = f'mongodb://{user}:{password}@{host}:{port}'
        
        if async_type:
            from motor.motor_asyncio import AsyncIOMotorClient
            return AsyncIOMotorClient(connect_uri)
        else:
            import pymongo
            return pymongo.MongoClient(connect_uri)

{
    "mysql": {
        "ubuntu": {
            "user": "root",
            "password": "your_password",
            "host": "localhost",
            "port": 3306
        },
        "server": {
            "user": "prod_user",
            "password": "prod_password",
            "host": "db.example.com",
            "port": 3306
        }
    },
    "mongo": {
        "ubuntu": {
            "user": "mongo_user",
            "password": "mongo_password",
            "host": "localhost",
            "port": 27017
        }
    }
}

# Python 3.x
python --version  # Python 3.7+

# 核心依赖
pip install pandas numpy
pip install sqlalchemy pymysql pymongo
pip install requests
pip install talib  # 技术分析
pip install scikit-learn  # 机器学习

# 1. 克隆仓库
git clone https://github.com/Rockyzsu/stock.git
cd stock

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

# 3. 配置数据库
cp configure/sample_config.json configure/config.json
# 编辑 config.json 填入你的数据库信息

# 4. 运行示例
python select_stock.py          # 选股
python jisilu.py               # 可转债数据
python get_break_high.py       # 50日新高

# backtest/macd_demo.py
import pandas as pd
import numpy as np
import talib

def backtest_macd(data, fast=12, slow=26, signal=9):
    """
    MACD策略回测
    金叉买入，死叉卖出
    """
    # 计算MACD
    macd, signal_line, hist = talib.MACD(
        data['close'].values,
        fastperiod=fast,
        slowperiod=slow,
        signalperiod=signal
    )
    
    # 生成信号
    data['macd'] = macd
    data['signal'] = signal_line
    data['hist'] = hist
    data['signal'][data['hist'] > 0] = 1   # 买入
    data['signal'][data['hist'] < 0] = -1  # 卖出
    
    # 计算收益
    returns = data['close'].pct_change()
    strategy_returns = returns * data['signal'].shift(1)
    
    # 累计收益
    cumulative = (1 + strategy_returns).cumprod()
    
    return {
        'total_return': cumulative.iloc[-1] - 1,
        'sharpe_ratio': strategy_returns.mean() / strategy_returns.std() * np.sqrt(252)
    }

# ptrade/ptrade_api.py
class PTradeAPI:
    def __init__(self, account, password):
        self.account = account
        self.password = password
        self.base_url = "https://ptrade.example.com/api"
    
    def login(self):
        """登录交易账户"""
        import requests
        data = {
            'account': self.account,
            'password': self.password
        }
        response = requests.post(
            f"{self.base_url}/login",
            json=data
        )
        return response.json()
    
    def buy(self, stock_code, price, quantity):
        """买入股票"""
        order = {
            'stock_code': stock_code,
            'price': price,
            'quantity': quantity,
            'action': 'buy'
        }
        return self.send_order(order)
    
    def sell(self, stock_code, price, quantity):
        """卖出股票"""
        order = {
            'stock_code': stock_code,
            'price': price,
            'quantity': quantity,
            'action': 'sell'
        }
        return self.send_order(order)

# futu/futu_api.py
class FutuAPI:
    def __init__(self, open_id, api_key):
        self.open_id = open_id
        self.api_key = api_key
        self.base_url = "https://openapi.futunnasy.com"
    
    def get_quote(self, stock_code):
        """获取实时行情"""
        import requests
        params = {
            'code': stock_code,
            'open_id': self.open_id,
            'sign': self.generate_sign()
        }
        response = requests.get(
            f"{self.base_url}/quote/get",
            params=params
        )
        return response.json()

# analysis/get_zt_info.py
def analyze_zt_strength(stock_list, date):
    """
    分析次新板块中的涨停强度
    """
    results = []
    for stock in stock_list:
        zt_info = get_zt_info(stock, date)
        results.append({
            'code': stock,
            'zt_date': zt_info['zt_date'],
            'zt_strength': zt_info['strength'],  # 封单金额/流通市值
            'break_count': zt_info['break_times']  # 开板次数
        })
    
    # 按强度排序
    df = pd.DataFrame(results)
    df = df.sort_values('zt_strength', ascending=False)
    return df

# analysis/diagnose_stock.py
def diagnose_stock(stock_code):
    """
    股票诊断：是否有黑历史、是否为东北股
    """
    diagnosis = {
        'code': stock_code,
        'has_blacklist': False,
        'is_northeast': False,
        'warnings': []
    }
    
    # 检查黑名单
    if is_in_blacklist(stock_code):
        diagnosis['has_blacklist'] = True
        diagnosis['warnings'].append('该股票有黑历史')
    
    # 检查东北股
    if is_northeast_stock(stock_code):
        diagnosis['is_northeast'] = True
        diagnosis['warnings'].append('该股票为东北股')
    
    return diagnosis