mb_utils 2.0.3__py3-none-any.whl

mb/utils/deprecated.py

@@ -0,0 +1,85 @@
+'''Utilities to deprecate a function or a module. 
+MTbase function.
+'''
+
+
+from functools import wraps
+import traceback as _tb
+from .logging import logg
+
+__all__ = ['deprecated_func']
+
+def extract_stack_compact():
+    '''Returns the current callstack in a compact format.'''
+    lines = _tb.format_list(_tb.extract_stack())
+    lines = "".join(lines).split('\n')
+    lines = [line for line in lines if 'frozen importlib' not in line]
+    return lines
+
+
+def deprecated_func(deprecated_version, suggested_func=None, removed_version=None, docstring_prefix="",logger=None):
+    '''A decorator to warn the user that the function has been deprecated and will be removed in future.
+    Parameters
+    ----------
+    deprecated_version : str
+        the version since which the function has been deprecated
+    suggested_func : str or list of strings, optional
+        the function to be used in replacement of the deprecated function
+    removed_version : str, optional
+        the future version from which the function will be removed
+    docstring_prefix : str
+        prefix string to be inserted at the beginning of every new line in the docstring
+    '''
+
+    def deprecated_decorator(func):
+        @wraps(func)
+        def func_wrapper(*args, **kwargs):
+            if not deprecated_func_warned[func]:
+                lines = extract_stack_compact()
+                if len(lines) > 7:
+                    logg.warn("IMPORT: Deprecated function '{}' invoked at:".format(func.__name__), logger)
+                    for x in lines[-7:-5]:
+                        logg.warn(x, logger)
+                    logg.warn("  It has been deprecated since version {}.".format(deprecated_version), logger)
+                else:
+                    logg.warn("IMPORT: Function {} has been deprecated since version {}.".format(func.__name__, deprecated_version), logger)
+                if removed_version:
+                    logg.warn("  It will be removed in version {}.".format(removed_version), logger)
+                if suggested_func:
+                    if isinstance(suggested_func, str):
+                        logg.warn("  Use function '{}' instead.".format(suggested_func), logger)
+                    else:
+                        logg.warn("  Use a function in {} instead.".format(suggested_func), logger)
+                deprecated_func_warned[func] = True
+            return func(*args, **kwargs)
+
+        deprecated_func_warned[func] = False # register the function
+
+        the_doc = func_wrapper.__doc__
+
+        msg = "{}.. deprecated:: {}\n".format(docstring_prefix, deprecated_version)
+        if not the_doc or len(the_doc) == 0:
+            the_doc = msg
+        else:
+            if the_doc[-1] != '\n':
+                the_doc += '\n'
+            the_doc += '\n'+msg
+
+        if removed_version:
+            the_doc += "{}   It will be removed in version {}.\n".format(docstring_prefix, removed_version)
+
+        if suggested_func:
+            if isinstance(suggested_func, str):
+                msg = ':func:`{}`'.format(suggested_func)
+            else:
+                msg = ' or '.join([':func:`{}`'.format(x) for x in suggested_func])
+            the_doc += "{}   Use {} instead.\n".format(docstring_prefix, msg)
+
+        func_wrapper.__doc__ = the_doc
+        return func_wrapper
+
+    return deprecated_decorator
+
+
+# map: deprecated function -> warned
+deprecated_func_warned = {}

mb/utils/extra.py

@@ -0,0 +1,46 @@
+##Extra functions - batch creation, timer wrapper, etc.
+import time
+from .logging import logg
+
+__all__ = ['timer', 'batch_generator', 'batch_create']
+
+def timer(func,logger=None):
+    """
+    Decorator to time a function
+    Input:
+        func: function to be timed
+    """
+    def wrapper(*args,**kwargs):
+        before = time.time()
+        a = func(*args,**kwargs)
+        logg.info('function time : {} seconds'.format(time.time() - before), logger)
+        return a
+    return wrapper
+
+def batch_generator(iterable, batch_size):
+    """
+    Generator to create batches of a given size from an iterable
+    Input:
+        iterable: iterable to be batched
+        batch_size: size of the batches
+    Output:
+        batch: batch of the given size
+    """
+    l = len(iterable)
+    for ndx in range(0, l, batch_size):
+        yield iterable[ndx:min(ndx + batch_size, l)]
+
+def batch_create(l, n,logger=None):
+    """
+    Create batches in a list of a size from a given list
+    Input:
+        l: list to be batched
+        n: size of the batches
+    Output:
+        batch(list): batch of the given size
+    """
+    batch_create_list=[]
+    for i in range(0, len(l), n):
+        batch_create_list.append(l[i:i+n])
+    logg.info("batches created : {}".format(len(batch_create_list)), logger)
+    return batch_create_list

