optimum-rbln 0.9.3rc0__py3-none-any.whl → 0.9.5a4__py3-none-any.whl

optimum/rbln/transformers/models/xlm_roberta/modeling_xlm_roberta.py

@@ -12,6 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from typing import Optional, Union
+
+import torch
+from transformers.modeling_outputs import BaseModelOutputWithPoolingAndCrossAttentions, SequenceClassifierOutput
+
 from ...modeling_generic import RBLNModelForSequenceClassification, RBLNTransformerEncoderForFeatureExtraction
 
 
@@ -20,6 +25,30 @@ class RBLNXLMRobertaModel(RBLNTransformerEncoderForFeatureExtraction):
     XLM-RoBERTa base model optimized for RBLN NPU.
     """
 
+    def forward(
+        self,
+        input_ids: Optional[torch.Tensor] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        token_type_ids: Optional[torch.Tensor] = None,
+        **kwargs,
+    ) -> Union[BaseModelOutputWithPoolingAndCrossAttentions, tuple]:
+        """
+        Forward pass for the RBLN-optimized XLM-RoBERTa base model.
+
+        Args:
+            input_ids (torch.Tensor of shape (batch_size, sequence_length), optional): Indices of input sequence tokens in the vocabulary.
+            attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional): Mask to avoid performing attention on padding token indices.
+            token_type_ids (torch.Tensor of shape (batch_size, sequence_length), optional): Segment token indices to indicate different portions of the inputs.
+
+        Returns:
+            The model outputs. If return_dict=False is passed, returns a tuple of tensors. Otherwise, returns a BaseModelOutputWithPoolingAndCrossAttentions object.
+        """
+
+        if token_type_ids is not None:
+            kwargs.setdefault("token_type_ids", token_type_ids)
+
+        return super().forward(input_ids=input_ids, attention_mask=attention_mask, **kwargs)
+
 
 class RBLNXLMRobertaForSequenceClassification(RBLNModelForSequenceClassification):
     """
