optimum-rbln 0.8.2a4__py3-none-any.whl → 0.9.3__py3-none-any.whl

optimum/rbln/utils/deprecation.py

@@ -0,0 +1,213 @@
+# Copyright 2024 The HuggingFace Team. All rights reserved.
+# Copyright 2025 Rebellions Inc. All rights reserved.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# **********************************************************************************
+# * NOTE: This file has been modified from its original version in              *
+# * the Hugging Face transformers library.                                      *
+# * Original source:                                                            *
+# * https://github.com/huggingface/transformers/blob/v4.57.1/src/transformers/utils/deprecation.py
+# **********************************************************************************
+
+import inspect
+from enum import Enum
+from functools import wraps
+from typing import Callable, Optional
+
+import packaging.version
+
+from ..__version__ import __version__
+from .logging import get_logger
+
+
+logger = get_logger(__name__)
+
+
+def warn_deprecated_npu(npu: Optional[str] = None):
+    import rebel
+
+    npu = npu or rebel.get_npu_name()
+    if npu == "RBLN-CA02":
+        logger.warning_once(
+            "Support for the RBLN-CA02 device is provided only up to optimum-rbln v0.8.0 and has reached end of life.",
+        )
+
+
+class Action(Enum):
+    NONE = "none"
+    NOTIFY = "notify"
+    RAISE = "raise"
+
+
+# Scenario Table for Deprecation Strategy Example
+# Assume that current version is v0.9.6 and the deprecated version is v0.10.0
+# |--------------------|----------------|----------------|---------------------------------------------|--------------------------------------------------------------------------------------|----------------------------------------------------------------------|
+# | Type               | v0.9.6 (as_is) | v0.9.6 (to_be) | v0.9.6 Patch                                | v0.9.7 Action                                                                        | v0.10.0+ Action                                                      |
+# |--------------------|----------------|----------------|---------------------------------------------|--------------------------------------------------------------------------------------|----------------------------------------------------------------------|
+# | Modify (Key Name)  | a: bool        | a': bool       | Add a', Keep a                              | 1. Only 'a' provided: replace a -> a' & future warning                               | In v0.10.0, raise error once, then remove decorator.                 |
+# |                    |                |                |                                             | 2. Both 'a' & 'a'' provided: ignore 'a' value & future warning                       |                                                                      |
+# |--------------------|----------------|----------------|---------------------------------------------|--------------------------------------------------------------------------------------|----------------------------------------------------------------------|
+# | Modify (Value Type)| b: bool        | b: str         | b: Union[str, bool]                         | 'bool' value provided for 'b': replace with corresponding 'str' & future warning     | In v0.10.0, raise error once, then remove decorator.                 |
+# |                    |                |                |                                             |                                                                                      |                                                                      |
+# |--------------------|----------------|----------------|---------------------------------------------|--------------------------------------------------------------------------------------|----------------------------------------------------------------------|
+# | Deletion           | c              | -              | Delete c or Keep c (flexible)               | ignore c & future warning                                                            | In v0.10.0, raise error once, then remove decorator.                 |
+# |                    |                |                |                                             |                                                                                      |                                                                      |
+# |--------------------|----------------|----------------|---------------------------------------------|--------------------------------------------------------------------------------------|----------------------------------------------------------------------|
+# | Addition           | -              | d              | Add d, set default_value for d              | No action needed as default value is set                                             | Keep default value                                                   |
+# |--------------------|----------------|----------------|---------------------------------------------|--------------------------------------------------------------------------------------|----------------------------------------------------------------------|
+
+
+def deprecate_kwarg(
+    old_name: str,
+    version: str,
+    new_name: Optional[str] = None,
+    deprecated_type: Optional[type] = None,
+    value_replacer: Optional[Callable] = None,
+    raise_if_greater_or_equal_version: bool = True,
+    raise_if_both_names: bool = False,
+    additional_message: Optional[str] = None,
+):
+    """
+    Function or method decorator to notify users about deprecated keyword arguments, replacing them with a new name if specified,
+    or handling deprecated value types.
+
+    This decorator allows you to:
+    - Notify users when a keyword argument name is deprecated (Scenario 'a', 'c').
+    - Notify users when a specific value type for an argument is deprecated (Scenario 'b').
+    - Automatically replace deprecated keyword arguments with new ones.
+    - Automatically replace deprecated values with new ones using a replacer function.
+    - Raise an error if deprecated arguments are used, depending on the specified conditions.
+
+    By default, the decorator notifies the user about the deprecated argument while the `optimum.rbln.__version__` < specified `version`
+    in the decorator. To keep notifications with any version `warn_if_greater_or_equal_version=True` can be set.
+
+    Parameters:
+        old_name (`str`):
+            Name of the deprecated keyword argument, or the argument with a deprecated value type.
+        version (`str`):
+            The version in which the keyword argument or value type was (or will be) deprecated.
+        new_name (`Optional[str]`, *optional*):
+            The new name for the deprecated keyword argument. If specified, the deprecated keyword argument will be replaced with this new name (Scenario 'a').
+        deprecated_type (`type`, *optional*):
+            The deprecated type for the keyword argument specified by `old_name` (Scenario 'b').
+            If this is set, `new_name` should typically be `None`.
+        value_replacer (`Callable`, *optional*):
+            A function that takes the old (deprecated type) value and returns a new value (Scenario 'b').
+            Used in conjunction with `deprecated_type`. If provided, the value will be automatically converted.
+        raise_if_greater_or_equal_version (`bool`, *optional*, defaults to `False`):
+            Whether to raise `ValueError` if current `optimum.rbln.` version is greater or equal to the deprecated version.
+        raise_if_both_names (`bool`, *optional*, defaults to `False`):
+            Whether to raise `ValueError` if both deprecated and new keyword arguments are set (only for Scenario 'a').
+        additional_message (`Optional[str]`, *optional*):
+            An additional message to append to the default deprecation message.
+
+    Raises:
+        ValueError:
+            If raise_if_greater_or_equal_version is True and the current version is greater than or equal to the deprecated version, or if raise_if_both_names is True and both old and new keyword arguments are provided.
+
+    Returns:
+        Callable:
+            A wrapped function that handles the deprecated keyword arguments according to the specified parameters.
+    """
+
+    deprecated_version = packaging.version.parse(version)
+    current_version = packaging.version.parse(__version__)
+    is_greater_or_equal_version = current_version >= deprecated_version
+
+    if is_greater_or_equal_version:
+        version_message = f"and removed starting from version {version}"
+    else:
+        version_message = f"and will be removed in version {version}"
+
+    def wrapper(func):
+        # Required for better warning message
+        sig = inspect.signature(func)
+        function_named_args = set(sig.parameters.keys())
+        is_instance_method = "self" in function_named_args
+        is_class_method = "cls" in function_named_args
+
+        @wraps(func)
+        def wrapped_func(*args, **kwargs):
+            # Get class + function name (just for better warning message)
+            func_name = func.__name__
+            if is_instance_method:
+                func_name = f"{args[0].__class__.__name__}.{func_name}"
+            elif is_class_method:
+                func_name = f"{args[0].__name__}.{func_name}"
+
+            minimum_action = Action.NONE
+            message = None
+
+            # Scenario A: Rename (e.g., a -> a')
+            if new_name is not None:
+                if old_name in kwargs and new_name in kwargs:
+                    minimum_action = Action.RAISE if raise_if_both_names else Action.NOTIFY
+                    message = f"Both `{old_name}` and `{new_name}` are set for `{func_name}`. Using `{new_name}={kwargs[new_name]}` and ignoring deprecated `{old_name}={kwargs[old_name]}`."
+                    kwargs.pop(old_name)
+
+                elif old_name in kwargs and new_name not in kwargs:
+                    minimum_action = Action.NOTIFY
+                    message = (
+                        f"`{old_name}` is deprecated {version_message} for `{func_name}`. Use `{new_name}` instead."
+                    )
+                    kwargs[new_name] = kwargs.pop(old_name)
+
+            # Scenario B: Value Type Change (e.g., b: bool -> str)
+            if deprecated_type is not None:
+                key_to_check = old_name if new_name is None else new_name  # For Senario A + B Mixed
+                if key_to_check in kwargs and isinstance(kwargs[key_to_check], deprecated_type):
+                    minimum_action = Action.NOTIFY
+                    old_value = kwargs[key_to_check]
+                    message = f"Using type `{deprecated_type.__name__}` for argument `{key_to_check}` in `{func_name}` is deprecated {version_message}."
+
+                    if value_replacer:
+                        try:
+                            new_value = value_replacer(old_value)
+                            kwargs[key_to_check] = new_value
+                            message += f" Value `{old_value}` has been automatically replaced with `{new_value}`."
+                        except Exception as e:
+                            logger.error(f"Error during deprecated value replacement for {key_to_check}: {e}")
+                            message += f" Automatic replacement failed: {e}. Passing original value."
+                    else:
+                        raise ValueError(
+                            f"value_replacer should be provided when deprecated_type is set for {key_to_check} in {func_name}"
+                        )
+
+            # Scenario C: Deletion (e.g., c)
+            if old_name in kwargs and new_name is None and deprecated_type is None:
+                minimum_action = Action.NOTIFY
+                message = f"`{old_name}` is deprecated {version_message} for `{func_name}`."
+                kwargs.pop(old_name)
+
+            if message is not None and additional_message is not None:
+                message = f"{message} {additional_message}"
+
+            # update minimum_action if argument is ALREADY deprecated (current version >= deprecated version)
+            if is_greater_or_equal_version:
+                # change to NOTIFY -> RAISE  in case we want to raise error for already deprecated arguments
+                if raise_if_greater_or_equal_version:
+                    minimum_action = Action.RAISE
+
+            # raise error or notify user
+            if minimum_action == Action.RAISE:
+                raise ValueError(message)
+            elif minimum_action == Action.NOTIFY:
+                # DeprecationWarning is ignored by default, so we use FutureWarning instead
+                logger.warning(message, stacklevel=2)
+
+            return func(*args, **kwargs)
+
+        return wrapped_func
+
+    return wrapper

