aimodelshare 0.1.21__py3-none-any.whl → 0.1.62__py3-none-any.whl

aimodelshare/model.py

@@ -23,6 +23,256 @@ from aimodelshare.utils import ignore_warning
 import warnings
 
 
+def _normalize_eval_payload(raw_eval):
+    """
+    Normalize the API response eval payload to (public_eval_dict, private_eval_dict).
+    
+    Handles multiple response formats:
+    - {"eval": [public_dict, private_dict]}  -> extract both dicts
+    - {"eval": public_dict}                   -> public_dict, {}
+    - {"eval": None} or missing              -> {}, {}
+    - Malformed responses                     -> {}, {} with warning
+    
+    Args:
+        raw_eval: The raw API response (expected to be dict with 'eval' key)
+        
+    Returns:
+        tuple: (public_eval_dict, private_eval_dict) - both guaranteed to be dicts
+    """
+    public_eval = {}
+    private_eval = {}
+    
+    if not isinstance(raw_eval, dict):
+        print("---------------------------------------------------------------")
+        print(f"--- WARNING: API response is not a dict (type={type(raw_eval)}) ---")
+        print("Defaulting to empty eval metrics.")
+        print("---------------------------------------------------------------")
+        return public_eval, private_eval
+    
+    eval_field = raw_eval.get('eval')
+    
+    if eval_field is None:
+        # No eval field present
+        return public_eval, private_eval
+    
+    if isinstance(eval_field, list):
+        # Expected format: [public_dict, private_dict, ...]
+        if len(eval_field) >= 1 and isinstance(eval_field[0], dict):
+            public_eval = eval_field[0]
+        if len(eval_field) >= 2 and isinstance(eval_field[1], dict):
+            private_eval = eval_field[1]
+        elif len(eval_field) >= 1:
+            # Only one dict in list, treat as public
+            if not public_eval:
+                public_eval = {}
+    elif isinstance(eval_field, dict):
+        # Single dict, treat as public eval
+        public_eval = eval_field
+    else:
+        print("---------------------------------------------------------------")
+        print(f"--- WARNING: 'eval' field has unexpected type: {type(eval_field)} ---")
+        print("Defaulting to empty eval metrics.")
+        print("---------------------------------------------------------------")
+    
+    return public_eval, private_eval
+
+
+def _subset_numeric(metrics_dict, keys_to_extract):
+    """
+    Safely extract a subset of numeric metrics from a metrics dictionary.
+    
+    Args:
+        metrics_dict: Dictionary containing metric key-value pairs
+        keys_to_extract: List of keys to extract from the dictionary
+        
+    Returns:
+        dict: Subset of metrics that exist and have numeric (float/int) values
+    """
+    if not isinstance(metrics_dict, dict):
+        print("---------------------------------------------------------------")
+        print(f"--- WARNING: metrics_dict is not a dict (type={type(metrics_dict)}) ---")
+        print("Returning empty metrics subset.")
+        print("---------------------------------------------------------------")
+        return {}
+    
+    subset = {}
+    for key in keys_to_extract:
+        value = metrics_dict.get(key)
+        if value is not None and isinstance(value, (int, float)):
+            subset[key] = value
+    
+    return subset
+
+
+def _prepare_preprocessor_if_function(preprocessor, debug_mode=False):
+    """Prepare a preprocessor for submission.
+    Accepts:
+      - None: returns None
+      - Path to existing preprocessor zip (.zip)
+      - Callable function: exports source or pickled callable with loader
+      - Transformer object (e.g., sklearn Pipeline/ColumnTransformer) with .transform: pickles object + loader
+    Returns: absolute path to created or existing preprocessor zip, or None.
+    Raises: RuntimeError with actionable message on failure.
+    """
+    import inspect
+    import tempfile
+    import zipfile
+    import pickle
+    import textwrap
+    
+    if preprocessor is None:
+        return None
+
+    # Existing zip path
+    if isinstance(preprocessor, str) and preprocessor.endswith('.zip'):
+        if not os.path.exists(preprocessor):
+            raise RuntimeError(f"Preprocessor export failed: zip path not found: {preprocessor}")
+        if debug_mode:
+            print(f"[DEBUG] Using existing preprocessor zip: {preprocessor}")
+        return preprocessor
+
+    # Determine if transformer object
+    is_transformer_obj = hasattr(preprocessor, 'transform') and not inspect.isfunction(preprocessor)
+
+    serialize_object = None
+    export_callable = None
+
+    if is_transformer_obj:
+        if debug_mode:
+            print('[DEBUG] Detected transformer object; preparing wrapper.')
+        transformer_obj = preprocessor
+
+        def _wrapped_preprocessor(data):
+            return transformer_obj.transform(data)
+        export_callable = _wrapped_preprocessor
+        serialize_object = transformer_obj  # pickle the transformer
+
+    elif callable(preprocessor):
+        export_callable = preprocessor
+    else:
+        raise RuntimeError(
+            f"Preprocessor export failed: Unsupported type {type(preprocessor)}. "
+            "Provide a callable, transformer with .transform, an existing .zip path, or None."
+        )
+
+    tmp_dir = tempfile.mkdtemp()
+    py_path = os.path.join(tmp_dir, 'preprocessor.py')
+    zip_path = os.path.join(tmp_dir, 'preprocessor.zip')
+    pkl_name = 'preprocessor.pkl'
+
+    source_written = False
+    # Attempt direct source extraction if not a transformer serialization
+    if serialize_object is None:
+        try:
+            src = inspect.getsource(export_callable)
+            with open(py_path, 'w') as f:
+                f.write(src)
+            source_written = True
+            if debug_mode:
+                print('[DEBUG] Wrote source for callable preprocessor.')
+        except Exception as e:
+            if debug_mode:
+                print(f'[DEBUG] Source extraction failed; falling back to pickled callable: {e}')
+            serialize_object = export_callable  # fallback to pickling callable
+
+    # If transformer or fallback pickled callable: write loader stub
+    if serialize_object is not None and not source_written:
+        loader_stub = textwrap.dedent(f"""
+        import pickle, os
+        _PKL_FILE = '{pkl_name}'
+        _loaded_obj = None
+        def preprocessor(data):
+            global _loaded_obj
+            if _loaded_obj is None:
+                with open(os.path.join(os.path.dirname(__file__), _PKL_FILE), 'rb') as pf:
+                    _loaded_obj = pickle.load(pf)
+            # If original object was a transformer it has .transform; else callable
+            if hasattr(_loaded_obj, 'transform'):
+                return _loaded_obj.transform(data)
+            return _loaded_obj(data)
+        """)
+        with open(py_path, 'w') as f:
+            f.write(loader_stub)
+        if debug_mode:
+            print('[DEBUG] Wrote loader stub for pickled object.')
+
+    # Serialize object if needed
+    if serialize_object is not None:
+        try:
+            with open(os.path.join(tmp_dir, pkl_name), 'wb') as pf:
+                pickle.dump(serialize_object, pf)
+            if debug_mode:
+                print('[DEBUG] Pickled transformer/callable successfully.')
+        except Exception as e:
+            raise RuntimeError(f'Preprocessor export failed: pickling failed: {e}')
+
+    # Create zip
+    try:
+        with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zf:
+            zf.write(py_path, arcname='preprocessor.py')
+            pkl_path = os.path.join(tmp_dir, pkl_name)
+            if os.path.exists(pkl_path):
+                zf.write(pkl_path, arcname=pkl_name)
+    except Exception as e:
+        raise RuntimeError(f'Preprocessor export failed: zip creation error: {e}')
+
+    # Final validation
+    if not os.path.exists(zip_path) or os.path.getsize(zip_path) == 0:
+        raise RuntimeError(f'Preprocessor export failed: zip file not found or empty at {zip_path}')
+
+    if debug_mode:
+        print(f'[DEBUG] Preprocessor zip created: {zip_path}')
+    return zip_path
+
+
+def _diagnose_closure_variables(preprocessor_fxn):
+    """
+    Diagnose closure variables for serialization issues.
+    
+    Args:
+        preprocessor_fxn: Function to diagnose
+        
+    Logs:
+        INFO for successful serialization of each closure object
+        WARNING for failed serialization attempts
+    """
+    import inspect
+    import pickle
+    import logging
+    
+    # Get closure variables
+    closure_vars = inspect.getclosurevars(preprocessor_fxn)
+    all_globals = closure_vars.globals
+    
+    if not all_globals:
+        logging.info("No closure variables detected in preprocessor function")
+        return
+    
+    logging.info(f"Analyzing {len(all_globals)} closure variables...")
+    
+    successful = []
+    failed = []
+    
+    for var_name, var_value in all_globals.items():
+        try:
+            # Attempt to pickle the object
+            pickle.dumps(var_value)
+            successful.append(var_name)
+            logging.info(f"✓ Closure variable '{var_name}' (type: {type(var_value).__name__}) is serializable")
+        except Exception as e:
+            failed.append((var_name, type(var_value).__name__, str(e)))
+            logging.warning(f"✗ Closure variable '{var_name}' (type: {type(var_value).__name__}) failed serialization: {e}")
+    
+    # Summary
+    if failed:
+        failure_summary = "; ".join([f"{name} ({vtype})" for name, vtype, _ in failed])
+        logging.warning(f"Serialization failures detected: {failure_summary}")
+    else:
+        logging.info(f"All {len(successful)} closure variables are serializable")
+    
+    return successful, failed
+
+
 def _get_file_list(client, bucket,keysubfolderid):
     #  Reading file list {{{
     try:
