datamint 1.4.1__py3-none-any.whl → 1.5.0__py3-none-any.whl

datamint/client_cmd_tools/datamint_config.py

@@ -1,45 +1,82 @@
 import argparse
 import logging
+import os
+import platform
 from datamint import configs
 from datamint.utils.logging_utils import load_cmdline_logging_config
-
-# Create two loggings: one for the user and one for the developer
+from rich.prompt import Prompt, Confirm
+from rich.console import Console
+from rich.theme import Theme
+
+# Create a custom theme that works well on both dark and blue backgrounds
+def _create_console_theme() -> Theme:
+    """Create a custom Rich theme optimized for cross-platform terminals."""
+    # Detect if we're likely on PowerShell (Windows + PowerShell)
+    is_powershell = (
+        platform.system() == "Windows" and 
+        os.environ.get("PSModulePath") is not None
+    )
+    
+    if is_powershell:
+        # PowerShell blue background - use high contrast colors
+        return Theme({
+            "warning": "bright_yellow",
+            "error": "bright_red on white",
+            "success": "bright_green",
+            "key": "bright_cyan",
+            "accent": "bright_cyan",
+            "title": "bold"
+        })
+    else:
+        # Linux/Unix terminals - standard colors
+        return Theme({
+            "warning": "yellow",
+            "error": "red",
+            "success": "green",
+            "key": "cyan",
+            "accent": "bright_blue",
+            "title": "bold"
+        })
+
+# Create console with custom theme
+console = Console(theme=_create_console_theme())
 _LOGGER = logging.getLogger(__name__)
-_USER_LOGGER = logging.getLogger('user_logger')
 
 
 def configure_default_url():
     """Configure the default API URL interactively."""
-    _USER_LOGGER.info("Current default URL: %s", configs.get_value(configs.APIURL_KEY, 'Not set'))
-    url = input("Enter the default API URL (leave empty to abort): ").strip()
+    current_url = configs.get_value(configs.APIURL_KEY, 'Not set')
+    console.print(f"Current default URL: [key]{current_url}[/key]")
+    url = Prompt.ask("Enter the default API URL (leave empty to abort)", console=console).strip()
     if url == '':
         return
 
     # Basic URL validation
     if not (url.startswith('http://') or url.startswith('https://')):
-        _USER_LOGGER.warning("URL should start with http:// or https://")
+        console.print("[warning]⚠️  URL should start with http:// or https://[/warning]")
         return
 
     configs.set_value(configs.APIURL_KEY, url)
-    _USER_LOGGER.info("Default API URL set successfully.")
+    console.print("[success]✅ Default API URL set successfully.[/success]")
 
 
 def ask_api_key(ask_to_save: bool) -> str | None:
     """Ask user for API key with improved guidance."""
-    _USER_LOGGER.info("💡 Get your API key from your Datamint administrator or the web app (https://app.datamint.io/team)")
+    console.print("[info]💡 Get your API key from your Datamint administrator or the web app (https://app.datamint.io/team)[/info]")
 
-    api_key = input('API key (leave empty to abort): ').strip()
+    api_key = Prompt.ask('API key (leave empty to abort)', console=console).strip()
     if api_key == '':
         return None
 
     if ask_to_save:
-        ans = input("Save the API key so it automatically loads next time? (y/n): ")
+        ans = Confirm.ask("Save the API key so it automatically loads next time? (y/n): ",
+                          default=True, console=console)
         try:
-            if ans.lower() == 'y':
+            if ans:
                 configs.set_value(configs.APIKEY_KEY, api_key)
-                _USER_LOGGER.info("✅ API key saved.")
+                console.print("[success]✅ API key saved.[/success]")
         except Exception as e:
-            _USER_LOGGER.error("❌ Error saving API key.")
+            console.print("[error]❌ Error saving API key.[/error]")
             _LOGGER.exception(e)
     return api_key
 
@@ -48,85 +85,91 @@ def show_all_configurations():
     """Display all current configurations in a user-friendly format."""
     config = configs.read_config()
     if config is not None and len(config) > 0:
-        _USER_LOGGER.info("📋 Current configurations:")
+        console.print("[title]📋 Current configurations:[/title]")
         for key, value in config.items():
             # Mask API key for security
             if key == configs.APIKEY_KEY and value:
                 masked_value = f"{value[:3]}...{value[-3:]}" if len(value) > 6 else value
