img4it 0.0.1__tar.gz

img4it-0.0.1/License.txt

@@ -0,0 +1,6 @@
+THIS SOFTWARE IS PROVIDED "AS IS", WITHOUT ANY WARRANTY WHATSOEVER.
+
+If you use or redistribute this software, you are permitted to do so
+under the terms of GNU [GPL-3.0]+ license.
+
+[GPL-3.0]: https://www.gnu.org/licenses/gpl-3.0.en.html

img4it-0.0.1/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.1
+Name: img4it
+Version: 0.0.1
+Summary: Exploit computer vision technology with Orange Data Mining !
+Home-page: 
+Author: Orange community
+Author-email: 
+Keywords: orange3 add-on
+License-File: License.txt
+Requires-Dist: aait
+Requires-Dist: paddlepaddle==2.6.2

img4it-0.0.1/img4it.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.1
+Name: img4it
+Version: 0.0.1
+Summary: Exploit computer vision technology with Orange Data Mining !
+Home-page: 
+Author: Orange community
+Author-email: 
+Keywords: orange3 add-on
+License-File: License.txt
+Requires-Dist: aait
+Requires-Dist: paddlepaddle==2.6.2

img4it-0.0.1/img4it.egg-info/SOURCES.txt

@@ -0,0 +1,28 @@
+License.txt
+setup.py
+img4it.egg-info/PKG-INFO
+img4it.egg-info/SOURCES.txt
+img4it.egg-info/dependency_links.txt
+img4it.egg-info/entry_points.txt
+img4it.egg-info/namespace_packages.txt
+img4it.egg-info/requires.txt
+img4it.egg-info/top_level.txt
+orangecontrib/__init__.py
+orangecontrib/IMG4IT/__init__.py
+orangecontrib/IMG4IT/utils/__init__.py
+orangecontrib/IMG4IT/widgets/OWConvertImages.py
+orangecontrib/IMG4IT/widgets/OWPaddleOCR.py
+orangecontrib/IMG4IT/widgets/__init__.py
+orangecontrib/IMG4IT/widgets/designer/__init__.py
+orangecontrib/IMG4IT/widgets/icons/__init__.py
+orangecontrib/IMG4IT/widgets/icons_dev/__init__.py
+tests/test_class_values_context_handler.py
+tests/test_credentials.py
+tests/test_domain_context_handler.py
+tests/test_gui.py
+tests/test_matplotlib_export.py
+tests/test_perfect_domain_context_handler.py
+tests/test_scatterplot_density.py
+tests/test_settings_handler.py
+tests/test_widgets_outputs.py
+tests/test_workflows.py

img4it-0.0.1/img4it.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

img4it-0.0.1/img4it.egg-info/entry_points.txt

@@ -0,0 +1,5 @@
+[orange.widgets]
+Advanced Artificial Intelligence Tools = orangecontrib.AAIT.widgets
+
+[orange.widgets.tutorials]
+AAIT Tutorials = orangecontrib.AAIT.tutorials

img4it-0.0.1/img4it.egg-info/namespace_packages.txt

@@ -0,0 +1 @@
+orangecontrib

img4it-0.0.1/img4it.egg-info/requires.txt

@@ -0,0 +1,2 @@
+aait
+paddlepaddle==2.6.2

img4it-0.0.1/img4it.egg-info/top_level.txt

@@ -0,0 +1 @@
+orangecontrib

img4it-0.0.1/orangecontrib/IMG4IT/widgets/OWConvertImages.py

