jbag 4.3.9__py3-none-any.whl

jbag/__init__.py

@@ -0,0 +1,3 @@
+from .log import logger
+from .metric_summary import MetricSummary
+from .parallel_map import parallel_map

jbag/clustering/__init__.py

@@ -0,0 +1 @@
+from .agglomerative_hierarchical_clustering import AgglomerativeHierarchicalClustering

jbag/clustering/agglomerative_hierarchical_clustering.py

@@ -0,0 +1,147 @@
+from typing import Callable
+
+import numpy as np
+
+
+class AgglomerativeHierarchicalClustering:
+    def __init__(self, metric: Callable[[np.ndarray, np.ndarray], float], linkage: str = "complete",
+                 n_clusters: int = 1):
+        """
+        Agglomerative hierarchical clustering algorithm. Only "complete" linkage is supported for now.
+        Note that `sklearn.cluster.AgglomerativeClustering` is much faster, this implementation is used when
+        AgglomerativeClustering in sklearn fails to meet the data dimension restriction when the sample is
+        represented by a matrix/tensor with feature dimensions greater than 1. While AgglomerativeClustering in sklearn
+        only supports data shape of (n_samples, n_features).
+
+        Args:
+            metric (Callable[[np.ndarray, np.ndarray], float]): metric function for measuring element distance.
+            linkage (str, optional, default="complete"): currently, only "complete" is supported.
+            n_clusters  (int, optional, default=1): the number of clusters for clustering.
+        """
+        supported_linkages = ["complete"]
+        if linkage not in supported_linkages:
+            raise ValueError(f"linkage must be one of {supported_linkages}")
+        if n_clusters < 1:
+            raise ValueError(f"Minimum number of clusters must be >= 1")
+        self.metric = metric
+        self.linkage = linkage
+        self.n_clusters = n_clusters
+
+    def fit(self, X):
+        """
+        Perform agglomerative hierarchical clustering on `X`.
+        Args:
+            X (np.ndarray): the input data `X` is expected to have be (n_samples, ...).
+
+        Returns:
+        The clustering with desired number of clusters and the full grouping tree.
+        """
+        n_samples = X.shape[0]
+
+        if n_samples < 2:
+            raise ValueError(f"Need at least 2 samples for clustering.")
+
+        cluster_distance = np.zeros((n_samples, n_samples))
+
+        for i in range(n_samples):
+            for j in range(i + 1, n_samples):
+                distance = self.metric(X[i], X[j])
+                cluster_distance[i][j] = distance
+                cluster_distance[j][i] = distance
+
+        np.fill_diagonal(cluster_distance, np.inf)
+
+        k_steps = n_samples - self.n_clusters
+        linkage_matrix = np.zeros((k_steps, 2), dtype=int)
+
+        # active_cluster_indices is the unmerged cluster indices
+        active_cluster_indices = list(range(n_samples))
+
+        actual_cluster_ids = list(range(n_samples))
+        new_cluster_id = n_samples
+
+        for k_step in range(k_steps):
+
+            argmin = np.argmin(cluster_distance)
+
+            i_idx, j_idx = np.unravel_index(argmin, cluster_distance.shape)
+
+            i_id, j_id = actual_cluster_ids[i_idx], actual_cluster_ids[j_idx]
+            linkage_matrix[k_step][0] = i_id
+            linkage_matrix[k_step][1] = j_id
+
+            actual_cluster_ids[i_idx] = new_cluster_id
+            new_cluster_id += 1
+
+            active_cluster_indices.remove(j_idx)
+
+            for i in active_cluster_indices:
+                if i != i_idx:
+                    distance = self._complete_linkage(cluster_distance, i_idx, j_idx, i)
+                    cluster_distance[i][i_idx] = distance
+                    cluster_distance[i_idx][i] = distance
+
+            cluster_distance[j_idx, :] = np.inf
+            cluster_distance[:, j_idx] = np.inf
+
+        clusterings = self.get_clusters(linkage_matrix, n_samples)
+        return clusterings[0], clusterings
+
+    @staticmethod
+    def get_clusters(linkage_matrix, n_samples: int):
+        """
+        Build the clusterings from linkage matrix. This function can also be applied to
+        sklearn.cluster.AgglomerativeClustering for building the clusterings:
+
+        Args:
+            linkage_matrix:
+            n_samples:
+
+        Returns: Clusterings with different numbers of clusters.
+
+        Examples:
+        >>> from sklearn.cluster import AgglomerativeClustering
+        >>> import numpy as np
+        >>> X = np.array([[1, 2], [1, 4], [1, 0],[4, 2], [4, 4], [4, 0]])
+        >>> clustering = AgglomerativeClustering(compute_full_tree=True).fit(X)
+        >>> linkage_matrix = clustering.children_
+        >>> clusterings = AgglomerativeHierarchicalClustering.get_clusters(linkage_matrix, X.shape[0])
+        >>> clusterings
+        [[[0, 1, 2, 3, 4, 5]], [[0, 1, 2], [3, 4, 5]], [[0, 1, 2], [3, 5], [4]], [[0, 1], [2], [3, 5], [4]], [[0, 1], [2], [3], [4], [5]], [[0], [1], [2], [3], [4], [5]]]
+        """
+        cluster_contents = [[i] for i in range(n_samples)]
+        active_cluster_ids = list(range(n_samples))
+
+        history_of_cluster_sets = []
+
+        current_set_of_clusters = [[i] for i in range(n_samples)]
+        history_of_cluster_sets.append(current_set_of_clusters)
+
+        for i in range(linkage_matrix.shape[0]):
+            c1_id, c2_id = linkage_matrix[i]
+
+            # Retrieve the cluster members of merged clusters
+            samples_c1 = cluster_contents[c1_id]
+            samples_c2 = cluster_contents[c2_id]
+
+            new_cluster_samples = sorted(samples_c1 + samples_c2)
+
+            cluster_contents.append(new_cluster_samples)
+            new_cluster_id = n_samples + i
+
+            active_cluster_ids.remove(c1_id)
+            active_cluster_ids.remove(c2_id)
+            active_cluster_ids.append(new_cluster_id)
+
+            current_set_snapshot = [list(cluster_contents[k]) for k in active_cluster_ids]
+            current_set_snapshot.sort()
+            history_of_cluster_sets.append(current_set_snapshot)
+
+        return history_of_cluster_sets[::-1]
+
+    @staticmethod
+    def _complete_linkage(cluster_distance, linkage_cluster_i_idx, linkage_cluster_j_idx, cluster_idx):
+
+        max_distance = max(cluster_distance[cluster_idx][linkage_cluster_i_idx],
+                           cluster_distance[cluster_idx][linkage_cluster_j_idx])
+        return max_distance

