torchwires 0.0.2__tar.gz

torchwires-0.0.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Your Full Name
+
+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.

torchwires-0.0.2/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: torchwires
+Version: 0.0.2
+Summary: A lightweight training framework for PyTorch
+Author-email: Youssef Samy Youssef <yosefsamy019@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/YosefSamy019/torchwires
+Project-URL: Repository, https://github.com/YosefSamy019/torchwires
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: matplotlib
+Dynamic: license-file
+
+Soon.

torchwires-0.0.2/README.md

@@ -0,0 +1 @@
+Soon.

torchwires-0.0.2/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "torchwires"
+version = "0.0.2"
+description = "A lightweight training framework for PyTorch"
+readme = "README.md"
+requires-python = ">=3.12"
+authors = [
+    { name = "Youssef Samy Youssef", email = "yosefsamy019@gmail.com" },
+]
+license = "MIT"
+license-files = ["LICENSE"]
+dependencies = [
+    "torch",
+    "numpy",
+    "pandas",
+    "matplotlib",
+]
+
+[project.urls]
+Homepage = "https://github.com/YosefSamy019/torchwires"
+Repository = "https://github.com/YosefSamy019/torchwires"
+
+[tool.setuptools.packages.find]
+where = ["src"]

torchwires-0.0.2/setup.cfg

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

torchwires-0.0.2/src/torchwires/__init__.py

@@ -0,0 +1,4 @@
+from .repo.repo import Repo
+from .callbacks.base_callback import BaseCallback
+from .trainer.trainer import Trainer
+from .visualizer.visualizer import Visualizer

torchwires-0.0.2/src/torchwires/callbacks/autosave_callback.py

@@ -0,0 +1,41 @@
+from typing import Literal, Callable
+
+from .base_callback import BaseCallback
+from ..common.logger.logger import print_log
+from ..state.epoch_state import EpochState
+
+
+class AutoSaveCallback(BaseCallback):
+    def __init__(
+            self,
+            save_function: Callable[[str], None],
+            interval: int,
+            checkpoint_name: str,
+            concat_with_epoch_no: bool,
+    ):
+        super().__init__()
+        self._save_function = save_function
+        self._interval = interval
+        self._checkpoint_name = checkpoint_name
+        self._concat_with_epoch_no = concat_with_epoch_no
+
+    def on_epoch_end(self, epoch_state: EpochState):
+        cur_epoch = epoch_state.aggregate_over_batches(
+            split="train",
+            feature=epoch_state.KEY_EPOCH_NO,
+            func='max'
+        )
+
+        if cur_epoch % self._interval == 0:
+            if self._concat_with_epoch_no:
+                save_name = f"{self._checkpoint_name} epoch={cur_epoch}"
+            else:
+                save_name = f"{self._checkpoint_name}"
+
+            print_log(
+                title="Auto Save Checkpoint",
+                content=
+                f"save to checkpoint {save_name}",
+            )
+
+            self._save_function(save_name)

torchwires-0.0.2/src/torchwires/callbacks/base_callback.py

@@ -0,0 +1,25 @@
+from abc import ABC
+
+from ..state.epoch_state import EpochState
+
+
+class BaseCallback(ABC):
+    def on_train_start(self):
+        pass
+
+    def on_train_end(self):
+        pass
+
+    def on_epoch_start(
+            self
+    ):
+        pass
+
+    def on_epoch_end(
+            self,
+            epoch_state: EpochState,
+    ):
+        pass
+
+    def should_stop_training(self):
+        return False

torchwires-0.0.2/src/torchwires/callbacks/callbacks_repo.py

@@ -0,0 +1,50 @@
+from typing import List
+
+from .base_callback import BaseCallback
+from ..state.epoch_state import EpochState
+
+
+class CallbacksRepo:
+    def __init__(self):
+        self._callbacks_list: List[BaseCallback] = []
+
+    def register_callback(
+            self,
+            callback: BaseCallback
+    ):
+        self._callbacks_list.append(callback)
+
+    def register_callbacks(
+            self,
+            callbacks: List[BaseCallback]
+    ):
+        for callback in callbacks:
+            self.register_callback(callback)
+
+    def notify_train_start(self) -> None:
+        for callback in self._callbacks_list:
+            callback.on_train_start()
+
+    def notify_train_end(self) -> None:
+        for callback in self._callbacks_list:
+            callback.on_train_end()
+
+    def notify_epoch_start(
+            self
+    ) -> None:
+        for callback in self._callbacks_list:
+            callback.on_epoch_start()
+
+    def notify_epoch_end(
+            self,
+            epoch_state: EpochState
+    ) -> None:
+        for callback in self._callbacks_list:
+            callback.on_epoch_end(epoch_state=epoch_state)
+
+    def should_stop_training(self) -> bool:
+        for callback in self._callbacks_list:
+            if callback.should_stop_training():
+                return True
+
+        return False

