h5typer 0.1.0__py3-none-any.whl

h5typer/__init__.py

@@ -0,0 +1,49 @@
+"""
+h5typer: Automatic Type Mapping for Python Objects to HDF5
+
+A lightweight, robust package for saving and loading nested Python dictionaries
+to/from HDF5 files. Automatically handles type conversion for numpy arrays,
+pandas DataFrames/Series, and standard Python types.
+
+Features:
+- Save and load arbitrarily nested dictionaries
+- Automatic type conversion (numpy, pandas, strings, None, etc.)
+- Support for complex nested structures
+- Robust handling of various data types
+
+Basic Usage
+-----------
+>>> import h5typer
+>>>
+>>> # Save data
+>>> data = {'experiment': {'results': np.array([1, 2, 3])}}
+>>> h5typer.save_data('output.h5', data)
+>>>
+>>> # Load data
+>>> loaded_data = h5typer.load_data('output.h5')
+
+Object-Oriented Usage
+--------------------
+>>> from h5typer import H5Typer
+>>>
+>>> io_handler = H5Typer()
+>>> io_handler.save_data('output.h5', data)
+>>> loaded = io_handler.load_data('output.h5')
+"""
+
+__version__ = "0.1.0"
+__author__ = "HiC-SCA Project"
+__license__ = "MIT"
+
+from .io import (
+    H5Typer,
+    save_data,
+    load_data
+)
+
+__all__ = [
+    'H5Typer',
+    'save_data',
+    'load_data',
+    '__version__'
+]

h5typer/io.py

