batoolset 0.1.0__py3-none-any.whl

batoolset/dialogs/opensave.py

@@ -0,0 +1,228 @@
+import os
+from batoolset.settings.global_settings import set_UI  # set the UI to qtpy
+set_UI()
+import sys
+from qtpy.QtWidgets import QApplication, QFileDialog,QCheckBox, QComboBox
+from os.path import expanduser
+
+# parent_window = None, extensions = "Supported Files (*.jpg *.tif *.png);;All Files (*)",
+# path = expanduser('~'),
+# almost there just add the possibility to chose the extensions by default and the alike stuff!!
+class SaveFileDialogWithOptions(QFileDialog):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.widgets = []
+
+    def add_widget(self, widget):
+        self.widgets.append(widget)
+
+    def get_widget_values(self):
+        return [widget.isChecked() for widget in self.widgets]
+
+    def getOpenFileName(self, parent=None,
+                        caption="Select a File",
+                        dir=expanduser('~'),
+                        filter="All files (*.*)",
+                        selectedFilter="",
+                        options=None):
+
+        # configuration of the dialog window: make sure it's complete!
+        self.setWindowTitle(caption)
+        self.setDirectory(dir)
+        self.setNameFilter(filter)
+        self.setFileMode(QFileDialog.AnyFile)
+        self.setAcceptMode(QFileDialog.AcceptOpen)  # "Open" button
+        if selectedFilter != "":
+            self.selectNameFilter(selectedFilter)
+        if options != None:
+            self.setOptions(options)
+
+        self.setOption(QFileDialog.DontUseNativeDialog, True)
+
+        layout = self.layout()
+
+        if self.widgets:
+            for iii, widget in enumerate(self.widgets):
+                layout.addWidget(widget, 4+iii, 0, 1, 4)
+
+        # user interaction and result return
+        if self.exec_():
+            widget_values = self.get_widget_values()
+            return widget_values, list(self.selectedFiles())[0]
+        else:
+            return ""
+
+
+class OpenFileDialogWithOptions(QFileDialog):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.widgets = []
+
+    def add_widget(self, widget):
+        self.widgets.append(widget)
+
+    def get_widget_values(self):
+        return [widget.isChecked() for widget in self.widgets]
+
+    def getSaveFileName(self, parent=None,
+                        caption="Save a File",
+                        dir=expanduser('~'),
+                        filter="All files (*.*)",
+                        selectedFilter="",
+                        options=None):
+
+        # configuration of the dialog window: make sure it's complete!
+        self.setWindowTitle(caption)
+        self.setDirectory(dir)
+        self.setNameFilter(filter)
+        self.setFileMode(QFileDialog.AnyFile)
+        self.setAcceptMode(QFileDialog.AcceptSave)  # "Save" button
+        if selectedFilter != "":
+            self.selectNameFilter(selectedFilter)
+        if options != None:
+            self.setOptions(options)
+
+        self.setOption(QFileDialog.DontUseNativeDialog, True)
+
+        layout = self.layout()
+
+        if self.widgets:
+            for iii, widget in enumerate(self.widgets):
+                layout.addWidget(widget, 4+iii, 0, 1, 4)
+
+        # user interaction and result return
+        if self.exec_():
+            widget_values = self.get_widget_values()
+            return widget_values, self.selectedFiles()[0]
+        else:
+            return ""
+
+def saveFileWithOptions():
+    fileDialog = SaveFileDialogWithOptions()
+
+    # Add checkboxes
+    fileDialog.add_widget(QCheckBox("consolidate"))
+    fileDialog.add_widget(QCheckBox("blabla_bli"))
+
+    return fileDialog.getOpenFileName()
+    # print("Widget values:", result[0])
+    # print("Selected file:", result[1])
+
+def openFileNameDialog(parent_window=None, extensions="Supported Files (*.jpg *.tif *.png);;All Files (*)",
+                       path=expanduser('~')):
+    """
+    Opens a file dialog to select a single file.
+
+    Args:
+        parent_window (object): Parent window object. Default is None.
+        extensions (str): File extension filters for the dialog. Default is "Supported Files (*.jpg *.tif *.png);;All Files (*)".
+        path (str): Initial path for the dialog. Default is user's home directory.
+
+    Returns:
+        str: Selected file name.
+
+    # Examples:
+    #     >>> filename = openFileNameDialog()
+    """
+    if not os.path.exists(path):
+        path = expanduser('~')
+    fileName, _ = QFileDialog.getOpenFileName(parent_window, "Select a File", path, extensions,
+                                              options=QFileDialog.DontUseNativeDialog)
+    return fileName
+
+
+def openFileNamesDialog(parent_window=None, extensions="Supported Files (*.jpg *.tif *.png);;All Files (*)",
+                        path=expanduser('~')):
+    """
+    Opens a file dialog to select multiple files.
+
+    Args:
+        parent_window (object): Parent window object. Default is None.
+        extensions (str): File extension filters for the dialog. Default is "Supported Files (*.jpg *.tif *.png);;All Files (*)".
+        path (str): Initial path for the dialog. Default is user's home directory.
+
+    Returns:
+        list: List of selected file names.
+
+    # Examples:
+    #     >>> files = openFileNamesDialog()
+    """
+    if not os.path.exists(path):
+        path = expanduser('~')
+    files, _ = QFileDialog.getOpenFileNames(parent_window, "Select Files", path, extensions,
+                                            options=QFileDialog.DontUseNativeDialog)
+    return files
+
+
+def saveFileDialog(parent_window=None, path=expanduser('~'), extensions="All Files (*);;Text Files (*.txt)",
+                    default_ext=None):
+    """
+    Opens a file dialog to save a file.
+
+    Args:
+        parent_window (object): Parent window object. Default is None.
+        path (str): Initial path for the dialog. Default is user's home directory.
+        extensions (str): File extension filters for the dialog. Default is "All Files (*);;Text Files (*.txt)".
+        default_ext (str): Default file extension. Default is None.
+
+    Returns:
+        str: Selected file name to save.
+
+    # Examples:
+    #     >>> filename = saveFileDialog(default_ext='.tif')
+    """
+    try:
+        if not os.path.exists(path) and not os.path.exists(os.path.dirname(path)):
+            path = expanduser('~')
+    except:
+        path = expanduser('~')
+    fd = QFileDialog(parent_window, "Save a File", path, extensions, options=QFileDialog.DontUseNativeDialog)
+    if default_ext is not None:
+        fd.setDefaultSuffix(default_ext)
+    fd.setAcceptMode(QFileDialog.AcceptSave)
+    selected = fd.exec()
+    if selected:
+        fileName = fd.selectedFiles()[0]
+        return fileName
+    else:
+        return
+
+
+def openDirectoryDialog(parent_window=None, path=expanduser('~')):
+    """
+    Opens a dialog to select a directory.
+
+    Args:
+        parent_window (object): Parent window object. Default is None.
+        path (str): Initial path for the dialog. Default is user's home directory.
+
+    Returns:
+        str: Selected directory path.
+
+    # Examples:
+    #     >>> folder = openDirectoryDialog()
+    """
+    if not os.path.exists(path):
+        path = expanduser('~')
+    folderName = QFileDialog.getExistingDirectory(parent_window, "Select a Directory", path,
+                                                  options=QFileDialog.DontUseNativeDialog)
+    if folderName is not None:
+        if not folderName.strip():
+            return None
+        if not folderName.endswith("/") and not folderName.endswith("\\"):
+            folderName += '/'
+    return folderName
+
+
+if __name__ == '__main__':
+    app = QApplication(sys.argv)
+    # filename = saveFileDialog(default_ext='.tif')
+
+    filename = saveFileWithOptions() # I can add options to this stuff and the content of the options is saved
+
+    # TODO --> finalize that to make it really usable
+    # or pop a widow first for parameters then for saving or vice versa -−> maybe simpler for now
+    # try that on windows to see if that works
+
+    print(filename)
+    sys.exit(0)

