cnhkmcp 2.3.3__py3-none-any.whl → 2.3.5__py3-none-any.whl

cnhkmcp/untracked/APP/trailSomeAlphas/skills/brain-feature-implementation/scripts/validator.py

@@ -65,51 +65,65 @@ supported_functions = {
     'ts_delay': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
     'ts_corr': {'min_args': 3, 'max_args': 3, 'arg_types': ['expression', 'expression', 'number']},
     'ts_zscore': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
-    'ts_returns': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'number'], 'param_names': ['x', 'd', 'mode']},
+    'ts_returns': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'number'], 'param_names': ['x', 'd', 'mode'], 'keyword_only': True},
     'ts_product': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
-    'ts_backfill': {'min_args': 2, 'max_args': 4, 'arg_types': ['expression', 'number', 'number', 'string']},
+    # Platform: ts_backfill(x, d)
+    'ts_backfill': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number'], 'param_names': ['x', 'd']},
     'days_from_last_change': {'min_args': 1, 'max_args': 1, 'arg_types': ['expression']},
     'last_diff_value': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
-    'ts_scale': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'number']},
-    'ts_entropy': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'expression', 'number'], 'param_names': ['x', 'd', 'buckets']},
+    # Platform: ts_scale(x, d, constant=0)
+    'ts_scale': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'number'], 'param_names': ['x', 'd', 'constant'], 'keyword_only': True},
+    # Platform: ts_entropy(x, d)
+    'ts_entropy': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number'], 'param_names': ['x', 'd']},
     'ts_step': {'min_args': 1, 'max_args': 1, 'arg_types': ['number']},
     'ts_sum': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
     'ts_co_kurtosis': {'min_args': 3, 'max_args': 3, 'arg_types': ['expression', 'expression', 'number']},
     'inst_tvr': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
-    'ts_decay_exp_window': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'number'], 'param_names': ['x', 'd', 'factor']},
+    'ts_decay_exp_window': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'number'], 'param_names': ['x', 'd', 'factor'], 'keyword_only': True},
     'ts_av_diff': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
     'ts_kurtosis': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
-    'ts_min_max_diff': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'number']},
+    # Platform: ts_min_max_diff(x, d, f=0.5)
+    'ts_min_max_diff': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'number'], 'param_names': ['x', 'd', 'f'], 'keyword_only': True},
     'ts_arg_max': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
     'ts_max': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
-    'ts_min_max_cps': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'number']},
-    'ts_rank': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'number']},
+    # Platform: ts_min_max_cps(x, d, f=2)
+    'ts_min_max_cps': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'number'], 'param_names': ['x', 'd', 'f'], 'keyword_only': True},
+    # Platform: ts_rank(x, d, constant=0)
+    'ts_rank': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'number'], 'param_names': ['x', 'd', 'constant'], 'keyword_only': True},
     'ts_ir': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
     'ts_theilsen': {'min_args': 3, 'max_args': 3, 'arg_types': ['expression', 'expression', 'number']},
-    'hump_decay': {'min_args': 1, 'max_args': 2, 'arg_types': ['expression', 'number']},
-    'ts_weighted_decay': {'min_args': 1, 'max_args': 2, 'arg_types': ['expression', 'number']},
-    'ts_quantile': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'string']},
+    # Platform: hump_decay(x, p=0)
+    'hump_decay': {'min_args': 1, 'max_args': 2, 'arg_types': ['expression', 'number'], 'param_names': ['x', 'p'], 'keyword_only': True},
+    # Platform: ts_weighted_decay(x, k=0.5)
+    'ts_weighted_decay': {'min_args': 1, 'max_args': 2, 'arg_types': ['expression', 'number'], 'param_names': ['x', 'k'], 'keyword_only': True},
+    # Platform: ts_quantile(x, d, driver="gaussian")
+    'ts_quantile': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'string'], 'param_names': ['x', 'd', 'driver'], 'keyword_only': True},
     'ts_min': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
     'ts_count_nans': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
     'ts_covariance': {'min_args': 3, 'max_args': 3, 'arg_types': ['expression', 'expression', 'number']},
     'ts_co_skewness': {'min_args': 3, 'max_args': 3, 'arg_types': ['expression', 'expression', 'number']},
     'ts_min_diff': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