@@ -140,10 +390,10 @@ def _upload_preprocessor(preprocessor, client, bucket, model_id, model_version):
 
 
 def _update_leaderboard(
-    modelpath, eval_metrics, client, bucket, model_id, model_version, onnx_model=None
+    modelpath, eval_metrics, client, bucket, model_id, model_version, onnx_model=None, custom_metadata=None
 ):
     # Loading the model and its metadata {{{
-    if onnx_model==None:
+    if onnx_model is not None:
         metadata = _get_leaderboard_data(onnx_model, eval_metrics)
 
     elif modelpath is not None:
@@ -154,13 +404,9 @@ def _update_leaderboard(
         metadata = _get_leaderboard_data(model, eval_metrics)
 
     else: 
-        metadata = eval_metrics
-        # get general model info
-        metadata['ml_framework'] = 'unknown'
-        metadata['transfer_learning'] = None
-        metadata['deep_learning'] = None
-        metadata['model_type'] = 'unknown'
-        metadata['model_config'] = None
+        # No ONNX model available - use _get_leaderboard_data with None
+        # This will safely inject defaults
+        metadata = _get_leaderboard_data(None, eval_metrics)
 
     if custom_metadata is not None: 
 
@@ -245,7 +491,7 @@ def _update_leaderboard_public(
     model_version=model_versions[0]
     
 
-    if modelpath == None and onnx_model:
+    if onnx_model is not None:
         metadata = _get_leaderboard_data(onnx_model, eval_metrics)
 
     elif modelpath is not None:
@@ -253,15 +499,9 @@ def _update_leaderboard_public(
         metadata = _get_leaderboard_data(onnx_model, eval_metrics)
 
     else: 
-
-        metadata = eval_metrics
-
-        # get general model info
-        metadata['ml_framework'] = 'unknown'
-        metadata['transfer_learning'] = None
-        metadata['deep_learning'] = None
-        metadata['model_type'] = 'unknown'
-        metadata['model_config'] = None
+        # No ONNX model available - use _get_leaderboard_data with None
+        # This will safely inject defaults
+        metadata = _get_leaderboard_data(None, eval_metrics)
 
 
     if custom_metadata is not None: 
@@ -345,6 +585,97 @@ def _update_leaderboard_public(
 
  
 
+def _normalize_model_config(model_config, model_type=None):
+    """
+    Normalize model_config to a dict, handling various input types.
+    
+    Args:
+        model_config: Can be None, dict, or string representation of dict
+        model_type: Optional model type for context in warnings
+        
+    Returns:
+        dict: Normalized model config, or empty dict if normalization fails
+    """
+    import ast
+    
+    # If already a dict, return as-is
+    if isinstance(model_config, dict):
+        return model_config
+    
+    # If None or other non-string type, return empty dict
+    if not isinstance(model_config, str):
+        if model_config is not None:
+            print(f"Warning: model_config is {type(model_config).__name__}, expected str or dict. Using empty config.")
+        return {}
+    
+    # Try to parse string to dict
+    try:
+        import astunparse
+        
+        tree = ast.parse(model_config)
+        stringconfig = model_config
+        
+        # Find and quote callable nodes
+        problemnodes = []
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Call):
+                problemnodes.append(astunparse.unparse(node).replace("\n", ""))
+        
+        problemnodesunique = set(problemnodes)
+        for i in problemnodesunique:
+            stringconfig = stringconfig.replace(i, "'" + i + "'")
+        
+        # Parse the modified string
+        model_config_dict = ast.literal_eval(stringconfig)
+        return model_config_dict if isinstance(model_config_dict, dict) else {}
+        
+    except Exception as e:
+        print(f"Warning: Failed to parse model_config string: {e}. Using empty config.")
+        return {}
+
+
+def _build_sklearn_param_dataframe(model_type, model_config):
+    """
+    Build parameter inspection DataFrame for sklearn/xgboost models.
+    
+    Creates a DataFrame with aligned columns by taking the union of default
+    parameters and model_config parameters. This ensures equal-length arrays
+    even when model_config contains extra parameters or is missing defaults.
+    
+    Args:
+        model_type: String name of the sklearn model class
+        model_config: Dict of model configuration parameters
+        
+    Returns:
+        pd.DataFrame: DataFrame with param_name, default_value, param_value columns,
+                     or empty DataFrame on error
+    """
+    import pandas as pd
+    import warnings
+    
+    try:
+        model_class = model_from_string(model_type)
+        default_instance = model_class()
+        defaults_dict = default_instance.get_params()
+        
+        # Take union of keys from both sources to ensure all parameters are included
+        # This prevents ValueError: "All arrays must be of the same length"
+        # when model_config has different keys than defaults
+        param_names = sorted(set(defaults_dict.keys()) | set(model_config.keys()))
+        default_values = [defaults_dict.get(k, None) for k in param_names]
+        param_values = [model_config.get(k, None) for k in param_names]
+        
+        return pd.DataFrame({
+            'param_name': param_names,
+            'default_value': default_values,
+            'param_value': param_values
+        })
+    except Exception as e:
+        # Log warning and fallback to empty DataFrame
+        warnings.warn(f"Failed to instantiate model class for {model_type}: {e}")
+        return pd.DataFrame()
+
+
 def upload_model_dict(modelpath, s3_presigned_dict, bucket, model_id, model_version, placeholder=False, onnx_model=None):
     import wget
     import json
@@ -365,59 +696,27 @@ def upload_model_dict(modelpath, s3_presigned_dict, bucket, model_id, model_vers
             
         elif meta_dict['ml_framework'] in ['sklearn', 'xgboost']:
 
-            model_config = meta_dict["model_config"]
-            tree = ast.parse(model_config)
-
-            stringconfig=model_config
-
-            problemnodes=[]
-            for node in ast.walk(tree):
-                if isinstance(node, ast.Call):
-                    problemnodes.append(astunparse.unparse(node).replace("\n",""))
-
-            problemnodesunique=set(problemnodes)
-            for i in problemnodesunique:
-                stringconfig=stringconfig.replace(i,"'"+i+"'")
-
-            try:
-                model_config=ast.literal_eval(stringconfig)
-                model_class = model_from_string(meta_dict['model_type'])
-                default = model_class()
-                default_config = default.get_params().values()
-                model_configkeys=model_config.keys()
-                model_configvalues=model_config.values()
-            except:
-                model_class = str(model_from_string(meta_dict['model_type']))
-                if model_class.find("Voting")>0:
-                      default_config = ["No data available"]
-                      model_configkeys=["No data available"]
-                      model_configvalues=["No data available"]
-
-
-            inspect_pd = pd.DataFrame({'param_name': model_configkeys,
-                                        'default_value': default_config,
-                                        'param_value': model_configvalues})
+            # Normalize model_config to dict (handles None, dict, or string)
+            model_config = _normalize_model_config(
+                meta_dict.get("model_config"), 
+                meta_dict.get('model_type')
+            )
+            
+            # Build parameter inspection DataFrame
+            inspect_pd = _build_sklearn_param_dataframe(
+                meta_dict['model_type'], 
+                model_config
+            )
 
         elif meta_dict['ml_framework'] in ['pyspark']:
-            import ast
-            import astunparse
-
-            model_config = meta_dict["model_config"]
-            tree = ast.parse(model_config)
-
-            stringconfig=model_config
-
-            problemnodes=[]
-            for node in ast.walk(tree):
-                if isinstance(node, ast.Call):
-                    problemnodes.append(astunparse.unparse(node).replace("\n",""))
-
-            problemnodesunique=set(problemnodes)
-            for i in problemnodesunique:
-                stringconfig=stringconfig.replace(i,"'"+i+"'")
+            
+            # Normalize model_config to dict (handles None, dict, or string)
+            model_config_temp = _normalize_model_config(
+                meta_dict.get("model_config"), 
+                meta_dict.get('model_type')
+            )
 
             try:
-                model_config_temp = ast.literal_eval(stringconfig)
                 model_class = pyspark_model_from_string(meta_dict['model_type'])
                 default = model_class()
 
@@ -435,10 +734,15 @@ def upload_model_dict(modelpath, s3_presigned_dict, bucket, model_id, model_vers
                 default_config = default_config.values()
             except:
                 model_class = str(pyspark_model_from_string(meta_dict['model_type']))
-                if model_class.find("Voting")>0:
-                      default_config = ["No data available"]
-                      model_configkeys=["No data available"]
-                      model_configvalues=["No data available"]
+                if model_class.find("Voting") > 0:
+                    default_config = ["No data available"]
+                    model_configkeys = ["No data available"]
+                    model_configvalues = ["No data available"]
+                else:
+                    # Fallback for other exceptions
+                    default_config = []
+                    model_configkeys = []
+                    model_configvalues = []
 
             inspect_pd = pd.DataFrame({'param_name': model_configkeys,
                                         'default_value': default_config,
@@ -557,7 +861,8 @@ def submit_model(
     custom_metadata=None,
     submission_type="competition",
     input_dict = None,
-    print_output=True
+    print_output=True,
+    debug_preprocessor=False
     ):
     """
     Submits model/preprocessor to machine learning competition using live prediction API url generated by AI Modelshare library
@@ -586,6 +891,10 @@ def submit_model(
                                 [OPTIONAL] to be set by the user
                                 "./reproducibility.json" 
                                 file is generated using export_reproducibility_env function from the AI Modelshare library
+    debug_preprocessor: boolean, default=False
+                        value - enable detailed diagnostics for preprocessor closure variable serialization
+                        [OPTIONAL] when True, logs detailed information about which closure variables 
+                        succeeded or failed serialization
     -----------------
     Returns
     response:   Model version if the model is submitted sucessfully
@@ -602,27 +911,21 @@ def submit_model(
         pass
 
 
-    # check whether preprocessor is function
-    import types
-    if isinstance(preprocessor, types.FunctionType): 
-        from aimodelshare.preprocessormodules import export_preprocessor
-        temp_prep=tmp.mkdtemp()
-        export_preprocessor(preprocessor,temp_prep)
-        preprocessor = temp_prep+"/preprocessor.zip"
+    # check whether preprocessor is function and validate export
+    preprocessor = _prepare_preprocessor_if_function(preprocessor, debug_mode=debug_preprocessor)
 
 
 
     import os
     from aimodelshare.aws import get_aws_token
-    from aimodelshare.modeluser import get_jwt_token, create_user_getkeyandpassword
+    from aimodelshare.modeluser import get_jwt_token
     import ast
 
-    # Confirm that creds are loaded, print warning if not
-    if all(["username" in os.environ, 
-            "password" in os.environ]):
-        pass
-    else:
-        return print("'Submit Model' unsuccessful. Please provide username and password using set_credentials() function.")
+    # Confirm that creds are loaded, raise error if not
+    # NOTE: Replaced 'return print(...)' with raise to prevent silent None propagation
+    if not all(["username" in os.environ, 
+                "password" in os.environ]):
+        raise RuntimeError("'Submit Model' unsuccessful. Please provide username and password using set_credentials() function.")
 
 
     ##---Step 2: Get bucket and model_id for playground and check prediction submission structure
@@ -719,61 +1022,76 @@ def submit_model(
         import requests
         prediction = requests.post(apiurl_eval,headers=headers,data=json.dumps(post_dict)) 
 
-    eval_metrics=json.loads(prediction.text)
-
-
-    eval_metrics_private = {"eval": eval_metrics['eval'][1]}
-    eval_metrics["eval"] = eval_metrics['eval'][0] 
-
-    if all([isinstance(eval_metrics, dict),"message" not in eval_metrics]):
-        pass        
-    else:
-        if all([isinstance(eval_metrics, list)]):
-            print(eval_metrics[0])
+    # Parse the raw API response
+    eval_metrics_raw = json.loads(prediction.text)
+    
+    # Validate API response structure
+    # NOTE: Replaced 'return print(...)' with raise to prevent silent None propagation
+    if not isinstance(eval_metrics_raw, dict):
+        if isinstance(eval_metrics_raw, list):
+            error_msg = str(eval_metrics_raw[0]) if eval_metrics_raw else "Empty list response"
+            raise RuntimeError(f'Unauthorized user: {error_msg}')
         else:
-            return print('Unauthorized user: You do not have access to submit models to, or request data from, this competition.')
-
-
-    if all(value == None for value in eval_metrics.values()):
-        return print("Failed to calculate evaluation metrics. Please check the format of the submitted predictions.")
-
-    s3_presigned_dict = {key:val for key, val in eval_metrics.items() if key != 'eval'}
-
-    idempotentmodel_version=s3_presigned_dict['idempotentmodel_version']
+            raise RuntimeError('Unauthorized user: You do not have access to submit models to, or request data from, this competition.')
+    
+    if "message" in eval_metrics_raw:
+        raise RuntimeError(f'Unauthorized user: {eval_metrics_raw.get("message", "You do not have access to submit models to, or request data from, this competition.")}')
+    
+    # Extract S3 presigned URL structure separately (before normalizing eval metrics)
+    s3_presigned_dict = {key: val for key, val in eval_metrics_raw.items() if key != 'eval'}
+    
+    if 'idempotentmodel_version' not in s3_presigned_dict:
+        raise RuntimeError("Failed to get model version from API. Please check the API response.")
+    
+    idempotentmodel_version = s3_presigned_dict['idempotentmodel_version']
     s3_presigned_dict.pop('idempotentmodel_version')
-
-    eval_metrics = {key:val for key, val in eval_metrics.items() if key != 'get'}
-    eval_metrics = {key:val for key, val in eval_metrics.items() if key != 'put'}
-
-    eval_metrics_private = {key:val for key, val in eval_metrics_private.items() if key != 'get'}
-    eval_metrics_private = {key:val for key, val in eval_metrics_private.items() if key != 'put'}
-
-
-    if eval_metrics.get("eval","empty")=="empty":
-      pass
-    else:
-      eval_metrics=eval_metrics['eval']
-
-
-    if eval_metrics_private.get("eval","empty")=="empty":
-      pass
-    else:
-      eval_metrics_private=eval_metrics_private['eval']
+    
+    # Normalize eval metrics using helper function
+    # This returns (public_eval_dict, private_eval_dict) regardless of API response shape
+    eval_metrics, eval_metrics_private = _normalize_eval_payload(eval_metrics_raw)
+    
+    # Check if we got any valid metrics
+    if not eval_metrics and not eval_metrics_private:
+        print("---------------------------------------------------------------")
+        print("--- WARNING: No evaluation metrics returned from API ---")
+        print("Proceeding with empty metrics. Model will be submitted without eval data.")
+        print("---------------------------------------------------------------")
 
 
     #upload preprocessor (1s for small upload vs 21 for 306 mbs)
     putfilekeys=list(s3_presigned_dict['put'].keys())
-    modelputfiles = [s for s in putfilekeys if str("zip") in s]
-
-    fileputlistofdicts=[]
-    for i in modelputfiles:
-      filedownload_dict=ast.literal_eval(s3_presigned_dict ['put'][i])
-      fileputlistofdicts.append(filedownload_dict)
-    import requests
-    if preprocessor is not None: 
+    
+    # Find preprocessor upload key using explicit pattern matching
+    # Prefer keys containing 'preprocessor_v' or 'preprocessor' ending in '.zip'
+    preprocessor_key = None
+    for key in putfilekeys:
+        if 'preprocessor_v' in key and key.endswith('.zip'):
+            preprocessor_key = key
+            break
+        elif 'preprocessor' in key and key.endswith('.zip'):
+            preprocessor_key = key
+    
+    if preprocessor_key is None and preprocessor is not None:
+        # Fallback to original logic if no explicit match
+        modelputfiles = [s for s in putfilekeys if str("zip") in s]
+        if modelputfiles:
+            preprocessor_key = modelputfiles[0]
+    
+    if preprocessor is not None:
+        if preprocessor_key is None:
+            raise RuntimeError("Failed to find preprocessor upload URL in presigned URLs")
+        
+        filedownload_dict = ast.literal_eval(s3_presigned_dict['put'][preprocessor_key])
+        
         with open(preprocessor, 'rb') as f:
-          files = {'file': (preprocessor, f)}
-          http_response = requests.post(fileputlistofdicts[0]['url'], data=fileputlistofdicts[0]['fields'], files=files)
+            files = {'file': (preprocessor, f)}
+            http_response = requests.post(filedownload_dict['url'], data=filedownload_dict['fields'], files=files)
+            
+            # Validate upload response status
+            if http_response.status_code not in [200, 204]:
+                raise RuntimeError(
+                    f"Preprocessor upload failed with status {http_response.status_code}: {http_response.text}"
+                )
 
     putfilekeys=list(s3_presigned_dict['put'].keys())
     modelputfiles = [s for s in putfilekeys if str("onnx") in s]
@@ -991,63 +1309,30 @@ def submit_model(
             model_graph = ""
             
         elif meta_dict['ml_framework'] in ['sklearn', 'xgboost']:
-            import ast
-            import astunparse
-            model_config = meta_dict["model_config"]
-            tree = ast.parse(model_config)
-
-            stringconfig=model_config
-
-            problemnodes=[]
-            for node in ast.walk(tree):
-                if isinstance(node, ast.Call):
-                    problemnodes.append(astunparse.unparse(node).replace("\n",""))
-
-            problemnodesunique=set(problemnodes)
-            for i in problemnodesunique:
-                stringconfig=stringconfig.replace(i,"'"+i+"'")
-
-            try:
-                model_config=ast.literal_eval(stringconfig)
-                model_class = model_from_string(meta_dict['model_type'])
-                default = model_class()
-                default_config = default.get_params().values()
-                model_configkeys=model_config.keys()
-                model_configvalues=model_config.values()
-            except:
-                model_class = str(model_from_string(meta_dict['model_type']))
-                if model_class.find("Voting")>0:
-                      default_config = ["No data available"]
-                      model_configkeys=["No data available"]
-                      model_configvalues=["No data available"]
-
-
-            inspect_pd = pd.DataFrame({'param_name': model_configkeys,
-                                        'default_value': default_config,
-                                        'param_value': model_configvalues})
+            
+            # Normalize model_config to dict (handles None, dict, or string)
+            model_config = _normalize_model_config(
+                meta_dict.get("model_config"), 
+                meta_dict.get('model_type')
+            )
+            
+            # Build parameter inspection DataFrame
+            inspect_pd = _build_sklearn_param_dataframe(
+                meta_dict['model_type'], 
+                model_config
+            )
 
             model_graph = ''
 
         elif meta_dict['ml_framework'] in ['pyspark']:
-            import ast
-            import astunparse
-
-            model_config = meta_dict["model_config"]
-            tree = ast.parse(model_config)
-
-            stringconfig=model_config
-
-            problemnodes=[]
-            for node in ast.walk(tree):
-                if isinstance(node, ast.Call):
-                    problemnodes.append(astunparse.unparse(node).replace("\n",""))
-
-            problemnodesunique=set(problemnodes)
-            for i in problemnodesunique:
-                stringconfig=stringconfig.replace(i,"'"+i+"'")
+            
+            # Normalize model_config to dict (handles None, dict, or string)
+            model_config_temp = _normalize_model_config(
+                meta_dict.get("model_config"), 
+                meta_dict.get('model_type')
+            )
 
             try:
-                model_config_temp = ast.literal_eval(stringconfig)
                 model_class = pyspark_model_from_string(meta_dict['model_type'])
                 default = model_class()
 
@@ -1065,10 +1350,15 @@ def submit_model(
                 default_config = default_config.values()
             except:
                 model_class = str(pyspark_model_from_string(meta_dict['model_type']))
-                if model_class.find("Voting")>0:
-                      default_config = ["No data available"]
-                      model_configkeys=["No data available"]
-                      model_configvalues=["No data available"]
+                if model_class.find("Voting") > 0:
+                    default_config = ["No data available"]
+                    model_configkeys = ["No data available"]
+                    model_configvalues = ["No data available"]
+                else:
+                    # Fallback for other exceptions
+                    default_config = []
+                    model_configkeys = []
+                    model_configvalues = []
 
             inspect_pd = pd.DataFrame({'param_name': model_configkeys,
                                     'default_value': default_config,
@@ -1082,11 +1372,13 @@ def submit_model(
         
     keys_to_extract = [ "accuracy", "f1_score", "precision", "recall", "mse", "rmse", "mae", "r2"]
 
-    eval_metrics_subset = {key: eval_metrics[key] for key in keys_to_extract}
-    eval_metrics_private_subset = {key: eval_metrics_private[key] for key in keys_to_extract}
+    # Safely extract metric subsets using helper function
+    eval_metrics_subset = _subset_numeric(eval_metrics, keys_to_extract)
+    eval_metrics_private_subset = _subset_numeric(eval_metrics_private, keys_to_extract)
 
-    eval_metrics_subset_nonulls = {key: value for key, value in eval_metrics_subset.items() if isinstance(value, float)}
-    eval_metrics_private_subset_nonulls = {key: value for key, value in eval_metrics_private_subset.items() if isinstance(value, float)}
+    # Keep only numeric values (already done by _subset_numeric, but kept for backward compatibility)
+    eval_metrics_subset_nonulls = {key: value for key, value in eval_metrics_subset.items() if isinstance(value, (int, float))}
+    eval_metrics_private_subset_nonulls = {key: value for key, value in eval_metrics_private_subset.items() if isinstance(value, (int, float))}
 
                               
     #Update model architecture data
@@ -1127,10 +1419,14 @@ def submit_model(
     else:
         code_comp_result="" #TODO: reponse 403 indicates that user needs to reset credentials.  Need to add a creds check to top of function.
 
+    # NOTE: Always return tuple (version, url) to prevent None propagation
+    # Print output is handled separately to maintain backward compatibility
+    model_page_url = "https://www.modelshare.ai/detail/model:"+response.text.split(":")[1]
+    
     if print_output:
-        return print("\nYour model has been submitted as model version "+str(model_version)+ "\n\n"+code_comp_result)
-    else:
-        return str(model_version), "https://www.modelshare.ai/detail/model:"+response.text.split(":")[1]
+        print("\nYour model has been submitted as model version "+str(model_version)+ "\n\n"+code_comp_result)
+    
+    return str(model_version), model_page_url
 
 def update_runtime_model(apiurl, model_version=None, submission_type="competition"):
     """