Format text classification and use warning

run_jobs.py

@@ -69,7 +69,7 @@ def prepare_env_and_get_command(
             )
         logger.info(f"Using {executable} as executable")
     except Exception as e:
-        logger.warn(f"Create env failed due to {e}, using the current env as fallback.")
+        logger.warning(f"Create env failed due to {e}, using the current env as fallback.")
         executable = "giskard_scanner"
 
     command = [

text_classification.py

@@ -14,6 +14,7 @@ AUTH_CHECK_URL = "https://huggingface.co/api/whoami-v2"
 
 logger = logging.getLogger(__file__)
 
+
 class HuggingFaceInferenceAPIResponse:
     def __init__(self, message):
         self.message = message
@@ -25,7 +26,7 @@ def get_labels_and_features_from_dataset(ds):
         label_keys = [i for i in dataset_features.keys() if i.startswith("label")]
         features = [f for f in dataset_features.keys() if not f.startswith("label")]
 
-        if len(label_keys) == 0: # no labels found
+        if len(label_keys) == 0:  # no labels found
             # return everything for post processing
             return list(dataset_features.keys()), list(dataset_features.keys()), None
 
@@ -40,11 +41,10 @@ def get_labels_and_features_from_dataset(ds):
             labels = dataset_features[label_keys[0]].names
         return labels, features, label_keys
     except Exception as e:
-        logging.warning(
-            f"Get Labels/Features Failed for dataset: {e}"
-        )
+        logging.warning(f"Get Labels/Features Failed for dataset: {e}")
         return None, None, None
 
+
 def check_model_task(model_id):
     # check if model is valid on huggingface
     try:
@@ -55,6 +55,7 @@ def check_model_task(model_id):
     except Exception:
         return None
 
+
 def get_model_labels(model_id, example_input):
     hf_token = os.environ.get(HF_WRITE_TOKEN, default="")
     payload = {"inputs": example_input, "options": {"use_cache": True}}
@@ -63,6 +64,7 @@ def get_model_labels(model_id, example_input):
         return None
     return extract_from_response(response, "label")
 
+
 def extract_from_response(data, key):
     results = []
 
@@ -80,6 +82,7 @@ def extract_from_response(data, key):
 
     return results
 
+
 def hf_inference_api(model_id, hf_token, payload):
     hf_inference_api_endpoint = os.environ.get(
         "HF_INFERENCE_ENDPOINT", default="https://api-inference.huggingface.co"
@@ -94,19 +97,26 @@ def hf_inference_api(model_id, hf_token, payload):
     try:
         output = response.json()
         if "error" in output and "Input is too long" in output["error"]:
-          payload.update({"parameters": {"truncation": True, "max_length": 512}})
-          response = requests.post(url, headers=headers, json=payload)
-          if not hasattr(response, "status_code") or response.status_code != 200:
-              logger.warning(f"Request to inference API returns {response}")
+            payload.update({"parameters": {"truncation": True, "max_length": 512}})
+            response = requests.post(url, headers=headers, json=payload)
+            if not hasattr(response, "status_code") or response.status_code != 200:
+                logger.warning(f"Request to inference API returns {response}")
         return response.json()
     except Exception:
         return {"error": response.content}
-    
+
+
 def preload_hf_inference_api(model_id):
-    payload = {"inputs": "This is a test", "options": {"use_cache": True, }}
+    payload = {
+        "inputs": "This is a test",
+        "options": {
+            "use_cache": True,
+        },
+    }
     hf_token = os.environ.get(HF_WRITE_TOKEN, default="")
     hf_inference_api(model_id, hf_token, payload)
 
+
 def check_model_pipeline(model_id):
     try:
         task = huggingface_hub.model_info(model_id).pipeline_tag
@@ -279,6 +289,7 @@ def check_dataset_features_validity(d_id, config, split):
 
     return df, dataset_features
 
+
 def select_the_first_string_column(ds):
     for feature in ds.features.keys():
         if isinstance(ds[0][feature], str):
@@ -286,13 +297,17 @@ def select_the_first_string_column(ds):
     return None
 
 
-def get_example_prediction(model_id, dataset_id, dataset_config, dataset_split, hf_token):
+def get_example_prediction(
+    model_id, dataset_id, dataset_config, dataset_split, hf_token
+):
     # get a sample prediction from the model on the dataset
     prediction_input = None
     prediction_result = None
     try:
         # Use the first item to test prediction
-        ds = datasets.load_dataset(dataset_id, dataset_config, split=dataset_split, trust_remote_code=True)
+        ds = datasets.load_dataset(
+            dataset_id, dataset_config, split=dataset_split, trust_remote_code=True
+        )
         if "text" not in ds.features.keys():
             # Dataset does not have text column
             prediction_input = ds[0][select_the_first_string_column(ds)]
@@ -305,10 +320,12 @@ def get_example_prediction(model_id, dataset_id, dataset_config, dataset_split,
         if isinstance(results, dict) and "error" in results.keys():
             if "estimated_time" in results.keys():
                 return prediction_input, HuggingFaceInferenceAPIResponse(
-                    f"Estimated time: {int(results['estimated_time'])}s. Please try again later.")
+                    f"Estimated time: {int(results['estimated_time'])}s. Please try again later."
+                )
             return prediction_input, HuggingFaceInferenceAPIResponse(
-                f"Inference Error: {results['error']}.")
-        
+                f"Inference Error: {results['error']}."
+            )
+
         while isinstance(results, list):
             if isinstance(results[0], dict):
                 break
@@ -402,4 +419,4 @@ def check_hf_token_validity(hf_token):
     response = requests.get(AUTH_CHECK_URL, headers=headers)
     if response.status_code != 200:
         return False
-    return True
+    return True

text_classification_ui_helpers.py

@@ -63,7 +63,7 @@ def get_dataset_splits(dataset_id, dataset_config):
         splits = datasets.get_dataset_split_names(dataset_id, dataset_config, trust_remote_code=True)
         return gr.update(choices=splits, value=splits[0], visible=True)
     except Exception as e:
-        logger.warn(f"Check your dataset {dataset_id} and config {dataset_config}: {e}")
+        logger.warning(f"Check your dataset {dataset_id} and config {dataset_config}: {e}")
         return gr.update(visible=False)
 
 def check_dataset(dataset_id):
@@ -83,7 +83,7 @@ def check_dataset(dataset_id):
             ""
         )
     except Exception as e:
