cnhkmcp 2.1.2__py3-none-any.whl → 2.1.3__py3-none-any.whl

cnhkmcp/untracked/APP/hkSimulator/autosimulator.py

@@ -1,447 +0,0 @@
-import sys
-import subprocess
-# --- Dependency Check & Auto-Install ---
-required_imports = [
-    ("getpass", None),
-    ("json", None),
-    ("logging", None),
-    ("os", None),
-    ("threading", None),
-    ("time", None),
-    ("functools", None),
-    ("multiprocessing", None),
-    ("pathlib", None),
-    ("typing", None),
-    ("urllib.parse", None),
-    ("pandas", "pandas"),
-    ("requests", "requests"),
-    ("tqdm", "tqdm"),
-    ("pandas.io.formats.style", "pandas"),
-]
-for mod, pipname in required_imports:
-    try:
-        if "." in mod:
-            __import__(mod.split(".")[0])
-        else:
-            __import__(mod)
-    except ImportError:
-        if pipname:
-            print(f"Installing missing package: {pipname}")
-            subprocess.check_call([sys.executable, "-m", "pip", "install", pipname])
-        else:
-            print(f"Module {mod} is a built-in or not installable via pip.")
-# --- Script Description ---
-"""
-Autosimulator for WorldQuant BRAIN platform
-- Timestamped logger
-- Authentication with biometric check
-- User-specified alpha JSON input
-- Single/multi simulation mode
-- Simulation worker: sends jobs, retries, saves locations
-- Result worker: fetches results, saves to JSON
-"""
-import os
-import sys
-import time
-import json
-import threading
-import logging
-from datetime import datetime
-from pathlib import Path
-import requests
-import getpass
-
-# Platform specific imports
-if sys.platform == 'win32':
-    import msvcrt
-else:
-    import tty
-    import termios
-from ace_lib import (
-    check_session_and_relogin,
-    simulate_single_alpha,
-    simulate_multi_alpha,
-)
-
-# --- Logger Setup ---
-def setup_logger():
-    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
-    log_filename = f'autosim_{timestamp}.log'
-    logger = logging.getLogger(f'autosim_{timestamp}')
-    logger.setLevel(logging.DEBUG)
-    formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
-    fh = logging.FileHandler(log_filename)
-    fh.setFormatter(formatter)
-    logger.addHandler(fh)
-    ch = logging.StreamHandler()
-    ch.setFormatter(formatter)
-    logger.addHandler(ch)
-    return logger, log_filename
-
-logger, log_filename = setup_logger()
-
-# --- Authentication ---
-def check_session_timeout(s):
-    """
-    Check if the current session has timed out.
-
-    Args:
-        s (SingleSession): The current session object.
-
-    Returns:
-        int: The number of seconds until the session expires, or 0 if the session has expired or an error occurred.
-    """
-    brain_api_url = os.environ.get("BRAIN_API_URL", "https://api.worldquantbrain.com")
-    authentication_url = brain_api_url + "/authentication"
-    try:
-        result = s.get(authentication_url).json()["token"]["expiry"]
-        logger.debug(f"Session (ID: {id(s)}) timeout check result: {result}")
-        return result
-    except Exception:
-        logger.error(f"Session timeout check failed for session (ID: {id(s)})")
-        return 0
-def get_credentials():
-    email = input("Email: ").strip()
-    print("Password: ", end='', flush=True)
-    password = []
-    
-    try:
-        if sys.platform == 'win32':
-            # Windows: Use msvcrt.getch()
-            while True:
-                char = msvcrt.getch()
-                
-                # Handle Enter key
-                if char in [b'\r', b'\n']:
-                    print()  # New line
-                    break
-                
-                # Handle Backspace
-                elif char == b'\x08':  # Backspace
-                    if password:
-                        password.pop()
-                        # Move cursor back, print space, move cursor back again
-                        print('\b \b', end='', flush=True)
-                
-                # Handle Ctrl+C
-                elif char == b'\x03':  # Ctrl+C
-                    print()
-                    raise KeyboardInterrupt
-                
-                # Handle printable characters (ASCII)
-                elif 32 <= ord(char) <= 126:  # Printable ASCII range
-                    password.append(char.decode('ascii'))
-                    print('*', end='', flush=True)
-                
-                # Handle extended characters
-                else:
-                    try:
-                        decoded_char = char.decode('utf-8')
-                        if decoded_char.isprintable():
-                            password.append(decoded_char)
-                            print('*', end='', flush=True)
-                    except UnicodeDecodeError:
-                        continue
-        else:
-            # Unix/macOS: Use tty and termios
-            fd = sys.stdin.fileno()
-            old_settings = termios.tcgetattr(fd)
-            try:
-                tty.setraw(fd)
-                while True:
-                    char = sys.stdin.read(1)
-                    
-                    # Handle Enter key
-                    if char in ['\r', '\n']:
-                        print('\r\n', end='', flush=True)
-                        break
-                    
-                    # Handle Backspace
-                    elif char in ['\x7f', '\x08']:
-                        if password:
-                            password.pop()
-                            print('\b \b', end='', flush=True)
-                    
-                    # Handle Ctrl+C
-                    elif char == '\x03':
-                        print('\r\n', end='', flush=True)
-                        raise KeyboardInterrupt
-                    
-                    # Handle printable characters
-                    elif char.isprintable():
-                        password.append(char)
-                        print('*', end='', flush=True)
-            finally:
-                termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
-                
-    except Exception as e:
-        # Fallback to getpass
-        print(f"\nError reading password: {e}")
-        print("Falling back to getpass...")
-        return (email, getpass.getpass())
-
-    return (email, ''.join(password))
-
-def authenticate():
-    from ace_lib import SingleSession
-    session = SingleSession()
-    session.auth = get_credentials()
-    brain_api_url = os.environ.get("BRAIN_API_URL", "https://api.worldquantbrain.com")
-    r = session.post(brain_api_url + "/authentication")
-    logger.debug(f"New session created (ID: {id(session)}) with authentication response: {r.status_code}, {r.json()}")
-    if r.status_code == requests.status_codes.codes.unauthorized:
-        if r.headers.get("WWW-Authenticate") == "persona":
-            print(
-                "Complete biometrics authentication and press any key to continue: \n"
-                + r.url + "/persona?inquiry=" + r.headers.get("Location", "")
-                + "\n"
-            )
-            input()
-            session.post(r.headers.get("Location", r.url))
-            while True:
-                if session.post(r.headers.get("Location", r.url)).status_code != 201:
-                    input(
-                        "Biometrics authentication is not complete. Please try again and press any key when completed \n"
-                    )
-                else:
-                    break
-        else:
-            logger.error("\nIncorrect email or password\n")
-            return authenticate()
-    return session
-
-# --- User Input ---
-MASTER_LOG_PATH = "autosim_master_log.json"
-
-def update_master_log(input_json_path, latest_index):
-    """
-    Update the master log file with the latest successful index for the given input file name.
-    """
-    import os, json
-    file_name = os.path.basename(input_json_path)
-    log_data = {}
-    # Read existing log if present
-    if os.path.exists(MASTER_LOG_PATH):
-        try:
-            with open(MASTER_LOG_PATH, "r", encoding="utf-8") as f:
-                log_data = json.load(f)
-        except Exception:
-            log_data = {}
-    # Update with latest index
-    log_data[file_name] = latest_index
-    # Atomic write
-    tmp_path = MASTER_LOG_PATH + ".tmp"
-    with open(tmp_path, "w", encoding="utf-8") as f:
-        json.dump(log_data, f, indent=2)
-    os.replace(tmp_path, MASTER_LOG_PATH)
-def get_user_json():
-    import re
-    while True:
-        raw_path = input('Enter path to alpha JSON file: ').strip()
-        json_path = re.sub(r'^["\']+|["\']+$', '', raw_path.strip())
-        if os.path.exists(json_path):
-            try:
-                with open(json_path, 'r', encoding='utf-8') as f:
-                    alpha_list = json.load(f)
-                # Check master log for previous progress
-                file_name = os.path.basename(json_path)
-                start_index = 0
-                if os.path.exists(MASTER_LOG_PATH):
-                    try:
-                        with open(MASTER_LOG_PATH, 'r', encoding='utf-8') as logf:
-                            log_data = json.load(logf)
-                        if file_name in log_data:
-                            last_index = log_data[file_name]
-                            print(f'Last time you simulated to position {last_index}.')
-                            resp = input(f'Do you want to start from {last_index + 1}? (Y/n) Or enter another starting index: ').strip()
-                            if resp.lower() in ['', 'y', 'yes']:
-                                start_index = last_index + 1
-                            elif resp.isdigit():
-                                start_index = int(resp)
-                            else:
-                                print('Invalid input, starting from 0.')
-                                start_index = 0
-                    except Exception:
-                        pass
-                # Slice alpha_list to start from chosen index
-                class AlphaList(list):
-                    pass
-                alpha_list = AlphaList(alpha_list[start_index:])
-                alpha_list._start_index = start_index
-                return alpha_list, json_path
-            except Exception as e:
-                logger.error(f'Error reading JSON file: {e}')
-        else:
-            logger.error(f'JSON file not found: {json_path}')
-        print('Please enter a valid path to your alpha JSON file.')
-
-def get_simulation_mode():
-    mode = input('Select simulation mode (single/multi): ').strip().lower()
-    if mode not in ['single', 'multi']:
-        logger.error('Invalid mode. Choose "single" or "multi".')
-        sys.exit(1)
-    batch_size = None
-    if mode == 'multi':
-        while True:
-            try:
-                batch_size = int(input('Enter number of elements per multi-simulation batch (2-10): ').strip())
-                if 2 <= batch_size <= 10:
-                    break
-                else:
-                    print('Batch size must be between 2 and 10.')
-            except Exception:
-                print('Please enter a valid integer between 2 and 10.')
-    return mode, batch_size
-
-def get_retry_timeout():
-    try:
-        timeout = int(input('Enter retry timeout in seconds (default 60): ').strip())
-        if timeout < 1:
-            timeout = 60
-    except Exception:
-        timeout = 60
-    return timeout
-
-# --- Simulation Worker ---
-def simulation_worker(session, alpha_list, mode, json_path, location_path, retry_timeout, batch_size=None):
-    locations = {}
-    # Initialize sent_count from user starting index (passed via alpha_list attribute if set)
-    file_name = os.path.basename(json_path)
-    sent_count = getattr(alpha_list, '_start_index', 0)
-    while alpha_list:
-        # Check session timeout before proceeding
-        if check_session_timeout(session) == 0:
-            logger.error('Session expired. Stopping simulation worker.')
-            break
-        session = check_session_and_relogin(session)
-        # Prepare batch but do NOT pop yet
-        if mode == 'single':
-            batch = [alpha_list[0]]
-        else:
-            size = batch_size if batch_size else min(10, max(2, len(alpha_list)))
-            batch = [alpha_list[i] for i in range(min(size, len(alpha_list)))]
-        try:
-            from ace_lib import start_simulation
-            location = None
-            while location is None:
-                # Check session timeout before each send
-                if check_session_timeout(session) == 0:
-                    logger.error('Session expired. Stopping simulation worker.')
-                    return
-                if mode == 'single':
-                    response = start_simulation(session, batch[0])
-                    location = response.headers.get('Location')
-                else:
-                    response = start_simulation(session, batch)
-                    location = response.headers.get('Location')
-                if location is None:
-                    logger.info(f'Simulation sent, location(s) saved: None')
-                    logger.info(f'No location received, waiting {retry_timeout} seconds and retrying...')
-                    time.sleep(retry_timeout)
-            # Only pop/remove after location is valid
-            if mode == 'single':
-                alpha_list.pop(0)
-                sent_count += 1
-                update_master_log(json_path, sent_count - 1)
-            else:
-                for _ in range(len(batch)):
-                    alpha_list.pop(0)
-                sent_count += len(batch)
-                update_master_log(json_path, sent_count - 1)
-            locations[str(time.time())] = location
-            with open(location_path, 'w', encoding='utf-8') as f:
-                json.dump(locations, f, indent=2)
-            # Do NOT overwrite the input JSON file
-            logger.info(f'Simulation sent, location(s) saved: {location}')
-        except Exception as e:
-            logger.error(f'Simulation error: {e}. Retrying in {retry_timeout} seconds.')
-            time.sleep(retry_timeout)
-
-# --- Result Worker ---
-def result_worker(session, location_path, result_path, poll_interval=30):
-    results = {}
-    from time import sleep
-    while True:
-        # Check session timeout before proceeding
-        if check_session_timeout(session) == 0:
-            logger.error('Session expired. Stopping result worker.')
-            break
-        session = check_session_and_relogin(session)
-        if not os.path.exists(location_path):
-            time.sleep(poll_interval)
-            continue
-        with open(location_path, 'r', encoding='utf-8') as f:
-            locations = json.load(f)
-        for loc_key, loc_val in locations.items():
-            if loc_key in results:
-                continue
-            if not loc_val or not isinstance(loc_val, str) or not loc_val.startswith('http'):
-                logger.error(f'Invalid or missing location for key {loc_key}: {loc_val}')
-                continue
-            try:
-                # Check session timeout before each result fetch
-                if check_session_timeout(session) == 0:
-                    logger.error('Session expired. Stopping result worker.')
-                    return
-                simulation_progress_url = loc_val
-                while True:
-                    simulation_progress = session.get(simulation_progress_url)
-                    retry_after = simulation_progress.headers.get("Retry-After", 0)
-                    if float(retry_after) == 0:
-                        break
-                    logger.info(f"Sleeping for {retry_after} seconds for location {simulation_progress_url}")
-                    sleep(float(retry_after))
-                sim_json = simulation_progress.json()
-                # Multi-simulation: check for children
-                if "children" in sim_json and sim_json.get("status") == "COMPLETE":
-                    child_results = {}
-                    for child_id in sim_json["children"]:
-                        child_url = f"https://api.worldquantbrain.com/simulations/{child_id}"
-                        child_resp = session.get(child_url)
-                        child_json = child_resp.json()
-                        alpha_id = child_json.get("alpha")
-                        if not alpha_id:
-                            logger.error(f"No alpha_id found for child {child_id}")
-                            child_results[child_id] = {"error": "No alpha_id found"}
-                        else:
-                            alpha = session.get(f"https://api.worldquantbrain.com/alphas/{alpha_id}")
-                            child_results[child_id] = alpha.json()
-                    results[loc_key] = {"multi_children": child_results}
-                    logger.info(f"Multi-simulation results fetched for location {loc_val}")
-                else:
-                    # Single simulation
-                    alpha_id = sim_json.get("alpha")
-                    if not alpha_id:
-                        logger.error(f"No alpha_id found for location {simulation_progress_url}")
-                        results[loc_key] = {"error": "No alpha_id found"}
-                    else:
-                        alpha = session.get(f"https://api.worldquantbrain.com/alphas/{alpha_id}")
-                        results[loc_key] = alpha.json()
-                    logger.info(f"Result fetched for location {loc_val}")
-                with open(result_path, 'w', encoding='utf-8') as f:
-                    json.dump(results, f, indent=2)
-            except Exception as e:
-                logger.error(f'Error fetching result for {loc_val}: {e}')
-        time.sleep(poll_interval)
-
-# --- Main ---
-def main():
-    session = authenticate()
-    alpha_list, json_path = get_user_json()
-    mode, batch_size = get_simulation_mode()
-    retry_timeout = get_retry_timeout()
-    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
-    location_path = f'autosim_locations_{timestamp}.json'
-    result_path = f'autosim_results_{timestamp}.json'
-    # Start workers
-    sim_thread = threading.Thread(target=simulation_worker, args=(session, alpha_list, mode, json_path, location_path, retry_timeout, batch_size))
-    res_thread = threading.Thread(target=result_worker, args=(session, location_path, result_path))
-    sim_thread.start()
-    res_thread.start()
-    sim_thread.join()
-    # Result worker runs until all locations processed
-    logger.info('Simulation worker finished. Waiting for results...')
-    res_thread.join()
-
-if __name__ == '__main__':
-    main()

