diff --git a/python/deeplake/__init__.py b/python/deeplake/__init__.py
index a6b866f41e..2b64355712 100644
--- a/python/deeplake/__init__.py
+++ b/python/deeplake/__init__.py
@@ -15,7 +15,7 @@ def progress_bar(iterable, *args, **kwargs):
 from ._deeplake import *
 from deeplake.ingestion import from_coco
 
-__version__ = "4.1.4"
+__version__ = "4.1.5"
 
 __all__ = [
     "__version__",
@@ -77,6 +77,9 @@ def progress_bar(iterable, *args, **kwargs):
     "UnsupportedChunkCompression",
     "InvalidImageCompression",
     "InvalidSegmentMaskCompression",
+    "InvalidMedicalCompression",
+    "UnexpectedMedicalTypeInputData",
+    "UnexpectedInputDataForDicomColumn",
     "InvalidBinaryMaskCompression",
     "DtypeMismatch",
     "UnspecifiedDtype",
@@ -202,7 +205,7 @@ def get_raw_columns(source):
             if not col.dtype.is_link and col.dtype.kind in {
                 deeplake.types.TypeKind.Image,
                 deeplake.types.TypeKind.SegmentMask,
-                deeplake.types.TypeKind.BinaryMask
+                deeplake.types.TypeKind.Medical,
             }
         ]
 