-        logger.warn(f"Check your dataset {dataset_id}: {e}")
+        logger.warning(f"Check your dataset {dataset_id}: {e}")
         if "doesn't exist" in str(e):
             gr.Warning(get_dataset_fetch_error_raw(e))
         if "forbidden" in str(e).lower(): # GSK-2770
@@ -232,7 +232,7 @@ def precheck_model_ds_enable_example_btn(
             )
     except Exception as e:
         # Config or split wrong
-        logger.warn(f"Check your dataset {dataset_id} and config {dataset_config} on split {dataset_split}: {e}")
+        logger.warning(f"Check your dataset {dataset_id} and config {dataset_config} on split {dataset_split}: {e}")
         return (
             gr.update(interactive=False),
             gr.update(visible=False),
@@ -372,30 +372,30 @@ def check_column_mapping_keys_validity(all_mappings):
 
 def enable_run_btn(uid, inference_token, model_id, dataset_id, dataset_config, dataset_split):
     if inference_token == "":
-        logger.warn("Inference API is not enabled")
+        logger.warning("Inference API is not enabled")
         return gr.update(interactive=False)
     if model_id == "" or dataset_id == "" or dataset_config == "" or dataset_split == "":
-        logger.warn("Model id or dataset id is not selected")
+        logger.warning("Model id or dataset id is not selected")
         return gr.update(interactive=False)
     
     all_mappings = read_column_mapping(uid)
     if not check_column_mapping_keys_validity(all_mappings):
-        logger.warn("Column mapping is not valid")
+        logger.warning("Column mapping is not valid")
         return gr.update(interactive=False)
 
     if not check_hf_token_validity(inference_token):
-        logger.warn("HF token is not valid")
+        logger.warning("HF token is not valid")
         return gr.update(interactive=False)
     return gr.update(interactive=True)
 
 def construct_label_and_feature_mapping(all_mappings, ds_labels, ds_features, label_keys=None):
     label_mapping = {}
     if len(all_mappings["labels"].keys()) != len(ds_labels):
-        logger.warn(f"""Label mapping corrupted: {CONFIRM_MAPPING_DETAILS_FAIL_RAW}. 
+        logger.warning(f"""Label mapping corrupted: {CONFIRM_MAPPING_DETAILS_FAIL_RAW}. 
                     \nall_mappings: {all_mappings}\nds_labels: {ds_labels}""")
       
     if len(all_mappings["features"].keys()) != len(ds_features):
-        logger.warn(f"""Feature mapping corrupted: {CONFIRM_MAPPING_DETAILS_FAIL_RAW}. 
+        logger.warning(f"""Feature mapping corrupted: {CONFIRM_MAPPING_DETAILS_FAIL_RAW}. 
                     \nall_mappings: {all_mappings}\nds_features: {ds_features}""")
 
     for i, label in zip(range(len(ds_labels)),  ds_labels):