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

cnhkmcp/untracked/mcp/321/206/320/246/320/227/321/204/342/225/227/342/225/242/321/210/320/276/342/225/221/321/205/320/255/320/253/321/207/320/231/320/2302_/321/205/320/266/320/222/321/206/320/256/320/254/321/205/320/236/320/257/321/207/320/231/320/230/321/205/320/240/320/277/321/205/320/232/320/270/321/204/342/225/225/320/235/321/204/342/225/221/320/226/321/206/342/225/241/320/237/321/210/320/267/320/230/321/205/320/251/320/270/321/205/342/226/221/342/226/222/321/210/320/277/320/245/321/210/342/224/220/320/251/321/204/342/225/225/320/272/user_config.json

@@ -0,0 +1,31 @@
+{
+  "credentials": {
+    "email": "youremail@mai.com",
+      "password": "yourpassword"
+    },
+  "api_settings": {
+    "base_url": "https://api.worldquantbrain.com",
+    "timeout": 30,
+    "retry_attempts": 3
+  },
+  "forum_settings": {
+    "base_url": "https://support.worldquantbrain.com",
+    "headless": true,
+    "timeout": 30
+  },
+  "simulation_defaults": {
+    "type": "REGULAR",
+    "instrument_type": "EQUITY",
+    "region": "USA",
+    "universe": "TOP3000",
+    "delay": 1,
+    "decay": 0,
+    "neutralization": "NONE",
+    "truncation": 0,
+    "test_period": "P0Y0M",
+    "unit_handling": "NONE",
+    "nan_handling": "NONE",
+    "language": "FASTEXPR",
+    "visualization": true
+  }
+} 

cnhkmcp/untracked/mcp/321/206/320/246/320/227/321/204/342/225/227/342/225/242/321/210/320/276/342/225/221/321/205/320/255/320/253/321/207/320/231/320/2302_/321/205/320/266/320/222/321/206/320/256/320/254/321/205/320/236/320/257/321/207/320/231/320/230/321/205/320/240/320/277/321/205/320/232/320/270/321/204/342/225/225/320/235/321/204/342/225/221/320/226/321/206/342/225/241/320/237/321/210/320/267/320/230/321/205/320/251/320/270/321/205/342/226/221/342/226/222/321/210/320/277/320/245/321/210/342/224/220/320/251/321/204/342/225/225/320/272//321/210/320/276/320/271AI/321/210/320/277/342/225/227/321/210/342/224/220/320/251/321/204/342/225/225/320/272/321/206/320/246/320/227/321/206/320/261/320/263/321/206/320/255/320/265/321/205/320/275/320/266/321/204/342/225/235/320/252/321/204/342/225/225/320/233/321/210/342/225/234/342/225/234/321/206/342/225/241/320/237/321/210/320/267/320/230/321/205/320/251/320/270.md