jbag/config.py

@@ -0,0 +1,140 @@
+import os
+import re
+import tomllib
+from typing import Mapping
+
+
+class Config(Mapping):
+    def __init__(self, config: Mapping):
+        self._config = config
+
+    def __getattr__(self, name):
+        try:
+            value = self._config[name]
+        except KeyError:
+            raise AttributeError(f"The config has no key {name}") from None
+        if isinstance(value, Mapping):
+            return Config(value)
+        return value
+
+    def __getitem__(self, key):
+        try:
+            value = self._config[key]
+        except KeyError:
+            raise KeyError(f"The config has no key {key}") from None
+        if isinstance(value, Mapping):
+            return Config(value)
+        return value
+
+    def as_primitive(self) -> dict:
+        return self._config
+
+    def __dir__(self) -> list:
+        return list(self._config.keys())
+
+    def __repr__(self) -> str:
+        return repr(self._config)
+
+    def __str__(self) -> str:
+        return f"configuration keys: {dir(self)}"
+
+    def __len__(self):
+        return len(self._config)
+
+    def __iter__(self):
+        return iter(self._config)
+
+
+def load_config(config_file: str):
+    if not os.path.isfile(config_file):
+        raise FileNotFoundError(f"Config file {config_file} not found.")
+
+    with open(config_file, "rb") as f:
+        config = tomllib.load(f)
+    refine_nodes(config, config)
+    config = Config(config)
+    return config
+
+
+def refine_nodes(node, root):
+    for k, v in node.items():
+        if isinstance(v, str):
+            replace_str(k, node, root)
+        elif isinstance(v, dict):
+            refine_nodes(v, root)
+        elif isinstance(v, list):
+            for i, inner_v in enumerate(v):
+                if isinstance(inner_v, str):
+                    replace_str(k, node, root, list_index=i)
+                elif isinstance(inner_v, dict):
+                    refine_nodes(inner_v, root)
+
+
+def replace_str(key, node, root, list_index=None):
+    """
+    If `node[key]` is list type, set list_index to the index of current element of `node[key]`.
+
+    Args:
+        key (str):
+        node (mapping):
+        root (mapping):
+        list_index (int or None, optional, default=None):
+
+    Returns:
+
+    """
+    reference_patten = r"(\$\{.+?\})"
+    reference_key_patten = r"\$\{(.+)\}"
+    if list_index is not None:
+        value = node[key][list_index]
+    else:
+        value = node[key]
+    match = re.findall(reference_patten, value)
+    if not match:
+        return
+    for each in match:
+        replace_key = re.search(reference_key_patten, each).group(1)
+        replace_node, replace_key = get_node_key(replace_key, node, root)
+        if isinstance(replace_node[replace_key], str):
+            replace_str(replace_key, replace_node, root)
+        if list_index is not None:
+            node[key][list_index] = node[key][list_index].replace(each, root[replace_key])
+        else:
+            node[key] = node[key].replace(each, str(replace_node[replace_key]))
+
+
+def get_node_key(key, node, root):
+    """
+    Get the inner node and key.
+
+    Args:
+        key (str):
+        node (dict):
+        root (mapping):
+
+    Returns:
+
+    """
+    node_hierarchy = key.split(".")
+    # first, search on current node
+    # second, search on root if search failed on current node
+
+    node, unpacked_key = search_node(node_hierarchy, node)
+    if node and unpacked_key:
+        return node, unpacked_key
+
+    node = root
+    node, unpacked_key = search_node(node_hierarchy, node)
+    if node and unpacked_key:
+        return node, unpacked_key
+    raise ValueError(f"The config has no key {key}")
+
+
+def search_node(node_hierarchy, node):
+    for i, key in enumerate(node_hierarchy):
+        if key in node:
+            if i == len(node_hierarchy) - 1:
+                return node, node_hierarchy[-1]
+            else:
+                node = node[key]
+    return None, None

