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

tunned_geobr/read_baze_sites.py

@@ -0,0 +1,155 @@
+import geopandas as gpd
+import tempfile
+import os
+import requests
+import subprocess
+import platform
+import shutil
+from io import BytesIO
+
+def read_baze_sites(simplified=False):
+    """Download Brazilian BAZE Sites data from MMA.
+    
+    This function downloads and processes the Brazilian BAZE Sites data
+    (Sites of Biological Importance and Ecosystem Services) from the
+    Ministry of Environment (MMA).
+    Original source: MMA - Ministério do Meio Ambiente
+    
+    Note: This function requires either 'unrar' or 'unar' to be installed on your system
+    to extract the RAR file. If you don't have these tools installed, you'll need to 
+    install them:
+    - On macOS: brew install unrar or brew install unar
+    - On Ubuntu/Debian: sudo apt-get install unrar or sudo apt-get install unar
+    - On Windows: Install WinRAR or 7-Zip
+    
+    Parameters
+    ----------
+    simplified : boolean, by default False
+        If True, returns a simplified version of the dataset with fewer columns
+        
+    Returns
+    -------
+    gpd.GeoDataFrame
+        Geodataframe with Brazilian BAZE Sites data
+        
+    Example
+    -------
+    >>> from tunned_geobr import read_baze_sites
+    
+    # Read BAZE Sites data
+    >>> baze_sites = read_baze_sites()
+    """
+    
+    url = "http://antigo.mma.gov.br/images/arquivo/80046/Especies/SitiosBAZE_2018.rar"
+    
+    # Check if extraction tools are available
+    unrar_available = shutil.which('unrar') is not None
+    unar_available = shutil.which('unar') is not None
+    seven_zip_available = shutil.which('7z') is not None
+    
+    if not (unrar_available or unar_available or seven_zip_available):
+        os_name = platform.system()
+        if os_name == 'Darwin':  # macOS
+            install_msg = "Install with: brew install unrar or brew install unar"
+        elif os_name == 'Linux':
+            install_msg = "Install with: sudo apt-get install unrar or sudo apt-get install unar"
+        elif os_name == 'Windows':
+            install_msg = "Install WinRAR or 7-Zip"
+        else:
+            install_msg = "Install unrar, unar, or 7-Zip"
+            
+        raise Exception(f"No RAR extraction tool found. This function requires unrar, unar, or 7-Zip to extract the data. {install_msg}")
+    
+    try:
+        # Create a temporary directory
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Download the RAR file to the temporary directory
+            rar_file_path = os.path.join(temp_dir, "baze_sites.rar")
+            
+            # Download the file
+            response = requests.get(url)
+            if response.status_code != 200:
+                raise Exception("Failed to download BAZE Sites data from MMA")
+                
+            # Save the content to a file
+            with open(rar_file_path, 'wb') as f:
+                f.write(response.content)
+            
+            # Extract the RAR file using available tools
+            extraction_success = False
+            extraction_error = ""
+            
+            if unrar_available:
+                try:
+                    subprocess.run(['unrar', 'x', rar_file_path, temp_dir], 
+                                  check=True, 
+                                  stdout=subprocess.PIPE, 
+                                  stderr=subprocess.PIPE)
+                    extraction_success = True
+                except subprocess.CalledProcessError as e:
+                    extraction_error += f"unrar failed: {e.stderr.decode()}. "
+            
+            if not extraction_success and unar_available:
+                try:
+                    subprocess.run(['unar', '-d', rar_file_path, '-o', temp_dir], 
+                                  check=True, 
+                                  stdout=subprocess.PIPE, 
+                                  stderr=subprocess.PIPE)
+                    extraction_success = True
+                except subprocess.CalledProcessError as e:
+                    extraction_error += f"unar failed: {e.stderr.decode()}. "
+            
+            if not extraction_success and seven_zip_available:
+                try:
+                    subprocess.run(['7z', 'x', rar_file_path, f'-o{temp_dir}'], 
+                                  check=True, 
+                                  stdout=subprocess.PIPE, 
+                                  stderr=subprocess.PIPE)
+                    extraction_success = True
+                except subprocess.CalledProcessError as e:
+                    extraction_error += f"7z failed: {e.stderr.decode()}. "
+            
+            if not extraction_success:
+                raise Exception(f"Failed to extract RAR file: {extraction_error}")
+            
+            # 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',        # Site name
+                    'categoria',   # Category
+                    'area_km2',    # Area in square kilometers
+                    'bioma',       # Biome
+                    'uf',          # State
+                    'importancia', # Importance
+                    'descricao',   # Description
+                    'referencia'   # 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 BAZE Sites data: {str(e)}")
+        
+    return gdf
+
+if __name__ == '__main__':
+    read_baze_sites()

tunned_geobr/read_biosphere_reserves.py