@@ -0,0 +1,101 @@
+# Guide: Setting Up Playwright with a Local Chrome Executable
+
+This guide explains how to configure Playwright to use a locally extracted Google Chrome browser. This is useful in environments where you don't have `sudo` permissions to install Chrome or its dependencies system-wide.
+
+## The Problem
+
+When running a Playwright script, you might encounter an error like this:
+
+```
+playwright._impl._errors.Error: BrowserType.launch: Executable doesn't exist at ...
+```
+
+This means Playwright cannot find the Chrome browser executable in its default search paths.
+
+## The Solution: Local Extraction
+
+The solution is to download the Chrome `.deb` package, extract the executable, and then point your Playwright script to it.
+
+### Step 0: pip install playwright
+
+Before you begin, make sure you have Playwright installed. You can install it using pip:
+
+```bash
+pip install playwright
+```
+
+### Step 1: Download the Chrome `.deb` Package
+
+You can download the latest stable version of Google Chrome for Debian/Ubuntu-based systems using `wget`:
+
+```bash
+wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
+```
+
+### Step 2: Extract the Executable
+
+Once you have the `.deb` file, you can extract its contents without installing it.
+
+1.  **Extract the `.deb` archive:** The `ar` command extracts the contents of the `.deb` file.
+
+    ```bash
+    ar x google-chrome-stable_current_amd64.deb
+    ```
+
+    This will create several files, including `data.tar.xz`.
+
+2.  **Extract the data archive:** The `data.tar.xz` file contains the actual program files.
+
+    ```bash
+    tar -xf data.tar.xz
+    ```
+
+    This will create an `opt` directory in your current location.
+
+### Step 3: Locate the Chrome Executable
+
+The Chrome executable is now located at `./opt/google/chrome/chrome`.
+
+### Step 4: Configure Your Playwright Script
+
+In your Python script forum_functions.py, you need to tell Playwright where to find the Chrome executable by using the `executable_path` argument when launching the browser.
+
+It is best practice to use an **absolute path** to avoid issues with the script's working directory. You can construct the absolute path by combining your project's root directory with the relative path to the executable.
+
+Here is an example:
+
+```python
+import os
+from playwright.async_api import async_playwright
+import asyncio
+
+async def main():
+    # Get the absolute path to the executable
+    project_dir = os.getcwd() # Or specify your project's absolute path
+    executable_path = os.path.join(project_dir, 'opt/google/chrome/chrome')
+
+    async with async_playwright() as p:
+        browser = await p.chromium.launch(
+            executable_path=executable_path,
+            args=['--headless=new', '--no-sandbox']
+        )
+        page = await browser.new_page()
+        await page.goto('http://playwright.dev')
+        print(await page.title())
+        await browser.close()
+
+if __name__ == '__main__':
+    asyncio.run(main())
+```
+
+By providing the absolute `executable_path`, you are explicitly telling Playwright where to find the browser, making your script more robust.
+
+## Alternative: `playwright install`
+
+If you have `sudo` permissions, the recommended way to install the browsers for Playwright is to use the following command:
+
+```bash
+playwright install --with-deps
+```
+
+This will download the browser and also install all the necessary system dependencies.

cnhkmcp/untracked/mcp/321/206/320/246/320/227/321/204/342/225/227/342/225/242/321/210/320/276/342/225/221/321/205/320/255/320/253/321/207/320/231/320/2302_/321/205/320/266/320/222/321/206/320/256/320/254/321/205/320/236/320/257/321/207/320/231/320/230/321/205/320/240/320/277/321/205/320/232/320/270/321/204/342/225/225/320/235/321/204/342/225/221/320/226/321/206/342/225/241/320/237/321/210/320/267/320/230/321/205/320/251/320/270/321/205/342/226/221/342/226/222/321/210/320/277/320/245/321/210/342/224/220/320/251/321/204/342/225/225/320/272//321/211/320/225/320/235/321/207/342/225/234/320/276/321/205/320/231/320/235/321/210/342/224/220/320/240/321/210/320/261/320/234/321/206/320/230/320/241_/321/205/320/276/320/231/321/210/320/263/320/225/321/205/342/224/220/320/225/321/210/320/266/320/221/321/204/342/225/233/320/255/321/210/342/225/241/320/246/321/205/320/234/320/225.py

