test: test case update for pzmm and cassette refresh

Author: jlwalke2

src/sasctl/_services/files.py

@@ -57,9 +57,7 @@ def create_file(cls, file, folder=None, filename=None, expiration=None):
 
         """
         if isinstance(file, (str, Path)):
-            # file = str(file)
-            # filename = filename or os.path.splitext(os.path.split(file)[1])[0]
-            filename = Path(file).name
+            filename = filename or Path(file).name
 
             with open(file, "rb") as f:
                 file = f.read()

src/sasctl/_services/model_repository.py

@@ -359,9 +359,10 @@ def create_model(
 
         model["scoreCodeType"] = score_code_type or model.get("scoreCodeType")
         model["trainTable"] = training_table or model.get("trainTable")
-        model["classificationEventProbabilityVariableName"] = (
-            event_prob_variable
-            or model.get("classificationEventProbabilityVariableName")
+        model[
+            "classificationEventProbabilityVariableName"
+        ] = event_prob_variable or model.get(
+            "classificationEventProbabilityVariableName"
         )
         model["classificationTargetEventValue"] = event_target_value or model.get(
             "classificationTargetEventValue"

src/sasctl/pzmm/import_model.py

@@ -24,17 +24,17 @@ def get_model_properties(
     if type(model_files) is dict:
         try:
             model = json.loads(model_files["ModelProperties.json"])
-        except json.JSONDecodeError:
+        except (json.JSONDecodeError, TypeError):
             model = model_files["ModelProperties.json"]
 
         try:
             input_var = json.loads(model_files["inputVar.json"])
-        except json.JSONDecodeError:
+        except (json.JSONDecodeError, TypeError):
             input_var = model_files["inputVar.json"]
 
         try:
             output_var = json.loads(model_files["outputVar.json"])
-        except json.JSONDecodeError:
+        except (json.JSONDecodeError, TypeError):
             output_var = model_files["outputVar.json"]
 
     else:
@@ -333,7 +333,9 @@ def import_model(
             if isinstance(model_files, dict):
                 zip_io_file = zm.zip_files(model_files, model_prefix, is_viya4=False)
             else:
-                zip_io_file = zm.zip_files(Path(model_files), model_prefix, is_viya4=False)
+                zip_io_file = zm.zip_files(
+                    Path(model_files), model_prefix, is_viya4=False
+                )
                 if cls.notebook_output:
                     print(f"All model files were zipped to {Path(model_files)}.")
 
@@ -459,7 +461,7 @@ def import_model(
                 except AttributeError:
                     print("Model failed to import to SAS Model Manager.")
 
-            score_code_dict = sc.write_score_code(
+            score_code_dict = sc().write_score_code(
                 model_prefix,
                 input_data,
                 predict_method,

src/sasctl/pzmm/pickle_model.py

@@ -77,6 +77,7 @@ def pickle_trained_model(
 
         """
         from .write_score_code import ScoreCode
+
         sanitized_prefix = ScoreCode.sanitize_model_prefix(model_prefix)
 
         if is_binary_string:
@@ -132,7 +133,9 @@ def pickle_trained_model(
                         "The h2o package is required to save the model as a mojo model."
                     )
                 trained_model.save_mojo(
-                    force=True, path=str(pickle_path), filename=f"{sanitized_prefix}.mojo"
+                    force=True,
+                    path=str(pickle_path),
+                    filename=f"{sanitized_prefix}.mojo",
                 )
             elif is_binary_model or is_h2o_model:
                 raise ValueError(

src/sasctl/pzmm/write_json_files.py

@@ -500,6 +500,7 @@ def write_file_metadata_json(
         """
 
         from .write_score_code import ScoreCode
+
         sanitized_prefix = ScoreCode.sanitize_model_prefix(model_prefix)
 
         dict_list = [
@@ -508,9 +509,13 @@ def write_file_metadata_json(
             {"role": "score", "name": f"score_{sanitized_prefix}.py"},
         ]
         if is_h2o_model:
-            dict_list.append({"role": "scoreResource", "name": sanitized_prefix + ".mojo"})
+            dict_list.append(
+                {"role": "scoreResource", "name": sanitized_prefix + ".mojo"}
+            )
         elif is_tf_keras_model:
-            dict_list.append({"role": "scoreResource", "name": sanitized_prefix + ".h5"})
+            dict_list.append(
+                {"role": "scoreResource", "name": sanitized_prefix + ".h5"}
+            )
         else:
             dict_list.append(
                 {"role": "scoreResource", "name": sanitized_prefix + ".pickle"}

src/sasctl/pzmm/write_score_code.py

@@ -18,7 +18,6 @@
 
 
 class ScoreCode:
-
     def __init__(self):
         self.score_code = ""
 
@@ -1068,6 +1067,7 @@ def _determine_returns_type(outputs: List[Any]) -> List[bool]:
             classification values and `False` represents probability or prediction
             values.
         """
+
         def is_str(val):
             if isinstance(val, str) or val == str:
                 return True

src/sasctl/tasks.py

@@ -187,7 +187,7 @@ def _compare_properties(project_name, model, input_vars=None, output_vars=None):
         )
 
 
-def _register_open_source_model(model, name, project, X):
+def _register_open_source_model(model, name, project, X, modeler):
     try:
         info = utils.get_model_info(model, X=X)
     except ValueError as e:
@@ -222,8 +222,9 @@ def _register_open_source_model(model, name, project, X):
         model_name=name,
         model_desc=info.description,
         model_algorithm=info.algorithm,
+        modeler=modeler,
         target_variable=info.target_column,
-        target_values=info.target_values
+        target_values=info.target_values,
     )
 
     # requirements = JSONFiles().create_requirements_json(model)
