bigdl-core-npu 2.5.0__cp311-cp311-win_amd64.whl → 2.6.0__cp311-cp311-win_amd64.whl

intel_npu_acceleration_library/external/openvino/runtime/ie_api.py

@@ -507,7 +507,7 @@ class Core(CoreBase):
         device_name: Optional[str] = None,
         config: Optional[dict] = None,
         *,
-        weights: Optional[bytes] = None
+        weights: Optional[bytes] = None,
     ) -> CompiledModel:
         """Creates a compiled model.
 

intel_npu_acceleration_library/external/openvino/runtime/op/__init__.py

@@ -15,4 +15,5 @@ from openvino._pyopenvino.op import Parameter
 from openvino._pyopenvino.op import if_op
 from openvino._pyopenvino.op import loop
 from openvino._pyopenvino.op import tensor_iterator
+from openvino._pyopenvino.op import read_value
 from openvino._pyopenvino.op import Result

intel_npu_acceleration_library/external/openvino/runtime/opset1/ops.py

@@ -31,7 +31,7 @@ from openvino.runtime.utils.types import (
     get_element_type_str,
     make_constant_node,
 )
-
+from openvino.utils import deprecated
 
 _get_node_factory_opset1 = partial(_get_node_factory, "opset1")
 
@@ -1532,6 +1532,7 @@ def lstm_cell(
     return _get_node_factory_opset1().create("LSTMCell", node_inputs, attributes)
 
 
+@deprecated(version="2025.0", message="Use lstm_sequence from opset 5")
 @nameable_op
 def lstm_sequence(
     X: NodeInput,

intel_npu_acceleration_library/external/openvino/runtime/opset13/ops.py

@@ -180,8 +180,7 @@ def multinomial(
     inputs = as_nodes(probs, num_samples, name=name)
 
     if global_seed < 0:
-        raise RuntimeError(
-            f"global_seed should be positive or 0. Got: {global_seed}")
+        raise RuntimeError(f"global_seed should be positive or 0. Got: {global_seed}")
 
     if op_seed < 0:
         raise RuntimeError(f"op_seed should be positive or 0. Got: {op_seed}")
@@ -223,8 +222,7 @@ def nms_rotated(
     :param clockwise: Flag that specifies direction of the box rotation.
     :return: The new node which performs NMSRotated
     """
