Model info

examples/register_scikit_classification_model.py

@@ -25,7 +25,7 @@
     # Register the model in Model Manager
     register_model(model,
                    model_name,
-                   input=X,         # Use X to determine model inputs
+                   X=X,         # Use X to determine model inputs
                    project='Iris',  # Register in "Iris" project
                    force=True)      # Create project if it doesn't exist
 
@@ -36,5 +36,5 @@
     x = X.iloc[0, :]
 
     # Call the published module and score the record
-    result = module.predict(x)
+    result = module.score(x)
     print(result)

examples/register_scikit_regression_model.py

@@ -28,7 +28,7 @@
     project_name = 'Boston Housing'
 
     # Register the model in SAS Model Manager
-    register_model(model, model_name, project_name, input=X, force=True)
+    register_model(model, model_name, project_name, X=X, force=True)
 
     # Publish the model to the real-time scoring engine
     module = publish_model(model_name, 'maslocal', replace=True)
@@ -37,5 +37,5 @@
     x = X.iloc[0, :]
 
     # Call the published module and score the record
-    result = module.predict(x)
+    result = module.score(x)
     print(result)

setup.py

@@ -42,11 +42,10 @@ def get_file(filename):
     packages=find_packages(where="src"),
     package_dir={"": "src"},
     python_requires=">=3.6",