@@ -234,20 +235,24 @@ def _register_open_source_model(model, name, project, X):
     pzmm_files.update(metadata)
     pzmm_files.update(properties)
 
-    model_obj, _ = ImportModel().import_model(model_files=pzmm_files,
-                                              model_prefix=name,
-                                              project=project,
-                                              input_data=info.X,
-                                              predict_method=[info.predict_function, info.y.iloc[0].to_list()],
-                                              predict_threshold=info.threshold,
-                                              score_metrics=info.output_column_names,
-                                              target_values=info.target_values,
-                                              pickle_type=serialization_format,
-                                              model_file_name=list(serialized_model.keys())[0])
+    model_obj, _ = ImportModel().import_model(
+        model_files=pzmm_files,
+        model_prefix=name,
+        project=project,
+        input_data=info.X,
+        predict_method=[info.predict_function, info.y.iloc[0].to_list()],
+        predict_threshold=info.threshold,
+        score_metrics=info.output_column_names,
+        target_values=info.target_values,
+        pickle_type=serialization_format,
+        model_file_name=list(serialized_model.keys())[0],
+    )
     return model_obj
 
 
-def _register_sas_model(model, name, project, create_project=False, version=None, X=None, repo_obj=None):
+def _register_sas_model(
+    model, name, project, create_project=False, version=None, X=None, repo_obj=None
+):
     if "DataStepSrc" in model.columns:
         zip_file = utils.create_package_from_datastep(model, input=X)
         if create_project:
@@ -278,9 +283,7 @@ def _register_sas_model(model, name, project, create_project=False, version=None
                 )
             else:
                 model_props = {}
-            project = _create_project(
-                project, model_props, repo_obj, in_var, out_var
-            )
+            project = _create_project(project, model_props, repo_obj, in_var, out_var)
         model = mr.import_model_from_zip(name, project, zip_file, version=version)
     # Assume ASTORE model if not a DataStep model
     else:
