bb_api 0.3.0__tar.gz → 0.4.0__tar.gz

{bb_api-0.3.0 → bb_api-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bb_api
-Version: 0.3.0
+Version: 0.4.0
 Summary: Wrapper da API do Banco do Brasil.
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown

{bb_api-0.3.0 → bb_api-0.4.0}/bb_api/__init__.py

@@ -4,11 +4,12 @@ from importlib.metadata import version
 try:
     __version__ = version("bb_api")
 except:
-    __version__ = "0.3.0"
+    __version__ = "0.4.0"
 
 
 from .common import Ambiente
 from .accountability import AccountabilityV3RepasseAPI, AccountabilityV3ControleAPI
+from .sia import BBSiaAPI
 from .gestao_agil import (
     parse_retorno_abertura_massificada,
     ler_retorno_abertura_massificada,
@@ -18,6 +19,7 @@ __all__ = [
     "Ambiente",
     "AccountabilityV3RepasseAPI",
     "AccountabilityV3ControleAPI",
+    "BBSiaAPI",
     "parse_retorno_abertura_massificada",
     "ler_retorno_abertura_massificada",
 ]

{bb_api-0.3.0 → bb_api-0.4.0}/bb_api/common.py

@@ -16,6 +16,10 @@ homo_api_domain = "https://api.hm.bb.com.br"
 homo_alt_api_domain = "https://api.sandbox.bb.com.br"
 prod_api_domain = "https://api.bb.com.br"
 
+dese_sia_domain = "https://gmtedi.desenv.bb.com.br"
+homo_sia_domain = "https://gmtedi.hm.bb.com.br"
+prod_sia_domain = "https://gmtedi.bb.com.br"
+
 time_between_access_token_requests = timedelta(minutes=10)
 
 
@@ -30,6 +34,27 @@ class Ambiente(Enum):
     PRODUCAO = 3
 
 
+_sia_domains = {
+    Ambiente.DESENVOLVIMENTO: dese_sia_domain,
+    Ambiente.HOMOLOGACAO: homo_sia_domain,
+    Ambiente.PRODUCAO: prod_sia_domain,
+}
+
+
+def sia_domain_for(ambiente: Ambiente) -> str:
+    """Devolve o domínio do BB Sia (GMT-EDI) correspondente ao ``ambiente``.
+
+    Lança ``ValueError`` para ambientes que o BB Sia não atende (como o
+    ``HOMOLOGACAO_ALTERNATIVO``).
+    """
+    domain = _sia_domains.get(ambiente)
+    if domain is None:
+        raise ValueError(
+            f"O ambiente '{ambiente.name}' não é suportado pela API BB Sia."
+        )
+    return domain
+
+
 def get_headers(access_token: str) -> dict[str, str]:
     return {
         "Authorization": f"Bearer {access_token}",

bb_api-0.4.0/bb_api/sia.py

@@ -0,0 +1,575 @@
+"""Encapsulador da API BB Sia (Gestão Ágil) do Banco do Brasil.
+
+O BB Sia é acessado pelo domínio do GMT-EDI (``gmtedi.bb.com.br`` em produção) e
+expõe, entre outros, os seguintes grupos de endpoints:
+
+* ``gmt-autorizador-api`` -- autorização (usuário/senha e refresh token) e
+  revogação de tokens;
+* ``gmt-catalogo-api`` -- catálogo dos uploads possíveis;
+* ``gmt-sia-api`` -- envio (upload) e recebimento (download) de arquivos, além
+  da consulta de downloads e dos seus metadados;
+* ``gmt-protocolo-api`` -- consulta de protocolos.
+
+Diferente da API ``Accountability``, a autorização do BB Sia não usa o fluxo
+``client_credentials`` do ``oauth.bb.com.br``: ela usa o *grant* ``password``
+(usuário e senha) ou ``refresh_token`` contra o próprio GMT-EDI, devolvendo um
+``access_token`` e um ``refresh_token``.
+
+.. note::
+    Os nomes das listas e colunas devolvidas pelos endpoints de consulta
+    (``listaUploads``, ``listaDownloads``, ``listaProtocolos`` e metadados) são
+    inferidos a partir da semântica de cada endpoint, pois não há um leiaute de
+    resposta publicado na coleção de referência. Por isso esses métodos não
+    renomeiam as colunas: ajuste o tratamento conforme a resposta real da API.
+"""
+
+import os
+import base64
+import hashlib
+import datetime
+from collections.abc import Mapping, Sequence
+from typing import cast
+
+import pandas as pd
+import requests
+
+import bb_api.common as common
+
+
+def _to_dataframe(
+    res: object,
+    main_list: str | None = None,
+    rename_dict: Mapping[str, str] | None = None,
+) -> pd.DataFrame:
+    """Constrói um ``DataFrame`` a partir de uma resposta de esquema desconhecido.
+
+    Usa ``main_list`` quando essa chave existe e aponta para uma lista; caso
+    contrário, usa a primeira lista encontrada na resposta e, se não houver
+    nenhuma, trata a resposta inteira como um único registro. Assim os endpoints
+    de consulta do BB Sia não quebram mesmo sem um leiaute de resposta conhecido.
+    """
+    record = cast("Mapping[str, object]", res)
+
+    if main_list is not None and isinstance(record.get(main_list), list):
+        return common.handle_results(res, main_list=main_list, rename_dict=rename_dict)
+
+    for key, value in record.items():
+        if isinstance(value, list):
+            return common.handle_results(res, main_list=key, rename_dict=rename_dict)
+
+    return common.handle_results(res, rename_dict=rename_dict)
+
+
+def _content_md5(conteudo: bytes) -> str:
+    """Calcula o cabeçalho ``Content-MD5`` (digest MD5 em base64, RFC 1864).
+
+    Usa ``usedforsecurity=False`` porque o MD5 aqui é de integridade, não
+    criptográfico -- isso também evita ``ValueError`` em builds FIPS do Python.
+    """
+    digest = hashlib.md5(conteudo, usedforsecurity=False).digest()
+    return base64.b64encode(digest).decode("utf-8")
+
+
+def _to_iso_z(value: common.DateLike, *, fim_do_dia: bool = False) -> str:
+    """Formata uma data no padrão ISO-8601 com milissegundos e sufixo ``Z``.
+
+    Strings são repassadas sem alteração (o chamador controla o formato exato).
+    Para ``date``/``datetime`` sem hora, usa ``00:00:00`` ou ``23:59:59`` (quando
+    ``fim_do_dia``), como nos exemplos de ``dtCriacaoMin``/``dtCriacaoMax``.
+    """
+    if isinstance(value, str):
+        return value
+
+    if isinstance(value, datetime.datetime):
+        dt = value
+    elif fim_do_dia:
+        dt = datetime.datetime.combine(value, datetime.time(23, 59, 59))
+    else:
+        dt = datetime.datetime.combine(value, datetime.time())
+
+    return dt.strftime("%Y-%m-%dT%H:%M:%S.000Z")
+
+
+class BBSiaAPI:
+    """Encapsulador da API BB Sia (Gestão Ágil) do Banco do Brasil.
+
+    O token de acesso é gerenciado automaticamente: a instância reaproveita o
+    token por 10 minutos e gera um novo quando necessário, preferindo o
+    ``refresh_token`` e caindo para usuário/senha quando ele não está disponível
+    ou expirou.
+    """
+
+    _scope: str
+    _sia_domain: str
+    _access_token: str
+    _username: str | None
+    _password: str | None
+    _refresh_token: str | None
+    _ambiente: common.Ambiente
+    _last_access_token_request_timestamp: datetime.datetime | None
+
+    def __init__(
+        self,
+        ambiente: common.Ambiente = common.Ambiente.HOMOLOGACAO,
+        username: str | None = None,
+        password: str | None = None,
+        refresh_token: str | None = None,
+        scope: str = "sia:usuario",
+    ):
+        """Inicia uma instância do encapsulador da API BB Sia do Banco do Brasil.
+
+        Parâmetros
+        ----------
+        ambiente: common.Ambiente
+            Ambiente de execução. O BB Sia não possui ambiente alternativo
+            (sandbox).
+        username: str | None
+            Nome de usuário para o *grant* ``password``. Lido da variável de
+            ambiente ``BBS_USERNAME`` quando não informado.
+        password: str | None
+            Senha para o *grant* ``password``. Lida da variável de ambiente
+            ``BBS_PASSWORD`` quando não informada.
+        refresh_token: str | None
+            Refresh token para o *grant* ``refresh_token``. Lido da variável de
+            ambiente ``BBS_REFRESH_TOKEN`` quando não informado.
+        scope: str
+            Escopo solicitado no *grant* ``password`` (padrão ``sia:usuario``).
+
+        É obrigatório fornecer um ``refresh_token`` ou o par usuário/senha.
+        """
+        self._ambiente = ambiente
+        self._sia_domain = common.sia_domain_for(ambiente)
+        self._scope = scope
+
+        self._username = username if username is not None else os.getenv("BBS_USERNAME")
+        self._password = password if password is not None else os.getenv("BBS_PASSWORD")
+        self._refresh_token = (
+            refresh_token if refresh_token is not None else os.getenv("BBS_REFRESH_TOKEN")
+        )
+
+        if not self._refresh_token and not (self._username and self._password):
+            raise ValueError(
+                "Credenciais inválidas para o BB Sia. Forneça um 'refresh_token'"
+                + " (ou a variável de ambiente 'BBS_REFRESH_TOKEN') ou o par"
+                + " usuário/senha (parâmetros 'username'/'password' ou as"
+                + " variáveis de ambiente 'BBS_USERNAME'/'BBS_PASSWORD')."
+            )
+
+        self._access_token = ""
+        self._last_access_token_request_timestamp = None
+
+    def _store_access_token(self, data: dict[str, object]) -> dict[str, object]:
+        access_token = data.get("access_token")
+        if not access_token:
+            raise Exception("A resposta de autorização do BB Sia não trouxe um 'access_token'.")
+
+        self._access_token = cast("str", access_token)
+        self._last_access_token_request_timestamp = datetime.datetime.now()
+        return data
+
+    def _password_grant(self) -> dict[str, object]:
+        if not (self._username and self._password):
+            raise ValueError(
+                "Usuário e senha são necessários para o grant 'password' do BB Sia."
+            )
+
+        res = requests.request(
+            "POST",
+            f"{self._sia_domain}/gmt-autorizador-api/autoriza",
+            headers={"Content-Type": "application/x-www-form-urlencoded"},
+            data={
+                "grant_type": "password",
+                "username": self._username,
+                "password": self._password,
+                "scope": self._scope,
+            },
+        )
+
+        if res.status_code != 200:
+            raise Exception("Não foi possível autorizar o acesso ao BB Sia com usuário e senha.")
+
+        data = common.parse_json_object(res)
+        refresh_token = data.get("refresh_token")
+        if refresh_token:
+            self._refresh_token = cast("str", refresh_token)
+
+        return self._store_access_token(data)
+
+    def _refresh_grant(
+        self,
+        validade_refresh_token: int | None = None,
+    ) -> dict[str, object]:
+        if not self._refresh_token:
+            raise ValueError("Nenhum refresh token disponível para renovar o acesso ao BB Sia.")
+
+        data = {
+            "grant_type": "refresh_token",
+            "refresh_token": self._refresh_token,
+        }
+        if validade_refresh_token is not None:
+            data["validade_refresh_token"] = str(validade_refresh_token)
+
+        res = requests.request(
+            "POST",
+            f"{self._sia_domain}/gmt-autorizador-api/autoriza",
+            headers={"Content-Type": "application/x-www-form-urlencoded"},
+            data=data,
+        )
+
+        if res.status_code != 200:
+            raise Exception("Não foi possível renovar o token de acesso ao BB Sia.")
+
+        return self._store_access_token(common.parse_json_object(res))
+
+    def _check_and_update_access_token(self) -> None:
+        now = datetime.datetime.now()
+        last_request = self._last_access_token_request_timestamp
+
+        is_token_valid = (
+            self._access_token != ""
+            and last_request is not None
+            and now - last_request <= common.time_between_access_token_requests
+        )
+        if is_token_valid:
+            return
+
+        if self._refresh_token:
+            try:
+                self._refresh_grant()
+                return
+            except Exception:
+                if not (self._username and self._password):
+                    raise
+
+        self._password_grant()
+
+    def _get_access_token(self) -> str:
+        self._check_and_update_access_token()
+        return self._access_token
+
+    def autorizar_novo_token(self) -> dict[str, object]:
+        """Solicita um novo token via *grant* ``password`` (usuário e senha).
+
+        Atualiza o token de acesso e o refresh token da instância e devolve a
+        resposta crua da API (com ``access_token``, ``refresh_token`` etc.).
+        """
+        return self._password_grant()
+
+    def renovar_token(
+        self,
+        validade_refresh_token: int | None = None,
+    ) -> dict[str, object]:
+        """Obtém um novo **token de acesso** a partir do refresh token.
+
+        Usa o *grant* ``refresh_token``. O refresh token em si não é renovado
+        nem substituído por esta chamada -- apenas um novo ``access_token`` é
+        devolvido (e passa a ser usado pela instância).
+
+        Parâmetros
+        ----------
+        validade_refresh_token: int | None
+            Validade, em dias, do refresh token atual. ``0`` deixa o refresh
+            token com validade indefinida. Quando ``None``, o parâmetro não é
+            enviado e vale o padrão do Banco do Brasil (1 dia).
+        """
+        return self._refresh_grant(validade_refresh_token)
+
+    def revogar_token(self, token: str, token_type_hint: str) -> None:
+        """Revoga um token de acesso ou de refresh.
+
+        Parâmetros
+        ----------
+        token: str
+            Valor do token a ser revogado.
+        token_type_hint: str
+            ``"access_token"`` ou ``"refresh_token"``.
+        """
+        res = requests.request(
+            "POST",
+            f"{self._sia_domain}/gmt-autorizador-api/revogar",
+            headers={"Content-Type": "application/x-www-form-urlencoded"},
+            data={
+                "token": token,
+                "token_type_hint": token_type_hint,
+            },
+        )
+
+        if res.status_code not in (200, 204):
+            raise Exception("Não foi possível revogar o token do BB Sia.")
+
+    def listar_uploads_possiveis(self) -> pd.DataFrame:
+        """Lista os uploads (FTAs) que o usuário pode enviar.
+
+        Endpoint ``GET /gmt-catalogo-api/listaUploads/``.
+        """
+        access_token = self._get_access_token()
+
+        res = requests.request(
+            "GET",
+            f"{self._sia_domain}/gmt-catalogo-api/listaUploads/",
+            headers=common.get_headers(access_token),
+        )
+
+        if res.status_code != 200:
+            raise Exception("Não foi possível listar os uploads possíveis no BB Sia.")
+
+        return _to_dataframe(common.parse_json_object(res))
+
+    def listar_downloads(self) -> pd.DataFrame:
+        """Lista os arquivos disponíveis para download.
+
+        Endpoint ``GET /gmt-sia-api/listaDownloads``.
+        """
+        access_token = self._get_access_token()
+
+        res = requests.request(
+            "GET",
+            f"{self._sia_domain}/gmt-sia-api/listaDownloads",
+            headers=common.get_headers(access_token),
+        )
+
+        if res.status_code != 200:
+            raise Exception("Não foi possível listar os downloads do BB Sia.")
+
+        return _to_dataframe(common.parse_json_object(res))
+
+    def consultar_metadados(
+        self,
+        id_arquivo: int | str,
+        nome_arquivo: str,
+    ) -> pd.DataFrame:
+        """Consulta os metadados de um arquivo disponível para download.
+
+        Endpoint ``GET /gmt-sia-api/listaDownloads/{id_arquivo}/{nome_arquivo}``.
+
+        Parâmetros
+        ----------
+        id_arquivo: int | str
+            Identificador do arquivo, como consta ao consultar os downloads.
+        nome_arquivo: str
+            Nome do arquivo, como consta ao consultar os downloads.
+        """
+        access_token = self._get_access_token()
+
+        res = requests.request(
+            "GET",
+            f"{self._sia_domain}/gmt-sia-api/listaDownloads/{id_arquivo}/{nome_arquivo}",
+            headers=common.get_headers(access_token),
+        )
+
+        if res.status_code != 200:
+            raise Exception("Não foi possível consultar os metadados do arquivo no BB Sia.")
+
+        return _to_dataframe(common.parse_json_object(res))
+
+    def baixar_arquivo(
+        self,
+        id_arquivo: int | str,
+        nome_arquivo: str,
+        caminho: str | os.PathLike[str] | None = None,
+    ) -> bytes:
+        """Baixa o conteúdo de um arquivo do BB Sia.
+
+        Endpoint ``GET /gmt-sia-api/download/{id_arquivo}/{nome_arquivo}``.
+
+        Parâmetros
+        ----------
+        id_arquivo: int | str
+            Identificador do arquivo, como consta ao consultar os downloads.
+        nome_arquivo: str
+            Nome do arquivo, como consta ao consultar os downloads.
+        caminho: str | os.PathLike | None
+            Quando informado, o conteúdo também é gravado nesse caminho.
+
+        Devolve o conteúdo do arquivo em ``bytes``.
+        """
+        access_token = self._get_access_token()
+
+        res = requests.request(
+            "GET",
+            f"{self._sia_domain}/gmt-sia-api/download/{id_arquivo}/{nome_arquivo}",
+            headers=common.get_headers(access_token),
+        )
+
+        if res.status_code != 200:
+            raise Exception("Não foi possível baixar o arquivo do BB Sia.")
+
+        if caminho is not None:
+            with open(caminho, "wb") as arquivo:
+                arquivo.write(res.content)
+
+        return res.content
+
+    def pre_upload(
+        self,
+        fta: int | str,
+        nome_arquivo: str,
+        conteudo: bytes,
+        evento: int | str = 1,
+        content_md5: str | None = None,
+    ) -> requests.Response:
+        """Negocia (HEAD) o envio de um arquivo antes do upload.
+
+        Endpoint ``HEAD /gmt-sia-api/upload/{fta}/{evento}/{nome_arquivo}``.
+
+        Não levanta exceção em respostas não-2xx nem segue redirecionamentos
+        automaticamente: o ``status_code`` e os cabeçalhos da resposta fazem
+        parte da negociação (por exemplo, para retomar um envio). Inspecione a
+        ``requests.Response`` devolvida.
+
+        Parâmetros
+        ----------
+        fta: int | str
+            Número do FTA para o qual o arquivo será enviado.
+        nome_arquivo: str
+            Nome do arquivo a ser enviado.
+        conteudo: bytes
+            Conteúdo do arquivo, usado para calcular MD5 e tamanho.
+        evento: int | str
+            Etapa de recepção (por padrão, ``1``).
+        content_md5: str | None
+            Sobrescreve o ``Content-MD5`` calculado (digest MD5 em base64).
+        """
+        access_token = self._get_access_token()
+        md5 = content_md5 if content_md5 is not None else _content_md5(conteudo)
+
+        return requests.request(
+            "HEAD",
+            f"{self._sia_domain}/gmt-sia-api/upload/{fta}/{evento}/{nome_arquivo}",
+            headers={
+                **common.get_headers(access_token),
+                "Content-MD5": md5,
+                "x-gmt-content-length": str(len(conteudo)),
+            },
+            allow_redirects=False,
+        )
+
+    def upload(
+        self,
+        fta: int | str,
+        nome_arquivo: str,
+        conteudo: bytes,
+        evento: int | str = 1,
+        byte_inicial: int = 0,
+        byte_final: int | None = None,
+        total_bytes: int | None = None,
+        content_md5: str | None = None,
+    ) -> requests.Response:
+        """Envia (PUT) um arquivo, ou um trecho dele, para o BB Sia.
+
+        Endpoint ``PUT /gmt-sia-api/upload/{fta}/{evento}/{nome_arquivo}``.
+
+        Levanta exceção apenas em respostas de erro (``status_code >= 400``).
+        Redirecionamentos não são seguidos automaticamente: respostas de
+        continuação (como ``308``) são devolvidas para o chamador decidir, o
+        que permite envios fracionados.
+
+        Parâmetros
+        ----------
+        fta: int | str
+            Número do FTA para o qual o arquivo será enviado.
+        nome_arquivo: str
+            Nome do arquivo a ser enviado.
+        conteudo: bytes
+            Bytes a serem enviados nesta requisição (o arquivo todo ou um trecho).
+        evento: int | str
+            Etapa de recepção (por padrão, ``1``).
+        byte_inicial: int
+            Primeiro byte deste trecho, para o cabeçalho ``Content-Range``.
+        byte_final: int | None
+            Último byte deste trecho. Quando ``None``, assume o último byte de
+            ``conteudo`` (``byte_inicial + len(conteudo) - 1``).
+        total_bytes: int | None
+            Tamanho total do arquivo. Quando ``None``, assume ``len(conteudo)``.
+        content_md5: str | None
+            Sobrescreve o ``Content-MD5`` calculado (digest MD5 em base64).
+        """
+        access_token = self._get_access_token()
+        md5 = content_md5 if content_md5 is not None else _content_md5(conteudo)
+
+        total = total_bytes if total_bytes is not None else len(conteudo)
+        fim = byte_final if byte_final is not None else byte_inicial + len(conteudo) - 1
+
+        res = requests.request(
+            "PUT",
+            f"{self._sia_domain}/gmt-sia-api/upload/{fta}/{evento}/{nome_arquivo}",
+            headers={
+                "Content-Type": "application/octet-stream",
+                **common.get_headers(access_token),
+                "Content-MD5": md5,
+                "Content-Length": str(len(conteudo)),
+                "Content-Range": f"bytes {byte_inicial}-{fim}/{total}",
+            },
+            data=conteudo,
+            allow_redirects=False,
+        )
+
+        if res.status_code >= 400:
+            raise Exception("Não foi possível enviar o arquivo para o BB Sia.")
+
+        return res
+
+    def listar_protocolos(
+        self,
+        pagina: int = 1,
+        por_pagina: int = 20,
+        protocolo: Sequence[int] | None = None,
+        cod_fta: Sequence[int] | None = None,
+        cod_estado_protocolo: Sequence[int] | None = None,
+        dt_criacao_min: common.DateLike | None = None,
+        dt_criacao_max: common.DateLike | None = None,
+    ) -> pd.DataFrame:
+        """Consulta protocolos no BB Sia.
+
+        Endpoint ``POST /gmt-protocolo-api/listaProtocolos``. Apenas os filtros
+        informados (diferentes de ``None``) são enviados no corpo da requisição.
+
+        Parâmetros
+        ----------
+        pagina: int
+            Página da consulta (``metadata.pagina``).
+        por_pagina: int
+            Quantidade de itens por página (``metadata.porPagina``).
+        protocolo: Sequence[int] | None
+            Números de protocolo a filtrar.
+        cod_fta: Sequence[int] | None
+            Códigos de FTA a filtrar.
+        cod_estado_protocolo: Sequence[int] | None
+            Códigos de estado do protocolo a filtrar.
+        dt_criacao_min: common.DateLike | None
+            Data de criação mínima. ``date``/``datetime`` viram o início do dia
+            em ISO-8601 com sufixo ``Z``; ``str`` é repassada como veio.
+        dt_criacao_max: common.DateLike | None
+            Data de criação máxima. ``date``/``datetime`` viram o fim do dia em
+            ISO-8601 com sufixo ``Z``; ``str`` é repassada como veio.
+        """
+        access_token = self._get_access_token()
+
+        body: dict[str, object] = {
+            "metadata": {
+                "pagina": pagina,
+                "porPagina": por_pagina,
+            },
+        }
+        if protocolo is not None:
+            body["protocolo"] = list(protocolo)
+        if cod_fta is not None:
+            body["codFta"] = list(cod_fta)
+        if cod_estado_protocolo is not None:
+            body["codEstadoProtocolo"] = list(cod_estado_protocolo)
+        if dt_criacao_min is not None:
+            body["dtCriacaoMin"] = _to_iso_z(dt_criacao_min)
+        if dt_criacao_max is not None:
+            body["dtCriacaoMax"] = _to_iso_z(dt_criacao_max, fim_do_dia=True)
+
+        res = requests.request(
+            "POST",
+            f"{self._sia_domain}/gmt-protocolo-api/listaProtocolos",
+            headers=common.get_headers(access_token),
+            json=body,
+        )
+
+        if res.status_code != 200:
+            raise Exception("Não foi possível listar os protocolos do BB Sia.")
+
+        return _to_dataframe(common.parse_json_object(res))

{bb_api-0.3.0 → bb_api-0.4.0}/bb_api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bb_api
-Version: 0.3.0
+Version: 0.4.0
 Summary: Wrapper da API do Banco do Brasil.
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown

{bb_api-0.3.0 → bb_api-0.4.0}/bb_api.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ bb_api/__init__.py
 bb_api/accountability.py
 bb_api/common.py
 bb_api/gestao_agil.py
+bb_api/sia.py
 bb_api.egg-info/PKG-INFO
 bb_api.egg-info/SOURCES.txt
 bb_api.egg-info/dependency_links.txt

{bb_api-0.3.0 → bb_api-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bb_api"
-version = "0.3.0"
+version = "0.4.0"
 description = "Wrapper da API do Banco do Brasil."
 readme = "README.md"
 requires-python = ">=3.13"