diff --git a/python/deeplake/__init__.pyi b/python/deeplake/__init__.pyi
index 41e3d8f4a1..22e7a4f506 100644
--- a/python/deeplake/__init__.pyi
+++ b/python/deeplake/__init__.pyi
@@ -67,6 +67,9 @@ __all__ = [
     "UnsupportedChunkCompression",
     "InvalidImageCompression",
     "InvalidSegmentMaskCompression",
+    "InvalidMedicalCompression",
+    "UnexpectedMedicalTypeInputData",
+    "UnexpectedInputDataForDicomColumn",
     "InvalidBinaryMaskCompression",
     "DtypeMismatch",
     "UnspecifiedDtype",
@@ -557,7 +560,7 @@ def query(query: str, token: str | None = None) -> DatasetView:
     ds.add_column("text", "text")
     ds.commit()
     ds = deeplake.create("mem://dataset")
-    ds.add_column("split", "text")
+    ds.add_column("train_split", "text")
     ds.add_column("confidence", "float32")
     ds.add_column("label", "text")
     ds.commit()
@@ -604,7 +607,7 @@ def query(query: str, token: str | None = None) -> DatasetView:
         # Filter training data
         train = deeplake.query('''
             SELECT * FROM "mem://dataset"
-            WHERE "split" = 'train' 
+            WHERE "train_split" = 'train' 
             AND confidence > 0.9
             AND label IN ('cat', 'dog')
         ''')
@@ -688,7 +691,7 @@ def query_async(query: str, token: str | None = None) -> Future:
         Non-blocking check:
         ```python
         future = deeplake.query_async(
-            "SELECT * FROM dataset WHERE \\"split\\" = 'train'"
+            "SELECT * FROM dataset WHERE train_split = 'train'"
         )
         
         if future.is_completed():
@@ -1924,7 +1927,7 @@ class Dataset(DatasetView):
         <!-- test-context
         ```python
         import deeplake
-        ds = deeplake.create("tmp://")
+        ds = deeplake.create("mem://ds_id")
         ds.indexing_mode = deeplake.IndexingMode.Off
         ds.add_column("column_name", deeplake.types.Text(deeplake.types.BM25))
         a = ['a']*10_000
@@ -1935,7 +1938,7 @@ class Dataset(DatasetView):
 
         Examples:
             ```python
-            ds = deeplake.open("tmp://")
+            ds = deeplake.open("mem://ds_id")
             ds.indexing_mode = deeplake.IndexingMode.Automatic
             ds.commit()
             ```
@@ -2629,6 +2632,15 @@ class InvalidImageCompression(Exception):
 class InvalidSegmentMaskCompression(Exception):
     pass
 
+class InvalidMedicalCompression(Exception):
+    pass
+
+class UnexpectedMedicalTypeInputData(Exception):
+    pass
+
+class UnexpectedInputDataForDicomColumn(Exception):
+    pass
+
 class InvalidBinaryMaskCompression(Exception):
     pass
 
@@ -3115,6 +3127,7 @@ def connect(
 
         ds = deeplake.connect("gcs://bucket/path/to/dataset",
             "al://my_org/dataset", creds_key="my_key")
+        ```
     """
 
 def disconnect(url: str, token: str | None = None) -> None:
@@ -3238,7 +3251,7 @@ def convert(
             Supports cloud provider credentials like access keys
         token: Optional Activeloop authentication token
 
-    <-- test-context
+    <!-- test-context
     ```python
     import deeplake
     deeplake.convert = lambda src, dst, dst_creds = None, token = None: None
diff --git a/python/deeplake/schemas.pyi b/python/deeplake/schemas.pyi
index a18c5fc3ec..4033c37fff 100644
--- a/python/deeplake/schemas.pyi
+++ b/python/deeplake/schemas.pyi
@@ -20,6 +20,14 @@ def TextEmbeddings(embedding_size: int, quantize: bool = False) -> SchemaTemplat
     - text_chunk (text): The text of the shard.
     - embedding (dtype=float32, size=embedding_size): The embedding of the text.
 
+    <!-- test-context
+    ```python
+    import deeplake
+    from deeplake import types
+    ds = deeplake.create("tmp://")
+    ```
+    -->
+
     Parameters:
         embedding_size: int
             Size of the embeddings.
diff --git a/python/deeplake/types.py b/python/deeplake/types.py
index 0070fcf6c7..117feb1911 100644
--- a/python/deeplake/types.py
+++ b/python/deeplake/types.py
@@ -24,6 +24,7 @@
     "Point",
     "QuantizationType",
     "SegmentMask",
+    "Medical",
     "Sequence",
     "Struct",
     "Text",
diff --git a/python/deeplake/types.pyi b/python/deeplake/types.pyi
index 436c13b6cc..18911d663e 100644
--- a/python/deeplake/types.pyi
+++ b/python/deeplake/types.pyi
@@ -26,6 +26,7 @@ __all__ = [
     "Point",
     "QuantizationType",
     "SegmentMask",
+    "Medical",
     "Sequence",
     "Struct",
     "Text",
@@ -47,6 +48,15 @@ class QuantizationType:
             Stores a binary quantized representation of the original embedding in the index 
             rather than a full copy of the embedding. This slightly decreases accuracy of 
             searches, while significantly improving query time.
+
+    <!--
+    ```python
+    import deeplake
+    import numpy as np
+    from deeplake import types
+    ds = deeplake.create("tmp://")
+    ```
+    -->
     """
 
     Binary: typing.ClassVar[QuantizationType]
@@ -242,6 +252,7 @@ class TypeKind:
         Polygon: Polygon data type
         ClassLabel: Class label data type
         Point: Point data type
+        Medical: Medical data type
         Link: Link data type
     """
 
@@ -258,6 +269,7 @@ class TypeKind:
     SegmentMask: typing.ClassVar[TypeKind]
     Sequence: typing.ClassVar[TypeKind]
     Text: typing.ClassVar[TypeKind]
+    Medical: typing.ClassVar[TypeKind]
     __members__: typing.ClassVar[dict[str, TypeKind]]
 
     def __eq__(self, other: typing.Any) -> bool: ...
@@ -310,6 +322,12 @@ def Array(dtype: DataType | str, dimensions: int | None, shape: list[int] | None
     Returns:
         DataType: A new array data type with the specified parameters.
 
+    <!--
+    ```python
+    ds = deeplake.create("tmp://")
+    ```
+    -->
+
     Examples:
         Create a three-dimensional array, where each dimension can have any number of elements:
         ```python
@@ -330,6 +348,12 @@ def Bool() -> DataType:
     Returns:
         DataType: A new boolean data type.
 
+    <!--
+    ```python
+    ds = deeplake.create("tmp://")
+    ```
+    -->
+
     Examples:
         Create columns with boolean type:
         ```python
@@ -356,6 +380,12 @@ def Text(index_type: str | TextIndexType | None = None) -> Type:
     Returns:
         Type: A new text data type.
 
+    <!--
+    ```python
+    ds = deeplake.create("tmp://")
+    ```
+    -->
+
     Examples:
         Create text columns with different configurations:
         ```python
@@ -395,6 +425,12 @@ def Dict() -> Type:
     See Also:
         :func:`deeplake.types.Struct` for a type that supports defining allowed keys.
 
+    <!--
+    ```python
+    ds = deeplake.create("tmp://")
+    ```
+    -->
+
     Examples:
         Create and use a dictionary column:
         ```python
@@ -428,6 +464,12 @@ def Embedding(
     See Also:
         :func:`deeplake.types.Array` for a multidimensional array.
 
+    <!--
+    ```python
+    ds = deeplake.create("tmp://")
+    ```
+    -->
+
     Examples:
         Create embedding columns:
         ```python
@@ -444,6 +486,12 @@ def Float32() -> DataType:
     Returns:
         DataType: A new 32-bit float data type.
 
+    <!--
+    ```python
+    ds = deeplake.create("tmp://")
+    ```
+    -->
+
     Examples:
         Create a column with 32-bit float type:
         ```python
@@ -459,6 +507,12 @@ def Float64() -> DataType:
     Returns:
         DataType: A new 64-bit float data type.
 
+    <!--
+    ```python
+    ds = deeplake.create("tmp://")
+    ```
+    -->
+
     Examples:
         Create a column with 64-bit float type:
         ```python
@@ -474,6 +528,12 @@ def Int16() -> DataType:
     Returns:
         DataType: A new 16-bit integer data type.
 
+    <!--
+    ```python
+    ds = deeplake.create("tmp://")
+    ```
+    -->
+
     Examples:
         Create a column with 16-bit integer type:
         ```python
@@ -489,6 +549,12 @@ def Int32() -> DataType:
     Returns:
         DataType: A new 32-bit integer data type.
 
+    <!--
+    ```python
+    ds = deeplake.create("tmp://")
+    ```
+    -->
+
     Examples:
         Create a column with 32-bit integer type:
         ```python
@@ -504,6 +570,12 @@ def Int64() -> DataType:
     Returns:
         DataType: A new 64-bit integer data type.
 
+    <!--
+    ```python
+    ds = deeplake.create("tmp://")
+    ```
+    -->
+
     Examples:
         Create a column with 64-bit integer type:
         ```python
@@ -519,6 +591,12 @@ def Int8() -> DataType:
     Returns:
         DataType: A new 8-bit integer data type.
 
+    <!--
+    ```python
+    ds = deeplake.create("tmp://")
+    ```
+    -->
+
     Examples:
         Create a column with 8-bit integer type:
         ```python
@@ -542,6 +620,12 @@ def Sequence(nested_type: DataType | str | Type) -> Type:
     Returns:
         Type: A new sequence data type.
 
+    <!--
+    ```python
+    ds = deeplake.create("tmp://")
+    ```
+    -->
+
     Examples:
         Create a sequence of images:
         ```python
@@ -569,6 +653,12 @@ def Image(dtype: DataType | str = "uint8", sample_compression: str = "png") -> T
         dtype: The data type of the array elements to return
         sample_compression: The on-disk compression/format of the image
 
+    <!--
+    ```python
+    ds = deeplake.create("tmp://")
+    ```
+    -->
+
     Examples:
         ```python
         ds.add_column("col1", types.Image)
@@ -584,6 +674,12 @@ def Link(type: Type) -> Type:
     Parameters:
         type: The type of the linked data
 
+    <!--
+    ```python
+    ds = deeplake.create("tmp://")
+    ```
+    -->
+
     Examples:
         ```python
         ds.add_column("col1", types.Link(types.Image()))
@@ -613,6 +709,12 @@ def BoundingBox(
         format: The bounding box format. Possible values: `ccwh`, `ltwh`, `ltrb`, `unknown`
         bbox_type: The pixel type. Possible values: `pixel`, `fractional`
 
+    <!--
+    ```python
+    ds = deeplake.create("tmp://")
+    ```
+    -->
+
     Examples:
         ```python
         ds.add_column("col1", types.BoundingBox())
@@ -633,6 +735,12 @@ def BinaryMask(
         sample_compression: How to compress each row's value. Possible values: lz4, null (default: null)
         chunk_compression: How to compress all the values stored in a single file. Possible values: lz4, null (default: null)
 
+    <!--
+    ```python
+    ds = deeplake.create("tmp://")
+    ```
+    -->
+
     Examples:
         ```python
         ds.add_column("col1", types.BinaryMask(sample_compression="lz4"))
@@ -655,6 +763,12 @@ def SegmentMask(
         sample_compression: How to compress each row's value. Possible values: lz4, null (default: null)
         chunk_compression: How to compress all the values stored in a single file. Possible values: lz4, null (default: null)
 
+    <!--
+    ```python
+    ds = deeplake.create("tmp://")
+    ```
+    -->
+
     Examples:
         ```python
         ds.add_column("col1", types.SegmentMask(sample_compression="lz4"))
@@ -663,6 +777,63 @@ def SegmentMask(
     """
     ...
 
+def Medical(
+    compression: str
+) -> Type:
+    """
+    Medical datatype for storing medical images.
+
+    <!-- test-context
+    ```python
+    import deeplake
+    from io import BytesIO
+    from deeplake import types
+    from inspect import Signature, Parameter
+    from functools import wraps
+
+    ds = deeplake.create("tmp://")
+
+    def __open(*args, **kwargs):
+        return BytesIO(b"")
+
+    # Extract the original open signature
+    original_signature = Signature(
+        parameters=[
+            Parameter("file", Parameter.POSITIONAL_OR_KEYWORD),
+            Parameter("mode", Parameter.POSITIONAL_OR_KEYWORD, default="r"),
+            Parameter("buffering", Parameter.POSITIONAL_OR_KEYWORD, default=-1),
+            Parameter("encoding", Parameter.POSITIONAL_OR_KEYWORD, default=None),
+            Parameter("errors", Parameter.POSITIONAL_OR_KEYWORD, default=None),
+            Parameter("newline", Parameter.POSITIONAL_OR_KEYWORD, default=None),
+            Parameter("closefd", Parameter.POSITIONAL_OR_KEYWORD, default=True),
+            Parameter("opener", Parameter.POSITIONAL_OR_KEYWORD, default=None),
+        ]
+    )
+
+    @wraps(__open)
+    def new_open(*args, **kwargs):
+        return __open(*args, **kwargs)
+
+    new_open.__signature__ = original_signature
+
+    open = new_open
+
+    ```
+    -->
+
+    Parameters:
+        compression: How to compress each row's value. Possible values: dcm, nii, nii.gz
+    Examples:
+        ```python
+        ds.add_column("col1", types.Medical(compression="dcm"))
+
+        with open("path/to/dicom/file.dcm", "rb") as f:
+            bytes_data = f.read()
+            ds.append([{"col1": bytes_data}])
+        ```
+    """
+    ...
+
 def Struct(fields: dict[str, DataType | str]) -> DataType:
     """
     Defines a custom datatype with specified keys.
@@ -672,6 +843,12 @@ def Struct(fields: dict[str, DataType | str]) -> DataType:
     Parameters:
         fields: A dict where the key is the name of the field, and the value is the datatype definition for it
 
+    <!--
+    ```python
+    ds = deeplake.create("tmp://")
+    ```
+    -->
+
     Examples:
         ```python
         ds.add_column("col1", types.Struct({
@@ -689,6 +866,12 @@ def UInt16() -> DataType:
     """
     An unsigned 16-bit integer value
 
+    <!--
+    ```python
+    ds = deeplake.create("tmp://")
+    ```
+    -->
+
     Examples:
         ```python
         ds.add_column("col1", types.UInt16)
@@ -700,6 +883,12 @@ def UInt32() -> DataType:
     """
     An unsigned 32-bit integer value
 
+    <!--
+    ```python
+    ds = deeplake.create("tmp://")
+    ```
+    -->
+
     Examples:
         ```python
         ds.add_column("col1", types.UInt16)
@@ -711,6 +900,12 @@ def UInt64() -> DataType:
     """
     An unsigned 64-bit integer value
 
+    <!--
+    ```python
+    ds = deeplake.create("tmp://")
+    ```
+    -->
+
     Examples:
         ```python
         ds.add_column("col1", types.UInt64)
@@ -722,6 +917,12 @@ def UInt8() -> DataType:
     """
     An unsigned 8-bit integer value
 
+    <!--
+    ```python
+    ds = deeplake.create("tmp://")
+    ```
+    -->
+
     Examples:
         ```python
         ds.add_column("col1", types.UInt16)