tessl/pypi-leafmap

A Python package for geospatial analysis and interactive mapping in a Jupyter environment.

0.80x

Evaluation — 54%

↓ 0.80x

Agent success when using this tile

Overview

Eval results

Files

Statistical Plotting

Name: tessl/pypi-leafmap
Rating: 0.54 (1 reviews)
Author: tessl

Interactive statistical plotting capabilities using Plotly for creating bar charts, line charts, histograms, and pie charts integrated with geospatial data workflows and supporting advanced customization options.

Capabilities

Bar Charts

Create interactive bar charts with support for grouped bars, horizontal orientation, and extensive customization options.

def bar_chart(data, x, y, color=None, **kwargs):
    """
    Create interactive bar chart.
    
    Args:
        data (pd.DataFrame): Input data
        x (str): Column name for x-axis (categories)
        y (str): Column name for y-axis (values)
        color (str): Column name for color grouping
        **kwargs: Chart options (title, orientation, etc.)
        
    Returns:
        plotly.graph_objects.Figure: Interactive bar chart
    """

def horizontal_bar_chart(data, x, y, **kwargs):
    """
    Create horizontal bar chart.
    
    Args:
        data (pd.DataFrame): Input data
        x (str): Column name for values
        y (str): Column name for categories
        **kwargs: Chart customization options
        
    Returns:
        plotly.graph_objects.Figure: Interactive horizontal bar chart
    """

def grouped_bar_chart(data, x, y, color, **kwargs):
    """
    Create grouped bar chart.
    
    Args:
        data (pd.DataFrame): Input data
        x (str): Column name for x-axis categories
        y (str): Column name for y-axis values
        color (str): Column name for grouping
        **kwargs: Chart options (barmode, etc.)
        
    Returns:
        plotly.graph_objects.Figure: Interactive grouped bar chart
    """

Line Charts

Create line charts for time series data and continuous variables with support for multiple lines and advanced styling.

def line_chart(data, x, y, color=None, **kwargs):
    """
    Create interactive line chart.
    
    Args:
        data (pd.DataFrame): Input data
        x (str): Column name for x-axis (usually time or continuous variable)
        y (str): Column name for y-axis (values)
        color (str): Column name for multiple lines
        **kwargs: Chart options (title, line_shape, etc.)
        
    Returns:
        plotly.graph_objects.Figure: Interactive line chart
    """

def time_series_chart(data, time_col, value_col, **kwargs):
    """
    Create time series chart.
    
    Args:
        data (pd.DataFrame): Input data with time series
        time_col (str): Column name for time/date values
        value_col (str): Column name for values
        **kwargs: Time series specific options (range_selector, etc.)
        
    Returns:
        plotly.graph_objects.Figure: Interactive time series chart
    """

def multi_line_chart(data, x, y_columns, **kwargs):
    """
    Create chart with multiple y-value lines.
    
    Args:
        data (pd.DataFrame): Input data
        x (str): Column name for x-axis
        y_columns (list): List of column names for multiple lines
        **kwargs: Multi-line chart options
        
    Returns:
        plotly.graph_objects.Figure: Interactive multi-line chart
    """

Histograms

Create histograms for data distribution analysis with support for overlaid distributions and statistical annotations.

def histogram(data, column, **kwargs):
    """
    Create interactive histogram.
    
    Args:
        data (pd.DataFrame): Input data
        column (str): Column name for histogram values
        **kwargs: Histogram options (nbins, histnorm, etc.)
        
    Returns:
        plotly.graph_objects.Figure: Interactive histogram
    """

def overlay_histogram(data, column, group_by, **kwargs):
    """
    Create overlaid histograms for different groups.
    
    Args:
        data (pd.DataFrame): Input data
        column (str): Column name for histogram values
        group_by (str): Column name for grouping
        **kwargs: Overlay options (opacity, barmode, etc.)
        
    Returns:
        plotly.graph_objects.Figure: Interactive overlaid histogram
    """

