tunned-geobr 0.1.2__py3-none-any.whl → 0.2.1__py3-none-any.whl

tunned_geobr/read_ebas.py

@@ -0,0 +1,80 @@
+import geopandas as gpd
+import tempfile
+import os
+import requests
+from zipfile import ZipFile
+from io import BytesIO
+
+def read_ebas(simplified=False):
+    """Download Endemic Bird Areas (EBAs) data.
+    
+    This function downloads and processes Endemic Bird Areas (EBAs) data. EBAs are 
+    regions of the world that contain concentrations of bird species found nowhere else.
+    Original source: Global Forest Watch
+    
+    Parameters
+    ----------
+    simplified : boolean, by default False
+        If True, returns a simplified version of the dataset with fewer columns
+        
+    Returns
+    -------
+    gpd.GeoDataFrame
+        Geodataframe with Endemic Bird Areas data
+        
+    Example
+    -------
+    >>> from tunned_geobr import read_ebas
+    
+    # Read Endemic Bird Areas data
+    >>> ebas = read_ebas()
+    """
+    
+    url = "http://gfw2-data.s3.amazonaws.com/conservation/zip/endemic_bird_areas.zip"
+    
+    try:
+        # Download the zip file
+        response = requests.get(url)
+        if response.status_code != 200:
+            raise Exception("Failed to download Endemic Bird Areas data")
+            
+        # Create a temporary directory
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Extract the zip file
+            with ZipFile(BytesIO(response.content)) as zip_ref:
+                zip_ref.extractall(temp_dir)
+            
+            # Find the shapefile
+            shp_files = [f for f in os.listdir(temp_dir) if f.endswith('.shp')]
+            if not shp_files:
+                raise Exception("No shapefile found in the downloaded data")
+                
+            # Read the shapefile
+            gdf = gpd.read_file(os.path.join(temp_dir, shp_files[0]))
+            
+            # Convert to SIRGAS 2000 (EPSG:4674)
+            gdf = gdf.to_crs(4674)
+            
+            if simplified:
+                # Keep only the most relevant columns
+                columns_to_keep = [
+                    'geometry',
+                    'EBA_Name',    # Endemic Bird Area name
+                    'EBA_ID',      # Endemic Bird Area ID
+                    'Area_km2',    # Area in square kilometers
+                    'Priority',    # Conservation priority
+                    'Region',      # Geographic region
+                    'Country'      # Country
+                ]
+                
+                # Filter columns that actually exist in the dataset
+                existing_columns = ['geometry'] + [col for col in columns_to_keep[1:] if col in gdf.columns]
+                gdf = gdf[existing_columns]
+    
+    except Exception as e:
+        raise Exception(f"Error downloading Endemic Bird Areas data: {str(e)}")
+        
+    return gdf
+
+if __name__ == '__main__':
+    read_ebas()

tunned_geobr/read_federal_highways.py

@@ -0,0 +1,79 @@
+import geopandas as gpd
+import tempfile
+import os
+import requests
+from zipfile import ZipFile
+from io import BytesIO
+
+def read_federal_highways(simplified=False):
+    """Download Federal Highways data from MapBiomas.
+    
+    This function downloads and processes federal highways data from MapBiomas. 
+    The data includes information about federally-managed highways across Brazil.
+    Original source: MapBiomas
+    
+    Parameters
+    ----------
+    simplified : boolean, by default False
+        If True, returns a simplified version of the dataset with fewer columns
+
+    Returns
+    -------
+    gpd.GeoDataFrame
+        Geodataframe with federal highways data
+        
+    Example
+    -------
+    >>> from tunned_geobr import read_federal_highways
+    
+    # Read federal highways data
+    >>> highways = read_federal_highways()
+    """
+    
+    url = "https://brasil.mapbiomas.org/wp-content/uploads/sites/4/2023/08/rodovia-federal.zip"
+    
+    try:
+        # Download the zip file
+        response = requests.get(url)
+        if response.status_code != 200:
+            raise Exception("Failed to download data from MapBiomas")
+            
+        # Create a temporary directory
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Extract the zip file
+            with ZipFile(BytesIO(response.content)) as zip_ref:
+                zip_ref.extractall(temp_dir)
+            
+            # Find the shapefile
+            shp_files = []
+            for root, dirs, files in os.walk(temp_dir):
+                shp_files.extend([os.path.join(root, f) for f in files if f.endswith('.shp')])
+            
+            if not shp_files:
+                raise Exception("No shapefile found in the downloaded data")
+                
+            # Read the shapefile
+            gdf = gpd.read_file(shp_files[0])
+            gdf = gdf.to_crs(4674)  # Convert to SIRGAS 2000
+            
+            if simplified:
+                # Keep only the most relevant columns
+                columns_to_keep = [
+                    'geometry',
+                    'sigla',        # Highway code (BR-XXX)
+                    'uf',           # State
+                    'jurisdicao',   # Jurisdiction
+                    'superficie',   # Surface type
+                    'situacao',     # Status
+                    'extensao_km',  # Length in km
+                    'tipo_trecho'   # Section type
+                ]
+                
+                # Filter columns that actually exist in the dataset
+                existing_columns = ['geometry'] + [col for col in columns_to_keep[1:] if col in gdf.columns]
+                gdf = gdf[existing_columns]
+    
+    except Exception as e:
+        raise Exception(f"Error downloading federal highways data: {str(e)}")
+        
+    return gdf

