pulumi-snowflake 0.57.0a1721977458__py3-none-any.whl → 0.57.0a1722246300__py3-none-any.whl

pulumi_snowflake/get_roles.py

@@ -22,13 +22,16 @@ class GetRolesResult:
     """
     A collection of values returned by getRoles.
     """
-    def __init__(__self__, id=None, pattern=None, roles=None):
+    def __init__(__self__, id=None, in_class=None, like=None, roles=None):
         if id and not isinstance(id, str):
             raise TypeError("Expected argument 'id' to be a str")
         pulumi.set(__self__, "id", id)
-        if pattern and not isinstance(pattern, str):
-            raise TypeError("Expected argument 'pattern' to be a str")
-        pulumi.set(__self__, "pattern", pattern)
+        if in_class and not isinstance(in_class, str):
+            raise TypeError("Expected argument 'in_class' to be a str")
+        pulumi.set(__self__, "in_class", in_class)
+        if like and not isinstance(like, str):
+            raise TypeError("Expected argument 'like' to be a str")
+        pulumi.set(__self__, "like", like)
         if roles and not isinstance(roles, list):
             raise TypeError("Expected argument 'roles' to be a list")
         pulumi.set(__self__, "roles", roles)
@@ -41,19 +44,27 @@ class GetRolesResult:
         """
         return pulumi.get(self, "id")
 
+    @property
+    @pulumi.getter(name="inClass")
+    def in_class(self) -> Optional[str]:
+        """
+        Filters the SHOW GRANTS output by class name.
+        """
+        return pulumi.get(self, "in_class")
+
     @property
     @pulumi.getter
-    def pattern(self) -> Optional[str]:
+    def like(self) -> Optional[str]:
         """
-        Filters the command output by object name.
+        Filters the output with **case-insensitive** pattern, with support for SQL wildcard characters (`%` and `_`).
         """
-        return pulumi.get(self, "pattern")
+        return pulumi.get(self, "like")
 
     @property
     @pulumi.getter
     def roles(self) -> Sequence['outputs.GetRolesRoleResult']:
         """
-        List of all the roles which you can view across your entire account, including the system-defined roles and any custom roles that exist.
+        Holds the aggregated output of all role details queries.
         """
         return pulumi.get(self, "roles")
 
@@ -65,52 +76,47 @@ class AwaitableGetRolesResult(GetRolesResult):
             yield self
         return GetRolesResult(
             id=self.id,
-            pattern=self.pattern,
+            in_class=self.in_class,
+            like=self.like,
             roles=self.roles)
 
 
-def get_roles(pattern: Optional[str] = None,
+def get_roles(in_class: Optional[str] = None,
+              like: Optional[str] = None,
               opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetRolesResult:
     """
