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

cnhkmcp/untracked/APP/simulator/alpha_submitter.py

@@ -0,0 +1,404 @@
+import requests
+import json
+import time
+from datetime import datetime
+import os
+from pathlib import Path
+import getpass
+import sys
+
+# Platform specific imports
+if sys.platform == 'win32':
+    import msvcrt
+else:
+    import tty
+    import termios
+
+def input_with_asterisks(prompt):
+    """Cross-platform password input showing asterisks"""
+    print(prompt, 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 getpass.getpass()
+
+    return ''.join(password)
+
+def login(account_choice=None):
+    """Login to WorldQuant Brain API"""
+    s = requests.Session()
+    
+    # Prompt user for credentials
+    print("\n=== WorldQuant Brain Login ===")
+    email = input("Enter your email: ").strip()
+    
+    # Use custom password input with asterisk masking
+    try:
+        password = input_with_asterisks("Enter your password: ")
+        if not password:
+            print("❌ Password is required.")
+            return None
+    except Exception as e:
+        print(f"❌ Error with custom password input: {e}")
+        print("Trying standard getpass...")
+        try:
+            password = getpass.getpass("Enter your password: ")
+            if not password:
+                print("❌ Password is required.")
+                return None
+        except Exception as e2:
+            print(f"❌ Error reading password: {e2}")
+            return None
+    
+    if not email:
+        print("❌ Email is required.")
+        return None
+    
+    print(f"Logging in with: {email}")
+    
+    # Set basic auth
+    s.auth = (email, password)
+    
+    try:
+        # Send authentication request
+        response = s.post('https://api.worldquantbrain.com/authentication')
+        print(f"Login response status: {response.status_code}")
+        print(f"Login response headers: {dict(response.headers)}")
+        
+        if response.text:
+            try:
+                response_json = response.json()
+                print(f"Login response body: {json.dumps(response_json, indent=2)}")
+            except json.JSONDecodeError:
+                print(f"Login response body (not JSON): {response.text}")
+        
+        response.raise_for_status()
+        print("Login successful!")
+        return s
+    except requests.exceptions.RequestException as e:
+        print(f"Login failed: {e}")
+        if hasattr(e, 'response') and e.response is not None:
+            print(f"Error response status: {e.response.status_code}")
+            print(f"Error response body: {e.response.text}")
+        return None
+
+def check_alpha_exists(s, alpha_id):
+    """Check if an alpha exists by making a GET request to /alphas/<alpha_id>"""
+    try:
+        response = s.get(f"https://api.worldquantbrain.com/alphas/{alpha_id}")
+        print(f"Alpha check response status: {response.status_code}")
+        print(f"Alpha check response headers: {dict(response.headers)}")
+        
+        if response.status_code == 200:
+            alpha_data = response.json()
+            print(f"✅ Alpha {alpha_id} exists - Type: {alpha_data.get('type', 'Unknown')}")
+            print(f"Alpha data: {json.dumps(alpha_data, indent=2)}")
+            return True, alpha_data
+        elif response.status_code == 404:
+            print(f"❌ Alpha {alpha_id} does not exist (404 Not Found)")
+            if response.text:
+                print(f"404 response body: {response.text}")
+            return False, None
+        else:
+            print(f"⚠️ Unexpected response for alpha {alpha_id}: {response.status_code}")
+            if response.text:
+                print(f"Unexpected response body: {response.text}")
+            return False, None
+    except requests.exceptions.RequestException as e:
+        print(f"❌ Error checking alpha {alpha_id}: {e}")
+        if hasattr(e, 'response') and e.response is not None:
+            print(f"Error response status: {e.response.status_code}")
+            print(f"Error response body: {e.response.text}")
+        return False, None
+
+def get_alpha_recordsets(s, alpha_id):
+    """Get available record sets for an alpha"""
+    try:
+        response = s.get(f"https://api.worldquantbrain.com/alphas/{alpha_id}/recordsets")
+        print(f"Recordsets response status: {response.status_code}")
+        print(f"Recordsets response headers: {dict(response.headers)}")
+        
+        if response.status_code == 200:
+            recordsets_data = response.json()
+            print(f"📊 Alpha {alpha_id} has {recordsets_data.get('count', 0)} record sets available")
+            print(f"Recordsets data: {json.dumps(recordsets_data, indent=2)}")
+            return recordsets_data
+        else:
+            print(f"⚠️ Could not fetch record sets for alpha {alpha_id}: {response.status_code}")
+            if response.text:
+                print(f"Recordsets error response body: {response.text}")
+            return None
+    except requests.exceptions.RequestException as e:
+        print(f"❌ Error fetching record sets for alpha {alpha_id}: {e}")
+        if hasattr(e, 'response') and e.response is not None:
+            print(f"Error response status: {e.response.status_code}")
+            print(f"Error response body: {e.response.text}")
+        return None
+
+def submit(s, alpha_id):
+    """Submit a single alpha with retry logic - keeps trying until success"""
+    
+    def submit_inner(s, alpha_id):
+        """Inner submit function with rate limiting handling"""
+        try:
+            result = s.post(f"https://api.worldquantbrain.com/alphas/{alpha_id}/submit")
+            print(f"Alpha submit, alpha_id={alpha_id}, status_code={result.status_code}")
+            print(f"Response headers: {dict(result.headers)}")
+            
+            # Handle rate limiting
+            while True:
+                if "retry-after" in result.headers:
+                    wait_time = float(result.headers["Retry-After"])
+                    print(f"Rate limited, waiting {wait_time} seconds...")
+                    time.sleep(wait_time)
+                    result = s.get(f"https://api.worldquantbrain.com/alphas/{alpha_id}/submit")
+                    print(f"Retry GET response, status_code={result.status_code}")
+                    print(f"Retry headers: {dict(result.headers)}")
+                else:
+                    break
+            
+            return result
+        except Exception as e:
+            print(f'Connection error: {e}, attempting to re-login...')
+            new_session = login()
+            if new_session is None:
+                return None
+            return submit_inner(new_session, alpha_id)
+    
+    attempt_count = 1
+    result = None
+    
+    while True:
+        print(f"Submit attempt {attempt_count} for alpha {alpha_id}")
+        result = submit_inner(s, alpha_id)
+        
+        if result is None:
+            print(f"Failed to submit {alpha_id} - connection error")
+            return None
+        
+        if result.status_code == 200:
+            print(f"✅ Alpha {alpha_id} submit successful, status_code={result.status_code}")
+            return result
+        elif result.status_code == 403:
+            print(f"❌ Alpha {alpha_id} submit forbidden, status_code={result.status_code}")
+            return result
+        else:
+            print(f"⚠️ Alpha submit fail, status_code={result.status_code}, alpha_id={alpha_id}, attempt {attempt_count}")
+            print(f"Waiting 2 minutes before retry...")
+            time.sleep(120)  # 2 minutes = 120 seconds
+            attempt_count += 1
+            continue
+
+def submit_alpha(alpha_id, session=None, account_choice=None):
+    """Submit a single alpha with comprehensive error handling"""
+    if session is None:
+        s = login(account_choice)
+        if s is None:
+            return False
+    else:
+        s = session
+    
+    # First check if the alpha exists
+    print(f"Checking if alpha {alpha_id} exists...")
+    exists, alpha_data = check_alpha_exists(s, alpha_id)
+    if not exists:
+        print(f"❌ Cannot submit alpha {alpha_id} - it does not exist")
+        return False
+    
+    # Submit the alpha
+    res = submit(s, alpha_id)
+    
+    if res is None:
+        print(f"Failed to submit {alpha_id} - connection error")
+        return False
+    
+    # Parse response
+    if res.text:
+        try:
+            res_json = res.json()
+            print(f"Submit response parsed successfully")
+        except json.JSONDecodeError:
+            print(f"Submit response is not JSON: {res.text[:200]}...")
+            return False
+    else:
+        print(f"Submit response has no text content")
+        return False
+    
+    # Check for various error conditions
+    if 'detail' in res_json and res_json['detail'] == 'Not found.':
+        print(f"{alpha_id} - Alpha ID not found")
+        return False
+    
+    # Check submission status
+    submitted = True
+    if 'is' in res_json and 'checks' in res_json['is']:
+        for item in res_json['is']['checks']:
+            if item['name'] == 'ALREADY_SUBMITTED':
+                submitted = False
+                print(f"{alpha_id} - Already submitted")
+                break
+            if item['result'] == 'FAIL':
+                submitted = False
+                print(f"{alpha_id} - {item['name']} check failed, limit = {item['limit']}, value = {item['value']}")
+                break
+    
+    if submitted:
+        print(f'{alpha_id} - Submission successful!')
+        return True
+    else:
+        return False
+
+def main():
+    """Main function to run the alpha submission script"""
+    print("=== WorldQuant Brain Alpha Submitter ===")
+    print("This script will help you submit alphas with automatic retry logic.")
+    print("You will be prompted to enter your WorldQuant Brain credentials.\n")
+    
+    # Login with user credentials
+    session = login()
+    if session is None:
+        print("Failed to login. Exiting.")
+        return
+    
+    print("\n=== Alpha Submission Mode ===")
+    print("Enter alpha IDs one by one. Type 'quit' to exit.")
+    print("Type 'relogin' to login with different credentials.")
+    print("Type 'info <alpha_id>' to check alpha details before submitting.")
+    
+    while True:
+        alpha_id = input("\nEnter alpha ID (or 'quit' to exit, 'relogin' to change credentials): ").strip()
+        
+        if alpha_id.lower() == 'quit':
+            print("Goodbye!")
+            break
+        
+        if alpha_id.lower() == 'relogin':
+            print("\nRe-logging in...")
+            session = login()
+            if session is None:
+                print("Failed to login. Exiting.")
+                return
+            continue
+        
+        if alpha_id.lower().startswith('info '):
+            info_alpha_id = alpha_id[5:].strip()
+            if not info_alpha_id:
+                print("Please provide an alpha ID after 'info'")
+                continue
+            
+            print(f"\nChecking details for alpha: {info_alpha_id}")
+            print("=" * 50)
+            
+            # Check if alpha exists
+            exists, alpha_data = check_alpha_exists(session, info_alpha_id)
+            if exists:
+                # Get record sets
+                get_alpha_recordsets(session, info_alpha_id)
+                
+                # Show some basic alpha info
+                if alpha_data:
+                    print(f"📋 Alpha Details:")
+                    print(f"   ID: {alpha_data.get('id', 'N/A')}")
+                    print(f"   Type: {alpha_data.get('type', 'N/A')}")
+                    if 'settings' in alpha_data:
+                        print(f"   Has settings: Yes")
+                    if 'regular' in alpha_data:
+                        print(f"   Has regular data: Yes")
+                    if 'combo' in alpha_data:
+                        print(f"   Has combo data: Yes")
+                    if 'selection' in alpha_data:
+                        print(f"   Has selection data: Yes")
+            
+            print("=" * 50)
+            continue
+        
+        if not alpha_id:
+            print("Please enter a valid alpha ID.")
+            continue
+        
+        print(f"\nSubmitting alpha: {alpha_id}")
+        print("=" * 50)
+        
+        success = submit_alpha(alpha_id, session)
+        
+        if success:
+            print(f"✅ Alpha {alpha_id} processed successfully!")
+        else:
+            print(f"❌ Alpha {alpha_id} failed to submit properly.")
+        
+        print("=" * 50)
+
+if __name__ == "__main__":
+    main()