pulumi-std 2.3.0__py3-none-any.whl

pulumi_std/log.py

@@ -0,0 +1,72 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins as _builtins
+import warnings
+import sys
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
+from . import _utilities
+
+__all__ = [
+    'LogResult',
+    'AwaitableLogResult',
+    'log',
+    'log_output',
+]
+
+@pulumi.output_type
+class LogResult:
+    def __init__(__self__, result=None):
+        if result and not isinstance(result, float):
+            raise TypeError("Expected argument 'result' to be a float")
+        pulumi.set(__self__, "result", result)
+
+    @_builtins.property
+    @pulumi.getter
+    def result(self) -> _builtins.float:
+        return pulumi.get(self, "result")
+
+
+class AwaitableLogResult(LogResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return LogResult(
+            result=self.result)
+
+
+def log(base: Optional[_builtins.float] = None,
+        input: Optional[_builtins.float] = None,
+        opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableLogResult:
+    """
+    Returns the greatest integer value less than or equal to the argument.
+    """
+    __args__ = dict()
+    __args__['base'] = base
+    __args__['input'] = input
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('std:index:log', __args__, opts=opts, typ=LogResult).value
+
+    return AwaitableLogResult(
+        result=pulumi.get(__ret__, 'result'))
+def log_output(base: Optional[pulumi.Input[_builtins.float]] = None,
+               input: Optional[pulumi.Input[_builtins.float]] = None,
+               opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[LogResult]:
+    """
+    Returns the greatest integer value less than or equal to the argument.
+    """
+    __args__ = dict()
+    __args__['base'] = base
+    __args__['input'] = input
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('std:index:log', __args__, opts=opts, typ=LogResult)
+    return __ret__.apply(lambda __response__: LogResult(
+        result=pulumi.get(__response__, 'result')))

pulumi_std/lookup.py

@@ -0,0 +1,76 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins as _builtins
+import warnings
+import sys
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
+from . import _utilities
+
+__all__ = [
+    'LookupResult',
+    'AwaitableLookupResult',
+    'lookup',
+    'lookup_output',
+]
+
+@pulumi.output_type
+class LookupResult:
+    def __init__(__self__, result=None):
+        if result and not isinstance(result, dict):
+            raise TypeError("Expected argument 'result' to be a dict")
+        pulumi.set(__self__, "result", result)
+
+    @_builtins.property
+    @pulumi.getter
+    def result(self) -> Any:
+        return pulumi.get(self, "result")
+
+
+class AwaitableLookupResult(LookupResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return LookupResult(
+            result=self.result)
+
+
+def lookup(default: Optional[Any] = None,
+           key: Optional[_builtins.str] = None,
+           map: Optional[Mapping[str, Any]] = None,
+           opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableLookupResult:
+    """
+    Performs a dynamic lookup into a map variable.
+    """
+    __args__ = dict()
+    __args__['default'] = default
+    __args__['key'] = key
+    __args__['map'] = map
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('std:index:lookup', __args__, opts=opts, typ=LookupResult).value
+
+    return AwaitableLookupResult(
+        result=pulumi.get(__ret__, 'result'))
+def lookup_output(default: Optional[pulumi.Input[Optional[Any]]] = None,
+                  key: Optional[pulumi.Input[_builtins.str]] = None,
+                  map: Optional[pulumi.Input[Mapping[str, Any]]] = None,
+                  opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[LookupResult]:
+    """
+    Performs a dynamic lookup into a map variable.
+    """
+    __args__ = dict()
+    __args__['default'] = default
+    __args__['key'] = key
+    __args__['map'] = map
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('std:index:lookup', __args__, opts=opts, typ=LookupResult)
+    return __ret__.apply(lambda __response__: LookupResult(
+        result=pulumi.get(__response__, 'result')))

pulumi_std/lower.py

@@ -0,0 +1,68 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins as _builtins
+import warnings
+import sys
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
+from . import _utilities
+
+__all__ = [
+    'LowerResult',
+    'AwaitableLowerResult',
+    'lower',
+    'lower_output',
+]
+
+@pulumi.output_type
+class LowerResult:
+    def __init__(__self__, result=None):
+        if result and not isinstance(result, str):
+            raise TypeError("Expected argument 'result' to be a str")
+        pulumi.set(__self__, "result", result)
+
+    @_builtins.property
+    @pulumi.getter
+    def result(self) -> _builtins.str:
+        return pulumi.get(self, "result")
+
+
+class AwaitableLowerResult(LowerResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return LowerResult(
+            result=self.result)
+
+
+def lower(input: Optional[_builtins.str] = None,
+          opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableLowerResult:
+    """
+    Returns a copy of the string with all Unicode letters mapped to their lower case.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('std:index:lower', __args__, opts=opts, typ=LowerResult).value
+
+    return AwaitableLowerResult(
+        result=pulumi.get(__ret__, 'result'))
+def lower_output(input: Optional[pulumi.Input[_builtins.str]] = None,
+                 opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[LowerResult]:
+    """
+    Returns a copy of the string with all Unicode letters mapped to their lower case.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('std:index:lower', __args__, opts=opts, typ=LowerResult)
+    return __ret__.apply(lambda __response__: LowerResult(
+        result=pulumi.get(__response__, 'result')))

pulumi_std/map.py

@@ -0,0 +1,68 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins as _builtins
+import warnings
+import sys
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
+from . import _utilities
+
+__all__ = [
+    'MapResult',
+    'AwaitableMapResult',
+    'map',
+    'map_output',
+]
+
+@pulumi.output_type
+class MapResult:
+    def __init__(__self__, result=None):
+        if result and not isinstance(result, dict):
+            raise TypeError("Expected argument 'result' to be a dict")
+        pulumi.set(__self__, "result", result)
+
+    @_builtins.property
+    @pulumi.getter
+    def result(self) -> Mapping[str, Any]:
+        return pulumi.get(self, "result")
+
+
+class AwaitableMapResult(MapResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return MapResult(
+            result=self.result)
+
+
+def map(args: Optional[Sequence[Any]] = None,
+        opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableMapResult:
+    """
+    Returns a map consisting of the key/value pairs specified as arguments.
+    """
+    __args__ = dict()
+    __args__['args'] = args
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('std:index:map', __args__, opts=opts, typ=MapResult).value
+
+    return AwaitableMapResult(
+        result=pulumi.get(__ret__, 'result'))
+def map_output(args: Optional[pulumi.Input[Sequence[Any]]] = None,
+               opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[MapResult]:
+    """
+    Returns a map consisting of the key/value pairs specified as arguments.
+    """
+    __args__ = dict()
+    __args__['args'] = args
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('std:index:map', __args__, opts=opts, typ=MapResult)
+    return __ret__.apply(lambda __response__: MapResult(
+        result=pulumi.get(__response__, 'result')))

pulumi_std/matchkeys.py

@@ -0,0 +1,74 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins as _builtins
+import warnings
+import sys
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
+from . import _utilities
+
+__all__ = [
+    'MatchkeysResult',
+    'AwaitableMatchkeysResult',
+    'matchkeys',
+    'matchkeys_output',
+]
+
+@pulumi.output_type
+class MatchkeysResult:
+    def __init__(__self__, result=None):
+        if result and not isinstance(result, list):
+            raise TypeError("Expected argument 'result' to be a list")
+        pulumi.set(__self__, "result", result)
+
+    @_builtins.property
+    @pulumi.getter
+    def result(self) -> Sequence[_builtins.str]:
+        return pulumi.get(self, "result")
+
+
+class AwaitableMatchkeysResult(MatchkeysResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return MatchkeysResult(
+            result=self.result)
+
+
+def matchkeys(search_list: Optional[Sequence[_builtins.str]] = None,
+              values: Optional[Sequence[_builtins.str]] = None,
+              opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableMatchkeysResult:
+    """
+    For two lists values and keys of equal length,
+    returns all elements from values where the corresponding element from keys exists in the searchset list.
+    """
+    __args__ = dict()
+    __args__['searchList'] = search_list
+    __args__['values'] = values
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('std:index:matchkeys', __args__, opts=opts, typ=MatchkeysResult).value
+
+    return AwaitableMatchkeysResult(
+        result=pulumi.get(__ret__, 'result'))
+def matchkeys_output(search_list: Optional[pulumi.Input[Sequence[_builtins.str]]] = None,
+                     values: Optional[pulumi.Input[Sequence[_builtins.str]]] = None,
+                     opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[MatchkeysResult]:
+    """
+    For two lists values and keys of equal length,
+    returns all elements from values where the corresponding element from keys exists in the searchset list.
+    """
+    __args__ = dict()
+    __args__['searchList'] = search_list
+    __args__['values'] = values
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('std:index:matchkeys', __args__, opts=opts, typ=MatchkeysResult)
+    return __ret__.apply(lambda __response__: MatchkeysResult(
+        result=pulumi.get(__response__, 'result')))

pulumi_std/max.py

@@ -0,0 +1,68 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins as _builtins
+import warnings
+import sys
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
+from . import _utilities
+
+__all__ = [
+    'MaxResult',
+    'AwaitableMaxResult',
+    'max',
+    'max_output',
+]
+
+@pulumi.output_type
+class MaxResult:
+    def __init__(__self__, result=None):
+        if result and not isinstance(result, float):
+            raise TypeError("Expected argument 'result' to be a float")
+        pulumi.set(__self__, "result", result)
+
+    @_builtins.property
+    @pulumi.getter
+    def result(self) -> _builtins.float:
+        return pulumi.get(self, "result")
+
+
+class AwaitableMaxResult(MaxResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return MaxResult(
+            result=self.result)
+
+
+def max(input: Optional[Sequence[_builtins.float]] = None,
+        opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableMaxResult:
+    """
+    Returns the largest of the floats.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('std:index:max', __args__, opts=opts, typ=MaxResult).value
+
+    return AwaitableMaxResult(
+        result=pulumi.get(__ret__, 'result'))
+def max_output(input: Optional[pulumi.Input[Sequence[_builtins.float]]] = None,
+               opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[MaxResult]:
+    """
+    Returns the largest of the floats.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('std:index:max', __args__, opts=opts, typ=MaxResult)
+    return __ret__.apply(lambda __response__: MaxResult(
+        result=pulumi.get(__response__, 'result')))

pulumi_std/md5.py

@@ -0,0 +1,68 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins as _builtins
+import warnings
+import sys
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
+from . import _utilities
+
+__all__ = [
+    'Md5Result',
+    'AwaitableMd5Result',
+    'md5',
+    'md5_output',
+]
+
+@pulumi.output_type
+class Md5Result:
+    def __init__(__self__, result=None):
+        if result and not isinstance(result, str):
+            raise TypeError("Expected argument 'result' to be a str")
+        pulumi.set(__self__, "result", result)
+
+    @_builtins.property
+    @pulumi.getter
+    def result(self) -> _builtins.str:
+        return pulumi.get(self, "result")
+
+
+class AwaitableMd5Result(Md5Result):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return Md5Result(
+            result=self.result)
+
+
+def md5(input: Optional[_builtins.str] = None,
+        opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableMd5Result:
+    """
+    Returns a (conventional) hexadecimal representation of the MD5 hash of the given string.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('std:index:md5', __args__, opts=opts, typ=Md5Result).value
+
+    return AwaitableMd5Result(
+        result=pulumi.get(__ret__, 'result'))
+def md5_output(input: Optional[pulumi.Input[_builtins.str]] = None,
+               opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[Md5Result]:
+    """
+    Returns a (conventional) hexadecimal representation of the MD5 hash of the given string.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('std:index:md5', __args__, opts=opts, typ=Md5Result)
+    return __ret__.apply(lambda __response__: Md5Result(
+        result=pulumi.get(__response__, 'result')))

pulumi_std/merge.py

@@ -0,0 +1,70 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins as _builtins
+import warnings
+import sys
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
+from . import _utilities
+
+__all__ = [
+    'MergeResult',
+    'AwaitableMergeResult',
+    'merge',
+    'merge_output',
+]
+
+@pulumi.output_type
+class MergeResult:
+    def __init__(__self__, result=None):
+        if result and not isinstance(result, dict):
+            raise TypeError("Expected argument 'result' to be a dict")
+        pulumi.set(__self__, "result", result)
+
+    @_builtins.property
+    @pulumi.getter
+    def result(self) -> Mapping[str, Any]:
+        return pulumi.get(self, "result")
+
+
+class AwaitableMergeResult(MergeResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return MergeResult(
+            result=self.result)
+
+
+def merge(input: Optional[Sequence[Mapping[str, Any]]] = None,
+          opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableMergeResult:
+    """
+    Returns the union of 2 or more maps. The maps are consumed in the order provided,
+    and duplicate keys overwrite previous entries.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('std:index:merge', __args__, opts=opts, typ=MergeResult).value
+
+    return AwaitableMergeResult(
+        result=pulumi.get(__ret__, 'result'))
+def merge_output(input: Optional[pulumi.Input[Sequence[Mapping[str, Any]]]] = None,
+                 opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[MergeResult]:
+    """
+    Returns the union of 2 or more maps. The maps are consumed in the order provided,
+    and duplicate keys overwrite previous entries.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('std:index:merge', __args__, opts=opts, typ=MergeResult)
+    return __ret__.apply(lambda __response__: MergeResult(
+        result=pulumi.get(__response__, 'result')))

pulumi_std/min.py

@@ -0,0 +1,68 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins as _builtins
+import warnings
+import sys
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
+from . import _utilities
+
+__all__ = [
+    'MinResult',
+    'AwaitableMinResult',
+    'min',
+    'min_output',
+]
+
+@pulumi.output_type
+class MinResult:
+    def __init__(__self__, result=None):
+        if result and not isinstance(result, float):
+            raise TypeError("Expected argument 'result' to be a float")
+        pulumi.set(__self__, "result", result)
+
+    @_builtins.property
+    @pulumi.getter
+    def result(self) -> _builtins.float:
+        return pulumi.get(self, "result")
+
+
+class AwaitableMinResult(MinResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return MinResult(
+            result=self.result)
+
+
+def min(input: Optional[Sequence[_builtins.float]] = None,
+        opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableMinResult:
+    """
+    Returns the smallest of the floats.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('std:index:min', __args__, opts=opts, typ=MinResult).value
+
+    return AwaitableMinResult(
+        result=pulumi.get(__ret__, 'result'))
+def min_output(input: Optional[pulumi.Input[Sequence[_builtins.float]]] = None,
+               opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[MinResult]:
+    """
+    Returns the smallest of the floats.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('std:index:min', __args__, opts=opts, typ=MinResult)
+    return __ret__.apply(lambda __response__: MinResult(
+        result=pulumi.get(__response__, 'result')))