@@ -27,3 +56,27 @@ class RBLNXLMRobertaForSequenceClassification(RBLNModelForSequenceClassification
     """
 
     rbln_model_input_names = ["input_ids", "attention_mask"]
+
+    def forward(
+        self,
+        input_ids: Optional[torch.LongTensor] = None,
+        attention_mask: Optional[torch.FloatTensor] = None,
+        token_type_ids: Optional[torch.LongTensor] = None,
+        **kwargs,
+    ) -> Union[SequenceClassifierOutput, tuple]:
+        """
+        Forward pass for the RBLN-optimized XLM-RoBERTa model for sequence classification.
+
+        Args:
+            input_ids (torch.LongTensor of shape (batch_size, sequence_length), optional): Indices of input sequence tokens in the vocabulary.
+            attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional): Mask to avoid performing attention on padding token indices.
+            token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional): Segment token indices to indicate first and second portions of the inputs.
+
+        Returns:
+            The model outputs. If return_dict=False is passed, returns a tuple of tensors. Otherwise, returns a SequenceClassifierOutput object.
+        """
+
+        if token_type_ids is not None:
+            kwargs.setdefault("token_type_ids", token_type_ids)
+
+        return super().forward(input_ids=input_ids, attention_mask=attention_mask, **kwargs)

optimum/rbln/transformers/utils/rbln_quantization.py

@@ -123,6 +123,15 @@ class RBLNQuantizationConfig(RBLNSerializableConfigProtocol):
         if self.RBLN_QUANT_BITS_ENV in os.environ:
             os.environ.pop(self.RBLN_QUANT_BITS_ENV)
 
+    @property
+    def nbits_per_param(self) -> int:
+        if self.weights in ["int4", "fp4"]:
+            return 4
+        elif self.weights in ["int8", "fp8"]:
+            return 8
+        else:
+            raise ValueError(f"Invalid weights: {self.weights}")
+
 
 class QuantizedLayerFactory:
     def __init__(self, quantization_config: RBLNQuantizationConfig):
@@ -212,11 +221,12 @@ def load_weight_files(
     cache_dir: Optional[str] = None,
     force_download: bool = False,
     local_files_only: bool = False,
+    exception_keywords: Optional[List[str]] = None,
 ) -> list[str]:
     """
     Discover and download safetensors files for the given model id.
     """
-
+    exception_keywords = exception_keywords or []
     if os.path.isdir(model_id):
         safetensor_files = glob.glob(f"{model_id}/*.safetensors")
     else:
@@ -228,17 +238,24 @@ def load_weight_files(
 
             for file in repo_files:
                 if file.endswith(".safetensors"):
-                    # Download the safetensors file
-                    downloaded_file = hf_hub_download(
-                        repo_id=model_id,
-                        filename=file,
-                        revision=revision,
-                        token=use_auth_token,
-                        cache_dir=cache_dir,
-                        force_download=force_download,
-                        local_files_only=local_files_only,
-                    )
-                    safetensor_files.append(downloaded_file)
+                    exculde = False
+                    for except_key in exception_keywords:
+                        if except_key in file:
+                            exculde = True
+                            break
+
+                    if not exculde:
+                        # Download the safetensors file
+                        downloaded_file = hf_hub_download(
+                            repo_id=model_id,
+                            filename=file,
+                            revision=revision,
+                            token=use_auth_token,
+                            cache_dir=cache_dir,
+                            force_download=force_download,
+                            local_files_only=local_files_only,
+                        )
+                        safetensor_files.append(downloaded_file)
         except Exception as e:
             logger.error(f"Failed to download safetensors files from Hugging Face Hub: {e}")
             raise e

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/import_utils.py

@@ -136,13 +136,32 @@ def is_rbln_available() -> bool:
 
 def check_version_compats() -> None:
     warnings.filterwarnings(action="always", category=ImportWarning, module="optimum.rbln")
-    my_version = importlib.metadata.version("optimum-rbln")
+    try:
+        my_version = importlib.metadata.version("optimum-rbln")
+    except importlib.metadata.PackageNotFoundError:
+        # Common dev case: running from source (e.g. PYTHONPATH=src) without installing the package.
+        # package metadata doesn't exist, so fall back to the in-repo version file.
+        try:
+            from optimum.rbln.__version__ import __version__ as my_version  # type: ignore
+        except Exception:
+            warnings.warn(
+                "Could not determine optimum-rbln version (package metadata missing). "
+                "If you are running from source, consider `pip install -e .` to install metadata.",
+                ImportWarning,
+                stacklevel=2,
+            )
+            return
+
     target_version = list(filter(lambda v: Version(my_version) >= Version(v), RBLN_VERSION_COMPATS.keys()))[0]
     for compat in RBLN_VERSION_COMPATS[target_version]:
         try:
             dep_version = importlib.metadata.version(compat.package_name)
         except importlib.metadata.PackageNotFoundError:
-            warnings.warn(f"optimum-rbln requires {compat.package_name} to be installed.", ImportWarning)
+            warnings.warn(
+                f"optimum-rbln requires {compat.package_name} to be installed.",
+                ImportWarning,
+                stacklevel=2,
+            )
             continue
         # For versions 0.7.2 and above, don't show warning for rebel-compiler if base versions match
 
@@ -160,6 +179,7 @@ def check_version_compats() -> None:
                     f"For optimal performance and compatibility, please ensure both packages share the same major and minor version numbers. "
                     "Please refer to our SDK release notes at https://docs.rbln.ai/about_atom/release_note.html",
                     ImportWarning,
+                    stacklevel=2,
                 )
         else:
             if not Version(compat.min_version) <= Version(dep_version) < Version(compat.max_version):
@@ -167,4 +187,5 @@ def check_version_compats() -> None:
                     f"optimum-rbln v{my_version} is compatible to {compat.package_name} v{compat.min_version} to v{compat.max_version}. (you are currently using v{dep_version})\n"
                     "Please refer to our SDK release notes at https://docs.rbln.ai/about_atom/release_note.html",
                     ImportWarning,
+                    stacklevel=2,
                 )

optimum/rbln/utils/runtime_utils.py

@@ -20,6 +20,42 @@ import rebel
 import torch
 
 
+def is_compiler_supports_buffer_resize() -> bool:
+    return hasattr(rebel.RBLNCompiledModel, "exp_multiply_buffer_size")
+
+
+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)
@@ -43,12 +79,6 @@ def tp_and_devices_are_ok(
     if tensor_parallel_size is None:
         tensor_parallel_size = 1
 
-    if rebel.device_count() < tensor_parallel_size:
-        return (
-            f"Tensor parallel size {tensor_parallel_size} is greater than "
-            f"the number of available devices {rebel.device_count()}."
-        )
-
     if device is None:
         device = list(range(tensor_parallel_size))
     elif isinstance(device, int):
@@ -71,6 +101,12 @@ def tp_and_devices_are_ok(
                 f"Device {device_id} is not a valid NPU device. Please check your NPU status with 'rbln-stat' command."
             )
 
+    if rebel.device_count() < tensor_parallel_size:
+        return (
+            f"Tensor parallel size {tensor_parallel_size} is greater than "
+            f"the number of available devices {rebel.device_count()}."
+        )
+
     if npu is not None:
         for device_id in device:
             npu_name = rebel.get_npu_name(device_id)

optimum/rbln/utils/submodule.py

@@ -37,7 +37,9 @@ class SubModulesMixin:
 
     _rbln_submodules: List[Dict[str, Any]] = []
 
-    def __init__(self, *, rbln_submodules: List["RBLNModel"] = [], **kwargs) -> None:
+    def __init__(self, *, rbln_submodules: Optional[List["RBLNModel"]] = None, **kwargs) -> None:
+        if rbln_submodules is None:
+            rbln_submodules = []
         for submodule_meta, submodule in zip(self._rbln_submodules, rbln_submodules):
             setattr(self, submodule_meta["name"], submodule)
 
@@ -59,12 +61,25 @@ class SubModulesMixin:
     ):
         return rbln_config
 
+    @classmethod
+    def _update_submodule_rbln_config(
+        cls,
+        submodule_name: str,
+        submodule_cls: Type["RBLNModel"],
+        model: "PreTrainedModel",
+        submodule_config: PretrainedConfig,
+        submodule_rbln_config: RBLNModelConfig,
+        preprocessors: Optional[Union["AutoFeatureExtractor", "AutoProcessor", "AutoTokenizer"]],
+    ):
+        return submodule_rbln_config
+
     @classmethod
     def _export_submodules_from_model(
         cls, model: "PreTrainedModel", model_save_dir: str, rbln_config: RBLNModelConfig, **kwargs
     ) -> List["RBLNModel"]:
         rbln_submodules = []
         submodule_prefix = getattr(cls, "_rbln_submodule_prefix", None)
+        submodule_postfix = getattr(cls, "_rbln_submodule_postfix", None)
         preprocessors = kwargs.pop("preprocessors", [])
 
         for submodule in cls._rbln_submodules:
@@ -72,6 +87,9 @@ class SubModulesMixin:
             if submodule_prefix is not None:
                 torch_submodule: PreTrainedModel = getattr(model, submodule_prefix)
                 torch_submodule = getattr(torch_submodule, submodule_name)
+            elif submodule_postfix is not None:
+                torch_submodule: PreTrainedModel = getattr(model, submodule_name)
+                torch_submodule = getattr(torch_submodule, submodule_postfix)
             else:
                 torch_submodule: PreTrainedModel = getattr(model, submodule_name)
 
@@ -90,6 +108,14 @@ class SubModulesMixin:
                 filtered_kwargs["cls_name"] = submodule_config_cls.__name__
                 submodule_rbln_config = submodule_config_cls(**filtered_kwargs)
 
+            submodule_rbln_config = cls._update_submodule_rbln_config(
+                submodule_name=submodule_name,
+                submodule_cls=submodule_cls,
+                model=model,
+                submodule_config=torch_submodule.config,
+                submodule_rbln_config=submodule_rbln_config,
+                preprocessors=preprocessors,
+            )
             setattr(rbln_config, submodule_name, submodule_rbln_config)
             submodule_rbln_config = submodule_cls._update_submodule_config(model, submodule_rbln_config, preprocessors)
 

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

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: optimum-rbln
-Version: 0.9.3rc0
+Version: 0.9.5a4
 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
-Project-URL: Repository, https://github.com/rebellions-sw/optimum-rbln
+Project-URL: Repository, https://github.com/rbln-sw/optimum-rbln
 Author-email: "Rebellions Inc." <support@rebellions.ai>
 License-Expression: Apache-2.0
 License-File: LICENSE
@@ -24,12 +24,12 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: <3.14,>=3.9
 Requires-Dist: accelerate>=1.0.1
-Requires-Dist: diffusers==0.35.1
+Requires-Dist: diffusers==0.36.0
 Requires-Dist: packaging>=24.1
 Requires-Dist: torch==2.8.0
 Requires-Dist: torchaudio<=2.8.0
 Requires-Dist: torchvision<=0.23.0
-Requires-Dist: transformers==4.57.1
+Requires-Dist: transformers==4.57.3
 Description-Content-Type: text/markdown
 
 
@@ -40,7 +40,7 @@ Description-Content-Type: text/markdown
 <img src="assets/rbln_logo.png" width="60%"/>
 
 [![PyPI version](https://badge.fury.io/py/optimum-rbln.svg)](https://badge.fury.io/py/optimum-rbln)
-[![License](https://img.shields.io/github/license/rebellions-sw/optimum-rbln)](https://github.com/rebellions-sw/optimum-rbln/blob/main/LICENSE)
+[![License](https://img.shields.io/github/license/rbln-sw/optimum-rbln)](https://github.com/rbln-sw/optimum-rbln/blob/main/LICENSE)
 [![Documentation](https://img.shields.io/badge/docs-available-brightgreen)](https://docs.rbln.ai/software/optimum/optimum_rbln.html)
 [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](CODE_OF_CONDUCT.md)
 
@@ -113,7 +113,7 @@ pip install optimum-rbln --extra-index-url https://download.pytorch.org/whl/cpu
 The below command installs `optimum-rbln` along with its dependencies.
 
 ```bash
-git clone https://github.com/rebellions-sw/optimum-rbln.git
+git clone https://github.com/rbln-sw/optimum-rbln.git
 cd optimum-rbln
 ./scripts/uv-sync.sh
 ```