-    'ts_decay_linear': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'boolean']},
-    'jump_decay': {'min_args': 2, 'max_args': 5, 'arg_types': ['expression', 'number', 'expression', 'number', 'number'], 'param_names': ['x', 'd', 'stddev', 'sensitivity', 'force']},
-    'ts_moment': {'min_args': 3, 'max_args': 3, 'arg_types': ['expression', 'number', 'number'], 'param_names': ['x', 'd', 'k']},
+    # Platform: ts_decay_linear(x, d, dense=false)
+    'ts_decay_linear': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'boolean'], 'param_names': ['x', 'd', 'dense'], 'keyword_only': True},
+    # Platform: jump_decay(x, d, sensitivity=0.5, force=0.1)
+    'jump_decay': {'min_args': 2, 'max_args': 4, 'arg_types': ['expression', 'number', 'number', 'number'], 'param_names': ['x', 'd', 'sensitivity', 'force'], 'keyword_only': True},
+    # Platform: ts_moment(x, d, k=0)
+    'ts_moment': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'number', 'number'], 'param_names': ['x', 'd', 'k'], 'keyword_only': True},
     'ts_arg_min': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
-    'ts_regression': {'min_args': 3, 'max_args': 5, 'arg_types': ['expression', 'expression', 'number', 'number', 'number'], 'param_names': ['y', 'x', 'd', 'lag', 'rettype']},
+    'ts_regression': {'min_args': 3, 'max_args': 5, 'arg_types': ['expression', 'expression', 'number', 'number', 'number'], 'param_names': ['y', 'x', 'd', 'lag', 'rettype'], 'keyword_only': True},
     'ts_skewness': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
     'ts_max_diff': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
     'kth_element': {'min_args': 3, 'max_args': 3, 'arg_types': ['expression', 'number', 'number']},
     'hump': {'min_args': 1, 'max_args': 2, 'arg_types': ['expression', 'number'], 'param_names': ['x', 'hump']},
     'ts_median': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
     'ts_delta': {'min_args': 2, 'max_args': 2, 'arg_types': ['expression', 'number']},
-    'ts_poly_regression': {'min_args': 3, 'max_args': 4, 'arg_types': ['expression', 'expression', 'number', 'number']},
-    'ts_target_tvr_decay': {'min_args': 1, 'max_args': 4, 'arg_types': ['expression', 'number', 'number', 'number'], 'param_names': ['x', 'lambda_min', 'lambda_max', 'target_tvr']},
-    'ts_target_tvr_delta_limit': {'min_args': 2, 'max_args': 5, 'arg_types': ['expression', 'expression', 'number', 'number', 'number']},
-    'ts_target_tvr_hump': {'min_args': 1, 'max_args': 4, 'arg_types': ['expression', 'number', 'number', 'number']},
-    'ts_delta_limit': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'expression', 'number']},
+    # Platform: ts_poly_regression(y, x, d, k=1) and k must be keyword if provided
+    'ts_poly_regression': {'min_args': 3, 'max_args': 4, 'arg_types': ['expression', 'expression', 'number', 'number'], 'param_names': ['y', 'x', 'd', 'k'], 'keyword_only': True, 'keyword_only_from': 3},
+    'ts_target_tvr_decay': {'min_args': 1, 'max_args': 4, 'arg_types': ['expression', 'number', 'number', 'number'], 'param_names': ['x', 'lambda_min', 'lambda_max', 'target_tvr'], 'keyword_only': True},
+    'ts_target_tvr_delta_limit': {'min_args': 2, 'max_args': 5, 'arg_types': ['expression', 'expression', 'number', 'number', 'number'], 'param_names': ['x', 'y', 'lambda_min', 'lambda_max', 'target_tvr'], 'keyword_only': True},
+    'ts_target_tvr_hump': {'min_args': 1, 'max_args': 4, 'arg_types': ['expression', 'number', 'number', 'number'], 'param_names': ['x', 'lambda_min', 'lambda_max', 'target_tvr'], 'keyword_only': True},
+    # Platform: ts_delta_limit(x, y, limit_volume=0.1)
+    'ts_delta_limit': {'min_args': 2, 'max_args': 3, 'arg_types': ['expression', 'expression', 'number'], 'param_names': ['x', 'y', 'limit_volume'], 'keyword_only': True},
     
     # Special 类别函数
     'inst_pnl': {'min_args': 1, 'max_args': 1, 'arg_types': ['expression']},
