rapidata 2.42.2__tar.gz → 2.42.4__tar.gz

{rapidata-2.42.2 → rapidata-2.42.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rapidata
-Version: 2.42.2
+Version: 2.42.4
 Summary: Rapidata package containing the Rapidata Python Client to interact with the Rapidata Web API in an easy way.
 License: Apache-2.0
 License-File: LICENSE

{rapidata-2.42.2 → rapidata-2.42.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "rapidata"
-version = "2.42.2"
+version = "2.42.4"
 description = "Rapidata package containing the Rapidata Python Client to interact with the Rapidata Web API in an easy way."
 authors = ["Rapidata AG <info@rapidata.ai>"]
 license = "Apache-2.0"

{rapidata-2.42.2 → rapidata-2.42.4}/src/rapidata/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2.42.2"
+__version__ = "2.42.4"
 
 from .rapidata_client import (
     RapidataClient,
@@ -31,7 +31,6 @@ from .rapidata_client import (
     AgeGroup,
     GenderFilter,
     Gender,
-    CountryCodes,
     Box,
     Datapoint,
     PromptMetadata,

{rapidata-2.42.2 → rapidata-2.42.4}/src/rapidata/rapidata_client/__init__.py

@@ -28,7 +28,6 @@ from .settings import (
     AllowNeitherBoth,
     SwapContextInstruction,
 )
-from .country_codes import CountryCodes
 from .filter import (
     CountryFilter,
     LanguageFilter,

{rapidata-2.42.2 → rapidata-2.42.4}/src/rapidata/rapidata_client/datapoints/metadata/_media_asset_metadata.py

@@ -6,13 +6,11 @@ from rapidata.api_client.models.multi_asset_input_assets_inner import (
     ExistingAssetInput,
     MultiAssetInputAssetsInner,
 )
+from pydantic import BaseModel
 
 
-class MediaAssetMetadata(Metadata):
-
-    def __init__(self, internal_file_name: str):
-        super().__init__()
-        self._internal_file_name = internal_file_name
+class MediaAssetMetadata(Metadata, BaseModel):
+    internal_file_name: str
 
     def to_model(self):
         return PromptAssetMetadataInput(
@@ -20,7 +18,7 @@ class MediaAssetMetadata(Metadata):
             asset=MultiAssetInputAssetsInner(
                 actual_instance=ExistingAssetInput(
                     _t="ExistingAssetInput",
-                    name=self._internal_file_name,
+                    name=self.internal_file_name,
                 ),
             ),
         )

rapidata-2.42.4/src/rapidata/rapidata_client/datapoints/metadata/_private_text_metadata.py

@@ -0,0 +1,16 @@
+from rapidata.api_client.models.private_text_metadata_input import (
+    PrivateTextMetadataInput,
+)
+from rapidata.rapidata_client.datapoints.metadata._base_metadata import Metadata
+from pydantic import BaseModel
+
+
+class PrivateTextMetadata(Metadata, BaseModel):
+
+    text: str
+    identifier: str = "private_text"
+
+    def to_model(self):
+        return PrivateTextMetadataInput(
+            _t="PrivateTextMetadataInput", identifier=self.identifier, text=self.text
+        )

{rapidata-2.42.2 → rapidata-2.42.4}/src/rapidata/rapidata_client/datapoints/metadata/_prompt_identifier_metadata.py

@@ -2,14 +2,13 @@ from rapidata.rapidata_client.datapoints.metadata._base_metadata import Metadata
 from rapidata.api_client.models.private_text_metadata_input import (
     PrivateTextMetadataInput,
 )
+from pydantic import BaseModel
 
 
-class PromptIdentifierMetadata(Metadata):
-    def __init__(self, identifier: str):
-        super().__init__()
-        self._identifier = identifier
+class PromptIdentifierMetadata(Metadata, BaseModel):
+    identifier: str
 
     def to_model(self):
         return PrivateTextMetadataInput(
-            _t="PrivateTextMetadataInput", identifier="prompt-id", text=self._identifier
+            _t="PrivateTextMetadataInput", identifier="prompt-id", text=self.identifier
         )

{rapidata-2.42.2 → rapidata-2.42.4}/src/rapidata/rapidata_client/datapoints/metadata/_prompt_metadata.py

@@ -1,17 +1,12 @@
 from rapidata.rapidata_client.datapoints.metadata._base_metadata import Metadata
 from rapidata.api_client.models.prompt_metadata_input import PromptMetadataInput
+from pydantic import BaseModel
 
 
-class PromptMetadata(Metadata):
+class PromptMetadata(Metadata, BaseModel):
     """The PromptMetadata class is used to display a prompt to the user."""
 
-    def __init__(self, prompt: str):
-        super().__init__()
-
-        if not isinstance(prompt, str):
-            raise ValueError("Prompt must be a string")
-
-        self._prompt = prompt
+    prompt: str
 
     def to_model(self):
-        return PromptMetadataInput(_t="PromptMetadataInput", prompt=self._prompt)
+        return PromptMetadataInput(_t="PromptMetadataInput", prompt=self.prompt)

rapidata-2.42.4/src/rapidata/rapidata_client/datapoints/metadata/_public_text_metadata.py

@@ -0,0 +1,16 @@
+from rapidata.api_client.models.public_text_metadata_input import (
+    PublicTextMetadataInput,
+)
+from rapidata.rapidata_client.datapoints.metadata._base_metadata import Metadata
+from pydantic import BaseModel
+
+
+class PublicTextMetadata(Metadata, BaseModel):
+
+    text: str
+    identifier: str = "public_text"
+
+    def to_model(self):
+        return PublicTextMetadataInput(
+            _t="PublicTextMetadataInput", identifier=self.identifier, text=self.text
+        )

{rapidata-2.42.2 → rapidata-2.42.4}/src/rapidata/rapidata_client/datapoints/metadata/_select_words_metadata.py

@@ -2,14 +2,13 @@ from rapidata.api_client.models.transcription_metadata_input import (
     TranscriptionMetadataInput,
 )
 from rapidata.rapidata_client.datapoints.metadata._base_metadata import Metadata
+from pydantic import BaseModel
 
 
-class SelectWordsMetadata(Metadata):
+class SelectWordsMetadata(Metadata, BaseModel):
     """SelectWordsMetadata Class is used to define the Sentence that will be display to the user."""
 
-    def __init__(self, select_words: str):
-        super().__init__()
-        self.select_words = select_words
+    select_words: str
 
     def to_model(self):
         return TranscriptionMetadataInput(

{rapidata-2.42.2 → rapidata-2.42.4}/src/rapidata/rapidata_client/demographic/demographic_manager.py

@@ -1,4 +1,3 @@
-from argparse import Action
 from rapidata.api_client import ExistingAssetInput
 from rapidata.api_client.models.create_demographic_rapid_model_asset import (
     CreateDemographicRapidModelAsset,

{rapidata-2.42.2 → rapidata-2.42.4}/src/rapidata/rapidata_client/filter/_base_filter.py

@@ -19,15 +19,15 @@ class RapidataFilter:
         # If self is already an OrFilter, extend its filters list
         if isinstance(self, OrFilter):
             if isinstance(other, OrFilter):
-                return OrFilter(self.filters + other.filters)
+                return OrFilter(filters=self.filters + other.filters)
             else:
-                return OrFilter(self.filters + [other])
+                return OrFilter(filters=self.filters + [other])
         # If other is an OrFilter, prepend self to its filters
         elif isinstance(other, OrFilter):
-            return OrFilter([self] + other.filters)
+            return OrFilter(filters=[self] + other.filters)
         # Neither is an OrFilter, create a new one
         else:
-            return OrFilter([self, other])
+            return OrFilter(filters=[self, other])
 
     def __and__(self, other):
         """Enable the & operator to create AndFilter combinations."""
@@ -39,15 +39,15 @@ class RapidataFilter:
         # If self is already an AndFilter, extend its filters list
         if isinstance(self, AndFilter):
             if isinstance(other, AndFilter):
-                return AndFilter(self.filters + other.filters)
+                return AndFilter(filters=self.filters + other.filters)
             else:
-                return AndFilter(self.filters + [other])
+                return AndFilter(filters=self.filters + [other])
         # If other is an AndFilter, prepend self to its filters
         elif isinstance(other, AndFilter):
-            return AndFilter([self] + other.filters)
+            return AndFilter(filters=[self] + other.filters)
         # Neither is an AndFilter, create a new one
         else:
-            return AndFilter([self, other])
+            return AndFilter(filters=[self, other])
 
     def __invert__(self):
         """Enable the ~ operator to create NotFilter negations."""
@@ -58,10 +58,4 @@ class RapidataFilter:
             return self.filter
         # Create a new NotFilter
         else:
-            return NotFilter(self)
-
-    def __str__(self) -> str:
-        return f"{self.__class__.__name__}()"
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}()"
+            return NotFilter(filter=self)

{rapidata-2.42.2 → rapidata-2.42.4}/src/rapidata/rapidata_client/filter/age_filter.py

@@ -1,29 +1,23 @@
-from typing import Any
 from rapidata.rapidata_client.filter._base_filter import RapidataFilter
 from rapidata.api_client.models.age_user_filter_model import AgeUserFilterModel
 from rapidata.rapidata_client.filter.models.age_group import AgeGroup
+from pydantic import BaseModel, ConfigDict
 
 
-class AgeFilter(RapidataFilter):
+class AgeFilter(RapidataFilter, BaseModel):
     """AgeFilter Class
 
     Can be used to filter who to target based on age groups.
 
-
     Args:
         age_groups (list[AgeGroup]): List of age groups to filter by."""
 
-    def __init__(self, age_groups: list[AgeGroup]):
-        self.age_groups = age_groups
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    age_groups: list[AgeGroup]
 
     def _to_model(self):
         return AgeUserFilterModel(
             _t="AgeFilter",
             ageGroups=[age_group._to_backend_model() for age_group in self.age_groups],
         )
-
-    def __str__(self) -> str:
-        return f"AgeFilter(age_groups={self.age_groups})"
-
-    def __repr__(self) -> str:
-        return f"AgeFilter(age_groups={self.age_groups!r})"

{rapidata-2.42.2 → rapidata-2.42.4}/src/rapidata/rapidata_client/filter/and_filter.py

@@ -4,9 +4,10 @@ from rapidata.api_client.models.and_user_filter_model import AndUserFilterModel
 from rapidata.api_client.models.and_user_filter_model_filters_inner import (
     AndUserFilterModelFiltersInner,
 )
+from pydantic import BaseModel, ConfigDict
 
 
-class AndFilter(RapidataFilter):
+class AndFilter(RapidataFilter, BaseModel):
     """A filter that combines multiple filters with a logical AND operation.
     This class implements a logical AND operation on a list of filters, where the condition is met if all of the filters' conditions are met.
 
@@ -23,11 +24,9 @@ class AndFilter(RapidataFilter):
         This will match users who have their phone set to English AND are located in the United States.
     """
 
-    def __init__(self, filters: list[RapidataFilter]):
-        if not all(isinstance(filter, RapidataFilter) for filter in filters):
-            raise ValueError("Filters must be a RapidataFilter object")
+    model_config = ConfigDict(arbitrary_types_allowed=True)
 
-        self.filters = filters
+    filters: list[RapidataFilter]
 
     def _to_model(self):
         return AndUserFilterModel(
@@ -37,9 +36,3 @@ class AndFilter(RapidataFilter):
                 for filter in self.filters
             ],
         )
-
-    def __str__(self) -> str:
-        return f"AndFilter(filters={self.filters})"
-
-    def __repr__(self) -> str:
-        return f"AndFilter(filters={self.filters!r})"

{rapidata-2.42.2 → rapidata-2.42.4}/src/rapidata/rapidata_client/filter/campaign_filter.py

@@ -1,11 +1,11 @@
-from typing import Any
 from rapidata.rapidata_client.filter._base_filter import RapidataFilter
 from rapidata.api_client.models.campaign_user_filter_model import (
     CampaignUserFilterModel,
 )
+from pydantic import BaseModel
 
 
-class CampaignFilter(RapidataFilter):
+class CampaignFilter(RapidataFilter, BaseModel):
     """CampaignFilter Class
 
     Can be used to filter who to target based on campaign IDs.
@@ -16,17 +16,10 @@ class CampaignFilter(RapidataFilter):
         campaign_ids (list[str]): List of campaign IDs to filter by.
     """
 
-    def __init__(self, campaign_ids: list[str]):
-        self.campaign_ids = campaign_ids
+    campaign_ids: list[str]
 
     def _to_model(self):
         return CampaignUserFilterModel(
             _t="CampaignFilter",
             campaignIds=self.campaign_ids,
         )
-
-    def __str__(self) -> str:
-        return f"CampaignFilter(campaign_ids={self.campaign_ids})"
-
-    def __repr__(self) -> str:
-        return f"CampaignFilter(campaign_ids={self.campaign_ids!r})"

rapidata-2.42.4/src/rapidata/rapidata_client/filter/country_filter.py

@@ -0,0 +1,35 @@
+from rapidata.rapidata_client.filter._base_filter import RapidataFilter
+from rapidata.api_client.models.country_user_filter_model import CountryUserFilterModel
+from pydantic import BaseModel, field_validator
+from rapidata.rapidata_client.config import logger
+
+
+class CountryFilter(RapidataFilter, BaseModel):
+    """CountryFilter Class
+
+    Can be used to filter who to target based on country codes.
+
+    Args:
+        country_codes (list[str]): List of country codes (capitalized) to filter by.
+    """
+
+    country_codes: list[str]
+
+    @field_validator("country_codes")
+    @classmethod
+    def validate_country_codes(cls, codes: list[str]) -> list[str]:
+        validated = []
+        for code in codes:
+            if len(code) != 2:
+                raise ValueError(
+                    f"Country codes must be length 2. Invalid code: '{code}'"
+                )
+            if code != code.upper():
+                logger.warning(
+                    f"Country code '{code}' should be uppercase. It will be uppercased automatically."
+                )
+            validated.append(code.upper())
+        return validated
+
+    def _to_model(self):
+        return CountryUserFilterModel(_t="CountryFilter", countries=self.country_codes)

{rapidata-2.42.2 → rapidata-2.42.4}/src/rapidata/rapidata_client/filter/custom_filter.py

@@ -1,9 +1,9 @@
-from typing import Any
 from rapidata.rapidata_client.filter._base_filter import RapidataFilter
 from rapidata.api_client.models.custom_user_filter_model import CustomUserFilterModel
+from pydantic import BaseModel
 
 
-class CustomFilter(RapidataFilter):
+class CustomFilter(RapidataFilter, BaseModel):
     """CustomFilter Class
 
     Can be used to filter who to target based on custom filters.
@@ -17,9 +17,8 @@ class CustomFilter(RapidataFilter):
         values (list[str]): List of values to filter by.
     """
 
-    def __init__(self, identifier: str, values: list[str]):
-        self.identifier = identifier
-        self.values = values
+    identifier: str
+    values: list[str]
 
     def _to_model(self):
         return CustomUserFilterModel(
@@ -27,9 +26,3 @@ class CustomFilter(RapidataFilter):
             identifier=self.identifier,
             values=self.values,
         )
-
-    def __str__(self) -> str:
-        return f"CustomFilter(identifier={self.identifier}, values={self.values})"
-
-    def __repr__(self) -> str:
-        return f"CustomFilter(identifier={self.identifier!r}, values={self.values!r})"

{rapidata-2.42.2 → rapidata-2.42.4}/src/rapidata/rapidata_client/filter/gender_filter.py

@@ -1,10 +1,10 @@
-from typing import Any
 from rapidata.rapidata_client.filter._base_filter import RapidataFilter
 from rapidata.api_client.models.gender_user_filter_model import GenderUserFilterModel
 from rapidata.rapidata_client.filter.models.gender import Gender
+from pydantic import BaseModel, ConfigDict
 
 
-class GenderFilter(RapidataFilter):
+class GenderFilter(RapidataFilter, BaseModel):
     """GenderFilter Class
 
     Can be used to filter who to target based on their gender.
@@ -13,17 +13,12 @@ class GenderFilter(RapidataFilter):
     Args:
         genders (list[Gender]): List of genders to filter by."""
 
-    def __init__(self, genders: list[Gender]):
-        self.genders = genders
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    genders: list[Gender]
 
     def _to_model(self):
         return GenderUserFilterModel(
             _t="GenderFilter",
             genders=[gender._to_backend_model() for gender in self.genders],
         )
-
-    def __str__(self) -> str:
-        return f"GenderFilter(genders={self.genders})"
-
-    def __repr__(self) -> str:
-        return f"GenderFilter(genders={self.genders!r})"

rapidata-2.42.4/src/rapidata/rapidata_client/filter/language_filter.py

@@ -0,0 +1,46 @@
+from rapidata.rapidata_client.filter._base_filter import RapidataFilter
+from rapidata.api_client.models.language_user_filter_model import (
+    LanguageUserFilterModel,
+)
+from pydantic import BaseModel, field_validator
+from rapidata.rapidata_client.config import logger
+
+
+class LanguageFilter(RapidataFilter, BaseModel):
+    """LanguageFilter Class
+
+    Can be used to filter who to target based on language codes.
+
+    Args:
+        language_codes (list[str]): List of language codes to filter by.
+
+    Example:
+        ```python
+        LanguageFilter(["en", "de"])
+        ```
+        This will limit the order to be shown to only people who have their phone set to english or german
+    """
+
+    language_codes: list[str]
+
+    @field_validator("language_codes")
+    @classmethod
+    def validate_language_codes(cls, codes: list[str]) -> list[str]:
+        validated = []
+        for code in codes:
+            if len(code) != 2:
+                raise ValueError(
+                    f"Language codes must be length 2. Invalid code: '{code}'"
+                )
+            if code != code.lower():
+                logger.warning(
+                    f"Language code '{code}' should be lowercase. It will be lowercased automatically."
+                )
+            validated.append(code.lower())
+        return validated
+
+    def _to_model(self):
+        return LanguageUserFilterModel(
+            _t="LanguageFilter",
+            languages=self.language_codes,
+        )

{rapidata-2.42.2 → rapidata-2.42.4}/src/rapidata/rapidata_client/filter/not_filter.py

@@ -4,9 +4,10 @@ from rapidata.api_client.models.not_user_filter_model import NotUserFilterModel
 from rapidata.api_client.models.and_user_filter_model_filters_inner import (
     AndUserFilterModelFiltersInner,
 )
+from pydantic import BaseModel, ConfigDict
 
 
-class NotFilter(RapidataFilter):
+class NotFilter(RapidataFilter, BaseModel):
     """A filter that negates another filter's condition.
     This class implements a logical NOT operation on a given filter, inverting its results.
 
@@ -23,20 +24,12 @@ class NotFilter(RapidataFilter):
         This will limit the order to be shown to only people who have their phone set to a language other than English.
     """
 
-    def __init__(self, filter: RapidataFilter):
-        if not isinstance(filter, RapidataFilter):
-            raise ValueError("Filter must be a RapidataFilter object")
+    model_config = ConfigDict(arbitrary_types_allowed=True)
 
-        self.filter = filter
+    filter: RapidataFilter
 
     def _to_model(self):
         return NotUserFilterModel(
             _t="NotFilter",
             filter=AndUserFilterModelFiltersInner(self.filter._to_model()),
         )
-
-    def __str__(self) -> str:
-        return f"NotFilter(filter={self.filter})"
-
-    def __repr__(self) -> str:
-        return f"NotFilter(filter={self.filter!r})"

{rapidata-2.42.2 → rapidata-2.42.4}/src/rapidata/rapidata_client/filter/or_filter.py

@@ -1,12 +1,12 @@
-from typing import Any
 from rapidata.rapidata_client.filter._base_filter import RapidataFilter
 from rapidata.api_client.models.or_user_filter_model import OrUserFilterModel
 from rapidata.api_client.models.and_user_filter_model_filters_inner import (
     AndUserFilterModelFiltersInner,
 )
+from pydantic import BaseModel, ConfigDict
 
 
-class OrFilter(RapidataFilter):
+class OrFilter(RapidataFilter, BaseModel):
     """A filter that combines multiple filters with a logical OR operation.
     This class implements a logical OR operation on a list of filters, where the condition is met if any of the filters' conditions are met.
 
@@ -23,11 +23,9 @@ class OrFilter(RapidataFilter):
         This will match users who either have their phone set to English OR are located in the United States.
     """
 
-    def __init__(self, filters: list[RapidataFilter]):
-        if not all(isinstance(filter, RapidataFilter) for filter in filters):
-            raise ValueError("Filters must be a RapidataFilter object")
+    model_config = ConfigDict(arbitrary_types_allowed=True)
 
-        self.filters = filters
+    filters: list[RapidataFilter]
 
     def _to_model(self):
         return OrUserFilterModel(
@@ -37,9 +35,3 @@ class OrFilter(RapidataFilter):
                 for filter in self.filters
             ],
         )
-
-    def __str__(self) -> str:
-        return f"OrFilter(filters={self.filters})"
-
-    def __repr__(self) -> str:
-        return f"OrFilter(filters={self.filters!r})"

{rapidata-2.42.2 → rapidata-2.42.4}/src/rapidata/rapidata_client/filter/response_count_filter.py

@@ -4,9 +4,10 @@ from rapidata.api_client.models.response_count_user_filter_model import (
     ResponseCountUserFilterModel,
 )
 from rapidata.api_client.models.comparison_operator import ComparisonOperator
+from pydantic import BaseModel, ConfigDict
 
 
-class ResponseCountFilter(RapidataFilter):
+class ResponseCountFilter(RapidataFilter, BaseModel):
     """ResponseCountFilter Class
     Can be used to filter users based on the number of responses they have given on validation tasks with the specified dimension.
 
@@ -34,13 +35,11 @@ class ResponseCountFilter(RapidataFilter):
         This will filter users who have a response count greater than 10 for the "electrical" dimension.
     """
 
-    def __init__(
-        self, response_count: int, dimension: str, operator: ComparisonOperator
-    ):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
 
-        self.response_count = response_count
-        self.dimension = dimension
-        self.operator = operator
+    response_count: int
+    dimension: str
+    operator: ComparisonOperator
 
     def _to_model(self):
         return ResponseCountUserFilterModel(
@@ -49,9 +48,3 @@ class ResponseCountFilter(RapidataFilter):
             dimension=self.dimension,
             operator=self.operator,
         )
-
-    def __str__(self) -> str:
-        return f"ResponseCountFilter(response_count={self.response_count}, dimension={self.dimension}, operator={self.operator})"
-
-    def __repr__(self) -> str:
-        return f"ResponseCountFilter(response_count={self.response_count!r}, dimension={self.dimension!r}, operator={self.operator!r})"

rapidata-2.42.4/src/rapidata/rapidata_client/filter/user_score_filter.py

@@ -0,0 +1,49 @@
+from pydantic_core.core_schema import FieldValidationInfo
+from rapidata.rapidata_client.filter._base_filter import RapidataFilter
+from rapidata.api_client.models.user_score_user_filter_model import (
+    UserScoreUserFilterModel,
+)
+from pydantic import BaseModel, field_validator, model_validator
+
+
+class UserScoreFilter(RapidataFilter, BaseModel):
+    """UserScoreFilter Class
+
+    Can be used to filter who to target based on their user score.
+
+    Args:
+        lower_bound (float): The lower bound of the user score.
+        upper_bound (float): The upper bound of the user score.
+        dimension (str): The dimension of the userScore to be considerd for the filter.
+
+    Example:
+        ```python
+        UserScoreFilter(0.5, 0.9)
+        ```
+        This will only show the order to users that have a UserScore of >=0.5 and <=0.9
+    """
+
+    lower_bound: float = 0.0
+    upper_bound: float = 1.0
+    dimension: str | None = None
+
+    @field_validator("lower_bound", "upper_bound")
+    @classmethod
+    def validate_bounds(cls, v: float, info: FieldValidationInfo) -> float:
+        if v < 0 or v > 1:
+            raise ValueError(f"{info.field_name} must be between 0 and 1")
+        return v
+
+    @model_validator(mode="after")
+    def validate_bounds_relationship(self) -> "UserScoreFilter":
+        if self.lower_bound >= self.upper_bound:
+            raise ValueError("lower_bound must be less than upper_bound")
+        return self
+
+    def _to_model(self):
+        return UserScoreUserFilterModel(
+            _t="UserScoreFilter",
+            upperbound=self.upper_bound,
+            lowerbound=self.lower_bound,
+            dimension=self.dimension,
+        )