cnhkmcp/untracked/APP/hkSimulator/helpful_functions.py

@@ -1,180 +0,0 @@
-import json
-import os
-from typing import Union
-
-import pandas as pd
-from pandas.io.formats.style import Styler
-
-brain_api_url = os.environ.get("BRAIN_API_URL", "https://api.worldquantbrain.com")
-brain_url = os.environ.get("BRAIN_URL", "https://platform.worldquantbrain.com")
-
-
-def make_clickable_alpha_id(alpha_id: str) -> str:
-    """
-    Create a clickable HTML link for an alpha ID.
-
-    Args:
-        alpha_id (str): The ID of the alpha.
-
-    Returns:
-        str: An HTML string containing a clickable link to the alpha's page on the platform.
-    """
-
-    url = brain_url + "/alpha/"
-    return f'<a href="{url}{alpha_id}">{alpha_id}</a>'
-
-
-def prettify_result(
-    result: list, detailed_tests_view: bool = False, clickable_alpha_id: bool = False
-) -> Union[pd.DataFrame, Styler]:
-    """
-    Combine and format simulation results into a single DataFrame for analysis.
-
-    Args:
-        result (list): A list of dictionaries containing simulation results.
-        detailed_tests_view (bool, optional): If True, include detailed test results. Defaults to False.
-        clickable_alpha_id (bool, optional): If True, make alpha IDs clickable. Defaults to False.
-
-    Returns:
-        pandas.DataFrame or pandas.io.formats.style.Styler: A DataFrame containing formatted results,
-        optionally with clickable alpha IDs.
-    """
-    list_of_is_stats = [result[x]["is_stats"] for x in range(len(result)) if result[x]["is_stats"] is not None]
-    is_stats_df = pd.concat(list_of_is_stats).reset_index(drop=True)
-    is_stats_df = is_stats_df.sort_values("fitness", ascending=False)
-
-    expressions = {
-        result[x]["alpha_id"]: (
-            {
-                "selection": result[x]["simulate_data"]["selection"],
-                "combo": result[x]["simulate_data"]["combo"],
-            }
-            if result[x]["simulate_data"]["type"] == "SUPER"
-            else result[x]["simulate_data"]["regular"]
-        )
-        for x in range(len(result))
-        if result[x]["is_stats"] is not None
-    }
-    expression_df = pd.DataFrame(list(expressions.items()), columns=["alpha_id", "expression"])
-
-    list_of_is_tests = [result[x]["is_tests"] for x in range(len(result)) if result[x]["is_tests"] is not None]
-    is_tests_df = pd.concat(list_of_is_tests, sort=True).reset_index(drop=True)
-    is_tests_df = is_tests_df[is_tests_df["result"] != "WARNING"]
-    if detailed_tests_view:
-        cols = ["limit", "result", "value"]
-        is_tests_df["details"] = is_tests_df[cols].to_dict(orient="records")
-        is_tests_df = is_tests_df.pivot(index="alpha_id", columns="name", values="details").reset_index()
-    else:
-        is_tests_df = is_tests_df.pivot(index="alpha_id", columns="name", values="result").reset_index()
-
-    alpha_stats = pd.merge(is_stats_df, expression_df, on="alpha_id")
-    alpha_stats = pd.merge(alpha_stats, is_tests_df, on="alpha_id")
-    alpha_stats = alpha_stats.drop(columns=alpha_stats.columns[(alpha_stats == "PENDING").any()])
-    alpha_stats.columns = alpha_stats.columns.str.replace("(?<=[a-z])(?=[A-Z])", "_", regex=True).str.lower()
-    if clickable_alpha_id:
-        return alpha_stats.style.format({"alpha_id": lambda x: make_clickable_alpha_id(str(x))})
-    return alpha_stats
-
-
-def concat_pnl(result: list) -> pd.DataFrame:
-    """
-    Combine PnL results from multiple alphas into a single DataFrame.
-
-    Args:
-        result (list): A list of dictionaries containing simulation results with PnL data.
-
-    Returns:
-        pandas.DataFrame: A DataFrame containing combined PnL data for all alphas.
-    """
-    list_of_pnls = [result[x]["pnl"] for x in range(len(result)) if result[x]["pnl"] is not None]
-    pnls_df = pd.concat(list_of_pnls).reset_index()
-
-    return pnls_df
-
-
-def concat_is_tests(result: list) -> pd.DataFrame:
-    """
-    Combine in-sample test results from multiple alphas into a single DataFrame.
-
-    Args:
-        result (list): A list of dictionaries containing simulation results with in-sample test data.
-
-    Returns:
-        pandas.DataFrame: A DataFrame containing combined in-sample test results for all alphas.
-    """
-    is_tests_list = [result[x]["is_tests"] for x in range(len(result)) if result[x]["is_tests"] is not None]
-    is_tests_df = pd.concat(is_tests_list, sort=True).reset_index(drop=True)
-    return is_tests_df
-
-
-def save_simulation_result(result: dict) -> None:
-    """
-    Save the simulation result to a JSON file in the 'simulation_results' folder.
-
-    Args:
-        result (dict): A dictionary containing the simulation result for an alpha.
-    """
-
-    alpha_id = result["id"]
-    region = result["settings"]["region"]
-    folder_path = "simulation_results/"
-    file_path = os.path.join(folder_path, f"{alpha_id}_{region}")
-
-    os.makedirs(folder_path, exist_ok=True)
-
-    with open(file_path, "w", encoding="utf-8") as file:
-        json.dump(result, file)
-
-
-def save_pnl(pnl_df: pd.DataFrame, alpha_id: str, region: str) -> None:
-    """
-    Save the PnL data for an alpha to a CSV file in the 'alphas_pnl' folder.
-
-    Args:
-        pnl_df (pandas.DataFrame): The DataFrame containing PnL data.
-        alpha_id (str): The ID of the alpha.
-        region (str): The region for which the PnL data was generated.
-    """
-
-    folder_path = "alphas_pnl/"
-    file_path = os.path.join(folder_path, f"{alpha_id}_{region}.csv")
-    os.makedirs(folder_path, exist_ok=True)
-
-    pnl_df.to_csv(file_path)
-
-
-def save_yearly_stats(yearly_stats: pd.DataFrame, alpha_id: str, region: str):
-    """
-    Save the yearly statistics for an alpha to a CSV file in the 'yearly_stats' folder.
-
-    Args:
-        yearly_stats (pandas.DataFrame): The DataFrame containing yearly statistics.
-        alpha_id (str): The ID of the alpha.
-        region (str): The region for which the statistics were generated.
-    """
-
-    folder_path = "yearly_stats/"
-    file_path = os.path.join(folder_path, f"{alpha_id}_{region}.csv")
-    os.makedirs(folder_path, exist_ok=True)
-
-    yearly_stats.to_csv(file_path, index=False)
-
-
-def expand_dict_columns(data: pd.DataFrame) -> pd.DataFrame:
-    """
-    Expand dictionary columns in a DataFrame into separate columns.
-
-    Args:
-        data (pandas.DataFrame): The input DataFrame with dictionary columns.
-
-    Returns:
-        pandas.DataFrame: A new DataFrame with expanded columns.
-    """
-    dict_columns = list(filter(lambda x: isinstance(data[x].iloc[0], dict), data.columns))
-    new_columns = pd.concat(
-        [data[col].apply(pd.Series).rename(columns=lambda x: f"{col}_{x}") for col in dict_columns],
-        axis=1,
-    )
-
-    data = pd.concat([data, new_columns], axis=1)
-    return data

cnhkmcp/untracked/APP/mirror_config.txt

@@ -1,20 +0,0 @@
-# PyPI Mirror Configuration
-# 配置 PyPI 镜像源
-
-# Default: Tsinghua University (China)
-# 默认：清华大学镜像源（中国）
-https://pypi.tuna.tsinghua.edu.cn/simple
-
-# Alternative mirrors / 其他可选镜像源:
-# 
-# Aliyun (阿里云):
-# https://mirrors.aliyun.com/pypi/simple/
-#
-# Douban (豆瓣):
-# https://pypi.douban.com/simple/
-#
-# USTC (中国科学技术大学):
-# https://pypi.mirrors.ustc.edu.cn/simple/
-#
-# Official PyPI (官方源):
-# https://pypi.org/simple