@@ -0,0 +1,128 @@
+import numpy as np
+import os
+import zipfile
+from PIL import Image
+import pillow_heif
+import Orange
+from Orange.data import Table, Domain, StringVariable
+from pathlib import Path
+from Orange.widgets.widget import OWWidget, Input, Output
+from AnyQt.QtWidgets import QApplication
+
+class OWConvertImages(OWWidget):
+    name = "Convert Images"
+    description = "Takes one or more folders as input. In these folders, if a .zip file is found, extract the images it contains, convert them to JPG, and reduce their resolution to decrease the image file size."
+    icon = "icons/resize-picture.svg"
+    if "site-packages/Orange/widgets" in os.path.dirname(os.path.abspath(__file__)).replace("\\", "/"):
+        icon = "icons_dev/resize-picture.svg"
+    priority = 3000
+
+    class Inputs:
+        data = Input("Data", Orange.data.Table)
+
+    @Inputs.data
+    def set_data(self, in_data):
+        self.data = in_data
+        if self.data is None:
+            return
+        if "folders_path" in in_data.domain:
+            self.folders_path = in_data.get_column("folders_path")
+        elif "folder_path" in in_data.domain:
+            self.folders_path = in_data.get_column("folder_path")
+        if "file_path" in in_data.domain:
+            self.path_file = in_data.get_column("file_path")
+        else:
+            if self.folders_path is None:
+                self.error("No folder provided.")
+                return
+            path = Path(str(self.folders_path[0]))
+            self.path_file = path.parent
+        self.run()
+
+    class Outputs:
+        data = Output("Data", Orange.data.Table)
+
+    def __init__(self):
+        super().__init__()
+        self.data = None
+        self.folders_path = None
+        self.path_file = None
+        self.MAX_SIZE = (1000, 1000)
+        self.run()
+
+    def trouver_fichiers_zip(self,dossier):
+        chemin_complet = None
+        for racine, dossiers, fichiers in os.walk(dossier):
+            for fichier in fichiers:
+                if fichier.lower().endswith('.zip'):
+                    chemin_complet = os.path.join(racine, fichier)
+        return chemin_complet
+
+    def run(self):
+        self.error("")
+        self.warning("")
+
+        if self.data is None:
+            return
+
+        if self.folders_path is None or self.path_file is None:
+            self.error("No folder provided.")
+            return
+
+        # Fonctionnel pour confideo
+        # a modifier cette fonction encore la fonction de dezip à l'intérieur
+        # il faudrait modifier pour enlever le début et ne laisser que la partie convertion d'image
+        image_paths = []
+        pillow_heif.register_heif_opener()
+        # Extraction et collecte des images
+        for file_path in self.folders_path:
+            img = []
+            path = self.trouver_fichiers_zip(file_path)
+            if path == None:
+                pass
+            extract_path = file_path + "/" + "temp_images"
+            os.makedirs(extract_path, exist_ok=True)
+            ext = os.path.splitext(str(path))[1].lower()
+            if ext == ".zip":
+                with zipfile.ZipFile(path, "r") as zip_ref:
+                    zip_ref.extractall(extract_path)
+                for root, dirs, files in os.walk(extract_path):
+                    for fname in files:
+                        if fname.lower().endswith((".png", ".jpg", ".jpeg", ".tiff", ".tif", ".heif", ".heic")):
+                            img.append(os.path.join(root, fname))
+            elif ext in [".png", ".jpg", ".jpeg", ".tiff", ".tif", ".heif", ".heic"]:
+                image_paths.append(path)
+            image_paths.append(img)
+
+        converted_path = str(self.path_file) + "/temp_images/converted"
+        os.makedirs(converted_path, exist_ok=True)
+        new_image_paths = []
+
+        for image_path in image_paths:
+            for img_path in image_path:
+                ext = os.path.splitext(img_path)[1].lower()
+                if ext in [".png", ".jpg", ".jpeg", ".tiff", ".tif", ".heif", ".heic"]:
+                    try:
+                        image = Image.open(img_path)
+                        if image.mode != 'RGB':
+                            image = image.convert('RGB')
+                        image.thumbnail(self.MAX_SIZE)
+                        new_filename = os.path.splitext(os.path.basename(img_path))[0] + ".jpg"
+                        new_path = os.path.join(converted_path, new_filename)
+                        image.save(new_path, format="JPEG", quality=70)
+                        new_image_paths.append(new_path)
+                        # Supprimer l'original (facultatif)
+                        # os.remove(img_path)
+                    except Exception as e:
+                        print(f"Erreur de conversion {img_path} : {e}")
+        data_metas = [[str(self.path_file), str(new_image_paths)]]
+        domain = Domain([], metas=[StringVariable("folder_path"), StringVariable("image_paths")])
+        table = Table.from_numpy(domain, np.empty((len(data_metas), 0)), metas=data_metas)
+        self.Outputs.data.send(table)
+
+if __name__ == "__main__":
+    import sys
+    app = QApplication(sys.argv)
+    my_widget = OWConvertImages()
+    my_widget.show()
+    app.exec_()

