tunned-geobr 1.0.0__py3-none-any.whl → 1.0.2__py3-none-any.whl

tunned_geobr/__init__.py

@@ -18,7 +18,6 @@ from .read_meso_region import read_meso_region
 from .read_micro_region import read_micro_region
 from .read_municipality import read_municipality
 from .read_weighting_area import read_weighting_area
-from .read_neighborhood import read_neighborhood
 from .read_health_region import read_health_region
 from .read_pop_arrangements import read_pop_arrangements
 from .lookup_muni import lookup_muni
@@ -65,7 +64,7 @@ from .read_water_bodies_ana import read_water_bodies_ana
 from .read_pan_strategic_areas import read_pan_strategic_areas
 from .read_geographic_regions import read_geographic_regions
 from .read_biosphere_reserves import read_biosphere_reserves
-from .read_neighborhoods_2022 import read_neighborhoods_2022
+from .read_neighborhood import read_neighborhood
 from .read_baze_sites import read_baze_sites
 from .read_existent_eolic import read_existent_eolic
 from .read_planned_eolic import read_planned_eolic

tunned_geobr/read_immediate_region.py

@@ -1,81 +1,69 @@
-from geobr.utils import select_metadata, download_gpkg, change_type_list, test_options
-
-
-def read_immediate_region(
-    code_immediate="all", year=2017, simplified=False, verbose=False
-):
-    """ Download shape files of Brazil's Immediate Geographic Areas as sf objects
+import geopandas as gpd
+import tempfile
+import os
+import requests
+from zipfile import ZipFile
+from io import BytesIO
+
+def read_immediate_region(simplified=False):
+    """Download official immediate region data from IBGE.
+    
+    This function downloads and processes immediate region data from IBGE (Brazilian Institute of Geography and Statistics).
+    The data includes immediate regions of Brazil for the year 2023.
+    Original source: IBGE
     
-     The Immediate Geographic Areas are part of the geographic division of 
-     Brazil created in 2017 by IBGE to replace the "Micro Regions" division. 
-     Data at scale 1:250,000, using Geodetic reference system "SIRGAS2000" 
-     and CRS(4674)
-
     Parameters
     ----------
-    code_immediate: 
-        6-digit code of an immediate region. 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 immediate regions of that state. If 
-        code_immediate="all", all immediate regions of the country are loaded 
-        (defaults to "all").
-    year : int, optional
-        Year of the data, by default 2017
-    simplify: boolean, by default True
-        Data 'type', indicating whether the function returns the 'original' dataset 
-        with high resolution or a dataset with 'simplify' borders (Default)
-    verbose : bool, optional
-        by default False
-    
+    simplified : boolean, by default False
+        If True, returns a simplified version of the dataset with fewer columns
+        
     Returns
     -------
     gpd.GeoDataFrame
-        Metadata and geopackage of selected states
-    
-    Raises
-    ------
-    Exception
-        If parameters are not found or not well defined
-
+        Geodataframe with immediate region data
+        
     Example
     -------
     >>> from geobr import read_immediate_region