jbag/converters/__init__.py

@@ -0,0 +1,2 @@
+from .dicom2nifti import dicom2nifti
+from .nifti2dicom import nifti2dicom

jbag/converters/dicom2nifti.py

@@ -0,0 +1,16 @@
+import os
+
+import dicom2nifti as d2n
+
+from jbag.io import ensure_output_file_dir_existence
+
+
+def dicom2nifti(input_dicom_series, output_nifti_file, pydicom_read_force=False):
+    if not os.path.exists(input_dicom_series):
+        raise ValueError(f"Input DICOM series {input_dicom_series} does not exist.")
+
+    if pydicom_read_force:
+        d2n.settings.pydicom_read_force = pydicom_read_force
+
+    ensure_output_file_dir_existence(output_nifti_file)
+    d2n.dicom_series_to_nifti(input_dicom_series, output_nifti_file, reorient_nifti=False)

jbag/converters/nifti2dicom.py

@@ -0,0 +1,155 @@
+import os
+import shutil
+
+import nibabel as nib
+import numpy as np
+from pydicom import Dataset
+from pydicom.uid import generate_uid
+
+from jbag import logger
+from jbag.dicom.dicom import get_dicom_dataset
+from jbag.dicom.modalities import Modality
+
+
+def write_slice(ds: Dataset, image_data, slice_index, output_dir):
+    output_filename = r"Slice_%04d.dcm" % (slice_index + 1)
+    image_slice = image_data[..., slice_index]
+    ds.SOPInstanceUID = generate_uid(None)
+    ds.PixelData = image_slice.tobytes()
+    ds.save_as(os.path.join(output_dir, output_filename), write_like_original=False)
+
+
+def get_nii2dcm_parameters(nii_data):
+    nii_img = nii_data.get_fdata()
+
+    dim_array = nii_data.header["dim"].astype(np.int16)
+    num_x, num_y, num_z = int(dim_array[1]), int(dim_array[2]), int(dim_array[3])
+    voxel_spacing_x, voxel_spacing_y, voxel_spacing_z = (nii_data.header["pixdim"][1],
+                                                         nii_data.header["pixdim"][2],
+                                                         nii_data.header["pixdim"][3])
+
+    slice_indices = range(1, num_z + 1)
+    last_location_z = (voxel_spacing_z * num_z) - voxel_spacing_z
+    slice_locations = np.linspace(0, last_location_z, num=num_z)
+
+    # Windowing
+    max_i = np.max(nii_img)
+    min_i = np.min(nii_img)
+    window_center = round((max_i - min_i) / 2)
+    window_width = round(max_i - min_i)
+
+    rescale_intercept = 0
+    rescale_slope = 1
+
+    # FOV
+    fov_x = num_x * voxel_spacing_x
+    fov_y = num_y * voxel_spacing_y
+    fov_z = num_z * voxel_spacing_z
+
+    # slice positioning in 3-D space
+    # -1 for direction cosines gives consistent orientation between Nifti and DICOM in ITK-Snap
+    affine = nii_data.affine
+    dir_cos_x = -1 * affine[:3, 0] / voxel_spacing_x
+    dir_cos_y = -1 * affine[:3, 1] / voxel_spacing_y
+
+    image_pos_patient_array = []
+    for slice_i in range(0, num_z):
+        v = affine.dot([0, 0, slice_i - 1, 1])
+        image_pos_patient_array.append([v[0], v[1], v[2]])
+
+    # output dictionary
+    nii2dcm_parameters = {
+        # series parameters
+        "DimX": voxel_spacing_x,
+        "DimY": voxel_spacing_y,
+        "SliceThickness": str(voxel_spacing_z),
+        "SpacingBetweenSlices": str(voxel_spacing_z),
+        "AcquisitionMatrix": [0, num_x, num_y, 0],
+        "Rows": num_x,
+        "Columns": num_y,
+        "NumberOfSlices": num_z,
+        "NumberOfInstances": num_z,
+        "PixelSpacing": [voxel_spacing_x, voxel_spacing_y],
+        "FOV": [fov_x, fov_y, fov_z],
+        "SmallestImagePixelValue": min_i,
+        "LargestImagePixelValue": max_i,
+        "WindowCenter": str(window_center),
+        "WindowWidth": str(window_width),
+        "RescaleIntercept": str(rescale_intercept),
+        "RescaleSlope": str(rescale_slope),
+        "ImageOrientationPatient": [dir_cos_y[0], dir_cos_y[1], dir_cos_y[2], dir_cos_x[0], dir_cos_x[1], dir_cos_x[2]],
+
+        # instance parameters
+        "InstanceNumber": slice_indices,
+        "SliceLocation": slice_locations,
+        "ImagePositionPatient": image_pos_patient_array
+    }
+
+    return nii2dcm_parameters
+
+
+def transfer_dicom_series_tags(nii2dcm_parameters: dict, ds: Dataset):
+    ds.Rows = nii2dcm_parameters["Rows"]
+    ds.Columns = nii2dcm_parameters["Columns"]
+    ds.PixelSpacing = [round(float(nii2dcm_parameters["DimX"]), 2), round(float(nii2dcm_parameters["DimY"]), 2)]
+    ds.SliceThickness = nii2dcm_parameters["SliceThickness"]
+    ds.SpacingBetweenSlices = round(float(nii2dcm_parameters["SpacingBetweenSlices"]), 2)
+    ds.ImageOrientationPatient = nii2dcm_parameters["ImageOrientationPatient"]
+    ds.AcquisitionMatrix = nii2dcm_parameters["AcquisitionMatrix"]
+    ds.SmallestImagePixelValue = int(nii2dcm_parameters["SmallestImagePixelValue"]) \
+        if int(nii2dcm_parameters["SmallestImagePixelValue"]) > 0 else 0
+    ds.LargestImagePixelValue = int(nii2dcm_parameters["LargestImagePixelValue"])
+    ds.WindowCenter = nii2dcm_parameters["WindowCenter"]
+    ds.WindowWidth = nii2dcm_parameters["WindowWidth"]
+    ds.RescaleIntercept = nii2dcm_parameters["RescaleIntercept"]
+    ds.RescaleSlope = nii2dcm_parameters["RescaleSlope"]
+
+
+def transfer_dicom_instance_tags(nii2dcm_parameters: dict, ds: Dataset, instance_index: int):
+    ds.InstanceNumber = nii2dcm_parameters["InstanceNumber"][instance_index]
+    ds.SliceLocation = nii2dcm_parameters["SliceLocation"][instance_index]
+    ds.ImagePositionPatient = [
+        str(nii2dcm_parameters["ImagePositionPatient"][instance_index][0]),
+        str(nii2dcm_parameters["ImagePositionPatient"][instance_index][1]),
+        str(nii2dcm_parameters["ImagePositionPatient"][instance_index][2]),
+    ]
+
+
+def nifti2dicom(input_nifti_file, output_dicom_dir, modality: Modality, force_overwrite=False):
+    """
+    Convert NIfTI image to DICOM image series. Inspired by https://github.com/tomaroberts/nii2dcm.
+
+    Args:
+        input_nifti_file (str):
+        output_dicom_dir (str):
+        modality (Modality):
+        force_overwrite (bool, optional, default=False): If `Ture`, overwrite `output_dicom_dir` if it exists.`
+
+    Returns:
+
+    """
+
+    if not os.path.isfile(input_nifti_file):
+        raise FileNotFoundError(f"Input NIfTI file {input_nifti_file} not found.")
+
+    if os.path.exists(output_dicom_dir):
+        if force_overwrite:
+            logger.info(f"Overwrite output DICOM dir {output_dicom_dir} as it already exists.")
+            shutil.rmtree(output_dicom_dir)
+        else:
+            raise ValueError(f"Output DICOM series dir {output_dicom_dir} already exists.")
+
+    nii_data = nib.load(input_nifti_file)
+
+    nii2dcm_properties = get_nii2dcm_parameters(nii_data)
+    file_name = os.path.splitext(os.path.basename(input_nifti_file))[0]
+
+    dicom_ds = get_dicom_dataset(file_name, modality=modality)
+    transfer_dicom_series_tags(nii2dcm_properties, dicom_ds)
+
+    image = nii_data.get_fdata()
+    image = image.astype(int)
+    os.makedirs(output_dicom_dir)
+    for instance_index in range(0, nii2dcm_properties["NumberOfInstances"]):
+        transfer_dicom_instance_tags(nii2dcm_properties, dicom_ds, instance_index)
+        write_slice(dicom_ds, image, instance_index, output_dicom_dir)