tunned_geobr/read_fossil_occurrences.py

@@ -0,0 +1,94 @@
+import geopandas as gpd
+import tempfile
+import os
+import requests
+import fiona
+from zipfile import ZipFile
+from io import BytesIO
+
+def read_fossil_occurrences(simplified=False):
+    """Download Fossil Occurrences data from SGB.
+    
+    This function downloads and processes data about fossil occurrences in Brazil 
+    from SGB (Serviço Geológico do Brasil). The data comes from a File Geodatabase (.gdb)
+    and includes information about fossil sites across the country.
+    Original source: SGB - Serviço Geológico do Brasil
+    
+    Parameters
+    ----------
+    simplified : boolean, by default False
+        If True, returns a simplified version of the dataset with fewer columns
+        
+    Returns
+    -------
+    gpd.GeoDataFrame
+        Geodataframe with fossil occurrences data
+        
+    Example
+    -------
+    >>> from tunned_geobr import read_fossil_occurrences
+    
+    # Read fossil occurrences data
+    >>> fossils = read_fossil_occurrences()
+    """
+    
+    url = "https://geoportal.sgb.gov.br/downloads/paleo.gdb.zip"
+    
+    try:
+        # Download the zip file
+        response = requests.get(url)
+        if response.status_code != 200:
+            raise Exception("Failed to download data from SGB")
+            
+        # Create a temporary directory
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Save the .gdb.zip file
+            gdb_zip = os.path.join(temp_dir, "paleo.gdb.zip")
+            with open(gdb_zip, 'wb') as f:
+                f.write(response.content)
+            
+            # Create the .gdb directory
+            gdb_path = os.path.join(temp_dir, "paleo.gdb")
+            os.makedirs(gdb_path, exist_ok=True)
+            
+            # Extract the .gdb.zip file directly into the .gdb directory
+            with ZipFile(gdb_zip) as zip_ref:
+                zip_ref.extractall(gdb_path)
+            
+            # List all layers in the GDB
+            layers = fiona.listlayers(gdb_path)
+            if not layers:
+                raise Exception("No layers found in the GDB")
+                
+            # Read the first layer (assuming it's the fossil occurrences)
+            gdf = gpd.read_file(gdb_path, layer=layers[0])
+            gdf = gdf.to_crs(4674)  # Convert to SIRGAS 2000
+            
+            if simplified:
+                # Keep only the most relevant columns
+                columns_to_keep = [
+                    'geometry',
+                    'LOCALIDADE',              # Locality name
+                    'DISTRITO',                # District
+                    'UNIDADE_LITOESTRATIGRAFICA',  # Lithostratigraphic unit
+                    'UNIDADE_CRONOESTRATIGRAFICA', # Chronostratigraphic unit
+                    'LITOLOGIA',               # Lithology
+                    'VESTIGIOS_ORGANICOS',     # Organic traces
+                    'AMBIENTE_DEPOSICAO',      # Depositional environment
+                    'TAXON',                   # Taxon
+                    'SISTEMATICA',             # Systematics
+                    'MATERIAL',                # Material
+                    'REFERENCIA_BIBLIOGRAFICA' # Bibliographic reference
+                ]
+                
+                # Filter columns that actually exist in the dataset
+                existing_columns = ['geometry'] + [col for col in columns_to_keep[1:] if col in gdf.columns]
+                gdf = gdf[existing_columns]
+    
+    except Exception as e:
+        raise Exception(f"Error downloading fossil occurrences data: {str(e)}")
+        
+    return gdf
+
+if __name__ == '__main__':
+    read_fossil_occurrences()

tunned_geobr/read_geographic_regions.py

