macsima2mc 1.2.3__py3-none-any.whl

macsima2mc/CLI.py

@@ -0,0 +1,84 @@
+import argparse
+import pathlib
+
+#---CLI-BLOCK---#
+def get_args():
+    """
+    This function parses the command line arguments and returns them as a namespace object.
+
+    returns: namespace object with the arguments.
+    """
+    parser=argparse.ArgumentParser()
+
+    #Mandatory arguments
+    parser.add_argument('-i',
+                    '--input',
+                    required=True,
+                    type=pathlib.Path,
+                    help='Path to the cycle folder'
+                    )
+
+    parser.add_argument('-o',
+                    '--output',
+                    required=True,
+                    type=pathlib.Path,
+                    help='Path where the stacks will be saved. If directory does not exist it will be created.'
+                    )
+    #Optional arguments
+    parser.add_argument('-rm',
+                    '--reference_marker',
+                    default='DAPI',
+                    help='string specifying the name of the reference marker'
+                    )
+    
+    parser.add_argument('-osd',
+                    '--output_subdir',
+                    default='raw',
+                    help='string specifying the name of the subfolder in which the staged images will be saved'
+                    )
+
+    parser.add_argument('-ic',
+                    '--illumination_correction',
+                    action='store_true',
+                    help='Applies illumination correction to all tiles, the illumination profiles are created with basicpy'
+                    )
+
+
+    parser.add_argument('-he',
+                    '--hi_exposure_only',
+                    action='store_true',
+                    help='Activate this flag to extract only the set of images with the highest exposure time.'
+                    )
+
+    parser.add_argument('-rr',
+                    '--remove_reference_marker',
+                    action='store_true',
+                    help='It will mark the removal of the reference markers in the markers.csv file except for the first cycle.  Use this when you \
+                        dont want to keep e.g. the DAPI images of the other cycles.'
+                    )
+    
+    parser.add_argument('-qc',
+                    '--qc_metrics',
+                    action='store_true',
+                    help='measure features of contrast, intensity and sharpness of each image'
+                    )
+    
+    parser.add_argument('-oqc',
+                    '--only_qc_file',
+                    action='store_true',
+                    help='skips the stacking of the tiles and only calculates the qc table. Still flag -wt is required to write the table. '
+                    )
+    
+    parser.add_argument('-wt',
+                    '--write_table',
+                    action='store_true',
+                    help='writes a table in --output/cycle_info. Content of table is acquisition parameters, metadata and, if enabled, qc metrics of each tile'
+                    )
+
+    args=parser.parse_args()
+
+    return args
+#---END_CLI-BLOCK---#
+
+
+

macsima2mc/exceptions.py

@@ -0,0 +1,92 @@
+import numpy as np
+import pandas as pd
+
+
+def any_ref(mf_tuple,
+            ref_marker='DAPI'):
+    """
+    This function checks if the reference marker is present in the mf_tuple.
+    Args:
+        mf_tuple (tuple): tuple with the markers and filters
+        ref_marker (str): reference marker used for registration
+    Returns:
+        bool: True if the reference marker is present in the mf_tuple, False otherwise.
+    """
+
+    exist_ref = False
+    for m in mf_tuple:
+        if m[0] == ref_marker:
+            exist_ref = True
+            break
+    return exist_ref
+
+def miss_channel(chann_index,chans_meta,conformed_markers):
+    
+    if chans_meta[ chann_index ].size:
+        pass
+    else:
+
+        ref_index=np.argwhere([meta.size > 0 for meta in chans_meta ]).flatten()[0]
+        chann_meta=chans_meta[ ref_index ]
+        edit_feats={'marker':conformed_markers[ chann_index ][0], 
+                    'filter':conformed_markers[ chann_index ][1]}
+                    #'exposure?':}
+                    #how are conformed markers formed?
+    return True
+
+
+
+def at_roi(grouped,dimensions,ref_marker):
+    #for dimensions is expected that the last element of the list is the exposure_level
+    rows=[]
+    for index,frame in grouped:
+        marker_filter_map = list( frame.groupby(["marker","filter"]).indices.keys() )
+        ref_exists=any_ref(marker_filter_map,ref_marker)
+        subst_exp_level=index[-1]
+        rows.append( list(index) + [ ref_exists, subst_exp_level ] )
+
+    df=pd.DataFrame(rows,columns=dimensions+['ref_marker','aux_exp_level'])
+
+    frames=[]
+    for index,frame in df.groupby(dimensions[:-1]):
+        substitute=frame.loc[ frame['ref_marker']==True,'exposure_level'].max()
+        frame['aux_exp_level']=frame['aux_exp_level'].where(frame['ref_marker'],substitute)
+        frames.append(frame)
+
+    return pd.concat(frames)
+
+def at_tile(group,marker_filter_map):
+    rows=[]
+    for tile_id,frame in group.groupby(['tile']):
+        aux_array = [   frame.loc[ (frame['marker']==marker) & (frame['filter']==filt)].size
+                        for marker, filt in marker_filter_map 
+                    ]
+
+        aux_array =np.array(aux_array)==0
+        missing_channel=np.any(aux_array)
+
+        if missing_channel:
+            channel_indices=np.argwhere(aux_array).flatten()
+            #Each missing (marker,filter) pair will be separated by a colon ":", i.e. marker1,filter1:marker2,filter2
+            channel= ':'.join( [ ','.join(marker_filter_map[i]) for i in channel_indices] )
+        else:
+            channel=''
+            
+        qc_data=[tile_id[0],missing_channel,channel,tile_id[0]]
+        cols=['tile','missing_ch','channels','aux_tile']
+        rows.append(   qc_data )
+
+    df=pd.DataFrame(rows,columns=cols)
+    auxiliary_tile_index=df.loc[df['missing_ch']==False ][['tile']].values[0]
+    df.loc[ df['missing_ch']==True, ['aux_tile']]=auxiliary_tile_index
+    
+    return df 
+
+
+
+
+
+
+
+
+

macsima2mc/illumination_corr.py