@@ -0,0 +1,85 @@
+import geopandas as gpd
+import tempfile
+import os
+import gdown
+from zipfile import ZipFile
+
+def read_biosphere_reserves(simplified=False):
+    """Download Brazilian Biosphere Reserves data.
+    
+    This function downloads and processes the Brazilian Biosphere Reserves data
+    from a Google Drive repository. The data includes UNESCO Biosphere Reserves
+    in Brazil, which are protected areas with high biodiversity value.
+    Original source: MMA - Ministério do Meio Ambiente
+    
+    Parameters
+    ----------
+    simplified : boolean, by default False
+        If True, returns a simplified version of the dataset with fewer columns
+        
+    Returns
+    -------
+    gpd.GeoDataFrame
+        Geodataframe with Brazilian biosphere reserves data
+        
+    Example
+    -------
+    >>> from tunned_geobr import read_biosphere_reserves
+    
+    # Read biosphere reserves data
+    >>> reserves = read_biosphere_reserves()
+    """
+    
+    # Google Drive folder URL
+    folder_url = "https://drive.google.com/drive/folders/19ygCKsQrI1gfRMe1jUbHZGQibbN_oLAC"
+    
+    try:
+        # Create a temporary directory
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Download the file from Google Drive
+            output_zip = os.path.join(temp_dir, "biosphere_reserves.zip")
+            
+            # Use gdown to download the folder contents
+            gdown.download_folder(folder_url, output=temp_dir, quiet=False)
+            
+            # 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',        # Reserve name
+                    'categoria',   # Category
+                    'area_km2',    # Area in square kilometers
+                    'bioma',       # Biome
+                    'uf',          # State
+                    'ano_criacao', # Creation year
+                    'legislacao',  # Legislation
+                    'orgao_gestor' # Managing agency
+                ]
+                
+                # 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 biosphere reserves data: {str(e)}")
+        
+    return gdf
+
+if __name__ == '__main__':
+    read_biosphere_reserves()

tunned_geobr/read_cave_potential.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_cave_potential(simplified=False):
+    """Download Cave Occurrence Potential data from ICMBio.
+    
+    This function downloads and processes data about the potential for cave occurrence 
+    across Brazil. The data is based on lithological characteristics and was produced 
+    by ICMBio's National Center for Cave Research and Conservation (CECAV).
+    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 cave occurrence potential data
+        Columns:
+        - geometry: Geometry of the area
+        - METODOLOGI: Methodology used to determine potential
+        - GRAU_DE_PO: Potential degree (Very High, High, Medium, Low, Very Low)
+        - COUNT: Number of occurrences in the area
+        
+    Example
+    -------
+    >>> from tunned_geobr import read_cave_potential
+    
+    # Read cave potential data
+    >>> potential = read_cave_potential()
+    """
+    
+    url = "https://www.gov.br/icmbio/pt-br/assuntos/centros-de-pesquisa/cavernas/publicacoes/mapa-de-potencialidades-de-ocorrencia-de-cavernas-no-brasil/dados-mapa-de-potencialidades-de-ocorrencia-de-cavermas-no-brasil.zip/@@download/file"
+    
+    try:
+        # Download the zip file
+        response = requests.get(url)
+        if response.status_code != 200:
+            raise Exception("Failed to download 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 = [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]))
+            gdf = gdf.to_crs(4674)  # Convert to SIRGAS 2000
+            
+            if simplified:
+                # Keep only the most relevant columns
+                columns_to_keep = [
+                    'geometry',
+                    'GRAU_DE_PO'  # Potential degree
+                ]
+                
+                # 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 cave potential data: {str(e)}")
+        
+    return gdf
+
+if __name__ == '__main__':
+    read_cave_potential()

tunned_geobr/read_census_tract_2022.py

@@ -0,0 +1,101 @@
+import geopandas as gpd
+import tempfile
+import os
+import requests
+import subprocess
+from io import BytesIO
+
+def read_census_tract_2022(simplified=False):
+    """Download Brazilian Census Tracts data from IBGE (2022 Census).
+    
+    This function downloads and processes the Brazilian Census Tracts 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 census tracts data
+        
+    Example
+    -------
+    >>> from tunned_geobr import read_census_tract_2022
+    
+    # Read census tracts data
+    >>> census_tracts = read_census_tract_2022()
+    """
+    
+    url = "https://geoftp.ibge.gov.br/organizacao_do_territorio/malhas_territoriais/malhas_de_setores_censitarios__divisoes_intramunicipais/censo_2022/setores/shp/BR/BR_setores_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, "census_tracts.zip")
+            
+            # Download the file
+            response = requests.get(url)
+            if response.status_code != 200:
+                raise Exception("Failed to download census tracts 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_SETOR',    # Census Tract Code
+                    'NM_SETOR',    # Census Tract Name
+                    'CD_SIT',      # Situation Code
+                    'NM_SIT',      # Situation Name (Urban/Rural)
+                    '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 census tracts data: {str(e)}")
+        
+    return gdf
+
+if __name__ == '__main__':
+    read_census_tract_2022()

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()