-                _USER_LOGGER.info(f"  {key}: {masked_value}")
+                console.print(f"  [key]{key}[/key]: [dim]{masked_value}[/dim]")
             else:
-                _USER_LOGGER.info(f"  {key}: {value}")
+                console.print(f"  [key]{key}[/key]: {value}")
     else:
-        _USER_LOGGER.info("No configurations found.")
+        console.print("[dim]No configurations found.[/dim]")
 
 
 def clear_all_configurations():
     """Clear all configurations with confirmation."""
-    yesno = input('Are you sure you want to clear all configurations? (y/n): ')
-    if yesno.lower() == 'y':
+    yesno = Confirm.ask('Are you sure you want to clear all configurations?',
+                        default=True, console=console)
+    if yesno:
         configs.clear_all_configurations()
-        _USER_LOGGER.info("All configurations cleared.")
+        console.print("[success]✅ All configurations cleared.[/success]")
 
 
 def configure_api_key():
+    """Configure API key interactively."""
     api_key = ask_api_key(ask_to_save=False)
     if api_key is None:
         return
     configs.set_value(configs.APIKEY_KEY, api_key)
-    _USER_LOGGER.info("✅ API key saved.")
+    console.print("[success]✅ API key saved.[/success]")
 
 
 def test_connection():
     """Test the API connection with current settings."""
     try:
         from datamint import APIHandler
-        _USER_LOGGER.info("🔄 Testing connection...")
+        console.print("[accent]🔄 Testing connection...[/accent]")
         api = APIHandler()
         # Simple test - try to get projects
         projects = api.get_projects()
-        _USER_LOGGER.info(f"✅ Connection successful! Found {len(projects)} projects.")
+        console.print(f"[success]✅ Connection successful! Found {len(projects)} projects.[/success]")
     except ImportError:
-        _USER_LOGGER.error("❌ Full API not available. Install with: pip install datamint-python-api[full]")
+        console.print("[error]❌ Full API not available. Install with: pip install datamint-python-api[full][/error]")
     except Exception as e:
-        _USER_LOGGER.error(f"❌ Connection failed: {e}")
-        _USER_LOGGER.info("💡 Check your API key and URL settings")
+        console.print(f"[error]❌ Connection failed: {e}[/error]")
 
 
 def interactive_mode():
-    _USER_LOGGER.info("🔧 Datamint Configuration Tool")
-
-    if len(configs.read_config()) == 0:
-        _USER_LOGGER.info("👋 Welcome! Let's set up your API key first.")
-        configure_api_key()
-
-    while True:
-        _USER_LOGGER.info("\n📋 Select the action you want to perform:")
-        _USER_LOGGER.info(" (1) Configure the API key")
-        _USER_LOGGER.info(" (2) Configure the default URL")
-        _USER_LOGGER.info(" (3) Show all configuration settings")
-        _USER_LOGGER.info(" (4) Clear all configuration settings")
-        _USER_LOGGER.info(" (5) Test connection")
-        _USER_LOGGER.info(" (q) Exit")
-        choice = input("Enter your choice: ").lower().strip()
-
-        if choice == '1':
+    """Run the interactive configuration mode."""
+    console.print("[title]🔧 Datamint Configuration Tool[/title]")
+
+    try:
+        if len(configs.read_config()) == 0:
+            console.print("[warning]👋 Welcome! Let's set up your API key first.[/warning]")
             configure_api_key()
-        elif choice == '2':
-            configure_default_url()
-        elif choice == '3':
-            show_all_configurations()
-        elif choice == '4':
-            clear_all_configurations()
-        elif choice == '5':
-            test_connection()
-        elif choice in ('q', 'exit', 'quit'):
-            _USER_LOGGER.info("👋 Goodbye!")
-            break
-        else:
-            _USER_LOGGER.info("❌ Invalid choice. Please enter a number between 1 and 5 or 'q' to quit.")
 
