Merge branch 'unsupport-pt2.1' of https://github.com/sirutBuasai/sagemaker-python-sdk into unsupport-pt2.1

Author: Sirut Buasai

CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## v2.203.1 (2024-01-09)
+
+### Bug Fixes and Other Changes
+
+ * TGI 1.3.3
+ * skip failing integs
+ * query hf api for model md
+ * update image_uri_configs  12-29-2023 06:17:34 PST
+
 ## v2.203.0 (2023-12-28)
 
 ### Features

VERSION

@@ -1 +1 @@
-2.203.1.dev0
+2.203.2.dev0

src/sagemaker/image_uri_config/huggingface-llm.json

@@ -10,7 +10,7 @@
             "1.0": "1.0.3",
             "1.1": "1.1.0",
             "1.2": "1.2.0",
-            "1.3": "1.3.1"
+            "1.3": "1.3.3"
         },
         "versions": {
             "0.6.0": {
@@ -341,7 +341,54 @@
                 "container_version": {
                     "gpu": "cu121-ubuntu20.04"
                 }
+            },
+            "1.3.3": {
+                "py_versions": [
+                    "py310"
+                ],
+                "registries": {
+                    "af-south-1": "626614931356",
+                    "il-central-1": "780543022126",
+                    "ap-east-1": "871362719292",
+                    "ap-northeast-1": "763104351884",
+                    "ap-northeast-2": "763104351884",
+                    "ap-northeast-3": "364406365360",
+                    "ap-south-1": "763104351884",
+                    "ap-south-2": "772153158452",
+                    "ap-southeast-1": "763104351884",
+                    "ap-southeast-2": "763104351884",
+                    "ap-southeast-3": "907027046896",
+                    "ap-southeast-4": "457447274322",
+                    "ca-central-1": "763104351884",
+                    "cn-north-1": "727897471807",
+                    "cn-northwest-1": "727897471807",
+                    "eu-central-1": "763104351884",
+                    "eu-central-2": "380420809688",
+                    "eu-north-1": "763104351884",
+                    "eu-west-1": "763104351884",
+                    "eu-west-2": "763104351884",
+                    "eu-west-3": "763104351884",
+                    "eu-south-1": "692866216735",
+                    "eu-south-2": "503227376785",
+                    "me-south-1": "217643126080",
+                    "me-central-1": "914824155844",
+                    "sa-east-1": "763104351884",
+                    "us-east-1": "763104351884",
+                    "us-east-2": "763104351884",
+                    "us-gov-east-1": "446045086412",
+                    "us-gov-west-1": "442386744353",
+                    "us-iso-east-1": "886529160074",
+                    "us-isob-east-1": "094389454867",
+                    "us-west-1": "763104351884",
+                    "us-west-2": "763104351884",
+                    "ca-west-1": "204538143572"
+                },
+                "tag_prefix": "2.1.1-tgi1.3.3",
+                "repository": "huggingface-pytorch-tgi-inference",
+                "container_version": {
+                    "gpu": "cu121-ubuntu20.04"
+                }
             }
         }
     }
-}
+}

src/sagemaker/jumpstart/filters.py

@@ -14,7 +14,7 @@
 from __future__ import absolute_import
 from ast import literal_eval
 from enum import Enum
-from typing import Dict, List, Union, Any
+from typing import Dict, List, Optional, Union, Any
 
 from sagemaker.jumpstart.types import JumpStartDataHolderType
 
@@ -38,6 +38,10 @@ class FilterOperators(str, Enum):
     NOT_EQUALS = "not_equals"
     IN = "in"
     NOT_IN = "not_in"
+    INCLUDES = "includes"
+    NOT_INCLUDES = "not_includes"
+    BEGINS_WITH = "begins_with"
+    ENDS_WITH = "ends_with"
 
 
 class SpecialSupportedFilterKeys(str, Enum):
@@ -52,6 +56,10 @@ class SpecialSupportedFilterKeys(str, Enum):
     FilterOperators.NOT_EQUALS: ["!==", "!=", "not equals", "is not"],
     FilterOperators.IN: ["in"],
     FilterOperators.NOT_IN: ["not in"],
+    FilterOperators.INCLUDES: ["includes", "contains"],
+    FilterOperators.NOT_INCLUDES: ["not includes", "not contains"],
+    FilterOperators.BEGINS_WITH: ["begins with", "starts with"],
+    FilterOperators.ENDS_WITH: ["ends with"],
 }
 
 