optimum/rbln/utils/hub.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import json
 from pathlib import Path
 from typing import List, Optional, Union
 
@@ -67,15 +68,25 @@ def validate_files(
     location: str,
 ):
     """Validate the presence and count of required files."""
-    if len(files) == 0:
-        raise FileNotFoundError(f"Could not find any rbln model file in {location}")
-
     if len(config_files) == 0:
         raise FileNotFoundError(f"Could not find `rbln_config.json` file in {location}")
 
     if len(config_files) > 1:
         raise FileExistsError(f"Multiple rbln_config.json files found in {location}. This is not expected.")
 
+    try:
+        with open(config_files[0], "r") as f:
+            config_data = json.load(f)
+        compile_cfgs = config_data.get("_compile_cfgs", [])
+        if len(compile_cfgs) == 0:
+            # If compile_cfgs is empty, we don't need .rbln files
+            return
+    except (json.JSONDecodeError, KeyError, OSError):
+        pass
+
+    if len(files) == 0:
+        raise FileNotFoundError(f"Could not find any rbln model file in {location}")
+
 
 def _get_huggingface_token(token: Union[bool, str]) -> str:
     if isinstance(token, str):

optimum/rbln/utils/runtime_utils.py

@@ -14,12 +14,44 @@
 
 import re
 import threading
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, List, Optional, Union
 
 import rebel
 import torch
 
 
