Add Streamlit data analytics app

.gitattributes

@@ -1,35 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text

.streamlit/config.toml

@@ -0,0 +1,6 @@
+[theme]
+base = "light"
+primaryColor = "#ffbe00"
+
+[server]
+maxUploadSize = 20000

Dockerfile

@@ -2,20 +2,11 @@ FROM python:3.9-slim
 
 WORKDIR /app
 
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    software-properties-common \
-    git \
-    && rm -rf /var/lib/apt/lists/*
+COPY requirements.txt .
+RUN pip install -r requirements.txt
 
-COPY requirements.txt ./
-COPY src/ ./src/
-
-RUN pip3 install -r requirements.txt
+COPY . .
 
 EXPOSE 8501
 
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
-
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+CMD ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

README.md

@@ -1,20 +1,49 @@
----
-title: Data Analytics
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Analise e visualize dados com gráficos interativos
-license: mit
----
-
-# Welcome to Streamlit!
-
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
-
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+# Dashboard de Análise de Dados
+
+Uma aplicação Streamlit para análise e visualização de dados com recursos interativos (inclui transformação de números para padrão brasileiro).
+
+**Desenvolvido por:** Guilherme Favaron  
+**Website:** [guilhermefavaron.com.br](https://guilhermefavaron.com.br)
+
+## Funcionalidades
+
+### 📁 Gerenciamento de Dados
+- **Upload de CSV**: Interface de arrastar e soltar para uploads fáceis
+- **Dados de Exemplo**: Dataset de demonstração integrado para exploração imediata
+- **Visualização de Dados**: Visão geral rápida da estrutura do dataset
+- **Tratamento de Erros**: Validação robusta para formatos de arquivo e tipos de dados
+
+### 📊 Visualizações
+- **Gráficos de Barras**: Compare categorias e valores
+- **Gráficos de Linha**: Acompanhe tendências ao longo do tempo
+- **Gráficos de Dispersão**: Explore relacionamentos entre variáveis
+- **Histogramas**: Analise distribuições de dados
+- **Box Plots**: Compare distribuições entre grupos
+
+### 🔍 Recursos Interativos
+- **Filtragem Dinâmica**: Filtragem de dados em tempo real com sliders e seleção múltipla
+- **Seleção de Colunas**: Escolha eixos X/Y e variáveis de agrupamento
+- **Atualizações em Tempo Real**: Gráficos atualizam automaticamente baseados nas seleções
+- **Design Responsivo**: Otimizado para diferentes tamanhos de tela
+
+### 💾 Opções de Exportação
+- **Download de Dados Filtrados**: Exporte dados processados como CSV
+- **Salvar Visualizações**: Baixe gráficos como arquivos HTML
+- **Arquivos com Timestamp**: Nomenclatura automática com timestamps
+
+### 📈 Analytics
+- **Resumo Estatístico**: Estatísticas descritivas para colunas numéricas
+- **Análise de Dados Ausentes**: Identifique e quantifique valores ausentes
+- **Insights Rápidos**: Métricas principais e visão geral dos dados
+- **Verificações de Qualidade**: Validação e relatórios automáticos
+
+### 🇧🇷 Suporte a Formato Brasileiro
+- **Conversão Automática**: Detecta e converte números no formato brasileiro (xx.xxx.xxx,xx)
+- **Compatibilidade Regional**: Suporte nativo para padrões numéricos brasileiros
+
+## Instalação
+
+1. **Clone ou baixe** este repositório
+2. **Instale as dependências**:
+   ```bash
+   pip install -r requirements.txt

app.py

@@ -0,0 +1,489 @@
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+import numpy as np
+import io
+import base64
+import re
+from datetime import datetime
+
+# Page configuration
+st.set_page_config(
+    page_title="Data Analysis Dashboard",
+    page_icon="📊",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS for better styling
+st.markdown("""
+<style>
+    .main-header {
+        font-size: 2.5rem;
+        font-weight: bold;
+        color: #1f77b4;
+        text-align: center;
+        margin-bottom: 2rem;
+    }
+    .metric-container {
+        background-color: #f0f2f6;
+        padding: 1rem;
+        border-radius: 0.5rem;
+        margin: 0.5rem 0;
+    }
+    .stSelectbox > div > div {
+        background-color: white;
+    }
+    .upload-section {
+        border: 2px dashed #cccccc;
+        border-radius: 10px;
+        padding: 2rem;
+        text-align: center;
+        margin: 1rem 0;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+def convert_brazilian_number(value):
+    """Convert Brazilian number format (xx.xxx.xxx,xx) to float"""
+    if pd.isna(value) or value == '':
+        return np.nan
+    
+    # Convert to string if not already
+    str_value = str(value).strip()
+    
+    # Check if it's already a number
+    try:
+        return float(str_value)
+    except ValueError:
+        pass
+    
+    # Brazilian number pattern: can have dots as thousand separators and comma as decimal
+    # Examples: "1.234.567,89", "1.234,56", "1234,56", "1234"
+    brazilian_pattern = r'^-?\d{1,3}(?:\.\d{3})*(?:,\d+)?$'
+    
+    if re.match(brazilian_pattern, str_value):
+        # Remove thousand separators (dots) and replace decimal comma with dot
+        converted = str_value.replace('.', '').replace(',', '.')
+        try:
+            return float(converted)
+        except ValueError:
+            return np.nan
+    
+    return np.nan
+
+def detect_and_convert_brazilian_numbers(df):
+    """Detect and convert Brazilian number format columns to numeric"""
+    converted_columns = []
+    df_converted = df.copy()
+    
+    for col in df.columns:
+        if df[col].dtype == 'object':  # Only check string columns
+            # Sample some non-null values to check if they look like Brazilian numbers
+            sample_values = df[col].dropna().astype(str).head(10)
+            
+            if len(sample_values) > 0:
+                # Check if most values match Brazilian number pattern
+                brazilian_count = 0
+                total_count = 0
+                
+                for value in sample_values:
+                    value = str(value).strip()
+                    if value and value != 'nan':
+                        total_count += 1
+                        # Brazilian number pattern
+                        if re.match(r'^-?\d{1,3}(?:\.\d{3})*(?:,\d+)?$', value) or re.match(r'^-?\d+,\d+$', value):
+                            brazilian_count += 1
+                
+                # If more than 70% of values look like Brazilian numbers, convert the column
+                if total_count > 0 and (brazilian_count / total_count) > 0.7:
+                    converted_series = df[col].apply(convert_brazilian_number)
+                    
+                    # Only convert if we successfully converted most values
+                    non_null_original = df[col].notna().sum()
+                    non_null_converted = converted_series.notna().sum()
+                    
+                    if non_null_converted >= (non_null_original * 0.8):  # At least 80% conversion success
+                        df_converted[col] = converted_series
+                        converted_columns.append(col)
+    
+    return df_converted, converted_columns
+
+def load_sample_data():
+    """Generate sample data for demonstration"""
+    np.random.seed(42)
+    n_samples = 1000
+    
+    data = {
+        'Date': pd.date_range('2023-01-01', periods=n_samples, freq='D'),
+        'Sales': np.random.normal(1000, 200, n_samples),
+        'Profit': np.random.normal(150, 50, n_samples),
+        'Category': np.random.choice(['Electronics', 'Clothing', 'Books', 'Home'], n_samples),
+        'Region': np.random.choice(['North', 'South', 'East', 'West'], n_samples),
+        'Customer_Age': np.random.randint(18, 80, n_samples),
+        'Rating': np.random.uniform(1, 5, n_samples)
+    }
+    
+    df = pd.DataFrame(data)
+    df['Sales'] = np.where(df['Sales'] < 0, abs(df['Sales']), df['Sales'])
+    df['Profit'] = np.where(df['Category'] == 'Electronics', df['Profit'] * 1.5, df['Profit'])
+    
+    # Add some Brazilian formatted numbers for demonstration
+    df['Vendas_BR'] = df['Sales'].apply(lambda x: f"{x:,.2f}".replace(',', 'X').replace('.', ',').replace('X', '.'))
+    df['Lucro_BR'] = df['Profit'].apply(lambda x: f"{x:,.2f}".replace(',', 'X').replace('.', ',').replace('X', '.'))
+    
+    return df
+
+def get_numeric_columns(df):
+    """Get numeric columns from dataframe"""
+    return df.select_dtypes(include=[np.number]).columns.tolist()
+
+def get_categorical_columns(df):
+    """Get categorical columns from dataframe"""
+    return df.select_dtypes(include=['object', 'category']).columns.tolist()
+
+def create_download_link(df, filename="filtered_data.csv"):
+    """Create download link for dataframe"""
+    csv = df.to_csv(index=False)
+    b64 = base64.b64encode(csv.encode()).decode()
+    href = f'<a href="data:file/csv;base64,{b64}" download="{filename}">Download CSV File</a>'
+    return href
+
+def main():
+    # Header
+    st.markdown('<h1 class="main-header">📊 Data Analysis Dashboard</h1>', unsafe_allow_html=True)
+    
+    # Sidebar
+    st.sidebar.title("🔧 Controls")
+    st.sidebar.markdown("---")
+    
+    # File upload section
+    st.sidebar.subheader("📁 Data Upload")
+    uploaded_file = st.sidebar.file_uploader(
+        "Choose a CSV file",
+        type="csv",
+        help="Upload a CSV file to analyze your data"
+    )
+    
+    use_sample = st.sidebar.checkbox(
+        "Use Sample Data",
+        value=True if uploaded_file is None else False,
+        help="Check this to use built-in sample data for demonstration"
+    )
+    
+    # Brazilian number conversion option
+    convert_brazilian = st.sidebar.checkbox(
+        "🇧🇷 Auto-convert Brazilian Numbers",
+        value=True,
+        help="Automatically detect and convert Brazilian number format (xx.xxx.xxx,xx) to numeric"
+    )
+    
+    # Load data
+    try:
+        if uploaded_file is not None:
+            df = pd.read_csv(uploaded_file)
+            st.sidebar.success(f"✅ File uploaded successfully! ({len(df)} rows)")
+        elif use_sample:
+            df = load_sample_data()
+            st.sidebar.info("📋 Using sample data")
+        else:
+            st.warning("Please upload a CSV file or use sample data to get started.")
+            st.markdown("""
+            ### 🚀 Welcome to the Data Analysis Dashboard!
+            
+            This app helps you analyze and visualize your data with:
+            - **Interactive charts** (bar, line, scatter, histogram)
+            - **Dynamic filtering** and data exploration
+            - **Statistical summaries** and insights
+            - **Export capabilities** for data and visualizations
+            - **🇧🇷 Brazilian number format support** (xx.xxx.xxx,xx)
+            
+            **To get started:**
+            1. Upload a CSV file using the sidebar, or
+            2. Check "Use Sample Data" to explore with demo data
+            """)
+            return
+        
+        # Apply Brazilian number conversion if enabled
+        if convert_brazilian:
+            df_original = df.copy()
+            df, converted_cols = detect_and_convert_brazilian_numbers(df)
+            
+            if converted_cols:
+                st.sidebar.success(f"🇧🇷 Converted {len(converted_cols)} columns from Brazilian format: {', '.join(converted_cols)}")
+            
+    except Exception as e:
+        st.error(f"❌ Error loading file: {str(e)}")
+        st.info("Please make sure your file is a valid CSV format.")
+        return
+    
+    # Data preview section
+    st.subheader("📋 Data Preview")
+    
+    col1, col2, col3, col4 = st.columns(4)
+    with col1:
+        st.metric("Total Rows", len(df))
+    with col2:
+        st.metric("Total Columns", len(df.columns))
+    with col3:
+        st.metric("Numeric Columns", len(get_numeric_columns(df)))
+    with col4:
+        st.metric("Text Columns", len(get_categorical_columns(df)))
+    
+    # Show data preview
+    with st.expander("🔍 View Raw Data", expanded=False):
+        st.dataframe(df.head(100), use_container_width=True)
+    
+    # Data summary
+    with st.expander("📊 Statistical Summary", expanded=False):
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.subheader("Numeric Columns")
+            numeric_cols = get_numeric_columns(df)
+            if numeric_cols:
+                st.dataframe(df[numeric_cols].describe())
+            else:
+                st.info("No numeric columns found")
+        
+        with col2:
+            st.subheader("Categorical Columns")
+            cat_cols = get_categorical_columns(df)
+            if cat_cols:
+                for col in cat_cols[:5]:  # Show first 5 categorical columns
+                    st.write(f"**{col}:** {df[col].nunique()} unique values")
+                    if df[col].nunique() <= 10:
+                        st.write(df[col].value_counts().head())
+            else:
+                st.info("No categorical columns found")
+    
+    # Show conversion info if Brazilian conversion was applied
+    if convert_brazilian and 'converted_cols' in locals() and converted_cols:
+        with st.expander("🇧🇷 Brazilian Number Conversion Details", expanded=False):
+            st.write("**Converted Columns:**")
+            for col in converted_cols:
+                original_sample = df_original[col].dropna().head(3).tolist()
+                converted_sample = df[col].dropna().head(3).tolist()
+                st.write(f"**{col}:**")
+                st.write(f"  - Original: {original_sample}")
+                st.write(f"  - Converted: {converted_sample}")
+    
+    # Filtering section
+    st.sidebar.markdown("---")
+    st.sidebar.subheader("🔍 Data Filters")
+    
+    # Create a copy for filtering
+    filtered_df = df.copy()
+    
+    # Numeric filters
+    numeric_cols = get_numeric_columns(df)
+    for col in numeric_cols:
+        if df[col].dtype in ['int64', 'float64']:
+            min_val = float(df[col].min())
+            max_val = float(df[col].max())
+            
+            if min_val != max_val:
+                selected_range = st.sidebar.slider(
+                    f"{col} Range",
+                    min_value=min_val,
+                    max_value=max_val,
+                    value=(min_val, max_val),
+                    help=f"Filter data by {col} values"
+                )
+                filtered_df = filtered_df[
+                    (filtered_df[col] >= selected_range[0]) & 
+                    (filtered_df[col] <= selected_range[1])
+                ]
+    
+    # Categorical filters
+    cat_cols = get_categorical_columns(df)
+    for col in cat_cols:
+        unique_values = df[col].unique().tolist()
+        if len(unique_values) <= 50:  # Only show filter for columns with reasonable number of unique values
+            selected_values = st.sidebar.multiselect(
+                f"Select {col}",
+                options=unique_values,
+                default=unique_values,
+                help=f"Filter data by {col} categories"
+            )
+            if selected_values:
+                filtered_df = filtered_df[filtered_df[col].isin(selected_values)]
+    
+    # Show filtered data info
+    if len(filtered_df) != len(df):
+        st.sidebar.info(f"Filtered: {len(filtered_df)} of {len(df)} rows")
+    
+    # Visualization section
+    st.markdown("---")
+    st.subheader("📈 Data Visualization")
+    
+    # Chart type selection
+    chart_type = st.selectbox(
+        "Select Chart Type",
+        ["Bar Chart", "Line Chart", "Scatter Plot", "Histogram", "Box Plot"],
+        help="Choose the type of visualization"
+    )
+    
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        if chart_type in ["Bar Chart", "Line Chart", "Scatter Plot", "Box Plot"]:
+            x_column = st.selectbox(
+                "X-axis Column",
+                options=df.columns.tolist(),
+                help="Select column for X-axis"
+            )
+        else:
+            x_column = st.selectbox(
+                "Column to Analyze",
+                options=numeric_cols,
+                help="Select numeric column for histogram"
+            )
+    
+    with col2:
+        if chart_type in ["Bar Chart", "Line Chart", "Scatter Plot", "Box Plot"]:
+            y_column = st.selectbox(
+                "Y-axis Column",
+                options=numeric_cols,
+                help="Select numeric column for Y-axis"
+            )
+        else:
+            y_column = None
+    
+    with col3:
+        if chart_type in ["Bar Chart", "Scatter Plot", "Box Plot"]:
+            color_column = st.selectbox(
+                "Color/Group By (Optional)",
+                options=[None] + cat_cols,
+                help="Select column to group/color data"
+            )
+        else:
+            color_column = None
+    
+    # Create visualization
+    if chart_type == "Bar Chart" and x_column and y_column:
+        if x_column in cat_cols:
+            # Aggregate data for categorical x-axis
+            agg_df = filtered_df.groupby(x_column)[y_column].mean().reset_index()
+            fig = px.bar(
+                agg_df, 
+                x=x_column, 
+                y=y_column,
+                title=f"Average {y_column} by {x_column}",
+                color=color_column if color_column and color_column in agg_df.columns else None
+            )
+        else:
+            fig = px.bar(
+                filtered_df, 
+                x=x_column, 
+                y=y_column,
+                title=f"{y_column} vs {x_column}",
+                color=color_column
+            )
+    
+    elif chart_type == "Line Chart" and x_column and y_column:
+        fig = px.line(
+            filtered_df, 
+            x=x_column, 
+            y=y_column,
+            title=f"{y_column} vs {x_column}",
+            color=color_column
+        )
+    
+    elif chart_type == "Scatter Plot" and x_column and y_column:
+        fig = px.scatter(
+            filtered_df, 
+            x=x_column, 
+            y=y_column,
+            title=f"{y_column} vs {x_column}",
+            color=color_column,
+            size=y_column if y_column in numeric_cols else None
+        )
+    
+    elif chart_type == "Histogram" and x_column:
+        fig = px.histogram(
+            filtered_df, 
+            x=x_column,
+            title=f"Distribution of {x_column}",
+            nbins=30
+        )
+    
+    elif chart_type == "Box Plot" and x_column and y_column:
+        fig = px.box(
+            filtered_df, 
+            x=x_column, 
+            y=y_column,
+            title=f"{y_column} Distribution by {x_column}",
+            color=color_column
+        )
+    
+    else:
+        st.warning("Please select appropriate columns for the chosen chart type.")
+        return
+    
+    # Update layout for better appearance
+    fig.update_layout(
+        height=500,
+        showlegend=True,
+        title_x=0.5,
+        font=dict(size=12)
+    )
+    
+    # Display chart
+    st.plotly_chart(fig, use_container_width=True)
+    
+    # Download section
+    st.markdown("---")
+    st.subheader("💾 Download Options")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.markdown("**Download Filtered Data**")
+        if st.button("Generate CSV Download Link"):
+            download_link = create_download_link(filtered_df, f"filtered_data_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv")
+            st.markdown(download_link, unsafe_allow_html=True)
+    
+    with col2:
+        st.markdown("**Download Chart**")
+        if st.button("Download Chart as HTML"):
+            html_string = fig.to_html(include_plotlyjs='cdn')
+            st.download_button(
+                label="Download HTML",
+                data=html_string,
+                file_name=f"chart_{datetime.now().strftime('%Y%m%d_%H%M%S')}.html",
+                mime="text/html"
+            )
+    
+    # Additional insights
+    if len(filtered_df) > 0:
+        st.markdown("---")
+        st.subheader("🔍 Quick Insights")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.markdown("**Data Overview**")
+            st.write(f"• Total records: {len(filtered_df):,}")
+            st.write(f"• Columns: {len(filtered_df.columns)}")
+            
+            if numeric_cols:
+                st.write(f"• Numeric columns: {len(numeric_cols)}")
+                for col in numeric_cols[:3]:
+                    mean_val = filtered_df[col].mean()
+                    st.write(f"  - {col}: avg = {mean_val:.2f}")
+        
+        with col2:
+            st.markdown("**Missing Data**")
+            missing_data = filtered_df.isnull().sum()
+            if missing_data.sum() > 0:
+                for col, missing in missing_data.items():
+                    if missing > 0:
+                        pct = (missing / len(filtered_df)) * 100
+                        st.write(f"• {col}: {missing} ({pct:.1f}%)")
+            else:
+                st.write("✅ No missing data found")
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -1,3 +1,4 @@
-altair
-pandas
-streamlit
+streamlit>=1.28.0
+pandas>=2.0.0
+plotly>=5.15.0
+numpy>=1.24.0

src/streamlit_app.py

@@ -1,40 +0,0 @@
-import altair as alt
-import numpy as np
-import pandas as pd
-import streamlit as st
-
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))