@@ -0,0 +1,190 @@
+"""
+check_install_packages.py
+
+Simple script that hardcodes the project's required packages and ensures they are installed
+before running the server or tests. It will install missing packages (or upgrade if below
+required version) by invoking pip via the running Python interpreter.
+
+Usage: python check_install_packages.py
+
+This script is intentionally conservative: it uses the distribution/package names from
+`requirements.txt` and calls pip to install the exact spec (e.g. "requests>=2.31.0").
+It prints a concise summary at the end.
+"""
+
+from __future__ import annotations
+import sys
+import subprocess
+import importlib
+import importlib.metadata
+import re
+from typing import List, Tuple, Optional
+
+# Hardcoded package requirements (from requirements.txt)
+REQUIRED_PACKAGES: List[str] = [
+    "fastmcp>=0.1.0",
+    "requests>=2.31.0",
+    "pandas>=2.0.0",
+    "selenium>=4.15.0",
+    "beautifulsoup4>=4.12.0",
+    "pydantic>=2.0.0",
+    "email-validator>=2.0.0",
+    "aiohttp>=3.8.0",
+    "webdriver-manager>=4.0.0"
+]
+
+
+def parse_spec(spec: str) -> Tuple[str, Optional[str]]:
+    """Return (name, min_version) for a spec like 'pkg>=1.2.3'."""
+    if ">=" in spec:
+        name, ver = spec.split(">=", 1)
+        return name.strip(), ver.strip()
+    return spec.strip(), None
+
+
+def version_tuple(v: str) -> List[int]:
+    parts = re.split(r"[^0-9]+", v)
+    nums = []
+    for p in parts:
+        if p == "":
+            continue
+        try:
+            nums.append(int(p))
+        except ValueError:
+            # Non-numeric part, stop parsing further
+            break
+    return nums
+
+
+def is_version_sufficient(installed: str, required: str) -> bool:
+    if not installed:
+        return False
+    try:
+        i_parts = version_tuple(installed)
+        r_parts = version_tuple(required)
+        # Compare element-wise
+        for a, b in zip(i_parts, r_parts):
+            if a > b:
+                return True
+            if a < b:
+                return False
+        # If equal up to the length of required, installed is sufficient if it's at least as long
+        return len(i_parts) >= len(r_parts)
+    except Exception:
+        return False
+
+
+def install_package(spec: str) -> Tuple[bool, str]:
+    """Install a package spec using pip. Streams output live and returns (success, output)."""
+    # Use -v for verbose pip output; capture stdout/stderr while streaming to console
+    cmd = [sys.executable, "-m", "pip", "install", "-v", spec]
+    try:
+        proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+        output_lines = []
+        if proc.stdout:
+            for line in proc.stdout:
+                output_lines.append(line)
+                # print each pip line as it arrives for visibility
+                try:
+                    print(line.rstrip())
+                except Exception:
+                    # fallback: print raw line
+                    print(line)
+        proc.wait()
+        out = "".join(output_lines)
+        success = proc.returncode == 0
+        return success, out
+    except Exception as e:
+        return False, str(e)
+
+
+def main():
+    results = []
+    print("Checking required packages...\n")
+    for spec in REQUIRED_PACKAGES:
+        name, min_ver = parse_spec(spec)
+        installed_ver = None
+        try:
+            installed_ver = importlib.metadata.version(name)
+        except importlib.metadata.PackageNotFoundError:
+            installed_ver = None
+        except Exception:
+            # Some packages may have different distribution vs import names; try best-effort
+            installed_ver = None
+
+        needs_install = False
+        action = "present"
+        if installed_ver is None:
+            needs_install = True
+            action = "install"
+        elif min_ver is not None:
+            if not is_version_sufficient(installed_ver, min_ver):
+                needs_install = True
+                action = f"upgrade (installed {installed_ver} < required {min_ver})"
+
+        if needs_install:
+            print(f"-> {name}: {action} via pip ({spec})")
+            success, output = install_package(spec)
+            # Attempt to read installed version after install
+            installed_after = None
+            if success:
+                try:
+                    installed_after = importlib.metadata.version(name)
+                except Exception:
+                    installed_after = None
+                if installed_after:
+                    print(f"   -> {name} now installed as: {installed_after}")
+
+            results.append({
+                "name": name,
+                "spec": spec,
+                "installed_version_before": installed_ver,
+                "installed_version_after": installed_after,
+                "action": action,
+                "success": success,
+                "output": output
+            })
+        else:
+            print(f"-> {name}: OK (installed: {installed_ver})")
+            results.append({
+                "name": name,
+                "spec": spec,
+                "installed_version_before": installed_ver,
+                "action": "none",
+                "success": True,
+                "output": ""
+            })
+
+    # Summary
+    print("\nSummary:")
+    installed_count = sum(1 for r in results if r["success"] and r["action"] == "none")
+    installed_or_fixed = sum(1 for r in results if r["success"] and r["action"] != "none")
+    failed = [r for r in results if not r["success"]]
+
+    print(f"  Packages already OK: {installed_count}")
+    print(f"  Packages installed/upgraded by this script: {installed_or_fixed}")
+    print(f"  Packages failed to install: {len(failed)}")
+    if failed:
+        for f in failed:
+            print(f"    - {f['name']}: attempted '{f['spec']}' -> error (see details below)")
+
+    # If any failed, print their outputs for debugging
+    if failed:
+        print("\nFailed install details:\n")
+        for f in failed:
+            print("-----")
+            print(f"Package: {f['name']}")
+            print(f"Spec: {f['spec']}")
+            print(f"Installed before: {f.get('installed_version_before')}")
+            print(f"Installed after: {f.get('installed_version_after')}")
+            print("Output:")
+            print(f.get("output", "(no output)"))
+
+    print("\nDone.")
+    # Exit with non-zero code if any install failed
+    if failed:
+        sys.exit(2)
+
+
+if __name__ == "__main__":
+    main()