+        while True:
+            console.print("\n[title]📋 Select the action you want to perform:[/title]")
+            console.print(" [accent](1)[/accent] Configure the API key")
+            console.print(" [accent](2)[/accent] Configure the default URL")
+            console.print(" [accent](3)[/accent] Show all configuration settings")
+            console.print(" [accent](4)[/accent] Clear all configuration settings")
+            console.print(" [accent](5)[/accent] Test connection")
+            console.print(" [accent](q)[/accent] Exit")
+            choice = Prompt.ask("Enter your choice", console=console).lower().strip()
+
+            if choice == '1':
+                configure_api_key()
+            elif choice == '2':
+                configure_default_url()
+            elif choice == '3':
+                show_all_configurations()
+            elif choice == '4':
+                clear_all_configurations()
+            elif choice == '5':
+                test_connection()
+            elif choice in ('q', 'exit', 'quit'):
+                break
+            else:
+                console.print("[error]❌ Invalid choice. Please enter a number between 1 and 5 or 'q' to quit.[/error]")
+    except KeyboardInterrupt:
+        console.print('')
+
+    console.print("[success]👋 Goodbye![/success]")
 
 def main():
+    """Main entry point for the configuration tool."""
     load_cmdline_logging_config()
     parser = argparse.ArgumentParser(
         description='🔧 Datamint API Configuration Tool',
@@ -148,15 +191,15 @@ More Documentation: https://sonanceai.github.io/datamint-python-api/command_line
 
     if args.api_key is not None:
         configs.set_value(configs.APIKEY_KEY, args.api_key)
-        _USER_LOGGER.info("✅ API key saved.")
+        console.print("[success]✅ API key saved.[/success]")
 
     if args.default_url is not None:
         # Basic URL validation
         if not (args.default_url.startswith('http://') or args.default_url.startswith('https://')):
-            _USER_LOGGER.error("❌ URL must start with http:// or https://")
+            console.print("[error]❌ URL must start with http:// or https://[/error]")
             return
         configs.set_value(configs.APIURL_KEY, args.default_url)
-        _USER_LOGGER.info("✅ Default URL saved.")
+        console.print("[success]✅ Default URL saved.[/success]")
 
     no_arguments_provided = args.api_key is None and args.default_url is None
 

datamint/client_cmd_tools/datamint_upload.py

@@ -7,13 +7,14 @@ from pathlib import Path
 import sys
 from datamint.utils.dicom_utils import is_dicom
 import fnmatch
-from typing import Sequence, Generator, Optional, Any
+from typing import Generator, Optional, Any
 from collections import defaultdict
 from datamint import __version__ as datamint_version
 from datamint import configs
 from datamint.client_cmd_tools.datamint_config import ask_api_key
 from datamint.utils.logging_utils import load_cmdline_logging_config
 import yaml
+from collections.abc import Iterable
 
 # Create two loggings: one for the user and one for the developer
 _LOGGER = logging.getLogger(__name__)
@@ -86,9 +87,9 @@ def _is_system_file(path: Path) -> bool:
     return any(fnmatch.fnmatch(path.name, pattern) for pattern in ignored_patterns)
 
 
-def walk_to_depth(path: str,
+def walk_to_depth(path: str | Path,
                   depth: int,
-                  exclude_pattern: str = None) -> Generator[Path, None, None]:
+                  exclude_pattern: str | None = None) -> Generator[Path, None, None]:
     path = Path(path)
     for child in path.iterdir():
         if _is_system_file(child):
@@ -104,7 +105,7 @@ def walk_to_depth(path: str,
             yield child
 
 
-def filter_files(files_path: Sequence[Path],
+def filter_files(files_path: Iterable[Path],
                  include_extensions,
                  exclude_extensions) -> list[Path]:
     def fix_extension(ext: str) -> str:
@@ -112,7 +113,7 @@ def filter_files(files_path: Sequence[Path],
             return ext
         return '.' + ext
 
-    def normalize_extensions(exts_list: Sequence[str]) -> list[str]:
+    def normalize_extensions(exts_list: Iterable[str]) -> list[str]:
         # explodes the extensions if they are separated by commas
         exts_list = [ext.split(',') for ext in exts_list]
         exts_list = [item for sublist in exts_list for item in sublist]
@@ -140,7 +141,7 @@ def filter_files(files_path: Sequence[Path],
     return files_path
 
 
-def handle_api_key() -> str:
+def handle_api_key() -> str | None:
     """
     Checks for API keys.
     If it does not exist, it asks the user to input it.
@@ -330,7 +331,7 @@ def _collect_metadata_files(files_path: list[str], auto_detect_json: bool) -> tu
     return metadata_files, filtered_files_path
 
 
-def _parse_args() -> tuple[Any, list, Optional[list[dict]], Optional[list[str]]]:
+def _parse_args() -> tuple[Any, list[str], Optional[list[dict]], Optional[list[str]]]:
     parser = argparse.ArgumentParser(
         description='DatamintAPI command line tool for uploading DICOM files and other resources')
 
@@ -391,11 +392,11 @@ def _parse_args() -> tuple[Any, list, Optional[list[dict]], Optional[list[str]]]
 
     # Handle path argument priority: positional takes precedence over --path flag
     if args.path is not None and args.path_flag is not None:
-        _USER_LOGGER.warning("Both positional path and --path flag provided. Using positional argument.")
+        _USER_LOGGER.warning("Both positional path and --path flag provided.")
+        raise ValueError("Both positional path and --path flag provided.")
+    elif args.path is not None and isinstance(args.path, (str, Path)):
         final_path = args.path
-    elif args.path is not None:
-        final_path = args.path
-    elif args.path_flag is not None:
+    elif args.path_flag is not None and isinstance(args.path_flag, (str, Path)):
         final_path = args.path_flag
     else:
         parser.error("Path argument is required. Provide it as a positional argument or use --path flag.")
@@ -424,6 +425,10 @@ def _parse_args() -> tuple[Any, list, Optional[list[dict]], Optional[list[str]]]
         else:
             try:
                 recursive_depth = 0 if args.recursive is None else args.recursive
+                if recursive_depth < 0:
+                    recursive_depth = MAX_RECURSION_LIMIT
+                else:
+                    recursive_depth = min(MAX_RECURSION_LIMIT, recursive_depth)
                 file_path = walk_to_depth(args.path, recursive_depth, args.exclude)
                 file_path = filter_files(file_path, args.include_extensions, args.exclude_extensions)
                 file_path = list(map(str, file_path))  # from Path to str
@@ -533,7 +538,7 @@ def print_input_summary(files_path: list[str],
 
 
 def print_results_summary(files_path: list[str],
-                          results: list[str | Exception]):
+                          results: list[str | Exception]) -> int:
     # Check for failed uploads
     failure_files = [f for f, r in zip(files_path, results) if isinstance(r, Exception)]
     _USER_LOGGER.info(f"\nUpload summary:")
@@ -541,12 +546,13 @@ def print_results_summary(files_path: list[str],
     _USER_LOGGER.info(f"\tSuccessful uploads: {len(files_path) - len(failure_files)}")
     _USER_LOGGER.info(f"\tFailed uploads: {len(failure_files)}")
     if len(failure_files) > 0:
-        _USER_LOGGER.warning(f"\tFailed files: {failure_files}")
+        _USER_LOGGER.warning(f"\tFailed files: {[os.path.basename(f) for f in failure_files]}")
         _USER_LOGGER.warning(f"\nFailures:")
         for f, r in zip(files_path, results):
             _LOGGER.debug(f"Failure: {f} - {r}")
             if isinstance(r, Exception):
                 _USER_LOGGER.warning(f"\t{os.path.basename(f)}: {r}")
+    return len(failure_files)
 
 
 def main():
@@ -556,7 +562,7 @@ def main():
         args, files_path, segfiles, metadata_files = _parse_args()
     except Exception as e:
         _USER_LOGGER.error(f'Error validating arguments. {e}')
-        return
+        sys.exit(1)
 
     print_input_summary(files_path,
                         args=args,
@@ -585,12 +591,14 @@ def main():
                                            segmentation_files=segfiles,
                                            transpose_segmentation=args.transpose_segmentation,
                                            assemble_dicoms=True,
-                                           metadata_files=metadata_files
+                                           metadata=metadata_files
                                            )
     _USER_LOGGER.info('Upload finished!')
     _LOGGER.debug(f"Number of results: {len(results)}")
 
-    print_results_summary(files_path, results)
+    num_failures = print_results_summary(files_path, results)
+    if num_failures > 0:
+        sys.exit(1)
 
 
 if __name__ == '__main__':

datamint/utils/dicom_utils.py

@@ -243,20 +243,20 @@ def assemble_dicoms(files_path: list[str | IO],
     
     for file_path in tqdm(files_path, desc="Reading DICOMs metadata", unit="file"):
         dicom = pydicom.dcmread(file_path,
-                                specific_tags=['FrameOfReferenceUID', 'InstanceNumber', 'Rows', 'Columns'])
-        fr_uid = dicom.get('FrameOfReferenceUID', None)
-        if fr_uid is None:
+                                specific_tags=['SeriesInstanceUID', 'InstanceNumber', 'Rows', 'Columns'])
+        series_uid = dicom.get('SeriesInstanceUID', None)
+        if series_uid is None:
             # generate a random uid
-            fr_uid = pydicom.uid.generate_uid()
+            series_uid = pydicom.uid.generate_uid()
         instance_number = dicom.get('InstanceNumber', 0)
         rows = dicom.get('Rows', None)
         columns = dicom.get('Columns', None)
-        dicoms_map[fr_uid].append((instance_number, file_path, rows, columns))
+        dicoms_map[series_uid].append((instance_number, file_path, rows, columns))
         if hasattr(file_path, "seek"):
             file_path.seek(0)
     
-    # Validate that all DICOMs with the same FrameOfReferenceUID have matching dimensions
-    for fr_uid, dicom_list in dicoms_map.items():
+    # Validate that all DICOMs with the same SeriesInstanceUID have matching dimensions
+    for series_uid, dicom_list in dicoms_map.items():
         if len(dicom_list) <= 1:
             continue
             
@@ -268,7 +268,7 @@ def assemble_dicoms(files_path: list[str | IO],
         for instance_number, file_path, rows, columns in dicom_list:
             if rows != first_rows or columns != first_columns:
                 msg = (
-                    f"Dimension mismatch in FrameOfReferenceUID {fr_uid}: "
+                    f"Dimension mismatch in SeriesInstanceUID {series_uid}: "
                     f"Expected {first_rows}x{first_columns}, got {rows}x{columns} "
                     f"for file {file_path} and {dicom_list[0][1]}"
                 )
@@ -360,11 +360,11 @@ def _generate_dicom_name(ds: pydicom.Dataset) -> str:
     #     components.append(os.path.basename(ds.filename))
     if hasattr(ds, 'SeriesDescription'):
         components.append(ds.SeriesDescription)
-    if hasattr(ds, 'SeriesNumber'):
+    if len(components) == 0 and hasattr(ds, 'SeriesNumber'):
         components.append(f"ser{ds.SeriesNumber}")
     if hasattr(ds, 'StudyDescription'):
         components.append(ds.StudyDescription)
-    if hasattr(ds, 'StudyID'):
+    elif hasattr(ds, 'StudyID'):
         components.append(ds.StudyID)
 
     # Join components and add extension
@@ -375,8 +375,8 @@ def _generate_dicom_name(ds: pydicom.Dataset) -> str:
         if len(description) > 0:
             return description
 
-    if hasattr(ds, 'FrameOfReferenceUID'):
-        return ds.FrameOfReferenceUID + ".dcm"
+    if hasattr(ds, 'SeriesInstanceUID'):
+        return ds.SeriesInstanceUID + ".dcm"
 
     # Fallback to generic name if no attributes found
     return ds.filename if hasattr(ds, 'filename') else f"merged_dicom_{uuid.uuid4()}.dcm"

{datamint-1.4.1.dist-info → datamint-1.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: datamint
-Version: 1.4.1
+Version: 1.5.0
 Summary: A library for interacting with the Datamint API, designed for efficient data management, processing and Deep Learning workflows.
 Requires-Python: >=3.10
 Classifier: Programming Language :: Python :: 3

{datamint-1.4.1.dist-info → datamint-1.5.0.dist-info}/RECORD

@@ -1,13 +1,13 @@
 datamint/__init__.py,sha256=7rKCCsaa4RBRTIfuHB708rai1xwDHLtkFNFJGKYG5D4,757
-datamint/apihandler/annotation_api_handler.py,sha256=uaxtkFCBfRdhXcNzZrqfoV_5FLe8w7MFE-4fVD1Wu8Y,40084
+datamint/apihandler/annotation_api_handler.py,sha256=NMS4SPcp1QAyee8TqLp2sw9htjGcdrEiW6_Qv4h0JlE,49905
 datamint/apihandler/api_handler.py,sha256=cdVSddrFCKlF_BJ81LO1aJ0OP49rssjpNEFzJ6Q7YyY,384
 datamint/apihandler/base_api_handler.py,sha256=XSxZEQEkbQpuixGDu_P9jbxUQht3Z3JgxaeiFKPkVDM,11690
 datamint/apihandler/dto/annotation_dto.py,sha256=otCIesoqGBlbSOw4ErqFsXp2HwJsPNUQlkynQh_7pHg,7110
 datamint/apihandler/exp_api_handler.py,sha256=hFUgUgBc5rL7odK7gTW3MnrvMY1pVfJUpUdzRNobMQE,6226
-datamint/apihandler/root_api_handler.py,sha256=-dy5IxDP3wJAr2ahhxKKswWfyKSzn6hHrPSYwKKW1pQ,44507
+datamint/apihandler/root_api_handler.py,sha256=OIGq6aHX64B94MmAikcFzF0rdekRH4l1S59x2Pa_DJA,51739
 datamint/client_cmd_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datamint/client_cmd_tools/datamint_config.py,sha256=NNWLBaHXYhY1fqherwg0u3bcu0r95ZJIMTH45X-bJ2Q,6279
-datamint/client_cmd_tools/datamint_upload.py,sha256=oDNt-91Naz8fQER2sk3I9x9G7C7xzQ0SjBjr0XNht1k,25900
+datamint/client_cmd_tools/datamint_config.py,sha256=md7dnWrbl10lPtXKbmD9yo6onLJsajeG8Vz0ZWH1v4M,8181
+datamint/client_cmd_tools/datamint_upload.py,sha256=yGwEsg5mrAH92UIMl1d5Vv5t0HWUAam4PW-SLJHbYE0,26380
 datamint/configs.py,sha256=Bdp6NydYwyCJ2dk19_gf_o3M2ZyQOmMHpLi8wEWNHUk,1426
 datamint/dataset/__init__.py,sha256=4PlUKSvVhdfQvvuq8jQXrkdqnot-iTTizM3aM1vgSwg,47
 datamint/dataset/base_dataset.py,sha256=EnnIeF3ZaBL2M8qEV39U0ogKptyvezBNoVOvrS12bZ8,38756
@@ -18,12 +18,12 @@ datamint/experiment/__init__.py,sha256=5qQOMzoG17DEd1YnTF-vS0qiM-DGdbNh42EUo91CR
 datamint/experiment/_patcher.py,sha256=ZgbezoevAYhJsbiJTvWPALGTcUiMT371xddcTllt3H4,23296
 datamint/experiment/experiment.py,sha256=aHK9dRFdQTi569xgUg1KqlCZLHZpDmSH3g3ndPIZvXw,44546
 datamint/logging.yaml,sha256=a5dsATpul7QHeUHB2TjABFjWaPXBMbO--dgn8GlRqwk,483
-datamint/utils/dicom_utils.py,sha256=HTuEjwXyTSMaTVGb9pFOO76q2KLTr2CxTDoCRElVHRA,26023
+datamint/utils/dicom_utils.py,sha256=n1CrYg1AgnlbgIktDfVXQ1Logh8lwCqYbjqHu5GElUE,26062
 datamint/utils/io_utils.py,sha256=ebP1atKkhKEf1mUU1LsVwDq0h_so7kVKkD_7hQYn_kM,6754
 datamint/utils/logging_utils.py,sha256=DvoA35ATYG3JTwfXEXYawDyKRfHeCrH0a9czfkmz8kM,1851
 datamint/utils/torchmetrics.py,sha256=lwU0nOtsSWfebyp7dvjlAggaqXtj5ohSEUXOg3L0hJE,2837
 datamint/utils/visualization.py,sha256=yaUVAOHar59VrGUjpAWv5eVvQSfztFG0eP9p5Vt3l-M,4470
-datamint-1.4.1.dist-info/METADATA,sha256=Av01QDy0f3zl0oud-ebW6vyjk0J0P33MGWMq8wg3nMs,4065
-datamint-1.4.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-datamint-1.4.1.dist-info/entry_points.txt,sha256=mn5H6jPjO-rY0W0CAZ6Z_KKWhMLvyVaSpoqk77jlTI4,145
-datamint-1.4.1.dist-info/RECORD,,
+datamint-1.5.0.dist-info/METADATA,sha256=_JkJij-WrsGHzHO3k39TAFKcX-0WQbvVwi-6POUgetE,4065
+datamint-1.5.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+datamint-1.5.0.dist-info/entry_points.txt,sha256=mn5H6jPjO-rY0W0CAZ6Z_KKWhMLvyVaSpoqk77jlTI4,145
+datamint-1.5.0.dist-info/RECORD,,