mb/utils/logging.py

@@ -0,0 +1,108 @@
+from logging import *
+import os
+import logging.handlers
+from colorama import Fore, Style
+from colorama import init as _colorama_init
+from .terminal import stty_size
+_colorama_init()
+
+__all__ = ['make_logger','logger', 'logg']
+
+
+class LoggerWrapper:
+    """
+    A wrapper that allows calling log methods without checking if logger is None.
+    
+    Usage:
+        from mb_utils.logging import logg
+        
+        # With explicit logger:
+        logg.info('hello', logger)  # If logger is None, does nothing. If logger exists, logs.
+        
+        # With default logger (set via set_default):
+        logg.set_default(make_logger('myapp'))
+        logg.info('hello')  # Uses default logger
+        
+        # Explicit None overrides default (does nothing):
+        logg.info('hello', None)
+    """
+    
+    def __init__(self):
+        self._default_logger = None
+    
+    def set_default(self, logger):
+        """Set a default logger to use when none is provided."""
+        self._default_logger = logger
+    
+    def _log(self, level, msg, logger=..., *args, **kwargs):
+        if logger is ...:
+            logger = self._default_logger
+        if logger is not None:
+            getattr(logger, level)(msg, *args, **kwargs)
+    
+    def debug(self, msg, logger=..., *args, **kwargs):
+        self._log('debug', msg, logger, *args, **kwargs)
+    
+    def info(self, msg, logger=..., *args, **kwargs):
+        self._log('info', msg, logger, *args, **kwargs)
+    
+    def warning(self, msg, logger=..., *args, **kwargs):
+        self._log('warning', msg, logger, *args, **kwargs)
+    
+    def error(self, msg, logger=..., *args, **kwargs):
+        self._log('error', msg, logger, *args, **kwargs)
+    
+    def critical(self, msg, logger=..., *args, **kwargs):
+        self._log('critical', msg, logger, *args, **kwargs)
+    
+    def exception(self, msg, logger=..., *args, **kwargs):
+        self._log('exception', msg, logger, *args, **kwargs)
+
+
+logg = LoggerWrapper()
+
+def make_logger(name):
+    """
+    logger package for user
+    Input:
+        name: name of the logger
+    Output:
+        logger object
+    """
+    logger = getLogger(name)
+    if logger is None:
+        logger.addHandler(NullHandler())
+    logger.setLevel(1) #getting all logs
+    #basicConfig(filename='logger.log',filemode='w',level=INFO)
+
+    # determine some max string lengths
+    column_length = stty_size()[1]-13
+    log_lvl_length = min(max(int(column_length*0.03), 1), 8)
+    s1 = '{}.{}s '.format(log_lvl_length, log_lvl_length)
+    column_length -= log_lvl_length
+    s5 = '-{}.{}s'.format(column_length, column_length)
+    
+    os.mkdir('logs') if not os.path.exists('logs') else None
+    should_roll_over = os.path.isfile('logs/logger.log')
+    file_handler = logging.handlers.RotatingFileHandler('logs/logger.log',mode='w' ,maxBytes=1000000, backupCount=3)
+    if should_roll_over:  # log already exists, roll over!
+        file_handler.doRollover()
+    file_handler.setLevel(DEBUG)
+    file_formatter = Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    file_handler.setFormatter(file_formatter)
+    
+    std_handler = StreamHandler()
+    std_handler.setLevel(DEBUG)
+    fmt_str = Fore.CYAN+'%(asctime)s '+Fore.LIGHTGREEN_EX+'%(levelname)'+s1+\
+            Fore.LIGHTWHITE_EX+'%(message)'+s5+Fore.RESET
+    formatter = Formatter(fmt_str)
+    formatter.default_time_format = "%a %H:%M:%S" 
+    std_handler.setFormatter(formatter)
+    
+    logger.addHandler(file_handler)
+    logger.addHandler(std_handler)
+
+    return logger
+
+
+logger = make_logger('mb_utils')