torchwires-0.0.2/src/torchwires/callbacks/checkpoint_callback.py

@@ -0,0 +1,52 @@
+from typing import Literal, Callable
+
+from .base_callback import BaseCallback
+from ..common.logger.logger import print_log
+from ..state.epoch_state import EpochState
+
+
+class CheckpointCallback(BaseCallback):
+    def __init__(
+            self,
+            save_function: Callable[[str], None],
+            split: Literal["train", "val"],
+            monitor: str,
+            mode: Literal["min", "max"],
+    ):
+        super().__init__()
+        self._save_function = save_function
+        self._split = split
+        self._monitor = monitor
+        self._mode = mode
+
+        self._checkpoint_name = f"best_checkpoint_{self._split}-{self._monitor}"
+
+        if mode == "min":
+            self._best_value = float("inf")
+        elif mode == "max":
+            self._best_value = float("inf") * -1
+        else:
+            raise ValueError(f"Invalid mode: {mode}")
+
+    def on_epoch_end(self, epoch_state: EpochState):
+        cur_value = epoch_state.aggregate_over_batches(feature=self._monitor, split=self._split, func='mean')
+
+        if self._mode == "min" and cur_value < self._best_value:
+            new_target_achieved = True
+        elif self._mode == "max" and cur_value > self._best_value:
+            new_target_achieved = True
+        else:
+            new_target_achieved = False
+
+        if new_target_achieved:
+            print_log(
+                title="Checkpoint taken",
+                content=
+                f"{self._split}-{self._monitor} improved from {self._best_value:0.6f} to {cur_value:0.6f}"
+                " | "
+                f"checkpoint name: {self._checkpoint_name}",
+            )
+
+            self._best_value = cur_value
+
+            self._save_function(self._checkpoint_name)

torchwires-0.0.2/src/torchwires/callbacks/early_stopping_callback.py

@@ -0,0 +1,75 @@
+from typing import Literal
+
+from .base_callback import BaseCallback
+from ..common.logger.logger import print_log
+from ..state.epoch_state import EpochState
+
+
+class EarlyStoppingCallback(BaseCallback):
+    def __init__(
+            self,
+            split: Literal["train", "val"],
+            monitor: str,
+            mode: Literal["min", "max"],
+            patience: int,
+    ):
+        super().__init__()
+        self._split = split
+        self._monitor = monitor
+        self._mode = mode
+        self._patience = patience
+
+        if mode == "min":
+            self._best_value = float("inf")
+        elif mode == "max":
+            self._best_value = float("inf") * -1
+        else:
+            raise ValueError(f"Invalid mode: {mode}")
+
+        self._counter = 0
+
+    def on_train_start(self):
+        self._counter = 0
+
+    def on_epoch_end(self, epoch_state: EpochState):
+        cur_val = epoch_state.aggregate_over_batches(
+            feature=self._monitor,
+            split=self._split,
+            func='mean'
+        )
+
+        if cur_val is None:
+            print_log(
+                title="Early Stopping",
+                content=f"Couldn't find {self._monitor} feature in {self._split} split",
+            )
+            return
+
+        if self._mode == "min":
+            self._best_value = min(cur_val, self._best_value)
+            if cur_val > self._best_value:
+                self._counter += 1
+            else:
+                self._counter = 0
+
+        if self._mode == "max":
+            self._best_value = max(cur_val, self._best_value)
+            if cur_val < self._best_value:
+                self._counter += 1
+            else:
+                self._counter = 0
+
+        if self.should_stop_training():
+            print_log(
+                title="Early Stopping",
+                content=f'the training has been stopped',
+            )
+        else:
+            pass
+            # print_log(
+            #     title="Early Stopping",
+            #     content=f"counter={self._counter:d}, best={self._best_value:0.5f}",
+            # )
+
+    def should_stop_training(self) -> bool:
+        return self._counter >= self._patience

torchwires-0.0.2/src/torchwires/common/functions/json_storage.py