@@ -0,0 +1,64 @@
+from basicpy import BaSiC
+import numpy as np
+
+def indices_per_channel(total_imgs, no_of_channels):
+    """
+    This function creates a list of lists with the indices of the images in the stack per channel.
+    Args:
+        total_imgs (int): total number of images in the stack.
+        no_of_channels (int): number of channels.
+    Returns:
+        list: list of lists with the indices of the images in the stack per channel.
+    """
+
+    #total_imgs in the stack
+    img_indices = [list(range(ch,total_imgs,no_of_channels)) for ch in range(0, no_of_channels)]
+    return img_indices
+
+
+def extract_channel_imgs (stack,indices):
+    """
+    This function extracts the images in the stack per channel.
+    Args:
+        stack (np.array): stack of images.
+        indices (list): list of indices of the images in the stack per channel.
+    Returns:
+        np.array: stack of images per channel.
+    """
+
+    return stack[indices,:,:]
+
+def filter_out_blanks(channel_tiles):
+
+    signal_indices=[index for index in range(0,channel_tiles.shape[0]) if np.sum(channel_tiles[index,:,:])>0 ]
+    filtered_tiles=channel_tiles[signal_indices,:,:]
+    return filtered_tiles
+
+
+
+def apply_corr(uncorr_stack,no_of_channels):
+    """
+    This function applies the BaSiC algorithm to correct the illumination in the images.
+    Args:
+        uncorr_stack (np.array): stack of uncorrected images.
+        no_of_channels (int): number of channels.
+    Returns:
+        np.array: stack of corrected images.
+    """
+
+    corr_stack = np.zeros( uncorr_stack.shape,dtype=uncorr_stack.dtype )
+    total_imgs = uncorr_stack.shape[0]
+    indices = indices_per_channel(total_imgs, no_of_channels)
+    basic = BaSiC(get_darkfield=False, smoothness_flatfield=1.0, fitting_mode="approximate", sort_intensity=True)
+
+    for ind_list in indices:
+        uncorr_imgs = extract_channel_imgs(uncorr_stack, ind_list)
+        imgs_for_ffp=filter_out_blanks(uncorr_imgs)
+        #basic.fit(uncorr_imgs)
+        basic.fit(imgs_for_ffp)
+        ffp = basic.flatfield
+        corr_stack[ind_list,:,:] = np.uint16(np.clip(uncorr_imgs.astype(float) / ffp, 0, 65535))
+
+    return corr_stack
+
+

macsima2mc/macsima2mc.py

@@ -0,0 +1,50 @@
+import tools
+from templates import macsima_pattern
+import CLI
+import mc_tools
+
+def main():
+    # Get arguments
+    args = CLI.get_args()
+
+    # Assign arguments to variables
+    input = args.input
+    output = args.output
+    ref = args.reference_marker
+    basicpy_corr = args.illumination_correction
+    out_folder_name = args.output_subdir
+
+    # Extract acquisition info of the cycle from file name,e.g. rack,well,markers,filters, etc.
+    cycle_info = tools.cycle_info(input, macsima_pattern(version=2), ref_marker= ref)
+    
+    # Extract and append ome metadata info contained in each file
+    cycle_info = tools.append_metadata( cycle_info )
+    
+    # Create stack
+    cycle_number=int(cycle_info['cycle'].unique()[0])
+    if args.only_qc_file:
+        pass
+    else:
+        output_dirs = tools.create_stack(cycle_info,
+                                     output,
+                                     ref_marker=ref,
+                                     hi_exp=args.hi_exposure_only,
+                                     ill_corr=basicpy_corr,
+                                     out_folder=out_folder_name)
+        # Save markers file in each output directory
+        for path in output_dirs:
+            mc_tools.write_markers_file(path,args.remove_reference_marker)
+
+    # Calculate and append ome metadata info contained in each file
+    if (args.qc_metrics or args.only_qc_file) :
+        import qc
+        cycle_info=qc.append_qc(cycle_info)
+
+    if args.write_table:
+        qc_output_dir=output / "cycle_info"
+        qc_output_dir.mkdir(parents=True, exist_ok=True)
+        cycle_info.to_csv( qc_output_dir / 'cycle_{c}.csv'.format( c=f'{ cycle_number:03d}' ), index=False )
+    
+
+if __name__ == '__main__':
+    main()

macsima2mc/mc_tools.py