mb/utils/path_checker.py

@@ -0,0 +1,35 @@
+##Function to check paths
+
+import os
+import pandas as pd
+from concurrent.futures import ThreadPoolExecutor
+from tqdm.auto import tqdm
+from .logging import logg
+
+__all__ = ['check_path']
+
+def check_path(path,logger=None,path_column=None,max_threads=16) -> bool:
+    """
+    Function to check the path.
+    Tqdm progress bar is used to show the progress and it updates every 1 second.
+    Input:
+        path (list): path to be checked (list or pandas.DataFrame).
+        path_column: column name if path is pandas.DataFrame (str, optional)
+        logger: logger object (optional)
+        max_threads: maximum number of threads to use (int, optional, default=16)
+    Output:
+        results: list of bools indicating if each path exists.
+    """
+    if type(path) != list:
+        if type(path) != pd.DataFrame or type(path) != pd.core.series.Series:
+            raise TypeError("Input should be a list or pandas.DataFrame or pandas.Series")
+        path = path[path_column].tolist()
+    
+    def check_single_path(p):
+        return os.path.exists(p)
+
+    with ThreadPoolExecutor(max_workers=max_threads) as executor:
+        results = list(tqdm(executor.map(check_single_path, path), total=len(path), mininterval=1))
+        
+    logg.info('Path not found: {}'.format(results.count(False)), logger)
+    return results

mb/utils/pip_update.py

@@ -0,0 +1,19 @@
+import subprocess
+from typing import Optional
+from .logging import logg
+
+__all__ = ['update_package']
+
+def update_package(package_name, logger: Optional[str]=None) -> None:
+    # Check if package is up-to-date
+    result = subprocess.run(['pip', 'check', package_name], capture_output=True, text=True)
+    if 'up-to-date' in result.stdout:        
+        logg.info(f"{package_name} is already up-to-date.",logger)
+        return
+    
+    # Install latest version of package
+    result = subprocess.run(['pip', 'install', '--upgrade', package_name], capture_output=True, text=True)
+    if result.returncode == 0:
+        logg.info(f"{package_name} has been updated.",logger)
+    else:
+        logg.info(f"Error updating {package_name}: {result.stderr}")

mb/utils/profiler.py

@@ -0,0 +1,63 @@
+import cProfile
+import subprocess
+import os
+import functools
+import sys
+from .logging import logg
+
+__all__ = ['run_with_snakeviz','line_profile']
+
+def run_with_snakeviz(func, *args, save_only=False,file_path=None,logger=None, **kwargs):
+    """
+    Profiles a function, saves to 'profiler.prof' in the current directory,
+    and optionally opens SnakeViz.
+
+    Args:
+        func: The function to profile.
+        *args, **kwargs: Arguments to pass to the function.
+        save_only (bool): If True, only saves the file and does not launch SnakeViz.
+        file_path (str): Path to save the profile file. If None, saves to 'profiler.prof' in the current directory.
+    
+    Examples:
+    @run_with_snakeviz
+    def my_function():
+        pass
+    """
+    if file_path is None:
+        file_path = os.path.join(os.getcwd(), "profiler.prof")
+
+    profiler = cProfile.Profile()
+    profiler.enable()
+    try:
+        result = func(*args, **kwargs)
+    finally:
+        profiler.disable()
+        profiler.dump_stats(file_path)
+        logg.info(f"[Profiler] Saved to {file_path}", logger)
+
+        if not save_only:
+            logg.info("[Profiler] Launching SnakeViz", logger)
+            subprocess.run(["snakeviz", file_path])
+
+    return result
+
+def line_profile(func, logger=None):
+    """
+    A decorator that profiles the function line-by-line using line_profiler.
+    Compatible with IPython/Jupyter. 
+
+    Examples:
+    @line_profile
+    def my_function():
+        pass
+    """
+    from line_profiler import LineProfiler
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        profiler = LineProfiler()
+        profiler.add_function(func)
+        result = profiler(func)(*args, **kwargs)
+        profiler.print_stats(stream=sys.stdout)
+        logg.info("[Profiler] Line profile complete", logger)
+        return result
+    return wrapper

