tkinterweb 4.17.1__tar.gz → 4.17.3__tar.gz

{tkinterweb-4.17.1/tkinterweb.egg-info → tkinterweb-4.17.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tkinterweb
-Version: 4.17.1
+Version: 4.17.3
 Summary: HTML/CSS viewer, editor, and app builder for Tkinter
 Home-page: https://github.com/Andereoo/TkinterWeb
 License: MIT

{tkinterweb-4.17.1 → tkinterweb-4.17.3}/setup.py

@@ -6,7 +6,7 @@ README = (HERE / "README.md").read_text()
 
 setup(
     name="tkinterweb",
-    version="4.17.1",
+    version="4.17.3",
     python_requires=">=3.2",
     description="HTML/CSS viewer, editor, and app builder for Tkinter",
     long_description=README,

{tkinterweb-4.17.1 → tkinterweb-4.17.3}/tkinterweb/bindings.py

@@ -532,13 +532,13 @@ It is likely that not all dependencies are installed. Make sure Cairo is install
             self.queue_after = None
         self.queue = None
 
-    def post_to_queue(self, callback):
+    def post_to_queue(self, callback, thread_safe=True):
         """Use this method to send a callback to TkinterWeb's thread-safety queue. The callback will be evaluated on the main thread.
         Use this when running Tkinter commands from within a thread. 
         If the queue is not running (i.e. threading is disabled), the callback will be evaluated immediately.
         
         New in version 4.9."""
-        if self.queue:
+        if thread_safe and self.queue:
             self.queue.put(callback)
         else:
             callback()
@@ -546,6 +546,7 @@ It is likely that not all dependencies are installed. Make sure Cairo is install
     def post_event(self, event, thread_safe=False):
         "Generate a virtual event."
         # NOTE: when thread_safe=True, this method is thread-safe
+        # Would you believe that?
         if not self.events_enabled:
             return
 
@@ -565,6 +566,7 @@ It is likely that not all dependencies are installed. Make sure Cairo is install
     def post_message(self, message, thread_safe=False):
         "Post a message."
         # NOTE: when thread_safe=True, this method is thread-safe
+        # Amazing stuff, eh?
         if not self.messages_enabled:
             return
         
@@ -722,20 +724,20 @@ It is likely that not all dependencies are installed. Make sure Cairo is install
         else:
             return utilities.cache_download(url, *args, insecure=self.insecure_https, cafile=self.ssl_cafile, headers=tuple(self.headers.items()), timeout=self.request_timeout)
     
-    def _thread_check(self, callback, *args, **kwargs):
+    def _thread_check(self, callback, url, *args, **kwargs):
         if not self.downloads_have_occured:
             self.downloads_have_occured = True
             
-        if not self.threading_enabled:
-            callback(*args, **kwargs)
+        if not self.threading_enabled or url.startswith("file://"):
+            callback(url, *args, **kwargs)
         elif len(self.active_threads) >= self.maximum_thread_count:
-            self.after(500, lambda callback=callback, args=args: self._thread_check(callback, *args, **kwargs))
+            self.after(500, lambda callback=callback, url=url, args=args: self._thread_check(callback, url, *args, **kwargs))
         else:
-            thread = utilities.StoppableThread(target=callback, args=args, kwargs=kwargs)
+            thread = utilities.StoppableThread(target=callback, args=(url, *args,), kwargs=kwargs)
             thread.start()
 
     def _begin_download(self):
-        # NOTE: this method is thread-safe and is designed to run in a thread
+        # NOTE: this runs in a thread
 
         thread = utilities.get_current_thread()
         self.active_threads.append(thread)
@@ -743,13 +745,13 @@ It is likely that not all dependencies are installed. Make sure Cairo is install
         return thread
 
     def _finish_download(self, thread):
-        # NOTE: this method is thread-safe and is designed to run in a thread
+        # NOTE: this runs in a thread
 
         self.active_threads.remove(thread)
         if len(self.active_threads) == 0:
-            self.post_to_queue(self._handle_load_finish)
+            self.post_to_queue(self._handle_load_finish, thread.is_subthread)
         else:
-            self.post_to_queue(lambda: self._handle_load_finish(False))
+            self.post_to_queue(lambda: self._handle_load_finish(False), thread.is_subthread)
 
     def _finish_resource_load(self, message, url, resource, success):
         # NOTE: this must run in the main thread

{tkinterweb-4.17.1 → tkinterweb-4.17.3}/tkinterweb/handlers.py

@@ -471,7 +471,7 @@ class ScriptManager(utilities.BaseManager):
         attributes = dict(zip(attributes[::2], attributes[1::2])) # Make attributes a dict
 
         if "src" in attributes:
-            self.html._thread_check(self.fetch_scripts, attributes, self.html.resolve_url(attributes["src"]))
+            self.html._thread_check(self.fetch_scripts, self.html.resolve_url(attributes["src"]), attributes)
         elif "defer" in attributes:
             self.pending_scripts.append((attributes, tag_contents))
         else:
@@ -479,27 +479,27 @@ class ScriptManager(utilities.BaseManager):
     
     def fetch_scripts(self, attributes, url=None, data=None):
         "Fetch and run scripts"
-        # NOTE: this method is thread-safe and is designed to run in a thread
+        # NOTE: this runs in a thread
 
         thread = self.html._begin_download()
 
         if url and thread.isrunning():
-            self.html.post_message(f"Fetching script from {utilities.shorten(url)}", True)
+            self.html.post_message(f"Fetching script from {utilities.shorten(url)}", thread.is_subthread)
             try:
                 data = self.html.download_url(url)[1]
             except Exception as error:
                 self.html.post_to_queue(lambda message=f"ERROR: could not load script {url}: {error}",
-                            url=url: self.html._finish_resource_load(message, url, "script", False))
+                            url=url: self.html._finish_resource_load(message, url, "script", False), thread.is_subthread)
 
         if data and thread.isrunning():
             if "defer" in attributes:
                 self.pending_scripts.append((attributes, data))
             else:
-                self.html.post_to_queue(lambda attributes=attributes, data=data: self.html.on_script(attributes, data))
+                self.html.post_to_queue(lambda attributes=attributes, data=data: self.html.on_script(attributes, data), thread.is_subthread)
                 
             if url:
                 self.html.post_to_queue(lambda message=f"Successfully loaded {utilities.shorten(url)}", 
-                            url=url: self.html._finish_resource_load(message, url, "script", True))
+                            url=url: self.html._finish_resource_load(message, url, "script", True), thread.is_subthread)
 
         self.html._finish_download(thread)
 