@@ -0,0 +1,110 @@
+from pathlib import Path
+from tools import extract_values
+import re
+import numpy as np
+from ome_types import from_tiff
+from pandas import DataFrame
+
+
+
+def flatten_list(lol):
+    """
+    This function flattens a list of lists.
+    Args:
+        lol (list): list of lists.
+    Returns:
+        list: flattened list.
+    """
+    return [x for xs in lol for x in xs]
+
+
+def markers_file():
+    """
+    This function creates a dictionary with the columns of the markers.csv file.
+    Returns:
+        dict: dictionary with the columns of the markers.csv file.
+    """
+    columns = {'channel_number': [],
+               'cycle_number': [],
+               'marker_name':[],
+               'Filter':[],
+               'background':[],
+               'exposure':[],
+               'remove':[]
+               }
+
+    return columns
+
+
+def get_patterns():
+    """
+    Dictionary of tuples where first element indicates the pattern to search and
+    second element is a boolean that indicates whether to transform the search output into a value or not
+    the keys of this dictionary should be a subset of the keys in the markers_file function.
+    Returns:
+        dict: dictionary with regular expressions to extract metadata from macsima filenames.
+    """
+
+    patterns = {
+        'cycle_number': (r"cycle-(.*?)-", True),
+        'marker_name' : (r"markers-(.*?)-filters",False),
+        'Filter'      : (r"-filters-(.*?).ome",False),
+        'background'  : (r"-src-(.*?)-" ,False)
+        }
+
+    return patterns
+
+
+def write_markers_file( data_path, rm_ref_marker,ref_marker='DAPI'):
+    """
+    This function writes the markers.csv file.
+    Args:
+        data_path (Path): path to the folder containing the images.
+        rm_ref_marker(Boolean): mark reference markers for removal except for the first one
+        ref_marker (str): reference marker.
+    Returns:
+        dict: dictionary with the columns of the markers.csv file.
+    """
+
+    img_paths = list(sorted( data_path.glob('*.tif*')))
+    mks_file = markers_file()
+    patt = get_patterns()
+
+    for img in img_paths:
+        img_name = [img.stem]
+        cycle_no = extract_values(patt['cycle_number'][0], img_name, number_cast=patt['cycle_number'][1])
+        background = extract_values(patt['background'][0], img_name, number_cast=patt['background'][1])
+        markers = extract_values(patt['marker_name'][0], img_name, number_cast=patt['marker_name'][1])[0].split('__')
+        filters = extract_values(patt['Filter'][0], img_name, number_cast=patt['Filter'][1])[0].split('__')
+        ome = from_tiff(img)
+
+        if background[0]=='B':
+            remove = len(markers)*['TRUE']
+            markers = ['bg_{c}_{m}-{f}'.format( c= f'{cycle_no[0]:03d}' , m=x , f=y ) for x,y in zip(markers,filters) ]
+            fmt_background = len(markers)*['']
+        else:
+            fmt_background = []
+            remove = len(markers)*['']
+            for x,y in zip(markers,filters):
+                if x == ref_marker:
+                    fmt_background.append('')
+                else:
+                    fmt_background.append(f'bg_{cycle_no[0]:03d}_{x}-{y}')
+
+        mks_file['cycle_number'].extend(len(markers)*cycle_no)
+        mks_file['marker_name'].extend(markers)
+        mks_file['Filter'].extend(filters)
+        mks_file['background'].extend(fmt_background)
+        mks_file['exposure'].extend([ome.images[0].pixels.planes[ch].exposure_time for ch,_ in enumerate(markers)])
+        mks_file['remove'].extend(remove)
+
+    mks_file['channel_number'] = list(range(1, 1 + len(mks_file['marker_name'])))
+    mks_file_df = DataFrame(mks_file)
+    if rm_ref_marker:
+        earliest_cycle=mks_file_df['cycle_number'].min()
+        condition=( mks_file_df['marker_name']== ref_marker ) & ( mks_file_df['cycle_number']>earliest_cycle ) 
+        mks_file_df.loc[ condition , ['remove'] ]='TRUE'
+    
+    mks_file_df.to_csv( data_path.parent.absolute() / 'markers.csv' , index=False )
+
+    return mks_file

macsima2mc/ome_schema.py

@@ -0,0 +1,179 @@
+#!/usr/bin/python
+import ome_types
+from uuid import uuid4
+from ome_types.model import OME,Image,Pixels,TiffData,Channel,Plane
+import platform
+
+
+
+def INPUTS(frame, conformed_markers):
+    """
+    This function creates a dictionary with the metadata of the tiles.
+    Args:
+        frame (pd.DataFrame): dataframe containing the metadata of the tiles.
+        conformed_markers (list): list of tuples with the name of the markers and their corresponding fluorophore.
+    Returns:
+        dict: dictionary with the metadata of the tiles.
+    """
+
+    #features = frame.columns.values
+    #inputs = {column:[] for column in features }
+    #metadata = [frame.loc[ (frame['marker']==marker) & (frame['filter']==filt)] for marker, filt in conformed_markers]
+    #for meta in metadata:
+    #    for f in features:
+    #        inputs[f].append(meta[f].values[0])2
+    inputs=frame.to_dict('list')
+
+    return inputs
+
+
+def TIFF_array(no_of_channels, inputs={'offset':0}):
+    """
+    This function creates a list of TIFFData objects.
+    Args:
+        no_of_channels (int): number of channels.
+        inputs (dict): dictionary with the metadata of the tiles.
+    Returns:
+        list: list of TIFFData objects.
+    """
+    TIFF = [
+        TiffData(
+            first_c=ch,
+            ifd=n,
+            plane_count=1
+            )
+        for n,ch in enumerate(range(0,no_of_channels), start=inputs['offset'])
+        ]
+
+    return TIFF
+
+
+def PLANE_array(no_of_channels, inputs):
+    """
+    This function creates a list of Plane objects.
+    Args:
+        no_of_channels (int): number of channels.
+        inputs (dict): dictionary with the metadata of the tiles.
+    Returns:
+        list: list of Plane objects.
+    """
+
+    PLANE = [
+        Plane(
+            the_c=ch,
+            the_t=0,
+            the_z=0,
+            position_x=inputs['position_x'][ch],
+            position_y=inputs['position_y'][ch],
+            position_z=0,#Z=0 is just a place holder
+            exposure_time=inputs['exposure_time'][ch],
+            position_x_unit=inputs['position_x_unit'][ch],
+            position_y_unit=inputs['position_y_unit'][ch]
+            )
+        for ch in range(0,no_of_channels)
+        ]
+
+    return PLANE
+
+
+def CHANN_array(no_of_channels, inputs):
+    """
+    This function creates a list of Channel objects.
+    Args:
+        no_of_channels (int): number of channels.
+        inputs (dict): dictionary with the metadata of the tiles.
+    Returns:
+        list: list of Channel objects.
+    """
+
+    CHANN = [
+        Channel(
+            id=f"Channel:{100+int(inputs['tile'][ch])}:{ch}:{inputs['marker'][ch]}", # 'Channel:{y}:{x}:{marker_name}'.format(x=ch,y=100+int( inputs['tile'][ch] ) ,marker_name=inputs['marker'][ch] )
+            color=(255,255,255),
+            emission_wavelength=inputs['emission_wavelenght'][ch],
+            emission_wavelength_unit=inputs['emission_wavelenght_unit'][ch],
+            excitation_wavelength=inputs['excitation_wavelenght'][ch],
+            excitation_wavelength_unit=inputs['excitation_wavelenght_unit'][ch]
+            )
+        for ch in range(0,no_of_channels)
+        ]
+
+    return CHANN
+
+
+def PIXELS_array(chann_block, plane_block, tiff_block, inputs):
+    """
+    This function creates a Pixels object.
+    Args:
+        chann_block (list): list of Channel objects.
+        plane_block (list): list of Plane objects.
+        tiff_block (list): list of TIFFData objects.
+        inputs (dict): dictionary with the metadata of the tiles.
+    Returns:
+        Pixels: Pixels object.
+    """
+
+    PIXELS = Pixels(
+        id=f"Pixels:{inputs['tile'][0]}",
+        dimension_order='XYCZT',
+        size_c=len(chann_block),
+        size_t=1,
+        size_x=inputs['size_x'][0],
+        size_y=inputs['size_y'][0],
+        size_z=1,
+        type=inputs['type'][0],#bit_depth
+        big_endian=False,
+        channels=chann_block,
+        interleaved=False,
+        physical_size_x=inputs['physical_size_x'][0],
+        physical_size_x_unit=inputs['physical_size_x_unit'][0],
+        physical_size_y=inputs['physical_size_y'][0],
+        physical_size_y_unit=inputs['physical_size_y_unit'][0],
+        physical_size_z=1.0,
+        planes=plane_block,
+        significant_bits=inputs['significant_bits'][0],
+        tiff_data_blocks=tiff_block
+    )
+
+    return PIXELS
+
+
+def IMAGE_array(pixels_block, imageID):
+    """
+    This function creates an Image object.
+    Args:
+        pixels_block (Pixels): Pixels object.
+        imageID (int): identifier of the image.
+    Returns:
+        Image: Image object.
+    """
+    
+    IMAGE = Image(
+            id =f'Image:{imageID}',
+            pixels=pixels_block
+            )
+
+    return IMAGE
+
+
+def OME_metadata(image_block):
+    """
+    This function creates an OME object.
+    Args:
+        image_block (list): list of Image objects.
+    Returns:
+        OME: OME object.
+    """
+    ome = OME()
+    ome.creator = " ".join([ome_types.__name__,
+                        ome_types.__version__,
+                        '/ python version-',
+                        platform.python_version()
+                        ]
+                        )
+
+    ome.images = image_block
+    ome.uuid = uuid4().urn
+    ome_xml = ome_types.to_xml(ome)
+
+    return ome, ome_xml