@@ -0,0 +1,33 @@
+import json
+import os
+
+
+def check_json(*path_segments) -> bool:
+    load_path = os.path.join(*path_segments)
+
+    if not load_path.endswith(".json"):
+        load_path += ".json"
+
+    return os.path.exists(load_path)
+
+
+def load_json(*path_segments) -> dict:
+    load_path = os.path.join(*path_segments)
+
+    if not load_path.endswith(".json"):
+        load_path += ".json"
+
+    with open(load_path, 'r') as f:
+        content = json.load(f)
+
+    return content
+
+
+def save_json(content, *path_segments) -> None:
+    save_path = os.path.join(*path_segments)
+
+    if not save_path.endswith(".json"):
+        save_path += ".json"
+
+    with open(save_path, 'w') as f:
+        json.dump(content, f)

torchwires-0.0.2/src/torchwires/common/logger/logger.py

@@ -0,0 +1,7 @@
+def print_log(
+        title: str,
+        content: str,
+        sep: str = ": ",
+):
+    print(f"\033[1m{title}\033[0m", end=sep)
+    print(content)

torchwires-0.0.2/src/torchwires/constants/constants.py

@@ -0,0 +1,11 @@
+DEFAULT_CHECKPOINT_NAME = "last"
+
+RAW_ANNOT_FOR_LOSS_NAME = ".raw"
+WEIGHT_ANNOT_FOR_LOSS_NAME = ".weight"
+EFF_ANNOT_FOR_LOSS_NAME = ".eff"
+
+LOADER_TRAIN_TYPE = "train"
+LOADER_VAL_TYPE = "val"
+LOADER_TEST_TYPE = "test"
+
+LR_ANNOT_FOR_OPTIMIZER_NAME = ".lr"

torchwires-0.0.2/src/torchwires/dataloaders_repo/dataloaders_repo.py

@@ -0,0 +1,28 @@
+import torch.utils.data
+
+
+class DataLoadersRepo:
+    def __init__(self) -> None:
+        self._train_loader: torch.utils.data.DataLoader | None = None
+        self._val_loader: torch.utils.data.DataLoader | None = None
+
+        self._loader_output_keys: list[str] = []
+
+    def attach_train_loader(
+            self, train_loader: torch.utils.data.DataLoader | None) -> None:
+        self._train_loader = train_loader
+
+    def attach_val_loader(self, val_loader: torch.utils.data.DataLoader | None) -> None:
+        self._val_loader = val_loader
+
+    def attach_loader_output_keys(self, loader_output_keys: list[str]) -> None:
+        self._loader_output_keys = loader_output_keys
+
+    def get_train_loader(self) -> torch.utils.data.DataLoader | None:
+        return self._train_loader
+
+    def get_val_loader(self) -> torch.utils.data.DataLoader | None:
+        return self._val_loader
+
+    def get_loader_output_keys(self) -> list[str]:
+        return self._loader_output_keys

torchwires-0.0.2/src/torchwires/display_widget/display_widget.py

@@ -0,0 +1,93 @@
+import time
+from pickle import NONE
+from typing import List
+
+from ..state.batch_state import BatchState
+from ..state.epoch_state import EpochState
+
+
+class DisplayWidget:
+    def __init__(
+            self,
+            tracked_features: List[str],
+            n_columns: int = 4,
+            columns_width: int = 35,
+    ):
+        self._tracked_features = tracked_features
+        self._n_columns = n_columns
+        self._columns_width = columns_width
+        self._max_length_ever = 0
+
+    def display_batch_state(
+            self,
+            split: str,
+            epoch_no: int,
+            max_epochs: int,
+            batch_no: int,
+            max_batch: int,
+            batch_state: BatchState,
+    ):
+        # time.sleep(0.1)
+
+        segments = [
+            "\r"
+            f"Epoch: {epoch_no}/{max_epochs} ({100 * epoch_no / max_epochs:5.1f} %)",
+            f"Batch: {batch_no}/{max_batch} ({100 * batch_no / max_batch:5.1f} %)",
+            f"Split: {split}",
+            " | ",
+        ]
+
+        for k, v in batch_state.get_dict().items():
+            if k not in self._tracked_features:
+                continue
+
+            if isinstance(v, float):
+                segments.append(f"{k}: {v:3.5f}")
+            else:
+                segments.append(f"{k}: {v}")
+
+            segments.append(f" - ")
+
+        line_str = ' '.join(segments[:-1])
+        self._max_length_ever = max(self._max_length_ever, len(line_str))
+        print(line_str, end=' ' * 15)
+
+    def display_epoch_state(
+            self,
+            epoch_no: int,
+            max_epochs: int,
+            epoch_state: EpochState,
+    ):
+        print(f"\rEpoch: {epoch_no}/{max_epochs}", end=' ' * self._max_length_ever)
+        print()
+
+        cell_i = 0
+
+        for feature in self._tracked_features:
+            for split in epoch_state.get_all_splits():
+                if feature in [BatchState.KEY_LOADER_TYPE, BatchState.KEY_EPOCH_NO, BatchState.KEY_BATCH_NO]:
+                    continue
+
+                value = epoch_state.aggregate_over_batches(
+                    feature=feature,
+                    split=split,
+                    func='mean',
+                )
+
+                if value is None:
+                    val_str = f"{split}-{feature}: {None}"
+                else:
+                    val_str = f"{split}-{feature}: {value:3.5f}"
+
+                val_str = val_str.ljust(self._columns_width)
+                print(val_str, end=' ')
+
+                if (cell_i + 1) % self._n_columns == 0:
+                    print()
+                else:
+                    print(' | ', end='')
+
+                cell_i += 1
+
+    def reset(self):
+        self._max_length_ever = 0