mb/utils/retry_decorator.py

@@ -0,0 +1,41 @@
+##function to retry a function if it fails
+# Path: mb_utils/src/retry_decorator.py
+
+from .logging import logg
+
+__all__ = ['retry']
+
+def retry(times, exceptions,logger=None):
+    """
+    Retry Decorator
+    Retries the wrapped function/method `times` times if the exceptions listed
+    in ``exceptions`` are thrown
+    Input:
+        times (int):  The number of times to repeat the wrapped function/method
+        exceptions (tuple of exceptiosn):  The exceptions to catch
+    Output:
+        The wrapped function/method
+    """
+    def decorator(func):
+        def newfn(*args, **kwargs):
+            attempt = 0
+            while attempt < times:
+                try:
+                    return func(*args, **kwargs)
+                except exceptions:
+                    logg.error(
+                        'Exception thrown when attempting to run %s, attempt '
+                        '%d of %d' % (func, attempt, times),logger)
+                    attempt += 1
+            return func(*args, **kwargs)
+        return newfn
+    return decorator
+
+##example of how to use the retry decorator
+# @retry(times=3, exceptions=(ValueError, TypeError))
+# def foo1():
+#     print('Some code here ....')
+#     print('Oh no, we have exception')
+#     raise ValueError('Some error')
+
+# foo1()

mb/utils/s3.py

@@ -0,0 +1,138 @@
+##file for s3 download and upload
+
+import boto3
+import os
+from functools import partial
+from concurrent.futures import ThreadPoolExecutor
+from tqdm.auto import tqdm
+from .logging import logg
+
+__all__ = ['download_file', 'upload_file', 'upload_dir', 'download_dir','list_objects']
+
+def download_file(bucket_name, file_name, local_file_name,logger=None):
+    """
+    download file from s3
+    Input:
+        bucket_name: name of the bucket
+        file_name: name of the file in s3
+        local_file_name: name of the file in local
+    Output:
+        None
+    """
+    s3 = boto3.resource('s3')
+    try:
+        s3.Bucket(bucket_name).download_file(file_name, local_file_name)
+    except Exception as e:
+        logg.error('Error in downloading file from s3',logger)
+        logg.error(e,logger)
+        raise e
+    logg.info('Downloaded file from s3',logger)
+
+def upload_file(bucket_name, file_name, local_file_name,logger=None):
+    """
+    upload file to s3
+    Input:
+        bucket_name: name of the bucket
+        file_name: name of the file in s3
+        local_file_name: name of the file in local
+    Output:
+        None
+    """
+    s3 = boto3.resource('s3')
+    try:
+        s3.Bucket(bucket_name).upload_file(local_file_name, file_name)
+    except Exception as e:
+        logg.error('Error in uploading file to s3',logger)
+        logg.error(e)
+        raise e
+    logg.info('File uploaded to s3',logger)
+
+def upload_dir(bucket_name, dir_name, local_dir_name,logger=None):
+    """
+    upload directory to s3
+    Input:
+        bucket_name: name of the bucket
+        dir_name: name of the directory in s3
+        local_dir_name: name of the directory in local
+    Output:
+        results (List) : list of uploaded files location. False if error in uploading individual file
+    """
+    s3 = boto3.resource('s3')
+    
+    file_list = []
+    def _get_all_files(local_dir_name):
+        return [os.path.join(dp, f) for dp, _, filenames in os.walk(local_dir_name) for f in filenames]
+    file_list = _get_all_files(local_dir_name)
+    
+    def _upload_file(bucket,dir_name,file):
+        try:
+            file_name = file.split('/')[-1]
+            file_loc = os.path.join(dir_name, file_name)
+            s3.Bucket(bucket).upload_file(file, file_loc)
+            return file_loc
+        except Exception as e:
+            return False
+
+    upload_func = partial(_upload_file, bucket=bucket_name, dir_name=dir_name)
+
+    results = []
+    with ThreadPoolExecutor(max_workers=8) as executor:
+        results = list(tqdm(executor.map(upload_func, file_list), total=len(file_list), mininterval=1))
+
+    if results.count(False) > 0:
+        logg.error('Error in uploading files : {i}'.format(i=results.count(False)),logger)
+    else:
+        logg.info('All files uploaded to s3 : {i}'.format(i=len(results)),logger)
+    return results
+
+def download_dir(bucket_name, dir_name, local_dir_name=None,max_workers=8):
+    """
+    download directory from s3
+    Input:
+        bucket_name: name of the bucket
+        dir_name: name of the directory in s3
+        local_dir_name: name of the directory in local
+        max_workers: number of parallel workers to use
+    Output:
+        results (List) : list of downloaded files location
+    """
+    s3 = boto3.resource('s3')
+    bucket = s3.Bucket(bucket_name)
+
+    def _download_file(bucket, local_dir_name):
+        for obj in bucket.objects.filter(Prefix=local_dir_name):
+            target = obj.key if local_dir_name is None \
+                else os.path.join(local_dir_name, os.path.relpath(obj.key, dir_name))
+            if not os.path.exists(os.path.dirname(target)):
+                os.makedirs(os.path.dirname(target))
+            if obj.key[-1] == '/':
+                continue
+            bucket.download_file(obj.key, target)
+            return target
+
+    download_func = partial(_download_file, bucket=bucket, local_dir_name=local_dir_name)
+    results = []
+    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        results = list(tqdm(executor.map(download_func, [local_dir_name]), total=1, mininterval=1))
+    return results  
+
+
+def list_objects(bucket_name,logger=None,**kwargs):
+    """
+    List all the objects in the bucket
+    Args:
+        bucket_name : str
+            Name of the bucket
+    Returns:
+        List of objects in the bucket
+    """
+    s3 = boto3.resource('s3')
+    objects = s3.list_objects_v2(Bucket=bucket_name)
+
+    if 'Contents' in objects:
+        for obj in objects['Contents']:
+            logg.info(obj['Key'],logger)
+        return objects['Contents']
+    else:
+        logg.info(f"No objects found in {bucket_name}",logger)
+        return []