img4it-0.0.1/orangecontrib/IMG4IT/widgets/OWPaddleOCR.py

@@ -0,0 +1,210 @@
+import os
+import sys
+import numpy as np
+
+import fitz
+from paddleocr import PaddleOCR
+
+import Orange.data
+from Orange.data import Table, Domain, StringVariable, ContinuousVariable
+from AnyQt.QtWidgets import QApplication
+from Orange.widgets import widget
+from Orange.widgets.utils.signals import Input, Output
+
+if "site-packages/Orange/widgets" in os.path.dirname(os.path.abspath(__file__)).replace("\\", "/"):
+    from Orange.widgets.orangecontrib.AAIT.utils import thread_management, SimpleDialogQt
+    from Orange.widgets.orangecontrib.AAIT.utils.import_uic import uic
+    from Orange.widgets.orangecontrib.AAIT.utils.initialize_from_ini import apply_modification_from_python_file
+    from Orange.widgets.orangecontrib.AAIT.utils.MetManagement import GetFromRemote, get_local_store_path
+else:
+    from orangecontrib.AAIT.utils import thread_management, SimpleDialogQt
+    from orangecontrib.AAIT.utils.import_uic import uic
+    from orangecontrib.AAIT.utils.initialize_from_ini import apply_modification_from_python_file
+    from orangecontrib.AAIT.utils.MetManagement import GetFromRemote, get_local_store_path
+
+
+
+@apply_modification_from_python_file(filepath_original_widget=__file__)
+class OWPaddleOCR(widget.OWWidget):
+    name = "Paddle OCR"
+    description = "Apply OCR on the PDF documents present in the 'path' column of the input Table"
+    icon = "icons/paddleocr.svg"
+    if "site-packages/Orange/widgets" in os.path.dirname(os.path.abspath(__file__)).replace("\\", "/"):
+        icon = "icons_dev/paddleocr.svg"
+    gui = os.path.join(os.path.dirname(os.path.abspath(__file__)), "designer/owpaddleocr.ui")
+    want_control_area = False
+    priority = 1212
+
+    class Inputs:
+        data = Input("Data", Orange.data.Table)
+
+    class Outputs:
+        data = Output("Data", Orange.data.Table)
+
+    @Inputs.data
+    def set_data(self, in_data):
+        self.data = in_data
+        if self.autorun:
+            self.run()
+
+    def __init__(self):
+        super().__init__()
+        # Qt Management
+        self.setFixedWidth(470)
+        self.setFixedHeight(300)
+        uic.loadUi(self.gui, self)
+
+        # Data Management
+        self.data = None
+        self.model = None
+        self.thread = None
+        self.autorun = True
+        self.result = None
+        self.load_model()
+        self.post_initialized()
+
+    def load_model(self):
+        local_store_path = get_local_store_path()
+        model_path = os.path.join(local_store_path, "Models", "ComputerVision", ".paddleocr", "whl")
+        load = True
+        if not os.path.exists(model_path):
+            load = False
+            self.error("PaddleOCR model is not in your computer. This widget cannot process your data.")
+            if not SimpleDialogQt.BoxYesNo("Model isn't in your computer. Do you want to download it from AAIT store?"):
+                return
+            try:
+                if 0 == GetFromRemote("Paddle OCR"):
+                    load = True
+                    self.error("")
+            except:
+                SimpleDialogQt.BoxError("Unable to get the Model.")
+                return
+        if load:
+            self.model = PaddleOCR(use_angle_cls=True, lang="fr",
+                                   det_model_dir=os.path.join(model_path, "det"),
+                                   rec_model_dir=os.path.join(model_path, "rec"),
+                                   cls_model_dir=os.path.join(model_path, "cls"),
+                                   show_log=False)
+            self.information("Paddle OCR model successfully loaded.")
+
+
+    def run(self):
+        # if thread is running quit
+        if self.thread is not None:
+            self.thread.safe_quit()
+
+        if self.data is None:
+            return
+
+        if self.model is None:
+            return
+
+        # Verification of in_data
+        self.error("")
+        try:
+            self.data.domain["path"]
+        except KeyError:
+            self.error('You need a "path" column in input data')
+            return
+
+        if type(self.data.domain["path"]).__name__ != 'StringVariable':
+            self.error('"path" column needs to be a Text')
+            return
+
+        # Start progress bar
+        self.progressBarInit()
+
+        # Connect and start thread : main function, progress, result and finish
+        # --> progress is used in the main function to track progress (with a callback)
+        # --> result is used to collect the result from main function
+        # --> finish is just an empty signal to indicate that the thread is finished
+        self.thread = thread_management.Thread(self.apply_OCR_on_Table, self.data, self.model)
+        self.thread.progress.connect(self.handle_progress)
+        self.thread.result.connect(self.handle_result)
+        self.thread.finish.connect(self.handle_finish)
+        self.thread.start()
+
+    def handle_progress(self, value: float) -> None:
+        self.progressBarSet(value)
+
+    def handle_result(self, result):
+        try:
+            self.result = result
+            self.Outputs.data.send(result)
+        except Exception as e:
+            print("An error occurred when sending out_data:", e)
+            self.Outputs.data.send(None)
+            return
+
+    def handle_finish(self):
+        print("Embeddings finished")
+        self.progressBarFinished()
+
+    def post_initialized(self):
+        pass
+
+
+    def apply_OCR_on_Table(self, table, model, progress_callback=None, argself=None):
+        # Copy of input data
+        data = table.copy()
+        attr_dom = list(data.domain.attributes)
+        metas_dom = list(data.domain.metas)
+        class_dom = list(data.domain.class_vars)
+
+        # Iterate on the data Table
+        rows = []
+        for i, row in enumerate(data):
+            # Get the rest of the data
+            features = [row[x] for x in attr_dom]
+            targets = [row[y] for y in class_dom]
+            metas = list(data.metas[i])
+            filepath = row["path"].value
+            result_per_page = apply_OCR_on_pdf(filepath, model)
+            for key, value in result_per_page.items():
+                new_row = features + targets + metas + [key, value]
+                rows.append(new_row)
+            if progress_callback is not None:
+                progress_value = float(100 * (i + 1) / len(data))
+                progress_callback(progress_value)
+            if argself is not None:
+                if argself.stop:
+                    break
+
+        # Create new Domain for new columns
+        ocr_dom = [ContinuousVariable("Page n°"), StringVariable("OCR Extraction")]
+        domain = Domain(attributes=attr_dom, metas=metas_dom + ocr_dom, class_vars=class_dom)
+
+        # Create and return table
+        out_data = Table.from_list(domain=domain, rows=rows)
+        return out_data
+
+
+def apply_OCR_on_pdf(filepath, model, dpi=300):
+    # Load the document
+    doc = fitz.open(filepath)
+    # Iterate over pages
+    result_per_page = {}
+    for page_num in range(len(doc)):
+        page = doc.load_page(page_num)
+
+        # Render page to a pixmap (RGB image)
+        mat = fitz.Matrix(dpi/72, dpi/72)
+        pix = page.get_pixmap(matrix=mat, colorspace=fitz.csRGB)
+        img = np.frombuffer(pix.samples, dtype=np.uint8).reshape(pix.height, pix.width, pix.n)
+
+        # Apply OCR
+        result_ocr = model.ocr(img, cls=True)[0]
+        full_text = ""
+        for line in result_ocr:
+            text = line[1][0]
+            # confidence = line[1][1] # maybe useful later
+            full_text += text + "\n"
+        result_per_page[page_num] = full_text
+    return result_per_page
+
+
+if __name__ == "__main__":
+    app = QApplication(sys.argv)
+    my_widget = OWPaddleOCR()
+    my_widget.show()
+    app.exec_()