+def get_available_dram(npu: Optional[str] = None) -> int:
+    """
+    Get the available DRAM size of the specified NPU.
+
+    Args:
+        npu : Optional[str], default=None
+            The NPU to get the available DRAM size.
+            If None, the function will attempt to retrieve through `ensure_valid_npu()`
+
+    Returns:
+        int
+            The available DRAM size in bytes.
+    """
+    if npu is None:
+        if not rebel.npu_is_available(0):
+            raise RuntimeError("No NPU is available to get available DRAM size.")
+
+        npu = rebel.get_npu_name(0)
+
+    if npu.startswith("RBLN-CR"):
+        # TODO(jongho): Assuming 4 chiplets.
+        DRAM_NBYTES = 144 * 2**30
+        SYS_DRAM_NBYTES = 4 * 2**30
+    elif npu.startswith("RBLN-CA"):
+        DRAM_NBYTES = 16 * 2**30
+        SYS_DRAM_NBYTES = 288 * 2**20
+    else:
+        raise ValueError(f"Unknown npu name: {npu}")
+
+    return DRAM_NBYTES - SYS_DRAM_NBYTES
+
+
 def normalize_npu(npu: str) -> str:
     """Normalize the NPU string by removing the form factor."""
     match = re.match(r"(RBLN-CA|RBLN-CR)(\d+)", npu)
@@ -94,7 +126,7 @@ class RBLNPytorchRuntime:
     def __call__(self, *args: Any, **kwds: Any) -> Any:
         return self.forward(*args, **kwds)
 