mb/utils/terminal.py

@@ -0,0 +1,24 @@
+##Functions related to terminal size
+#Functions taken from mtbase : https://github.com/inteplus/mtbase/tree/master/mt/base 
+import shutil
+
+
+__all__ = ['stty_imgres', 'stty_size']
+
+
+def stty_size() -> list:
+    '''Gets the terminal size.
+    Returns the Linux-compatible console's number of rows and number of characters per
+    row. If the information does not exist, returns (72, 128).'''
+
+    res = shutil.get_terminal_size(fallback=(128, 72))
+    return [res[1], res[0]]
+
+
+def stty_imgres() -> list:
+    '''Gets the terminal resolution.
+    Returns the Linux-compatible console's number of letters per row and the number of
+    rows. If the information does not exist, returns (128, 72).'''
+
+    res = shutil.get_terminal_size(fallback=(128, 72))
+    return [res[0], res[1]]

mb/utils/verify_image.py

@@ -0,0 +1,54 @@
+##Function to verify the image
+import PIL.Image as Image
+import os
+from concurrent.futures import ThreadPoolExecutor
+from functools import partial
+from tqdm.auto import tqdm
+from .logging import logg
+
+__all__ = ['verify_image']
+
+def verify_image(image_paths: list, image_type=None, image_shape=None,logger=None,max_workers=16) -> list:
+    """
+    Function to verify the image. Checks Path, Type and Size of the image if the later two are provided.
+    tqdm progress bar is used to show the progress and it updates every 1 second.
+    Input:
+        image_paths: list of paths to the images
+        image_type (str : optional): type of the image
+        image_shape (Tuple : optional): verify if image shape. (width, height) 
+    Output:
+        results (list : bool): lists of bools indicating if each image is valid. Also returns size_mismatch if image_shape is provided and not correct.
+    """
+    
+
+    def verify_single_image(image_path,image_type=None, image_shape=None):
+        if os.path.isfile(image_path):
+            im = Image.open(image_path)
+            if image_type and im.format != image_type.upper():
+                return 'image_type_mismatch'
+            elif not image_type and im.format not in ('JPEG', 'PNG', 'GIF', 'BMP', 'TIFF', 'JPG'):
+                return 'unknown_image_format'
+            if image_shape and im.size != image_shape:  # PIL uses (width, height)
+                    return 'image_shape_mismatch'
+            im.close()
+            return True
+        else:
+            return False
+                    
+    verify_func = partial(verify_single_image, image_type=image_type, image_shape=image_shape) ### partial function fixes the given arguments
+    
+    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        results = list(tqdm(executor.map(verify_func, image_paths), total=len(image_paths),mininterval=1))
+    if image_shape:
+        if logger:
+            logger.info('Image shape mismatch: {}'.format(results.count('image_shape_mismatch')))
+        else:
+            print('Image shape mismatch: {}'.format(results.count('image_shape_mismatch')))
+    if image_type:
+        if logger:
+            logger.info('Image type mismatch: {}'.format(results.count('image_type_mismatch')))
+        else:
+            print('Image type mismatch: {}'.format(results.count('image_type_mismatch')))
+    
+    logg.info('Image not found: {}'.format(results.count(False)),logger)
+    return results