def box_plot(data, x, y, **kwargs):
    """
    Create interactive box plot.
    
    Args:
        data (pd.DataFrame): Input data
        x (str): Column name for categories (optional)
        y (str): Column name for values
        **kwargs: Box plot options (points, etc.)
        
    Returns:
        plotly.graph_objects.Figure: Interactive box plot
    """

Pie Charts

Create pie charts for categorical data visualization with support for nested charts and custom styling.

def pie_chart(data, names, values, **kwargs):
    """
    Create interactive pie chart.
    
    Args:
        data (pd.DataFrame): Input data
        names (str): Column name for category labels
        values (str): Column name for values
        **kwargs: Pie chart options (hole, pull, etc.)
        
    Returns:
        plotly.graph_objects.Figure: Interactive pie chart
    """

def donut_chart(data, names, values, **kwargs):
    """
    Create donut chart (pie chart with hole).
    
    Args:
        data (pd.DataFrame): Input data
        names (str): Column name for category labels
        values (str): Column name for values
        **kwargs: Donut chart options (hole size, etc.)
        
    Returns:
        plotly.graph_objects.Figure: Interactive donut chart
    """

def sunburst_chart(data, path, values, **kwargs):
    """
    Create hierarchical sunburst chart.
    
    Args:
        data (pd.DataFrame): Input data
        path (list): List of column names for hierarchy levels
        values (str): Column name for values
        **kwargs: Sunburst chart options
        
    Returns:
        plotly.graph_objects.Figure: Interactive sunburst chart
    """

Scatter Plots

Create scatter plots for correlation analysis and pattern identification with advanced interaction features.

def scatter_plot(data, x, y, color=None, size=None, **kwargs):
    """
    Create interactive scatter plot.
    
    Args:
        data (pd.DataFrame): Input data
        x (str): Column name for x-axis values
        y (str): Column name for y-axis values
        color (str): Column name for color mapping
        size (str): Column name for marker size
        **kwargs: Scatter plot options (trendline, etc.)
        
    Returns:
        plotly.graph_objects.Figure: Interactive scatter plot
    """

def bubble_chart(data, x, y, size, color=None, **kwargs):
    """
    Create bubble chart (scatter plot with variable sizes).
    
    Args:
        data (pd.DataFrame): Input data
        x (str): Column name for x-axis values
        y (str): Column name for y-axis values
        size (str): Column name for bubble sizes
        color (str): Column name for color mapping
        **kwargs: Bubble chart options
        
    Returns:
        plotly.graph_objects.Figure: Interactive bubble chart
    """

def correlation_matrix(data, **kwargs):
    """
    Create correlation matrix heatmap.
    
    Args:
        data (pd.DataFrame): Input data
        **kwargs: Heatmap options (colorscale, annotations, etc.)
        
    Returns:
        plotly.graph_objects.Figure: Interactive correlation heatmap
    """

Statistical Analysis Charts

Create advanced statistical visualization including distribution fitting and confidence intervals.

def violin_plot(data, x, y, **kwargs):
    """
    Create violin plot showing distribution shapes.
    
    Args:
        data (pd.DataFrame): Input data
        x (str): Column name for categories
        y (str): Column name for values
        **kwargs: Violin plot options (points, box, etc.)
        
    Returns:
        plotly.graph_objects.Figure: Interactive violin plot
    """

def density_plot(data, column, **kwargs):
    """
    Create density plot for continuous variable.
    
    Args:
        data (pd.DataFrame): Input data
        column (str): Column name for density calculation
        **kwargs: Density plot options (bandwidth, etc.)
        
    Returns:
        plotly.graph_objects.Figure: Interactive density plot
    """

def qq_plot(data, column, **kwargs):
    """
    Create Q-Q plot for normality testing.
    
    Args:
        data (pd.DataFrame): Input data
        column (str): Column name for Q-Q plot
        **kwargs: Q-Q plot options
        
    Returns:
        plotly.graph_objects.Figure: Interactive Q-Q plot
    """

Usage Examples

Basic Chart Creation