-
-    # Read specific state at a given year
-    >>> df = read_immediate_region(year=2017)
+    
+    # Read immediate region data
+    >>> immediate_region = read_immediate_region()
     """
-
-    test_options(code_immediate, "code_immediate", not_allowed=[None])
-
-    metadata = select_metadata("immediate_regions", year=year, simplified=simplified)
-
-    gdf = download_gpkg(metadata)
-
-    # ensure type
-    code_immediate = str(code_immediate)
-
-    if code_immediate == "all":
-
-        if verbose:
-            print(
-                "Loading data for the whole country. "
-                "This might take a few minutes.\n"
-            )
-
-        return gdf
-
-    elif code_immediate in gdf["abbrev_state"].tolist():
-
-        return gdf.query(f'abbrev_state == "{code_immediate}"')
-
-    elif code_immediate in change_type_list(gdf["code_state"].tolist()):
-
-        return gdf.query(f'code_state == "{code_immediate}"')
-
-    elif code_immediate in change_type_list(gdf["code_immediate"].tolist()):
-
-        return gdf.query(f'code_immediate == "{code_immediate}"')
-
-    else:
-
-        raise Exception("Invalid Value to argument 'code_immediate'")
+    
+    url = "https://geoftp.ibge.gov.br/organizacao_do_territorio/malhas_territoriais/malhas_municipais/municipio_2023/Brasil/BR_RG_Imediatas_2023.zip"
+    
+    try:
+        # Download the zip file
+        response = requests.get(url)
+        if response.status_code != 200:
+            raise Exception("Failed to download data from IBGE")
+            
+        # Create a temporary directory
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Extract zip content
+            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]))
+            
+            if simplified:
+                # Keep only the most relevant columns
+                # Note: These columns are based on typical immediate region data structure
+                # You may want to adjust these based on the actual data
+                columns_to_keep = [
+                    'geometry',
+                    'CD_RGI',  # Immediate region code
+                    'NM_RGI',  # Immediate region name
+                ]
+                gdf = gdf[columns_to_keep]
+    
+    except Exception as e:
+        raise Exception(f"Error downloading immediate region data: {str(e)}")
+        
+    return gdf

tunned_geobr/read_indigenous_land.py

@@ -1,44 +1,77 @@
-from geobr.utils import select_metadata, download_gpkg
+import geopandas as gpd
+import tempfile
+import os
+import requests
+from zipfile import ZipFile
+from io import BytesIO
 
-
-def read_indigenous_land(date=201907, simplified=False, verbose=False):
-    """ Download official data of indigenous lands as an sf object.
+def read_indigenous_land(simplified=False):
+    """Download Indigenous Land data from FUNAI.
+    
+    This function downloads and processes data about indigenous lands in Brazil 
+    from FUNAI (Fundação Nacional dos Povos Indígenas). The data includes location 
+    and basic information about registered indigenous lands.
+    Original source: FUNAI - Fundação Nacional dos Povos Indígenas
     
-     The data set covers the whole of Brazil and it includes indigenous lands from all ethnicities and
- in different stages of demarcation. The original data comes from the National Indian Foundation (FUNAI)
- and can be found at http://www.funai.gov.br/index.php/shape. Although original data is updated monthly,
- the geobr package will only keep the data for a few months per year.
-
     Parameters
     ----------
-    date : int, optional
-        A date numer in YYYYMM format, by default 201907
-    simplified: boolean, by default True
-        Data 'type', indicating whether the function returns the 'original' dataset 
-        with high resolution or a dataset with 'simplified' borders (Default)
-    verbose : bool, optional
-        by default False
-    
+    simplified : boolean, by default False
+        If True, returns a simplified version of the dataset with fewer columns
+        
     Returns
     -------
     gpd.GeoDataFrame
-        Metadata and geopackage of selected states
-    
-    Raises
-    ------
-    Exception
-        If parameters are not found or not well defined
-
+        Geodataframe with indigenous land data
+        Columns:
+        - geometry: Land boundaries
+        - nome: Land name
+        - municipio: Municipality
+        - uf: State
+        - etnia: Ethnicity
+        - fase: Legal status
+        - area_ha: Area in hectares
+        
     Example
     -------
-    >>> from geobr import read_indigenous_land
-
-    # Read specific state at a given year
-    >>> df = read_indigenous_land(date=201907)
+    >>> from tunned_geobr import read_indigenous_land
+    >>> lands = read_indigenous_land()
     """
-
-    metadata = select_metadata("indigenous_land", year=date, simplified=simplified)
-
-    gdf = download_gpkg(metadata)
-
+    
+    url = "https://geoserver.funai.gov.br/geoserver/Funai/ows?service=WFS&version=1.0.0&request=GetFeature&typeName=Funai%3Atis_poligonais&maxFeatures=10000&outputFormat=SHAPE-ZIP"
+    
+    try:
+        # Download the zip file with a 60-second timeout
+        response = requests.get(url, timeout=60)
+        if response.status_code != 200:
+            raise Exception(f"Failed to download data from FUNAI. Status code: {response.status_code}")
+            
+        # 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:
+                columns_to_keep = ['geometry', 'nome', 'municipio', 'uf', 'etnia', 'fase', 'area_ha']
+                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 indigenous land data: {str(e)}")
+        
     return gdf
+
+if __name__ == '__main__':
+    read_indigenous_land()

tunned_geobr/read_intermediate_region.py

@@ -1,61 +1,69 @@
-from geobr.utils import select_metadata, download_gpkg
+import geopandas as gpd
+import tempfile
+import os
+import requests
+from zipfile import ZipFile
+from io import BytesIO
 