macsima2mc/ome_writer.py

@@ -0,0 +1,30 @@
+import ome_schema as schema
+import pandas as pd
+
+
+def create_ome(tile_info,
+               conformed_markers):
+    """
+    This function creates an OME-XML file from a pandas dataframe containing the metadata of the tiles.
+    Args:
+        tile_info (pd.DataFrame): dataframe containing the metadata of the tiles.
+        conformed_markers (list): list of tuples with the name of the markers and their corresponding fluorophore.
+    Returns:
+        str: OME-XML file.
+    """
+
+    grouped_tiles = tile_info.groupby(['tile'])
+    no_of_channels = len(conformed_markers)
+    tiles_counter = 0
+    image = []
+    for tileID, frame in grouped_tiles:
+        metadata = schema.INPUTS(frame, conformed_markers)
+        tiff = schema.TIFF_array(no_of_channels, inputs={'offset': no_of_channels * tiles_counter})
+        plane = schema.PLANE_array(no_of_channels, metadata)
+        channel = schema.CHANN_array(no_of_channels, metadata)
+        pixels = schema.PIXELS_array(channel, plane, tiff, metadata)
+        image.append(schema.IMAGE_array (pixels, tiles_counter))
+        tiles_counter += 1
+    ome, ome_xml = schema.OME_metadata(image)
+
+    return ome, ome_xml

macsima2mc/qc.py

@@ -0,0 +1,77 @@
+import pandas as pd
+from skimage.measure import blur_effect
+from tifffile import imread
+from tools import merge_dicts
+import numpy as np
+from multiprocessing import Pool
+
+
+def contrast(img):
+
+
+    #the dictionary below gives the arguments of the np.roll function to
+    #shift the array in the elemental angle specified by the dictionary keys
+
+    angles={0  : [(-1,0),(1,0)],
+            45 : [(-1,1),(1,0)],
+            90 : [(0,1),(0,0)],
+            135: [(1,1),(1,0)],
+            180: [(1,0),(1,0)],
+            225: [(-1,1),(0,1)],
+            270: [(0,-1),(0,0)],
+            315: [(-1,-1),(0,1)]
+            }
+    diff=np.zeros(img.shape)
+    for key,val in angles.items():
+        diff+= ( img-np.roll(img,val[0],axis=val[1]) )**2
+
+    contrast_arr=np.sqrt(diff)
+    med=np.median(contrast_arr)
+    iqr=np.percentile(contrast_arr, 75)-np.percentile(contrast_arr, 25)
+    
+    return med,iqr
+    
+
+
+
+def calculate_img_qc(img_path):
+    """
+    This function extracts the metadata from a tiff file using the ome-xml format.
+    Args:
+        img_path (Path): full path to the tiff file
+    Returns:
+        dict: dictionary with qc_metrics for the input file (img_path)
+    """
+    img=imread(img_path)
+    intensity_med=np.median(img)
+    intensity_iqr=np.percentile(img, 75)-np.percentile(img, 25)
+    contrast_med,contrast_iqr=contrast(img)
+    blur=blur_effect(img)
+
+    return {
+            "intensity_median" : intensity_med ,
+            "intensity_iqr"    : intensity_iqr ,
+            "contrast_median"  :contrast_med,
+            "contrast_iqr"     :contrast_iqr,
+            "blur"             :blur
+            }
+
+
+
+def append_qc(cycle_info_df,append=False):
+
+    with Pool() as pool:
+        qc_feats=pool.map(calculate_img_qc, cycle_info_df['full_path'].values)
+
+    for key, val in merge_dicts(qc_feats).items():
+        cycle_info_df.insert(loc=cycle_info_df.shape[1], column=key, value=val)
+        
+    return cycle_info_df
+
+
+
+
+
+
+
+

macsima2mc/templates.py