import leafmap
import pandas as pd

# Load sample data
data = pd.read_csv('sample_data.csv')

# Create bar chart
bar_fig = leafmap.bar_chart(
    data=data,
    x='category',
    y='value',
    title='Sample Bar Chart'
)

# Display chart
bar_fig.show()

# Create line chart for time series
line_fig = leafmap.line_chart(
    data=data,
    x='date', 
    y='temperature',
    title='Temperature Over Time'
)

line_fig.show()

Geospatial Data Analysis with Charts

import leafmap
import geopandas as gpd

# Load geospatial data
gdf = gpd.read_file('census_data.shp')

# Create histogram of population density
hist_fig = leafmap.histogram(
    data=gdf,
    column='pop_density',
    title='Population Density Distribution',
    nbins=30
)

# Create scatter plot of income vs education
scatter_fig = leafmap.scatter_plot(
    data=gdf,
    x='median_income',
    y='college_rate',
    color='region',
    title='Income vs Education by Region',
    trendline='ols'  # Add regression line
)

# Display charts
hist_fig.show()
scatter_fig.show()

# Also display data on map
m = leafmap.Map()
m.add_gdf(gdf, 
         column='pop_density',
         scheme='quantiles',
         cmap='viridis',
         legend=True)
m

Multi-Variable Analysis

import leafmap
import pandas as pd

# Load environmental data
env_data = pd.read_csv('environmental_monitoring.csv')

# Create grouped bar chart by station
grouped_bar = leafmap.grouped_bar_chart(
    data=env_data,
    x='month',
    y='pollution_level',
    color='station_id',
    title='Monthly Pollution Levels by Station'
)

# Create multi-line time series
multi_line = leafmap.multi_line_chart(
    data=env_data,
    x='date',
    y_columns=['temperature', 'humidity', 'air_quality'],
    title='Environmental Parameters Over Time'
)

# Create correlation matrix
correlation_fig = leafmap.correlation_matrix(
    data=env_data[['temperature', 'humidity', 'air_quality', 'pollution_level']],
    title='Environmental Parameter Correlations'
)

# Display all charts
grouped_bar.show()
multi_line.show()
correlation_fig.show()

Statistical Distribution Analysis

import leafmap
import pandas as pd
import numpy as np

# Generate sample data
np.random.seed(42)
sample_data = pd.DataFrame({
    'group': np.repeat(['A', 'B', 'C'], 100),
    'values': np.concatenate([
        np.random.normal(10, 2, 100),  # Group A
        np.random.normal(15, 3, 100),  # Group B  
        np.random.normal(12, 1.5, 100) # Group C
    ])
})

# Create overlaid histograms
overlay_hist = leafmap.overlay_histogram(
    data=sample_data,
    column='values',
    group_by='group',
    title='Distribution Comparison by Group',
    opacity=0.7
)

# Create box plot
box_fig = leafmap.box_plot(
    data=sample_data,
    x='group',
    y='values',
    title='Value Distribution by Group',
    points='outliers'
)

# Create violin plot
violin_fig = leafmap.violin_plot(
    data=sample_data,
    x='group',
    y='values',
    title='Distribution Shapes by Group',
    box=True,
    points='outliers'
)

# Display statistical plots
overlay_hist.show()
box_fig.show()
violin_fig.show()

Dashboard Creation

import leafmap
import pandas as pd
from plotly.subplots import make_subplots

# Load comprehensive dataset
data = pd.read_csv('comprehensive_data.csv')

# Create subplot dashboard
fig = make_subplots(
    rows=2, cols=2,
    subplot_titles=['Bar Chart', 'Line Chart', 'Histogram', 'Pie Chart'],
    specs=[[{'type': 'bar'}, {'type': 'scatter'}],
           [{'type': 'histogram'}, {'type': 'pie'}]]
)

# Add bar chart
bar_trace = leafmap.bar_chart(data, x='category', y='count')
fig.add_trace(bar_trace.data[0], row=1, col=1)