@@ -520,7 +520,7 @@ class StyleManager(utilities.BaseManager):
     
     def _on_style(self, attributes, tag_contents):
         "Handle <style> elements."
-        self.html._thread_check(self.fetch_styles, data=tag_contents)
+        self._finish_fetching_styles(data=tag_contents)
 
     def _on_link(self, node):
         "Handle <link> elements."
@@ -532,11 +532,9 @@ class StyleManager(utilities.BaseManager):
         except tk.TclError:
             return
 
-        if (
-            ("stylesheet" in rel)
-            and ("all" in media or "screen" in media)
-        ):
-            self.html._thread_check(self.fetch_styles, node, url)
+        if (("stylesheet" in rel)
+            and ("all" in media or "screen" in media)):
+            self.html._thread_check(self.fetch_styles, url, node)
             # Onload is fired if and when the stylesheet is parsed
         elif "icon" in rel:
             self.html.icon = url
@@ -550,8 +548,7 @@ class StyleManager(utilities.BaseManager):
         try:
             new_url = self.html.resolve_url(new_url, parent_url)
             self.html.post_message(f"Loading stylesheet from {utilities.shorten(new_url)}")
-
-            self.html._thread_check(self.fetch_styles, url=new_url)
+            self.html._thread_check(self.fetch_styles, new_url)
 
         except Exception as error:
             self.html.post_message(f"ERROR: could not load stylesheet {new_url}: {error}")
@@ -564,25 +561,25 @@ class StyleManager(utilities.BaseManager):
         newurl = f"url('{newurl}')"
         return newurl
     
-    def fetch_styles(self, node=None, url=None, data=None):
+    def fetch_styles(self, url=None, node=None):
         "Fetch stylesheets and parse the CSS code they contain"
-        # NOTE: this method is thread-safe and is designed to run in a thread
+        # NOTE: this runs in a thread
 
         thread = self.html._begin_download()
         if url and thread.isrunning():
-            self.html.post_message(f"Fetching stylesheet from {utilities.shorten(url)}", True)
+            self.html.post_message(f"Fetching stylesheet from {utilities.shorten(url)}", thread.is_subthread)
             try:
                 data = self.html.download_url(url)[1]
