tunned-geobr 0.2.10__py3-none-any.whl → 1.0.1__py3-none-any.whl

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-0.2.10.dist-info → tunned_geobr-1.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tunned-geobr
-Version: 0.2.10
+Version: 1.0.1
 Summary: Fork personalizado do geobr com funcionalidades extras como download de dados da ANM
 Author: Anderson Stolfi
 License: MIT