mirror of
https://github.com/aykhans/AzSuicideDataVisualization.git
synced 2025-04-22 10:28:02 +00:00
253 lines
9.0 KiB
Python
253 lines
9.0 KiB
Python
# Copyright 2018-2022 Streamlit Inc.
|
|
#
|
|
# 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.
|
|
|
|
from typing import cast, Sequence, Union
|
|
|
|
from streamlit.beta_util import function_beta_warning
|
|
from streamlit.errors import StreamlitAPIException
|
|
from streamlit.proto.Block_pb2 import Block as BlockProto
|
|
|
|
import streamlit
|
|
|
|
SpecType = Union[int, Sequence[Union[int, float]]]
|
|
|
|
|
|
class LayoutsMixin:
|
|
def container(self):
|
|
"""Insert a multi-element container.
|
|
|
|
Inserts an invisible container into your app that can be used to hold
|
|
multiple elements. This allows you to, for example, insert multiple
|
|
elements into your app out of order.
|
|
|
|
To add elements to the returned container, you can use "with" notation
|
|
(preferred) or just call methods directly on the returned object. See
|
|
examples below.
|
|
|
|
Examples
|
|
--------
|
|
|
|
Inserting elements using "with" notation:
|
|
|
|
>>> with st.container():
|
|
... st.write("This is inside the container")
|
|
...
|
|
... # You can call any Streamlit command, including custom components:
|
|
... st.bar_chart(np.random.randn(50, 3))
|
|
...
|
|
>>> st.write("This is outside the container")
|
|
|
|
.. output ::
|
|
https://share.streamlit.io/streamlit/docs/main/python/api-examples-source/layout.container1.py
|
|
height: 520px
|
|
|
|
Inserting elements out of order:
|
|
|
|
>>> container = st.container()
|
|
>>> container.write("This is inside the container")
|
|
>>> st.write("This is outside the container")
|
|
>>>
|
|
>>> # Now insert some more in the container
|
|
>>> container.write("This is inside too")
|
|
|
|
.. output ::
|
|
https://share.streamlit.io/streamlit/docs/main/python/api-examples-source/layout.container2.py
|
|
height: 480px
|
|
"""
|
|
return self.dg._block()
|
|
|
|
# TODO: Enforce that columns are not nested or in Sidebar
|
|
def columns(self, spec: SpecType):
|
|
"""Insert containers laid out as side-by-side columns.
|
|
|
|
Inserts a number of multi-element containers laid out side-by-side and
|
|
returns a list of container objects.
|
|
|
|
To add elements to the returned containers, you can use "with" notation
|
|
(preferred) or just call methods directly on the returned object. See
|
|
examples below.
|
|
|
|
.. warning::
|
|
Currently, you may not put columns inside another column.
|
|
|
|
Parameters
|
|
----------
|
|
spec : int or list of numbers
|
|
If an int
|
|
Specifies the number of columns to insert, and all columns
|
|
have equal width.
|
|
|
|
If a list of numbers
|
|
Creates a column for each number, and each
|
|
column's width is proportional to the number provided. Numbers can
|
|
be ints or floats, but they must be positive.
|
|
|
|
For example, `st.columns([3, 1, 2])` creates 3 columns where
|
|
the first column is 3 times the width of the second, and the last
|
|
column is 2 times that width.
|
|
|
|
Returns
|
|
-------
|
|
list of containers
|
|
A list of container objects.
|
|
|
|
Examples
|
|
--------
|
|
|
|
You can use `with` notation to insert any element into a column:
|
|
|
|
>>> col1, col2, col3 = st.columns(3)
|
|
>>>
|
|
>>> with col1:
|
|
... st.header("A cat")
|
|
... st.image("https://static.streamlit.io/examples/cat.jpg")
|
|
...
|
|
>>> with col2:
|
|
... st.header("A dog")
|
|
... st.image("https://static.streamlit.io/examples/dog.jpg")
|
|
...
|
|
>>> with col3:
|
|
... st.header("An owl")
|
|
... st.image("https://static.streamlit.io/examples/owl.jpg")
|
|
|
|
.. output ::
|
|
https://share.streamlit.io/streamlit/docs/main/python/api-examples-source/layout.columns1.py
|
|
height: 620px
|
|
|
|
Or you can just call methods directly in the returned objects:
|
|
|
|
>>> col1, col2 = st.columns([3, 1])
|
|
>>> data = np.random.randn(10, 1)
|
|
>>>
|
|
>>> col1.subheader("A wide column with a chart")
|
|
>>> col1.line_chart(data)
|
|
>>>
|
|
>>> col2.subheader("A narrow column with the data")
|
|
>>> col2.write(data)
|
|
|
|
.. output ::
|
|
https://share.streamlit.io/streamlit/docs/main/python/api-examples-source/layout.columns2.py
|
|
height: 550px
|
|
|
|
"""
|
|
weights = spec
|
|
weights_exception = StreamlitAPIException(
|
|
"The input argument to st.columns must be either a "
|
|
+ "positive integer or a list of positive numeric weights. "
|
|
+ "See [documentation](https://docs.streamlit.io/library/api-reference/layout/st.columns) "
|
|
+ "for more information."
|
|
)
|
|
|
|
if isinstance(weights, int):
|
|
# If the user provided a single number, expand into equal weights.
|
|
# E.g. (1,) * 3 => (1, 1, 1)
|
|
# NOTE: A negative/zero spec will expand into an empty tuple.
|
|
weights = (1,) * weights
|
|
|
|
if len(weights) == 0 or any(weight <= 0 for weight in weights):
|
|
raise weights_exception
|
|
|
|
def column_proto(normalized_weight):
|
|
col_proto = BlockProto()
|
|
col_proto.column.weight = normalized_weight
|
|
col_proto.allow_empty = True
|
|
return col_proto
|
|
|
|
block_proto = BlockProto()
|
|
block_proto.horizontal.SetInParent()
|
|
row = self.dg._block(block_proto)
|
|
total_weight = sum(weights)
|
|
return [row._block(column_proto(w / total_weight)) for w in weights]
|
|
|
|
def expander(self, label: str, expanded: bool = False):
|
|
"""Insert a multi-element container that can be expanded/collapsed.
|
|
|
|
Inserts a container into your app that can be used to hold multiple elements
|
|
and can be expanded or collapsed by the user. When collapsed, all that is
|
|
visible is the provided label.
|
|
|
|
To add elements to the returned container, you can use "with" notation
|
|
(preferred) or just call methods directly on the returned object. See
|
|
examples below.
|
|
|
|
.. warning::
|
|
Currently, you may not put expanders inside another expander.
|
|
|
|
Parameters
|
|
----------
|
|
label : str
|
|
A string to use as the header for the expander.
|
|
expanded : bool
|
|
If True, initializes the expander in "expanded" state. Defaults to
|
|
False (collapsed).
|
|
|
|
Examples
|
|
--------
|
|
|
|
You can use `with` notation to insert any element into an expander
|
|
|
|
>>> st.bar_chart({"data": [1, 5, 2, 6, 2, 1]})
|
|
>>>
|
|
>>> with st.expander("See explanation"):
|
|
... st.write(\"\"\"
|
|
... The chart above shows some numbers I picked for you.
|
|
... I rolled actual dice for these, so they're *guaranteed* to
|
|
... be random.
|
|
... \"\"\")
|
|
... st.image("https://static.streamlit.io/examples/dice.jpg")
|
|
|
|
.. output ::
|
|
https://share.streamlit.io/streamlit/docs/main/python/api-examples-source/layout.expander.py
|
|
height: 750px
|
|
|
|
Or you can just call methods directly in the returned objects:
|
|
|
|
>>> st.bar_chart({"data": [1, 5, 2, 6, 2, 1]})
|
|
>>>
|
|
>>> expander = st.expander("See explanation")
|
|
>>> expander.write(\"\"\"
|
|
... The chart above shows some numbers I picked for you.
|
|
... I rolled actual dice for these, so they're *guaranteed* to
|
|
... be random.
|
|
... \"\"\")
|
|
>>> expander.image("https://static.streamlit.io/examples/dice.jpg")
|
|
|
|
.. output ::
|
|
https://share.streamlit.io/streamlit/docs/main/python/api-examples-source/layout.expander.py
|
|
height: 750px
|
|
|
|
"""
|
|
if label is None:
|
|
raise StreamlitAPIException("A label is required for an expander")
|
|
|
|
expandable_proto = BlockProto.Expandable()
|
|
expandable_proto.expanded = expanded
|
|
expandable_proto.label = label
|
|
|
|
block_proto = BlockProto()
|
|
block_proto.allow_empty = True
|
|
block_proto.expandable.CopyFrom(expandable_proto)
|
|
|
|
return self.dg._block(block_proto=block_proto)
|
|
|
|
@property
|
|
def dg(self) -> "streamlit.delta_generator.DeltaGenerator":
|
|
"""Get our DeltaGenerator."""
|
|
return cast("streamlit.delta_generator.DeltaGenerator", self)
|
|
|
|
# Deprecated beta_ functions
|
|
beta_container = function_beta_warning(container, "2021-11-02")
|
|
beta_expander = function_beta_warning(expander, "2021-11-02")
|
|
beta_columns = function_beta_warning(columns, "2021-11-02")
|