@@ -276,6 +290,10 @@ class ExpressionValidator:
         self.parser = yacc.yacc(module=self, debug=False)
         # 错误信息存储
         self.errors = []
+        # Cache for unit inference (unit/scalar/category)
+        self._unit_cache: Dict[int, str] = {}
+        # Cache for derived category detection (bucket/group_cartesian_product outputs)
+        self._derived_category_cache: Dict[int, bool] = {}
     
     # 词法分析器规则
     tokens = ('FUNCTION', 'FIELD', 'NUMBER', 'LPAREN', 'RPAREN', 
@@ -509,6 +527,12 @@ class ExpressionValidator:
             return self._validate_add(args, is_in_group_arg)
 
         errors = []
+
+        # Keyword-only enforcement for optional parameters.
+        # If enabled, only the required leading arguments can be positional.
+        keyword_only_from = function_info.get('keyword_only_from')
+        if keyword_only_from is None and function_info.get('keyword_only'):
+            keyword_only_from = function_info.get('min_args', 0)
         
         # 检查参数数量
         if len(args) < function_info['min_args']:
@@ -545,12 +569,14 @@ class ExpressionValidator:
                         errors.append(f"函数 {function_name} 不存在参数 '{arg['name']}'")
                 elif arg['type'] == 'positional':
                     # 位置参数（字典形式）
-                    # 对于winsorize函数，第二个参数必须是命名参数
-                    if function_name == 'winsorize' and positional_index == 1:
-                        errors.append(f"函数 {function_name} 的第二个参数必须使用命名参数 'std='")
-                    # 对于ts_moment函数，第三个参数必须是命名参数
-                    elif function_name == 'ts_moment' and positional_index == 2:
-                        errors.append(f"函数 {function_name} 的第三个参数必须使用命名参数 'k='")
+                    if keyword_only_from is not None and positional_index >= keyword_only_from:
+                        param_name = None
+                        if 'param_names' in function_info and positional_index < len(function_info['param_names']):
+                            param_name = function_info['param_names'][positional_index]
+                        if param_name:
+                            errors.append(f"函数 {function_name} 的第{positional_index+1}个参数必须使用命名参数 '{param_name}='")
+                        else:
+                            errors.append(f"函数 {function_name} 的第{positional_index+1}个参数必须使用命名参数")
                     else:
                         # 验证位置参数的类型
                         if positional_index < len(function_info['arg_types']):
@@ -564,12 +590,14 @@ class ExpressionValidator:
                     positional_index += 1
             else:
                 # 位置参数（直接ASTNode形式）
-                # 对于winsorize函数，第二个参数必须是命名参数
-                if function_name == 'winsorize' and positional_index == 1:
-                    errors.append(f"函数 {function_name} 的第二个参数必须使用命名参数 'std='")
-                # 对于ts_moment函数，第三个参数必须是命名参数
-                elif function_name == 'ts_moment' and positional_index == 2:
-                    errors.append(f"函数 {function_name} 的第三个参数必须使用命名参数 'k='")
+                if keyword_only_from is not None and positional_index >= keyword_only_from:
+                    param_name = None
+                    if 'param_names' in function_info and positional_index < len(function_info['param_names']):
+                        param_name = function_info['param_names'][positional_index]
+                    if param_name:
+                        errors.append(f"函数 {function_name} 的第{positional_index+1}个参数必须使用命名参数 '{param_name}='")
+                    else:
+                        errors.append(f"函数 {function_name} 的第{positional_index+1}个参数必须使用命名参数")
                 else:
                     # 验证位置参数的类型
                     if positional_index < len(function_info['arg_types']):
@@ -583,6 +611,16 @@ class ExpressionValidator:
     def _validate_arg_type(self, arg: ASTNode, expected_type: str, arg_index: int, function_name: str, is_in_group_arg: bool = False) -> List[str]:
         """验证参数类型是否符合预期"""
         errors = []
+
+        # Unit compatibility check
+        # bucket()/group_cartesian_product() output a derived category (grouping key).
+        # It can only be consumed where a category/grouping key is expected (typically by group_* operators).
+        # It must not flow into normal Unit[] inputs like ts_mean's first argument.
+        if self._is_derived_category(arg) and expected_type != 'category':
+            errors.append(
+                f"Incompatible unit for input of \"{function_name}\" at index {arg_index}, expected \"Unit[]\", found \"Unit[Group:1]\""
+            )
+            return errors
         
         # 首先检查是否是group类型字段，如果是则只能用于Group类型函数
         # 但是如果当前函数是group_xxx或在group函数的参数链中，则允许使用
@@ -618,6 +656,86 @@ class ExpressionValidator:
         
         return errors
 
+    def _infer_unit(self, node: ASTNode) -> str:
+        """Infer the Unit kind of an AST node.
+
+        Returns:
+            'unit'     - regular numeric time-series Unit[]
+            'scalar'   - literals (numbers/booleans/strings)
+            'category' - category/grouping keys (industry/sector or derived via bucket/cartesian)
+        """
+        if node is None:
+            return 'unit'
+
+        cache_key = id(node)
+        cached = self._unit_cache.get(cache_key)
+        if cached is not None:
+            return cached
+
+        unit = 'unit'
+
+        if node.node_type in {'number', 'boolean', 'string'}:
+            unit = 'scalar'
+        elif node.node_type in {'field', 'identifier'}:
+            unit = 'unit'
+        elif node.node_type == 'category':
+            unit = 'category'
+        elif node.node_type in {'unop', 'binop'}:
+            child_units = [self._infer_unit(child) for child in node.children if hasattr(child, 'node_type')]
+            unit = 'category' if 'category' in child_units else 'unit'
+        elif node.node_type == 'function':
+            fname = node.value
+            # Group-building functions create derived category outputs
+            if fname in {'bucket', 'group_cartesian_product'}:
+                unit = 'category'
+            else:
+                # Default: propagate from the first positional argument if available
+                first_arg = None
+                for child in node.children:
+                    if isinstance(child, dict):
+                        if child.get('type') == 'positional':
+                            first_arg = child.get('value')
+                            break
+                    else:
+                        first_arg = child
+                        break
+
+                if hasattr(first_arg, 'node_type'):
+                    unit = self._infer_unit(first_arg)
+                else:
+                    unit = 'unit'
+
+        self._unit_cache[cache_key] = unit
+        return unit
+
+    def _is_derived_category(self, node: ASTNode) -> bool:
+        """Return True if node is a derived category/grouping key (e.g., bucket/cartesian output)."""
+        if node is None:
+            return False
+
+        cache_key = id(node)
+        cached = self._derived_category_cache.get(cache_key)
+        if cached is not None:
+            return cached
+
+        derived = False
+        if node.node_type == 'function' and node.value in {'bucket', 'group_cartesian_product'}:
+            derived = True
+        elif node.node_type in {'unop', 'binop'}:
+            derived = any(
+                self._is_derived_category(child)
+                for child in node.children
+                if hasattr(child, 'node_type')
+            )
+        elif node.node_type == 'function':
+            derived = any(
+                self._is_derived_category(child.get('value')) if isinstance(child, dict) else self._is_derived_category(child)
+                for child in node.children
+            )
+
+        self._derived_category_cache[cache_key] = derived
+        return derived
+
     def _validate_add(self, args: List[Any], is_in_group_arg: bool = False) -> List[str]:
         """Validate add(x, y, ..., filter=false).
 
@@ -885,6 +1003,9 @@ class ExpressionValidator:
         """
         # 重置错误列表
         self.errors = []
+        # Reset unit inference cache for this expression
+        self._unit_cache = {}
+        self._derived_category_cache = {}
         
         try:
             expression = expression.strip()

cnhkmcp/untracked/APP//321/210/342/224/220/320/240/321/210/320/261/320/234/321/206/320/231/320/243/321/205/342/225/235/320/220/321/206/320/230/320/241.py

@@ -7,6 +7,14 @@ A complete web application for decoding string templates with WorldQuant BRAIN i
 import subprocess
 import sys
 import os
+import io
+
+# try set gbk problem
+try:
+    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
+except Exception as e:
+    print(e)
+    pass
 
 def install_requirements():
     """Install required packages from requirements.txt if they're missing"""
@@ -128,6 +136,7 @@ try:
     import queue
     import uuid
     from datetime import datetime
+    from blueprints.validator import ExpressionValidator
     print("📚 Core packages imported successfully!")
 
     # Import ace_lib for simulation options
@@ -407,6 +416,51 @@ def test_simulator_connection():
             'error': f'Connection failed: {str(e)}'
         })
 
