Interactive Maps

class Map:
    def __init__(self, center=[20, 0], zoom=2, basemap='HYBRID', **kwargs):
        """
        Create an interactive map.
        
        Args:
            center (list): Map center as [latitude, longitude]
            zoom (int): Initial zoom level (1-20)
            basemap (str): Base map provider name
            **kwargs: Backend-specific options
        """
    
    def add_basemap(self, basemap='HYBRID', show=True, **kwargs):
        """
        Add a basemap to the map.
        
        Args:
            basemap (str): Basemap provider name or custom definition
            show (bool): Whether to show the basemap immediately
            **kwargs: Basemap-specific options
        """
    
    def add_layer_control(self, position='topright', **kwargs):
        """
        Add a layer control widget to toggle layers.
        
        Args:
            position (str): Control position ('topright', 'topleft', 'bottomright', 'bottomleft')
            **kwargs: Control-specific options
        """
    
    def add_fullscreen_control(self, **kwargs):
        """
        Add a fullscreen control button.
        
        Args:
            **kwargs: Control-specific options
        """
    
    def set_center(self, lon, lat, zoom=None):
        """
        Center map at specific coordinates.
        
        Args:
            lon (float): Longitude coordinate
            lat (float): Latitude coordinate  
            zoom (int): Optional zoom level
        """
    
    def zoom_to_bounds(self, bounds):
        """
        Zoom map to fit bounding box.
        
        Args:
            bounds (list): Bounding box [minx, miny, maxx, maxy]
        """
    
    def find_layer(self, name):
        """
        Find layer by name.
        
        Args:
            name (str): Layer name to search for
            
        Returns:
            Layer object or None if not found
        """
    
    def get_layer_names(self):
        """
        Get list of all layer names.
        
        Returns:
            list: Layer names
        """

def add_layer(self, layer, **kwargs):
    """
    Add a generic layer to the map.
    
    Args:
        layer: Layer object (backend-specific)
        **kwargs: Layer-specific options
    """

def add_tile_layer(self, url, name='Untitled', attribution='', **kwargs):
    """
    Add an XYZ tile layer.
    
    Args:
        url (str): Tile URL template with {x}, {y}, {z} placeholders
        name (str): Layer name for display
        attribution (str): Attribution text
        **kwargs: Tile layer options (opacity, etc.)
    """

def add_wms_layer(self, url, layers, name='Untitled', **kwargs):
    """
    Add a WMS layer.
    
    Args:
        url (str): WMS service URL
        layers (str): Comma-separated layer names
        name (str): Layer name for display
        **kwargs: WMS-specific options (format, transparent, etc.)
    """

def add_wmts_layer(self, url, layer, **kwargs):
    """
    Add a WMTS layer.
    
    Args:
        url (str): WMTS service URL
        layer (str): Layer identifier
        **kwargs: WMTS-specific options
    """

def add_vector_tile(self, url, **kwargs):
    """
    Add a vector tile layer.
    
    Args:
        url (str): Vector tile URL template
        **kwargs: Vector tile styling options
    """

def add_pmtiles(self, url, **kwargs):
    """
    Add a PMTiles layer.
    
    Args:
        url (str): PMTiles file URL
        **kwargs: PMTiles-specific options
    """

def add_markers(self, markers, **kwargs):
    """
    Add point markers to the map.
    
    Args:
        markers (list): List of marker coordinates [[lat, lon], ...]
        **kwargs: Marker styling options (color, size, popup, etc.)
    """

def add_circle_markers_from_xy(self, data, x, y, **kwargs):
    """
    Add circle markers from coordinate data.
    
    Args:
        data: DataFrame or similar with coordinate columns
        x (str): Column name for longitude/x coordinates
        y (str): Column name for latitude/y coordinates
        **kwargs: Circle marker options (radius, color, etc.)
    """

def add_draw_control(self, **kwargs):
    """
    Add drawing tools for interactive geometry creation.
    
    Args:
        **kwargs: Drawing control options (draw_options, edit_options, etc.)
    """

def add_measure_control(self, **kwargs):
    """
    Add measurement tools for distance and area calculation.
    
    Args:
        **kwargs: Measurement control options
    """

def add_toolbar(self, **kwargs):
    """
    Add a custom toolbar with various tools.
    
    Args:
        **kwargs: Toolbar configuration options
    """

def split_map(self, left_layer=None, right_layer=None, **kwargs):
    """
    Create a split-screen map comparison.
    
    Args:
        left_layer: Layer for left side of comparison
        right_layer: Layer for right side of comparison
        **kwargs: Split map options (add_close_button, etc.)
    """

def linked_maps(self, rows=2, cols=2, **kwargs):
    """
    Create linked maps that pan and zoom together.
    
    Args:
        rows (int): Number of map rows
        cols (int): Number of map columns
        **kwargs: Linked map options
    """

def to_html(self, filename=None, **kwargs):
    """
    Export map to HTML file.
    
    Args:
        filename (str): Output HTML file path
        **kwargs: Export options (title, width, height, etc.)
        
    Returns:
        str: HTML content if filename is None
    """

def to_image(self, filename=None, **kwargs):
    """
    Export map to image file.
    
    Args:
        filename (str): Output image file path
        **kwargs: Image export options (width, height, dpi, etc.)
        
    Returns:
        bytes: Image data if filename is None
    """

def to_streamlit(self, **kwargs):
    """
    Convert map for Streamlit display.
    
    Args:
        **kwargs: Streamlit-specific options
        
    Returns:
        streamlit component
    """

def save_draw_features(self, filename, **kwargs):
    """
    Save drawn features to file.
    
    Args:
        filename (str): Output file path
        **kwargs: Save options (format, crs, etc.)
    """

import leafmap.leafmap as leafmap

# Full API with 222 methods including:
# - Complete layer management
# - Interactive widgets and controls  
# - Advanced analysis tools
# - Export capabilities

import leafmap.foliumap as leafmap

# 149 methods with focus on:
# - Core mapping functionality
# - HTML export compatibility
# - Colab/marimo optimization

import leafmap.maplibregl as leafmap

# 179 methods including:
# - 3D terrain visualization
# - WebGL acceleration
# - Advanced styling with JSON
# - Custom UI widgets

import leafmap.plotlymap as leafmap

# 50+ methods focused on:
# - Statistical visualization
# - Dashboard integration
# - Interactive plotting

import leafmap.deckgl as leafmap      # GPU-accelerated visualization
import leafmap.bokehmap as leafmap    # Server-based applications  
import leafmap.kepler as leafmap      # Advanced geospatial visualization
import leafmap.heremap as leafmap     # HERE Maps integration
import leafmap.mapbox as leafmap      # Custom Mapbox GL JS

import leafmap

# Create a basic map
m = leafmap.Map(center=[37.7749, -122.4194], zoom=10)

# Add basemap
m.add_basemap('SATELLITE')

# Add layer control
m.add_layer_control()

# Display
m

# Force specific backend
import leafmap.maplibregl as leafmap

# Create 3D map
m = leafmap.Map(
    center=[37.7749, -122.4194], 
    zoom=10,
    pitch=60,
    bearing=45
)

# Add 3D terrain
m.add_3d_terrain()