torchwires-0.0.2/src/torchwires/history/history.py

@@ -0,0 +1,115 @@
+import json
+import os
+from typing import Any, Dict
+
+import numpy as np
+import torch
+import pandas as pd
+
+from ..common.logger.logger import print_log
+
+
+class History:
+    def __init__(
+            self,
+    ):
+        self._tracked_features = []
+        self._content: list[dict[str, Any]] = []
+
+    def save(
+            self,
+            repo_name: str,
+            experiment: str,
+    ):
+        dir_path = os.path.join(repo_name, experiment)
+        cache_path = os.path.join(repo_name, experiment, "history.json")
+        csv_path = os.path.join(repo_name, experiment, "history.csv")
+        tracked_features_path = os.path.join(repo_name, experiment, "history_tracked.json")
+
+        os.makedirs(dir_path, exist_ok=True)
+
+        with open(cache_path, "w") as f:
+            f.write(
+                json.dumps(self._content)
+            )
+
+        pd.read_json(cache_path).to_csv(csv_path, index=False)
+
+        with open(tracked_features_path, "w") as f:
+            f.write(
+                json.dumps(self._tracked_features)
+            )
+
+    def load(
+            self,
+            repo_name: str,
+            experiment: str,
+    ):
+        cache_path = os.path.join(repo_name, experiment, "history.json")
+        tracked_features_path = os.path.join(repo_name, experiment, "history_tracked.json")
+
+        if os.path.exists(cache_path):
+            with open(cache_path, "r") as f:
+                self._content = json.loads(f.read())
+            print_log(
+                title="History loaded",
+                content=f"path={cache_path}",
+            )
+        else:
+            print_log(
+                title="No History cache found",
+                content=f"path={cache_path}",
+            )
+
+        if os.path.exists(tracked_features_path):
+            with open(tracked_features_path, "r") as f:
+                self._tracked_features = json.loads(f.read())
+            print_log(
+                title="History Features loaded",
+                content=f"path={tracked_features_path}",
+            )
+        else:
+            print_log(
+                title="No History Features found",
+                content=f"path={tracked_features_path}",
+            )
+
+    def track_feature(self, feature: str):
+        if feature not in self._tracked_features:
+            self._tracked_features.append(feature)
+
+    def track_features(self, features: list[str]):
+        for feature in features:
+            self.track_feature(feature)
+
+    def record(
+            self, state_dict: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        new_line = {}
+
+        for feature in self._tracked_features:
+            val = state_dict.get(feature, None)
+
+            if isinstance(val, torch.Tensor):
+                val = val.item()
+
+            if isinstance(val, np.generic):
+                return val.item()
+
+            new_line[feature] = val
+
+        self._content.append(new_line)
+        return new_line
+
+    def get_feature_columns(self, feature: str) -> list:
+        li = []
+        for row in self._content:
+            li.append(row.get(feature))
+        return li
+
+    def get_tracked_features(self) -> list:
+        return self._tracked_features
+
+    def return_as_df(self) -> pd.DataFrame:
+        df = pd.DataFrame(self._content)
+        return df