@@ -0,0 +1,65 @@
+import re
+
+def info_dic(target_pattern):
+    """
+    creates a dictionary with keys mirroring the keys in the target_pattern dictionary.
+    The value of each key is an empty string.
+    Args:
+        target_pattern (dict): dictionary taken from the macsima_pattern function.
+    Returns:
+        dict: template with keys from macsima_pattern plus 2 extra keys, full path of image and image name.
+    """
+
+    # Initialize dictionary
+    template = {
+        'full_path': '',
+        'img_name': ''
+    }
+
+    for key in target_pattern:
+        template[key] = ''
+    
+    return template
+
+
+def macsima_pattern(version=1):
+    """
+    Returns a dictionary with regular expressions to extract metadata from macsima filenames.
+    Args:
+        version (int): version of the macsima filenames. Default is 1.
+    Returns:
+        dict: dictionary with regular expressions to extract metadata from macsima filenames.
+    """
+    
+    if version == 1:
+        pattern = {
+            "cycle"         : r"(.*?)_(.*?)Cycle",
+            "source"        : r"_(.*?)Cycle",
+            "rack"          : r"_R-(\d+)",
+            "well"          : r"_W-(\d+)",
+            "roi"           : r"_G-(\d+)",
+            "tile"          : r"_F-(\d+)",
+            "exposure_time" : r"_E-(\d+)",
+            "marker"        : r"Cycle_(.*?)_",
+            "filter"        : r".*_([^_]*)_\d+bit"
+        }
+
+    elif version==2:
+
+        pattern = {
+            "cycle"         : r"CYC-(\d+)",
+            "source"        : r"_ST-(.*?)_",
+            "rack"          : r"_R-(\d+)",
+            "well"          : r"_W-(.*?\d+)",
+            "roi"           : r"_ROI-(\d+)",
+            "tile"          : r"_F-(\d+)",
+            "exposure_time" : r"_EXP-(\d+(?:\.\d+)?)",
+            "marker"        : r"_A-(.*?)_",
+            "filter"        : r"_D-(.*?)_"
+            }
+        
+    else:
+        raise ValueError(
+            "version argument should be 1 or 2"
+        )
+    return pattern

macsima2mc/tools.py

