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

tunned_geobr/read_apcb_zcm.py

@@ -0,0 +1,78 @@
+import geopandas as gpd
+import tempfile
+import os
+import requests
+from zipfile import ZipFile
+from io import BytesIO
+
+def read_apcb_zcm(simplified=False):
+    """Download Priority Areas for Biodiversity Conservation (APCB) data for the Coastal and Marine Zone.
+    
+    This function downloads and processes APCB data from the Ministry of Environment (MMA). 
+    The data includes priority areas for biodiversity conservation in the Coastal and Marine Zone (ZCM).
+    Original source: Ministério do Meio Ambiente (MMA)
+    
+    Parameters
+    ----------
+    simplified : boolean, by default False
+        If True, returns a simplified version of the dataset with fewer columns
+
+    Returns
+    -------
+    gpd.GeoDataFrame
+        Geodataframe with Coastal and Marine Zone APCB data
+        
+    Example
+    -------
+    >>> from tunned_geobr import read_apcb_zcm
+    
+    # Read Coastal and Marine Zone APCB data
+    >>> apcb = read_apcb_zcm()
+    """
+    
+    url = "https://www.gov.br/mma/pt-br/assuntos/biodiversidade-e-biomas/biomas-e-ecossistemas/conservacao-1/areas-prioritarias/arquivos/zcm.zip"
+    
+    try:
+        # Download the zip file
+        response = requests.get(url)
+        if response.status_code != 200:
+            raise Exception("Failed to download data from MMA")
+            
+        # 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',        # Area name
+                    'Importanci',  # Importance
+                    'Prioridade',  # Priority
+                    'Area_km2',    # Area in km²
+                    'Oportunida',  # Opportunity
+                    'Ameaca'       # Threats
+                ]
+                
+                # 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 Coastal and Marine Zone APCB data: {str(e)}")
+        
+    return gdf

tunned_geobr/read_archaeological_sites.py

@@ -0,0 +1,94 @@
+import geopandas as gpd
+import tempfile
+import os
+import requests
+from zipfile import ZipFile
+from io import BytesIO
+
+def read_archaeological_sites(simplified=False):
+    """Download Archaeological Sites data from IPHAN.
+    
+    This function downloads and processes data about archaeological sites in Brazil 
+    from IPHAN (Instituto do Patrimônio Histórico e Artístico Nacional). The data 
+    includes location and basic information about registered archaeological sites.
+    Original source: IPHAN - Instituto do Patrimônio Histórico e Artístico Nacional
+    
+    Parameters
+    ----------
+    simplified : boolean, by default False
+        If True, returns a simplified version of the dataset with fewer columns
+        
+    Returns
+    -------
+    gpd.GeoDataFrame
+        Geodataframe with archaeological sites data
+        Columns:
+        - geometry: Site location
+        - nome: Site name
+        - municipio: Municipality
+        - uf: State
+        - tipo: Site type
+        - exposicao: Exposure type
+        - relevancia: Relevance
+        - preservacao: Preservation state
+        - datacao: Dating
+        - artefatos: Artifacts found
+        - fonte: Data source
+        
+    Example
+    -------
+    >>> from tunned_geobr import read_archaeological_sites
+    
+    # Read archaeological sites data
+    >>> sites = read_archaeological_sites()
+    """
+    
+    url = "http://portal.iphan.gov.br/geoserver/SICG/ows?service=WFS&version=1.0.0&request=GetFeature&typeName=SICG:sitios&maxFeatures=50000&outputFormat=SHAPE-ZIP"
+    
+    try:
+        # Download the zip file
+        response = requests.get(url)
+        if response.status_code != 200:
+            raise Exception("Failed to download data from IPHAN")
+            
+        # 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
+            
+            # Print columns for debugging
+            print("Available columns:", gdf.columns)
+            
+            if simplified:
+                # Keep only the most relevant columns
+                columns_to_keep = [
+                    'geometry',
+                    'nome',       # Site name
+                    'municipio',  # Municipality
+                    'uf',         # State
+                    'tipo',       # Site type
+                    'relevancia', # Relevance
+                    'preservacao' # Preservation state
+                ]
+                
+                # 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 archaeological sites data: {str(e)}")
+        
+    return gdf
+
+if __name__ == '__main__':
+    read_archaeological_sites()

tunned_geobr/read_atlantic_forest_law_limits.py

@@ -0,0 +1,74 @@
+import geopandas as gpd
+import tempfile
+import os
+import requests
+from zipfile import ZipFile
+from io import BytesIO
+
+def read_atlantic_forest_law_limits(simplified=False):
+    """Download Atlantic Forest Legal Limits data from MMA/IBGE.
+    
+    This function downloads and processes data about the Atlantic Forest legal limits 
+    as defined by Law 11.428/2006. The data is provided by IBGE and MMA (Ministry of Environment).
+    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 Atlantic Forest legal limits data
+        
+    Example
+    -------
+    >>> from tunned_geobr import read_atlantic_forest_law_limits
+    
+    # Read Atlantic Forest legal limits data
+    >>> limits = read_atlantic_forest_law_limits()
+    """
+    
+    url = "http://antigo.mma.gov.br/estruturas/202/_arquivos/shape_mata_atlantica_ibge_5milhoes_policonica_sirgas2000shp_202.zip"
+    
+    try:
+        # Download the zip file
+        response = requests.get(url)
+        if response.status_code != 200:
+            raise Exception("Failed to download data from MMA")
+            
+        # 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',
+                    'NM_TEMA',    # Theme name
+                    'NM_REGIAO',  # Region name
+                    'AREA_KM2',   # Area in km²
+                    'LEI',        # Law reference
+                    'FONTE'       # Data source
+                ]
+                
+                # 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 Atlantic Forest legal limits data: {str(e)}")
+        
+    return gdf

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