jbag/dicom/dicom.py

@@ -0,0 +1,164 @@
+import datetime
+from random import randint
+
+from pydicom import Dataset
+from pydicom.dataset import FileDataset, FileMetaDataset
+from pydicom.uid import generate_uid
+
+from jbag.dicom.modalities import Modality
+
+
+def get_dicom_dataset(name, modality: Modality) -> FileDataset:
+    file_meta = FileMetaDataset()
+    file_meta.TransferSyntaxUID = "1.2.840.10008.1.2.1"
+    file_meta.ImplementationVersionName = "DICOM"
+
+    ds = FileDataset(name, {}, file_meta=file_meta, preamble=b"\0" * 128)
+    ds.is_implicit_VR = False
+    ds.is_little_endian = True
+    ds.ImageType = ["DERIVED", "SECONDARY"]
+
+    # add properties
+    patient(ds)
+    general_study(ds)
+    patient_study(ds)
+    frame_of_reference(ds)
+    general_equipment(ds)
+    general_image(ds)
+    general_acquisition(ds)
+    image_plane(ds)
+    image_pixel(ds)
+    SOP_common(ds)
+    VOI_LUT(ds)
+    general_series(ds, file_meta, modality)
+
+    # set datatime
+    dt = datetime.datetime.now()
+    date_str = dt.strftime("%Y%m%d")
+    time_str = dt.strftime("%H%M%S.%f")  # long format with micro seconds
+
+    ds.ContentDate = date_str
+    ds.ContentTime = time_str
+    ds.StudyDate = date_str
+    ds.StudyTime = time_str
+    ds.SeriesDate = date_str
+    ds.SeriesTime = time_str
+    ds.AcquisitionDate = date_str
+    ds.AcquisitionTime = time_str
+    ds.InstanceCreationDate = date_str
+    ds.InstanceCreationTime = time_str
+
+    ds.RescaleIntercept = ""
+    ds.RescaleSlope = ""
+
+    return ds
+
+
+def patient(ds: Dataset):
+    ds.PatientName = "Patient Name"
+    ds.PatientID = "1"
+    ds.PatientSex = ""
+    ds.PatientBirthDate = ""
+
+
+def general_study(ds: Dataset):
+    ds.StudyInstanceUID = generate_uid()
+    ds.StudyDescription = ""
+    ds.ReferringPhysicianName = ""
+
+
+def patient_study(ds: Dataset):
+    ds.PatientAge = ""
+    ds.PatientWeight = ""
+
+
+def general_series(ds: Dataset, file_meta: FileMetaDataset, modality: Modality):
+    ds.Modality = modality.name
+    match modality:
+        case Modality.CT:
+            file_meta.MediaStorageSOPClassUID = "1.2.840.10008.5.1.4.1.1.2"
+            ds.SOPClassUID = "1.2.840.10008.5.1.4.1.1.2"
+            CT_image(ds)
+
+    ds.SeriesInstanceUID = generate_uid(None)
+    ds.SeriesNumber = str(randint(1000, 9999))
+    ds.ProtocolName = "DICOM"
+    ds.PatientPosition = ""
+    ds.AccessionNumber = "123456"
+
+
+def frame_of_reference(ds: Dataset):
+    ds.FrameOfReferenceUID = generate_uid(None)
+
+
+def general_equipment(ds: Dataset):
+    ds.Manufacturer = ""
+    ds.InstitutionName = "INSTITUTION_NAME_UNDEFINED"
+    ds.ManufacturerModelName = ""
+    ds.SoftwareVersions = ""
+
+
+def general_image(ds: Dataset):
+    ds.InstanceNumber = ""
+    ds.PatientOrientation = ""
+    ds.ContentDate = ""
+    ds.ContentTime = ""
+    ds.ImageType = ["SECONDARY", "DERIVED"]
+    ds.LossyImageCompression = "00"
+
+
+def general_acquisition(ds: Dataset):
+    ds.AcquisitionNumber = ""
+    ds.AcquisitionDate = ""
+    ds.AcquisitionTime = ""
+
+
+def image_plane(ds: Dataset):
+    ds.PixelSpacing = ""
+    ds.ImageOrientationPatient = ["1", "0", "0", "0", "1", "0"]
+    ds.ImagePositionPatient = ["0", "0", "0"]
+    ds.SliceThickness = ""
+    ds.SpacingBetweenSlices = ""
+    ds.SliceLocation = ""
+
+
+def image_pixel(ds: Dataset):
+    ds.Rows = 0
+    ds.Columns = 0
+
+    ds.BitsAllocated = 0
+    ds.BitsStored = 0
+    ds.HighBit = 0
+
+    ds.PixelRepresentation = 1
+
+    ds.SmallestImagePixelValue = ""
+    ds.LargestImagePixelValue = ""
+
+    ds.PixelData = ""
+
+
+def SOP_common(ds: Dataset):
+    ds.SOPClassUID = ""
+    ds.SOPInstanceUID = ""
+
+    ds.SpecificCharacterSet = "ISO_IR 100"
+    ds.InstanceCreationDate = ""
+    ds.InstanceCreationTime = ""
+
+    ds.InstanceCreatorUID = ""
+
+
+def VOI_LUT(ds: Dataset):
+    ds.WindowCenter = ""
+    ds.WindowWidth = ""
+
+
+def CT_image(ds: Dataset):
+    ds.SamplesPerPixel = 1
+
+    ds.PhotometricInterpretation = "MONOCHROME2"
+
+    ds.BitsAllocated = 16
+    ds.BitsStored = 12
+    ds.HighBit = ds.BitsStored - 1