# Add line chart  
line_trace = leafmap.line_chart(data, x='date', y='trend')
fig.add_trace(line_trace.data[0], row=1, col=2)

# Add histogram
hist_trace = leafmap.histogram(data, column='distribution')
fig.add_trace(hist_trace.data[0], row=2, col=1)

# Add pie chart
pie_trace = leafmap.pie_chart(data, names='segment', values='proportion')
fig.add_trace(pie_trace.data[0], row=2, col=2)

# Update layout
fig.update_layout(
    title='Comprehensive Data Dashboard',
    height=800,
    showlegend=False
)

fig.show()

Integration with Map Visualizations

import leafmap
import geopandas as gpd

# Load spatial data
cities = gpd.read_file('cities.shp')

# Create map visualization
m = leafmap.Map(center=[40, -100], zoom=4)
m.add_gdf(cities, 
         column='population',
         scheme='quantiles',
         legend=True,
         layer_name='Cities by Population')

# Create supporting charts
# Population distribution
pop_hist = leafmap.histogram(
    data=cities,
    column='population',
    title='City Population Distribution'
)

# Regional breakdown
region_pie = leafmap.pie_chart(
    data=cities.groupby('region')['population'].sum().reset_index(),
    names='region',
    values='population',
    title='Population by Region'
)

# Population vs Area relationship
scatter_fig = leafmap.scatter_plot(
    data=cities,
    x='area',
    y='population',
    color='region',
    title='Population vs Area by Region',
    size='gdp_per_capita'
)

# Display map and charts together
m
pop_hist.show()
region_pie.show() 
scatter_fig.show()

Chart Customization Options

Styling Options

chart_styling = {
    'title': 'Chart Title',              # Chart title
    'title_font_size': 16,               # Title font size
    'width': 800,                        # Chart width
    'height': 600,                       # Chart height
    'template': 'plotly_white',          # Color template
    'color_discrete_sequence': ['#FF6B6B', '#4ECDC4', '#45B7D1'],  # Custom colors
    'font_family': 'Arial',              # Font family
    'font_size': 12                      # Font size
}

Axis Options

axis_options = {
    'xaxis_title': 'X Axis Label',       # X-axis label
    'yaxis_title': 'Y Axis Label',       # Y-axis label
    'xaxis_tickangle': -45,              # X-axis tick angle
    'yaxis_type': 'log',                 # Y-axis scale (linear/log)
    'xaxis_range': [0, 100],             # X-axis range
    'yaxis_range': [0, 200],             # Y-axis range
    'showgrid': True,                    # Show grid lines
    'zeroline': True                     # Show zero line
}

Interactive Options

interactive_options = {
    'hovermode': 'x unified',            # Hover behavior
    'dragmode': 'zoom',                  # Drag behavior
    'showlegend': True,                  # Show legend
    'legend_orientation': 'h',           # Legend orientation
    'margin': dict(l=50, r=50, t=50, b=50),  # Chart margins
    'annotations': [],                   # Custom annotations
    'shapes': []                         # Custom shapes
}

Export Options

export_options = {
    'format': 'png',                     # Export format (png, pdf, svg, html)
    'width': 1200,                       # Export width
    'height': 800,                       # Export height
    'scale': 2,                          # Scale factor
    'engine': 'kaleido'                  # Rendering engine
}

Advanced Features

Statistical Annotations

Trend lines: Linear, polynomial, and LOWESS regression
Confidence intervals: Statistical uncertainty visualization
R-squared values: Correlation strength indicators
P-values: Statistical significance testing

Interactive Features

Zoom and pan: Navigate large datasets
Hover tooltips: Detailed information on demand
Crossfilter: Linked brushing across multiple charts
Animation: Time-based data exploration

Data Processing

Aggregation: Automatic grouping and summarization
Filtering: Interactive data subset selection
Sorting: Dynamic data ordering
Binning: Automatic histogram bin selection

Install with Tessl CLI

npx tessl i tessl/pypi-leafmap

tessl/pypi-leafmap