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

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

tunned_geobr/read_neighborhoods_2022.py

@@ -0,0 +1,99 @@
+import geopandas as gpd
+import tempfile
+import os
+import requests
+import subprocess
+from io import BytesIO
+
+def read_neighborhoods_2022(simplified=False):
+    """Download Brazilian Neighborhoods data from IBGE (2022 Census).
+    
+    This function downloads and processes the Brazilian Neighborhoods data
+    from IBGE (Brazilian Institute of Geography and Statistics) for the 2022 Census.
+    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 neighborhoods data
+        
+    Example
+    -------
+    >>> from tunned_geobr import read_neighborhoods_2022
+    
+    # Read neighborhoods data
+    >>> neighborhoods = read_neighborhoods_2022()
+    """
+    
+    url = "https://geoftp.ibge.gov.br/organizacao_do_territorio/malhas_territoriais/malhas_de_setores_censitarios__divisoes_intramunicipais/censo_2022/bairros/shp/BR/BR_bairros_CD2022.zip"
+    
+    try:
+        # Create a temporary directory
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Download the zip file to the temporary directory
+            zip_file_path = os.path.join(temp_dir, "neighborhoods.zip")
+            
+            # Download the file
+            response = requests.get(url)
+            if response.status_code != 200:
+                raise Exception("Failed to download neighborhoods data from IBGE")
+                
+            # Save the content to a file
+            with open(zip_file_path, 'wb') as f:
+                f.write(response.content)
+            
+            # Use unzip command line tool to extract the file (handles more compression methods)
+            try:
+                subprocess.run(['unzip', '-o', zip_file_path, '-d', temp_dir], 
+                              check=True, 
+                              stdout=subprocess.PIPE, 
+                              stderr=subprocess.PIPE)
+            except subprocess.CalledProcessError as e:
+                raise Exception(f"Failed to extract zip file: {e.stderr.decode()}")
+            
+            # 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_BAIRRO',   # Neighborhood Code
+                    'NM_BAIRRO',   # Neighborhood Name
+                    'CD_MUN',      # Municipality Code
+                    'NM_MUN',      # Municipality 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 neighborhoods data: {str(e)}")
+        
+    return gdf
+
+if __name__ == '__main__':
+    read_neighborhoods_2022()

tunned_geobr/read_pan_strategic_areas.py

@@ -0,0 +1,89 @@
+import geopandas as gpd
+import tempfile
+import os
+import requests
+from zipfile import ZipFile
+from io import BytesIO
+
+def read_pan_strategic_areas(simplified=False):
+    """Download Strategic Areas data from ICMBio's PAN.
+    
+    This function downloads and processes the Strategic Areas data from ICMBio's 
+    National Action Plans (PAN). These are areas of strategic importance for 
+    biodiversity conservation in 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 PAN strategic areas data
+        
+    Example
+    -------
+    >>> from tunned_geobr import read_pan_strategic_areas
+    
+    # Read PAN strategic areas data
+    >>> strategic_areas = read_pan_strategic_areas()
+    """
+    
+    url = "https://geoservicos.inde.gov.br/geoserver/ICMBio/ows?request=GetFeature&service=WFS&version=1.0.0&typeName=ICMBio:pan_icmbio_areas_estrat_052024_a&outputFormat=SHAPE-ZIP"
+    
+    try:
+        # Download the zip file
+        response = requests.get(url)
+        if response.status_code != 200:
+            raise Exception("Failed to download strategic areas data from ICMBio")
+            
+        # 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',
+                    'nome',        # Area name
+                    'pan',         # PAN name
+                    'tipo',        # Type of strategic area
+                    'area_km2',    # Area in square kilometers
+                    'bioma',       # Biome
+                    'uf',          # State
+                    'municipio',   # Municipality
+                    'importancia', # Importance
+                    'descricao'    # Description
+                ]
+                
+                # 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 PAN strategic areas data: {str(e)}")
+        
+    return gdf
+
+if __name__ == '__main__':
+    read_pan_strategic_areas()

tunned_geobr/read_ports.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_ports(simplified=False):
+    """Download Brazilian Ports data from SNIRH.
+    
+    This function downloads and processes ports data from SNIRH (Sistema Nacional de 
+    Informações sobre Recursos Hídricos). The data includes information about ports 
+    across Brazil.
+    Original source: SNIRH (Sistema Nacional de Informações sobre Recursos Hídricos)
+    
+    Parameters
+    ----------
+    simplified : boolean, by default False
+        If True, returns a simplified version of the dataset with fewer columns
+
+    Returns
+    -------
+    gpd.GeoDataFrame
+        Geodataframe with Brazilian ports data
+        
+    Example
+    -------
+    >>> from tunned_geobr import read_ports
+    
+    # Read ports data
+    >>> ports = read_ports()
+    """
+    
+    url = "https://metadados.snirh.gov.br/geonetwork/srv/api/records/0afc9687-db93-4eb1-ab31-3bbd871ff303/attachments/GEOFT_PORTO.zip"
+    
+    try:
+        # Download the zip file
+        response = requests.get(url)
+        if response.status_code != 200:
+            raise Exception("Failed to download data from SNIRH")
+            
+        # 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',          # Port name
+                    'municipio',     # Municipality
+                    'uf',           # State
+                    'tipo',         # Port type
+                    'administra',   # Administration
+                    'situacao',     # Status
+                    'localizaca'    # Location details
+                ]
+                
+                # 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 ports data: {str(e)}")
+        
+    return gdf