mb/utils/version.py

@@ -0,0 +1,5 @@
+MAJOR_VERSION = 2
+MINOR_VERSION = 0
+PATCH_VERSION = 0
+version = '{}.{}.{}'.format(MAJOR_VERSION, MINOR_VERSION, PATCH_VERSION)
+__all__  = ['MAJOR_VERSION', 'MINOR_VERSION', 'PATCH_VERSION', 'version']

mb_utils-2.0.3.dist-info/METADATA

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: mb_utils
+Version: 2.0.3
+Summary: Extra mb python utilities
+Author: ['Malav Bateriwala']
+Requires-Python: >=3.8
+Dynamic: author
+Dynamic: requires-python
+Dynamic: summary

mb_utils-2.0.3.dist-info/RECORD

@@ -0,0 +1,16 @@
+mb/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mb/utils/deprecated.py,sha256=dpcS3xS7ka78jqhfPkWvcPzYCy5QxG6q-AOBQNRL9iQ,3398
+mb/utils/extra.py,sha256=MPBfOKA7g8f1eKlcrrveb8Riq-rLRxw6tbhQeDd8k1A,1320
+mb/utils/logging.py,sha256=sUBZb0kfjuGGnaNsspsyc7aPodeSIaWm2rGfJqEoRXs,3568
+mb/utils/path_checker.py,sha256=xy2SlA1PYIOFCdB7uhzTlwaHUwzR8NI-PxR-ao4IAR0,1318
+mb/utils/pip_update.py,sha256=WGz6w2uMEdyIrqFDE4Bpw9wHRI4ebDiLrO-HGF1L8MI,753
+mb/utils/profiler.py,sha256=YtSA5hgcaJzmaNEUKnL1ppUjRKrTtayuEWIvFbtUJZA,1860
+mb/utils/retry_decorator.py,sha256=LoRnS3wElwmWxSj3Mvo9jIZvhj6fZgXmmHB77D_Fw8A,1282
+mb/utils/s3.py,sha256=VdraDTBv4B9lkKq2jauVmneV6RO_rM71aeyQX6jsuQs,4652
+mb/utils/terminal.py,sha256=_1l8K9CwAFYx4UgfkwOWfgeZ2bZu4s-71gnyxWJc2xA,777
+mb/utils/verify_image.py,sha256=p9OEiItCabinIqiQAc9xXKWw5K5XCbOcD68Io6PnPYY,2448
+mb/utils/version.py,sha256=-04OdYXfRiKT1yPXdBkqIuzdWT9q41bUBvrUwRsTmDQ,206
+mb_utils-2.0.3.dist-info/METADATA,sha256=3SQKqd9ffEatsGhIfWb8ExTH6ZzJmis7VCNP9JH8cYk,197
+mb_utils-2.0.3.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+mb_utils-2.0.3.dist-info/top_level.txt,sha256=2T5lqIVZs7HUr0KqUMPEaPF59QXcr0ErDy6K-J88ycM,3
+mb_utils-2.0.3.dist-info/RECORD,,

mb_utils-2.0.3.dist-info/WHEEL

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

mb_utils-2.0.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+mb