batoolset 0.1.0__py3-none-any.whl

batoolset/unsafe/tools.py

@@ -0,0 +1,115 @@
+from batoolset.settings.global_settings import set_UI # set the UI to qtpy
+set_UI()
+import sys
+from qtpy.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget, QPushButton, QTextEdit, QLabel, QMessageBox
+from batoolset.img import Img
+
+def execute_code(code, parent=None):
+    # code = self.code_editor.toPlainText()
+
+    # Display a warning dialog before executing the code
+    warning_dialog = QMessageBox(parent=parent)
+    warning_dialog.setWindowTitle("Warning")
+    warning_dialog.setText("Executing arbitrary code can be dangerous.\nAre you sure you want to proceed?")
+    warning_dialog.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
+    warning_dialog.setDefaultButton(QMessageBox.No)
+    warning_dialog.setIcon(QMessageBox.Warning)
+
+    # Execute the code if the user clicks "Yes"
+    if warning_dialog.exec_() == QMessageBox.Yes:
+        param = 10
+        text = 'this is a test of your system'
+        # print('before', locals())
+
+        # local_namespace = {"param": param, "text": text, "img": img}
+        local_namespace = {}
+
+        # current_locals = locals()
+        try:
+            exec(code, locals(), local_namespace)
+            # exec(code, current_locals, local_namespace)
+            # img = local_namespace["img"]
+
+            """
+            example of calling the stuff
+
+            # img=img[...,0]
+            # text='tutu'
+            # param+=6
+            self.img=self.img[...,0]
+            text='tutu'
+            param+=6
+            """
+
+            # only allow very few number of variables to be edited -−> TODO
+            if False:
+                if False:  # below it gets all the variables that may cause trouble
+                    # Update the local variables from the local namespace from the code (there are advantages to that but it may also cause problems)
+                    for var_name, var_value in local_namespace.items():
+                        if var_name in locals() and locals()[var_name] != var_value:
+                            locals()[var_name] = var_value
+                else:
+                    # a slightly better version that excludes local variables with _
+                    for var_name, var_value in local_namespace.items():
+                        if not var_name.startswith("_") and var_name in locals() and locals()[var_name] != var_value:
+                            locals()[var_name] = var_value
+                            # globals()[var_name] = var_value
+
+            # print('after', locals())
+            #
+            # if 'text' in local_namespace:
+            #     text = local_namespace['text']
+            # if 'param' in local_namespace:
+            #     param = local_namespace['param']
+            # if 'self.img' in local_namespace:  # that works also with self --> do this specifically for the image stuff
+            #     self.img = local_namespace['self.img']
+            #
+            # # print("Result:", img.shape)  # Print the result in console for demonstration
+            # print("Result: text", text)  # Print the result in console for demonstration
+            # print("Result: param", param)
+            # print("Result: self.img", self.img.shape)
+            # print("Result:", param)
+
+            # print("Result:", img.shape)  # Print the result in console for demonstration
+        except Exception as e:
+            print("Error:", e)
+
+
+class CodeExecutorWindow(QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("Code Executor")
+        self.setGeometry(100, 100, 600, 400)
+
+        central_widget = QWidget()
+        self.setCentralWidget(central_widget)
+
+        layout = QVBoxLayout(central_widget)
+
+        self.code_editor = QTextEdit()
+        layout.addWidget(self.code_editor)
+
+        execute_button = QPushButton("Execute")
+        execute_button.clicked.connect(lambda: execute_code(self.code_editor.toPlainText(), self))
+        layout.addWidget(execute_button)
+
+        self.warning_label = QLabel("Warning: Executing arbitrary code can be dangerous. Only rely on trusted sources.")
+        self.warning_label.setStyleSheet("color: red")
+        layout.addWidget(self.warning_label)
+
+        self.img = Img('/E/Sample_images/sample_images_PA/mini_vide/focused_Series012.png') # that works and it is really cool
+        # shall I take a user edited result instead and keep the original --> in a way yes be cause this is the only way to preseve the integrity of the images --> think of that --> I really need to think
+        # but then I cannot share the images between all objects --> anyway this is not smart if they can be edited -->
+
+
+
+
+
+
+
+
+if __name__ == "__main__":
+    app = QApplication(sys.argv)
+    window = CodeExecutorWindow()
+    window.show()
+    sys.exit(app.exec_())

batoolset/utils/commontools.py

@@ -0,0 +1,158 @@
+import functools
+import sys
+
+def get_python_version():
+    """
+    Returns the Python version.
+
+    Returns:
+        str: The Python version.
+
+    # Examples:
+    #     >>> get_python_version()
+    #     '3.7.6'
+    """
+    return sys.version
+
+def get_version_infos():
+    """
+    Returns the version information of the Python interpreter.
+
+    Returns:
+        sys.version_info: Version information as a named tuple.
+
+    # Examples:
+    #     >>> get_version_infos()
+    #     sys.version_info(major=3, minor=7, micro=6, releaselevel='final', serial=0)
+    """
+    return sys.version_info
+
+def get_path_to_python_executable():
+    """
+    Returns the path to the Python executable.
+
+    Returns:
+        str: Path to the Python executable.
+
+    # Examples:
+    #     >>> get_path_to_python_executable()
+    #     '/usr/local/bin/python3.7'
+    """
+    return sys.executable
+
+
+# the cost to keep this is too high as it forces the import of tf which is not good
+# def get_tensorflow_version():
+#     """
+#     Returns the version of TensorFlow installed.
+#
+#     Returns:
+#         str: TensorFlow version.
+#
+#     # Examples:
+#     #     >>> get_tensorflow_version()
+#     #     '2.6.5'
+#     """
+#     import tensorflow as tf
+#     return tf.__version__
+
+def execute_chained_functions(function_to_chain_iterable, parameter, reverse=False):
+    """
+    Executes a chain of functions on a parameter.
+
+    Args:
+        function_to_chain_iterable (iterable): Iterable containing the functions to chain.
+        parameter: The parameter to be processed by the chained functions.
+        reverse (bool, optional): Specifies whether to reverse the order of the functions in the chain. Defaults to False.
+
+    Returns:
+        The result of applying the chained functions on the parameter.
+
+    Examples:
+        >>> def add_two(x):
+        ...     return x + 2
+        ...
+        >>> def multiply_by_three(x):
+        ...     return x * 3
+        ...
+        >>> def subtract_one(x):
+        ...     return x - 1
+        ...
+        >>> functions = [add_two, multiply_by_three, subtract_one]
+        >>> execute_chained_functions(functions, 5)
+        20
+        >>> execute_chained_functions(functions, 5, reverse=True)
+        14
+    """
+    result = functools.reduce(lambda fn, f: f(fn), reversed(function_to_chain_iterable) if reverse else function_to_chain_iterable, parameter)
+    return result
+
+def execute_chained_functions_and_save_as_tiff(parameter, function_to_chain_iterable=None, output_file_name=None, reverse=False):
+    """
+    Executes a chain of functions on a parameter and saves the result as a TIFF image.
+
+    Args:
+        parameter: The parameter to be processed by the chained functions.
+        function_to_chain_iterable (iterable, optional): Iterable containing the functions to chain. Defaults to None.
+        output_file_name (callable, optional): A callable that returns the output file name based on the parameter. Defaults to None.
+        reverse (bool, optional): Specifies whether to reverse the order of the functions in the chain. Defaults to False.
+
+    """
+    result = execute_chained_functions(function_to_chain_iterable=function_to_chain_iterable, parameter=parameter, reverse=False)
+    save_as_tiff(result, output_name=output_file_name(parameter))
+
+
+if __name__ == '__main__':
+    if True:
+        print("Python version")
+        print(get_python_version())
+        print("Version info")
+        print(get_version_infos())
+        print("Executable")
+        print(get_path_to_python_executable())
+        # print('tf')
+        # print(get_tensorflow_version())
+
+
+    # --> cool so all will be easy with this stuff
+    if True:
+        '''SINGLE IMAGE VERSION BELOW'''
+        # quick and rapid code to chain output of fucntions --> really useful --> I really love it
+
+        from functools import partial
+        from batoolset.img import save_as_tiff, Img, elastic_deform, invert
+        from batoolset.files.tools import smart_name_parser
+        from batoolset.utils.loadlist import list_processor, loadlist
+
+        img_path = '/E/Sample_images/wings/adult_wings/N01_YwrGal4_males_wing0_projected.png'
+        save = partial(save_as_tiff, output_name=smart_name_parser(
+            '/E/Sample_images/wings/adult_wings/N01_YwrGal4_males_wing0_projected_inverted.tif', 'full_no_ext') + '.tif')
+
+        chained_functions = [Img, invert, elastic_deform, save]
+        print('chained functions', chained_functions)
+        execute_chained_functions(chained_functions, img_path)  # load image invert it and save it
+
+    if True:
+        ''' MT VERSION BELOW '''
+        from functools import partial
+        from batoolset.img import save_as_tiff, Img
+        from batoolset.files.tools import smart_name_parser
+        from batoolset.utils.loadlist import list_processor, loadlist
+
+
+        # see if I can MT that
+        lst = loadlist('/E/Sample_images/sample_images_PA/mini_empty/list.lst')
+        def output_file_name(input_file_name):
+            return smart_name_parser(
+                input_file_name, 'full_no_ext') + 'inverted2.tif'
+
+
+        chained_functions = [Img, invert, elastic_deform]
+
+        list_processor(lst=lst, processing_fn=chained_functions, multithreading=True, use_save_execution_if_chained=True,progress_callback=None, name_processor_function_for_saving=output_file_name)
+
+        import sys
+        sys.exit(0)
+
+        # very good for all
+        # all is ok