@@ -0,0 +1,406 @@
+from templates import info_dic
+import re
+import pandas as pd
+import tifffile as tifff
+from bs4 import BeautifulSoup
+import numpy as np
+from pathlib import Path
+import ome_writer
+import exceptions as expt
+import illumination_corr
+
+
+def merge_dicts(list_of_dicts):
+    """
+    This function merges a list of dictionaries into a single dictionary where the values are stored in lists.
+    Args:
+        list_of_dicts (list): list of dictionaries with common keys
+    Returns:
+        merged_dict (dict): dictionary with the values stored in lists
+    """
+    merged_dict = {}
+    for d in list_of_dicts:
+        for key, value in d.items():
+            if key in merged_dict:
+                merged_dict[key].append(value)
+            else:
+                merged_dict[key] = [value]
+    return merged_dict
+
+def extract_values(target_pattern,
+                   strings,
+                   number_cast=True):
+    """
+    This function extracts the values from a list of strings using a regular expression pattern.
+    Args:
+        target_pattern (str): regular expression pattern
+        strings (list): list of strings to extract the values from
+        number_cast (bool): if True, the extracted values are cast to integers
+    Returns:
+        list: list of extracted values
+    """
+    return [
+        (int(m.group(1)) if number_cast else m.group(1))
+        if (m := re.search(target_pattern, s))
+        else None
+        for s in strings
+    ]
+
+
+def extract_metadata(tile_abs_path):
+    """
+    This function extracts the metadata from a tiff file using the ome-xml format.
+    Args:
+        tile_abs_path (Path): full path to the tiff file
+    Returns:
+        dict: dictionary with the metadata extracted from the tiff file using the ome-xml format.
+    """
+    with tifff.TiffFile(tile_abs_path) as tif:
+            metadata = tif.ome_metadata
+
+    ome = BeautifulSoup(metadata, "xml")
+    return {
+            "position_x": float(ome.StageLabel["X"]),
+            "position_y": float(ome.StageLabel["Y"]),
+            "position_x_unit": ome.StageLabel["XUnit"],
+            "position_y_unit": ome.StageLabel["YUnit"],
+            "physical_size_x": float(ome.Pixels["PhysicalSizeX"]),
+            "physical_size_x_unit": ome.Pixels["PhysicalSizeXUnit"],
+            "physical_size_y": float(ome.Pixels["PhysicalSizeY"]),
+            "physical_size_y_unit": ome.Pixels["PhysicalSizeXUnit"],
+            "size_x":ome.Pixels["SizeX"],
+            "size_y":ome.Pixels["SizeY"],
+            "type": ome.Pixels["Type"],#bit_depth
+            "significant_bits": int(ome.Pixels["SignificantBits"]),
+            "emission_wavelenght":ome.Channel["EmissionWavelength"],
+            "excitation_wavelenght":ome.Channel["ExcitationWavelength"],
+            "emission_wavelenght_unit":ome.Channel["EmissionWavelengthUnit"],
+            "excitation_wavelenght_unit":ome.Channel["ExcitationWavelengthUnit"]
+            }
+
+def cycle_info(cycle_path,
+               platform_pattern,
+               ref_marker='DAPI'):
+    """
+    This function reads the images produced by the MACSima device and returns the acquisition information
+    specified in the image name.
+
+    Args:
+        cycle_path (Path): full path to the cycle folder
+        platform_pattern (dict): dictionary with the pattern to search in the image name.
+        ref_marker (str): marker of reference used for registration
+
+    Returns:
+        df (pd.DataFrame): dataframe with the acquisition information, ROI, rack, exposure time etc.
+    """
+
+    full_image_paths = list(cycle_path.glob("*.tif"))
+    file_names = [x.name for x in full_image_paths]
+
+    info=info_dic(platform_pattern)
+
+    info['full_path'] = full_image_paths
+    info['img_name'] = file_names
+
+    for feat,value in platform_pattern.items():
+        info[feat]=extract_values(target_pattern=value, strings=file_names,number_cast=False)
+
+    df = pd.DataFrame(info)
+    df.loc[df['filter']==ref_marker,'marker'] = ref_marker
+
+    df.insert(loc=df.shape[1], column="exposure_level", value=0)
+    df["exposure_time"] = df["exposure_time"].astype(float)
+    df["exposure_level"] = ( df.groupby(["source","marker","filter"])["exposure_time"].rank(method="dense")).astype(int)
+
+    return df
+
+
+def append_metadata(cycle_info_df):
+    """
+    This function appends the metadata extracted from the tiff files to the cycle_info dataframe.
+    Args:
+        cycle_info_df (pd.DataFrame): dataframe with the acquisition information
+    Returns:
+        pd.DataFrame: dataframe with the metadata appended to the cycle_info dataframe as new columns.
+    """
+    meta_feats=list( map(extract_metadata, cycle_info_df['full_path'].values) )
+
+    for key, val in merge_dicts(meta_feats).items():
+        cycle_info_df.insert(loc=cycle_info_df.shape[1], column=key, value=val)
+
+    return cycle_info_df
+
+
+def conform_markers(mf_tuple,
+                    ref_marker='DAPI'):
+    """
+    This function reorders the markers in the mf_tuple so that the reference marker is the first element.
+    Args:
+        mf_tuple (tuple): tuple with the markers and filters
+        ref_marker (str): reference marker used for registration
+    Returns:
+        list: list with the markers and filters reordered so that the reference marker is the first element.
+    """
+
+    markers = [tup for tup in mf_tuple if tup[0]!=ref_marker]
+    markers.insert(0,(ref_marker,ref_marker))
+    return markers
+
+def init_stack(group,
+               no_of_channels):
+    """
+    This function initializes the stack array with the dimensions of the tiles.
+    Args:
+        ref_tile_index (int): index of the reference tile
+        groupby_obj (pd.DataFrame.groupby): groupby object with the tiles
+        marker_filter_map (list): list with the markers and filters
+    Returns:
+        np.ndarray: array with the dimensions of the stack array (depth, height, width) and the dtype of the
+        reference tile.
+    """
+    aux_array=[ group['size_x'].unique() , group['size_y'].unique(), group['type'].unique() ]
+    check_array=np.array( [ len(element) for element in aux_array ] )
+    if np.any(check_array>1):
+        print("Warning:tiles of these acquisition have no unique value for the following columns: xy-size or data type")
+    width, height, data_type = [ element[0] for element in aux_array  ]
+    total_tiles = group['tile'].nunique()
+    depth = total_tiles * no_of_channels
+    
+    stack = np.zeros( (depth,int(height),int(width)), dtype=data_type)
+
+    return stack
+
+def cast_stack_name(cycle_no,
+                    acq_group_index,
+                    marker_filter_map):
+    """
+    This function creates the name of the stack file.
+    Args:
+        cycle_no (int): cycle number
+        acq_group_index (tuple): tuple with the acquisition information
+        marker_filter_map (list): list with the markers and filters
+    Returns:
+        str: name of the stack file.
+    """
+    markers='__'.join([element[0] for element in marker_filter_map ])
+    filters='__'.join([element[1] for element in marker_filter_map ])
+    cycle_no = int(cycle_no)
+
+    c = f'{cycle_no:03d}'
+    s = acq_group_index[0]
+    e = acq_group_index[4]
+    r = acq_group_index[1]
+    w = acq_group_index[2]
+    roi = acq_group_index[3]
+    m = markers
+    f = filters
+    img_format = 'ome.tiff'
+
+    # Nicer way to format strings
+    name = f'cycle-{c}-src-{s}-rack-{r}-well-{w}-roi-{roi}-exp-{e}-markers-{m}-filters-{f}.{img_format}'
+
+    return name
+
+
+def cast_outdir_name(tup):
+    """
+    This function creates the name of the output directory.
+    Args:
+        tup (tuple): tuple with the acquisition information
+    Returns:
+        str: name of the output directory.
+    """
+    r = tup[1]
+    w = tup[2]
+    roi = tup[3]
+    e = tup[4]
+
+    # Nicer way to format strings
+    name = f'rack-{r}-well-{w}-roi-{roi}-exp-{e}'
+
+    return name
+
+
+def outputs_dic():
+    """
+    This function initializes the dictionary used to store the outputs of the create_stack function.
+    Returns:
+        dict: dictionary with the keys 'index', 'array', 'full_path', 'ome' and empty lists as values
+    """
+
+    out={
+        'index':[],
+        'array':[],
+        'full_path':[],
+        'ome':[],
+        }
+
+    return out
+
+
+def select_by_exposure(list_indices,
+                       exp_index,
+                       target='max'):
+    """
+    This function selects the indices with the maximum or minimum exposure time.
+    Args:
+        list_indices (list): list of indices
+        exp_index (int): index of the exposure time
+        target (str): 'max' or 'min'
+    Returns:
+        list: list of selected indices
+    """
+    selected_indices = []
+    df_aux = pd.DataFrame( np.row_stack(list_indices) )
+    group_by_indices = np.setdiff1d( range(0, len(list_indices[0]) ), exp_index ).tolist()
+
+    for key, frame in df_aux.groupby( group_by_indices ):
+        if target == 'max':
+            selected_indices.append( key + ( int(frame[exp_index].max() ), ) )
+        elif target == 'min':
+            selected_indices.append( key + ( int( frame[exp_index].min()), ) )
+
+    return selected_indices
+
+def append_reference(frame,frame_index,groups,aux_reference_exp_level,ref_marker_name):
+
+    aux_index = list(frame_index)
+    aux_index[-1] = aux_reference_exp_level
+    aux_index = tuple(aux_index)
+    aux_group = groups.get_group(aux_index)
+    aux_group = aux_group.loc[aux_group['marker']==ref_marker_name]
+    frame_ = pd.concat([frame, aux_group])
+    return frame_
+
+def append_missing_channels(group, exception_table ):
+    #exception_table.cols=["tile","missing_ch","channels","aux_tile"]
+    tiles=group.groupby(['tile'])
+    incomplete_tiles=exception_table.loc[exception_table['missing_ch']==True ] 
+    add_tiles=[]
+    for row in incomplete_tiles.itertuples(index=False):
+        aux_tile_df=tiles.get_group( (row.aux_tile,) )
+        missing_markers=[ tuple(element.split(',')) for element in row.channels.split(':') ]
+        for marker, filt in missing_markers:
+            df=aux_tile_df.loc[ (aux_tile_df['marker']==marker) & (aux_tile_df['filter']==filt) ]
+            #df['tile']=row.tile
+            df.loc[:,'tile']=row.tile
+            add_tiles.append(df)
+
+    aux_group=pd.concat(add_tiles)
+    aux_group[ ['full_path','img_name'] ]='missing'
+    group_=pd.concat([group,aux_group])
+
+    return group_
+
+def conform_acquisition_group(group,conformed_markers):
+    aux=[]
+    for tile_id,frame in group.groupby(['tile']):
+        aux.extend([ frame.loc[ (frame['marker']==marker) & (frame['filter']==filt)] for marker, filt in conformed_markers ]) 
+    group_conformed=pd.concat(aux)
+
+    return group_conformed
+
+
+
+def create_stack(cycle_info_df,
+                 output_dir,
+                 ref_marker='DAPI',
+                 hi_exp=False,
+                 ill_corr=False,
+                 out_folder='raw',
+                 extended_outputs=False):
+    """
+    This function creates the stack of images from the cycle_info dataframe.
+    Args:
+        cycle_info_df (pd.DataFrame): dataframe with the acquisition information
+        output_dir (Path): full path to the output directory
+        ref_marker (str): reference marker used for registration
+        hi_exp (bool): if True, only the tiles with the highest exposure time are selected
+        ill_corr (bool): if True, the illumination correction is applied
+        out_folder (str): name of the output folder
+        extended_outputs (bool): if True, the function returns a dictionary with the stack arrays, full paths and ome-xml metadata
+    Returns:
+        np.ndarray or list: stack array or list with the full paths of the stack files created in the output directory.
+    """
+
+    if extended_outputs:
+        out = outputs_dic()
+    else:
+        out = {'output_paths':[]}
+
+    #'exposure_level' should always be the last element of the dimensions list
+    dimensions=['source','rack','well','roi','exposure_level']
+    
+    acq_group = cycle_info_df.groupby(dimensions)
+    acq_index = list( acq_group.indices.keys() )
+    expt_matrix_roi=expt.at_roi(acq_group,dimensions,ref_marker).groupby(dimensions)#exceptions matrix
+
+    if hi_exp:
+        exp_level_index=np.argwhere( np.asarray(dimensions)=='exposure_level' ).flatten()[0]
+        acq_index = select_by_exposure(acq_index,exp_level_index,target='max')
+
+    for index in acq_index:
+        stack_output_dir = output_dir / cast_outdir_name(index) / out_folder
+        stack_output_dir.mkdir(parents=True, exist_ok=True)
+        group = acq_group.get_group(index)
+
+        exist_ref, aux_reference= expt_matrix_roi.get_group(index )[ ['ref_marker','aux_exp_level'] ].iloc[0].values
+        if not exist_ref:
+            group=append_reference(group, index, acq_group, aux_reference, ref_marker)
+        #extract list of unique pairs (marker,filter)
+        marker_filter_map=group[['marker','filter']].value_counts().index.values
+        #conform the pairs (marker,filter) as to have the reference marker in the first place (1st channel) of the list 
+        conformed_markers = conform_markers(marker_filter_map, ref_marker)
+        
+        expt_matrix_tiles=expt.at_tile(group,conformed_markers)
+        if expt_matrix_tiles['missing_ch'].any():
+            group=append_missing_channels(group,expt_matrix_tiles)
+
+        stack = init_stack(group, len( conformed_markers))
+        conformed_group=conform_acquisition_group(group,conformed_markers)
+        #ome = ome_writer.create_ome(group, conformed_markers)
+        ome = ome_writer.create_ome(conformed_group, conformed_markers)
+        counter = 0
+        groups_of_tiles = conformed_group.groupby(['tile'])
+        #for tile_no, frame in groups_of_tiles:
+        #    for marker, filter in conformed_markers:
+        #        target_path = frame.loc[ (frame['marker']==marker) & (frame['filter']==filter) ].full_path.values[0]
+        #       stack[counter,:,:] = tifff.imread(Path(target_path))
+        #      counter += 1
+        for tile_id,frame in groups_of_tiles:
+            for img_path in frame['full_path'].values:
+                try:
+                    stack[counter,:,:] = tifff.imread(Path(img_path))
+                except:
+                    if img_path=='missing':
+                        pass
+                counter += 1
+                
+
+
+        stack_name = cast_stack_name(frame.cycle.iloc[0], index, conformed_markers)
+
+        if ill_corr:
+            tag = 'corr_'
+            no_of_channels = len(conformed_markers)
+            stack = illumination_corr.apply_corr(stack,no_of_channels)
+        else:
+            tag = ''
+
+        stack_file_path = stack_output_dir / f'{tag}{stack_name}'
+
+        if extended_outputs:
+            out['index'].append(index)
+            out['array'].append(stack)
+            out['full_path'].append(stack_file_path)
+            out['ome'].append(ome)
+        else:
+            out['output_paths'].append(stack_output_dir)
+            tifff.imwrite( stack_file_path , stack, photometric='minisblack' )
+            ome,ome_xml = ome_writer.create_ome(group, conformed_markers)
+            tifff.tiffcomment(stack_file_path, ome_xml)
+        
+    if extended_outputs:
+        return out
+    else:
+        return np.unique( out['output_paths'] )