-
-def read_intermediate_region(
-    code_intermadiate="all", year=2019, simplified=False, verbose=False
-):
-    r"""Download spatial data of Brazil's Intermediate Geographic Areas
-
-    The intermediate Geographic Areas are part of the geographic division of
-    Brazil created in 2017 by IBGE. These regions were created to replace the
-    "Meso Regions" division. Data at scale 1:250,000, using Geodetic reference
-    system "SIRGAS2000" and CRS(4674)
-
-       Parameters
-       ----------
-       code_intermadiate: str or int, by default "all"
-            4-digit code of an intermediate region. 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 intermediate regions of that
-            state. If `code_intermediate="all"` (Default), all intermediate regions of
-            the country are loaded.
-       year : int, optional
-           Year of the data, by default 2019
-       simplified: boolean, by default True
-           Data 'type', indicating whether the function returns the 'original' dataset
-           with high resolution or a dataset with 'simplified' borders (Default)
-       verbose : bool, optional
-           by default False
-
-       Returns
-       -------
-       gpd.GeoDataFrame
-           Metadata and geopackage of selected states
-
-       Raises
-       ------
-       Exception
-           If parameters are not found or not well defined
-
-       Example
-       -------
-       >>> from geobr import read_intermediate_region
-
-       # Read specific state at a given year
-       >>> df = read_intermediate_region(year=2019)
+def read_intermediate_region(simplified=False):
+    """Download official intermediate region data from IBGE.
+    
+    This function downloads and processes intermediate region data from IBGE (Brazilian Institute of Geography and Statistics).
+    The data includes intermediate regions of Brazil for the year 2023.
+    Original source: IBGE
+    
+    Parameters
+    ----------
+    simplified : boolean, by default False
+        If True, returns a simplified version of the dataset with fewer columns
+        
+    Returns
+    -------
+    gpd.GeoDataFrame
+        Geodataframe with intermediate region data
+        
+    Example
+    -------
+    >>> from geobr import read_intermediate_region
+    
+    # Read intermediate region data
+    >>> intermediate_region = read_intermediate_region()
     """
-
-    metadata = select_metadata("intermediate_regions", year=year, simplified=simplified)
-
-    gdf = download_gpkg(metadata)
-
-    if code_intermadiate == "all":
-        return gdf
-
-    for col in ["abbrev_state", "code_state", "code_intermediate"]:
-        if code_intermadiate in gdf[col].unique():
-            return gdf[gdf[col] == code_intermadiate]
-    else:
-        raise ValueError(
-            f"Invalid value to argumet `code_intermadiate`: {code_intermadiate}"
-        )
+    
+    url = "https://geoftp.ibge.gov.br/organizacao_do_territorio/malhas_territoriais/malhas_municipais/municipio_2023/Brasil/BR_RG_Intermediarias_2023.zip"
+    
+    try:
+        # Download the zip file
+        response = requests.get(url)
+        if response.status_code != 200:
+            raise Exception("Failed to download data from IBGE")
+            
+        # Create a temporary directory
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Extract zip content
+            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]))
+            
+            if simplified:
+                # Keep only the most relevant columns
+                # Note: These columns are based on typical intermediate region data structure
+                # You may want to adjust these based on the actual data
+                columns_to_keep = [
+                    'geometry',
+                    'CD_RGINT',  # Intermediate region code
+                    'NM_RGINT',  # Intermediate region name
+                ]
+                gdf = gdf[columns_to_keep]
+    
+    except Exception as e:
+        raise Exception(f"Error downloading intermediate region data: {str(e)}")
+        
+    return gdf

tunned_geobr/read_meso_region.py

@@ -1,78 +1,69 @@
-from geobr.utils import select_metadata, download_gpkg
-
-
-def read_meso_region(code_meso="all", year=2010, simplified=False, verbose=False):
-    """Download shape files of meso region as sf objects. Data at scale 1:250,000, using Geodetic reference system "SIRGAS2000" and CRS(4674)
-
-     Data at scale 1:250,000, using Geodetic reference system "SIRGAS2000" and CRS(4674)
-
+import geopandas as gpd
+import tempfile
+import os
+import requests
+from zipfile import ZipFile
+from io import BytesIO
+
+def read_meso_region(simplified=False):
+    """Download official mesoregion data from IBGE.
+    
+    This function downloads and processes mesoregion data from IBGE (Brazilian Institute of Geography and Statistics).
+    The data includes mesoregions of Brazil for the year 2022.
+    Original source: IBGE
+    
     Parameters
     ----------
-    code_meso: int or string, by default 'all'
-        The 4-digit code of a meso region. 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 meso regions of that state.
-        If code_meso="all", all meso regions of the country are loaded.
-    year : int, optional
-        Year of the data, by default 2010
-    simplified: boolean, by default True
-        Data 'type', indicating whether the function returns the 'original' dataset
-        with high resolution or a dataset with 'simplified' borders (Default)
-    verbose : bool, optional
-        by default False
-
+    simplified : boolean, by default False
+        If True, returns a simplified version of the dataset with fewer columns
+        
     Returns
     -------
     gpd.GeoDataFrame
-        Metadata and geopackage of selected states
-
-    Raises
-    ------
-    Exception
-        If parameters are not found or not well defined
-
+        Geodataframe with mesoregion data
+        
     Example
     -------
     >>> from geobr import read_meso_region
-
-    # Read specific meso region at a given year
-    >>> df = read_meso_region(code_meso=3301, year=2018)
-
-    # Read all meso regions of a state at a given year
-    >>> df = read_meso_region(code_meso=12, year=2017)
-    >>> df = read_meso_region(code_meso="AM", year=2000)
-
-    # Read all meso regions of the country at a given year
-    >>> df = read_meso_region(code_meso="all", year=2010)
+    
+    # Read mesoregion data
+    >>> meso_region = read_meso_region()
     """