+                if data and thread.isrunning():
+                    self.html.post_to_queue(lambda node=node, url=url, data=data: self._finish_fetching_styles(node, url, data), thread.is_subthread)
+
             except Exception as error:
                 self.html.post_to_queue(lambda message=f"ERROR: could not load stylesheet {url}: {error}",
-                    url=url: self.html._finish_resource_load(message, url, "stylesheet", False))
-
-        if data and thread.isrunning():
-            self.html.post_to_queue(lambda node=node, url=url, data=data: self._finish_fetching_styles(node, url, data))
+                    url=url: self.html._finish_resource_load(message, url, "stylesheet", False), thread.is_subthread)
                         
         self.html._finish_download(thread)
 
-    def _finish_fetching_styles(self, node, url, data):
+    def _finish_fetching_styles(self, node=None, url=None, data=None):
         # NOTE: this must run in the main thread
 
         self.html._style_count += 1
@@ -648,7 +645,7 @@ class ImageManager(utilities.BaseManager):
         self.bad_paths.add(url)
         
         if not self.html.ignore_invalid_images:
-            image, data_is_image = self.check_images(utilities.BROKEN_IMAGE, name, url, "image/png")
+            image, data_is_image = self.check_images(utilities.BROKEN_IMAGE, name, url, "image/png", False)
             image = imageutils.data_to_image(image, name, "image/png", data_is_image)
 
             self.loaded_images.setdefault(name, set()).add(image)
@@ -695,29 +692,32 @@ class ImageManager(utilities.BaseManager):
 
     def fetch_images(self, url, name):
         "Fetch images and display them in the document."
-        # NOTE: this method is thread-safe and is designed to run in a thread
+        # NOTE: this runs in a thread
 
         thread = self.html._begin_download()
         if thread.isrunning():
-            self.html.post_message(f"Fetching image from {utilities.shorten(url)}", True)
+            self.html.post_message(f"Fetching image from {utilities.shorten(url)}", thread.is_subthread)
 
             if url == self.html.base_url:
-                self.html.post_to_queue(lambda url=url, name=name, error="ERROR: image url not specified": self._on_image_error(url, name, error))
+                self.html.post_to_queue(lambda url=url, name=name, error="ERROR: image url not specified": 
+                                        self._on_image_error(url, name, error), thread.is_subthread)
             else:
                 try:
                     url, data, filetype, code = self.html.download_url(url)
-                    data, data_is_image = self.check_images(data, name, url, filetype)                
+                    data, data_is_image = self.check_images(data, name, url, filetype, thread.is_subthread)                
                         
                     if thread.isrunning():
-                        self.html.post_to_queue(lambda data=data, name=name, url=url, filetype=filetype, data_is_image=data_is_image: self.finish_fetching_images(data, name, url, filetype, data_is_image))
+                        self.html.post_to_queue(lambda data=data, name=name, url=url, filetype=filetype, data_is_image=data_is_image: 
+                                                self.finish_fetching_images(data, name, url, filetype, data_is_image), thread.is_subthread)
                 except Exception as error:
-                    self.html.post_to_queue(lambda url=url, name=name, error=f"ERROR: could not load image {url}: {error}": self._on_image_error(url, name, error))
+                    self.html.post_to_queue(lambda url=url, name=name, error=f"ERROR: could not load image {url}: {error}": 
+                                            self._on_image_error(url, name, error), thread.is_subthread)
 
         self.html._finish_download(thread)
 
-    def check_images(self, data, name, url, filetype):
+    def check_images(self, data, name, url, filetype, thread_safe):
         "Invert images if needed and convert SVG images to PNGs."
-        # NOTE: this method is thread-safe and is designed to run in a thread
+        # NOTE: this runs in a thread
 
         data_is_image = False
         if "svg" in filetype:
@@ -732,7 +732,7 @@ class ImageManager(utilities.BaseManager):
                 data_is_image = True
             except (ImportError, ModuleNotFoundError,):
                 error = f"ERROR: could not invert the image {url}: PIL and PIL.ImageTk must be installed."
-                self.html.post_to_queue(lambda url=url, name=name, error=error: self._on_image_error(url, name, error))
+                self.html.post_to_queue(lambda url=url, name=name, error=error: self._on_image_error(url, name, error), thread_safe)
             
         return data, data_is_image
 
@@ -887,7 +887,7 @@ class ObjectManager(utilities.BaseManager):
                     return
 
                 self.html.post_message(f"Creating object from {utilities.shorten(data)}")
-                self.html._thread_check(self.fetch_objects, node, data)
+                self.html._thread_check(self.fetch_objects, data, node)
 
     def _on_object_value_change(self, node, attribute, value):
         if attribute == "data":
@@ -898,10 +898,11 @@ class ObjectManager(utilities.BaseManager):
                 # Force reset because it might contain widgets that are added internally
                 self.html.widget_manager.map_node(node, True)
 
