mb_utils 2.0.3__tar.gz

mb_utils-2.0.3/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,165 @@
+# MB Utils
+
+[![Python Version](https://img.shields.io/badge/python-3.8+-blue)](https://www.python.org/)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://github.com/bigmb/mb_utils/graphs/commit-activity)
+[![Downloads](https://static.pepy.tech/badge/mb_utils)](https://pepy.tech/project/mb_utils)
+
+A collection of utility functions and tools to simplify common Python development tasks. Part of the `mb` namespace — install as `mb_utils`, import as `mb.utils`.
+
+## Features
+
+- **Logging**: Easy-to-use logging with colored console output, rotating file handlers, and a safe `LoggerWrapper` (`logg`) that skips logging when no logger is provided
+- **File Operations**: Concurrent path checking and validation
+- **Decorators**: Deprecation warnings and retry logic
+- **Image Verification**: Validate image files (path, type, shape) with multithreading
+- **S3 Integration**: Simplified AWS S3 file and directory operations
+- **Profiling**: Function profiling with SnakeViz, line-by-line profiling
+- **Utilities**: Timer decorator, batch creation
+
+## Installation
+
+```bash
+pip install mb_utils
+# or
+uv pip install mb_utils
+```
+
+This installs under the `mb` namespace. Import everything via `mb.utils.*`.
+
+## Usage
+
+### Logging
+
+```python
+from mb.utils.logging import make_logger, logg
+
+# Create a logger with colored console + rotating file output
+logger = make_logger('myapp')
+logger.info("Direct logger usage")
+
+# Safe logging wrapper — no need for `if logger:` checks
+logg.info("This message logs", logger)      # logs normally
+logg.info("This is silenced", None)          # does nothing
+
+# Set a default logger so you don't have to pass it every time
+logg.set_default(logger)
+logg.info("Uses default logger")             # logs via default
+logg.warning("Also works")
+```
+
+### Path Checking
+
+```python
+from mb.utils.path_checker import check_path
+
+# Check a list of paths concurrently (returns list of bools)
+results = check_path(['/path/to/file1', '/path/to/file2'], max_threads=16)
+```
+
+### Retry Decorator
+
+```python
+from mb.utils.retry_decorator import retry
+
+@retry(times=3, exceptions=(ValueError, TypeError))
+def might_fail():
+    pass
+```
+
+### Deprecation Decorator
+
+```python
+from mb.utils.deprecated import deprecated_func
+
+@deprecated_func(deprecated_version="1.0", suggested_func="new_func", removed_version="3.0")
+def old_function():
+    pass
+```
+
+### S3 Operations
+
+```python
+from mb.utils.s3 import upload_file, download_file, upload_dir, download_dir, list_objects
+
+# Upload / download a single file
+upload_file('bucket-name', 'remote_key.txt', 'local_file.txt')
+download_file('bucket-name', 'remote_key.txt', 'local_file.txt')
+
+# Upload / download entire directories
+upload_dir('bucket-name', 's3/prefix', '/local/dir')
+download_dir('bucket-name', 's3/prefix', '/local/dir')
+
+# List objects
+list_objects('bucket-name')
+```
+
+### Timer & Batch Utilities
+
+```python
+from mb.utils.extra import timer, batch_generator, batch_create
+
+@timer
+def slow_function():
+    pass
+
+# Generator-based batching
+for batch in batch_generator(range(100), batch_size=10):
+    process(batch)
+
+# List-based batching
+batches = batch_create(my_list, n=10)
+```
+
+### Image Verification
+
+```python
+from mb.utils.verify_image import verify_image
+
+results = verify_image(
+    image_paths=['/path/img1.jpg', '/path/img2.png'],
+    image_type='JPEG',           # optional: check format
+    image_shape=(1920, 1080),    # optional: check dimensions (width, height)
+    max_workers=16
+)
+# Returns list: True, False, 'image_type_mismatch', 'image_shape_mismatch', 'unknown_image_format'
+```
+
+### Profiling
+
+```python
+from mb.utils.profiler import run_with_snakeviz, line_profile
+
+# Profile and visualize with SnakeViz
+@run_with_snakeviz
+def process_data(data):
+    pass
+
+# Save profile without opening SnakeViz
+run_with_snakeviz(my_func, arg1, arg2, save_only=True, file_path="output.prof")
+
+# Line-by-line profiling
+@line_profile
+def process_item(item):
+    result = item * 2
+    return result
+```
+
+## Available Modules
+
+| Module | Description | Import Path |
+|--------|-------------|-------------|
+| logging | Logger with colored output, file rotation, safe wrapper | `from mb.utils.logging import make_logger, logg` |
+| path_checker | Concurrent path validation | `from mb.utils.path_checker import check_path` |
+| deprecated | Function deprecation decorator | `from mb.utils.deprecated import deprecated_func` |
+| verify_image | Image verification (path, type, shape) | `from mb.utils.verify_image import verify_image` |
+| retry_decorator | Retry mechanism for functions | `from mb.utils.retry_decorator import retry` |
+| s3 | AWS S3 upload/download/list operations | `from mb.utils.s3 import *` |
+| extra | Timer decorator, batch utilities | `from mb.utils.extra import *` |
+| profiler | SnakeViz and line profiling | `from mb.utils.profiler import *` |
+| terminal | Terminal size utilities | `from mb.utils.terminal import stty_size` |
+| version | Package version info | `from mb.utils.version import version` |
+
+## Included Scripts
+
+- `verify_images_script`: Utility script for batch image verification

mb_utils-2.0.3/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-2.0.3/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-2.0.3/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-2.0.3/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-2.0.3/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-2.0.3/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-2.0.3/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-2.0.3/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-2.0.3/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-2.0.3/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-2.0.3/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/mb_utils.egg-info/PKG-INFO

@@ -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/mb_utils.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+README.md
+pyproject.toml
+setup.py
+mb/utils/__init__.py
+mb/utils/deprecated.py
+mb/utils/extra.py
+mb/utils/logging.py
+mb/utils/path_checker.py
+mb/utils/pip_update.py
+mb/utils/profiler.py
+mb/utils/retry_decorator.py
+mb/utils/s3.py
+mb/utils/terminal.py
+mb/utils/verify_image.py
+mb/utils/version.py
+mb_utils.egg-info/PKG-INFO
+mb_utils.egg-info/SOURCES.txt
+mb_utils.egg-info/dependency_links.txt
+mb_utils.egg-info/top_level.txt

mb_utils-2.0.3/mb_utils.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mb_utils-2.0.3/mb_utils.egg-info/top_level.txt

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

mb_utils-2.0.3/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"

mb_utils-2.0.3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mb_utils-2.0.3/setup.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from setuptools import find_namespace_packages, setup,find_packages
+import os
+
+VERSION_FILE = os.path.join(os.path.dirname(__file__), "VERSION.txt")
+print(VERSION_FILE)
+setup(
+    name="mb_utils",
+    description="Extra mb python utilities",
+    author=["Malav Bateriwala"],
+    packages=find_namespace_packages(include=["mb.*"]),
+    #packages=find_packages(),
+    scripts=[],
+    install_requires=[],
+    setup_requires=["setuptools-git-versioning<2"],
+    python_requires='>=3.8',
+    setuptools_git_versioning={
+        "enabled": True,
+        "version_file": VERSION_FILE,
+        "count_commits_from_version_file": True,
+        "template": "{tag}",
+        "dev_template": "{tag}.dev{ccount}+{branch}",
+        "dirty_template": "{tag}.post{ccount}",
+    },
+)