-
-    metadata = select_metadata("meso_region", year=year, simplified=simplified)
-
-    if code_meso == "all":
-
-        if verbose:
-            print("Loading data for the whole country. This might take a few minutes.")
-
-        return download_gpkg(metadata)
-
-    metadata = metadata[
-        metadata[["code", "code_abbrev"]].apply(
-            lambda x: str(code_meso)[:2] in str(x["code"])
-            or str(code_meso)[:2]  # if number e.g. 12
-            in str(x["code_abbrev"]),  # if UF e.g. RO
-            1,
-        )
-    ]
-
-    if not len(metadata):
-        raise Exception("Invalid Value to argument code_meso.")
-
-    gdf = download_gpkg(metadata)
-
-    if len(str(code_meso)) == 2:
-        return gdf
-
-    elif code_meso in gdf["code_meso"].tolist():
-        return gdf.query(f"code_meso == {code_meso}")
-
-    else:
-        raise Exception("Invalid Value to argument code_meso.")
+    
+    url = "https://geoftp.ibge.gov.br/organizacao_do_territorio/malhas_territoriais/malhas_municipais/municipio_2022/Brasil/BR/BR_Mesorregioes_2022.zip"
+    
+    try:
+        # Download the zip file
+        response = requests.get(url)
+        if response.status_code != 200:
+            raise Exception("Failed to download data from IBGE")
+            
+        # Create a temporary directory
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Extract zip content
+            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]))
+            
+            if simplified:
+                # Keep only the most relevant columns
+                # Note: These columns are based on typical mesoregion data structure
+                # You may want to adjust these based on the actual data
+                columns_to_keep = [
+                    'geometry',
+                    'CD_MESO',  # Mesoregion code
+                    'NM_MESO',  # Mesoregion name
+                ]
+                gdf = gdf[columns_to_keep]
+    
+    except Exception as e:
+        raise Exception(f"Error downloading mesoregion data: {str(e)}")
+        
+    return gdf

tunned_geobr/read_micro_region.py

@@ -1,78 +1,69 @@
-from geobr.utils import select_metadata, download_gpkg
-
-
-def read_micro_region(code_micro="all", year=2010, simplified=False, verbose=False):
-    """Download shape files of micro region as sf objects
-
-     Data at scale 1:250,000, using Geodetic reference system "SIRGAS2000" and CRS(4674)
-
+import geopandas as gpd
+import tempfile
+import os
+import requests
+from zipfile import ZipFile
+from io import BytesIO
+
+def read_micro_region(simplified=False):
+    """Download official microregion data from IBGE.
+    
+    This function downloads and processes microregion data from IBGE (Brazilian Institute of Geography and Statistics).
+    The data includes microregions of Brazil for the year 2022.
+    Original source: IBGE
+    
     Parameters
     ----------
-    code_micro:
-        5-digit code of a micro region. 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 micro regions of that state.
-        If code_micro="all", all micro regions of the country are loaded.
-    year : int, optional
-        Year of the data, by default 2010
-    simplified: boolean, by default True
-        Data 'type', indicating whether the function returns the 'original' dataset
-        with high resolution or a dataset with 'simplified' borders (Default)
-    verbose : bool, optional
-        by default False
-
+    simplified : boolean, by default False
+        If True, returns a simplified version of the dataset with fewer columns
+        
     Returns
     -------
     gpd.GeoDataFrame
-        Metadata and geopackage of selected states
-
-    Raises
-    ------
-    Exception
-        If parameters are not found or not well defined
-
+        Geodataframe with microregion data
+        
     Example
     -------
     >>> from geobr import read_micro_region