jbag/dicom/dicom_tags.py

@@ -0,0 +1,10 @@
+# Largest Image Pixel Value
+Largest_Image_Pixel_Value = (0x0028, 0x0107)
+# Smallest Image Pixel Value
+Smallest_Image_Pixel_Value = (0x0028, 0x0106)
+# Rescale Slope
+Rescale_Slope = (0x0028, 0x1053)
+# Rescale Intercept
+Rescale_Intercept = (0x0028, 0x1052)
+# Pixel Padding Value
+Pixel_Padding_Value = (0x0028,0x0120)

jbag/dicom/modalities.py

@@ -0,0 +1,5 @@
+from enum import Enum
+
+
+class Modality(Enum):
+    CT = 1

jbag/docx/__init__.py

@@ -0,0 +1,4 @@
+from .image import add_image
+from .paragraph import add_paragraph
+from .table import set_cell, set_cell_border, set_three_line_border
+from .text import add_text

jbag/docx/doc.py

@@ -0,0 +1,13 @@
+import os.path
+
+from docx import Document
+
+
+def import_style_from_template(doc: Document, template_doc_file):
+    if not os.path.exists(template_doc_file):
+        raise FileNotFoundError(f"Template Doc file {template_doc_file} not found.")
+
+    template_doc = Document(template_doc_file)
+
+    for style in template_doc.styles:
+        doc.styles.add_style(style.style_id, style.type)