radnn 0.0.8__py3-none-any.whl → 0.1.0__py3-none-any.whl

radnn/system/files/textfile.py

@@ -6,7 +6,7 @@
 # ______________________________________________________________________________________
 # ......................................................................................
 
-# Copyright (c) 2018-2025 Pantelis I. Kaplanoglou
+# Copyright (c) 2018-2026 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
@@ -38,15 +38,50 @@ 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
+    self._opened_filename = None
+    self._encoding = None
+  # ----------------------------------------------------------------------------------
+  def open(self, filename, encoding=None):
+    self._opened_filename = filename
+    self._encoding = encoding
+    return self
 
   # ----------------------------------------------------------------------------------
+  def close(self):
+    self._opened_filename = None
+    self._encoding = None
+  # ----------------------------------------------------------------------------------
+  @property
+  def rows(self):
+    sFileName = self._useFileName(self._opened_filename)
+
+    if os.path.isfile(sFileName):
+      if self._encoding is not None:
+        oEncodingToTry = [self._encoding]
+      else:
+        oEncodingToTry = ["utf-8", "utf-16", "latin1", "ascii"]  # Add more if needed
+      bIsLoaded = False
+      for sEnc in oEncodingToTry:
+        try:
+          with open(sFileName, "r", encoding=sEnc) as oFile:
+            yield oFile.read()
+          bIsLoaded = True
+          break
+        except (UnicodeDecodeError, UnicodeError):
+          continue
+      if not bIsLoaded:
+        raise ValueError("Unsupported encoding")
+  # ----------------------------------------------------------------------------------
   def load(self, filename=None, encoding=None):
     filename = self._useFileName(filename)
 
-    oEncodingToTry = ["utf-8", "utf-16", "latin1", "ascii"]  # Add more if needed
-
     sText = None
-    if encoding is None:
+    if os.path.isfile(filename):
+      if self._encoding is not None:
+        oEncodingToTry = [encoding]
+      else:
+        oEncodingToTry = ["utf-8", "utf-16", "latin1", "ascii"]  # Add more if needed
+
       bIsLoaded = False
       for sEnc in oEncodingToTry:
         try:
@@ -58,9 +93,6 @@ class TextFile(FileObject):
           continue
       if not bIsLoaded:
         raise ValueError("Unsupported encoding")
-    else:
-      with open(filename, "r", encoding=encoding) as oFile:
-        sText = oFile.read()
 
     return sText
   # --------------------------------------------------------------------------------------------------------------------
@@ -74,9 +106,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)
 

radnn/system/files/zipfile.py

@@ -0,0 +1,96 @@
+# ======================================================================================
+#
+#     Rapid Deep Neural Networks
+#
+#     Licensed under the MIT License
+# ______________________________________________________________________________________
+# ......................................................................................
+
+# Copyright (c) 2018-2026 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 os
+import zipfile
+from .fileobject import FileObject
+
+class ZipFile(FileObject):
+  # --------------------------------------------------------------------------------------------------------------------
+  def __init__(self, filename, parent_folder=None, error_template=None, is_verbose=False):
+    super().__init__(filename, parent_folder, error_template)
+    self.is_verbose = is_verbose
+    self._opened_filename = None
+    self._encoding = None
+  
+  # --------------------------------------------------------------------------------------------------------
+  def save(self, source_path, must_replace=True):
+    """
+    Compress a folder (including subfolders) into a .zip file.
+
+    Args:
+        output_zip_path (str): The path where the .zip file will be saved.
+    """
+    dest_zip_file = os.path.join(self.parent_folder, self.filename)
+    if must_replace:
+      if os.path.exists(dest_zip_file):
+        os.remove(dest_zip_file)
+      
+      # Create the zip file
+      with zipfile.ZipFile(dest_zip_file, 'w', zipfile.ZIP_DEFLATED) as zipf:
+        for root, dirs, files in os.walk(source_path):
+          for file in files:
+            abs_path = os.path.join(root, file)
+            # Get relative path for proper folder structure inside zip
+            rel_path = os.path.relpath(abs_path, start=source_path)
+            zipf.write(abs_path, rel_path)
+  
+  # --------------------------------------------------------------------------------------------------------
+  def extract(self, dest_path, has_progress_bar=True, is_verbose=True):
+    """
+    Extracts a .zip file into the specified folder.
+
+    Args:
+        zip_filename (str): Path to the .zip file.
+        destination_folder (str): Folder where the contents should be extracted.
+    """
+    source_zip_file = os.path.join(self.parent_folder, self.filename)
+    
+    # Ensure the zip file exists
+    if not os.path.isfile(source_zip_file):
+      raise FileNotFoundError(f"Zip file not found: {source_zip_file}")
+    
+    # Ensure destination directory exists
+    os.makedirs(dest_path, exist_ok=True)
+    
+    # Extract the zip file
+    with zipfile.ZipFile(source_zip_file, 'r') as zip_ref:
+      file_list = zip_ref.infolist()
+      total_files = len(file_list)
+      
+      oIterator = file_list
+      if is_verbose and has_progress_bar:
+        from tqdm import tqdm
+        oIterator = tqdm(file_list, total=total_files, desc="Extracting", unit="file")
+      
+      for file_info in oIterator:
+        zip_ref.extract(file_info, dest_path)
+    if is_verbose:
+      print(f" |_ Extracted '{source_zip_file}' to '{dest_path}'")
+  # ----------------------------------------------------------------------------------

