radnn 0.0.7.3__py3-none-any.whl → 0.0.9__py3-none-any.whl

radnn/system/files/textfile.py

@@ -29,6 +29,7 @@
 # .......................................................................................
 import os
 import numpy as np
+import locale
 from .fileobject import FileObject
 
 
@@ -37,8 +38,33 @@ class TextFile(FileObject):
   def __init__(self, filename, parent_folder=None, error_template=None, is_verbose=False):
     super(TextFile, self).__init__(filename, parent_folder, error_template)
     self.is_verbose = is_verbose
+
+  # ----------------------------------------------------------------------------------
+  def load(self, filename=None, encoding=None):
+    filename = self._useFileName(filename)
+
+    sText = None
+    if os.path.isfile(filename):
+      oEncodingToTry = ["utf-8", "utf-16", "latin1", "ascii"]  # Add more if needed
+      if encoding is None:
+        bIsLoaded = False
+        for sEnc in oEncodingToTry:
+          try:
+            with open(filename, "r", encoding=sEnc) as oFile:
+              sText = oFile.read()
+            bIsLoaded = True
+            break
+          except (UnicodeDecodeError, UnicodeError):
+            continue
+        if not bIsLoaded:
+          raise ValueError("Unsupported encoding")
+      else:
+        with open(filename, "r", encoding=encoding) as oFile:
+          sText = oFile.read()
+
+    return sText
   # --------------------------------------------------------------------------------------------------------------------
-  def save(self, text_obj, filename=None):
+  def save(self, text_obj, filename=None, encoding="utf-8"):
     sFilename = self._useFileName(filename)
 
     """
@@ -48,9 +74,6 @@ class TextFile(FileObject):
         p_sFileName        : Full path to the text file
         p_sText            : Text to write
     """
-    if (self.parent_folder is not None):
-      sFilename = os.path.join(self.parent_folder, sFilename)
-
     if self.is_verbose:
       print("  {.} Saving text to %s" % sFilename)
 
@@ -61,12 +84,12 @@ class TextFile(FileObject):
       bIsIterable = text_obj.dtype = str
 
     if bIsIterable:
-      with open(sFilename, "w") as oFile:
+      with open(sFilename, "w", encoding=encoding) as oFile:
         for sLine in text_obj:
           print(sLine, file=oFile)
         oFile.close()
     else:
-      with open(sFilename, "w") as oFile:
+      with open(sFilename, "w", encoding=encoding) as oFile:
         print(text_obj, file=oFile)
         oFile.close()
     return True

radnn/system/filestore.py

@@ -35,7 +35,7 @@ if (sys.version_info.major == 3) and (sys.version_info.minor <= 7):
   import pickle5 as pickle
 else:
   import pickle
-
+from radnn.system.files import FileList
 from radnn.system.files import JSONFile
 from radnn.system.files import PickleFile
 from radnn.system.files import TextFile
@@ -53,6 +53,7 @@ class FileStore(object):
   def __init__(self, base_folder, is_verbose=False, must_exist=False):
     #.......................... |  Instance Attributes | ............................
     self.base_folder = base_folder
+    self.absolute_path = os.path.abspath(base_folder)
     if not os.path.exists(self.base_folder):
       if must_exist:
         raise Exception(f"File store folder {self.base_folder} does not exist.")
@@ -98,7 +99,7 @@ class FileStore(object):
     return self.folder(subfolder_name)
   # --------------------------------------------------------------------------------------------------------
   def folder(self, folder_name):
-    sFolder = os.path.join(self.base_folder, folder_name)
+    sFolder = os.path.join(self.absolute_path, folder_name)
     if not os.path.exists(sFolder):
       os.makedirs(sFolder)
 
@@ -110,13 +111,19 @@ class FileStore(object):
         file_name += "." + file_ext
       else:
         file_name += file_ext
-    return os.path.join(self.base_folder, file_name)
+    return os.path.join(self.absolute_path, file_name)
   # --------------------------------------------------------------------------------------------------------
   def entries(self):
     return os.listdir(self.base_folder)
   # --------------------------------------------------------------------------------------------------------