@@ -0,0 +1,88 @@
+import geopandas as gpd
+import tempfile
+import os
+import requests
+from zipfile import ZipFile
+from io import BytesIO
+
+def read_geographic_regions(simplified=False):
+    """Download Brazilian Geographic Regions data from IBGE.
+    
+    This function downloads and processes the Brazilian Geographic Regions data
+    from IBGE (Brazilian Institute of Geography and Statistics). The data includes
+    the official geographic regions division of Brazil from 2017.
+    Original source: IBGE - Instituto Brasileiro de Geografia e Estatística
+    
+    Parameters
+    ----------
+    simplified : boolean, by default False
+        If True, returns a simplified version of the dataset with fewer columns
+        
+    Returns
+    -------
+    gpd.GeoDataFrame
+        Geodataframe with Brazilian geographic regions data
+        
+    Example
+    -------
+    >>> from tunned_geobr import read_geographic_regions
+    
+    # Read geographic regions data
+    >>> regions = read_geographic_regions()
+    """
+    
+    url = "https://geoftp.ibge.gov.br/organizacao_do_territorio/divisao_regional/divisao_regional_do_brasil/divisao_regional_do_brasil_em_regioes_geograficas_2017/shp/RG2017_regioesgeograficas2017_20180911.zip"
+    
+    try:
+        # Download the zip file
+        response = requests.get(url)
+        if response.status_code != 200:
+            raise Exception("Failed to download geographic regions data from IBGE")
+            
+        # Create a temporary directory
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Extract the zip file
+            with ZipFile(BytesIO(response.content)) as zip_ref:
+                zip_ref.extractall(temp_dir)
+            
+            # Find the shapefile
+            shp_files = []
+            for root, dirs, files in os.walk(temp_dir):
+                shp_files.extend([os.path.join(root, f) for f in files if f.endswith('.shp')])
+            
+            if not shp_files:
+                raise Exception("No shapefile found in the downloaded data")
+                
+            # Read the shapefile
+            gdf = gpd.read_file(shp_files[0])
+            
+            # Convert to SIRGAS 2000 (EPSG:4674) if not already
+            if gdf.crs is None or gdf.crs.to_epsg() != 4674:
+                gdf = gdf.to_crs(4674)
+            
+            if simplified:
+                # Keep only the most relevant columns
+                # Note: Column names may need adjustment based on actual data
+                columns_to_keep = [
+                    'geometry',
+                    'CD_RGGI',     # Immediate Geographic Region Code
+                    'NM_RGGI',     # Immediate Geographic Region Name
+                    'CD_RGINT',    # Intermediate Geographic Region Code
+                    'NM_RGINT',    # Intermediate Geographic Region Name
+                    'CD_UF',       # State Code
+                    'NM_UF',       # State Name
+                    'SIGLA_UF',    # State Abbreviation
+                    'AREA_KM2'     # Area in square kilometers
+                ]
+                
+                # Filter columns that actually exist in the dataset
+                existing_columns = ['geometry'] + [col for col in columns_to_keep[1:] if col in gdf.columns]
+                gdf = gdf[existing_columns]
+    
+    except Exception as e:
+        raise Exception(f"Error downloading geographic regions data: {str(e)}")
+        
+    return gdf
+
+if __name__ == '__main__':
+    read_geographic_regions()

tunned_geobr/read_heliports.py

@@ -0,0 +1,81 @@
+import geopandas as gpd
+import tempfile
+import os
+import requests
+from zipfile import ZipFile
+from io import BytesIO
+
+def read_heliports(simplified=False):
+    """Download Heliports data from MapBiomas.
+    
+    This function downloads and processes heliports data from MapBiomas. 
+    The data includes information about heliports across Brazil.
+    Original source: MapBiomas
+    
+    Parameters
+    ----------
+    simplified : boolean, by default False
+        If True, returns a simplified version of the dataset with fewer columns
+
+    Returns
+    -------
+    gpd.GeoDataFrame
+        Geodataframe with heliports data
+        
+    Example
+    -------
+    >>> from tunned_geobr import read_heliports
+    
+    # Read heliports data
+    >>> heliports = read_heliports()
+    """
+    
+    url = "https://brasil.mapbiomas.org/wp-content/uploads/sites/4/2023/08/Helipontos.zip"
+    
+    try:
+        # Download the zip file
+        response = requests.get(url)
+        if response.status_code != 200:
+            raise Exception("Failed to download data from MapBiomas")
+            
+        # Create a temporary directory
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Extract the zip file
+            with ZipFile(BytesIO(response.content)) as zip_ref:
+                zip_ref.extractall(temp_dir)
+            
+            # Find the shapefile
+            shp_files = []
+            for root, dirs, files in os.walk(temp_dir):
+                shp_files.extend([os.path.join(root, f) for f in files if f.endswith('.shp')])
+            
+            if not shp_files:
+                raise Exception("No shapefile found in the downloaded data")
+                
+            # Read the shapefile
+            gdf = gpd.read_file(shp_files[0])
+            gdf = gdf.to_crs(4674)  # Convert to SIRGAS 2000
+            
+            if simplified:
+                # Keep only the most relevant columns
+                columns_to_keep = [
+                    'geometry',
+                    'nome',         # Heliport name
+                    'municipio',    # Municipality
+                    'uf',          # State
+                    'codigo_oaci', # ICAO code
+                    'altitude',    # Altitude
+                    'tipo_uso',    # Usage type
+                    'compriment',  # Length
+                    'largura',     # Width
+                    'tipo_pista'   # Surface type
+                ]
+                
+                # Filter columns that actually exist in the dataset
+                existing_columns = ['geometry'] + [col for col in columns_to_keep[1:] if col in gdf.columns]
+                gdf = gdf[existing_columns]
+    
+    except Exception as e:
+        raise Exception(f"Error downloading heliports data: {str(e)}")
+        
+    return gdf