-    install_requires=["pandas>=0.24.0", "requests", "pyyaml", "packaging"],
+    install_requires=["dill", "pandas>=0.24.0", "requests", "pyyaml", "packaging"],
     extras_require={
         "swat": ["swat"],
         "GitPython": ["GitPython"],
-        "numpy": ["numpy"],
         "scikit-learn": ["scikit-learn"],
         "kerberos": [
             'kerberos ; platform_system != "Windows"',

src/sasctl/_services/files.py

@@ -5,6 +5,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import os
+from pathlib import Path
 
 from sasctl.utils.cli import sasctl_command
 
@@ -40,7 +41,7 @@ def create_file(cls, file, folder=None, filename=None, expiration=None):
 
         Parameters
         ----------
-        file : str or file_like
+        file : str, pathlib.Path, or file_like
             Path to the file to upload or a file-like object.
         folder : str or dict, optional
             Name, or, or folder information as returned by :func:`.get_folder`.
@@ -55,8 +56,8 @@ def create_file(cls, file, folder=None, filename=None, expiration=None):
             A dictionary containing the file attributes.
 
         """
-        if isinstance(file, str):
-            filename = filename or os.path.splitext(os.path.split(file)[1])[0]
+        if isinstance(file, (str, Path)):
+            filename = filename or Path(file).name
 
             with open(file, "rb") as f:
                 file = f.read()

src/sasctl/_services/model_repository.py

@@ -524,7 +524,7 @@ def import_model_from_zip(
         project : str or dict
             The name or id of the model project, or a dictionary
             representation of the project.
-        file : bytes
+        file : bytes or file-like object
             The ZIP file containing the model and contents.
         description : str
             The description of the model.
@@ -551,9 +551,14 @@ def import_model_from_zip(
         }
         params = "&".join("{}={}".format(k, v) for k, v in params.items())
 
+        if not isinstance(file, bytes):
+            if file.seekable():
+                file.seek(0)
+            file = file.read()
+
         r = cls.post(
             "/models#octetStream",
-            data=file.read(),
+            data=file,
             params=params,
             headers={"Content-Type": "application/octet-stream"},
         )

src/sasctl/pzmm/import_model.py

@@ -22,9 +22,21 @@ def get_model_properties(
     model_files: Union[str, Path, None] = None,
 ):
     if type(model_files) is dict:
-        model = model_files["ModelProperties.json"]
-        input_var = model_files["inputVar.json"]
-        output_var = model_files["outputVar.json"]
+        try:
+            model = json.loads(model_files["ModelProperties.json"])
+        except (json.JSONDecodeError, TypeError):
+            model = model_files["ModelProperties.json"]
+
+        try:
+            input_var = json.loads(model_files["inputVar.json"])
+        except (json.JSONDecodeError, TypeError):
+            input_var = model_files["inputVar.json"]
+
+        try:
+            output_var = json.loads(model_files["outputVar.json"])
+        except (json.JSONDecodeError, TypeError):
+            output_var = model_files["outputVar.json"]
+
     else:
         with open(Path(model_files) / "ModelProperties.json") as f:
             model = json.load(f)
@@ -99,7 +111,9 @@ def project_exists(
                 response = _create_project(project, model, repo, input_var, output_var)
             else:
                 response = mr.create_project(project, repo)
-            print(f"A new project named {response.name} was created.")
+
+            if check_if_jupyter():
+                print(f"A new project named {response.name} was created.")
             return response
     else:
         model, input_var, output_var = get_model_properties(target_values, model_files)
@@ -348,7 +362,7 @@ def import_model(
         # For SAS Viya 4, the score code can be written beforehand and imported with
         # all the model files
         elif current_session().version_info() == 4:
-            score_code_dict = sc.write_score_code(
+            score_code_dict = sc().write_score_code(
                 model_prefix,
                 input_data,
                 predict_method,
@@ -447,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

@@ -2,7 +2,6 @@
 # SPDX-License-Identifier: Apache-2.0
 # %%
 import codecs
-import gzip
 import pickle
 import shutil
 from pathlib import Path
@@ -77,6 +76,10 @@ def pickle_trained_model(
             models.
 
         """
+        from .write_score_code import ScoreCode
+
+        sanitized_prefix = ScoreCode.sanitize_model_prefix(model_prefix)
+
         if is_binary_string:
             # For models that use a binary string representation
             binary_string = codecs.encode(
@@ -91,25 +94,25 @@ def pickle_trained_model(
                 # For models imported from MLFlow
                 shutil.copy(ml_pickle_path, pickle_path)
                 pzmm_pickle_path = Path(pickle_path) / mlflow_details["model_path"]
-                pzmm_pickle_path.rename(Path(pickle_path) / (model_prefix + PICKLE))
+                pzmm_pickle_path.rename(Path(pickle_path) / (sanitized_prefix + PICKLE))
             else:
                 with open(ml_pickle_path, "rb") as pickle_file:
-                    return {model_prefix + PICKLE: pickle.load(pickle_file)}
+                    return {sanitized_prefix + PICKLE: pickle.load(pickle_file)}
         else:
             # For all other model types
             if not is_h2o_model:
                 if pickle_path:
                     with open(
-                        Path(pickle_path) / (model_prefix + PICKLE), "wb"
+                        Path(pickle_path) / (sanitized_prefix + PICKLE), "wb"
                     ) as pickle_file:
                         pickle.dump(trained_model, pickle_file)
                     if cls.notebook_output:
                         print(
                             f"Model {model_prefix} was successfully pickled and saved "
-                            f"to {Path(pickle_path) / (model_prefix + PICKLE)}."
+                            f"to {Path(pickle_path) / (sanitized_prefix + PICKLE)}."
                         )
                 else:
-                    return {model_prefix + PICKLE: pickle.dumps(trained_model)}
+                    return {sanitized_prefix + PICKLE: pickle.dumps(trained_model)}
             # For binary H2O models, save the binary file as a "pickle" file
             elif is_h2o_model and is_binary_model and pickle_path:
                 if not h2o:
@@ -121,7 +124,7 @@ def pickle_trained_model(
                     model=trained_model,
                     force=True,
                     path=str(pickle_path),
-                    filename=f"{model_prefix}.pickle",
+                    filename=f"{sanitized_prefix}.pickle",
                 )
             # For MOJO H2O models, save as a mojo file and adjust the extension to .mojo
             elif is_h2o_model and pickle_path:
@@ -130,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"{model_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

@@ -498,18 +498,27 @@ def write_file_metadata_json(
             Dictionary containing a key-value pair representing the file name and json
             dump respectively.
         """
+
+        from .write_score_code import ScoreCode
+
+        sanitized_prefix = ScoreCode.sanitize_model_prefix(model_prefix)
+
         dict_list = [
             {"role": "inputVariables", "name": INPUT},
             {"role": "outputVariables", "name": OUTPUT},
-            {"role": "score", "name": f"score_{model_prefix}.py"},
+            {"role": "score", "name": f"score_{sanitized_prefix}.py"},
         ]
         if is_h2o_model:
-            dict_list.append({"role": "scoreResource", "name": model_prefix + ".mojo"})
+            dict_list.append(
+                {"role": "scoreResource", "name": sanitized_prefix + ".mojo"}
+            )
         elif is_tf_keras_model:
-            dict_list.append({"role": "scoreResource", "name": model_prefix + ".h5"})
+            dict_list.append(
+                {"role": "scoreResource", "name": sanitized_prefix + ".h5"}
+            )
         else:
             dict_list.append(
-                {"role": "scoreResource", "name": model_prefix + ".pickle"}
+                {"role": "scoreResource", "name": sanitized_prefix + ".pickle"}
             )
 
         if json_path:
@@ -2314,9 +2323,9 @@ def generate_model_card(
                 "Only classification and prediction target types are currently accepted."
             )
         if selection_statistic is None:
-            if target_type is "classification":
+            if target_type == "classification":
                 selection_statistic = "_KS_"
-            elif target_type is "prediction":
+            elif target_type == "prediction":
                 selection_statistic = "_ASE_"
         if selection_statistic not in cls.valid_params:
             raise RuntimeError(