-
-    # Read specific meso region at a given year
-    >>> df = read_micro_region(code_micro=11008, year=2018)
-
-    # Read all meso regions of a state at a given year
-    >>> df = read_micro_region(code_micro=12, year=2017)
-    >>> df = read_micro_region(code_micro="AM", year=2000)
-
-    # Read all meso regions of the country at a given year
-    >>> df = read_micro_region(code_micro="all", year=2010)
+    
+    # Read microregion data
+    >>> micro_region = read_micro_region()
     """
-
-    metadata = select_metadata("micro_region", year=year, simplified=simplified)
-
-    if code_micro == "all":
-
-        if verbose:
-            print("Loading data for the whole country. This might take a few minutes.")
-
-        return download_gpkg(metadata)
-
-    metadata = metadata[
-        metadata[["code", "code_abbrev"]].apply(
-            lambda x: str(code_micro)[:2] in str(x["code"])
-            or str(code_micro)[:2]  # if number e.g. 12
-            in str(x["code_abbrev"]),  # if UF e.g. RO
-            1,
-        )
-    ]
-
-    if not len(metadata):
-        raise Exception("Invalid Value to argument code_micro.")
-
-    gdf = download_gpkg(metadata)
-
-    if len(str(code_micro)) == 2:
-        return gdf
-
-    elif code_micro in gdf["code_micro"].tolist():
-        return gdf.query(f"code_micro == {code_micro}")
-
-    else:
-        raise Exception("Invalid Value to argument code_micro.")
+    
+    url = "https://geoftp.ibge.gov.br/organizacao_do_territorio/malhas_territoriais/malhas_municipais/municipio_2022/Brasil/BR/BR_Microrregioes_2022.zip"
+    
+    try:
+        # Download the zip file
+        response = requests.get(url)
+        if response.status_code != 200:
+            raise Exception("Failed to download data from IBGE")
+            
+        # Create a temporary directory
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Extract zip content
+            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]))
+            
+            if simplified:
+                # Keep only the most relevant columns
+                # Note: These columns are based on typical microregion data structure
+                # You may want to adjust these based on the actual data
+                columns_to_keep = [
+                    'geometry',
+                    'CD_MICRO',  # Microregion code
+                    'NM_MICRO',  # Microregion name
+                ]
+                gdf = gdf[columns_to_keep]
+    
+    except Exception as e:
+        raise Exception(f"Error downloading microregion data: {str(e)}")
+        
+    return gdf

tunned_geobr/read_neighborhood.py

@@ -1,39 +1,99 @@
-from geobr.utils import select_metadata, download_gpkg
+import geopandas as gpd
+import tempfile
+import os
+import requests
+import subprocess
+from io import BytesIO
 
-
-def read_neighborhood(year=2010, simplified=False, verbose=False):
-    """ Download neighborhood limits of Brazilian municipalities as a geopandas geodataframe object
+def read_neighborhood(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
     ----------
-    year : int, optional
-        Year of the data, by default 2010
-    simplified: boolean, by default True
-        Data 'type', indicating whether the function returns the 'original' dataset 
-        with high resolution or a dataset with 'simplified' borders (Default)
-    verbose : bool, optional
-        by default False
-    
+    simplified : boolean, by default False
+        If True, returns a simplified version of the dataset with fewer columns
+        
     Returns
     -------
     gpd.GeoDataFrame
-        Metadata and geopackage of selected states
-    
-    Raises
-    ------
-    Exception
-        If parameters are not found or not well defined
-
+        Geodataframe with Brazilian neighborhoods data
+        
     Example
     -------
-    >>> from geobr import read_neighborhood
-
-    # Read specific neighborhoods at a given year
-    >>> df = read_neighborhood(year=2010)
+    >>> from tunned_geobr import read_neighborhoods_2022
+    
+    # Read neighborhoods data
+    >>> neighborhoods = read_neighborhoods_2022()
     """
-
-    metadata = select_metadata("neighborhood", year=year, simplified=simplified)
-
-    gdf = download_gpkg(metadata)
-
+    
+    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_region.py

@@ -1,31 +1,69 @@
-from geobr import read_region as _read_region
+import geopandas as gpd
+import tempfile
+import os
+import requests
+from zipfile import ZipFile
+from io import BytesIO
 
-
-def read_region(year=2010, simplified=False, verbose=False):
-    """ Download shape file of Brazil Regions as sf objects.
+def read_region(simplified=False):
+    """Download official region data from IBGE.
+    
+    This function downloads and processes region data from IBGE (Brazilian Institute of Geography and Statistics).
+    The data includes regions of Brazil for the year 2022.
+    Original source: IBGE
     
-    Data at scale 1:250,000, using Geodetic reference system "SIRGAS2000" and CRS(4674)
-
     Parameters
     ----------
-    year : int, optional
-        Year of the data, by default 2010
-    simplified: boolean, by default True
-        Data 'type', indicating whether the function returns the 'original' dataset 
-        with high resolution or a dataset with 'simplified' borders (Default)
-    verbose : bool, optional
-        by default False
-    
+    simplified : boolean, by default False
+        If True, returns a simplified version of the dataset with fewer columns
+        
     Returns
     -------
     gpd.GeoDataFrame
-        Metadata and geopackage of selected states
-    
+        Geodataframe with region data
+        
     Example
     -------
-    >>> from tunned_geobr import read_region
-
-    # Read specific state at a given year
-    >>> df = read_region(year=2010)
+    >>> from geobr import read_region
+    
+    # Read region data
+    >>> region = read_region()
     """
-    return _read_region(year=year, simplified=simplified, verbose=verbose)
+    
+    url = "https://geoftp.ibge.gov.br/organizacao_do_territorio/malhas_territoriais/malhas_municipais/municipio_2022/Brasil/BR/BR_Regioes_2022.zip"
+    
+    try:
+        # Download the zip file
+        response = requests.get(url)
+        if response.status_code != 200:
+            raise Exception("Failed to download data from IBGE")
+            
+        # Create a temporary directory
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Extract zip content
+            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]))
+            
+            if simplified:
+                # Keep only the most relevant columns
+                # Note: These columns are based on typical region data structure
+                # You may want to adjust these based on the actual data
+                columns_to_keep = [
+                    'geometry',
+                    'CD_RG',  # Region code
+                    'NM_RG',  # Region name
+                ]
+                gdf = gdf[columns_to_keep]
+    
+    except Exception as e:
+        raise Exception(f"Error downloading region data: {str(e)}")
+        
+    return gdf