-  def list_files(self, file_matching_pattern, is_full_path=True, is_removing_extension=False, sort_filename_key=None):
-    sEntries = glob.glob1(self.base_folder, file_matching_pattern)
+  def _ls(self, file_matching_pattern, is_removing_extension, sort_filename_key):
+    if ";" in file_matching_pattern:
+      sEntries = []
+      for sExt in file_matching_pattern.split(";"):
+        sEntries += glob.glob1(self.base_folder, sExt.strip())
+    else:
+      sEntries = glob.glob1(self.base_folder, file_matching_pattern)
+
     if is_removing_extension:
       oFileNamesOnly = []
       for sEntry in sEntries:
@@ -124,15 +131,24 @@ class FileStore(object):
         oFileNamesOnly.append(sFileNameOnly)
       sEntries = sorted(oFileNamesOnly, key=sort_filename_key)
 
+    return sEntries
+  # --------------------------------------------------------------------------------------------------------
+  def list_files(self, file_matching_pattern, is_full_path=True, is_removing_extension=False, sort_filename_key=None):
+    sEntries = self._ls(file_matching_pattern, is_removing_extension, sort_filename_key)
     if is_full_path:
       oResult = [os.path.join(self.base_folder, x) for x in sEntries]
     else:
       oResult = [x for x in sEntries]
-
     return oResult
   # --------------------------------------------------------------------------------------------------------
-  @property
-  def lis_folders(self, is_full_path=True):
+  def filelist(self, file_matching_pattern, is_removing_extension=False, sort_filename_key=None):
+    sEntries = self._ls(file_matching_pattern, is_removing_extension, sort_filename_key)
+    oFileList = FileList(self.base_folder)
+    for x in sEntries:
+      oFileList.append(x)
+    return oFileList
+  # --------------------------------------------------------------------------------------------------------
+  def list_folders(self, is_full_path=True):
     sResult = []
     for sFolder in os.listdir(self.base_folder):
       sFullPath = os.path.join(self.base_folder, sFolder)
@@ -163,10 +179,10 @@ class FileStore(object):
     pass
   # ----------------------------------------------------------------------------------
   def __repr__(self)->str:
-    return self.base_folder
+    return self.absolute_path
   # --------------------------------------------------------------------------------------------------------
   def __str__(self)->str:
-    return self.base_folder
+    return self.absolute_path
   # --------------------------------------------------------------------------------------------------------
 # ======================================================================================================================
 

radnn/system/filesystem.py

@@ -35,7 +35,7 @@ from radnn.system.files import JSONFile
 # =======================================================================================================================
 class FileSystem(object):
   # --------------------------------------------------------------------------------------------------------