radnn/system/filestore.py

@@ -6,7 +6,7 @@
 # ______________________________________________________________________________________
 # ......................................................................................
 
-# Copyright (c) 2018-2025 Pantelis I. Kaplanoglou
+# Copyright (c) 2018-2026 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
@@ -31,6 +31,9 @@ import os
 import shutil
 import glob
 import sys
+import zipfile
+from typing import Any, Type
+import importlib.util
 if (sys.version_info.major == 3) and (sys.version_info.minor <= 7):
   import pickle5 as pickle
 else:
@@ -40,11 +43,13 @@ from radnn.system.files import JSONFile
 from radnn.system.files import PickleFile
 from radnn.system.files import TextFile
 from radnn.system.files import CSVFile
-from radnn.ml_system import mlsys
-if mlsys.is_opencv_installed:
-  from radnn.system.files.imgfile import PNGFile
+from radnn.system.files import ZipFile
+from radnn.errors import *
 
 
+_is_opencv_installed = importlib.util.find_spec("cv2") is not None
+if _is_opencv_installed:
+  from radnn.system.files.imgfile import PNGFile
 
 
 # =======================================================================================================================
@@ -60,13 +65,13 @@ class FileStore(object):
       else:
         os.makedirs(self.base_folder)
 
-    self.is_verbose  = is_verbose
-    self.json = JSONFile(None, parent_folder=self.base_folder)
-    self.obj = PickleFile(None, parent_folder=self.base_folder)
-    self.text = TextFile(None, parent_folder=self.base_folder)
-    self.csv = CSVFile(None, parent_folder=self.base_folder)
-    if mlsys.is_opencv_installed:
-      self.img = PNGFile(None, parent_folder=base_folder)
+    self.is_verbose = is_verbose
+    self.json: JSONFile = JSONFile(None, parent_folder=self.base_folder)
+    self.obj: PickleFile = PickleFile(None, parent_folder=self.base_folder)
+    self.text: TextFile = TextFile(None, parent_folder=self.base_folder)
+    self.csv: CSVFile = CSVFile(None, parent_folder=self.base_folder)
+    if _is_opencv_installed:
+      self.img: PNGFile = PNGFile(None, parent_folder=base_folder)
     self.donefs = None
     #................................................................................
   # --------------------------------------------------------------------------------------------------------
@@ -113,6 +118,48 @@ class FileStore(object):
         file_name += file_ext
     return os.path.join(self.absolute_path, file_name)
   # --------------------------------------------------------------------------------------------------------
+  def get_file_kind(self, file_name: str):
+    name, ext = os.path.splitext(file_name)
+    ext = ext.lower()
+    if ext == ".pkl":
+      return "obj"
+    elif ext == ".txt":
+      return "text"
+    elif ext == ".json":
+      return "json"
+    elif ext == ".png":
+      return "img"
+    elif ext == ".zip":
+      return "zip"
+    else:
+      return "?"
+  # --------------------------------------------------------------------------------------------------------
+  def artifact(self, file_name: str, kind: str | None = None) -> Any:
+    if kind is None:
+      kind = self.get_file_kind(file_name)
+      
+    oFile = None
+    if kind == "obj":
+      oFile = PickleFile(file_name, parent_folder=self.base_folder)
+    elif kind == "text":
+      oFile = TextFile(file_name, parent_folder=self.base_folder)
+    elif kind == "json":
+      oFile = JSONFile(file_name, parent_folder=self.base_folder)
+    elif kind == "csv":
+      oFile = CSVFile(file_name, parent_folder=self.base_folder)
+    elif kind == "img":
+      if _is_opencv_installed:
+        oFile = PNGFile(file_name, parent_folder=self.base_folder)
+      else:
+        print("Open CV is not installed")  #TODO: Support PIL
+    elif kind == "zip":
+      oFile = ZipFile(file_name, parent_folder=self.base_folder)
+      
+    if oFile is None:
+      raise Exception(FILESTORE_DATAFILE_KIND_NOT_SUPPORTED % str(kind))
+    
+    return oFile
+  # --------------------------------------------------------------------------------------------------------
   def entries(self):
     return os.listdir(self.base_folder)
   # --------------------------------------------------------------------------------------------------------