@@ -62,7 +70,19 @@ class SpecialSupportedFilterKeys(str, Enum):
 )
 
 ACCEPTABLE_OPERATORS_IN_PARSE_ORDER = (
-    list(map(_PAD_ALPHABETIC_OPERATOR, FILTER_OPERATOR_STRING_MAPPINGS[FilterOperators.NOT_EQUALS]))
+    list(
+        map(_PAD_ALPHABETIC_OPERATOR, FILTER_OPERATOR_STRING_MAPPINGS[FilterOperators.BEGINS_WITH])
+    )
+    + list(
+        map(_PAD_ALPHABETIC_OPERATOR, FILTER_OPERATOR_STRING_MAPPINGS[FilterOperators.ENDS_WITH])
+    )
+    + list(
+        map(_PAD_ALPHABETIC_OPERATOR, FILTER_OPERATOR_STRING_MAPPINGS[FilterOperators.NOT_INCLUDES])
+    )
+    + list(map(_PAD_ALPHABETIC_OPERATOR, FILTER_OPERATOR_STRING_MAPPINGS[FilterOperators.INCLUDES]))
+    + list(
+        map(_PAD_ALPHABETIC_OPERATOR, FILTER_OPERATOR_STRING_MAPPINGS[FilterOperators.NOT_EQUALS])
+    )
     + list(map(_PAD_ALPHABETIC_OPERATOR, FILTER_OPERATOR_STRING_MAPPINGS[FilterOperators.NOT_IN]))
     + list(map(_PAD_ALPHABETIC_OPERATOR, FILTER_OPERATOR_STRING_MAPPINGS[FilterOperators.EQUALS]))
     + list(map(_PAD_ALPHABETIC_OPERATOR, FILTER_OPERATOR_STRING_MAPPINGS[FilterOperators.IN]))
@@ -428,9 +448,96 @@ def parse_filter_string(filter_string: str) -> ModelFilter:
     raise ValueError(f"Cannot parse filter string: {filter_string}")
 
 
+def _negate_boolean(boolean: BooleanValues) -> BooleanValues:
+    """Negates boolean expression (False -> True, True -> False)."""
+    if boolean == BooleanValues.TRUE:
+        return BooleanValues.FALSE
+    if boolean == BooleanValues.FALSE:
+        return BooleanValues.TRUE
+    return boolean
+
+
+def _evaluate_filter_expression_equals(
+    model_filter: ModelFilter,
+    cached_model_value: Optional[Union[str, bool, int, float, Dict[str, Any], List[Any]]],
+) -> BooleanValues:
+    """Evaluates filter expressions for equals."""
+    if cached_model_value is None:
+        return BooleanValues.FALSE
+    model_filter_value = model_filter.value
+    if isinstance(cached_model_value, bool):
+        cached_model_value = str(cached_model_value).lower()
+        model_filter_value = model_filter.value.lower()
+    if str(model_filter_value) == str(cached_model_value):
+        return BooleanValues.TRUE
+    return BooleanValues.FALSE
+
+
+def _evaluate_filter_expression_in(
+    model_filter: ModelFilter,
+    cached_model_value: Optional[Union[str, bool, int, float, Dict[str, Any], List[Any]]],
+) -> BooleanValues:
+    """Evaluates filter expressions for string/list in."""
+    if cached_model_value is None:
+        return BooleanValues.FALSE
+    py_obj = model_filter.value
+    try:
+        py_obj = literal_eval(py_obj)
+        try:
+            iter(py_obj)
+        except TypeError:
+            return BooleanValues.FALSE
+    except Exception:  # pylint: disable=W0703
+        pass
+    if isinstance(cached_model_value, list):
+        return BooleanValues.FALSE
+    if cached_model_value in py_obj:
+        return BooleanValues.TRUE
+    return BooleanValues.FALSE
+
+
+def _evaluate_filter_expression_includes(
+    model_filter: ModelFilter,
+    cached_model_value: Optional[Union[str, bool, int, float, Dict[str, Any], List[Any]]],
+) -> BooleanValues:
+    """Evaluates filter expressions for string includes."""
+    if cached_model_value is None:
+        return BooleanValues.FALSE
+    filter_value = str(model_filter.value)
+    if filter_value in cached_model_value:
+        return BooleanValues.TRUE
+    return BooleanValues.FALSE
+
+
+def _evaluate_filter_expression_begins_with(
+    model_filter: ModelFilter,
+    cached_model_value: Optional[Union[str, bool, int, float, Dict[str, Any], List[Any]]],
+) -> BooleanValues:
+    """Evaluates filter expressions for string begins with."""
+    if cached_model_value is None:
+        return BooleanValues.FALSE
+    filter_value = str(model_filter.value)
+    if cached_model_value.startswith(filter_value):
+        return BooleanValues.TRUE
+    return BooleanValues.FALSE
+
+
+def _evaluate_filter_expression_ends_with(
+    model_filter: ModelFilter,
+    cached_model_value: Optional[Union[str, bool, int, float, Dict[str, Any], List[Any]]],
+) -> BooleanValues:
+    """Evaluates filter expressions for string ends with."""
+    if cached_model_value is None:
+        return BooleanValues.FALSE
+    filter_value = str(model_filter.value)
+    if cached_model_value.endswith(filter_value):
+        return BooleanValues.TRUE
+    return BooleanValues.FALSE
+
+
 def evaluate_filter_expression(  # pylint: disable=too-many-return-statements
     model_filter: ModelFilter,
-    cached_model_value: Union[str, bool, int, float, Dict[str, Any], List[Any]],
+    cached_model_value: Optional[Union[str, bool, int, float, Dict[str, Any], List[Any]]],
 ) -> BooleanValues:
     """Evaluates model filter with cached model spec value, returns boolean.
 
@@ -440,36 +547,29 @@ def evaluate_filter_expression(  # pylint: disable=too-many-return-statements
             evaluate the filter.
     """
     if model_filter.operator in FILTER_OPERATOR_STRING_MAPPINGS[FilterOperators.EQUALS]:
-        model_filter_value = model_filter.value
-        if isinstance(cached_model_value, bool):
-            cached_model_value = str(cached_model_value).lower()
-            model_filter_value = model_filter.value.lower()
-        if str(model_filter_value) == str(cached_model_value):
-            return BooleanValues.TRUE
-        return BooleanValues.FALSE
+        return _evaluate_filter_expression_equals(model_filter, cached_model_value)
+
     if model_filter.operator in FILTER_OPERATOR_STRING_MAPPINGS[FilterOperators.NOT_EQUALS]:
-        if isinstance(cached_model_value, bool):
-            cached_model_value = str(cached_model_value).lower()
-            model_filter.value = model_filter.value.lower()
-        if str(model_filter.value) == str(cached_model_value):
-            return BooleanValues.FALSE
-        return BooleanValues.TRUE
+        return _negate_boolean(_evaluate_filter_expression_equals(model_filter, cached_model_value))
+
     if model_filter.operator in FILTER_OPERATOR_STRING_MAPPINGS[FilterOperators.IN]:
-        py_obj = literal_eval(model_filter.value)
-        try:
-            iter(py_obj)
-        except TypeError:
-            return BooleanValues.FALSE
-        if cached_model_value in py_obj:
-            return BooleanValues.TRUE
-        return BooleanValues.FALSE
+        return _evaluate_filter_expression_in(model_filter, cached_model_value)
+
     if model_filter.operator in FILTER_OPERATOR_STRING_MAPPINGS[FilterOperators.NOT_IN]:
-        py_obj = literal_eval(model_filter.value)
-        try:
-            iter(py_obj)
-        except TypeError:
-            return BooleanValues.TRUE
-        if cached_model_value in py_obj:
-            return BooleanValues.FALSE
-        return BooleanValues.TRUE
+        return _negate_boolean(_evaluate_filter_expression_in(model_filter, cached_model_value))
+
+    if model_filter.operator in FILTER_OPERATOR_STRING_MAPPINGS[FilterOperators.INCLUDES]:
+        return _evaluate_filter_expression_includes(model_filter, cached_model_value)
+
+    if model_filter.operator in FILTER_OPERATOR_STRING_MAPPINGS[FilterOperators.NOT_INCLUDES]:
+        return _negate_boolean(
+            _evaluate_filter_expression_includes(model_filter, cached_model_value)
+        )
+
+    if model_filter.operator in FILTER_OPERATOR_STRING_MAPPINGS[FilterOperators.BEGINS_WITH]:
+        return _evaluate_filter_expression_begins_with(model_filter, cached_model_value)
+
+    if model_filter.operator in FILTER_OPERATOR_STRING_MAPPINGS[FilterOperators.ENDS_WITH]:
+        return _evaluate_filter_expression_ends_with(model_filter, cached_model_value)
+
     raise RuntimeError(f"Bad operator: {model_filter.operator}")