kostyl-toolkit 0.1.36__py3-none-any.whl → 0.1.38__py3-none-any.whl

kostyl/ml/{lightning/extensions/pretrained_model.py → integrations/lightning/mixins.py}

@@ -12,12 +12,12 @@ from kostyl.utils.logging import setup_logger
 logger = setup_logger("LightningPretrainedModelMixin", fmt="only_message")
 
 
-class LightningCheckpointLoaderMixin(PreTrainedModel):
+class LightningCheckpointLoaderMixin:
     """A mixin class for loading pretrained models from PyTorch Lightning checkpoints."""
 
     @classmethod
-    def from_lightning_checkpoint[TModelInstance: LightningCheckpointLoaderMixin](  # noqa: C901
-        cls: type[TModelInstance],
+    def from_lightning_checkpoint[TModelInstance: PreTrainedModel](  # noqa: C901
+        cls: type[TModelInstance],  # pyright: ignore[reportGeneralTypeIssues]
         checkpoint_path: str | Path,
         config_key: str = "config",
         weights_prefix: str | None = "model.",
@@ -78,7 +78,7 @@ class LightningCheckpointLoaderMixin(PreTrainedModel):
             mmap=True,
         )
 
-        # 1. Восстанавливаем конфиг
+        # Load config
         config_cls = cast(type[PretrainedConfig], cls.config_class)
         config_dict = checkpoint_dict[config_key]
         config_dict.update(kwargs)
@@ -91,6 +91,7 @@ class LightningCheckpointLoaderMixin(PreTrainedModel):
 
         raw_state_dict: dict[str, torch.Tensor] = checkpoint_dict["state_dict"]
 
+        # Handle weights prefix
         if weights_prefix:
             if not weights_prefix.endswith("."):
                 weights_prefix = weights_prefix + "."
@@ -117,6 +118,7 @@ class LightningCheckpointLoaderMixin(PreTrainedModel):
         else:
             state_dict = raw_state_dict
 
+        # Instantiate model and load state dict
         model = cls.from_pretrained(
             pretrained_model_name_or_path=None,
             config=config,

kostyl/ml/{lightning/extensions/custom_module.py → integrations/lightning/module.py}

@@ -5,17 +5,15 @@ from typing import override
 
 import lightning as L
 import torch
-import torch.distributed as dist
 from lightning.pytorch.strategies import FSDPStrategy
 from torch import nn
-from torch.distributed import ProcessGroup
 from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
 from torchmetrics import Metric
 from torchmetrics import MetricCollection
 from transformers import PretrainedConfig
 from transformers import PreTrainedModel
 
-from kostyl.ml.metrics_formatting import apply_suffix
+from kostyl.ml.integrations.lightning.metrics_formatting import apply_suffix
 from kostyl.ml.schedulers.base import BaseScheduler
 from kostyl.utils import setup_logger
 
@@ -26,37 +24,6 @@ module_logger = setup_logger(fmt="only_message")
 class KostylLightningModule(L.LightningModule):
     """Custom PyTorch Lightning Module with logging, checkpointing, and distributed training utilities."""
 
-    @property
-    def process_group(self) -> ProcessGroup | None:
-        """Returns the data parallel process group for distributed training."""
-        return self.get_process_group()
-
-    def get_process_group(self) -> ProcessGroup | None:
-        """
-        Retrieves the data parallel process group for distributed training.
-
-        This method checks if distributed processing is initialized. If a device mesh is provided,
-        it extracts the data parallel mesh and returns its process group, unless the mesh size is 1,
-        in which case it logs a warning and returns None. If no device mesh is provided, it returns
-        the world process group.
-
-        Returns:
-            ProcessGroup | None: The data parallel process group if available and valid, otherwise None.
-
-        """
-        if not dist.is_initialized():
-            return None
-
-        if self.device_mesh is not None:
-            dp_mesh = self.device_mesh["data_parallel"]
-            if dp_mesh.size() == 1:
-                module_logger.warning("Data parallel mesh size is 1, returning None")
-                return None
-            dp_pg = dp_mesh.get_group()
-        else:
-            dp_pg = dist.group.WORLD
-        return dp_pg
-
     @property
     def model_instance(self) -> PreTrainedModel | nn.Module:
         """Returns the underlying model."""
@@ -65,10 +32,7 @@ class KostylLightningModule(L.LightningModule):
     @property
     def model_config(self) -> PretrainedConfig | None:
         """Returns the model configuration if available."""
-        model = self.model_instance
-        if hasattr(model, "config"):
-            return model.config  # type: ignore
-        return None
+        raise NotImplementedError
 
     @property
     def grad_clip_val(self) -> float | None:

kostyl/ml/{lightning → integrations/lightning}/utils.py

@@ -14,7 +14,7 @@ TRAINING_STRATEGIES = (
     FSDP1StrategyConfig | DDPStrategyConfig | SingleDeviceStrategyConfig
 )
 
-logger = setup_logger(add_rank=True)
+logger = setup_logger()
 
 
 def estimate_total_steps(

kostyl/ml/schedulers/__init__.py

@@ -1,18 +1,18 @@
 from .composite import CompositeScheduler
 from .cosine import CosineParamScheduler
 from .cosine import CosineScheduler
-from .cosine_with_plateu import CosineWithPlateauParamScheduler
-from .cosine_with_plateu import CosineWithPlateuScheduler
 from .linear import LinearParamScheduler
 from .linear import LinearScheduler
+from .plateau import PlateauWithAnnealingParamScheduler
+from .plateau import PlateauWithAnnealingScheduler
 
 
 __all__ = [
     "CompositeScheduler",
     "CosineParamScheduler",
     "CosineScheduler",
-    "CosineWithPlateauParamScheduler",
-    "CosineWithPlateuScheduler",
     "LinearParamScheduler",
     "LinearScheduler",
+    "PlateauWithAnnealingParamScheduler",
+    "PlateauWithAnnealingScheduler",
 ]

kostyl/ml/schedulers/{cosine_with_plateu.py → plateau.py}

@@ -1,4 +1,5 @@
 from typing import Any
+from typing import Literal
 from typing import override
 
 import numpy as np
@@ -7,20 +8,25 @@ import torch
 from .base import BaseScheduler
 
 
-class _CosineWithPlateauSchedulerCore(BaseScheduler):
-    """Core cosine with plateau scheduler logic."""
+class _PlateauWithAnnealingCore(BaseScheduler):
+    """Core annealing with plateau scheduler logic."""
 
     def __init__(
         self,
         param_name: str,
         num_iters: int,
-        base_value: float,
+        plateau_value: float,
         final_value: float,
         plateau_ratio: float,
         warmup_value: float | None = None,
         warmup_ratio: float | None = None,
         freeze_ratio: float | None = None,
+        annealing_type: Literal["cosine", "linear"] = "cosine",
     ) -> None:
+        if annealing_type not in ("cosine", "linear"):
+            raise ValueError(
+                f"Annealing type must be 'cosine' or 'linear', got {annealing_type}."
+            )
         if warmup_ratio is not None:
             if not (0 < warmup_ratio < 1):
                 raise ValueError(f"Warmup ratio must be in (0, 1), got {warmup_ratio}.")
@@ -47,16 +53,17 @@ class _CosineWithPlateauSchedulerCore(BaseScheduler):
 
         self.param_name = param_name
         self.num_iters = num_iters
-        self.base_value = base_value
+        self.plateau_value = plateau_value
         self.final_value = final_value
-        self.cosine_annealing_ratio = 1 - pre_annealing_ratio
+        self.annealing_ratio = 1 - pre_annealing_ratio
         self.plateau_ratio = plateau_ratio
         self.warmup_ratio = warmup_ratio
         self.warmup_value = warmup_value
         self.freeze_ratio = freeze_ratio
+        self.annealing_type = annealing_type
 
         self.scheduled_values: np.ndarray = np.array([], dtype=np.float64)
-        self.current_value_ = self.base_value
+        self.current_value_ = self.plateau_value
         return
 
     def _create_scheduler(self) -> None:
@@ -72,28 +79,41 @@ class _CosineWithPlateauSchedulerCore(BaseScheduler):
         if self.warmup_ratio is not None and self.warmup_value is not None:
             warmup_iters = int(self.num_iters * self.warmup_ratio)
             warmup_schedule = np.linspace(
-                self.warmup_value, self.base_value, warmup_iters, dtype=np.float64
+                self.warmup_value, self.plateau_value, warmup_iters, dtype=np.float64
             )
         else:
             warmup_iters = 0
             warmup_schedule = np.array([], dtype=np.float64)
 
-        # Create cosine annealing schedule
-        if self.cosine_annealing_ratio > 0:
-            cosine_annealing_iters = int(self.num_iters * self.cosine_annealing_ratio)
-            iters = np.arange(cosine_annealing_iters)
-            cosine_annealing_schedule = self.final_value + 0.5 * (
-                self.base_value - self.final_value
-            ) * (1 + np.cos(np.pi * iters / len(iters)))
+        # Create annealing schedule
+        if self.annealing_ratio > 0:
+            annealing_iters = int(self.num_iters * self.annealing_ratio)
+            match self.annealing_type:
+                case "cosine":
+                    iters = np.arange(annealing_iters)
+                    annealing_schedule = self.final_value + 0.5 * (
+                        self.plateau_value - self.final_value
+                    ) * (1 + np.cos(np.pi * iters / len(iters)))
+                case "linear":
+                    annealing_schedule = np.linspace(
+                        self.plateau_value,
+                        self.final_value,
+                        annealing_iters,
+                        dtype=np.float64,
+                    )
+                case _:
+                    raise ValueError(
+                        f"Unsupported annealing type: {self.annealing_type}"
+                    )
         else:
-            cosine_annealing_iters = 0
-            cosine_annealing_schedule = np.array([], dtype=np.float64)
+            annealing_iters = 0
+            annealing_schedule = np.array([], dtype=np.float64)
 
-        plateau_iters = (
-            self.num_iters - warmup_iters - freeze_iters - cosine_annealing_iters
-        )
+        plateau_iters = self.num_iters - warmup_iters - freeze_iters - annealing_iters
         if plateau_iters > 0:
-            plateau_schedule = np.full(plateau_iters, self.base_value, dtype=np.float64)
+            plateau_schedule = np.full(
+                plateau_iters, self.plateau_value, dtype=np.float64
+            )
         else:
             plateau_schedule = np.array([], dtype=np.float64)
 
@@ -103,7 +123,7 @@ class _CosineWithPlateauSchedulerCore(BaseScheduler):
                 freeze_schedule,
                 warmup_schedule,
                 plateau_schedule,
-                cosine_annealing_schedule,
+                annealing_schedule,
             )
         )
         self._verify()
@@ -137,12 +157,12 @@ class _CosineWithPlateauSchedulerCore(BaseScheduler):
         return {self.param_name: self.current_value_}
 
 
-class CosineWithPlateuScheduler(_CosineWithPlateauSchedulerCore):
+class PlateauWithAnnealingScheduler(_PlateauWithAnnealingCore):
     """
-    Applies a cosine schedule with plateau to an optimizer param-group field.
+    Applies an annealing schedule with plateau to an optimizer param-group field.
 
-    Schedule phases: freeze (0) → warmup → plateau (base_value) → cosine annealing to final_value.
-    The plateau phase maintains the base_value before cosine annealing begins.
+    Schedule phases: freeze (0) → warmup → plateau (plateau_value) → annealing (cosine/linear) to final_value.
+    The plateau phase maintains the plateau_value before annealing begins.
     """
 
     def __init__(
@@ -150,30 +170,32 @@ class CosineWithPlateuScheduler(_CosineWithPlateauSchedulerCore):
         optimizer: torch.optim.Optimizer,
         param_group_field: str,
         num_iters: int,
-        base_value: float,
+        plateau_value: float,
         final_value: float,
         plateau_ratio: float,
         warmup_value: float | None = None,
         warmup_ratio: float | None = None,
         freeze_ratio: float | None = None,
+        annealing_type: Literal["cosine", "linear"] = "cosine",
         multiplier_field: str | None = None,
         skip_if_zero: bool = False,
         apply_if_field: str | None = None,
         ignore_if_field: str | None = None,
     ) -> None:
         """
-        Configure cosine scheduling for matching optimizer groups.
+        Configure annealing scheduling for matching optimizer groups.
 
         Args:
             optimizer: Optimizer whose param groups are updated in-place.
             param_group_field: Name of the field that receives the scheduled value.
             num_iters: Number of scheduler iterations before clamping at ``final_value``.
-            base_value: Value maintained during plateau phase and used as cosine start.
-            final_value: Value approached as iterations progress during cosine annealing.
-            plateau_ratio: Fraction of iterations to maintain ``base_value`` before cosine annealing.
-            warmup_ratio: Optional fraction of iterations to linearly ramp from ``warmup_value`` to ``base_value``.
+            plateau_value: Value maintained during plateau phase and used as annealing start.
+            final_value: Value approached as iterations progress during annealing.
+            plateau_ratio: Fraction of iterations to maintain ``plateau_value`` before annealing.
+            warmup_ratio: Optional fraction of iterations to linearly ramp from ``warmup_value`` to ``plateau_value``.
             warmup_value: Starting value for the warmup ramp.
             freeze_ratio: Optional fraction of iterations to keep the value frozen at zero at the beginning.
+            annealing_type: Type of annealing from plateau to final value ("cosine" or "linear").
             multiplier_field: Optional per-group multiplier applied to the scheduled value.
             skip_if_zero: Leave groups untouched when their target field equals zero.
             apply_if_field: Require this flag to be present in a param group before updating.
@@ -188,12 +210,13 @@ class CosineWithPlateuScheduler(_CosineWithPlateauSchedulerCore):
         super().__init__(
             param_name=param_group_field,
             num_iters=num_iters,
-            base_value=base_value,
+            plateau_value=plateau_value,
             final_value=final_value,
             plateau_ratio=plateau_ratio,
             warmup_ratio=warmup_ratio,
             warmup_value=warmup_value,
             freeze_ratio=freeze_ratio,
+            annealing_type=annealing_type,
         )
         self.param_group_field = param_group_field
         return
@@ -242,12 +265,12 @@ class CosineWithPlateuScheduler(_CosineWithPlateauSchedulerCore):
         return
 
 
-class CosineWithPlateauParamScheduler(_CosineWithPlateauSchedulerCore):
+class PlateauWithAnnealingParamScheduler(_PlateauWithAnnealingCore):
     """
-    Standalone cosine scheduler with plateau for non-optimizer parameters.
+    Standalone annealing scheduler with plateau for non-optimizer parameters.
 
-    Schedule phases: freeze (0) → warmup → plateau (base_value) → cosine annealing to final_value.
-    The plateau phase maintains the base_value before cosine annealing begins.
+    Schedule phases: freeze (0) → warmup → plateau (plateau_value) → annealing (cosine/linear) to final_value.
+    The plateau phase maintains the plateau_value before annealing begins.
     """
 
     @override

kostyl/utils/logging.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import inspect
+import os
 import sys
 import uuid
 from collections import namedtuple
@@ -18,32 +19,18 @@ from loguru import logger as _base_logger
 if TYPE_CHECKING:
     from loguru import Logger
 
-    class CustomLogger(Logger):  # noqa: D101
+    class KostylLogger(Logger):  # noqa: D101
         def log_once(self, level: str, message: str, *args, **kwargs) -> None: ...  # noqa: ANN003, D102
         def warning_once(self, message: str, *args, **kwargs) -> None: ...  # noqa: ANN003, D102
 else:
-    CustomLogger = type(_base_logger)
+    KostylLogger = type(_base_logger)
 
 try:
-    import torch.distributed as dist
     from torch.nn.modules.module import (
         _IncompatibleKeys,  # pyright: ignore[reportAssignmentType]
     )
 except Exception:
 
-    class _Dummy:
-        @staticmethod
-        def is_available() -> bool:
-            return False
-
-        @staticmethod
-        def is_initialized() -> bool:
-            return False
-
-        @staticmethod
-        def get_rank() -> int:
-            return 0
-
     class _IncompatibleKeys(
         namedtuple("IncompatibleKeys", ["missing_keys", "unexpected_keys"]),
     ):
@@ -56,14 +43,13 @@ except Exception:
 
         __str__ = __repr__
 
-    dist = _Dummy()
     _IncompatibleKeys = _IncompatibleKeys
 
 _once_lock = Lock()
 _once_keys: set[tuple[str, str]] = set()
 
 
-def _log_once(self: CustomLogger, level: str, message: str, *args, **kwargs) -> None:  # noqa: ANN003
+def _log_once(self: KostylLogger, level: str, message: str, *args, **kwargs) -> None:  # noqa: ANN003
     key = (message, level)
 
     with _once_lock:
@@ -75,7 +61,7 @@ def _log_once(self: CustomLogger, level: str, message: str, *args, **kwargs) ->
     return
 
 
-_base_logger = cast(CustomLogger, _base_logger)
+_base_logger = cast(KostylLogger, _base_logger)
 _base_logger.log_once = _log_once  # pyright: ignore[reportAttributeAccessIssue]
 _base_logger.warning_once = partialmethod(_log_once, "WARNING")  # pyright: ignore[reportAttributeAccessIssue]
 
@@ -91,44 +77,83 @@ _DEFAULT_FMT = "<level>{level: <8}</level> {time:HH:mm:ss.SSS} [{extra[channel]}
 _ONLY_MESSAGE_FMT = "<level>{message}</level>"
 _PRESETS = {"default": _DEFAULT_FMT, "only_message": _ONLY_MESSAGE_FMT}
 
+KOSTYL_LOG_LEVEL = os.getenv("KOSTYL_LOG_LEVEL", "INFO")
+
 
 def setup_logger(
     name: str | None = None,
     fmt: Literal["default", "only_message"] | str = "only_message",
-    level: str = "INFO",
-    add_rank: bool | None = None,
+    level: str | None = None,
     sink=sys.stdout,
     colorize: bool = True,
     serialize: bool = False,
-) -> CustomLogger:
+) -> KostylLogger:
     """
-    Returns a bound logger with its own sink and formatting.
+    Creates and configures a logger with custom formatting and output.
+
+    The function automatically removes the default sink on first call and creates
+    an isolated logger with a unique identifier for message filtering.
+
+    Args:
+        name (str | None, optional): Logger channel name. If None, automatically
+            uses the calling function's filename. Defaults to None.
+        fmt (Literal["default", "only_message"] | str, optional): Log message format.
+            Available presets:
+            - "default": includes level, time, and channel
+            - "only_message": outputs only the message itself
+            Custom format strings are also supported. Defaults to "only_message".
+        level (str | None, optional): Logging level (TRACE, DEBUG, INFO, SUCCESS,
+            WARNING, ERROR, CRITICAL). If None, uses the KOSTYL_LOG_LEVEL environment
+            variable or "INFO" by default. Defaults to None.
+        sink: Output object for logs (file, sys.stdout, sys.stderr, etc.).
+            Defaults to sys.stdout.
+        colorize (bool, optional): Enable colored output formatting.
+            Defaults to True.
+        serialize (bool, optional): Serialize logs to JSON format.
+            Defaults to False.
+
+    Returns:
+        CustomLogger: Configured logger instance with additional methods
+            log_once() and warning_once().
+
+    Example:
+        >>> # Basic usage with automatic name detection
+        >>> logger = setup_logger()
+        >>> logger.info("Hello World")
 
-    Note: If name=None, the caller's filename (similar to __file__) is used automatically.
+        >>> # With custom name and level
+        >>> logger = setup_logger(name="MyApp", level="DEBUG")
+
+        >>> # With custom format
+        >>> logger = setup_logger(
+        ...     name="API",
+        ...     fmt="{level} | {time:YYYY-MM-DD HH:mm:ss} | {message}"
+        ... )
 
-    Format example: "{level} {time:MM-DD HH:mm:ss} [{extra[channel]}] {message}"
     """
     global _DEFAULT_SINK_REMOVED
     if not _DEFAULT_SINK_REMOVED:
         _base_logger.remove()
         _DEFAULT_SINK_REMOVED = True
 
-    if name is None:
-        base = _caller_filename()
-    else:
-        base = name
+    if level is None:
+        if KOSTYL_LOG_LEVEL not in {
+            "TRACE",
+            "DEBUG",
+            "INFO",
+            "SUCCESS",
+            "WARNING",
+            "ERROR",
+            "CRITICAL",
+        }:
+            level = "INFO"
+        else:
+            level = KOSTYL_LOG_LEVEL
 
-    if (add_rank is None) or add_rank:
-        try:
-            add_rank = dist.is_available() and dist.is_initialized()
-        except Exception:
-            add_rank = False
-
-    if add_rank:
-        rank = dist.get_rank()
-        channel = f"rank:{rank} - {base}"
+    if name is None:
+        channel = _caller_filename()
     else:
-        channel = base
+        channel = name
 
     if fmt in _PRESETS:
         fmt = _PRESETS[fmt]
@@ -146,7 +171,7 @@ def setup_logger(
         filter=lambda r: r["extra"].get("logger_id") == logger_id,
     )
     logger = _base_logger.bind(logger_id=logger_id, channel=channel)
-    return cast(CustomLogger, logger)
+    return cast(KostylLogger, logger)
 
 
 def log_incompatible_keys(
@@ -154,22 +179,12 @@ def log_incompatible_keys(
     incompatible_keys: _IncompatibleKeys
     | tuple[list[str], list[str]]
     | dict[str, list[str]],
-    model_specific_msg: str = "",
+    postfix_msg: str = "",
 ) -> None:
     """
     Logs warnings for incompatible keys encountered during model loading or state dict operations.
 
     Note: If incompatible_keys is of an unsupported type, an error message is logged and the function returns early.
-
-    Args:
-        logger (Logger): The logger instance used to output warning messages.
-        incompatible_keys (_IncompatibleKeys | tuple[list[str], list[str]] | dict[str, list[str]]): An object containing lists of missing and unexpected keys.
-        model_specific_msg (str, optional): A custom message to append to the log output, typically
-            indicating the model or context. Defaults to an empty string.
-
-    Returns:
-        None
-
     """
     incompatible_keys_: dict[str, list[str]] = {}
     match incompatible_keys:
@@ -192,5 +207,5 @@ def log_incompatible_keys(
             return
 
     for name, keys in incompatible_keys_.items():
-        logger.warning(f"{name} {model_specific_msg}: {', '.join(keys)}")
+        logger.warning(f"{name} {postfix_msg}: {', '.join(keys)}")
     return

{kostyl_toolkit-0.1.36.dist-info → kostyl_toolkit-0.1.38.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: kostyl-toolkit
-Version: 0.1.36
+Version: 0.1.38
 Summary: Kickass Orchestration System for Training, Yielding & Logging 
 Requires-Dist: case-converter>=1.2.0
 Requires-Dist: loguru>=0.7.3

kostyl_toolkit-0.1.38.dist-info/RECORD

@@ -0,0 +1,40 @@
+kostyl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kostyl/ml/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kostyl/ml/base_uploader.py,sha256=KxHuohCcNK18kTVFBBqDu_IOQefluhSXOzwC56O66wc,484
+kostyl/ml/configs/__init__.py,sha256=djYjLxA7riFcSibAKfWHns-BCESEPrqSz_ZY2rJO-cc,913
+kostyl/ml/configs/hyperparams.py,sha256=lvtbvOFEoTBAJug7FR35xMQdPLgDQjRoP2fyDP-jD7E,3305
+kostyl/ml/configs/mixins.py,sha256=xHHAoRoPbzP9ECFP9duzg6SzegHcoLI8Pr9NrLoWNHs,1411
+kostyl/ml/configs/training_settings.py,sha256=wT9CHuLaKrLwonsc87Ee421EyFis_c9fqOgn9bSClm8,2747
+kostyl/ml/data_collator.py,sha256=kxiaMDKwSKXGBtrF8yXxHcypf7t_6syU-NwO1LcX50k,4062
+kostyl/ml/dist_utils.py,sha256=UFNMLEHc0A5F6KvTRG8GQPpRDwG4m5dvM__UvXNc2aQ,4526
+kostyl/ml/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kostyl/ml/integrations/clearml/__init__.py,sha256=3TBVI-3fE9ZzuvOLEohW9TOK0BZTLD5JiYalAVDkocc,217
+kostyl/ml/integrations/clearml/checkpoint_uploader.py,sha256=PupFi7jKROsIddOz7X5DhV7nUNdDZg5kKaaLvzdCHlY,4012
+kostyl/ml/integrations/clearml/config_mixin.py,sha256=70QRicU7etiDzLX-MplqVX8uFm5siuPrM8KbTOriZnQ,3308
+kostyl/ml/integrations/clearml/dataset_utils.py,sha256=eij_sr2KDhm8GxEbVbK8aBjPsuVvLl9-PIGGaKVgXLA,1729
+kostyl/ml/integrations/clearml/loading_utils.py,sha256=NAMmB9NTGCXCHh-bR_nrQZyqImUVZqicNjExDyPM2mU,5224
+kostyl/ml/integrations/clearml/version_utils.py,sha256=GBjIIZbH_itd5sj7XpvxjkyZwxxGOpEcQ3BiWaJTyq8,1210
+kostyl/ml/integrations/lightning/__init__.py,sha256=r96os8kTuKIAymx3k9Td1JBrO2PH7nQAWUC54NsY5yY,392
+kostyl/ml/integrations/lightning/callbacks/__init__.py,sha256=EnKkNwwNDZnEqKRlpY4FVrqP88ECPF6nlT2bSLUIKRk,194
+kostyl/ml/integrations/lightning/callbacks/checkpoint.py,sha256=SfcaQRkXviMUej0UgrfXcqMDlRKYaAN3rgYCMKI97Os,18433
+kostyl/ml/integrations/lightning/callbacks/early_stopping.py,sha256=D5nyjktCJ9XYAf28-kgXG8jORvXLl1N3nbDQnvValPM,615
+kostyl/ml/integrations/lightning/loggers/__init__.py,sha256=e51dszaoJbuzwBkbdugmuDsPldoSO4yaRgmZUg1Bdy0,71
+kostyl/ml/integrations/lightning/loggers/tb_logger.py,sha256=CpjlcEIT187cJXJgRYafqfzvcnwPgPaVZ0vLUflIr7k,899
+kostyl/ml/integrations/lightning/metrics_formatting.py,sha256=U6vdNENZLvp2dT1L3HqFKtXrHwGKoDXN93hvamPGHjM,1341
+kostyl/ml/integrations/lightning/mixins.py,sha256=hVIsIUu6Iryrz6S7GQTqog9vNq8LQyjJd2aoJ5Ws6KU,5253
+kostyl/ml/integrations/lightning/module.py,sha256=39hcVNZSGyj5tLpXyX8IoqMGWt5vf6-Bx5JnNJ2-Wag,5218
+kostyl/ml/integrations/lightning/utils.py,sha256=DhLy_3JA5VyMQkB1v6xxRxDNHfisjXFYVjuIKPpO81M,1967
+kostyl/ml/params_groups.py,sha256=nUyw5d06Pvy9QPiYtZzLYR87xwXqJLxbHthgQH8oSCM,3583
+kostyl/ml/schedulers/__init__.py,sha256=VIo8MOP4w5Ll24XqFb3QGi2rKvys6c0dEFYPIdDoPlw,526
+kostyl/ml/schedulers/base.py,sha256=bjmwgdZpnSqpCnHPnKC6MEiRO79cwxMJpZq-eQVNs2M,1353
+kostyl/ml/schedulers/composite.py,sha256=ee4xlMDMMtjKPkbTF2ue9GTr9DuGCGjZWf11mHbi6aE,2387
+kostyl/ml/schedulers/cosine.py,sha256=y8ylrgVOkVcr2-ExoqqNW--tdDX88TBYPQCOppIf2_M,8685
+kostyl/ml/schedulers/linear.py,sha256=RnnnblRuRXP3LT03QVIHUaK2kNsiMP1AedrMoeyh3qk,5843
+kostyl/ml/schedulers/plateau.py,sha256=N-hiostPtTR0W4xnEJYB_1dv0DRx39iufLkGUrSIoWE,11235
+kostyl/utils/__init__.py,sha256=hkpmB6c5pr4Ti5BshOROebb7cvjDZfNCw83qZ_FFKMM,240
+kostyl/utils/dict_manipulations.py,sha256=e3vBicID74nYP8lHkVTQc4-IQwoJimrbFELy5uSF6Gk,1073
+kostyl/utils/fs.py,sha256=gAQNIU4R_2DhwjgzOS8BOMe0gZymtY1eZwmdgOdDgqo,510
+kostyl/utils/logging.py,sha256=CgNFNogcK0hoZmygvBWlTcq5A3m2Pfv9eOAP_gwx0pM,6633
+kostyl_toolkit-0.1.38.dist-info/WHEEL,sha256=e_m4S054HL0hyR3CpOk-b7Q7fDX6BuFkgL5OjAExXas,80
+kostyl_toolkit-0.1.38.dist-info/METADATA,sha256=nz5AzlWjKBqh7OZCklk-efWZ1jVDihw3YrrpLyoII3k,4269
+kostyl_toolkit-0.1.38.dist-info/RECORD,,

{kostyl_toolkit-0.1.36.dist-info → kostyl_toolkit-0.1.38.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.9.24
+Generator: uv 0.9.27
 Root-Is-Purelib: true
-Tag: py3-none-any
+Tag: py3-none-any

kostyl/ml/lightning/__init__.py

@@ -1,5 +0,0 @@
-from .extensions import KostylLightningModule
-from .extensions import LightningCheckpointLoaderMixin
-
-
-__all__ = ["KostylLightningModule", "LightningCheckpointLoaderMixin"]

kostyl/ml/lightning/extensions/__init__.py

@@ -1,5 +0,0 @@
-from .custom_module import KostylLightningModule
-from .pretrained_model import LightningCheckpointLoaderMixin
-
-
-__all__ = ["KostylLightningModule", "LightningCheckpointLoaderMixin"]