-    def fetch_objects(self, node, url):
-        # NOTE: this method is thread-safe and is designed to run in a thread
+    def fetch_objects(self, url, node):
+        # NOTE: this runs in a thread
 
         thread = self.html._begin_download()
+
         if thread.isrunning():
             try:
                 url, data, filetype, code = self.html.download_url(url)
@@ -909,10 +910,12 @@ class ObjectManager(utilities.BaseManager):
                 if data and thread.isrunning():
                     if filetype.startswith("image"):
                         name = self.html.image_manager.allocate_image_name()
-                        data, data_is_image = self.html.image_manager.check_images(data, name, url, filetype)
-                        self.html.post_to_queue(lambda node=node, data=data, name=name, url=url, filetype=filetype, data_is_image=data_is_image: self._finish_fetching_image_objects(node, data, name, url, filetype, data_is_image))
+                        data, data_is_image = self.html.image_manager.check_images(data, name, url, filetype, thread.is_subthread)
+                        self.html.post_to_queue(lambda node=node, data=data, name=name, url=url, filetype=filetype, data_is_image=data_is_image: 
+                                                self._finish_fetching_image_objects(node, data, name, url, filetype, data_is_image), thread.is_subthread)
                     elif filetype == "text/html":
-                        self.html.post_to_queue(lambda node=node, data=data, name=name, url=url, filetype=filetype: self._finish_fetching_HTML_objects(node, data, name, url, filetype))
+                        self.html.post_to_queue(lambda node=node, data=data, url=url, filetype=filetype: 
+                                                self._finish_fetching_HTML_objects(node, data, url, filetype), thread.is_subthread)
 
             except Exception as error:
                 self.html.post_message(f"ERROR: could not load object element with data {url}: {error}", True)
@@ -920,9 +923,9 @@ class ObjectManager(utilities.BaseManager):
         self.html._finish_download(thread)
 
     def _finish_fetching_image_objects(self, node, data, name, url, filetype, data_is_image):
-        # NOTE: this must run in the main thread
+        # NOTE: this must run in the main thread 
 
-        image = self.html.image_manager.finish_fetching_images(None, data, name, filetype, url, data_is_image)
+        image = self.html.image_manager.finish_fetching_images(data, name, filetype, url, data_is_image)
         self.html.override_node_properties(node, "-tkhtml-replacement-image", f"url({image})")
         self.html.event_manager.post_element_event(node, "onload", None, utilities.ELEMENT_LOADED_EVENT)
 

{tkinterweb-4.17.1 → tkinterweb-4.17.3}/tkinterweb/htmlwidgets.py

@@ -437,7 +437,7 @@ class HtmlFrame(Frame):
             file_url = "file://" + str(file_url)
             self._current_url = file_url
             self._html.post_event(utilities.URL_CHANGED_EVENT)