tunned_geobr/read_municipality_direct.py

@@ -0,0 +1,127 @@
+import geopandas as gpd
+import tempfile
+import os
+import requests
+from zipfile import ZipFile
+from io import BytesIO
+
+def read_municipality(code_muni="all", simplified=True):
+    """Download shapefiles of Brazilian municipalities as geopandas objects.
+
+    This function downloads and processes municipality data directly from IBGE (Brazilian Institute of Geography and Statistics).
+    Data uses Geodetic reference system "SIRGAS2000" and CRS(4674).
+    
+    Parameters
+    ----------
+    code_muni : str, optional
+        The 7-digit code of a municipality. If the two-digit code or a two-letter uppercase abbreviation of
+        a state is passed, (e.g. 33 or "RJ") the function will load all municipalities of that state.
+        If code_muni="all", all municipalities of the country will be loaded (Default).
+    simplified : boolean, by default True
+        If True, returns a simplified version of the dataset with fewer columns
+
+    Returns
+    -------
+    gpd.GeoDataFrame
+        Geodataframe with municipality boundaries
+
+    Example
+    -------
+    >>> from tunned_geobr import read_municipality
+
+    # Read all municipalities
+    >>> municipalities = read_municipality()
+
+    # Read all municipalities in a state by code
+    >>> state_municipalities = read_municipality(code_muni=33)
+
+    # Read all municipalities in a state by abbreviation
+    >>> state_municipalities = read_municipality(code_muni="RJ")
+    
+    # Read specific municipality by code
+    >>> municipality = read_municipality(code_muni=3304557)
+    """
+    
+    url = "https://geoftp.ibge.gov.br/organizacao_do_territorio/malhas_territoriais/malhas_municipais/municipio_2023/Brasil/BR_Municipios_2023.zip"
+    
+    try:
+        # Download the zip file
+        response = requests.get(url)
+        if response.status_code != 200:
+            raise Exception("Failed to download municipality data from IBGE")
+            
+        # Create a temporary directory
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Extract the zip file
+            with ZipFile(BytesIO(response.content)) as zip_ref:
+                zip_ref.extractall(temp_dir)
+            
+            # Find the shapefile
+            shp_files = []
+            for root, dirs, files in os.walk(temp_dir):
+                shp_files.extend([os.path.join(root, f) for f in files if f.endswith('.shp')])
+            
+            if not shp_files:
+                raise Exception("No shapefile found in the downloaded data")
+                
+            # Read the shapefile
+            gdf = gpd.read_file(shp_files[0])
+            
+            # Convert to SIRGAS 2000 (EPSG:4674) if not already
+            if gdf.crs is None or gdf.crs.to_epsg() != 4674:
+                gdf = gdf.to_crs(4674)
+            
+            # Filter by code_muni if not "all"
+            if code_muni != "all":
+                if isinstance(code_muni, int) or code_muni.isdigit():
+                    if len(str(code_muni)) == 7:
+                        # Filter by municipality code
+                        gdf = gdf[gdf['CD_MUN'] == str(code_muni)]
+                    elif len(str(code_muni)) == 2:
+                        # Filter by state code
+                        gdf = gdf[gdf['CD_MUN'].str.startswith(str(code_muni).zfill(2))]
+                elif isinstance(code_muni, str) and len(code_muni) == 2:
+                    # Filter by state abbreviation - need to get state code first
+                    state_url = "https://geoftp.ibge.gov.br/organizacao_do_territorio/malhas_territoriais/malhas_municipais/municipio_2023/Brasil/BR_UF_2023.zip"
+                    state_response = requests.get(state_url)
+                    
+                    if state_response.status_code == 200:
+                        with tempfile.TemporaryDirectory() as state_temp_dir:
+                            with ZipFile(BytesIO(state_response.content)) as zip_ref:
+                                zip_ref.extractall(state_temp_dir)
+                            
+                            state_shp_files = []
+                            for root, dirs, files in os.walk(state_temp_dir):
+                                state_shp_files.extend([os.path.join(root, f) for f in files if f.endswith('.shp')])
+                            
+                            if state_shp_files:
+                                state_gdf = gpd.read_file(state_shp_files[0])
+                                state_code = state_gdf[state_gdf['SIGLA_UF'] == code_muni.upper()]['CD_UF'].values
+                                
+                                if len(state_code) > 0:
+                                    gdf = gdf[gdf['CD_MUN'].str.startswith(state_code[0])]
+                
+                if len(gdf) == 0:
+                    raise Exception(f"No data found for code_muni={code_muni}")
+            
+            if simplified:
+                # Keep only the most relevant columns
+                columns_to_keep = [
+                    'geometry',
+                    'CD_MUN',      # Municipality code
+                    'NM_MUN',      # Municipality name
+                    'SIGLA_UF',    # State abbreviation
+                    'AREA_KM2'     # Area in square kilometers
+                ]
+                
+                # Filter columns that actually exist in the dataset
+                existing_columns = ['geometry'] + [col for col in columns_to_keep[1:] if col in gdf.columns]
+                gdf = gdf[existing_columns]
+    
+    except Exception as e:
+        raise Exception(f"Error downloading municipality data: {str(e)}")
+        
+    return gdf
+
+if __name__ == '__main__':
+    read_municipality()