+@app.route('/api/validate_expressions', methods=['POST'])
+def validate_expressions():
+    """Validate a list of expressions using ExpressionValidator"""
+    try:
+        data = request.json
+        expressions = data.get('expressions', [])
+        
+        if not isinstance(expressions, list):
+            return jsonify({'error': 'Expressions must be a list'}), 400
+            
+        validator = ExpressionValidator()
+        results = []
+        valid_count = 0
+        invalid_count = 0
+        
+        # Validate all expressions
+        expressions_to_validate = expressions
+        
+        for expr in expressions_to_validate:
+            validation_result = validator.check_expression(expr)
+            if validation_result['valid']:
+                valid_count += 1
+                results.append({
+                    'expression': expr,
+                    'valid': True
+                })
+            else:
+                invalid_count += 1
+                results.append({
+                    'expression': expr,
+                    'valid': False,
+                    'errors': validation_result['errors']
+                })
+        
+        return jsonify({
+            'results': results,
+            'summary': {
+                'total': len(expressions_to_validate),
+                'valid': valid_count,
+                'invalid': invalid_count
+            }
+        })
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
 @app.route('/api/simulator/run', methods=['POST'])
 def run_simulator_with_params():
     """Run simulator with user-provided parameters in a new terminal"""

cnhkmcp/untracked/arxiv_api.py