img4it-0.0.1/orangecontrib/__init__.py

@@ -0,0 +1 @@
+__import__("pkg_resources").declare_namespace(__name__)

img4it-0.0.1/setup.cfg

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

img4it-0.0.1/setup.py

@@ -0,0 +1,65 @@
+from setuptools import setup, find_packages
+
+# Nom du package PyPI ('pip install NAME')
+NAME = "img4it"
+
+# Version du package PyPI
+VERSION = "0.0.1"  # la version doit être supérieure à la précédente sinon la publication sera refusée
+
+# Facultatif / Adaptable à souhait
+AUTHOR = "Orange community"
+AUTHOR_EMAIL = ""
+URL = ""
+DESCRIPTION = "Exploit computer vision technology with Orange Data Mining !"
+LICENSE = ""
+
+# 'orange3 add-on' permet de rendre l'addon téléchargeable via l'interface addons d'Orange
+KEYWORDS = ["orange3 add-on",]
+
+# Tous les packages python existants dans le projet (avec un __ini__.py)
+PACKAGES = find_packages()
+PACKAGES = [pack for pack in PACKAGES if "IMG4IT" in pack]
+PACKAGES.append("orangecontrib")
+print(PACKAGES)
+
+
+
+# Fichiers additionnels aux fichiers .py (comme les icons ou des .ows)
+PACKAGE_DATA = {
+}
+# /!\ les noms de fichier 'orangecontrib.hkh_bot.widgets' doivent correspondre à l'arborescence
+
+# Dépendances
+
+INSTALL_REQUIRES = [
+    "aait",
+    "paddlepaddle==2.6.2"]
+
+
+# Spécifie le dossier contenant les widgets et le nom de section qu'aura l'addon sur Orange
+ENTRY_POINTS = {
+    "orange.widgets": (
+        "Advanced Artificial Intelligence Tools = orangecontrib.AAIT.widgets",
+    ),
+    "orange.widgets.tutorials": (
+        "AAIT Tutorials = orangecontrib.AAIT.tutorials",
+    )
+}
+# /!\ les noms de fichier 'orangecontrib.hkh_bot.widgets' doivent correspondre à l'arborescence
+
+NAMESPACE_PACKAGES = ["orangecontrib"]
+
+setup(name=NAME,
+      version=VERSION,
+      author=AUTHOR,
+      author_email=AUTHOR_EMAIL,
+      url=URL,
+      description=DESCRIPTION,
+      license=LICENSE,
+      keywords=KEYWORDS,
+      packages=PACKAGES,
+      package_data=PACKAGE_DATA,
+      install_requires=INSTALL_REQUIRES,
+      entry_points=ENTRY_POINTS,
+      namespace_packages=NAMESPACE_PACKAGES,
+      )