macsima2mc-1.2.3.dist-info/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2024, Schapiro Lab
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

macsima2mc-1.2.3.dist-info/METADATA

@@ -0,0 +1,64 @@
+Metadata-Version: 2.2
+Name: macsima2mc
+Version: 1.2.3
+Summary: stages MACSima tiles for registration with ASHLAR in MCMICRO.
+Author-email: Victor Perez <hhabraxas@gmail.com>, "Miguel A. Ibarra-Arellano" <c180l058j@mozmail.com>
+License: BSD-3-Clause
+Project-URL: Homepage, https://github.com/SchapiroLabor/macsima2mc
+Project-URL: Issues, https://github.com/SchapiroLabor/macsima2mc/issues
+Keywords: mcmicro,multiplex imaging,proteomics,macsima,staging
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ome-types==0.5.2
+Requires-Dist: numpy
+Requires-Dist: tifffile
+Requires-Dist: pandas
+Requires-Dist: beautifulsoup4
+Requires-Dist: scikit-image
+Requires-Dist: BaSiCPy
+
+# Staging module for Miltenyi - MACSIMA to MCMICRO
+
+The macsima2mc.py script stages MACSima data sets for being registerd with ASHLAR in MCMICRO.
+
+The script takes as main input the path to the cycle folder that cointains the raw tiles generated by the Miltenyi-MACSima platform.  macsima2mc.py reads these tiles and distributes them into acquisition groups. i.e tiles with common rack, well, ROI and exposure levels will be written into an ome.tiff file with the necessary metadata for registration.  To be more precise two such ome.tiff files will be generated per cycle, one corresponds to the background signal and the other to the markers signal.
+ 
+## CLI
+### Required arguments
+| Argument|Long name|Type|Description|Default value|
+|---------|---------|----|-----------|-------------|
+| -i | string/path | --input | Absolute path to the the parent folder of the raw tiles, i.e. the cycle folder whose name follows the pattern X_Cycle_N,where N represents the cycle number | NA |
+| -o | string/path | --output | Absolute path to the directory in which the outputs will be saved. If the output directory doesn't exist it will be created. | NA | 
+
+### Optional arguments
+| Argument|Type|Long name| Description | Default value |
+|---------|----|---------|-------------|---------------|
+|-rm|string | --reference_marker | Name of the reference marker for registration|'DAPI'|
+|-osd|string | --output_subdir | String specifying the name of the subfolder in which the staged images will be saved.|'raw'|
+|-ic|boolean flag | --illumination_correction |Give this flag to apply illumination correction to all tiles, the illumination profiles are calculated with basicpy | FALSE |
+|-he|boolean flag | --hi_exposure_only |Give this flag to extract only the set of images with the highest exposure time|FALSE|
+|-rr|boolean flag | --remove_reference_marker |mark the removal of the reference marker ,e.g. DAPI, for all cycles except the first one |FALSE|
+|-qc|boolean flag | --qc_metrics | measure features of contrast, intensity and sharpness of each tile in the cycle and appends them to a table |FALSE|
+|-wt|boolean flag | --write_table | writes a table with the acquisition parameters, metadata and,if enabled, qc metrics of each tile. Table will be saved in --output/cycle_info   |FALSE|
+## Container usage
+### download container:
+- Docker
+```
+docker pull ghcr.io/schapirolabor/macsima2mc:v1.1.1
+```
+- Singularity
+```
+singularity pull docker://ghcr.io/schapirolabor/macsima2mc:v1.1.1
+```
+### Script execution
+
+- Singularity
+``` bash
+singularity exec --bind $path_to_your_local_cycle_folder:/mnt,$path_to_your_local_output_folder:/media --no-home $path_to_container python staging/macsima2mc/macsima2mc.py -i /mnt/$path_to_your_local_cycle_folder -o /media/$path_to_your_local_output_folder
+```
+

