streamlit-octostar-utils 0.5.5.dev1__tar.gz → 0.5.6.dev2__tar.gz

{streamlit_octostar_utils-0.5.5.dev1 → streamlit_octostar_utils-0.5.6.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: streamlit-octostar-utils
-Version: 0.5.5.dev1
+Version: 0.5.6.dev2
 Summary: 
 License: MIT
 License-File: LICENSE

{streamlit_octostar_utils-0.5.5.dev1 → streamlit_octostar_utils-0.5.6.dev2}/pyproject.toml

@@ -5,7 +5,7 @@ include = '\.pyi?$'
 
 [tool.poetry]
 name = "streamlit-octostar-utils"
-version = "0.5.5-dev.1"
+version = "0.5.6-dev.2"
 description = ""
 license = "MIT"
 authors = ["Octostar"]

{streamlit_octostar_utils-0.5.5.dev1 → streamlit_octostar_utils-0.5.6.dev2}/streamlit_octostar_utils/api_crafter/nifi.py

@@ -17,7 +17,6 @@ from starlette.exceptions import HTTPException as StarletteHTTPException
 
 from octostar.utils.workspace import upsert_entities
 from octostar.utils.ontology import fetch_ontology_data
-from octostar.utils.workspace.permissions import get_permissions, PermissionLevel
 from octostar.utils.pipeline import update_processing_status
 
 from octostar.client import make_client
@@ -54,144 +53,6 @@ OS_RESERVED_FIELDS = [
 MAX_IN_MEMORY_SIZE_BYTES = 5_242_880
 
 
-class NifiPriority:
-    COMPONENT_WIDTHS = (10, 10, 1, 20)
-    SEPARATOR = "."
-    MAX_FRAGMENT_DEPTH = 9
-    BASE62_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
-    BASE = len(BASE62_CHARS)
-    _BASE62_SET = frozenset(BASE62_CHARS)
-
-    @staticmethod
-    def _normalize_component(value, width):
-        if value is None:
-            return "z" * width
-        s = str(value)
-        invalid = set(s) - NifiPriority._BASE62_SET
-        if invalid:
-            raise ValueError(f"Invalid base62 character(s): {sorted(invalid)!r}")
-        if len(s) > width:
-            return "z" * width
-        return s.rjust(width, "0")
-
-    def __init__(self, op_reserved=None, user_prio=None, fragment_prio=0, entity_timestamp=0):
-        w = self.COMPONENT_WIDTHS
-        self.op_reserved = self._normalize_component(op_reserved, w[0])
-        self.user_prio = self._normalize_component(user_prio, w[1])
-        self.fragment_prio = int(fragment_prio)
-        self.entity_timestamp = int(entity_timestamp)
-
-    @staticmethod
-    def _encode_base62(value, width):
-        chars = NifiPriority.BASE62_CHARS
-        base = NifiPriority.BASE
-        if value < 0:
-            value = 0
-        if value == 0:
-            return "0" * width
-        result = []
-        v = value
-        while v > 0:
-            result.append(chars[v % base])
-            v //= base
-        result.reverse()
-        s = "".join(result)
-        if len(s) > width:
-            return chars[-1] * width
-        return s.rjust(width, "0")
-
-    @staticmethod
-    def _decode_base62(s):
-        chars = NifiPriority.BASE62_CHARS
-        result = 0
-        for c in s:
-            idx = chars.find(c)
-            if idx < 0:
-                raise ValueError(f"Invalid base62 character: {c!r}")
-            result = result * NifiPriority.BASE + idx
-        return result
-
-    @classmethod
-    def from_string(cls, s):
-        if not s or cls.SEPARATOR not in s:
-            return cls()
-        parts = s.split(cls.SEPARATOR)
-        if len(parts) != 4:
-            return cls()
-        try:
-            for part in parts:
-                if set(part) - cls._BASE62_SET:
-                    return cls()
-            return cls(
-                op_reserved=parts[0],
-                user_prio=parts[1],
-                fragment_prio=cls._decode_base62(parts[2]),
-                entity_timestamp=cls._decode_base62(parts[3]),
-            )
-        except (ValueError, TypeError):
-            return cls()
-
-    @classmethod
-    def from_dict(cls, d):
-        if not d:
-            return cls()
-        return cls(
-            op_reserved=d.get("op_reserved"),
-            user_prio=d.get("user_prio"),
-            fragment_prio=d.get("fragment_prio", 0),
-            entity_timestamp=d.get("entity_timestamp", 0),
-        )
-
-    @classmethod
-    def from_entity(cls, entity):
-        existing = entity.request.get("priority", {})
-        prio = cls.from_dict(existing)
-        prio.fragment_prio = cls.compute_fragment_depth(entity)
-        ts_str = entity.request.get("entity_timestamp")
-        if ts_str:
-            try:
-                dt = string_to_datetime(ts_str)
-                prio.entity_timestamp = int(dt.timestamp() * 1000)
-            except Exception:
-                prio.entity_timestamp = 0
-        else:
-            prio.entity_timestamp = 0
-        return prio
-
-    @staticmethod
-    def compute_fragment_depth(entity):
-        stack = entity.request.get("config", {}).get("fragment", {}).get("fragments_stack", [])
-        depth = 0
-        for key in stack:
-            try:
-                info = NifiFragmenter.get_fragment_info(entity, key)
-                if info.get("index", 0) != 0:
-                    depth += 1
-                else:
-                    break
-            except (KeyError, RuntimeError):
-                break
-        return min(depth, 9)
-
-    def to_string(self):
-        w = self.COMPONENT_WIDTHS
-        return self.SEPARATOR.join([
-            self.op_reserved,
-            self.user_prio,
-            self._encode_base62(self.fragment_prio, w[2]),
-            self._encode_base62(self.entity_timestamp, w[3]),
-        ])
-
-    def to_dict(self):
-        return {
-            "op_reserved": self.op_reserved,
-            "user_prio": self.user_prio,
-        }
-
-    def apply_to_entity(self, entity):
-        entity.request["priority"] = self.to_dict()
-
-
 class NifiProxyEntityModel(BaseModel):
     entity_id: str
     entity_type: str
@@ -223,8 +84,6 @@ class NifiEntityModel(BaseModel):
         is_temporary: bool = False
         exception: dict = Field(default_factory=dict)
         last_processor_name: Optional[str] = None
-        fallback_os_workspace: Optional[str] = None
-        priority: dict = Field(default_factory=dict)
 
     class RecordModel(BaseModel):
         model_config = ConfigDict(extra="allow")
@@ -614,7 +473,6 @@ class NifiContextManager(object):
     def __init__(self, json_data, lazy_sync=True):
         if not json_data:
             raise ValueError("Nifi context manager received list of 0 entities")
-        self.permissions = {}
         self.in_batches = None
         self.out_entities = None
         self.nonlazy_sync_ids = set()
@@ -667,8 +525,6 @@ class NifiContextManager(object):
             key=lambda x: string_to_datetime(x.request.get("entity_timestamp")),
         )
         entities = list({e.record["entity_id"]: e for e in entities}.values())
-        for entity in entities:
-            NifiPriority.from_entity(entity).apply_to_entity(entity)
         entities = [
             (
                 jsondict_hash(NifiContextManager._config_get(entity, processor_name)),
@@ -693,16 +549,6 @@ class NifiContextManager(object):
     def __enter__(self):
         return self
 
-    def get_workspaces_permissions(self, workspace_ids):
-        permissions_to_fetch = list(set(workspace_ids).difference(set(list(self.permissions.keys()))))
-        if permissions_to_fetch:
-            permissions = get_permissions.sync(permissions_to_fetch, client=self.client)
-            self.permissions.update(permissions)
-        permissions = {}
-        for k in workspace_ids:
-            permissions[k] = self.permissions.get(k, PermissionLevel.NONE)
-        return permissions
-
     def request_entity_sync(
         self,
         entity,
@@ -743,9 +589,6 @@ class NifiContextManager(object):
         )
         self.out_entities = list({e.record["entity_id"]: e for e in all_entities}.values())
         self.sync_entities()
-        for entity in self.out_entities:
-            prio = NifiPriority.from_entity(entity)
-            entity.request["nifi_attributes"]["priority"] = prio.to_string()
         return [entity for entity in self.jsonify(self.out_entities)["content"]]
 
     def raise_exception(self, entity, exc):
@@ -772,16 +615,18 @@ class NifiContextManager(object):
         import logging
         _lock_logger = logging.getLogger(__name__)
 
-        records = []
-        for e in entities:
-            if isinstance(e, dict):
-                records.append(
-                    (e, e.get("entity_timestamp"))
-                )
-            else:
-                records.append(
-                    (e.record, e.request.get("entity_timestamp") if e.request else None)
-                )
+        def _read_entries():
+            entries = []
+            for e in entities:
+                if isinstance(e, dict):
+                    entries.append((e, e.get("entity_timestamp")))
+                else:
+                    entries.append(
+                        (e.record, e.request.get("entity_timestamp") if e.request else None)
+                    )
+            return entries
+
+        records = _read_entries()
 
         long_expiry = (datetime.now(timezone.utc) + timedelta(seconds=timeout)).strftime("%Y-%m-%dT%H:%M:%SZ")
         statuses = [
@@ -815,6 +660,7 @@ class NifiContextManager(object):
         try:
             yield True
         finally:
+            records = _read_entries()
             short_expiry = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
             statuses = [
                 {
@@ -849,10 +695,8 @@ class NifiContextManager(object):
             self._sync_upsert_entities(entities_to_upsert)
         self._sync_fetch_relationships(entities, fetch_rel_entities, fetch_concept_rels)
 
-        now_ts = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
         for entity in all_entities_to_modify:
             entity.request["is_temporary"] = False
-            entity.request["entity_timestamp"] = now_ts
 
         for entity in entities:
             entity.sync_params = {}
@@ -1114,29 +958,7 @@ class NifiEntity(object):
 
     @property
     def write_os_workspace(self):
-        permissions = self.context.get_workspaces_permissions(
-            [
-                e
-                for e in [
-                    self.record.get("os_workspace"),
-                    self.request.get("fallback_os_workspace"),
-                ]
-                if e
-            ]
-        )
-        if (
-            self.record.get("os_workspace")
-            and (permissions.get(self.record.get("os_workspace")) or PermissionLevel.NONE) >= PermissionLevel.WRITE
-        ):
-            return self.record["os_workspace"]
-        elif (
-            self.request.get("fallback_os_workspace")
-            and (permissions.get(self.request.get("fallback_os_workspace")) or PermissionLevel.NONE)
-            >= PermissionLevel.WRITE
-        ):
-            return self.request["fallback_os_workspace"]
-        else:
-            return None
+        return self.record.get("os_workspace")
 
     @property
     def label(self):
@@ -1164,29 +986,6 @@ class NifiEntity(object):
             options={"verify_signature": False},
         )
 
-    @property
-    def priority(self):
-        return NifiPriority.from_entity(self)
-
-    @priority.setter
-    def priority(self, value):
-        if isinstance(value, NifiPriority):
-            self.request["priority"] = value.to_dict()
-        elif isinstance(value, dict):
-            self.request["priority"] = value
-        else:
-            raise TypeError("priority must be a NifiPriority or dict")
-
-    def set_user_priority(self, value):
-        prio = self.priority
-        prio.user_prio = NifiPriority._normalize_component(value, NifiPriority.COMPONENT_WIDTHS[1])
-        self.priority = prio
-
-    def set_op_priority(self, value):
-        prio = self.priority
-        prio.op_reserved = NifiPriority._normalize_component(value, NifiPriority.COMPONENT_WIDTHS[0])
-        self.priority = prio
-
     def update_last_timestamp(self):
         self.record["os_last_updated_at"] = now()
 
@@ -1377,8 +1176,6 @@ class NifiEntity(object):
             "is_temporary": True,
             "exception": {},
             "last_processor_name": None,
-            "fallback_os_workspace": self.request["fallback_os_workspace"],
-            "priority": deepcopy(self.request.get("priority", {})),
         }
         child_entity = NifiEntity(
             self.context,
@@ -1604,6 +1401,7 @@ class NifiEntity(object):
         os_entity_uid=None,
         os_relationship_uid=None,
         os_entity_type=FRAGMENT_ENTITY_NAME,
+        os_parent_uid=None,
         previous_fragment_uid=None,
         previous_fragment_relationship_uid=None,
         previous_fragment_relationship=PREVIOUS_FRAGMENT_RELATIONSHIP,
@@ -1616,7 +1414,7 @@ class NifiEntity(object):
         fields = {
             **{k: v for k, v in self.record.items() if k.startswith("fragment") and v is not None},
             **fields,
-            "os_parent_uid": self.record["os_entity_uid"],
+            "os_parent_uid": os_parent_uid or self.record["os_entity_uid"],
             "source_entity_uid": source_entity_uid,
             "previous_entity_uid": previous_fragment_uid,
             "next_entity_uid": next_fragment_uid,

streamlit_octostar_utils-0.5.6.dev2/streamlit_octostar_utils/core/opensearch_conversion.py

@@ -0,0 +1,354 @@
+"""Mapping-aware client-side conversion of Python values to OpenSearch types.
+
+Recursively walks a data dict alongside an OpenSearch index mapping and
+coerces Python values so they match the expected field types (text, keyword,
+integer, date, binary, knn_vector, nested, etc.).
+
+Primary entry point:
+    ``convert_clientside(data, curr_mapping)``
+
+The *curr_mapping* can be either the raw ``{"properties": {...}}`` tree or
+just the inner ``properties`` dict -- the function handles both.
+"""
+
+from .dict import travel_dict
+from .timestamp import string_to_datetime
+import json
+import base64
+import logging
+import datetime as dt
+from typing import Dict, Any
+
+logger = logging.getLogger(__name__)
+
+vector_nomenclature_order = [
+    "model_name",
+    "dim",
+    "model_version",
+]
+
+conversion_matrix = {
+    ("str", "text"): lambda d: (d, False),
+    ("str", "keyword"): lambda d: (d, False),
+    ("str", "boolean"): lambda d: (bool(d), False),
+    ("str", "integer"): lambda d: (int(d), False),
+    ("str", "long"): lambda d: (int(d), False),
+    ("str", "float"): lambda d: (float(d), False),
+    ("str", "double"): lambda d: (float(d), False),
+    ("str", "date"): lambda d: (
+        string_to_datetime(d).strftime("%Y-%m-%dT%H:%M:%SZ"),
+        False,
+    ),
+    ("str", "binary"): lambda d: (
+        base64.b64encode(d.encode("utf-8")).decode("utf-8"),
+        False,
+    ),
+    ("str", "object"): lambda d: (json.loads(d), True),
+    ("str", "nested"): lambda d: (json.loads(d), True),
+    ("bool", "text"): lambda d: (str(d), False),
+    ("bool", "keyword"): lambda d: (str(d), False),
+    ("bool", "boolean"): lambda d: (d, False),
+    ("bool", "integer"): lambda d: (int(d), False),
+    ("bool", "long"): lambda d: (int(d), False),
+    ("bool", "float"): lambda d: (float(int(d)), False),
+    ("bool", "double"): lambda d: (float(int(d)), False),
+    ("bool", "binary"): lambda d: (
+        base64.b64encode(str(int(d)).encode("utf-8")).decode("utf-8"),
+        False,
+    ),
+    ("int", "text"): lambda d: (str(d), False),
+    ("int", "keyword"): lambda d: (str(d), False),
+    ("int", "boolean"): lambda d: (bool(d), False),
+    ("int", "integer"): lambda d: (d, False),
+    ("int", "long"): lambda d: (d, False),
+    ("int", "float"): lambda d: (float(d), False),
+    ("int", "double"): lambda d: (float(d), False),
+    ("int", "date"): lambda d: (
+        dt.datetime.fromtimestamp(d).strftime("%Y-%m-%dT%H:%M:%SZ"),
+        False,
+    ),
+    ("int", "binary"): lambda d: (
+        base64.b64encode(str(d).encode("utf-8")).decode("utf-8"),
+        False,
+    ),
+    ("float", "text"): lambda d: (str(d), False),
+    ("float", "keyword"): lambda d: (str(d), False),
+    ("float", "boolean"): lambda d: (bool(d), False),
+    ("float", "integer"): lambda d: (int(d), False),
+    ("float", "long"): lambda d: (int(d), False),
+    ("float", "float"): lambda d: (d, False),
+    ("float", "double"): lambda d: (d, False),
+    ("float", "date"): lambda d: (
+        dt.datetime.fromtimestamp(int(d)).strftime("%Y-%m-%dT%H:%M:%SZ"),
+        False,
+    ),
+    ("float", "binary"): lambda d: (
+        base64.b64encode(str(d).encode("utf-8")).decode("utf-8"),
+        False,
+    ),
+    ("bytes", "text"): lambda d: (d.decode("utf-8"), False),
+    ("bytes", "keyword"): lambda d: (d.decode("utf-8"), False),
+    ("bytes", "boolean"): lambda d: (
+        d.decode("utf-8").lower() in ["true", "1", "yes", "y", "on"],
+        False,
+    ),
+    ("bytes", "integer"): lambda d: (int(d.decode("utf-8")), False),
+    ("bytes", "long"): lambda d: (int(d.decode("utf-8")), False),
+    ("bytes", "float"): lambda d: (float(d.decode("utf-8")), False),
+    ("bytes", "double"): lambda d: (float(d.decode("utf-8")), False),
+    ("bytes", "date"): lambda d: (
+        string_to_datetime(d.decode("utf-8")).strftime("%Y-%m-%dT%H:%M:%SZ"),
+        False,
+    ),
+    ("bytes", "binary"): lambda d: (base64.b64encode(d).decode("utf-8"), False),
+    ("bytes", "object"): lambda d: (json.loads(d.decode("utf-8")), True),
+    ("bytes", "nested"): lambda d: (json.loads(d.decode("utf-8")), True),
+    ("dict", "text"): lambda d: (json.dumps(d), False),
+    ("dict", "keyword"): lambda d: (json.dumps(d), False),
+    ("dict", "boolean"): lambda d: (bool(d), False),
+    ("dict", "object"): lambda d: (d, True),
+    ("dict", "nested"): lambda d: (d, True),
+}
+
+
+def has_opensearch_type(mapping):
+    return "type" in mapping and isinstance(mapping["type"], str)
+
+
+def has_opensearch_properties(mapping):
+    return (
+        "properties" in mapping
+        and isinstance(mapping["properties"], dict)
+        and ("type" not in mapping or has_opensearch_type(mapping))
+    )
+
+
+def mapping_from_data(data, mapping):
+    python_to_os_types = {
+        "str": "text",
+        "bool": "boolean",
+        "int": "long",
+        "float": "double",
+    }
+    if not mapping:
+        mapping = {}
+    if data is None:
+        return mapping
+    datatype = type(data).__name__
+    if datatype == "NoneType" or data == {} or data == []:
+        return {}
+    if datatype not in ["str", "bool", "int", "float", "bytes", "dict", "list"]:
+        raise TypeError()
+    elif datatype == "dict":
+        for key, value in data.items():
+            mapping[key] = mapping_from_data(value, {})
+    elif datatype == "list":
+        mapping = mapping_from_data(data[0], {})
+    else:
+        if datatype == "bytes":
+            datatype = "str"
+        datatype = python_to_os_types[datatype]
+        if datatype == "text":
+            try:
+                dt.datetime.fromisoformat(data)
+                datatype = "date"
+            except Exception:
+                pass
+        mapping = {"type": datatype}
+    return mapping
+
+
+def convert_data_type(data, curr_mapping, key):
+    data_elem = travel_dict(data, key, "r", True)
+    if data_elem is None or data_elem == []:
+        return
+    data_type = type(data_elem).__name__
+    if not curr_mapping:
+        curr_mapping = mapping_from_data(data_elem, {})
+    if not has_opensearch_type(curr_mapping):
+        mapping_type = "object"
+    else:
+        mapping_type = curr_mapping.get("type", "object")
+    recurse = False
+    try:
+        converted_elem, recurse = conversion_matrix[(data_type, mapping_type)](
+            data_elem
+        )
+    except BaseException as e:
+        logger.warning(f"{type(e).__name__}: {str(e)}")
+        converted_elem = None
+    if converted_elem and recurse:
+        converted_elem = convert_clientside(converted_elem, curr_mapping)
+    travel_dict(data, key, "w", True)(converted_elem)
+
+
+def handle_incompatible_data_type(data, key):
+    value = travel_dict(data, key, "r", True)
+    datatype = type(value).__name__
+    if datatype == "NoneType":
+        return data
+    if datatype not in ["str", "bool", "int", "float", "bytes", "dict", "list"]:
+        travel_dict(data, key, "w")(str(value))
+    return data
+
+
+def handle_data_dict(data, curr_mapping, key):
+    curr_data = travel_dict(data, key, "r")
+    if (
+        curr_mapping
+        and has_opensearch_type(curr_mapping)
+        and curr_mapping.get("type") not in ["object", "nested"]
+    ):
+        convert_data_type(data, curr_mapping, key)
+    else:
+        for subkey in list(curr_data.keys()):
+            convert_clientside(data, curr_mapping.get(subkey), key + [subkey])
+            sub_val = curr_data.get(subkey)
+            if isinstance(sub_val, dict):
+                sub_val.pop("#type", None)
+
+
+def get_vector_name(metadata: Dict[str, Any]) -> str:
+    vector_name = "vector"
+    for prop in vector_nomenclature_order:
+        if prop in metadata:
+            vector_name += f"_{metadata[prop]}"
+    return vector_name
+
+
+def validate_vector_data(vector_data, curr_mapping):
+    try:
+        assert "data" in vector_data, "'data' field missing in vector_data"
+        assert (
+            isinstance(vector_data["data"], list) and vector_data["data"]
+        ), "'data' must be a non-empty list"
+        assert "metadata" in vector_data, "'metadata' field missing in vector_data"
+        assert isinstance(
+            vector_data["metadata"], dict
+        ), "'metadata' must be a dictionary"
+        assert "dim" in vector_data["metadata"], "'dim' field missing in 'metadata'"
+        assert (
+            isinstance(vector_data["metadata"]["dim"], int)
+            and vector_data["metadata"]["dim"] > 0
+        ), "'dim' must be a positive integer"
+        assert vector_data["metadata"]["dim"] == len(
+            vector_data["data"]
+        ), "'dim' must match the length of 'data'"
+        return True
+    except AssertionError as e:
+        logger.warning(f"Validation failed: {str(e)}")
+        return False
+
+
+def handle_data_vector(data, curr_mapping, key, vector_data=None):
+    if vector_data is None:
+        vector_data = travel_dict(data, key, "r")
+
+    if not validate_vector_data(vector_data, curr_mapping):
+        convert_clientside(data, curr_mapping, key)
+        return
+
+    vector_name = get_vector_name(vector_data["metadata"])
+
+    if vector_name not in curr_mapping:
+        logger.warning(
+            f"Found valid vector in input data but no field '{vector_name}' allocated in OpenSearch for it"
+        )
+        convert_clientside(data, curr_mapping, key)
+        return
+
+    travel_dict(data, key, "w")(
+        {
+            vector_name: {
+                "value": vector_data["data"],
+            },
+            "#type": "VECTOR",
+        }
+    )
+
+
+def handle_data_list(data, curr_mapping, key):
+    def _align_elems_to_mapping(
+        data, super_path, i, path, elem_structure, curr_mapping
+    ):
+        path = []
+        for key in elem_structure.keys() | curr_mapping.keys():
+            sub_path = path + [key]
+            if key not in curr_mapping:
+                continue
+            if key not in elem_structure:
+                convert_clientside(data, elem_structure, super_path + [i] + sub_path)
+            else:
+                if isinstance(elem_structure[key], dict) and isinstance(
+                    curr_mapping[key], dict
+                ):
+                    _align_elems_to_mapping(
+                        data,
+                        super_path,
+                        i,
+                        sub_path,
+                        elem_structure[key],
+                        curr_mapping[key],
+                    )
+                elif elem_structure[key] != curr_mapping[key]:
+                    convert_clientside(
+                        data, elem_structure, super_path + [i] + sub_path
+                    )
+
+    curr_data = travel_dict(data, key, "r")
+    if len(curr_data) == 0:
+        return
+
+    elem_structure = {}
+    for i, elem in enumerate(curr_data):
+        data = convert_clientside(data, curr_mapping, key + [i])
+        elem = travel_dict(data, key + [i], "r")
+        elem_structure = {**mapping_from_data(elem, {}), **elem_structure}
+    elem_structure = {**elem_structure, **curr_mapping}
+
+    if isinstance(curr_data[0], dict) and curr_data[0].get("#type") == "VECTOR":
+        vectors_data = {}
+        for i, elem in enumerate(curr_data):
+            elem.pop("#type", None)
+            for vector_name in elem:
+                if vector_name not in vectors_data:
+                    vectors_data[vector_name] = []
+                vectors_data[vector_name].append({"value": elem[vector_name]["value"]})
+        travel_dict(data, key, "w")(vectors_data)
+        elem_structure.pop("#type")
+
+    if elem_structure != curr_mapping:
+        _align_elems_to_mapping(data, key, i, [], elem_structure, curr_mapping)
+
+
+def convert_clientside(data, curr_mapping, parent_keylist=[]):
+    """Recursively convert *data* so values match the OpenSearch *curr_mapping*.
+
+    *curr_mapping* may be a full mapping dict (with a ``"properties"`` key) or
+    the inner properties dict directly.  *parent_keylist* is used internally
+    for recursive traversal and should normally be left empty.
+    """
+    if not curr_mapping:
+        curr_mapping = {}
+    if has_opensearch_properties(curr_mapping):
+        curr_mapping = curr_mapping["properties"]
+    if parent_keylist:
+        curr_data = travel_dict(data, parent_keylist, "r")
+    else:
+        curr_data = data
+    datatype = type(curr_data).__name__
+    if datatype not in ["str", "bool", "int", "float", "bytes", "dict", "list"]:
+        handle_incompatible_data_type(data, parent_keylist)
+        convert_data_type(data, curr_mapping, parent_keylist)
+    elif datatype == "dict":
+        if curr_data.get("#type") == "VECTOR":
+            curr_data.pop("#type", None)
+            handle_data_vector(data, curr_mapping, parent_keylist)
+        else:
+            curr_data.pop("#type", None)
+            handle_data_dict(data, curr_mapping, parent_keylist)
+    elif datatype == "list":
+        handle_data_list(data, curr_mapping, parent_keylist)
+    else:
+        convert_data_type(data, curr_mapping, parent_keylist)
+    return data