Fixed conflicts for Optionals

Author: aws-byeldos

src/sagemaker/clarify.py

@@ -25,9 +25,16 @@
 
 import tempfile
 from abc import ABC, abstractmethod
-from typing import List, Union, Dict, Optional, Any
-
-from schema import Schema, And, Use, Or, Optional, Regex
+from typing import List, Union, Dict, Any, Optional
+
+from schema import (
+    Schema,
+    And,
+    Use,
+    Or,
+    Optional as SchemaOptional,
+    Regex
+)
 
 import sagemaker
 from sagemaker import image_uris, s3, utils
@@ -43,7 +50,7 @@
 
 ANALYSIS_CONFIG_SCHEMA_V1_0 = Schema(
     {
-        Optional("version"): str,
+        SchemaOptional("version"): str,
         "dataset_type": And(
             str,
             Use(str.lower),
@@ -56,27 +63,27 @@
                 "application/x-image",
             ),
         ),
-        Optional("dataset_uri"): str,
-        Optional("headers"): [str],
-        Optional("label"): Or(str, int),
+        SchemaOptional("dataset_uri"): str,
+        SchemaOptional("headers"): [str],
+        SchemaOptional("label"): Or(str, int),
         # this field indicates user provides predicted_label in dataset
-        Optional("predicted_label"): Or(str, int),
-        Optional("features"): str,
-        Optional("label_values_or_threshold"): [Or(int, float, str)],
-        Optional("probability_threshold"): float,
-        Optional("facet"): [
-            {"name_or_index": Or(str, int), Optional("value_or_threshold"): [Or(int, float, str)]}
+        SchemaOptional("predicted_label"): Or(str, int),
+        SchemaOptional("features"): str,
+        SchemaOptional("label_values_or_threshold"): [Or(int, float, str)],
+        SchemaOptional("probability_threshold"): float,
+        SchemaOptional("facet"): [
+            {"name_or_index": Or(str, int), SchemaOptional("value_or_threshold"): [Or(int, float, str)]}
         ],
-        Optional("facet_dataset_uri"): str,
-        Optional("facet_headers"): [str],
-        Optional("predicted_label_dataset_uri"): str,
-        Optional("predicted_label_headers"): [str],
-        Optional("excluded_columns"): [Or(int, str)],
-        Optional("joinsource_name_or_index"): Or(str, int),
-        Optional("group_variable"): Or(str, int),
+        SchemaOptional("facet_dataset_uri"): str,
+        SchemaOptional("facet_headers"): [str],
+        SchemaOptional("predicted_label_dataset_uri"): str,
+        SchemaOptional("predicted_label_headers"): [str],
+        SchemaOptional("excluded_columns"): [Or(int, str)],
+        SchemaOptional("joinsource_name_or_index"): Or(str, int),
+        SchemaOptional("group_variable"): Or(str, int),
         "methods": {
-            Optional("shap"): {
-                Optional("baseline"): Or(
+            SchemaOptional("shap"): {
+                SchemaOptional("baseline"): Or(
                     # URI of the baseline data file
                     str,
                     # Inplace baseline data (a list of something)
@@ -93,14 +100,14 @@
                         )
                     ],
                 ),
-                Optional("num_clusters"): int,
-                Optional("use_logit"): bool,
-                Optional("num_samples"): int,
-                Optional("agg_method"): And(
+                SchemaOptional("num_clusters"): int,
+                SchemaOptional("use_logit"): bool,
+                SchemaOptional("num_samples"): int,
+                SchemaOptional("agg_method"): And(
                     str, Use(str.lower), lambda s: s in ("mean_abs", "median", "mean_sq")
                 ),
-                Optional("save_local_shap_values"): bool,
-                Optional("text_config"): {
+                SchemaOptional("save_local_shap_values"): bool,
+                SchemaOptional("text_config"): {
                     "granularity": And(
                         str, Use(str.lower), lambda s: s in ("token", "sentence", "paragraph")
                     ),
@@ -237,43 +244,43 @@
                             "yo",
                         ),
                     ),
-                    Optional("max_top_tokens"): int,
+                    SchemaOptional("max_top_tokens"): int,
                 },
-                Optional("image_config"): {
-                    Optional("num_segments"): int,
-                    Optional("segment_compactness"): int,
-                    Optional("feature_extraction_method"): str,
-                    Optional("model_type"): str,
-                    Optional("max_objects"): int,
-                    Optional("iou_threshold"): float,
-                    Optional("context"): float,
-                    Optional("debug"): {
-                        Optional("image_names"): [str],
-                        Optional("class_ids"): [int],
-                        Optional("sample_from"): int,
-                        Optional("sample_to"): int,
+                SchemaOptional("image_config"): {
+                    SchemaOptional("num_segments"): int,
+                    SchemaOptional("segment_compactness"): int,
+                    SchemaOptional("feature_extraction_method"): str,
+                    SchemaOptional("model_type"): str,
+                    SchemaOptional("max_objects"): int,
+                    SchemaOptional("iou_threshold"): float,
+                    SchemaOptional("context"): float,
+                    SchemaOptional("debug"): {
+                        SchemaOptional("image_names"): [str],
+                        SchemaOptional("class_ids"): [int],
+                        SchemaOptional("sample_from"): int,
+                        SchemaOptional("sample_to"): int,
                     },
                 },
-                Optional("seed"): int,
+                SchemaOptional("seed"): int,
             },
-            Optional("pre_training_bias"): {"methods": Or(str, [str])},
-            Optional("post_training_bias"): {"methods": Or(str, [str])},
-            Optional("pdp"): {
+            SchemaOptional("pre_training_bias"): {"methods": Or(str, [str])},
+            SchemaOptional("post_training_bias"): {"methods": Or(str, [str])},
+            SchemaOptional("pdp"): {
                 "grid_resolution": int,
-                Optional("features"): [Or(str, int)],
-                Optional("top_k_features"): int,
+                SchemaOptional("features"): [Or(str, int)],
+                SchemaOptional("top_k_features"): int,
             },
-            Optional("report"): {"name": str, Optional("title"): str},
+            SchemaOptional("report"): {"name": str, SchemaOptional("title"): str},
         },
-        Optional("predictor"): {
-            Optional("endpoint_name"): str,
-            Optional("endpoint_name_prefix"): And(str, Regex(ENDPOINT_NAME_PREFIX_PATTERN)),
-            Optional("model_name"): str,
-            Optional("target_model"): str,
-            Optional("instance_type"): str,
-            Optional("initial_instance_count"): int,
-            Optional("accelerator_type"): str,
-            Optional("content_type"): And(
+        SchemaOptional("predictor"): {
+            SchemaOptional("endpoint_name"): str,
+            SchemaOptional("endpoint_name_prefix"): And(str, Regex(ENDPOINT_NAME_PREFIX_PATTERN)),
+            SchemaOptional("model_name"): str,
+            SchemaOptional("target_model"): str,
+            SchemaOptional("instance_type"): str,
+            SchemaOptional("initial_instance_count"): int,
+            SchemaOptional("accelerator_type"): str,
+            SchemaOptional("content_type"): And(
                 str,
                 Use(str.lower),
                 lambda s: s
@@ -286,16 +293,16 @@
                     "application/x-npy",
                 ),
             ),
-            Optional("accept_type"): And(
+            SchemaOptional("accept_type"): And(
                 str,
                 Use(str.lower),
                 lambda s: s in ("text/csv", "application/jsonlines", "application/json"),
             ),
-            Optional("label"): Or(str, int),
-            Optional("probability"): Or(str, int),
-            Optional("label_headers"): [Or(str, int)],
-            Optional("content_template"): Or(str, {str: str}),
-            Optional("custom_attributes"): str,
+            SchemaOptional("label"): Or(str, int),
+            SchemaOptional("probability"): Or(str, int),
+            SchemaOptional("label_headers"): [Or(str, int)],
+            SchemaOptional("content_template"): Or(str, {str: str}),
+            SchemaOptional("custom_attributes"): str,
         },
     }
 )