-        self._continue_loading(file_url, decode=decode, force=force)
+        self.load_url(file_url, decode, force)
 
     def load_website(self, website_url, decode=None, force=False):
         """Convenience method to load a website.
@@ -482,7 +482,8 @@ class HtmlFrame(Frame):
 
         if self._thread_in_progress:
             self._thread_in_progress.stop()
-        if self._html.threading_enabled:
+            
+        if self._html.threading_enabled and not url.startswith("file://"):
             thread = utilities.StoppableThread(target=self._continue_loading, args=(
                 url,), kwargs={"decode": decode, "force": force, "thread_safe": True})
             self._thread_in_progress = thread
@@ -1131,6 +1132,9 @@ class HtmlFrame(Frame):
 
         if self.unshrink:
             if event.x and self._prev_configure != (event.width, event.x):
+                # if not self._html.using_tkhtml30:
+                #    self._html.configure(textwrap=False)
+                #    self.after(10, lambda: self._html.configure(textwrap=True))
                 self.after_idle(lambda: self._html.configure(
                     width=self.winfo_screenwidth(), 
                     height=event.height)
@@ -1183,7 +1187,7 @@ class HtmlFrame(Frame):
 
     def _continue_loading(self, url, data="", method="GET", decode=None, force=False, thread_safe=False):
         "Finish loading urls and handle URI fragments."
-        # NOTE: this method is thread-safe and is designed to run in a thread
+        # NOTE: this runs in a thread
 
         code = 404
         self._current_url = url
@@ -1219,6 +1223,8 @@ class HtmlFrame(Frame):
                     url = url.replace("view-source:", "")
                     parsed = urlparse(url)
 
+                thread = utilities.get_current_thread()
+
                 location = parsed.netloc if parsed.netloc else parsed.path
                 self._html.post_message(f"Connecting to {location}", True)
                 if self._html.insecure_https: self._html.post_message("WARNING: Using insecure HTTPS session", True)
@@ -1226,7 +1232,7 @@ class HtmlFrame(Frame):
                 newurl, data, filetype, code = self._html.download_url(url, data, method, decode)
                 self._html.post_message(f"Successfully connected to {location}", True)
 
-                if utilities.get_current_thread().isrunning():
+                if thread.isrunning():
                     if view_source:
                         newurl = "view-source:"+newurl
                         if self._current_url != newurl:
@@ -1246,7 +1252,7 @@ class HtmlFrame(Frame):
                     elif "image" in filetype:
                         name = self._html.image_manager.allocate_image_name()
                         if name:
-                            data, data_is_image = self._html.image_manager.check_images(data, name, url, filetype)
+                            data, data_is_image = self._html.image_manager.check_images(data, name, url, filetype, thread.is_subthread)
                             self._html.post_to_queue(lambda data=data, name=name, url=url, filetype=filetype, data_is_image=data_is_image: self._finish_loading_image(data, name, url, filetype, data_is_image))
                         else:
                             self.load_html(self._get_about_page("about:image", name), newurl, _thread_safe=thread_safe)
@@ -1271,7 +1277,7 @@ class HtmlFrame(Frame):
         if self._current_url != url:
             self._html.post_event(utilities.URL_CHANGED_EVENT)
         text = self._get_about_page("about:image", name)
-        self._html.image_manager.finish_fetching_images(None, data, name, url, filetype, data_is_image)
+        self._html.image_manager.finish_fetching_images(data, name, url, filetype, data_is_image)
         self.load_html(text, url)
     
     def _finish_loading_nothing(self):

{tkinterweb-4.17.1 → tkinterweb-4.17.3}/tkinterweb/utilities.py

@@ -31,7 +31,7 @@ __title__ = "TkinterWeb"
 __author__ = "Andrew Clarke"
 __copyright__ = "(c) 2021-2025 Andrew Clarke"
 __license__ = "MIT"
-__version__ = "4.17.1"
+__version__ = "4.17.3"
 
 
 ROOT_DIR = os.path.join(os.path.abspath(os.path.dirname(__file__)), "resources")
@@ -686,6 +686,8 @@ class StoppableThread(threading.Thread):
         self.daemon = True
         self.running = True
 
+        self.is_subthread = True
+
     def stop(self):
         self.running = False
 
@@ -697,6 +699,9 @@ class PlaceholderThread:
     """Fake StoppableThread. The only purpose of this is to provide fake methods that mirror the StoppableThread class.
     This means that if a download is running in the MainThread, the stop flags can still be set without raising errors, though they won't do anything."""
 
+    def __init__(self, *args, **kwargs):
+        self.is_subthread = False
+
     def stop(self):
         return
 
@@ -855,14 +860,11 @@ def download(url, data=None, method="GET", decode=None, insecure=False, cafile=N
         parsed = urlparse(url)
         url = urlunparse(parsed._replace(query=""))
 
-    thread = get_current_thread()
     url = url.replace(" ", "%20")
     if data and (method == "POST"):
         req = Request(url, data, headers=dict(headers))
     else:
         req = Request(url, headers=dict(headers))
-    if not thread.isrunning():
-        return None, url, "", ""
     
     with urlopen(req, context=context, timeout=timeout) as res:
         data = res.read()
@@ -893,10 +895,8 @@ def download(url, data=None, method="GET", decode=None, insecure=False, cafile=N
                 data = data.decode(decode, errors="ignore")
             else:
                 data = data.decode(errors="ignore")
-        if not thread.isrunning():
-            return url, None, "", code
-        else:
-            return url, data, filetype, code
+
+        return url, data, filetype, code
 
 
 @lru_cache()
@@ -915,6 +915,7 @@ def shorten(string):
 def get_current_thread():
     "Return the currently running thread"
     thread = threading.current_thread()
+    # Py 3.4+: Use is threading.main_thread()
     if thread.name == "MainThread":
         thread = PlaceholderThread()
     return thread

{tkinterweb-4.17.1 → tkinterweb-4.17.3/tkinterweb.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tkinterweb
-Version: 4.17.1
+Version: 4.17.3
 Summary: HTML/CSS viewer, editor, and app builder for Tkinter
 Home-page: https://github.com/Andereoo/TkinterWeb
 License: MIT