macsima2mc-1.2.3.dist-info/RECORD

@@ -0,0 +1,17 @@
+macsima2mc/CLI.py,sha256=631g1-wqKMUkuwYU6Lul9OnZG8uNeDhku-B3qvzCxwY,3019
+macsima2mc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+macsima2mc/exceptions.py,sha256=JmerNzYUx9nF684lwhUESL0WBb_Vgx_krw20RGwOXXM,2950
+macsima2mc/illumination_corr.py,sha256=R5kaTdKpSG_NNLUkUFFb_o9ysjRo9Z_NVF7XeYSShuw,2150
+macsima2mc/macsima2mc.py,sha256=LnHZhYYEbFOkVNEPgcg4niT_EJkkLzbFW40hOsSkn00,1740
+macsima2mc/mc_tools.py,sha256=XYW6QZhmdmmBWlSzDU9Fx8Wyv9e1Ru_p8kUtFIi4upQ,3965
+macsima2mc/ome_schema.py,sha256=Ub8zWW292UJ-UPPizYOym8Pdguzk_oANVVNUFvS4YNA,5263
+macsima2mc/ome_writer.py,sha256=1mNAG2_X7qq4Et6RuA0QcMp-J1c9coHFn7NRP9Ysbx0,1163
+macsima2mc/qc.py,sha256=GG-nteWJt1YAmNQybS141WOlp7tcA9-0u-IMpv4BR_E,1958
+macsima2mc/templates.py,sha256=FXoFrmjXHo27fRmxDBh9SUY-t87x4D6PrcbX5DR4bmY,1974
+macsima2mc/tools.py,sha256=7cB9j3spT7bXn7tOCBl8IIKedoht5sf0x7Yc3xqA3zg,15198
+macsima2mc-1.2.3.dist-info/LICENSE,sha256=HGw52jD0kv8othfJyGZUgeF0ixa0nXNxpm9LYHI6Mo4,1499
+macsima2mc-1.2.3.dist-info/METADATA,sha256=eGsuab1C4-hiDkgXd6BqMGIqNxY-MYsynzFQSX9bCh4,3708
+macsima2mc-1.2.3.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+macsima2mc-1.2.3.dist-info/entry_points.txt,sha256=b5eMvcI2cGc45a4KL98gHAlwcICMTXSsi0wGEb-D8hc,58
+macsima2mc-1.2.3.dist-info/top_level.txt,sha256=9cYr15WLXjXnOaEh4UkVoxAH_jzBYsqSpqphNaYIZ8c,11
+macsima2mc-1.2.3.dist-info/RECORD,,

macsima2mc-1.2.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (76.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

macsima2mc-1.2.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+macsima2mc = macsima2mc.macsima2mc:main

macsima2mc-1.2.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+macsima2mc