@@ -173,6 +220,95 @@ class FileStore(object):
     if is_full_path and (sFileName is not None):
       sFileName = os.path.join(self.donefs.base_folder, sFileName)
     return sFileName
+  
+  # --------------------------------------------------------------------------------------------------------
+  def move_to(self, source_files: str | list, fs):
+    oFiles = source_files
+    if isinstance(source_files, str):
+      # A pattern is given
+      if "*" in source_files:
+        oFiles = self.list_files(source_files, is_full_path=False)
+      else:
+        oFiles = [source_files]
+    oDestFiles = []
+    for sFile in oFiles:
+      sDestFile =  os.path.join(fs.absolute_path, sFile)
+      oDestFiles.append(sDestFile)
+      shutil.move(os.path.join(self.absolute_path, sFile),sDestFile)
+    return oDestFiles
+  
+  # --------------------------------------------------------------------------------------------------------
+  def copy_to(self, source_files: str | list, fs):
+    oFiles = source_files
+    if isinstance(source_files, str):
+      # A pattern is given
+      if "*" in source_files:
+        oFiles = self.list_files(source_files, is_full_path=False)
+      else:
+        oFiles = [source_files]
+    oDestFiles = []
+    for sFile in oFiles:
+      sDestFile =  os.path.join(fs.absolute_path, sFile)
+      oDestFiles.append(sDestFile)
+      shutil.copy(os.path.join(self.absolute_path, sFile),sDestFile)
+    return oDestFiles
+  
+  # --------------------------------------------------------------------------------------------------------
+  def remove_existing(self, filename):
+    sFileName = self.file(filename)
+    if os.path.exists(sFileName):
+      os.remove(sFileName)
+  # --------------------------------------------------------------------------------------------------------
+  def compress_to_zip(self, output_zip_path, must_replace=True):
+    """
+    Compress a folder (including subfolders) into a .zip file.
+
+    Args:
+        output_zip_path (str): The path where the .zip file will be saved.
+    """
+    if must_replace:
+      if os.path.exists(output_zip_path):
+        os.remove(output_zip_path)
+    
+      # Create the zip file
+      with zipfile.ZipFile(output_zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+        for root, dirs, files in os.walk(self.absolute_path):
+          for file in files:
+            abs_path = os.path.join(root, file)
+            # Get relative path for proper folder structure inside zip
+            rel_path = os.path.relpath(abs_path, start=self.absolute_path)
+            zipf.write(abs_path, rel_path)
+  # --------------------------------------------------------------------------------------------------------
+  def extract_from_zip(self, zip_filename, has_progress_bar=True):
+    """
+    Extracts a .zip file into the specified folder.
+
+    Args:
+        zip_filename (str): Path to the .zip file.
+        destination_folder (str): Folder where the contents should be extracted.
+    """
+    # Ensure the zip file exists
+    if not os.path.isfile(zip_filename):
+      raise FileNotFoundError(f"Zip file not found: {zip_filename}")
+    
+    sDestFolder = self.absolute_path
+    # Ensure destination directory exists
+    os.makedirs(sDestFolder, exist_ok=True)
+    
+    # Extract the zip file
+    with zipfile.ZipFile(zip_filename, 'r') as zip_ref:
+      file_list = zip_ref.infolist()
+      total_files = len(file_list)
+      
+      oIterator = file_list
+      if has_progress_bar:
+        from tqdm import tqdm
+        oIterator = tqdm(file_list, total=total_files, desc="Extracting", unit="file")
+      
+      for file_info in oIterator:
+        zip_ref.extract(file_info, sDestFolder)
+    
+    print(f" |_ Extracted '{zip_filename}' to '{sDestFolder}'")
   # --------------------------------------------------------------------------------------------------------
   def purge_done(self):
     #//TODO: Remove from the current filestore all files that are moved into the .done filestore
@@ -187,42 +323,6 @@ class FileStore(object):
 # ======================================================================================================================
 
 
-# .................... Tests ....................
-if __name__ == "__main__":
-  VISUALIZE = False
-  import numpy as np
-
-  # Lazy initialize a file store folder
-  oFS = FileStore("C:\MLData\SomeDataSet")
-
-  # Serialize data into a sub folder
-  oData = np.asarray([1, 2, 3]).astype(np.float32)
-  print(oFS.subfs("test"))
-  oFS.subfs("test").obj.save(oData, "sample1.pkl")
-
-  # Get paths
-  print("==== Paths ====")
-  print(oFS.subfs("test").file("sample1.png"))
-  print(oFS.folder("test"))
-
-  # Deserialize data from a sub folder
-  oLoadedData = oFS.subfs("test").obj.load("sample1.pkl")
-  print(oLoadedData)
-
-  # List files
-  print("==== Files ====")
-  sFiles = oFS.subfs("test").list_files("*.pkl", True)
-  print("\n".join(sFiles))
-
-  # Load a PNG file
-  if (is_opencv_installed()):
-    oPng = FileStore("C:\\UX").subfs("PNG").img.load("Ideas.png")
-    print(oPng.shape)
-
-    if VISUALIZE:
-      import matplotlib.pyplot as plt
-      plt.imshow(oPng)
-      plt.show()
 
 
 

radnn/system/filesystem.py

@@ -77,9 +77,9 @@ class FileSystem(object):
 
     # ...................... | Fields | ......................
     self.setup = dSetup
-    self.configs   = FileStore(config_folder, must_exist=self._must_exist)
-    self.models    = FileStore(model_folder, must_exist=self._must_exist)
-    self.datasets  = FileStore(dataset_folder, must_exist=self._must_exist)
+    self.configs: FileStore = FileStore(config_folder, must_exist=self._must_exist)
+    self.models: FileStore = FileStore(model_folder, must_exist=self._must_exist)
+    self.datasets: FileStore = FileStore(dataset_folder, must_exist=self._must_exist)
     # ........................................................
   # --------------------------------------------------------------------------------------------------------
   def group(self, group_name):

radnn/test/__init__.py

@@ -0,0 +1 @@
+from .tensor_hash import TensorHash

radnn/test/tensor_hash.py

@@ -0,0 +1,130 @@
+import hashlib
+import numpy as np
+from radnn import mlsys, FileStore
+
+if mlsys.framework == "torch":
+  import torch
+elif mlsys.framework == "tensorflow":
+  import tensorflow as tf
+  
+
+class TensorHash(object):
+  def __init__(self, test_fs, filename):
+    self.fs: FileStore = test_fs
+    self.filename = filename
+    self.hashes = []
+    self.loaded_hashes = None
+    self.is_loaded = False
+  
+  def collect_model_params(self, model):
+    if mlsys.framework == "torch":
+      for key, value in model.state_dict().items():
+        # print(key, value.shape)
+        self.collect_hash(value)
+    return self
+  
+  def end_collection(self):
+    if self.is_loaded:
+      if self.compare():
+        print(f"[v] {self.filename} Reproducibility for {len(self.hashes)} collected values")
+      else:
+        print(f"[x] {self.filename} Non deterministic behaviour!")
+    else:
+      self.save()
+      
+  def collect_hash(self, x: torch.Tensor, normalize_shape=True) -> str:
+    if mlsys.framework == "torch":
+      return self.calculate_hash_torch(x, normalize_shape)
+    elif mlsys.framework == "tensorflow":
+      return self.calculate_hash_tf(x, normalize_shape)
+    else:
+      return ""
+  
+  def calculate_hash_tf(self, x, normalize_shape: bool = True) -> str:
+    if not tf.is_tensor(x):
+      # allow numpy arrays too if you want:
+      if isinstance(x, np.ndarray):
+        x = tf.convert_to_tensor(x)
+      else:
+        raise TypeError("x must be a tf.Tensor (or numpy.ndarray)")
+    
+    t = x  # keep as tf.Tensor
+    
+    # Canonicalize shape to (28, 28, 1) if requested
+    if normalize_shape:
+      if t.shape.rank == 2:
+        # (28, 28) -> (28, 28, 1)
+        t = tf.expand_dims(t, axis=-1)
+      elif t.shape.rank == 3:
+        # (1, 28, 28) -> (28, 28, 1)  (common in CHW)
+        # Only do this if first dim is 1.
+        if t.shape[0] == 1:
+          t = tf.transpose(t, perm=[1, 2, 0])
+    
+    # Canonicalize dtype
+    if t.dtype.is_floating:
+      t = tf.clip_by_value(t, 0.0, 1.0)
+      t = tf.round(t * 255.0)
+      t = tf.cast(t, tf.uint8)
+    else:
+      t = tf.cast(t, tf.uint8)
+    
+    # Hash raw bytes (ensure deterministic C-order bytes)
+    # tf.io.serialize_tensor includes dtype/shape metadata, so we avoid it.
+    b = t.numpy().tobytes(order="C")
+    sResult = hashlib.sha256(b).hexdigest()
+    self.hashes.append(sResult)
+    return sResult
+  
+  def calculate_hash_torch(self, x: torch.Tensor, normalize_shape=True) -> str:
+    if not isinstance(x, torch.Tensor):
+      raise TypeError("x must be a torch.Tensor")
+    
+    # Move to CPU, detach, make contiguous
+    t = x.detach().to("cpu").contiguous()
+    
+    # Canonicalize shape to (28, 28, 1) if requested
+    if normalize_shape:
+      if t.ndim == 2:  # (28,28)
+        t = t.unsqueeze(-1)  # (28,28,1)
+      elif t.ndim == 3 and t.shape[0] == 1:  # (1,28,28) -> (28,28,1)
+        t = t.permute(1, 2, 0).contiguous()
+    
+    # Canonicalize dtype to avoid hash changing across float16/float32/etc.
+    # If your data is in [0,1] floats, this will quantize deterministically.
+    if t.dtype.is_floating_point:
+      t = (t.clamp(0, 1) * 255.0).round().to(torch.uint8)
+    else:
+      # If already uint8/int, you can keep it; here we convert to uint8 for consistency.
+      t = t.to(torch.uint8)
+    
+    # Hash raw bytes
+    b = t.numpy().tobytes(order="C")
+    sResult = hashlib.sha256(b).hexdigest()
+    self.hashes.append(sResult)
+    return sResult
+  
+  def save(self, filename=None):
+    if filename is not None:
+      self.filename = filename
+    
+    self.fs.text.save(self.hashes, self.filename)
+    return self
+
+  def load(self, filename=None):
+    if filename is not None:
+      self.filename = filename
+
+    self.loaded_hashes = self.fs.text.load(self.filename)
+    self.is_loaded = self.loaded_hashes is not None
+    return self
+  
+  def compare(self):
+    bResult = True
+    if self.loaded_hashes is not None:
+      for nIndex, sHash in enumerate(self.hashes):
+        if sHash != self.hashes[nIndex]:
+          bResult = False
+          break
+        
+    return bResult

radnn/utils.py

@@ -6,7 +6,7 @@
 # ______________________________________________________________________________________
 # ......................................................................................
 
-# Copyright (c) 2024-2025 Pantelis I. Kaplanoglou
+# Copyright (c) 2024-2026 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
@@ -28,6 +28,7 @@
 
 # .......................................................................................
 import numpy as np
+import json
 import time
 import hashlib
 import zlib
@@ -35,8 +36,21 @@ import contextlib
 
 phi=(1.0+np.sqrt(5.0))/2.0
 
+# ======================================================================================================================
+class classproperty(property):
+  def __get__(self, obj, owner):
+    return self.fget(owner)
+# ======================================================================================================================
 
-# --------------------------------------------------------------------------------------
+
+# ----------------------------------------------------------------------------------------------------------------------
+def to_json(obj, is_sorted_keys=False, is_utf8=False):
+  if isinstance(obj, dict):
+    sJSON = json.dumps(obj, sort_keys=is_sorted_keys, indent=4, ensure_ascii=is_utf8)
+  else:
+    sJSON = json.dumps(obj, default=lambda o: obj.__dict__, sort_keys=is_sorted_keys, indent=4, ensure_ascii=is_utf8)
+  return sJSON
+# ----------------------------------------------------------------------------------------------------------------------
 '''
   Checks if the p_sSettingsName is inside the settings dictionary p_dConfig
   and returns its value, otherwise the p_oDefault value

radnn-0.1.0.dist-info/METADATA

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: radnn
+Version: 0.1.0
+Summary: Rapid Deep Neural Networks
+Author-email: "Pantelis I. Kaplanoglou" <pikaplanoglou@ihu.gr>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/pikaplan/radnn
+Project-URL: Documentation, https://radnn.readthedocs.io/
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: numpy>=1.26.4
+Requires-Dist: matplotlib>=3.8.4
+Requires-Dist: pandas>=2.2.1
+Requires-Dist: scikit-learn>=1.4.2
+Requires-Dist: tqdm>=4.67.1
+Dynamic: license-file