img4it-0.0.1/tests/test_class_values_context_handler.py

@@ -0,0 +1,75 @@
+from unittest import TestCase
+from unittest.mock import Mock
+from Orange.data import DiscreteVariable, Domain
+from Orange.data import ContinuousVariable
+from Orange.widgets.settings import ContextSetting, ClassValuesContextHandler
+from Orange.widgets.utils import vartype
+
+Continuous = vartype(ContinuousVariable("x"))
+Discrete = vartype(DiscreteVariable("x"))
+
+
+class TestClassValuesContextHandler(TestCase):
+    def setUp(self):
+        self.domain = Domain(
+            attributes=[ContinuousVariable('c1'),
+                        DiscreteVariable('d1', values='abc'),
+                        DiscreteVariable('d2', values='def')],
+            class_vars=[DiscreteVariable('d3', values='ghi')],
+            metas=[ContinuousVariable('c2'),
+                   DiscreteVariable('d4', values='jkl')]
+        )
+        self.args = (self.domain,
+                     {'c1': Continuous, 'd1': Discrete,
+                      'd2': Discrete, 'd3': Discrete},
+                     {'c2': Continuous, 'd4': Discrete, })
+        self.handler = ClassValuesContextHandler()
+        self.handler.read_defaults = lambda: None
+
+    def test_open_context(self):
+        self.handler.bind(SimpleWidget)
+        context = Mock(
+            classes=['g', 'h', 'i'], values=dict(
+                text='u',
+                with_metas=[('d1', Discrete), ('d2', Discrete)]
+            ))
+        self.handler.global_contexts = \
+            [Mock(classes=[], values={}), context, Mock(classes=[], values={})]
+
+        widget = SimpleWidget()
+        self.handler.initialize(widget)
+        self.handler.open_context(widget, self.args[0].class_var)
+        self.assertEqual(widget.text, 'u')
+        self.assertEqual(widget.with_metas, [('d1', Discrete),
+                                             ('d2', Discrete)])
+
+    def test_open_context_with_no_match(self):
+        self.handler.bind(SimpleWidget)
+        context = Mock(
+            classes=['g', 'h', 'i'], values=dict(
+                text='u',
+                with_metas=[('d1', Discrete), ('d2', Discrete)]
+            ))
+        self.handler.global_contexts = \
+            [Mock(classes=[], values={}), context, Mock(classes=(), values={})]
+        widget = SimpleWidget()
+        self.handler.initialize(widget)
+        widget.text = 'u'
+
+        self.handler.open_context(widget, self.args[0][1])
+
+        context = widget.current_context
+        self.assertEqual(context.classes, ('a', 'b', 'c'))
+        self.assertEqual(widget.text, 'u')
+        self.assertEqual(widget.with_metas, [])
+
+
+class SimpleWidget:
+    text = ContextSetting("")
+    with_metas = ContextSetting([])
+    required = ContextSetting("", required=ContextSetting.REQUIRED)
+
+    def retrieveSpecificSettings(self):
+        pass
+    def storeSpecificSettings(self):
+        pass