-    def forward(self, *args: List["torch.Tensor"], **kwargs: Dict[str, "torch.Tensor"]):
+    def forward(self, *args: List["torch.Tensor"], **kwargs: "torch.Tensor"):
         # filtering useless args or kwarg such as None.
         args = list(filter(lambda arg: isinstance(arg, torch.Tensor), args))
         kwargs = dict(filter(lambda kwarg: isinstance(kwarg[1], torch.Tensor) or kwarg[0] == "out", kwargs.items()))
@@ -142,7 +174,7 @@ class UnavailableRuntime:
         """Returns an iterator with self as the only item."""
         return iter([self])
 
-    def forward(self, *args: List["torch.Tensor"], **kwargs: Dict[str, "torch.Tensor"]):
+    def forward(self, *args: List["torch.Tensor"], **kwargs: "torch.Tensor"):
         """Raises a detailed RuntimeError explaining why inference cannot be performed."""
         raise RuntimeError(
             "Cannot perform inference: RBLN runtime is not available.\n\n"
@@ -167,33 +199,44 @@ class ContextRblnConfig:
         device=None,
         device_map=None,
         create_runtimes=None,
-        optimize_host_mem=None,
         activate_profiler=None,
         timeout=None,
     ):
         self.device = device
         self.device_map = device_map
         self.create_runtimes = create_runtimes
-        self.optimize_host_mem = optimize_host_mem
         self.activate_profiler = activate_profiler
         self.timeout = timeout
+        self._previous_context = None
 
     def __enter__(self):
-        self._local.device = self.device
-        self._local.device_map = self.device_map
-        self._local.create_runtimes = self.create_runtimes
-        self._local.optimize_host_memory = self.optimize_host_mem
-        self._local.activate_profiler = self.activate_profiler
-        self._local.timeout = self.timeout
+        self._previous_context = {
+            "device": getattr(self._local, "device", None),
+            "device_map": getattr(self._local, "device_map", None),
+            "create_runtimes": getattr(self._local, "create_runtimes", None),
+            "activate_profiler": getattr(self._local, "activate_profiler", None),
+            "timeout": getattr(self._local, "timeout", None),
+        }
+
+        if self.device is not None:
+            self._local.device = self.device
+        if self.device_map is not None:
+            self._local.device_map = self.device_map
+        if self.create_runtimes is not None:
+            self._local.create_runtimes = self.create_runtimes
+        if self.activate_profiler is not None:
+            self._local.activate_profiler = self.activate_profiler
+        if self.timeout is not None:
+            self._local.timeout = self.timeout
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        self._local.device = None
-        self._local.device_map = None
-        self._local.create_runtimes = None
-        self._local.optimize_host_memory = None
-        self._local.activate_profiler = None
-        self._local.timeout = None
+        if self._previous_context is not None:
+            self._local.device = self._previous_context["device"]
+            self._local.device_map = self._previous_context["device_map"]
+            self._local.create_runtimes = self._previous_context["create_runtimes"]
+            self._local.activate_profiler = self._previous_context["activate_profiler"]
+            self._local.timeout = self._previous_context["timeout"]
 
     @classmethod
     def get_current_context(cls):
@@ -201,7 +244,6 @@ class ContextRblnConfig:
             "device": getattr(cls._local, "device", None),
             "device_map": getattr(cls._local, "device_map", None),
             "create_runtimes": getattr(cls._local, "create_runtimes", None),
-            "optimize_host_memory": getattr(cls._local, "optimize_host_memory", None),
             "activate_profiler": getattr(cls._local, "activate_profiler", None),
             "timeout": getattr(cls._local, "timeout", None),
         }

optimum/rbln/utils/submodule.py

@@ -13,16 +13,16 @@
 # limitations under the License.
 
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Dict, List, Type
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Type, Union
 
 from transformers import PretrainedConfig
 
-from ..configuration_utils import RBLNModelConfig
+from ..configuration_utils import RBLNModelConfig, get_rbln_config_class
 from ..utils.model_utils import get_rbln_model_cls
 
 
 if TYPE_CHECKING:
-    from transformers import PreTrainedModel
+    from transformers import AutoFeatureExtractor, AutoProcessor, AutoTokenizer, PreTrainedModel
 
     from ..modeling import RBLNModel
 
@@ -42,7 +42,21 @@ class SubModulesMixin:
             setattr(self, submodule_meta["name"], submodule)
 
     @classmethod