batoolset/dicts/tools.py

@@ -0,0 +1,299 @@
+# will contain a series of tools to better handle dicts
+
+import numpy as np
+import json
+
+def dict_diff(d1, d2, verbose=False):
+    """Return a dictionary containing the keys and values that are different between d1 and d2."""
+    diff = {}
+    unique_to_d1 = {}
+    unique_to_d2 = {}
+    for key in set(d1.keys()) | set(d2.keys()):
+        if key in d1 and key in d2:
+            try:
+                if d1[key] != d2[key]:
+                    diff[key] = (d1[key], d2[key])
+            except:
+                if not np.array_equal(d1[key], d2[key]):
+                    diff[key] = (d1[key], d2[key])
+        elif key in d1:
+            unique_to_d1[key] = d1[key]
+        elif key in d2:
+            unique_to_d2[key] = d2[key]
+    if verbose:
+        print("Keys and values that are different:")
+        for key, (val1, val2) in diff.items():
+            print(f"{key}: {val1} (in d1) vs. {val2} (in d2)")
+
+        print("\nKeys and values that are unique to d1:")
+        for key, val in unique_to_d1.items():
+            print(f"{key}: {val}")
+
+        print("\nKeys and values that are unique to d2:")
+        for key, val in unique_to_d2.items():
+            print(f"{key}: {val}")
+    return diff, unique_to_d1, unique_to_d2
+
+
+def string_to_dict(string):
+    """
+    Converts a string representation of a dictionary back to a real dictionary.
+
+    Args:
+        string (str): The string representation of a dictionary.
+
+    Returns:
+        dict: The converted dictionary.
+
+    Examples:
+        >>> string = "{'key1': 'value1', 'key2': 'value2'}"
+        >>> result = string_to_dict(string)
+        >>> print(result)
+        {'key1': 'value1', 'key2': 'value2'}
+    """
+    if string is None:
+        return None
+
+    # Replace single quotes with double quotes and 'None' with 'null'
+    string = string.replace("'", '"').replace('None', 'null')
+
+    # Convert the string to a dictionary using json.loads
+    return json.loads(string)
+
+def invert_keys_and_values(input_dict, warn_on_dupes=True):
+    """
+    Swaps keys and values of a dictionary.
+
+    Args:
+        input_dict (dict): The input dictionary.
+        warn_on_dupes (bool, optional): Whether to warn if there are duplicated values in the dictionary. Default is True.
+
+    Returns:
+        dict: The dictionary with keys and values inverted.
+
+    Examples:
+        >>> input_dict = {'A': 1, 'B': 2, 'C': 3}
+        >>> result = invert_keys_and_values(input_dict)
+        >>> print(result)
+        {1: 'A', 2: 'B', 3: 'C'}
+
+        >>> input_dict = {'A': 1, 'B': 1, 'C': 3}
+        >>> result = invert_keys_and_values(input_dict, warn_on_dupes=True)
+        Warning: some values in the dictionary are duplicated. Keys and values cannot be inverted safely.
+        >>> print(result)
+        {1: 'B', 3: 'C'}
+    """
+    # Create a new dictionary with keys and values swapped using a dictionary comprehension
+    output_dict = {value:key for key, value in input_dict.items()}
+
+    # Check if warning on duplicates is enabled
+    if warn_on_dupes:
+        # Check if the length of the output dictionary is not equal to the length of the input dictionary
+        if len(output_dict) != len(input_dict):
+            # Print a warning message if there are duplicated values in the dictionary
+            print('Warning: some values in the dictionary are duplicated. Keys and values cannot be inverted safely.')
+
+    # Return the resulting dictionary with inverted keys and values
+    return output_dict
+
+
+def dict_to_numpy(input_dict):
+    """
+    Converts a dictionary to a NumPy array.
+
+    Args:
+        input_dict (dict): The input dictionary.
+
+    Returns:
+        numpy.ndarray: The NumPy array containing key-value pairs as items.
+
+    Examples:
+        >>> input_dict = {'key1': 1, 'key2': 2, 'key3': 3}
+        >>> result = dict_to_numpy(input_dict)
+        >>> print(result)
+        [['key1' '1']
+         ['key2' '2']
+         ['key3' '3']]
+
+    """
+    return np.array(list(input_dict.items()))
+
+def get_values_in_dict_matching_a_search_list(input_dict, search_list, ignore_not_found=True, value_for_not_found_if_not_ignored=None):
+    """
+    Finds values in a dictionary that match a search list.
+
+    Args:
+        input_dict (dict): The input dictionary to search.
+        search_list (list): The list of values to search for in the dictionary.
+        ignore_not_found (bool): Flag to ignore search values not found in the dictionary. Defaults to True.
+        value_for_not_found_if_not_ignored: Value to use for search values not found if ignore_not_found is False.
+
+    Returns:
+        list: A list of values from the dictionary that match the search list.
+
+    Examples:
+        >>> input_dict = {'key1': 1, 'key2': 2, 'key3': 3}
+        >>> search_list = ['key2', 'key3']
+        >>> result = get_values_in_dict_matching_a_search_list(input_dict, search_list)
+        >>> print(result)
+        [2, 3]
+    """
+    if ignore_not_found:
+        # Find values in the input_dict that match the search_list and ignore not found values
+        output = [input_dict[search] for search in search_list if search in input_dict.keys()]
+    else:
+        # Find values in the input_dict that match the search_list and handle not found values with a specified value
+        output = [input_dict[search] if search in input_dict.keys() else value_for_not_found_if_not_ignored for search in search_list]
+    return output
+
+
+def prepend_dict(dictionary, new_key, new_value):
+    """
+    Prepend a new key-value pair to a dictionary.
+
+    Args:
+        dictionary (dict): The dictionary to modify.
+        new_key (hashable): The key to prepend.
+        new_value (Any): The value to associate with the new key.
+
+    Returns:
+        dict: A new dictionary containing the prepended key-value pair and the original key-value pairs.
+
+    Examples:
+        >>> dictionary = {'key1': 'value1', 'key2': 'value2'}
+        >>> new_key = 'key0'
+        >>> new_value = 'value0'
+        >>> result = prepend_dict(dictionary, new_key, new_value)
+        >>> print(result)
+        {'key0': 'value0', 'key1': 'value1', 'key2': 'value2'}
+    """
+    new_dict = {new_key: new_value}
+    new_dict.update(dictionary)
+    return new_dict
+
+
+def _to_dict(input):
+    """
+    Convert a list of key-value pairs to a dictionary.
+
+    Args:
+        input (list): List of key-value pairs.
+
+    Returns:
+        dict: A dictionary created from the input list.
+
+    Examples:
+        >>> input = [('key1', 'value1'), ('key2', 'value2')]
+        >>> result = _to_dict(input)
+        >>> print(result)
+        {'key1': 'value1', 'key2': 'value2'}
+    """
+    # Create an empty dictionary
+    dct = {}
+
+    # Iterate over each key-value pair in the input list
+    for k, v in input:
+        # Assign the value to the key in the dictionary
+        dct[k] = v
+
+    # Return the resulting dictionary
+    return dct
+
+
+
+def prepend_txt_to_all_dict_keys(dictionary, text):
+    """
+    Prepend a given text to all keys of a dictionary.
+
+    Args:
+        dictionary (dict): The dictionary to modify.
+        text (str): The text to prepend to the keys.
+
+    Returns:
+        dict: A new dictionary with modified keys.
+
+    Examples:
+        >>> dictionary = {'key1': 'value1', 'key2': 'value2'}
+        >>> result = prepend_txt_to_all_dict_keys(dictionary, 'prefix_')
+        >>> print(result)
+        {'prefix_key1': 'value1', 'prefix_key2': 'value2'}
+    """
+    # Use a dictionary comprehension to create a new dictionary with modified keys
+    return {text + key: value for key, value in dictionary.items()}
+
+def sort_dict_by_keys(dictionary):
+    """
+    Sort a dictionary by its keys in ascending order.
+
+    Args:
+        dictionary (dict): The dictionary to sort.
+
+    Returns:
+        dict: The sorted dictionary.
+
+    Examples:
+        >>> dictionary = {'c': 3, 'a': 1, 'b': 2}
+        >>> result = sort_dict_by_keys(dictionary)
+        >>> print(result)
+        {'a': 1, 'b': 2, 'c': 3}
+    """
+    # Sort the dictionary by keys using the sorted() function and convert it back to a dictionary
+    sorted_dict = dict(sorted(dictionary.items()))
+
+    # Return the sorted dictionary
+    return sorted_dict
+
+def sort_dict_by_values(input_dict, ascending=True):
+    """
+    Sort a dictionary by its values in ascending or descending order.
+
+    Args:
+        input_dict (dict): The input dictionary to be sorted.
+        ascending (bool, optional): If True, sort in ascending order; if False, sort in descending order.
+                                   Default is True (ascending).
+
+    Returns:
+        dict: A new dictionary with the same keys but sorted by values based on the specified order.
+
+    Examples:
+        >>> my_dict = {'apple': 3, 'banana': 1, 'cherry': 2}
+        >>> ascending_sorted_dict = sort_dict_by_values(my_dict, ascending=True)
+        >>> descending_sorted_dict = sort_dict_by_values(my_dict, ascending=False)
+        >>> print(ascending_sorted_dict)
+        {'banana': 1, 'cherry': 2, 'apple': 3}
+        >>> print(descending_sorted_dict)
+        {'apple': 3, 'cherry': 2, 'banana': 1}
+    """
+    sorted_dict = dict(sorted(input_dict.items(), key=lambda item: item[1], reverse=not ascending))
+    return sorted_dict
+
+
+if __name__ == '__main__':
+
+    if True:
+        # Example dictionary
+        my_dict = {'a': 1, 'b': 2, 'c': 3}
+        print(my_dict)
+
+        # New key and value to prepend
+        new_key = 'x'
+        new_value = 0
+
+        # Prepend the new key-value pair to the dictionary
+        new_dict = prepend_dict(my_dict, new_key, new_value)
+
+        # Print the resulting dictionary
+        print(new_dict)
+
+    if True:
+        # Example dictionary header
+        header = {'Name': 'John', 'Age': 30, 'Gender': 'Male'}
+        print(header)
+        # Text to prepend to keys
+        text = 'Prefix_'
+
+        # Prepend the text to all keys in the dictionary header
+        new_header = prepend_txt_to_all_dict_keys(header, text)
+
+        # Print the resulting dictionary header
+        print(new_header)