@@ -0,0 +1,397 @@
+"""
+h5typer I/O Module
+
+Handles saving and loading nested Python dictionaries to/from HDF5 files.
+Provides automatic type mapping between Python objects and HDF5 data types.
+Compatible with numpy arrays, pandas DataFrames/Series, and standard Python types.
+"""
+
+import numpy as np
+import pandas as pd
+import h5py
+import types
+from typing import Dict, Optional, Any
+from pathlib import Path
+
+
+class H5Typer:
+    """
+    Handles saving and loading of nested Python dictionaries to HDF5.
+
+    Provides automatic type conversion and mapping between Python objects
+    and HDF5 data types.
+    """
+
+    def __init__(self):
+        """Initialize the data I/O handler."""
+        self.version = 1.0
+
+    @staticmethod
+    def _convert_npstr_to_byte(str_array: np.ndarray) -> np.ndarray:
+        """Convert numpy string array to bytes for HDF5 compatibility."""
+        return np.char.encode(str_array, encoding='utf-8')
+
+    @staticmethod
+    def _convert_npbyte_to_str(byte_array: np.ndarray) -> np.ndarray:
+        """Convert numpy bytes array to string."""
+        return np.char.decode(byte_array, encoding='utf-8')
+
+    @staticmethod
+    def _convert_obj_to_dtypes(obj_array: np.ndarray) -> np.ndarray:
+        """Convert object dtype arrays to appropriate types."""
+        current_array = np.array(obj_array.tolist())
+        current_type = type(current_array.dtype)
+
+        type_handlers = {
+            str: lambda x: x.encode('utf-8'),
+            np.dtypes.StrDType: H5Typer._convert_npstr_to_byte,
+            types.NoneType: lambda x: h5py.Empty('f'),
+        }
+
+        if current_type == np.dtypes.ObjectDType:
+            return obj_array
+        elif current_type in type_handlers:
+            return type_handlers[current_type](current_array)
+        else:
+            return current_array
+
+    def _convert_to_h5_compatible(self, obj: Any) -> tuple:
+        """
+        Convert Python objects to HDF5-compatible format.
+
+        Returns
+        -------
+        tuple
+            (data_type, converted_obj)
+        """
+        data_type = ''
+        converted_obj = obj
+
+        if isinstance(obj, np.ndarray):
+            data_type = 'numpy'
+            dtype_type = type(obj.dtype)
+
+            if dtype_type == np.dtypes.StrDType:
+                converted_obj = self._convert_npstr_to_byte(obj)
+            elif dtype_type == np.dtypes.ObjectDType:
+                converted_obj = self._convert_obj_to_dtypes(obj)
+
+        elif isinstance(obj, dict):
+            data_type = 'dict'
+
+        elif isinstance(obj, pd.core.generic.NDFrame):
+            values = obj.values
+            index = obj.index.values
+            name = obj.index.name
+
+            if isinstance(obj, pd.DataFrame):
+                data_type = 'pandas dataframe'
+                columns = obj.columns.values
+                converted_obj = {'values': values, 'index': index, 'name': name, 'columns': columns}
+
+            elif isinstance(obj, pd.Series):
+                data_type = 'pandas series'
+                converted_obj = {'values': values, 'index': index, 'name': name}
+
+        elif isinstance(obj, types.NoneType):
+            data_type = 'None'
+            converted_obj = h5py.Empty('f')
+
+        elif isinstance(obj, str):
+            data_type = 'str'
+            converted_obj = obj.encode('utf-8')
+
+        elif isinstance(obj, (int, float, np.integer, np.floating)):
+            data_type = 'scalar'
+            converted_obj = np.array(obj)
+
+        elif isinstance(obj, list) or isinstance(obj, tuple):
+            obj = np.array(obj)
+            data_type = 'object'
+            dtype_type = type(obj.dtype)
+
+            if dtype_type == np.dtypes.StrDType:
+                converted_obj = self._convert_npstr_to_byte(obj)
+            elif dtype_type == np.dtypes.ObjectDType:
+                converted_obj = self._convert_obj_to_dtypes(obj)
+
+        else:
+            data_type = 'object'
+            converted_obj = np.array(obj)
+
+        return data_type, converted_obj
+
+    def _flatten_dict(self, input_dict: Dict, parent_address: str = "") -> tuple:
+        """
+        Flatten nested dictionary for HDF5 storage.
+
+        Parameters
+        ----------
+        input_dict : dict
+            Nested dictionary to flatten
+        parent_address : str
+            Current hierarchical path
+
+        Returns
+        -------
+        tuple
+            (meta_dict, output_dict) containing metadata and flattened data
+        """
+        output_dict = {}
+        meta_dict = {}
+
+        if len(input_dict) == 0:
+            meta_dict[parent_address] = 'dict'
+        else:
+            for key, value in input_dict.items():
+                data_type, current_value = self._convert_to_h5_compatible(value)
+                current_full_address = parent_address + '/' + str(key)
+
+                if isinstance(current_value, dict):
+                    temp_meta_dict, temp_output_dict = self._flatten_dict(
+                        current_value, current_full_address
+                    )
+                    output_dict.update(temp_output_dict)
+
+                    # For pandas types, store metadata at current level
+                    if 'pandas' in data_type:
+                        meta_dict[current_full_address] = data_type
+                    else:
+                        meta_dict.update(temp_meta_dict)
+                else:
+                    output_dict[current_full_address] = current_value
+                    meta_dict[current_full_address] = data_type
+
+        if parent_address == "":
+            meta_dict = {'/__meta__' + key: val for key, val in meta_dict.items()}
+
+        return meta_dict, output_dict
+
+    def save_data(self, filename: str, data_dict: Dict, update: bool = False) -> None:
+        """
+        Save nested dictionary to HDF5 file.
+
+        Parameters
+        ----------
+        filename : str
+            Path to HDF5 file
+        data_dict : dict
+            Nested dictionary containing data to save
+        update : bool, optional
+            If True, update existing file; if False, overwrite (default: False)
+        """
+        write_mode = 'a' if update else 'w'
+
+        meta_dict, flat_dict = self._flatten_dict(data_dict)
+
+        with h5py.File(filename, write_mode) as h5_file:
+            h5_file.update(flat_dict)
+            h5_file.update(meta_dict)
+            h5_file['__version__'] = self.version
+
+    def _auto_input_type_converter(self, obj: Any) -> Any:
+        """Convert HDF5 objects back to Python types."""
+        obj_type = type(obj)
+
+        if obj_type == np.ndarray:
+            dtype_type = type(obj.dtype)
+
+            if dtype_type == np.dtypes.BytesDType:
+                return self._convert_npbyte_to_str(obj)
+            elif dtype_type == np.dtypes.StrDType:
+                return obj
+
+        elif obj_type == bytes:
+            return obj.decode('utf-8')
+        elif isinstance(obj, h5py._hl.base.Empty):
+            return None
+
+        return obj
+
+    def _object_input_handler(self, data_type: str, var_name: str, data_dict: Dict) -> Any:
+        """Handle object type reconstruction."""
+        data_obj = self._auto_input_type_converter(data_dict[var_name])
+
+        if (data_type == 'object') and (type(data_obj) == np.ndarray):
+            return data_obj.tolist()
+        
+        elif (data_type in ('object', 'scalar')) and isinstance(data_obj, np.generic):
+            return data_obj.item()
+
+        return data_obj
+
+    def _str_input_handler(self, data_type: str, var_name: str, data_dict: Dict) -> str:
+        """Handle string type reconstruction."""
+        return data_dict[var_name].decode('utf-8')
+
+    def _dict_input_handler(self, data_type: str, var_name: str, data_dict: Dict) -> dict:
+        """Handle empty dict reconstruction."""
+        return {}
+
+    def _pandas_input_handler(self, data_type: str, var_name: str, data_dict: Dict):
+        """Handle pandas DataFrame and Series reconstruction."""
+        values = data_dict[var_name + '/values']
+        name = self._auto_input_type_converter(data_dict[var_name + '/name'])
+        index = self._auto_input_type_converter(data_dict[var_name + '/index'])
+
+        if len(index.shape) > 1:
+            index = pd.MultiIndex.from_arrays(index.T, names=name)
+        else:
+            index = pd.Index(index, name=name)
+
+        if data_type == 'pandas series':
+            return pd.Series(values, index=index)
+
+        elif data_type == 'pandas dataframe':
+            columns = self._auto_input_type_converter(data_dict[var_name + '/columns'])
+
+            if len(columns.shape) > 1:
+                columns = pd.MultiIndex.from_arrays(columns.T)
+
+            return pd.DataFrame(values, index=index, columns=columns)
+
+        else:
+            raise ValueError(f"Invalid pandas data type: {data_type}")
+
+    def _build_dict_recursive(self, name_list: list, value: Any, existing_dict: Optional[Dict] = None) -> Dict:
+        """Recursively rebuild nested dictionary structure."""
+        if existing_dict is None:
+            existing_dict = {}
+
+        current_key = name_list[0]
+
+        if len(name_list) > 1:
+            if current_key in existing_dict:
+                existing_dict[current_key].update(
+                    self._build_dict_recursive(name_list[1:], value, existing_dict[current_key])
+                )
+            else:
+                existing_dict[current_key] = self._build_dict_recursive(name_list[1:], value)
+        else:
+            existing_dict[current_key] = value
+
+        return existing_dict
+
+    def _reload_from_flat_dict(self, meta_dict: Dict, data_dict: Dict) -> Dict:
+        """Reconstruct nested dictionary from flattened HDF5 data."""
+        input_handlers = {
+            'numpy': self._object_input_handler,
+            'object': self._object_input_handler,
+            'dict': self._dict_input_handler,
+            'str': self._str_input_handler,
+            'None': self._object_input_handler,
+            'scalar': self._object_input_handler,
+            'pandas series': self._pandas_input_handler,
+            'pandas dataframe': self._pandas_input_handler,
+        }
+
+        processed_dict = {}
+
+        for var_full_name, data_type in meta_dict.items():
+            handler = input_handlers.get(data_type, self._object_input_handler)
+            var_name_list = var_full_name.split('/')
+
+            # Convert string keys that are integers back to int
+            for idx, var_name in enumerate(var_name_list):
+                if var_name.isdigit():
+                    var_name_list[idx] = int(var_name)
+
+            var_name = var_name_list[0]
+            value = handler(data_type, var_full_name, data_dict)
+
+            if len(var_name_list) > 1:
+                if var_name in processed_dict:
+                    current_value = self._build_dict_recursive(
+                        var_name_list[1:], value, processed_dict[var_name]
+                    )
+                else:
+                    current_value = self._build_dict_recursive(var_name_list[1:], value)
+            else:
+                current_value = value
+
+            processed_dict[var_name] = current_value
+
+        return processed_dict
+
+    def load_data(self, filename: str) -> Dict:
+        """
+        Load nested dictionary from HDF5 file.
+
+        Parameters
+        ----------
+        filename : str
+            Path to HDF5 file
+
+        Returns
+        -------
+        dict
+            Nested dictionary containing loaded data
+        """
+        with h5py.File(filename, 'r') as h5_file:
+            # Check version
+            if '__version__' in h5_file:
+                version = h5_file['__version__'][()]
+                if version != self.version:
+                    print(f"Warning: File version {version} differs from current version {self.version}")
+
+            # Collect metadata and data
+            meta_dict = {}
+            data_dict = {}
+
+            def visitor(name, obj):
+                if isinstance(obj, h5py.Dataset):
+                    address_list = name.split('/')
+
+                    if address_list[0] == '__meta__':
+                        meta_dict['/'.join(address_list[1:])] = obj[()].decode('utf-8')
+                    elif name != '__version__':
+                        data_dict[name] = obj[()]
+
+            h5_file.visititems(visitor)
+
+        return self._reload_from_flat_dict(meta_dict, data_dict)
+
+
+# Convenience functions for direct module usage
+def save_data(filename: str, data_dict: Dict, update: bool = False) -> None:
+    """
+    Save nested dictionary to HDF5 file (convenience function).
+
+    Parameters
+    ----------
+    filename : str
+        Path to HDF5 file
+    data_dict : dict
+        Nested dictionary to save
+    update : bool, optional
+        Update existing file if True
+
+    Examples
+    --------
+    >>> data = {'results': {'exp1': np.array([1, 2, 3])}}
+    >>> save_data('output.h5', data)
+    """
+    io_handler = H5Typer()
+    io_handler.save_data(filename, data_dict, update=update)
+
+
+def load_data(filename: str) -> Dict:
+    """
+    Load nested dictionary from HDF5 file (convenience function).
+
+    Parameters
+    ----------
+    filename : str
+        Path to HDF5 file
+
+    Returns
+    -------
+    dict
+        Loaded nested dictionary
+
+    Examples
+    --------
+    >>> data = load_data('output.h5')
+    """
+    io_handler = H5Typer()
+    return io_handler.load_data(filename)

