tsbootstrap 0.1.2__tar.gz → 0.1.4__tar.gz

{tsbootstrap-0.1.2/src/tsbootstrap.egg-info → tsbootstrap-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tsbootstrap
-Version: 0.1.2
+Version: 0.1.4
 Summary: A Python package to generate bootstrapped time series
 Author-email: Sankalp Gilda <sankalp.gilda@gmail.com>
 Maintainer-email: Sankalp Gilda <sankalp.gilda@gmail.com>, Franz Kiraly <franz.kiraly@sktime.net>, Benedikt Heidrich <benedikt.heidrich@sktime.net>
@@ -34,25 +34,25 @@ Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: Unix
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Python: <3.13,>=3.8
+Requires-Python: <3.13,>=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy<1.27,>=1.21
-Requires-Dist: scikit-base<=0.9.0,>=0.8.0
-Requires-Dist: scikit-learn<=1.5.1,>=0.24
-Requires-Dist: scipy<2.0.0,>=1.2
-Requires-Dist: packaging
+Requires-Dist: scikit-base<0.11,>=0.10.0
+Requires-Dist: scikit-learn<1.6.0,>=1.5.1
+Requires-Dist: scipy<1.14.0,>=1.13
+Requires-Dist: packaging<24.2,>=24.0
+Requires-Dist: pydantic<3.0,>=2.0
 Provides-Extra: all-extras
-Requires-Dist: arch<=7.0.0,>=5.0.0; extra == "all-extras"
+Requires-Dist: arch<7.1.0,>=7.0.0; extra == "all-extras"
 Requires-Dist: hmmlearn<0.3.2,>=0.3.0; extra == "all-extras"
 Requires-Dist: pyclustering<0.11.0,>=0.10.0; extra == "all-extras"
 Requires-Dist: scikit_learn_extra<0.4.0,>=0.3.0; extra == "all-extras"
-Requires-Dist: statsmodels<0.15.0,>=0.12.1; extra == "all-extras"
+Requires-Dist: statsmodels<0.15.0,>=0.14.2; extra == "all-extras"
 Requires-Dist: dtaidistance; python_version < "3.10" and extra == "all-extras"
 Provides-Extra: docs
 Requires-Dist: furo; extra == "docs"
@@ -106,6 +106,8 @@ Requires-Dist: tomlkit; extra == "dev"
         <img src="https://img.shields.io/badge/Pytest-0A9EDC.svg?stylee&logo=Pytest&logoColor=white" alt="pytest" />
         <img src="https://img.shields.io/badge/GitHub%20Actions-2088FF.svg?style&logo=GitHub-Actions&logoColor=white" alt="actions" />
     </p>
+    <a href="https://arxiv.org/abs/2404.15227"><img src="https://img.shields.io/static/v1?label=arXiv&message=2404.15227&color=B31B1B&logo=arXiv" alt="preprint">
+    </a>
     <a href="https://pypi.org/project/tsbootstrap/">
         <img src="https://img.shields.io/pypi/v/tsbootstrap?color=5D6D7E&logo=pypi" alt="pypi-version" />
     </a>
@@ -165,12 +167,13 @@ X = np.arange(n_samples)
 n_bootstraps = 3
 block_length = 3
 rng = 42
-mbb = MovingBlockBootstrap(n_bootstraps=n_bootstraps, rng=rng, block_length=block_length)
+mbb = MovingBlockBootstrap(
+    n_bootstraps=n_bootstraps, rng=rng, block_length=block_length
+)
 
 # Generate bootstrapped samples
 return_indices = False
-bootstrapped_samples = mbb.bootstrap(
-    X, return_indices=return_indices)
+bootstrapped_samples = mbb.bootstrap(X, return_indices=return_indices)
 
 # Collect bootstrap samples
 X_bootstrapped = []
@@ -186,7 +189,7 @@ X_bootstrapped = np.array(X_bootstrapped)
 
 #### ✔️ Prerequisites
 
-- Python (3.8 or higher)
+- Python (3.9 or higher)
 - `pip` (latest version recommended), plus suitable environment manager (`venv`, `conda`)
 
 You can also consider using ``uv`` to speed up environment setu.

{tsbootstrap-0.1.2 → tsbootstrap-0.1.4}/README.md

@@ -16,6 +16,8 @@
         <img src="https://img.shields.io/badge/Pytest-0A9EDC.svg?stylee&logo=Pytest&logoColor=white" alt="pytest" />
         <img src="https://img.shields.io/badge/GitHub%20Actions-2088FF.svg?style&logo=GitHub-Actions&logoColor=white" alt="actions" />
     </p>
+    <a href="https://arxiv.org/abs/2404.15227"><img src="https://img.shields.io/static/v1?label=arXiv&message=2404.15227&color=B31B1B&logo=arXiv" alt="preprint">
+    </a>
     <a href="https://pypi.org/project/tsbootstrap/">
         <img src="https://img.shields.io/pypi/v/tsbootstrap?color=5D6D7E&logo=pypi" alt="pypi-version" />
     </a>
@@ -75,12 +77,13 @@ X = np.arange(n_samples)
 n_bootstraps = 3
 block_length = 3
 rng = 42
-mbb = MovingBlockBootstrap(n_bootstraps=n_bootstraps, rng=rng, block_length=block_length)
+mbb = MovingBlockBootstrap(
+    n_bootstraps=n_bootstraps, rng=rng, block_length=block_length
+)
 
 # Generate bootstrapped samples
 return_indices = False
-bootstrapped_samples = mbb.bootstrap(
-    X, return_indices=return_indices)
+bootstrapped_samples = mbb.bootstrap(X, return_indices=return_indices)
 
 # Collect bootstrap samples
 X_bootstrapped = []
@@ -96,7 +99,7 @@ X_bootstrapped = np.array(X_bootstrapped)
 
 #### ✔️ Prerequisites
 
-- Python (3.8 or higher)
+- Python (3.9 or higher)
 - `pip` (latest version recommended), plus suitable environment manager (`venv`, `conda`)
 
 You can also consider using ``uv`` to speed up environment setu.

{tsbootstrap-0.1.2 → tsbootstrap-0.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tsbootstrap"
-version = "0.1.2"
+version = "0.1.4"
 description = "A Python package to generate bootstrapped time series"
 maintainers = [
     { name = "Sankalp Gilda", email = "sankalp.gilda@gmail.com" },
@@ -12,7 +12,7 @@ authors = [
 ]
 license = { file = "LICENSE" }
 readme = "README.md"
-requires-python = ">=3.8,<3.13"
+requires-python = ">=3.9,<3.13"
 classifiers = [
     "Development Status :: 4 - Beta",
     "Intended Audience :: Science/Research",
@@ -22,7 +22,6 @@ classifiers = [
     "Operating System :: Unix",
     "Programming Language :: Python",
     "Programming Language :: Python :: 3 :: Only",
-    "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
@@ -31,20 +30,21 @@ classifiers = [
 
 dependencies = [
     "numpy<1.27,>=1.21",
-    "scikit-base>=0.8.0,<=0.9.0",
-    "scikit-learn>=0.24,<=1.5.1",
-    "scipy>=1.2,<2.0.0",
-    "packaging",
+    "scikit-base>=0.10.0,<0.11",
+    "scikit-learn>=1.5.1,<1.6.0",
+    "scipy>=1.13,<1.14.0",
+    "packaging>=24.0,<24.2",
+    "pydantic>=2.0,<3.0",
 ]
 
 [project.optional-dependencies]
 
 all-extras = [
-    "arch>=5.0.0,<=7.0.0",
+    "arch>=7.0.0,<7.1.0",
     "hmmlearn>=0.3.0,<0.3.2",
     "pyclustering>=0.10.0,<0.11.0",
     "scikit_learn_extra>=0.3.0,<0.4.0",
-    "statsmodels>=0.12.1,<0.15.0",
+    "statsmodels>=0.14.2,<0.15.0",
     "dtaidistance; python_version < '3.10'",
 ]
 

tsbootstrap-0.1.4/src/tsbootstrap/registry/_lookup.py

@@ -0,0 +1,201 @@
+"""
+Registry lookup methods.
+
+This module exports the following methods for registry lookup:
+
+- all_objects(object_types: Optional[Union[str, List[str]]] = None,
+             filter_tags: Optional[Dict[str, Union[str, List[str], bool]]] = None,
+             exclude_objects: Optional[Union[str, List[str]]] = None,
+             return_names: bool = True,
+             as_dataframe: bool = False,
+             return_tags: Optional[Union[str, List[str]]] = None,
+             suppress_import_stdout: bool = True) -> Union[List[Any], List[Tuple]]
+    Lookup and filtering of objects in the tsbootstrap registry.
+"""
+
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from skbase.base import BaseObject
+from skbase.lookup import all_objects as _all_objects
+
+from tsbootstrap.registry._tags import (
+    OBJECT_TAG_REGISTER,
+    check_tag_is_valid,
+)
+
+VALID_OBJECT_TYPE_STRINGS: set = {tag.scitype for tag in OBJECT_TAG_REGISTER}
+
+
+def all_objects(
+    object_types: Optional[Union[str, List[str]]] = None,
+    filter_tags: Optional[
+        Union[str, Dict[str, Union[str, List[str], bool]]]
+    ] = None,
+    exclude_objects: Optional[Union[str, List[str]]] = None,
+    return_names: bool = True,
+    as_dataframe: bool = False,
+    return_tags: Optional[Union[str, List[str]]] = None,
+    suppress_import_stdout: bool = True,
+) -> Union[List[Any], List[Tuple]]:
+    """
+    Get a list of all objects from tsbootstrap.
+
+    This function crawls the module and retrieves all classes that inherit
+    from tsbootstrap's and sklearn's base classes.
+
+    Excluded from retrieval are:
+        - The base classes themselves
+        - Classes defined in test modules
+
+    Parameters
+    ----------
+    object_types : Union[str, List[str]], optional (default=None)
+        Specifies which types of objects to return.
+        - If None, no filtering is applied and all objects are returned.
+        - If str or list of str, only objects matching the specified scitypes are returned.
+          Valid scitypes are entries in `registry.BASE_CLASS_REGISTER` (first column).
+
+    filter_tags : Union[str, Dict[str, Union[str, List[str], bool]]], optional (default=None)
+        Dictionary or string to filter returned objects based on their tags.
+        - If a string, it is treated as a boolean tag filter with the value `True`.
+        - If a dictionary, each key-value pair represents a filter condition in an "AND" conjunction.
+          - Key is the tag name to filter on.
+          - Value is a string, list of strings, or boolean that the tag value must match or be within.
+        - Only objects satisfying all filter conditions are returned.
+
+    exclude_objects : Union[str, List[str]], optional (default=None)
+        Names of objects to exclude from the results.
+
+    return_names : bool, optional (default=True)
+        - If True, the object's class name is included in the returned results.
+        - If False, the class name is omitted.
+
+    as_dataframe : bool, optional (default=False)
+        - If True, returns a pandas.DataFrame with named columns for all returned attributes.
+        - If False, returns a list (of objects or tuples).
+
+    return_tags : Union[str, List[str]], optional (default=None)
+        - Names of tags to fetch and include in the returned results.
+        - If specified, tag values are appended as either columns or tuple entries.
+
+    suppress_import_stdout : bool, optional (default=True)
+        Whether to suppress stdout printout upon import.
+
+    Returns
+    -------
+    Union[List[Any], List[Tuple]]
+        Depending on the parameters:
+        1. List of objects:
+            - Entries are objects matching the query, in alphabetical order of object name.
+        2. List of tuples:
+            - Each tuple contains (optional object name, object class, optional object tags).
+            - Ordered alphabetically by object name.
+        3. pandas.DataFrame:
+            - Columns represent the returned attributes.
+            - Includes "objects", "names", and any specified tag columns.
+
+    Examples
+    --------
+    >>> from tsbootstrap.registry import all_objects
+    >>> # Return a complete list of objects as a DataFrame
+    >>> all_objects(as_dataframe=True)
+    >>> # Return all bootstrap algorithms by filtering for object type
+    >>> all_objects("bootstrap", as_dataframe=True)
+    >>> # Return all bootstraps which are block bootstraps
+    >>> all_objects(
+    ...     object_types="bootstrap",
+    ...     filter_tags={"bootstrap_type": "block"},
+    ...     as_dataframe=True
+    ... )
+
+    References
+    ----------
+    Adapted version of sktime's `all_estimators`,
+    which is an evolution of scikit-learn's `all_estimators`.
+    """
+    MODULES_TO_IGNORE = (
+        "tests",
+        "setup",
+        "contrib",
+        "utils",
+        "all",
+    )
+
+    result: Union[List[Any], List[Tuple]] = []
+    ROOT = str(
+        Path(__file__).parent.parent
+    )  # tsbootstrap package root directory
+
+    # Prepare filter_tags
+    if isinstance(filter_tags, str):
+        # Ensure the tag expects a boolean value
+        tag = next(
+            (t for t in OBJECT_TAG_REGISTER if t.name == filter_tags), None
+        )
+        if not tag:
+            raise ValueError(
+                f"Tag '{filter_tags}' not found in OBJECT_TAG_REGISTER."
+            )
+        if tag.value_type != "bool":
+            raise ValueError(
+                f"Tag '{filter_tags}' does not expect a boolean value."
+            )
+        filter_tags = {filter_tags: True}
+    elif isinstance(filter_tags, dict):
+        # Validate each tag in filter_tags
+        for key, value in filter_tags.items():
+            try:
+                if not check_tag_is_valid(key, value):
+                    raise ValueError(
+                        f"Invalid value '{value}' for tag '{key}'."
+                    )
+            except KeyError as e:
+                raise ValueError(
+                    f"Tag '{key}' not found in OBJECT_TAG_REGISTER."
+                ) from e
+    else:
+        filter_tags = None
+
+    if object_types:
+        if isinstance(object_types, str):
+            object_types = [object_types]
+        # Validate object_types
+        invalid_types = set(object_types) - VALID_OBJECT_TYPE_STRINGS
+        if invalid_types:
+            raise ValueError(
+                f"Invalid object_types: {invalid_types}. Valid types are {VALID_OBJECT_TYPE_STRINGS}."
+            )
+        if filter_tags and "object_type" not in filter_tags:
+            object_tag_filter = {"object_type": object_types}
+            filter_tags.update(object_tag_filter)
+        elif filter_tags and "object_type" in filter_tags:
+            existing_filter = filter_tags.get("object_type", [])
+            if isinstance(existing_filter, str):
+                existing_filter = [existing_filter]
+            elif isinstance(existing_filter, list):
+                pass
+            else:
+                raise ValueError(
+                    f"Unexpected type for 'object_type' filter: {type(existing_filter)}"
+                )
+            combined_filter = list(set(object_types + existing_filter))
+            filter_tags["object_type"] = combined_filter
+        else:
+            filter_tags = {"object_type": object_types}
+
+    # Retrieve objects using skbase's all_objects
+    result = _all_objects(
+        object_types=[BaseObject],
+        filter_tags=filter_tags,
+        exclude_objects=exclude_objects,
+        return_names=return_names,
+        as_dataframe=as_dataframe,
+        return_tags=return_tags,
+        suppress_import_stdout=suppress_import_stdout,
+        package_name="tsbootstrap",
+        path=ROOT,
+        modules_to_ignore=MODULES_TO_IGNORE,
+    )
+
+    return result

tsbootstrap-0.1.4/src/tsbootstrap/registry/_tags.py

@@ -0,0 +1,287 @@
+"""
+Register of estimator and object tags.
+
+Note for extenders:
+    New tags should be entered in `OBJECT_TAG_REGISTER`.
+    No other place is necessary to add new tags.
+
+This module exports the following:
+
+- OBJECT_TAG_REGISTER : List[Tag]
+    A list of Tag instances, each representing a tag with its attributes.
+
+- OBJECT_TAG_TABLE : List[Dict[str, Any]]
+    `OBJECT_TAG_REGISTER` in table form as a list of dictionaries.
+
+- OBJECT_TAG_LIST : List[str]
+    List of tag names extracted from `OBJECT_TAG_REGISTER`.
+
+- check_tag_is_valid(tag_name: str, tag_value: Any) -> bool
+    Function to validate if a tag value is valid for a given tag name.
+"""
+
+from typing import Any, Dict, List, Tuple, Union
+
+from pydantic import BaseModel, field_validator
+
+
+class Tag(BaseModel):
+    """
+    Represents a single tag with its properties.
+
+    Attributes
+    ----------
+    name : str
+        Name of the tag as used in the _tags dictionary.
+    scitype : str
+        Name of the scitype this tag applies to.
+    value_type : Union[str, Tuple[str, Union[List[str], str]], List[Union[str, Tuple[str, Union[List[str], str]]]]]
+        Expected type(s) of the tag value.
+    description : str
+        Plain English description of the tag.
+    """
+
+    name: str
+    scitype: str
+    value_type: Union[
+        str,
+        Tuple[str, Union[List[str], str]],
+        List[Union[str, Tuple[str, Union[List[str], str]]]],
+    ]
+    description: str
+
+    @field_validator("value_type")
+    @classmethod
+    def validate_value_type(cls, v):
+        """
+        Validates the `value_type` attribute to ensure it adheres to expected formats.
+
+        Parameters
+        ----------
+        v : Union[str, Tuple[str, Union[List[str], str]], List[Union[str, Tuple[str, Union[List[str], str]]]]]
+            The value to validate.
+
+        Returns
+        -------
+        Union[str, Tuple[str, Union[List[str], str]], List[Union[str, Tuple[str, Union[List[str], str]]]]]
+            The validated value.
+
+        Raises
+        ------
+        ValueError
+            If `v` does not conform to expected types and constraints.
+        TypeError
+            If `v` is neither a string, a tuple, nor a list.
+        """
+        valid_base_types = {"bool", "int", "str", "list", "dict"}
+
+        def validate_single_type(single_v):
+            if isinstance(single_v, str):
+                if single_v not in valid_base_types:
+                    raise ValueError(
+                        f"Invalid value_type: {single_v}. Must be one of {valid_base_types}."
+                    )
+            elif isinstance(single_v, tuple):
+                if len(single_v) != 2:
+                    raise ValueError(
+                        "Tuple value_type must have exactly two elements."
+                    )
+                base, subtype = single_v
+                if base not in {"str", "list"}:
+                    raise ValueError(
+                        "First element of tuple must be 'str' or 'list'."
+                    )
+                if base == "str":
+                    if not isinstance(subtype, list) or not all(
+                        isinstance(item, str) for item in subtype
+                    ):
+                        raise ValueError(
+                            "Second element must be a list of strings when base is 'str'."
+                        )
+                elif base == "list" and not (
+                    (
+                        isinstance(subtype, list)
+                        and all(isinstance(item, str) for item in subtype)
+                    )
+                    or isinstance(subtype, str)
+                ):
+                    raise ValueError(
+                        "Second element must be a list of strings or 'str' when base is 'list'."
+                    )
+            else:
+                raise TypeError(
+                    "Each value_type must be either a string or a tuple."
+                )
+
+        if isinstance(v, list):
+            if not v:
+                raise ValueError("value_type list cannot be empty.")
+            for item in v:
+                validate_single_type(item)
+        else:
+            validate_single_type(v)
+
+        return v
+
+
+# Define the OBJECT_TAG_REGISTER with Tag instances
+OBJECT_TAG_REGISTER: List[Tag] = [
+    # --------------------------
+    # All objects and estimators
+    # --------------------------
+    Tag(
+        name="object_type",
+        scitype="object",
+        value_type=("str", ["regressor", "transformer"]),
+        description="Type of object, e.g., 'regressor', 'transformer'.",
+    ),
+    Tag(
+        name="python_version",
+        scitype="object",
+        value_type="str",
+        description="Python version specifier (PEP 440) for estimator, or None for all versions.",
+    ),
+    Tag(
+        name="python_dependencies",
+        scitype="object",
+        # Allow both string and list of strings
+        value_type=["str", ("list", "str")],
+        description="Python dependencies of estimator as string or list of strings.",
+    ),
+    Tag(
+        name="python_dependencies_alias",
+        scitype="object",
+        value_type="dict",
+        description="Alias for Python dependencies if import name differs from package name. Key-value pairs are package name and import name.",
+    ),
+    # -----------------------
+    # BaseTimeSeriesBootstrap
+    # -----------------------
+    Tag(
+        name="bootstrap_type",
+        scitype="bootstrap",
+        value_type=("list", "str"),
+        description="Type(s) of bootstrap the algorithm supports.",
+    ),
+    Tag(
+        name="capability:multivariate",
+        scitype="bootstrap",
+        value_type="bool",
+        description="Whether the bootstrap algorithm supports multivariate data.",
+    ),
+    # ----------------------------
+    # BaseMetaObject reserved tags
+    # ----------------------------
+    Tag(
+        name="named_object_parameters",
+        scitype="object",
+        value_type="str",
+        description="Name of component list attribute for meta-objects.",
+    ),
+    Tag(
+        name="fitted_named_object_parameters",
+        scitype="estimator",
+        value_type="str",
+        description="Name of fitted component list attribute for meta-objects.",
+    ),
+]
+
+# Create OBJECT_TAG_TABLE as a list of dictionaries
+OBJECT_TAG_TABLE: List[Dict[str, Any]] = [
+    {
+        "name": tag.name,
+        "scitype": tag.scitype,
+        "value_type": tag.value_type,
+        "description": tag.description,
+    }
+    for tag in OBJECT_TAG_REGISTER
+]
+
+# Create OBJECT_TAG_LIST as a list of tag names
+OBJECT_TAG_LIST: List[str] = [tag.name for tag in OBJECT_TAG_REGISTER]
+
+
+def check_tag_is_valid(tag_name: str, tag_value: Any) -> bool:
+    """
+    Check whether a tag value is valid for a given tag name.
+
+    Parameters
+    ----------
+    tag_name : str
+        The name of the tag to validate.
+    tag_value : Any
+        The value to validate against the tag's expected type.
+
+    Returns
+    -------
+    bool
+        True if the tag value is valid for the tag name, False otherwise.
+
+    Raises
+    ------
+    KeyError
+        If the tag_name is not found in OBJECT_TAG_REGISTER.
+    """
+    try:
+        tag = next(tag for tag in OBJECT_TAG_REGISTER if tag.name == tag_name)
+    except StopIteration as e:
+        raise KeyError(
+            f"Tag name '{tag_name}' not found in OBJECT_TAG_REGISTER."
+        ) from e
+
+    value_type = tag.value_type
+
+    if isinstance(value_type, list):
+        # Iterate through each type definition and return True if any matches
+        for vt in value_type:
+            if isinstance(vt, str):
+                if isinstance(tag_value, str):
+                    return True
+            elif isinstance(vt, tuple):
+                base_type, subtype = vt
+                if base_type == "str":
+                    if isinstance(tag_value, str) and tag_value in subtype:
+                        return True
+                elif base_type == "list" and isinstance(tag_value, list):
+                    if subtype == "str":
+                        if all(isinstance(item, str) for item in tag_value):
+                            return True
+                    elif isinstance(subtype, list) and all(
+                        isinstance(item, str) and item in subtype
+                        for item in tag_value
+                    ):
+                        return True
+        return False
+    elif isinstance(value_type, str):
+        expected_type = value_type
+        if expected_type == "bool":
+            return isinstance(tag_value, bool)
+        elif expected_type == "int":
+            return isinstance(tag_value, int)
+        elif expected_type == "str":
+            return isinstance(tag_value, str)
+        elif expected_type == "list":
+            return isinstance(tag_value, list)
+        elif expected_type == "dict":
+            return isinstance(tag_value, dict)
+        else:
+            return False
+    elif isinstance(value_type, tuple):
+        base_type, subtype = value_type
+        if base_type == "str":
+            if isinstance(tag_value, str):
+                return tag_value in subtype
+            return False
+        elif base_type == "list":
+            if not isinstance(tag_value, list):
+                return False
+            if isinstance(subtype, list):
+                return all(
+                    isinstance(item, str) and item in subtype
+                    for item in tag_value
+                )
+            elif subtype == "str":
+                return all(isinstance(item, str) for item in tag_value)
+        return False
+    else:
+        return False