@@ -3,6 +3,13 @@ import xml.etree.ElementTree as ET
 import os
 import sys
 import argparse
+import io
+# try set gbk problem
+try:
+    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
+except Exception as e:
+    print(e)
+    pass
 
 def search_arxiv(query, max_results=10):
     """Search arXiv for papers"""

cnhkmcp/untracked/back_up/forum_functions.py

@@ -22,6 +22,14 @@ from selenium.common.exceptions import TimeoutException, NoSuchElementException
 import requests
 import os
 import shutil
+import io
+
+# try set gbk problem
+try:
+    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
+except Exception as e:
+    print(e)
+    pass
 
 # Initialize forum MCP server
 try:

cnhkmcp/untracked/forum_functions.py

@@ -15,6 +15,14 @@ from bs4 import BeautifulSoup
 from playwright.async_api import async_playwright
 import requests
 import os
+import io
+
+# try set gbk problem
+try:
+    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
+except Exception as e:
+    print(e)
+    pass
 
 def log(message: str, level: str = "INFO"):
     """Log message with timestamp."""

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/forum_functions.py

@@ -15,6 +15,14 @@ from bs4 import BeautifulSoup
 from playwright.async_api import async_playwright
 import requests
 import os
+import io
+
+# try set gbk problem
+try:
+    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
+except Exception as e:
+    print(e)
+    pass
 
 def log(message: str, level: str = "INFO"):
     """Log message with timestamp."""

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/platform_functions.py

@@ -18,7 +18,7 @@ import os
 import sys
 import math
 from time import sleep
-
+import io
 import requests
 import pandas as pd
 from mcp.server.fastmcp import FastMCP
@@ -29,6 +29,13 @@ from pathlib import Path
 # Import the new forum client
 from forum_functions import forum_client
 
+# try set gbk problem
+try:
+    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
+except Exception as e:
+    print(e)
+    pass
+
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)

cnhkmcp/untracked/platform_functions.py

@@ -18,6 +18,13 @@ import os
 import sys
 import math
 from time import sleep
+import io
+# try set gbk problem
+try:
+    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
+except Exception as e:
+    print(e)
+    pass
 
 import requests
 import pandas as pd