h5typer-0.1.0.dist-info/METADATA

@@ -0,0 +1,319 @@
+Metadata-Version: 2.4
+Name: h5typer
+Version: 0.1.0
+Summary: Automatic type mapping for Python objects to HDF5
+Author-email: Justin Chan <chan.waisoon@qst.go.jp>, Hidetoshi Kono <kono.hidetoshi@qst.go.jp>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/iQLS-MMS/h5typer
+Keywords: hdf5,type-mapping,numpy,pandas,serialization
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.19.0
+Requires-Dist: pandas>=1.0.0
+Requires-Dist: h5py>=3.0.0
+Dynamic: license-file
+
+# h5typer
+
+**Automatic type mapping for Python objects to HDF5**
+
+h5typer is a lightweight Python package that provides seamless type conversion when saving and loading nested Python dictionaries to/from HDF5 files. It automatically handles the complexity of mapping Python types (numpy arrays, pandas DataFrames/Series, None, etc.) to HDF5-compatible formats.
+
+Originally developed as part of the [HiC-SCA](https://github.com/iQLS-MMS/hic-sca) package for Hi-C analysis, h5typer has been extracted as a standalone, reusable package that can be used in any Python project requiring HDF5 I/O with automatic type handling.
+
+## Features
+
+- **Automatic Type Conversion**: Transparently handles numpy arrays, pandas DataFrames/Series, strings, None, and standard Python types
+- **Nested Dictionary Support**: Save and load arbitrarily nested dictionary structures
+- **Robust**: Handles edge cases like empty arrays, None values, and object dtypes
+- **Simple API**: Just two main functions - `save_data()` and `load_data()`
+- **Efficient**: Uses HDF5's hierarchical storage for fast I/O
+
+## Why h5typer?
+
+Standard HDF5 libraries like h5py require manual handling of type conversions:
+
+```python
+# Without h5typer - manual type handling
+import h5py
+
+with h5py.File('data.h5', 'w') as f:
+    f.create_dataset('array', data=np.array([1, 2, 3]))
+    f.create_dataset('string', data='hello'.encode('utf-8'))  # Must encode
+    # Complex types like pandas DataFrames require custom serialization
+
+# With h5typer - automatic!
+import h5typer
+
+data = {
+    'array': np.array([1, 2, 3]),
+    'string': 'hello',
+    'dataframe': pd.DataFrame({'A': [1, 2]})
+}
+h5typer.save_data('data.h5', data)
+```
+
+h5typer handles all the boilerplate, letting you focus on your data.
+
+## Installation
+
+```bash
+# Install from source
+git clone https://github.com/iQLS-MMS/h5typer.git
+cd h5typer
+pip install .
+```
+
+### Requirements
+
+- Python >= 3.7
+- numpy >= 1.19.0
+- pandas >= 1.0.0
+- h5py >= 3.0.0
+
+## Quick Start
+
+```python
+import h5typer
+import numpy as np
+import pandas as pd
+
+# Create some data
+data = {
+    'experiment': {
+        'results': np.array([1, 2, 3, 4, 5]),
+        'metadata': {
+            'name': 'Test Experiment',
+            'date': '2025-10-27',
+            'valid': True
+        },
+        'dataframe': pd.DataFrame({
+            'A': [1, 2, 3],
+            'B': [4, 5, 6]
+        }),
+        'empty_value': None
+    }
+}
+
+# Save to HDF5
+h5typer.save_data('output.h5', data)
+
+# Load from HDF5
+loaded_data = h5typer.load_data('output.h5')
+
+# Access your data - it's exactly as you saved it!
+print(loaded_data['experiment']['results'])  # array([1, 2, 3, 4, 5])
+print(loaded_data['experiment']['metadata']['name'])  # 'Test Experiment'
+print(loaded_data['experiment']['dataframe'])  # Original DataFrame
+```
+
+## API Reference
+
+### Functions
+
+#### `save_data(filename, data_dict, update=False)`
+
+Save a nested dictionary to an HDF5 file.
+
+**Parameters:**
+- `filename` (str): Path to the HDF5 file
+- `data_dict` (dict): Nested dictionary to save
+- `update` (bool, optional): If True, update existing file; if False, overwrite. Default: False
+
+**Example:**
+```python
+import h5typer
+
+data = {'key': 'value', 'array': np.array([1, 2, 3])}
+h5typer.save_data('mydata.h5', data)
+
+# Update existing file
+more_data = {'new_key': 'new_value'}
+h5typer.save_data('mydata.h5', more_data, update=True)
+```
+
+#### `load_data(filename)`
+
+Load a nested dictionary from an HDF5 file.
+
+**Parameters:**
+- `filename` (str): Path to the HDF5 file
+
+**Returns:**
+- `dict`: The loaded nested dictionary
+
+**Example:**
+```python
+import h5typer
+
+data = h5typer.load_data('mydata.h5')
+print(data['key'])  # 'value'
+```
+
+### Class API
+
+For more control, use the `H5Typer` class directly:
+
+```python
+from h5typer import H5Typer
+
+# Create instance
+io_handler = H5Typer()
+
+# Save data
+io_handler.save_data('output.h5', my_dict)
+
+# Load data
+loaded = io_handler.load_data('output.h5')
+```
+
+## Supported Types
+
+h5typer automatically handles the following Python types:
+
+| Python Type | HDF5 Storage | Notes |
+|-------------|--------------|-------|
+| `numpy.ndarray` | Dataset | All dtypes supported, including object arrays |
+| `pandas.DataFrame` | Group with datasets | Index, columns, and values preserved |
+| `pandas.Series` | Group with datasets | Index and values preserved |
+| `dict` | Group | Nested dictionaries become HDF5 groups |
+| `str` | Dataset (bytes) | UTF-8 encoded |
+| `int`, `float` | Dataset | Stored as numpy scalars |
+| `None` | h5py.Empty | Preserved on load |
+| `list`, `tuple` | Dataset | Converted to numpy arrays, all elements must be of the same type |
+
+## Type Conversion Details
+
+### NumPy Arrays
+
+```python
+# String arrays
+str_array = np.array(['a', 'b', 'c'])
+# Automatically converted to bytes for HDF5
+
+# Float64 arrays
+float_array = np.array([1.0, 5.0, 3.0], dtype=np.float64)
+```
+
+### Pandas Objects
+
+```python
+# DataFrames - index, columns, and values all preserved
+df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
+
+# Series - index and values preserved
+series = pd.Series([1, 2, 3], index=['a', 'b', 'c'])
+```
+
+### None Values
+
+```python
+data = {
+    'value': None,
+}
+# None values are preserved through save/load
+```
+
+## Advanced Usage
+
+### Nested Structures
+
+```python
+data = {
+    'level1': {
+        'level2': {
+            'level3': {
+                'deep_array': np.array([1, 2, 3])
+            }
+        }
+    }
+}
+
+h5typer.save_data('nested.h5', data)
+loaded = h5typer.load_data('nested.h5')
+# Structure is preserved
+```
+
+### Updating Files
+
+```python
+# Initial save
+h5typer.save_data('data.h5', {'key1': 'value1'})
+
+# Add more data
+h5typer.save_data('data.h5', {'key2': 'value2'}, update=True)
+
+# Load gets both keys
+data = h5typer.load_data('data.h5')
+# {'key1': 'value1', 'key2': 'value2'}
+```
+
+### Integer Keys
+
+```python
+# Integer keys are preserved
+data = {
+    100: 'hundred',
+    200: 'two hundred',
+    'string_key': 'value'
+}
+
+h5typer.save_data('intkeys.h5', data)
+loaded = h5typer.load_data('intkeys.h5')
+print(loaded[100])  # 'hundred' - key is still an integer
+```
+
+## Integration with HiC-SCA
+
+h5typer is used by [HiC-SCA](https://github.com/iQLS-MMS/hic-sca) for all HDF5 I/O operations:
+
+```python
+# In HiC-SCA
+from hicsca import HiCSCA
+
+# Process Hi-C data
+hicsca = HiCSCA("sample.hic", resolutions=[100000])
+hicsca.process_all_chromosomes()
+
+# Save results (uses h5typer internally)
+hicsca.to_hdf5("results.h5")
+
+# Load results (uses h5typer internally)
+hicsca_loaded = HiCSCA.from_hdf5("results.h5")
+```
+
+The integration is transparent - HiC-SCA uses h5typer for automatic type mapping of complex nested dictionaries containing numpy arrays, pandas DataFrames, and metadata.
+
+## License
+
+MIT License
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## Changelog
+
+### Version 0.1.0
+- Initial release
+- Support for numpy arrays, pandas DataFrames/Series, None values
+- Nested dictionary support
+- Integer key preservation
+- Update functionality
+
+## See Also
+
+- **HiC-SCA**: Hi-C Spectral Compartment Analysis package using h5typer
+- **h5py**: Low-level HDF5 interface for Python
+- **pandas**: Data analysis library with HDF5 support

h5typer-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+h5typer/__init__.py,sha256=tG9uZADIDAW5c9Ph7b-8KpIvYyZ1BMA-Ycqjs51xCew,1132
+h5typer/io.py,sha256=GDE72JreMxnAk8W2e7Iij4WyDggVQ95f3XtY1fRRv-E,13359
+h5typer-0.1.0.dist-info/licenses/LICENSE,sha256=58XdpW1w9bAYTrokz315fY90xhh-SMsFh55EUiZL0V0,1106
+h5typer-0.1.0.dist-info/METADATA,sha256=rzSzmQVLz0kA7vRkP0qKUHxyOID7qaiAizlr68V0ckc,8222
+h5typer-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+h5typer-0.1.0.dist-info/top_level.txt,sha256=k4zAyVsea7DFRK3X9NEbLwF-L1GHBHurAV7-ZbfQQhE,8
+h5typer-0.1.0.dist-info/RECORD,,

h5typer-0.1.0.dist-info/WHEEL

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

h5typer-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Molecular Modelling and Simulation Team, iQLS, QST
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

h5typer-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+h5typer