@@ -320,9 +323,7 @@ def _register_sas_model(model, name, project, create_project=False, version=None
         if current_session().version_info() < 4:
             # Upload the model as a ZIP file if using Viya 3.
             zipfile = utils.create_package(model, input=input)
-            model = mr.import_model_from_zip(
-                name, project, zipfile, version=version
-            )
+            model = mr.import_model_from_zip(name, project, zipfile, version=version)
         else:
             # If using Viya 4, just upload the raw AStore and Model Manager will handle inspection.
             astore = cas.astore.download(rstore=model)
@@ -338,6 +339,7 @@ def _register_sas_model(model, name, project, create_project=False, version=None
             )
     return model
 
+
 def register_model(
     model,
     name,
@@ -348,7 +350,8 @@ def register_model(
     files=None,
     force=False,
     record_packages=True,
-    input=None
+    modeler=None,
+    input=None,
 ):
     """Register a model in the model repository.
 
@@ -389,6 +392,9 @@ def register_model(
     record_packages : bool, optional
         Capture Python packages registered in the environment.  Defaults to
         True.  Ignored if `model` is not a Python object.
+    modeler : str, optional
+        The name of the user who created the model.  Will default ot the
+        current user if not specified.
     input : DataFrame, type, list of type, or dict of str: type, optional
         Deprecated, use `X` instead.
 
@@ -474,10 +480,20 @@ def register_model(
                 "received '%r'." % (swat.CASTable, model)
             )
 
-        model_obj = _register_sas_model(model, name, project, repo_obj=repo_obj, X=X, create_project=create_project, version=version)
+        model_obj = _register_sas_model(
+            model,
+            name,
+            project,
+            repo_obj=repo_obj,
+            X=X,
+            create_project=create_project,
+            version=version,
+        )
 
     elif not isinstance(model, dict):
-        model_obj = _register_open_source_model(model, name, project, X=X)
+        model_obj = _register_open_source_model(
+            model, name, project, X=X, modeler=modeler or current_session().username
+        )
     else:
         project = _create_project(project, model, repo_obj)
 
@@ -506,7 +522,9 @@ def register_model(
         if isinstance(file, dict):
             for k in file.keys():
                 if k not in ("name", "file", "role"):
-                    raise ValueError(f"Invalid key '{k}' in `file` dictionary.  Valid keys are 'name', 'file', and 'role'.")
+                    raise ValueError(
+                        f"Invalid key '{k}' in `file` dictionary.  Valid keys are 'name', 'file', and 'role'."
+                    )
             mr.add_model_content(model_obj, **file)
         else:
             mr.add_model_content(model_obj, file)

src/sasctl/utils/astore.py

@@ -384,7 +384,6 @@ def regression_target(r):
         properties["targetVariable"] = classification_target(result)
 
     elif algorithm in ("forest", "gradboost", "tree-based models"):
-
         if algorithm == "forest":
             properties["algorithm"] = "Random forest"
         elif algorithm == "gradboost":

src/sasctl/utils/model_info.py

@@ -170,21 +170,24 @@ class PyTorchModelInfo(ModelInfo):
     """Stores model information for a PyTorch model instance."""
 
     def __init__(self, model, X, y=None):
-
         if torch is None:
-            raise RuntimeError("The PyTorch library must be installed to work with PyTorch models.  Please `pip install torch`.")
+            raise RuntimeError(
+                "The PyTorch library must be installed to work with PyTorch models.  Please `pip install torch`."
+            )
 
         if not isinstance(model, torch.nn.Module):
             raise ValueError(f"Expected PyTorch model, received {type(model)}.")
 
         # Some models may take multiple tensors as input.  These can be passed as a tuple
         # of tensors.  To simplify processing, convert even single inputs into tuples.
         if not isinstance(X, tuple):
-            X = (X, )
+            X = (X,)
 
         for x in X:
             if not isinstance(x, (np.ndarray, torch.Tensor)):
-                raise ValueError(f"Expected input data to be a numpy array or PyTorch tensor, received {type(X)}.")
+                raise ValueError(
+                    f"Expected input data to be a numpy array or PyTorch tensor, received {type(X)}."
+                )
         # if X.ndim != 2:
         #     raise ValueError(f"Expected input date with shape (n_samples, n_dim), received shape {X.shape}.")
 
@@ -201,7 +204,9 @@ def __init__(self, model, X, y=None):
                 y = model(*X)
 
         if not isinstance(y, (np.ndarray, torch.Tensor)):
-            raise ValueError(f"Expected output data to be a numpy array or PyTorch tensor, received {type(y)}.")
+            raise ValueError(
+                f"Expected output data to be a numpy array or PyTorch tensor, received {type(y)}."
+            )
 
         self._model = model
 
@@ -342,8 +347,6 @@ class SklearnModelInfo(ModelInfo):
     }
 
     def __init__(self, model, X, y):
-
-
         is_classifier = hasattr(model, "classes_")
         is_binary_classifier = is_classifier and len(model.classes_) == 2
         is_clusterer = hasattr(model, "cluster_centers_")
@@ -360,7 +363,11 @@ def __init__(self, model, X, y):
 
         # If not a classfier or a clustering algorithm and output is a single column, then
         # assume its a regression algorithm
-        is_regressor = not is_classifier and not is_clusterer and (y_df.shape[1] == 1 or "Regress" in type(model).__name__)
+        is_regressor = (
+            not is_classifier
+            and not is_clusterer
+            and (y_df.shape[1] == 1 or "Regress" in type(model).__name__)
+        )
 
         if not is_classifier and not is_regressor and not is_clusterer:
             raise ValueError(f"Unexpected model type {model} received.")

tests/conftest.py

@@ -185,6 +185,7 @@ def add_placeholder(pattern, string, placeholder, group):
 # config.cassette_library_dir = 'tests/cassettes'
 # config.default_cassette_options['serialize_with'] = 'prettyjson'
 config.default_cassette_options["serialize_with"] = "binary"
+config.default_cassette_options["preserve_exact_body_bytes"] = True
 config.default_cassette_options["record_mode"] = record_mode
 config.default_cassette_options["match_requests_on"] = [
     "method",