-    def _update_submodule_config(cls, model: "PreTrainedModel", rbln_config: RBLNModelConfig):
+    def _get_submodule_config_class(
+        cls, cls_name: str, submodule_rbln_config: Dict[str, Any]
+    ) -> Type[RBLNModelConfig]:
+        if isinstance(submodule_rbln_config, dict) and "cls_name" in submodule_rbln_config:
+            config_cls_name = submodule_rbln_config["cls_name"]
+            return get_rbln_config_class(config_cls_name)
+        return get_rbln_config_class(f"RBLN{cls_name}Config")
+
+    @classmethod
+    def _update_submodule_config(
+        cls,
+        model: "PreTrainedModel",
+        rbln_config: RBLNModelConfig,
+        preprocessors: Optional[Union["AutoFeatureExtractor", "AutoProcessor", "AutoTokenizer"]],
+    ):
         return rbln_config
 
     @classmethod
@@ -51,6 +65,7 @@ class SubModulesMixin:
     ) -> List["RBLNModel"]:
         rbln_submodules = []
         submodule_prefix = getattr(cls, "_rbln_submodule_prefix", None)
+        preprocessors = kwargs.pop("preprocessors", [])
 
         for submodule in cls._rbln_submodules:
             submodule_name = submodule["name"]
@@ -63,13 +78,20 @@ class SubModulesMixin:
             cls_name = torch_submodule.__class__.__name__
             submodule_cls: Type["RBLNModel"] = get_rbln_model_cls(f"RBLN{cls_name}")
             submodule_rbln_config = getattr(rbln_config, submodule_name) or {}
+            submodule_config_cls = cls._get_submodule_config_class(cls_name, submodule_rbln_config)
 
             if isinstance(submodule_rbln_config, dict):
-                submodule_rbln_config_class = submodule_cls.get_rbln_config_class()
-                submodule_rbln_config = submodule_rbln_config_class(**submodule_rbln_config)
-                setattr(rbln_config, submodule_name, submodule_rbln_config)
-
-            submodule_rbln_config = submodule_cls._update_submodule_config(model, submodule_rbln_config)
+                filtered_kwargs = rbln_config.filter_parameters(submodule_config_cls, submodule_rbln_config)
+                filtered_kwargs["cls_name"] = submodule_config_cls.__name__
+                submodule_rbln_config = submodule_config_cls(**filtered_kwargs)
+            elif not isinstance(submodule_rbln_config, submodule_config_cls):
+                config_dict = {k: v for k, v in submodule_rbln_config.__dict__.items() if not k.startswith("_")}
+                filtered_kwargs = rbln_config.filter_parameters(submodule_config_cls, config_dict)
+                filtered_kwargs["cls_name"] = submodule_config_cls.__name__
+                submodule_rbln_config = submodule_config_cls(**filtered_kwargs)
+
+            setattr(rbln_config, submodule_name, submodule_rbln_config)
+            submodule_rbln_config = submodule_cls._update_submodule_config(model, submodule_rbln_config, preprocessors)
 
             rbln_submodule = submodule_cls.from_model(
                 model=torch_submodule,

{optimum_rbln-0.8.2a4.dist-info → optimum_rbln-0.9.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: optimum-rbln
-Version: 0.8.2a4
+Version: 0.9.3
 Summary: Optimum RBLN is the interface between the HuggingFace Transformers and Diffusers libraries and RBLN accelerators. It provides a set of tools enabling easy model loading and inference on single and multiple rbln device settings for different downstream tasks.
 Project-URL: Homepage, https://rebellions.ai
 Project-URL: Documentation, https://docs.rbln.ai
@@ -20,15 +20,16 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Requires-Python: <3.13,>=3.9
+Requires-Python: <3.14,>=3.9
 Requires-Dist: accelerate>=1.0.1
-Requires-Dist: diffusers==0.34.0
+Requires-Dist: diffusers==0.35.2
 Requires-Dist: packaging>=24.1
-Requires-Dist: torch==2.7.0
-Requires-Dist: torchaudio<=2.7.0
-Requires-Dist: torchvision<=0.22.0
-Requires-Dist: transformers==4.51.3
+Requires-Dist: torch==2.8.0
+Requires-Dist: torchaudio<=2.8.0
+Requires-Dist: torchvision<=0.23.0
+Requires-Dist: transformers==4.57.1
 Description-Content-Type: text/markdown