img4it-0.0.1/tests/test_credentials.py

@@ -0,0 +1,76 @@
+import unittest
+from unittest.mock import patch
+
+import keyring
+import keyring.errors
+import keyring.backend
+
+from Orange.widgets.credentials import CredentialManager
+
+
+# minimal in-memory keyring implementation so the test is not dependent on
+# the system config/services.
+class Keyring(keyring.backend.KeyringBackend):
+    priority = 0
+
+    def __init__(self):
+        self.__store = {}
+
+    def set_password(self, service, username, password=None):
+        self.__store[(service, username)] = password
+
+    def get_password(self, service, username):
+        return self.__store.get((service, username), None)
+
+    def delete_password(self, service, username):
+        try:
+            del self.__store[service, username]
+        except KeyError:
+            raise keyring.errors.PasswordDeleteError()
+
+
+class TestCredentialManager(unittest.TestCase):
+    def setUp(self):
+        self._ring = keyring.get_keyring()
+        keyring.set_keyring(Keyring())
+        self.cm = CredentialManager('Orange')
+
+    def tearDown(self):
+        keyring.set_keyring(self._ring)
+
+    def test_credential_manager(self):
+        cm = CredentialManager('Orange')
+        cm.key = 'Foo'
+        self.assertEqual(cm.key, 'Foo')
+        del cm.key
+        self.assertEqual(cm.key, None)
+
+    def test_set_password(self):
+        """
+        Handle error when setting password fails.
+        GH-2354
+        """
+        with patch("keyring.set_password", side_effect=Exception), \
+                patch("Orange.widgets.credentials.log.exception") as log:
+            self.cm.key = ""
+            log.assert_called()
+
+    def test_delete_password(self):
+        """
+        Handling error when deleting password fails
+        GH-2354
+        """
+        with patch("keyring.delete_password", side_effect=Exception), \
+                patch("Orange.widgets.credentials.log.exception") as log:
+            del self.cm.key
+            log.assert_called()
+
+    def test_get_password(self):
+        """
+        Handling errors when getting password fails.
+        GH-2354
+        """
+        with patch("keyring.get_password", side_effect=Exception), \
+                patch("Orange.widgets.credentials.log.exception") as log:
+            self.assertEqual(self.cm.key, None)
+            log.assert_called()