tunned_geobr/read_natural_caves.py

@@ -0,0 +1,83 @@
+import geopandas as gpd
+import tempfile
+import os
+import requests
+from zipfile import ZipFile
+from io import BytesIO
+
+def read_natural_caves(simplified=False):
+    """Download Natural Caves data from ICMBio.
+    
+    This function downloads and processes natural caves data from ICMBio's WFS service. 
+    The data includes registered natural caves across Brazil.
+    Original source: ICMBio (Instituto Chico Mendes de Conservação da Biodiversidade)
+    
+    Parameters
+    ----------
+    simplified : boolean, by default False
+        If True, returns a simplified version of the dataset with fewer columns
+
+    Returns
+    -------
+    gpd.GeoDataFrame
+        Geodataframe with natural caves data
+        
+    Example
+    -------
+    >>> from tunned_geobr import read_natural_caves
+    
+    # Read natural caves data
+    >>> caves = read_natural_caves()
+    """
+    
+    url = "https://geoservicos.inde.gov.br/geoserver/ICMBio/ows?service=wfs&version=1.3.0&request=GetFeature&TYPENAMES=cavernas_092022_p&SRSNAME=EPSG:4674&OUTPUTFORMAT=shape-zip"
+    
+    try:
+        # Download the zip file
+        response = requests.get(url)
+        if response.status_code != 200:
+            raise Exception("Failed to download data from ICMBio WFS service")
+            
+        # Create a temporary directory
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Extract the zip file
+            with ZipFile(BytesIO(response.content)) as zip_ref:
+                zip_ref.extractall(temp_dir)
+            
+            # Find the shapefile
+            shp_files = []
+            for root, dirs, files in os.walk(temp_dir):
+                shp_files.extend([os.path.join(root, f) for f in files if f.endswith('.shp')])
+            
+            if not shp_files:
+                raise Exception("No shapefile found in the downloaded data")
+                
+            # Read the shapefile
+            gdf = gpd.read_file(shp_files[0])
+            
+            # CRS should already be 4674 (SIRGAS 2000) as requested in WFS query
+            # but let's ensure it
+            if gdf.crs is None or gdf.crs.to_epsg() != 4674:
+                gdf = gdf.to_crs(4674)
+            
+            if simplified:
+                # Keep only the most relevant columns
+                columns_to_keep = [
+                    'geometry',
+                    'nome',          # Cave name
+                    'municipio',     # Municipality
+                    'uf',           # State
+                    'litologia',    # Lithology
+                    'desenvolvimento_m',  # Cave development in meters
+                    'tipo',         # Type
+                    'status'        # Status
+                ]
+                
+                # Filter columns that actually exist in the dataset
+                existing_columns = ['geometry'] + [col for col in columns_to_keep[1:] if col in gdf.columns]
+                gdf = gdf[existing_columns]
+    
+    except Exception as e:
+        raise Exception(f"Error downloading natural caves data: {str(e)}")
+        
+    return gdf