-  def __init__(self, config_folder="MLConfig", model_folder="MLModels", dataset_folder="MLData", must_exist=False, setup_filename="*auto*", is_custom_setup=False):
+  def __init__(self, config_folder="MLConfig", model_folder="MLModels", dataset_folder="MLData", must_exist=False, setup_filename="*auto*", is_custom_setup=True):
     '''
     Initializes the file system settings for an experiment
     :param config_folder: The folder that contains the experiment hyperparameter files.

radnn/system/hosts/windows_host.py

@@ -28,6 +28,7 @@
 
 # .......................................................................................
 import win32api
+import ctypes
 class WindowsHost(object):
   # --------------------------------------------------------------------------------------------------------------------
   @classmethod
@@ -66,4 +67,13 @@ class WindowsHost(object):
         str_info = u'\\StringFileInfo\\%04X%04X\\%s' % (sLanguageCode, sCodePage, sVersionString)
         dInfo[sVersionString] = repr(win32api.GetFileVersionInfo(dll_filename, str_info))
     return dInfo
+  # --------------------------------------------------------------------------------------------------------------------
+  @classmethod
+  def set_windows_sleep_resolution(cls, msecs=1):
+    """
+    Requests a minimum resolution for periodic timers. This increases accuracy
+    for the waiting interval of the time.sleep function
+    """
+    oWinMM = ctypes.WinDLL('oWinMM')
+    oWinMM.timeBeginPeriod(msecs)
   # --------------------------------------------------------------------------------------------------------------------

radnn/system/threads/__init__.py

@@ -0,0 +1,5 @@
+from .thread_context   import ThreadContext, ThreadEx
+from .thread_worker   import ThreadWorker
+from .semaphore_lock   import SemaphoreLock
+from .thread_safe_queue  import ThreadSafeQueue
+from .thread_safe_string_collection import ThreadSafeQueue

radnn/system/threads/semaphore_lock.py

@@ -0,0 +1,58 @@
+# ======================================================================================
+#
+#     Rapid Deep Neural Networks
+#
+#     Licensed under the MIT License
+# ______________________________________________________________________________________
+# ......................................................................................
+
+# Copyright (c) 2018-2025 Pantelis I. Kaplanoglou
+
+# 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.
+
+# .......................................................................................
+from threading import BoundedSemaphore
+
+#=======================================================================================================================
+class SemaphoreLock(BoundedSemaphore):
+    # ------------------------------------------------------------------------------------------------------------------
+    def __init__(self, value=1):
+        super(SemaphoreLock, self).__init__(value)
+    # ------------------------------------------------------------------------------------------------------------------
+    def lock(self, blocking=True, timeout=None):
+        self.acquire(blocking, timeout)
+    # ------------------------------------------------------------------------------------------------------------------
+    def unlock(self):
+        self.release()
+    # ------------------------------------------------------------------------------------------------------------------
+    # //TODO: Not working, check if this can be fixed
+    '''
+    def __enter__(self):
+        self.Lock()
+        return self
+    
+    def __exit__(self, exception_type, exception_val, trace):
+        try:
+            self.Unlock()
+        except:
+            print("Could not unlock semaphore")
+            return True     
+    '''
+    # ------------------------------------------------------------------------------------------------------------------
+#=======================================================================================================================

radnn/system/threads/thread_context.py

@@ -0,0 +1,175 @@
+# ======================================================================================
+#
+#     Rapid Deep Neural Networks
+#
+#     Licensed under the MIT License
+# ______________________________________________________________________________________
+# ......................................................................................
+
+# Copyright (c) 2018-2025 Pantelis I. Kaplanoglou
+
+# 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.
+
+# .......................................................................................
+import time
+from threading import Thread, Event, get_ident
+from datetime import datetime
+
+
+#=======================================================================================================================
+class ThreadEx(Thread):
+    # ------------------------------------------------------------------------------------------------------------------
+    def __init__(self,target=None, name=None, args=(), kwargs=None):
+        #//TODO: delegate target, args and kwargs properly
+        super(ThreadEx, self).__init__(target=target, name=name, args=args, kwargs=kwargs)
+        self._stop_event = Event()
+    # ------------------------------------------------------------------------------------------------------------------
+    def stop(self):
+        self._stop_event.set()
+    # ------------------------------------------------------------------------------------------------------------------
+    @property
+    def is_stopped(self):
+        return self._stop_event.is_set()
+    # ------------------------------------------------------------------------------------------------------------------
+#=======================================================================================================================
+    
+    
+    
+    
+
+
+
+    
+    
+#=======================================================================================================================
+class ThreadContext(object):
+    __NEXT_ID = 0
+
+    # ------------------------------------------------------------------------------------------------------------------
+    def __init__(self, name=None, is_daemon_thread=True, verbose_level=1):
+        #........................... |  Instance Attributes | ...........................
+        type(self).__NEXT_ID += 1
+        if name is None:
+            self.name = str(type(self).__NEXT_ID)
+        else:
+            self.name           = f"{name}{str(type(self).__NEXT_ID)}"
+        self.thread_id      = None
+        self.verbose_level = verbose_level
+
+        #// Settings \\
+        self.is_daemon_thread     = is_daemon_thread
+        self.join_timeout        = 5 #secs
+        
+        # // Control Variables \\ 
+        self.must_continue       = False
+        self.has_finished  = False
+        self.has_started   = False
+
+        # // Agregated Objects \\
+        self.thread_handle       = None
+        self.thread_args         = None
+        self.on_after_finish_handler = None
+        self.run_once_func  = None
+        #................................................................................
+    # ------------------------------------------------------------------------------------------------------------------
+    def sleep(self, interval_in_msecs):
+        time.sleep(interval_in_msecs / 1000.0)
+    # ------------------------------------------------------------------------------------------------------------------
+    def _thread_start(self, args):
+        self.thread_id   = get_ident()
+        self.thread_args = args
+        self.has_started = True
+
+        if self.verbose_level > 0:
+            print(f"{self} is starting with arguments:", args)
+
+        self.has_finished = False
+        try:
+            if self.run_once_func is None:
+                self.loop()
+            else:            
+                self.run_once_func(args)
+        finally:
+            self.has_finished = True
+    # ------------------------------------------------------------------------------------------------------------------
+    def _thread_finish(self):
+        while not self.has_finished:
+            pass
+
+        # Callback after finishing
+        if self.on_after_finish_handler is not None:
+            self.on_after_finish_handler()
+
+        # Signal the thread to stop via the event
+        self.thread_handle.stop()
+
+        # Wait for the thread to finish
+        if self.verbose_level > 1:
+            print(f"{self} joining...")
+
+        self.thread_handle.join(self.join_timeout)
+
+        if self.verbose_level > 1:
+            nTimeDelta = datetime.now() - self._stop_action_start
+            print(f"{self} joined after {(nTimeDelta.microseconds / 1000):.3f} msecs")
+    # ------------------------------------------------------------------------------------------------------------------
+    def start(self, args=None):
+        self.must_continue = True
+
+        self.thread_handle = ThreadEx(target=self._thread_start, args=(), kwargs={"args": args})
+        self.thread_handle.setDaemon(True)
+        self.thread_handle.start()
+    # ------------------------------------------------------------------------------------------------------------------
+    def resume(self, args=None):
+        if not self.has_started:
+            self.start(args)
+    # ------------------------------------------------------------------------------------------------------------------
+    def stop(self):
+        self._stop_action_start = datetime.now()
+        if self.verbose_level > 0:
+            print(f"{self} is stopping ...")
+        # Break the loop and wait for the method to exit
+        self.must_continue = False
+        self._thread_finish()
+    # ------------------------------------------------------------------------------------------------------------------
+    def terminate(self):
+        self.stop()
+    # ------------------------------------------------------------------------------------------------------------------
+    def loop(self):
+        pass
+    # ------------------------------------------------------------------------------------------------------------------
+    def __str__(self):
+        return f"{self.name} ({self.thread_id})"
+    # ------------------------------------------------------------------------------------------------------------------
+    def __repr__(self):
+        return self.__str__()
+    # ------------------------------------------------------------------------------------------------------------------
+#=======================================================================================================================
+
+
+
+
+
+
+
+
+
+
+
+

radnn/system/threads/thread_safe_queue.py

@@ -0,0 +1,163 @@
+# ======================================================================================
+#
+#     Rapid Deep Neural Networks
+#
+#     Licensed under the MIT License
+# ______________________________________________________________________________________
+# ......................................................................................
+
+# Copyright (c) 2018-2025 Pantelis I. Kaplanoglou
+
+# 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.
+
+# .......................................................................................
+from .semaphore_lock import SemaphoreLock
+
+    
+
+class ThreadSafeQueue(object):
+    #-------------------------------------------------------------------------------------------------------------------
+    def __init__(self, name="Queue", max_queued_items=None):
+        #........................... |  Instance Attributes | ...........................
+        self.name = name
+        self.queue=[]
+                
+        # // Settings \\
+        self.max_queued_items = max_queued_items
+        self.can_delete              = True
+        
+        # // Control Params \\
+        self.is_queue_locked = False
+        
+        # // Composites \\
+        self.update_lock = SemaphoreLock()
+        #................................................................................
+
+    # -------------------------------------------------------------------------------------------------------------------
+    @property
+    def count(self):
+        return len(self.queue)
+
+    # -------------------------------------------------------------------------------------------------------------------
+    @property
+    def is_empty(self):
+        bResult = (len(self.queue) == 0)
+
+        return bResult
+    #-------------------------------------------------------------------------------------------------------------------
+    def push(self, value):
+        self.update_lock.lock()
+        try:
+            if self.max_queued_items is None:
+                bCanAppend = True
+            else: 
+                bCanAppend = len(self.queue) < self.max_queued_items
+            
+            if bCanAppend:     
+                self.queue.append(value)
+        finally:
+            self.update_lock.unlock()
+    #-------------------------------------------------------------------------------------------------------------------
+    def pop(self, index=0):
+        nValue = None        
+        if self.can_delete:
+            self.update_lock.lock()
+            try:
+                bMustPop = len(self.queue) > 0
+                if bMustPop:
+                    if index == -1:
+                        index = len(self.queue) - 1
+                    nValue = self.queue.pop(index)
+            finally:
+                self.update_lock.unlock()
+            
+        return nValue
+    #-------------------------------------------------------------------------------------------------------------------
+    def clear(self):
+        self.update_lock.lock()
+        try:
+            self.queue = []
+        finally:
+            self.update_lock.unlock()
+    #-------------------------------------------------------------------------------------------------------------------
+    '''
+    def pop_ex(self, index=0):
+        nValue,nRemainingItemCount = [None,None]
+        if self.can_delete:
+            self.update_lock.Lock()
+            try:
+                nRemainingItemCount = len(self.queue)
+                bMustPop = nRemainingItemCount > 0 
+                if bMustPop:
+                    if index == -1:
+                        index = len(self.queue) - 1
+                    nValue = self.queue.pop(index)
+                    nRemainingItemCount = len(self.queue)
+            finally:
+                self.update_lock.UnLock()
+            
+        return nValue, nRemainingItemCount
+    '''
+    #-------------------------------------------------------------------------------------------------------------------
+    def push_ex(self, message):
+        while self.is_queue_locked:
+            pass
+        
+        if self.max_queued_items is None:
+            bCanAppend = True
+        else: 
+            bCanAppend = len(self.queue) < self.max_queued_items
+            
+        if not bCanAppend:
+            return  
+        
+        self.is_queue_locked = True
+        try:
+            self.queue.append(message)
+        finally:
+            self.is_queue_locked = False
+    #-------------------------------------------------------------------------------------------------------------------
+    def pop_ex(self):
+        sMessage = None
+        if self.can_delete:
+            while self.is_queue_locked:
+                pass
+                
+            self.is_queue_locked = True
+            try:
+                if len(self.queue) > 0:
+                    sMessage = self.queue.pop(0)
+            finally:
+                self.is_queue_locked = False
+
+        return sMessage
+    #-------------------------------------------------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+

radnn/system/threads/thread_safe_string_collection.py

@@ -0,0 +1,66 @@
+from .thread_safe_queue import ThreadSafeQueue
+
+class StringCollectionThreadSafe(ThreadSafeQueue):
+  # -------------------------------------------------------------------------------------------------------------------
+  def __init__(self, filename=None, name="Text"):
+    super(StringCollectionThreadSafe, self).__init__(name)
+
+    self.filename = filename
+    self.__count  = 0
+    self.__index  = 0
+  # -------------------------------------------------------------------------------------------------------------------
+  def append(self, text):
+    self.push(text)
+  # -------------------------------------------------------------------------------------------------------------------
+  def print(self, text, *args):
+    if args is None:
+      self.push(text)
+    else:
+      self.push(text + " " + " ".join(map(str, args)))
+  # -------------------------------------------------------------------------------------------------------------------
+  def flush(self):
+    if self.CanDelete:
+      with open(self.filename, "a") as oFile:
+        for sLine in self.queue:
+          print(sLine, file=oFile)
+      self.clear()
+  # -------------------------------------------------------------------------------------------------------------------
+  def display_and_flush(self):
+    if self.CanDelete:
+      if self.filename is None:
+        for sLine in self.queue:
+          print(sLine)
+      else:
+        with open(self.filename, "a") as oFile:
+          for sLine in self.queue:
+            print(sLine, file=oFile)
+      self.clear()
+  # -------------------------------------------------------------------------------------------------------------------
+  def __iter__(self):
+    self.update_lock.Lock()
+    try:
+      self.__index  = 0
+      self.__count = len(self.queue)
+      self.CanDelete = False
+    finally:
+      self.update_lock.UnLock()
+
+    return self
+  # -------------------------------------------------------------------------------------------------------------------
+  def __next__(self):
+    if self.__index < self.__count:
+      oResult = self.queue[self.__index]
+      self.__index += 1
+      return oResult
+    else:
+      self.CanDelete = True
+      raise StopIteration()
+  # -------------------------------------------------------------------------------------------------------------------
+
+
+
+
+
+
+
+