batoolset/dims/tools.py

@@ -0,0 +1,83 @@
+# this will contain basic tools to do unit conversions from one dimension to another, e.g. cm to inches
+# https://pixelcalculator.com/fr -> cool to test
+
+def cm_to_inch(size_in_cm):
+    return size_in_cm / 2.54
+
+
+def scaling_factor_to_achieve_DPI(desired_dpi, dpi=72):
+    return desired_dpi / dpi
+
+
+def inch_to_cm(size_in_inch):
+    """
+    Convert a length from inches to centimeters.
+
+    Args:
+        size_in_inch (float): The length in inches.
+
+    Returns:
+        float: The length in centimeters.
+    """
+    return size_in_inch * 2.54
+
+
+def pixels_to_cm(pixels, dpi=72):
+    """
+    Convert a length from pixels to centimeters, given a DPI resolution.
+
+    Args:
+        pixels (int): The length in pixels.
+        dpi (float): The desired DPI (dots per inch) resolution.
+
+    Returns:
+        float: The length in centimeters.
+    """
+    inches = pixels / dpi
+    return inches * 2.54
+
+
+def pixels_to_inch(pixels, dpi=72):
+    """
+    Convert a length from pixels to inches, given a DPI resolution.
+
+    Args:
+        pixels (int): The length in pixels.
+        dpi (float): The desired DPI (dots per inch) resolution.
+
+    Returns:
+        float: The length in inches.
+    """
+    return pixels / dpi
+
+def cm_to_pixels(cm, dpi=72):
+    """
+    Convert a length from centimeters to pixels, given a DPI resolution.
+
+    Args:
+        cm (float): The length in centimeters.
+        dpi (float): The desired DPI (dots per inch) resolution.
+
+    Returns:
+        int: The length in pixels.
+    """
+    inches = cm / 2.54
+    return int(inches * dpi)
+
+
+def inch_to_pixels(inch, dpi=72):
+    """
+    Convert a length from inches to pixels, given a DPI resolution.
+
+    Args:
+        inch (float): The length in inches.
+        dpi (float): The desired DPI (dots per inch) resolution.
+
+    Returns:
+        int: The length in pixels.
+    """
+    return int(inch * dpi)
+
+
+if __name__ == '__main__':
+    print(cm_to_pixels(21))