tunned_geobr/read_sigef_properties.py

@@ -32,8 +32,6 @@ def read_sigef_properties(simplified=False):
     """
     
     url = "https://certificacao.incra.gov.br/csv_shp/zip/Sigef%20Brasil.zip"
-    if 1==1:
-        return "Essa camada está muito pesada, baixe manualmente no link: " + url
     try:
         # Download the zip file
         # Disable SSL verification due to INCRA's certificate issues

{tunned_geobr-1.0.0.dist-info → tunned_geobr-1.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tunned-geobr
-Version: 1.0.0
+Version: 1.0.2
 Summary: Fork personalizado do geobr com funcionalidades extras como download de dados da ANM
 Author: Anderson Stolfi
 License: MIT
@@ -23,6 +23,8 @@ Requires-Dist: patool>=1.15.0
 Requires-Dist: fiona>=1.10.1
 Requires-Dist: gdown>=5.2.0
 Requires-Dist: tabulate>=0.9.0
+Requires-Dist: build>=1.2.2.post1
+Requires-Dist: twine>=6.1.0
 Description-Content-Type: text/markdown
 
 # geobr: Download Official Spatial Data Sets of Brazil 

{tunned_geobr-1.0.0.dist-info → tunned_geobr-1.0.2.dist-info}/RECORD

@@ -1,8 +1,8 @@
-tunned_geobr-1.0.0.dist-info/METADATA,sha256=4vI9Jp2a5SZS9G4UG-9bOrPPwbxrUx-OLvueEql-c9s,5018
-tunned_geobr-1.0.0.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
-tunned_geobr-1.0.0.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
-tunned_geobr-1.0.0.dist-info/licenses/LICENSE.txt,sha256=mECZRcbde3HssOKe1Co4zgqBLGVN0OWpTsEy3LIbcRA,75
-tunned_geobr/__init__.py,sha256=RP_fInq17ZOJxZOIVtkWeYDBUIr2lR4QbbHbvMqr5K4,7454
+tunned_geobr-1.0.2.dist-info/METADATA,sha256=mmz2jbljwyJeyc1qcdGLzi4bHmmeuUMwzOI_GLugK5Q,5080
+tunned_geobr-1.0.2.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
+tunned_geobr-1.0.2.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+tunned_geobr-1.0.2.dist-info/licenses/LICENSE.txt,sha256=mECZRcbde3HssOKe1Co4zgqBLGVN0OWpTsEy3LIbcRA,75
+tunned_geobr/__init__.py,sha256=rxOGWhc2o3F8qDORi34uF4sCGouQFK74bKpuuAXWlHY,7393
 tunned_geobr/data/grid_state_correspondence_table.csv,sha256=FpkBuX_-lRXQ1yBrQODxQgG9oha9Fd8A8zGKfdsDAmk,2660
 tunned_geobr/list_geobr.py,sha256=6rsdtSZUvFrS-n5KXLOSQ34P1AK_yMFAj_MVZRvvZmQ,17278
 tunned_geobr/lookup_muni.py,sha256=ny1zU4i6OagvL4Mrc6XQWPgn2RrJa_mXlKXh81oVYsM,3462
@@ -65,13 +65,13 @@ tunned_geobr/read_hydroelectric_inventory_aai_studies.py,sha256=GWnSzsnMJSDjSpXF
 tunned_geobr/read_ibama_embargoes.py,sha256=hzbWiifgoCgq7TP4X3H4TWFFkLnE5Y9969KUd3aJsek,3251
 tunned_geobr/read_icmbio_embargoes.py,sha256=Xn3oxt4yK8wE6sAKWsU91EyU2h0yLysIbtQk2VUuJ5A,3107
 tunned_geobr/read_icmbio_infractions.py,sha256=Heolqhuxc3sUby4RhxJZ88djIBWRcXkFbubhXgkpYos,3182
-tunned_geobr/read_immediate_region.py,sha256=K-i5UBdxB1ZQw2R8fGMp1GqX5sXJwUkjVHqC84QtJtc,2555
-tunned_geobr/read_indigenous_land.py,sha256=ZyHcJ93cDNjUcc5CyBKiWHjlrt9owDv993IFKUlEPZ4,1460
-tunned_geobr/read_intermediate_region.py,sha256=PipeQFGVpZf6a_J7OrttPOnE7o6E5IJHJXLKvzYjoEY,2186
+tunned_geobr/read_immediate_region.py,sha256=rxPfNYTvYM1n09KNJ1QkdLdXukvO6gZ4wU9IZP-Mum0,2465
+tunned_geobr/read_indigenous_land.py,sha256=0QmsWQjq1RNS6GqF_vfPzTibBv09Qrxw-Mgg0GE9yzA,2839
+tunned_geobr/read_intermediate_region.py,sha256=b-Txa79C5MIcQDUwudAorah4QFARM277-bhAgcQ7jOo,2513
 tunned_geobr/read_isolated_systems.py,sha256=k0dxfUNubsJXV3_5ph1CWghR_Mfpn4oe_4zLkg7c5Cs,5343
-tunned_geobr/read_meso_region.py,sha256=UacQUroAZWcfhq2Piby-FDVTDmEVeLEQCvcLcc1w7rY,2602
+tunned_geobr/read_meso_region.py,sha256=siwlqiZ9Q8XMmrEf4YjS6TJiQW0fsTq0udi2oByIiL0,2396
 tunned_geobr/read_metro_area.py,sha256=e18jyXrRMwQTv_ZO2hGoyC8qZsV6NlYfWXsu6DusRQM,1498
-tunned_geobr/read_micro_region.py,sha256=61KbztQWYw-QPFLJOoxNWX32bHBKLb2pnunzSFo3S_0,2510
+tunned_geobr/read_micro_region.py,sha256=hs1NhVfb_LazLLp9EmLxQCDscPlkqqG-OjTv2fIGoFw,2412
 tunned_geobr/read_mining_processes.py,sha256=UmywViEDD9hx7qcDj9CMRHdPM69NQhsRB4870Y77QSs,2569
 tunned_geobr/read_municipal_seat.py,sha256=9Vi-q1jzY8n086O-nNY1sVkVzV_NZbdzE5juosCcVZI,1142
 tunned_geobr/read_municipality.py,sha256=dZM1BVi3U9ZvasLADV-ciKVr9R4o92dRowpEVdVkvYw,5651
@@ -79,8 +79,7 @@ tunned_geobr/read_municipality_direct.py,sha256=VrZR_5__DsV5IbbX-sr56WT-P4M_tVdn
 tunned_geobr/read_natural_caves.py,sha256=-XjoRxhT_yYy0fZu87S6RRUZ-cyaWPqWqOrd9Y8ERKo,3073
 tunned_geobr/read_natural_gas_delivery_points.py,sha256=nJJmqbJJ5Xx2P2wVL9yXdGLuPI0O8pCCL9zDkHQtZOs,5387
 tunned_geobr/read_natural_gas_processing_hub.py,sha256=qI5o-4TmPfi3h0gYNWjeMR5GsRAq-fsXoB62llqt9RA,5367
-tunned_geobr/read_neighborhood.py,sha256=2QWMz-TVkTJmbVQ_aKNyh2NNJ6KIJqnrPL1CrB9Oqdw,1085
-tunned_geobr/read_neighborhoods_2022.py,sha256=EX1-5CM3tNe05HE1F5r3YtZ-66X_NC67u_DzrmzKvTc,3952
+tunned_geobr/read_neighborhood.py,sha256=xM2Ztl2uvaQ4fLmO9lCboa-lqGoUNlo_OM_ktVqlOn0,3946
 tunned_geobr/read_og_basement.py,sha256=nwUOn-BMYC3mvvP9uTBLYly00drIw6CwU5lHJeOdi-Y,4617
 tunned_geobr/read_og_effective_geographic_basin.py,sha256=Qvy--_A8oGrL-Os3mfofr14MA0qWv3s5FFdtIabBJ8E,5457
 tunned_geobr/read_og_ipa_direct_evidence.py,sha256=N5nDr7AinKFqhcfgnvygVjzpdN2D1TP5VSILS8gkIgU,4738
@@ -117,13 +116,13 @@ tunned_geobr/read_processing_facilities.py,sha256=8iCveDTk7MXm1bmb1pcknzen62HTGY
 tunned_geobr/read_public_aerodromes.py,sha256=nq3b9HF5_e-yeNcSfQ5ktdAGHKbSfDD_imj-tOhjKJA,2909
 tunned_geobr/read_quilombola_areas.py,sha256=iY-r4YDRjaGyO-iPRBm1kWDkN_-axjYxMAQyAjIfG68,4288
 tunned_geobr/read_railways.py,sha256=J6eM0yr049CaOL95PMd4sGc7JJHiEinJhqf0ThCOClg,2763
-tunned_geobr/read_region.py,sha256=kfwjoMj-klayqSty_mUNILIQA8RYgNuB86y_0raDApQ,956
+tunned_geobr/read_region.py,sha256=X7IwsAVxwUl0apsExSuBr9kIK_7IUehPenLXAF-JFDA,2331
 tunned_geobr/read_rppn.py,sha256=nXDzclIiqhutkYWvxlIH_mYSNGdfRVSUzSzi-15X-3w,3963
 tunned_geobr/read_schools.py,sha256=kxaRwuKmZDPgSuhCUd_Ltxo-6_z3b3jXY9Qo0MY_b-A,1364
 tunned_geobr/read_sedimentary_basins.py,sha256=mpCde4-WRdAAuHF-AwrODd0GpxRhzJOuP60U6Zbl9pE,4583
 tunned_geobr/read_semiarid.py,sha256=pxxYTWq8_UPUyblA7_FXXXRz-XOCrrebCvYQ-kgDSrU,1358
 tunned_geobr/read_settlements.py,sha256=C47Wj4DhSDa-pSFfYK4uGDwtu4sUwqPMr-CuuxS95xg,3060
-tunned_geobr/read_sigef_properties.py,sha256=LZ69L6ev-7JT0chINKcgHZKl1ZpH6iLk6Je_HAxDnsQ,3204
+tunned_geobr/read_sigef_properties.py,sha256=EBqTUbL9Kg9EUPh--nYHX2OVacymq80YrPCZXKAP6sQ,3108
 tunned_geobr/read_snci_properties.py,sha256=lKhRSBeayD3M_ffljSf5_Sn57VhYh0g3lwFnOgpYji0,3226
 tunned_geobr/read_state.py,sha256=JgV3cR0LFbmwIzuzPbR_Zfy1bR_2eBeEPxunozctuag,3819
 tunned_geobr/read_state_direct.py,sha256=8Tdz-gVH_t90BJngcfcpr0VLs5HfCUxRgRQj8hy4Bt0,3826
@@ -138,4 +137,4 @@ tunned_geobr/read_water_bodies_ana.py,sha256=Z-dpTPVgRHVndTeSFxx8uXn7ufMg2jm0Dlz
 tunned_geobr/read_waterways.py,sha256=mEdoVogYWr5EYZ8bE3xMCVWyLrHYU7xTL2lUE0XbDAM,2951
 tunned_geobr/read_weighting_area.py,sha256=m2X5Ua3jRqLlkqCQbIzR2jmo58pzqkyR3UYcGtgy20E,2325
 tunned_geobr/utils.py,sha256=WT9PSGWvcERjj3yhfTvyWSE5ZiEjO4tYK5xIj5jJCg8,8170
-tunned_geobr-1.0.0.dist-info/RECORD,,
+tunned_geobr-1.0.2.dist-info/RECORD,,

{tunned_geobr-1.0.0.dist-info → tunned_geobr-1.0.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: pdm-backend (2.4.3)
+Generator: pdm-backend (2.4.4)
 Root-Is-Purelib: true
 Tag: py3-none-any

tunned_geobr/read_neighborhoods_2022.py

@@ -1,99 +0,0 @@
-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()