-    inputs = as_nodes(boxes, scores, max_output_boxes_per_class,
-                      iou_threshold, score_threshold, name=name)
+    inputs = as_nodes(boxes, scores, max_output_boxes_per_class, iou_threshold, score_threshold, name=name)
 
     attributes = {
         "sort_result_descending": sort_result_descending,
@@ -301,6 +299,7 @@ def constant(
                           - dtype force conversion of data.
     :return: The Constant node initialized with provided data.
     """
+
     def display_shared_memory_warning(warning_message: str) -> None:
         if shared_memory:
             log.warning(f"{warning_message}. Memory sharing is disabled by default. Set shared_memory=False to hide this warning.")
@@ -313,10 +312,10 @@ def constant(
     # Handle type casting, when dtype is not None:
     if dtype:
         # Expect packed data, use different constructor to handle it correctly:
-        if dtype in [Type.u1, Type.i4, Type.u4, Type.nf4]:
+        if dtype in [Type.u1, Type.i4, Type.u4, Type.nf4, Type.f4e2m1]:
             display_shared_memory_warning(f"Constant initialized with packed type of {dtype}")
             return Constant(dtype, Shape(_value.shape), _value.flatten().tolist())
-        elif dtype in [Type.bf16]:
+        elif dtype in [Type.bf16, Type.f8e8m0, Type.f8e4m3, Type.f8e5m2]:
             display_shared_memory_warning(f"Constant initialized with OpenVINO custom {dtype}")
             return Constant(dtype, Shape(_value.shape), _value.flatten().tolist())
         # General use-case for all other types:

intel_npu_acceleration_library/external/openvino/runtime/opset15/__init__.py

@@ -7,4 +7,11 @@
 # TODO (ticket 138273): Add previous opset operators at the end of opset15 development
 from openvino.runtime.opset1.ops import parameter
 from openvino.runtime.opset15.ops import col2im
+from openvino.runtime.opset15.ops import embedding_bag_offsets
+from openvino.runtime.opset15.ops import embedding_bag_packed
 from openvino.runtime.opset15.ops import scatter_nd_update
+from openvino.runtime.opset15.ops import roi_align_rotated
+from openvino.runtime.opset15.ops import string_tensor_pack
+from openvino.runtime.opset15.ops import string_tensor_unpack
+from openvino.runtime.opset15.ops import bitwise_left_shift
+from openvino.runtime.opset15.ops import bitwise_right_shift

intel_npu_acceleration_library/external/openvino/runtime/opset15/ops.py

@@ -4,11 +4,14 @@
 
 """Factory functions for ops added to openvino opset15."""
 from functools import partial
-from typing import Optional, Literal, List
+from typing import List, Literal, Optional
 
+import numpy as np
 from openvino.runtime import Node, Type
+from openvino.runtime.opset1 import convert_like
+from openvino.runtime.opset14 import constant
 from openvino.runtime.opset_utils import _get_node_factory
-from openvino.runtime.utils.decorators import nameable_op
+from openvino.runtime.utils.decorators import binary_op, nameable_op
 from openvino.runtime.utils.types import NodeInput, as_nodes
 
 _get_node_factory_opset15 = partial(_get_node_factory, "opset15")
@@ -83,3 +86,191 @@ def col2im(
             "pads_end": pads_end,
         },
     )
+
+
+@nameable_op
+def embedding_bag_offsets(
+    emb_table: NodeInput,
+    indices: NodeInput,
+    offsets: NodeInput,
+    default_index: Optional[NodeInput] = None,
+    per_sample_weights: Optional[NodeInput] = None,
+    reduction: Literal["sum", "mean"] = "sum",
+    name: Optional[str] = None,
+) -> Node:
+    """Return a node which performs sums or means of bags of embeddings without the intermediate embeddings.
+
+    :param emb_table: Tensor containing the embedding lookup table.
+    :param indices: 1D Tensor with indices.
+    :param offsets: 1D Tensor containing the starting index positions of each bag in indices.
+    :param per_sample_weights: Tensor with weights for each sample.
+    :param default_index: Scalar containing default index in embedding table to fill empty bags.
+                          If unset or set to -1, empty bags will be filled with 0.
+                          Reverse indexing using negative indices is not supported.
+    :param reduction: String to select algorithm used to perform reduction of elements in bag.
+    :param name: Optional name for output node.
+    :return: The new node performing EmbeddingBagOffsets operation.
+    """
+    inputs = [emb_table, indices, offsets]
+    if default_index is not None:
+        inputs.append(default_index)
+    elif per_sample_weights is not None:
+        inputs.append(convert_like(constant(np.array(-1, np.int32)), inputs[1]))
+    if per_sample_weights is not None:
+        inputs.append(per_sample_weights)
+
+    return _get_node_factory_opset15().create("EmbeddingBagOffsets", as_nodes(*inputs, name=name), {"reduction": reduction})
+
+
+@nameable_op
+def embedding_bag_packed(
+    emb_table: NodeInput,
+    indices: NodeInput,
+    per_sample_weights: Optional[NodeInput] = None,
+    reduction: Literal["sum", "mean"] = "sum",
+    name: Optional[str] = None,
+) -> Node:
+    """Return a node which performs sums or means of "bags" of embeddings, without the intermediate embeddings.
+
+    :param emb_table: Tensor containing the embedding lookup table.
+    :param indices: 2D Tensor of shape [batch, indices_per_bag] with indices.
+    :param per_sample_weights: Tensor of weights to be multiplied with embedding table with same shape as indices.
+    :param reduction: Operator to perform reduction of elements in bag.
+    :param name: Optional name for output node.
+    :return: The new node performing EmbeddingBagPacked operation.
+    """
+    inputs = [emb_table, indices]
+    if per_sample_weights is not None:
+        inputs.append(per_sample_weights)
+
+    return _get_node_factory_opset15().create("EmbeddingBagPacked", as_nodes(*inputs, name=name), {"reduction": reduction})
+
+
+@nameable_op
+def roi_align_rotated(
+    data: NodeInput,
+    rois: NodeInput,
+    batch_indices: NodeInput,
+    pooled_h: int,
+    pooled_w: int,
+    sampling_ratio: int,
+    spatial_scale: float,
+    clockwise_mode: bool,
+    name: Optional[str] = None,
+) -> Node:
+    """Return a node which performs ROIAlignRotated operation.
+
+    :param data: Input data.
+    :param rois: RoIs (Regions of Interest) to pool over.
+    :param batch_indices: Tensor with each element denoting the index of
+                          the corresponding image in the batch.
+    :param pooled_h: Height of the ROI output feature map.
+    :param pooled_w: Width of the ROI output feature map.
+    :param sampling_ratio: Number of bins over height and width to use to calculate
+                           each output feature map element.
+    :param spatial_scale: Multiplicative spatial scale factor to translate ROI coordinates.
+    :param clockwise_mode:  If true, rotation angle is interpreted as clockwise,
+                            otherwise as counterclockwise
+    :param name: The optional name for the output node
+
+    :return: The new node which performs ROIAlignRotated
+    """
+    return _get_node_factory_opset15().create(
+        "ROIAlignRotated",
+        as_nodes(data, rois, batch_indices, name=name),
+        {
+            "pooled_h": pooled_h,
+            "pooled_w": pooled_w,
+            "sampling_ratio": sampling_ratio,
+            "spatial_scale": spatial_scale,
+            "clockwise_mode": clockwise_mode,
+        },
+    )
+
+
+@nameable_op
+def string_tensor_unpack(
+    data: NodeInput,
+    name: Optional[str] = None,
+) -> Node:
+    """Perform an operation which unpacks a batch of strings into three tensors.
+
+    :param data: The node providing input data.
+
+    :return: The new node performing StringTensorUnpack operation.
+    """
+    return _get_node_factory_opset15().create(
+        "StringTensorUnpack",
+        as_nodes(data, name=name)
+    )
+
+
+@nameable_op
+def string_tensor_pack(
+    begins: NodeInput,
+    ends: NodeInput,
+    symbols: NodeInput,
+    name: Optional[str] = None,
+) -> Node:
+    """Perform an operation which packs a concatenated batch of strings into a batched string tensor.
+
+    :param begins: ND tensor of non-negative integer numbers containing indices of each string's beginnings.
+    :param ends: ND tensor of non-negative integer numbers containing indices of each string's endings.
+    :param symbols: 1D tensor of concatenated strings data encoded in utf-8 bytes.
+
+    :return: The new node performing StringTensorPack operation.
+    """
+    return _get_node_factory_opset15().create(
+        "StringTensorPack",
+        as_nodes(begins, ends, symbols, name=name)
+    )
+
+
+@binary_op
+def bitwise_left_shift(
+    arg0: NodeInput,
+    arg1: NodeInput,
+    auto_broadcast: str = "NUMPY",
+    name: Optional[str] = None,
+) -> Node:
+    """Return node which performs BitwiseLeftShift operation on input nodes element-wise.
+
+    :param arg0: Node with data to be shifted.
+    :param arg1: Node with number of shifts.
+    :param auto_broadcast: The type of broadcasting specifies rules used for auto-broadcasting of input tensors.
+                           Defaults to “NUMPY”.
+
+    :return: The new node performing BitwiseLeftShift operation.
+    """
+    return _get_node_factory_opset15().create(
+        "BitwiseLeftShift",
+        as_nodes(arg0, arg1, name=name),
+        {
+            "auto_broadcast": auto_broadcast.upper(),
+        },
+    )
+
+
+@binary_op
+def bitwise_right_shift(
+    arg0: NodeInput,
+    arg1: NodeInput,
+    auto_broadcast: str = "NUMPY",
+    name: Optional[str] = None,
+) -> Node:
+    """Return node which performs BitwiseRightShift operation on input nodes element-wise.
+
+    :param arg0: Tensor with data to be shifted.
+    :param arg1: Tensor with number of shifts.
+    :param auto_broadcast: The type of broadcasting specifies rules used for auto-broadcasting of input tensors.
+                           Defaults to “NUMPY”.
+
+    :return: The new node performing BitwiseRightShift operation.
+    """
+    return _get_node_factory_opset15().create(
+        "BitwiseRightShift",
+        as_nodes(arg0, arg1, name=name),
+        {
+            "auto_broadcast": auto_broadcast.upper(),
+        },
+    )

intel_npu_acceleration_library/external/openvino/runtime/opset6/ops.py

@@ -2,35 +2,26 @@
 # Copyright (C) 2018-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
+import numpy as np
+
 """Factory functions for all openvino ops."""
-from typing import Callable, Iterable, List, Optional, Set, Union, Dict, Any
+from typing import Optional, Union
 
-import numpy as np
 from functools import partial, singledispatch
 
-from openvino.runtime import Node, Shape, Type, PartialShape
+from openvino.runtime import Node, Type, PartialShape, Output, Shape
 from openvino.runtime.op import assign, Constant, Parameter
+from openvino.runtime.op import read_value as _read_value
+from openvino.runtime.op.util import VariableInfo, Variable
 from openvino.runtime.opset_utils import _get_node_factory
-from openvino.runtime.utils.decorators import binary_op, nameable_op, unary_op
-from openvino.runtime.utils.input_validation import (
-    assert_list_of_ints,
-    check_valid_attributes,
-    is_non_negative_value,
-    is_positive_value,
-)
-from openvino.runtime.utils.node_factory import NodeFactory
+from openvino.runtime.utils.decorators import nameable_op, overloading
 from openvino.runtime.utils.types import (
     NodeInput,
-    NumericData,
     NumericType,
-    ScalarData,
     TensorShape,
     as_node,
     as_nodes,
-    get_dtype,
     get_element_type,
-    get_element_type_str,
-    make_constant_node,
 )
 
 _get_node_factory_opset6 = partial(_get_node_factory, "opset6")
@@ -124,12 +115,13 @@ def mvn(
     return _get_node_factory_opset6().create("MVN", inputs, attributes)
 
 
-@singledispatch
+@overloading(Union[Node, Output, int, float, np.ndarray], str, Optional[Union[type, np.dtype, Type, str]],
+             Optional[Union[TensorShape, Shape, PartialShape]], Optional[str])
 @nameable_op
-def read_value(init_value: NodeInput,
+def read_value(init_value: Union[Node, Output, int, float, np.ndarray],
                variable_id: str,
-               variable_type: Optional[Union[NumericType, Type, str]] = None,
-               variable_shape: Optional[TensorShape] = None,
+               variable_type: Optional[Union[type, np.dtype, Type, str]] = None,
+               variable_shape: Optional[Union[TensorShape, Shape, PartialShape]] = None,
                name: Optional[str] = None) -> Node:
     """Return a node which produces the Assign operation.
 
@@ -140,29 +132,32 @@ def read_value(init_value: NodeInput,
     :param name:         Optional name for output node.
     :return: ReadValue node
     """
-    attr_map: Dict[str, Any] = {"variable_id": variable_id}
+    info = VariableInfo()
+    info.variable_id = variable_id
 
     if variable_type is not None:
         if not isinstance(variable_type, Type) and not isinstance(variable_type, str):
-            attr_map["variable_type"] = get_element_type_str(variable_type)
+            info.data_type = get_element_type(variable_type)
         else:
-            attr_map["variable_type"] = variable_type
+            info.data_type = variable_type
+    else:
+        info.data_type = Type.dynamic
 
     if variable_shape is not None:
-        attr_map["variable_shape"] = PartialShape(variable_shape)
+        info.data_shape = PartialShape(variable_shape)
+    else:
+        info.data_shape = PartialShape.dynamic()
 
-    return _get_node_factory_opset6().create(
-        "ReadValue",
-        [as_node(init_value, name=name)],
-        attr_map,
-    )
+    var_from_info = Variable(info)
+    return _read_value(new_value=as_node(init_value, name=name), variable=var_from_info)
 
 
-@read_value.register
-def _(variable_id: str,
-      variable_type: Optional[Union[NumericType, Type, str]] = None,
-      variable_shape: Optional[TensorShape] = None,
-      name: Optional[str] = None) -> Node:
+@overloading(str, Optional[Union[type, np.dtype, Type, str]], Optional[Union[TensorShape, Shape, PartialShape]], Optional[str])  # type: ignore
+@nameable_op
+def read_value(variable_id: str,  # noqa: F811
+               variable_type: Optional[Union[type, np.dtype, Type, str]] = None,
+               variable_shape: Optional[Union[TensorShape, Shape, PartialShape]] = None,
+               name: Optional[str] = None) -> Node:
     """Return a node which produces the Assign operation.
 
     :param variable_id:  Id of a variable to be read.
@@ -171,19 +166,50 @@ def _(variable_id: str,
     :param name:         Optional name for output node.
     :return: ReadValue node
     """
-    attr_map: Dict[str, Any] = {"variable_id": variable_id}
+    info = VariableInfo()
+    info.variable_id = variable_id
 
     if variable_type is not None:
         if not isinstance(variable_type, Type) and not isinstance(variable_type, str):
-            attr_map["variable_type"] = get_element_type_str(variable_type)
+            info.data_type = get_element_type(variable_type)
         else:
-            attr_map["variable_type"] = variable_type
+            info.data_type = variable_type
+    else:
+        info.data_type = Type.dynamic
 
     if variable_shape is not None:
-        attr_map["variable_shape"] = PartialShape(variable_shape)
+        info.data_shape = PartialShape(variable_shape)
+    else:
+        info.data_shape = PartialShape.dynamic()
+
+    var_from_info = Variable(info)
+
+    return _read_value(var_from_info)
 
-    return _get_node_factory_opset6().create(
-        "ReadValue",
-        [],
-        attr_map,
-    )
+
+@overloading(Variable, Optional[str])    # type: ignore
+@nameable_op
+def read_value(ov_variable: Variable,  # noqa: F811
+               name: Optional[str] = None) -> Node:
+    """Return a node which produces the Assign operation.
+
+    :param ov_variable:  Variable to be read.
+    :param name:         Optional name for output node.
+    :return: ReadValue node
+    """
+    return _read_value(ov_variable)
+
+
+@overloading(Union[Node, Output, int, float, np.ndarray], Variable, Optional[str])  # type: ignore
+@nameable_op
+def read_value(init_value: Union[Node, Output, int, float, np.ndarray],  # noqa: F811
+               ov_variable: Variable,
+               name: Optional[str] = None) -> Node:
+    """Return a node which produces the Assign operation.
+
+    :param init_value:   Optional node producing a value to be returned instead of an unassigned variable.
+    :param ov_variable:  Variable to be read.
+    :param name:         Optional name for output node.
+    :return: ReadValue node
+    """
+    return _read_value(as_node(init_value, name=name), ov_variable)

intel_npu_acceleration_library/external/openvino/runtime/opset8/ops.py

@@ -336,6 +336,7 @@ def random_uniform(
     output_type: str,
     global_seed: int = 0,
     op_seed: int = 0,
+    alignment: str = "tensorflow",
     name: Optional[str] = None,
 ) -> Node:
     """Return a node which generates sequence of random values from uniform distribution.
@@ -347,6 +348,8 @@ def random_uniform(
                                 'i64', 'i32', 'f64', 'f32', 'f16', 'bf16'.
     :param global_seed: Specifies global seed value. Required to be a positive integer or 0.
     :param op_seed: Specifies operational seed value. Required to be a positive integer or 0.
+    :param alignment: Specifies alignment of the randomly generated numbers to a given framework.
+                                Possible values: 'tensorflow', 'pytorch'. Default is 'tensorflow'.
     :param name: Optional output node name.
 
     :return: The new node which performs generation of random values from uniform distribution.
@@ -363,6 +366,7 @@ def random_uniform(
         "output_type": output_type,
         "global_seed": global_seed,
         "op_seed": op_seed,
+        "alignment": alignment.lower(),
     }
     return _get_node_factory_opset8().create("RandomUniform", inputs, attributes)
 

intel_npu_acceleration_library/external/openvino/runtime/properties/__init__.py

@@ -5,6 +5,7 @@
 # Enums
 from openvino._pyopenvino.properties import Affinity
 from openvino._pyopenvino.properties import CacheMode
+from openvino._pyopenvino.properties import WorkloadType
 
 # Properties
 from openvino._pyopenvino.properties import enable_profiling
@@ -27,6 +28,7 @@ from openvino._pyopenvino.properties import max_batch_size
 from openvino._pyopenvino.properties import range_for_async_infer_requests
 from openvino._pyopenvino.properties import execution_devices
 from openvino._pyopenvino.properties import loaded_from_cache
+from openvino._pyopenvino.properties import cache_encryption_callbacks
 
 # Submodules
 from openvino.runtime.properties import hint

intel_npu_acceleration_library/external/openvino/runtime/utils/data_helpers/data_dispatcher.py

@@ -7,7 +7,7 @@ from typing import Any, Dict, Union, Optional
 
 import numpy as np
 
-from openvino._pyopenvino import ConstOutput, Tensor, Type
+from openvino._pyopenvino import ConstOutput, Tensor, Type, RemoteTensor
 from openvino.runtime.utils.data_helpers.wrappers import _InferRequestWrapper, OVDict
 
 ContainerTypes = Union[dict, list, tuple, OVDict]
@@ -61,6 +61,16 @@ def _(
     return value
 
 
+@value_to_tensor.register(RemoteTensor)
+def _(
+    value: RemoteTensor,
+    request: Optional[_InferRequestWrapper] = None,
+    is_shared: bool = False,
+    key: Optional[ValidKeys] = None,
+) -> RemoteTensor:
+    return value
+
+
 @value_to_tensor.register(np.ndarray)
 def _(
     value: np.ndarray,
@@ -137,7 +147,11 @@ def _(
 def to_c_style(value: Any, is_shared: bool = False) -> Any:
     if not isinstance(value, np.ndarray):
         if hasattr(value, "__array__"):
-            return to_c_style(np.array(value, copy=False), is_shared) if is_shared else np.array(value, copy=True)
+            if np.lib.NumpyVersion(np.__version__) >= "2.0.0":
+                # https://numpy.org/devdocs/numpy_2_0_migration_guide.html#adapting-to-changes-in-the-copy-keyword
+                return to_c_style(np.asarray(value), is_shared) if is_shared else np.asarray(value, copy=True)  # type: ignore
+            else:
+                return to_c_style(np.array(value, copy=False), is_shared) if is_shared else np.array(value, copy=True)
         return value
     return value if value.flags["C_CONTIGUOUS"] else np.ascontiguousarray(value)
 
@@ -152,7 +166,11 @@ def normalize_arrays(
 ) -> Any:
     # Check the special case of the array-interface
     if hasattr(inputs, "__array__"):
-        return to_c_style(np.array(inputs, copy=False), is_shared) if is_shared else np.array(inputs, copy=True)
+        if np.lib.NumpyVersion(np.__version__) >= "2.0.0":
+            # https://numpy.org/devdocs/numpy_2_0_migration_guide.html#adapting-to-changes-in-the-copy-keyword
+            return to_c_style(np.asarray(inputs), is_shared) if is_shared else np.asarray(inputs, copy=True)  # type: ignore
+        else:
+            return to_c_style(np.array(inputs, copy=False), is_shared) if is_shared else np.array(inputs, copy=True)
     # Error should be raised if type does not match any dispatchers
     raise TypeError(f"Incompatible inputs of type: {type(inputs)}")
 

intel_npu_acceleration_library/external/openvino/runtime/utils/decorators.py

@@ -3,8 +3,8 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from functools import wraps
-from inspect import getfullargspec
-from typing import Any, Callable, List, Optional
+from inspect import signature
+from typing import Any, Callable, Dict, Optional, Union, get_origin, get_args
 
 from openvino.runtime import Node, Output
 from openvino.runtime.utils.types import NodeInput, as_node, as_nodes
@@ -68,3 +68,89 @@ def custom_preprocess_function(custom_function: Callable) -> Callable:
         return Output._from_node(custom_function(node))
 
     return wrapper
+
+
+class MultiMethod(object):
+    def __init__(self, name: str):
+        self.name = name
+        self.typemap: Dict[tuple, Callable] = {}
+
+    # Checks if actual_type is a subclass of any type in the union
+    def matches_union(self, union_type, actual_type) -> bool:  # type: ignore
+        for type_arg in get_args(union_type):
+            if isinstance(type_arg, type) and issubclass(actual_type, type_arg):
+                return True
+            elif get_origin(type_arg) == list:
+                if issubclass(actual_type, list):
+                    return True
+        return False
+
+    def matches_optional(self, optional_type, actual_type) -> bool:  # type: ignore
+        return actual_type is None or self.matches_union(optional_type, actual_type)
+
+    # Checks whether there is overloading which matches invoked argument types
+    def check_invoked_types_in_overloaded_funcs(self, tuple_to_check: tuple, key_structure: tuple) -> bool:
+        for actual_type, expected_type in zip(tuple_to_check, key_structure):
+            origin = get_origin(expected_type)
+            if origin is Union:
+                if not self.matches_union(expected_type, actual_type):
+                    return False
+            elif origin is Optional:
+                if not self.matches_optional(expected_type, actual_type):
+                    return False
+            elif not issubclass(actual_type, expected_type):
+                return False
+        return True
+
+    def __call__(self, *args, **kwargs) -> Any:  # type: ignore
+        arg_types = tuple(arg.__class__ for arg in args)
+        kwarg_types = {key: type(value) for key, value in kwargs.items()}
+
+        key_matched = None
+        if len(kwarg_types) == 0 and len(arg_types) != 0:
+            for key in self.typemap.keys():
+                # compare types of called function with overloads
+                if self.check_invoked_types_in_overloaded_funcs(arg_types, key):
+                    key_matched = key
+                    break
+        elif len(arg_types) == 0 and len(kwarg_types) != 0:
+            for key, func in self.typemap.items():
+                func_signature = {arg_name: types.annotation for arg_name, types in signature(func).parameters.items()}
+                # if kwargs of called function are subset of overloaded function, we use this overload
+                if kwarg_types.keys() <= func_signature.keys():
+                    key_matched = key
+                    break
+        elif len(arg_types) != 0 and len(kwarg_types) != 0:
+            for key, func in self.typemap.items():
+                func_signature = {arg_name: types.annotation for arg_name, types in signature(func).parameters.items()}
+                # compare types of called function with overloads
+                if self.check_invoked_types_in_overloaded_funcs(arg_types, tuple(func_signature.values())):
+                    # if kwargs of called function are subset of overloaded function, we use this overload
+                    if kwarg_types.keys() <= func_signature.keys():
+                        key_matched = key
+                        break
+
+        if key_matched is None:
+            raise TypeError(f"The necessary overload for {self.name} was not found")
+
+        function = self.typemap.get(key_matched)
+        return function(*args, **kwargs)  # type: ignore
+
+    def register(self, types: tuple, function: Callable) -> None:
+        if types in self.typemap:
+            raise TypeError("duplicate registration")
+        self.typemap[types] = function
+
+
+registry: Dict[str, MultiMethod] = {}
+
+
+def overloading(*types: tuple) -> Callable:
+    def register(function: Callable) -> MultiMethod:
+        name = function.__name__
+        mm = registry.get(name)
+        if mm is None:
+            mm = registry[name] = MultiMethod(name)
+        mm.register(types, function)
+        return mm
+    return register