-    ## Example Usage
-
-    ```python
-    import pulumi
-    import pulumi_snowflake as snowflake
+    !> **V1 release candidate** This resource was reworked and is a release candidate for the V1. We do not expect significant changes in it before the V1. We will welcome any feedback and adjust the resource if needed. Any errors reported will be resolved with a higher priority. We encourage checking this resource out before the V1 release. Please follow the migration guide to use it.
 
-    this = snowflake.get_roles()
-    ad = snowflake.get_roles(pattern="SYSADMIN")
-    ```
+    Datasource used to get details of filtered roles. Filtering is aligned with the current possibilities for [SHOW ROLES](https://docs.snowflake.com/en/sql-reference/sql/show-roles) query (`like` and `in_class` are all supported). The results of SHOW are encapsulated in one output collection.
 
 
-    :param str pattern: Filters the command output by object name.
+    :param str in_class: Filters the SHOW GRANTS output by class name.
+    :param str like: Filters the output with **case-insensitive** pattern, with support for SQL wildcard characters (`%` and `_`).
     """
     __args__ = dict()
-    __args__['pattern'] = pattern
+    __args__['inClass'] = in_class
+    __args__['like'] = like
     opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke('snowflake:index/getRoles:getRoles', __args__, opts=opts, typ=GetRolesResult).value
 
     return AwaitableGetRolesResult(
         id=pulumi.get(__ret__, 'id'),
-        pattern=pulumi.get(__ret__, 'pattern'),
+        in_class=pulumi.get(__ret__, 'in_class'),
+        like=pulumi.get(__ret__, 'like'),
         roles=pulumi.get(__ret__, 'roles'))
 
 
 @_utilities.lift_output_func(get_roles)
-def get_roles_output(pattern: Optional[pulumi.Input[Optional[str]]] = None,
+def get_roles_output(in_class: Optional[pulumi.Input[Optional[str]]] = None,
+                     like: Optional[pulumi.Input[Optional[str]]] = None,
                      opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetRolesResult]:
     """
-    ## Example Usage
-
-    ```python
-    import pulumi
-    import pulumi_snowflake as snowflake
+    !> **V1 release candidate** This resource was reworked and is a release candidate for the V1. We do not expect significant changes in it before the V1. We will welcome any feedback and adjust the resource if needed. Any errors reported will be resolved with a higher priority. We encourage checking this resource out before the V1 release. Please follow the migration guide to use it.
 
-    this = snowflake.get_roles()
-    ad = snowflake.get_roles(pattern="SYSADMIN")
-    ```
+    Datasource used to get details of filtered roles. Filtering is aligned with the current possibilities for [SHOW ROLES](https://docs.snowflake.com/en/sql-reference/sql/show-roles) query (`like` and `in_class` are all supported). The results of SHOW are encapsulated in one output collection.
 
 
-    :param str pattern: Filters the command output by object name.
+    :param str in_class: Filters the SHOW GRANTS output by class name.
+    :param str like: Filters the output with **case-insensitive** pattern, with support for SQL wildcard characters (`%` and `_`).
     """
     ...

pulumi_snowflake/get_schemas.py

@@ -9,6 +9,7 @@ import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union, overload
 from . import _utilities
 from . import outputs
+from ._inputs import *
 
 __all__ = [
     'GetSchemasResult',
@@ -22,41 +23,96 @@ class GetSchemasResult:
     """
     A collection of values returned by getSchemas.
     """
-    def __init__(__self__, database=None, id=None, schemas=None):
-        if database and not isinstance(database, str):
-            raise TypeError("Expected argument 'database' to be a str")
-        pulumi.set(__self__, "database", database)
+    def __init__(__self__, id=None, in_=None, like=None, limit=None, schemas=None, starts_with=None, with_describe=None, with_parameters=None):
         if id and not isinstance(id, str):
             raise TypeError("Expected argument 'id' to be a str")
         pulumi.set(__self__, "id", id)
+        if in_ and not isinstance(in_, dict):
+            raise TypeError("Expected argument 'in_' to be a dict")
+        pulumi.set(__self__, "in_", in_)
+        if like and not isinstance(like, str):
+            raise TypeError("Expected argument 'like' to be a str")
+        pulumi.set(__self__, "like", like)
+        if limit and not isinstance(limit, dict):
+            raise TypeError("Expected argument 'limit' to be a dict")
+        pulumi.set(__self__, "limit", limit)
         if schemas and not isinstance(schemas, list):
             raise TypeError("Expected argument 'schemas' to be a list")
         pulumi.set(__self__, "schemas", schemas)
+        if starts_with and not isinstance(starts_with, str):
+            raise TypeError("Expected argument 'starts_with' to be a str")
+        pulumi.set(__self__, "starts_with", starts_with)
+        if with_describe and not isinstance(with_describe, bool):
+            raise TypeError("Expected argument 'with_describe' to be a bool")
+        pulumi.set(__self__, "with_describe", with_describe)
+        if with_parameters and not isinstance(with_parameters, bool):
+            raise TypeError("Expected argument 'with_parameters' to be a bool")
+        pulumi.set(__self__, "with_parameters", with_parameters)
 
     @property
     @pulumi.getter
-    def database(self) -> str:
+    def id(self) -> str:
         """
-        The database from which to return the schemas from.
+        The provider-assigned unique ID for this managed resource.
         """
-        return pulumi.get(self, "database")
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter(name="in")
+    def in_(self) -> Optional['outputs.GetSchemasInResult']:
+        """
+        IN clause to filter the list of streamlits
+        """
+        return pulumi.get(self, "in_")
 
     @property
     @pulumi.getter
-    def id(self) -> str:
+    def like(self) -> Optional[str]:
         """
-        The provider-assigned unique ID for this managed resource.
+        Filters the output with **case-insensitive** pattern, with support for SQL wildcard characters (`%` and `_`).
         """
-        return pulumi.get(self, "id")
+        return pulumi.get(self, "like")
+
+    @property
+    @pulumi.getter
+    def limit(self) -> Optional['outputs.GetSchemasLimitResult']:
+        """
+        Limits the number of rows returned. If the `limit.from` is set, then the limit wll start from the first element matched by the expression. The expression is only used to match with the first element, later on the elements are not matched by the prefix, but you can enforce a certain pattern with `starts_with` or `like`.
+        """
+        return pulumi.get(self, "limit")
 
     @property
     @pulumi.getter
     def schemas(self) -> Sequence['outputs.GetSchemasSchemaResult']:
         """
-        The schemas in the database
+        Holds the aggregated output of all SCHEMA details queries.
         """
         return pulumi.get(self, "schemas")
 
+    @property
+    @pulumi.getter(name="startsWith")
+    def starts_with(self) -> Optional[str]:
+        """
+        Filters the output with **case-sensitive** characters indicating the beginning of the object name.
+        """
+        return pulumi.get(self, "starts_with")
+
+    @property
+    @pulumi.getter(name="withDescribe")
+    def with_describe(self) -> Optional[bool]:
+        """
+        Runs DESC SCHEMA for each schema returned by SHOW SCHEMAS. The output of describe is saved to the description field. By default this value is set to true.
+        """
+        return pulumi.get(self, "with_describe")
+
+    @property
+    @pulumi.getter(name="withParameters")
+    def with_parameters(self) -> Optional[bool]:
+        """
+        Runs SHOW PARAMETERS FOR SCHEMA for each schema returned by SHOW SCHEMAS. The output of describe is saved to the parameters field as a map. By default this value is set to true.
+        """
+        return pulumi.get(self, "with_parameters")
+
 
 class AwaitableGetSchemasResult(GetSchemasResult):
     # pylint: disable=using-constant-test
@@ -64,51 +120,72 @@ class AwaitableGetSchemasResult(GetSchemasResult):
         if False:
             yield self
         return GetSchemasResult(
-            database=self.database,
             id=self.id,
-            schemas=self.schemas)
-
-
-def get_schemas(database: Optional[str] = None,
+            in_=self.in_,
+            like=self.like,
+            limit=self.limit,
+            schemas=self.schemas,
+            starts_with=self.starts_with,
+            with_describe=self.with_describe,
+            with_parameters=self.with_parameters)
+
+
+def get_schemas(in_: Optional[pulumi.InputType['GetSchemasInArgs']] = None,
+                like: Optional[str] = None,
+                limit: Optional[pulumi.InputType['GetSchemasLimitArgs']] = None,
+                starts_with: Optional[str] = None,
+                with_describe: Optional[bool] = None,
+                with_parameters: Optional[bool] = None,
                 opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetSchemasResult:
     """
-    ## Example Usage
+    Datasource used to get details of filtered schemas. Filtering is aligned with the current possibilities for [SHOW SCHEMAS](https://docs.snowflake.com/en/sql-reference/sql/show-schemas) query. The results of SHOW, DESCRIBE, and SHOW PARAMETERS IN are encapsulated in one output collection.
 
-    ```python
-    import pulumi
-    import pulumi_snowflake as snowflake
 
-    current = snowflake.get_schemas(database="MYDB")
-    ```
-
-
-    :param str database: The database from which to return the schemas from.
+    :param pulumi.InputType['GetSchemasInArgs'] in_: IN clause to filter the list of streamlits
+    :param str like: Filters the output with **case-insensitive** pattern, with support for SQL wildcard characters (`%` and `_`).
+    :param pulumi.InputType['GetSchemasLimitArgs'] limit: Limits the number of rows returned. If the `limit.from` is set, then the limit wll start from the first element matched by the expression. The expression is only used to match with the first element, later on the elements are not matched by the prefix, but you can enforce a certain pattern with `starts_with` or `like`.
+    :param str starts_with: Filters the output with **case-sensitive** characters indicating the beginning of the object name.
+    :param bool with_describe: Runs DESC SCHEMA for each schema returned by SHOW SCHEMAS. The output of describe is saved to the description field. By default this value is set to true.
+    :param bool with_parameters: Runs SHOW PARAMETERS FOR SCHEMA for each schema returned by SHOW SCHEMAS. The output of describe is saved to the parameters field as a map. By default this value is set to true.
     """
     __args__ = dict()
-    __args__['database'] = database
+    __args__['in'] = in_
+    __args__['like'] = like
+    __args__['limit'] = limit
+    __args__['startsWith'] = starts_with
+    __args__['withDescribe'] = with_describe
+    __args__['withParameters'] = with_parameters
     opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke('snowflake:index/getSchemas:getSchemas', __args__, opts=opts, typ=GetSchemasResult).value
 
     return AwaitableGetSchemasResult(
-        database=pulumi.get(__ret__, 'database'),
         id=pulumi.get(__ret__, 'id'),
-        schemas=pulumi.get(__ret__, 'schemas'))
+        in_=pulumi.get(__ret__, 'in_'),
+        like=pulumi.get(__ret__, 'like'),
+        limit=pulumi.get(__ret__, 'limit'),
+        schemas=pulumi.get(__ret__, 'schemas'),
+        starts_with=pulumi.get(__ret__, 'starts_with'),
+        with_describe=pulumi.get(__ret__, 'with_describe'),
+        with_parameters=pulumi.get(__ret__, 'with_parameters'))
 
 
 @_utilities.lift_output_func(get_schemas)
-def get_schemas_output(database: Optional[pulumi.Input[str]] = None,
+def get_schemas_output(in_: Optional[pulumi.Input[Optional[pulumi.InputType['GetSchemasInArgs']]]] = None,
+                       like: Optional[pulumi.Input[Optional[str]]] = None,
+                       limit: Optional[pulumi.Input[Optional[pulumi.InputType['GetSchemasLimitArgs']]]] = None,
+                       starts_with: Optional[pulumi.Input[Optional[str]]] = None,
+                       with_describe: Optional[pulumi.Input[Optional[bool]]] = None,
+                       with_parameters: Optional[pulumi.Input[Optional[bool]]] = None,
                        opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetSchemasResult]:
     """
-    ## Example Usage
-
-    ```python
-    import pulumi
-    import pulumi_snowflake as snowflake
-
-    current = snowflake.get_schemas(database="MYDB")
-    ```
+    Datasource used to get details of filtered schemas. Filtering is aligned with the current possibilities for [SHOW SCHEMAS](https://docs.snowflake.com/en/sql-reference/sql/show-schemas) query. The results of SHOW, DESCRIBE, and SHOW PARAMETERS IN are encapsulated in one output collection.
 
 
-    :param str database: The database from which to return the schemas from.
+    :param pulumi.InputType['GetSchemasInArgs'] in_: IN clause to filter the list of streamlits
+    :param str like: Filters the output with **case-insensitive** pattern, with support for SQL wildcard characters (`%` and `_`).
+    :param pulumi.InputType['GetSchemasLimitArgs'] limit: Limits the number of rows returned. If the `limit.from` is set, then the limit wll start from the first element matched by the expression. The expression is only used to match with the first element, later on the elements are not matched by the prefix, but you can enforce a certain pattern with `starts_with` or `like`.
+    :param str starts_with: Filters the output with **case-sensitive** characters indicating the beginning of the object name.
+    :param bool with_describe: Runs DESC SCHEMA for each schema returned by SHOW SCHEMAS. The output of describe is saved to the description field. By default this value is set to true.
+    :param bool with_parameters: Runs SHOW PARAMETERS FOR SCHEMA for each schema returned by SHOW SCHEMAS. The output of describe is saved to the parameters field as a map. By default this value is set to true.
     """
     ...

pulumi_snowflake/get_streamlits.py

@@ -0,0 +1,159 @@
+# coding=utf-8
+# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import copy
+import warnings
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+from . import _utilities
+from . import outputs
+from ._inputs import *
+
+__all__ = [
+    'GetStreamlitsResult',
+    'AwaitableGetStreamlitsResult',
+    'get_streamlits',
+    'get_streamlits_output',
+]
+
+@pulumi.output_type
+class GetStreamlitsResult:
+    """
+    A collection of values returned by getStreamlits.
+    """
+    def __init__(__self__, id=None, in_=None, like=None, limit=None, streamlits=None, with_describe=None):
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if in_ and not isinstance(in_, dict):
+            raise TypeError("Expected argument 'in_' to be a dict")
+        pulumi.set(__self__, "in_", in_)
+        if like and not isinstance(like, str):
+            raise TypeError("Expected argument 'like' to be a str")
+        pulumi.set(__self__, "like", like)
+        if limit and not isinstance(limit, dict):
+            raise TypeError("Expected argument 'limit' to be a dict")
+        pulumi.set(__self__, "limit", limit)
+        if streamlits and not isinstance(streamlits, list):
+            raise TypeError("Expected argument 'streamlits' to be a list")
+        pulumi.set(__self__, "streamlits", streamlits)
+        if with_describe and not isinstance(with_describe, bool):
+            raise TypeError("Expected argument 'with_describe' to be a bool")
+        pulumi.set(__self__, "with_describe", with_describe)
+
+    @property
+    @pulumi.getter
+    def id(self) -> str:
+        """
+        The provider-assigned unique ID for this managed resource.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter(name="in")
+    def in_(self) -> Optional['outputs.GetStreamlitsInResult']:
+        """
+        IN clause to filter the list of streamlits
+        """
+        return pulumi.get(self, "in_")
+
+    @property
+    @pulumi.getter
+    def like(self) -> Optional[str]:
+        """
+        Filters the output with **case-insensitive** pattern, with support for SQL wildcard characters (`%` and `_`).
+        """
+        return pulumi.get(self, "like")
+
+    @property
+    @pulumi.getter
+    def limit(self) -> Optional['outputs.GetStreamlitsLimitResult']:
+        """
+        Limits the number of rows returned. If the `limit.from` is set, then the limit wll start from the first element matched by the expression. The expression is only used to match with the first element, later on the elements are not matched by the prefix, but you can enforce a certain pattern with `starts_with` or `like`.
+        """
+        return pulumi.get(self, "limit")
+
+    @property
+    @pulumi.getter
+    def streamlits(self) -> Sequence['outputs.GetStreamlitsStreamlitResult']:
+        """
+        Holds the aggregated output of all streamlits details queries.
+        """
+        return pulumi.get(self, "streamlits")
+
+    @property
+    @pulumi.getter(name="withDescribe")
+    def with_describe(self) -> Optional[bool]:
+        """
+        Runs DESC STREAMLIT for each streamlit returned by SHOW STREAMLITS. The output of describe is saved to the description field. By default this value is set to true.
+        """
+        return pulumi.get(self, "with_describe")
+
+
+class AwaitableGetStreamlitsResult(GetStreamlitsResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetStreamlitsResult(
+            id=self.id,
+            in_=self.in_,
+            like=self.like,
+            limit=self.limit,
+            streamlits=self.streamlits,
+            with_describe=self.with_describe)
+
+
+def get_streamlits(in_: Optional[pulumi.InputType['GetStreamlitsInArgs']] = None,
+                   like: Optional[str] = None,
+                   limit: Optional[pulumi.InputType['GetStreamlitsLimitArgs']] = None,
+                   with_describe: Optional[bool] = None,
+                   opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetStreamlitsResult:
+    """
+    !> **V1 release candidate** This resource was reworked and is a release candidate for the V1. We do not expect significant changes in it before the V1. We will welcome any feedback and adjust the resource if needed. Any errors reported will be resolved with a higher priority. We encourage checking this resource out before the V1 release. Please follow the migration guide to use it.
+
+    Datasource used to get details of filtered streamlits. Filtering is aligned with the current possibilities for [SHOW STREAMLITS](https://docs.snowflake.com/en/sql-reference/sql/show-streamlits) query (only `like` is supported). The results of SHOW and DESCRIBE are encapsulated in one output collection `streamlits`.
+
+
+    :param pulumi.InputType['GetStreamlitsInArgs'] in_: IN clause to filter the list of streamlits
+    :param str like: Filters the output with **case-insensitive** pattern, with support for SQL wildcard characters (`%` and `_`).
+    :param pulumi.InputType['GetStreamlitsLimitArgs'] limit: Limits the number of rows returned. If the `limit.from` is set, then the limit wll start from the first element matched by the expression. The expression is only used to match with the first element, later on the elements are not matched by the prefix, but you can enforce a certain pattern with `starts_with` or `like`.
+    :param bool with_describe: Runs DESC STREAMLIT for each streamlit returned by SHOW STREAMLITS. The output of describe is saved to the description field. By default this value is set to true.
+    """
+    __args__ = dict()
+    __args__['in'] = in_
+    __args__['like'] = like
+    __args__['limit'] = limit
+    __args__['withDescribe'] = with_describe
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('snowflake:index/getStreamlits:getStreamlits', __args__, opts=opts, typ=GetStreamlitsResult).value
+
+    return AwaitableGetStreamlitsResult(
+        id=pulumi.get(__ret__, 'id'),
+        in_=pulumi.get(__ret__, 'in_'),
+        like=pulumi.get(__ret__, 'like'),
+        limit=pulumi.get(__ret__, 'limit'),
+        streamlits=pulumi.get(__ret__, 'streamlits'),
+        with_describe=pulumi.get(__ret__, 'with_describe'))
+
+
+@_utilities.lift_output_func(get_streamlits)
+def get_streamlits_output(in_: Optional[pulumi.Input[Optional[pulumi.InputType['GetStreamlitsInArgs']]]] = None,
+                          like: Optional[pulumi.Input[Optional[str]]] = None,
+                          limit: Optional[pulumi.Input[Optional[pulumi.InputType['GetStreamlitsLimitArgs']]]] = None,
+                          with_describe: Optional[pulumi.Input[Optional[bool]]] = None,
+                          opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetStreamlitsResult]:
+    """
+    !> **V1 release candidate** This resource was reworked and is a release candidate for the V1. We do not expect significant changes in it before the V1. We will welcome any feedback and adjust the resource if needed. Any errors reported will be resolved with a higher priority. We encourage checking this resource out before the V1 release. Please follow the migration guide to use it.
+
+    Datasource used to get details of filtered streamlits. Filtering is aligned with the current possibilities for [SHOW STREAMLITS](https://docs.snowflake.com/en/sql-reference/sql/show-streamlits) query (only `like` is supported). The results of SHOW and DESCRIBE are encapsulated in one output collection `streamlits`.
+
+
+    :param pulumi.InputType['GetStreamlitsInArgs'] in_: IN clause to filter the list of streamlits
+    :param str like: Filters the output with **case-insensitive** pattern, with support for SQL wildcard characters (`%` and `_`).
+    :param pulumi.InputType['GetStreamlitsLimitArgs'] limit: Limits the number of rows returned. If the `limit.from` is set, then the limit wll start from the first element matched by the expression. The expression is only used to match with the first element, later on the elements are not matched by the prefix, but you can enforce a certain pattern with `starts_with` or `like`.
+    :param bool with_describe: Runs DESC STREAMLIT for each streamlit returned by SHOW STREAMLITS. The output of describe is saved to the description field. By default this value is set to true.
+    """
+    ...