Referência

Aqui está o código ou referência da API Web, fornecendo detalhes sobre as classes, métodos, parâmetros, atributos e cada parte deste aplicação.

.
├── app
│   ├── adapters/
│   |   ├── factories/
│   |   ├── gateway/
│   |   ├── helpers/
|   |   └── presenters/
│   ├── core/
│   |   ├── common/
│   |   ├── config/
│   |   ├── data/
│   |   ├── domain/
|   |   └── usecases/
│   ├── framework/
│   |   ├── dependencies/
│   |   ├── exceptions/
│   |   ├── fastapi/
│   |   └── middleware/
│   └── utils/

SearchParams

Validador de tipo para parâmetros de busca Chave da API e Palavras-chave
código fonte core.common
app/core/common/types.py

class SearchParams(
    api_key: str = Field(),
    keywords: Keywords = Field()
)

Um validador de modelo criado usando o Pydantic BaseModel para os parâmetros Chave da API e Palavras-chave usados na busca da Scopus Search API, validando sua tipagem e valores usando a função Pydantic Field().

Note

Leia mais sobre as regras e especificações da Chave da API e Palavras-chave na seção de requisitos.

Parâmetro	Tipo	Descrição
`api_key`	`str`	Parâmetro de busca Chave da API
`keywords`	`Keywords`	Parâmetro de busca Palavras-chave

ScopusResult

Serializador para o item do campo entry no esquema JSON da resposta
código fonte core.data
app/core/data/serializers.py

class ScopusResult(
    link: str = Field(),
    url: str = Field()
    scopus_id: str = Field()
)

Um serializador de modelo criado usando o Pydantic BaseModel para os itens da entrada na resposta da busca da Scopus Search API, convertendo-os para o código usando a função Pydantic Field().

Parâmetro	Tipo	Campo JSON	Descrição
`link`	`str`	`@_fa`	Links de navegação no nível superior
`url`	`str`	`prism:url`	URI da Content Abstract Retrieval API
`scopus_id`	`str`	`dc:identifier`	ID Scopus do artigo

ScopusSearch

Serializador para o esquema JSON da resposta da Scopus Search API
código fonte core.data
app/core/data/serializers.py

class ScopusSearch(
    total_results: int = Field(),
    items_per_page: int = Field(),
    entry: list[ScopusResult] = Field()
)

Um serializador de modelo construído usando o Pydantic BaseModel para a resposta JSON da Scopus Search API, convertendo-a para o código usando a função Pydantic Field().

Antes da validação, ele acessará o campo JSON search-results para achatar a hierarquia e obter os dados reais.

Info

Achatamento (Flattening) é o processo de transformar uma estrutura de dados JSON aninhada em um único nível de pares chave-valor.

Parâmetro	Tipo	Campo JSON	Descrição
`total_results`	`int`	`opensearch:totalResults`	Número total de artigos encontrados
`items_per_page`	`int`	`opensearch:itemsPerPage`	Número de artigos divididos em cada página
`entry`	`list[ScopusResult]`	`entry`	Listas de dados dos artigos com os campos especificados na busca

Note

Leia mais sobre o corpo JSON retornado e seus campos.

pages_count

def pages_count() -> int

Calcula o número de páginas dividindo o total de resultados pelo número de itens por página, retornando o menor int usando a função math ceil().

ScopusQuotaRateLimit

Serializador para as respostas das APIs da Scopus
código fonte core.data
app/core/data/serializers.py

class ScopusQuotaRateLimit(
    reset: float = Field(),
    status: str = Field(),
    error_code: str = Field()
)

Um serializador de modelo construído usando Pydantic BaseModel para as respostas das APIs da Scopus, convertendo-as em código usando a função Pydantic Field().

Antes da validação, ele recuperará os cabeçalhos da resposta e obterá o campo JSON error-response, se presente.

Parâmetro	Tipo	Campo da Resposta	Descrição
`reset`	`float`	`X-RateLimit-Reset`	Data/hora em Epoch segundos quando a cota da API será redefinida
`status`	`str`	`X-ELS-Status`	Status da Scopus API/servidor Elsevier
`error_code`	`str`	`error-code`	Código de erro da Scopus API/servidor Elsevier

Info

Epoch é o número de segundos que se passaram desde 1º de janeiro de 1970, também conhecido como tempo Unix.

reset_datetime

def reset_datetime() -> str

Converte a data e hora da epoch do cabeçalho de redefinição de cota para datetime, formate-o e retorne-o como uma str mais compreensível da data e hora, informando quando a cota de solicitação da API será redefinida.

quota_exceeded

def quota_exceeded() -> int

Verifique o valor do cabeçalho de status da resposta, retornando True se for igual a QUOTA_EXCEEDED - Quota Exceeded ou False caso contrário.

Note

Saiba mais sobre o limite de cota de solicitações de API.

rate_limit_exceeded

def rate_limit_exceeded() -> bool

Verifique o valor do campo de código de erro da resposta, retornando True se for igual a RATE_LIMIT_EXCEEDED ou False caso contrário.

Note

Saiba mais sobre o limite da taxa de limitação de solicitação da API.

ScopusAbstract

Serializador para o esquema JSON da resposta da Scopus Abstract Retrieval API
código fonte core.data
app/core/data/serializers.py

class ScopusAbstract(
    url: str = Field(),
    scopus_id: str = Field(),
    authors: str = Field(),
    title: str = Field(),
    publication_name: str = Field(),
    abstract: str = Field(),
    date: str = Field(),
    eid: str = Field(),
    doi: str = Field(),
    volume: str = Field(),
    citations: str = Field()
)

Um serializador de modelo construído usando o Pydantic BaseModel para os resumos Scopus dos artigos na resposta JSON, convertendo-os em código usando a função Pydantic Field() e definindo null para todos os campos que não forem retornados.

Antes da validação, a hierarquia será achatada para obter os dados reais. Primeiro, o campo JSON abstracts-retrieval-response será acessado, então o campo authors será definido a partir do campo JSON author, obtido do campo JSON authors se retornado ou do campo JSON dc:creator caso contrário.

Info

Achatamento (Flattening) é o processo de transformar uma estrutura de dados JSON aninhada em um único nível de pares chave-valor.

Além disso, os nomes dos autores serão selecionados do campo JSON ce:indexed-name dos dados do autor, para serem concatenados e retornados. Finalmente, o campo JSON coredata será acessado e atualizado com os dados do autor antes de retorná-los.

Quando desserializado em dict, o campo date, quando não null, será formatado como DD-MM-AAAA.

Parâmetro	Tipo	Campo JSON	Descrição
`url`	`str`	`link ref=scopus`	URL da página de visualização do artigo do Scopus
`scopus_id`	`str`	`dc:identifier`	ID Scopus do artigo
`authors`	`str`	`authors` or `dc:creator`	Lista completa de autores ou apenas o primeiro autor
`title`	`str`	`dc:title`	Título do artigo
`publication_name`	`str`	`prism:publicationName`	Título da fonte
`abstract`	`str`	`dc:description`	Resumo completo do artigo
`date`	`str`	`prism:coverDate`	Data de publicação
`eid`	`str`	`eid`	ID Eletrônico do artigo
`doi`	`str`	`prism:doi`	Identificador de Objeto do Documento
`volume`	`str`	`prism:volume`	Identificador para uma publicação em série
`citations`	`str`	`citedby-count`	Contagem de citações

Note

Leia mais sobre os campos retornados na documentação do Scopus Search Views.

AccessToken

Obtém e valida o Token de Acesso
código fonte framework.dependencies
app/framework/dependencies/access_token.py

class AccessToken()(
    request: Request,
    access_token: Annotated[str | None, TokenHeader] = None
)

Uma dependência de rota que implementa o método __call__ para criar uma instância chamável que obterá e validará o cabeçalho Token de Acesso por meio da função FastAPI Header() ou da solicitação.

Para fornecer um pouco mais de segurança, o aplicaçaõ gerará automaticamente um Token que será passado para a página web da API da aplicação, que por sua vez o enviará no cabeçalho da solicitação para validação.

Parâmetro	Tipo	Descrição
`request`	`Request`	O objeto FastAPI `Request`
`access_token`	`str` or `None`	Descritor e validador do cabeçalho Token da solicitação. Default: `None`

QueryParams

Obtém e valida os Query Params
código fonte framework.dependencies
app/framework/dependencies/query_params.py

class QueryParams()(
    request: Request,
    api_key: Annotated[str | None, APIKeyQuery] = None,
    keywords: Annotated[Keywords | None, KeywordsQuery] = None
)

Uma dependência de rota que implementa o método __call__ para criar uma instância chamável que obterá e validará os parâmetros de consulta Chave da API e Palavras-chave por meio da função FastAPI Query() ou da solicitação.

Parâmetro	Tipo	Descrição
`request`	`Request`	O objeto FastAPI `Request`
`api_key`	`str` or `None`	Descritor e validador do Query Param da solicitação Chave da API. Default: `None`
`keywords`	`Keywords` or `None`	Descritor e validador do Query Param da solicitação Palavras-chave. Default: `None`

equals

def equals(api_key: str, keywords: list[str]) -> bool

Compara a Chave da API e as Palavras-chave da instância com outra Chave de API e Palavras-chave, retorna True se forem iguais ou False caso contrário.

Parâmetro	Tipo	Descrição
`api_key`	`str`	Chave da API para comparação
`keywords`	`list[str]`	Keywords para comparação

to_dict

def to_dict() -> dict[str, str | Keywords]

Serializa os atributos de instância Chave da API e Palavras-chave como um dict.

HTTPRetryHelper

Faça solicitações HTTP com mecanismos de throttling e retry
código fonte adapters.helpers
app/adapters/helpers/http_retry_helper.py

class HTTPRetryHelper(
    for_search: bool = None
)

Um cliente HTTP para fazer solicitações com os seguintes mecanismos:

Throttling: controla a taxa de fluxo de dados em um serviço limitando o número de solicitações da API que um usuário pode fazer em um determinado período.
Retry: tenta novamente operações com falha automaticamente para se recuperar de falhas inesperadas e continuar funcionando corretamente.
Rate Limiting: limita o tráfego da rede controlando o número de solicitações que podem ser feitas em um determinado período de tempo.
Session: persiste certos parâmetros e reutiliza a mesma conexão em todas as solicitações.
Cache: armazena dados temporariamente para que futuras solicitações desses dados possam ser atendidas mais rapidamente.

Parâmetro	Tipo	Descrição
`for_search`	`bool`	Indica na mensagem do log se a solicitação será direcionada para a Scopus Search API ou não. Default: `None`

mount_session

def mount_session(headers: Headers) -> None

Inicializa a sessão e a monta registrando o adaptador de conexão de controle de cache com a configuração de retry.

Parâmetro	Tipo	Descrição
`headers`	`Headers`	Os cabeçalhos HTTP para enviar na solicitação

close

def close() -> None

Fecha o adaptador de conexão de controle de cache e a sessão.

request

def request(url: str) -> Response

Inicializa, prepara com sessão, envia a solicitação, e então retorna a resposta como um objeto Requests Response.

Parâmetro	Tipo	Descrição
`url`	`str`	A URL para enviar a solicitação

URLBuilderHelper

Gera e formata URLs para as solicitações HTTP
código fonte adapters.helpers
app/adapters/helpers/url_builder_helper.py

class URLBuilderHelper()

Um construtor para gerar as URLs de recursos das APIs da Scopus e a URL de paginação.

get_search_url

def get_search_url(keywords: Keywords) -> str

Gera a URL do recurso da Scopus Search API e a retorna como str.

Parâmetro	Tipo	Descrição
`keywords`	`Keywords`	As Palavras-chave que serão utilizadas na busca

get_pagination_url

def get_pagination_url(page: int) -> str

Gera a URL de paginação da Scopus Search API e a retorna como str.

Parâmetro	Tipo	Descrição
`page`	`int`	O índice de página para o início da paginação

get_article_page_url

def get_abstract_url(url: str) -> str

Gera a URL do recurso da Scopus Abstract Retrieval API e a retorna como str.

Parâmetro	Tipo	Descrição
`url`	`str`	A URL do recurso base da Scopus Abstract Retrieval API

ScopusSearchAPI

Busca e recupera artigos por meio da Scopus Search API
código fonte adapters.gateway
app/adapters/gateway/scopus_search_api.py

class ScopusSearchAPI(
    http_helper: HttpRetry,
    url_builder: UrlBuilder
)

Primeiro, os cabeçalhos da solicitação para a API da Scopus serão construídos com a Chave da API, a URL do recurso é construída com a Chave da API e Palavras-chave como parâmetros de pesquisa, e então os artigos serão buscados por meio da Scopus Search API. Em seguida, a resposta é validada, recuperando os artigos se bem-sucedida ou lidando com erros caso contrário.

Um erro será retornado quando: nenhum artigo for encontrado, a cota da Chave da API for excedida, a Scopus Search API retornar um erro de status HTTP, e quando a resposta JSON não puder ser validada.

Note

Saiba mais sobre a cota de quantos dados uma Chave da API pode recuperar.

Os dados dos artigos serão validados, assumindo como padrão null para os campos que não forem retornados. Ele pode usar threads com o ThreadPoolExecutor e construir a URL com o índice da página quando houver vários artigos para buscar com paginação.

Parâmetro	Tipo	Descrição
`http_helper`	`HttpRetry`	Injeta o `HttpRetryHelper` para fazer as solicitações
`url_builder`	`UrlBuilder`	Injeta o `UrlBuilderHelper` para construir as URLs

search_articles

def search_articles(search_params: SearchParams) -> list[ScopusResult]

Busca artigos por meio da Scopus Search API, compila e retorna todos os dados recuperados em uma list de ScopusResult.

Parâmetro	Tipo	Descrição
`search_params`	`SearchParams`	Parâmetros de pesquisa `Chave de API` e `Palavras-chave` validados

ScopusAbstractRetrievalAPI

Recupera resumos Scopus por meio da Scopus Abstract Retrieval API
código fonte adapters.gateway
app/adapters/gateway/scopus_abstract_retrieval_api.py

class ScopusAbstractRetrievalAPI(
    http_helper: HttpRetry,
    url_builder: UrlBuilder
)

Primeiro, os cabeçalhos da solicitação para a API da Scopus serão criados com a Chave da API, a URL do recurso é criada a partir da URL do recurso base e, em seguida, os resumos Scopus serão recuperados por meio da Scopus Abstracts Retrieval API. A resposta é então validada, recuperando os resumos se bem-sucedida ou manipulando erros caso contrário.

Um erro será retornado quando: a cota da Chave da API for excedida, a Scopus Abstract Retrieval API retornar um erro de status HTTP, e quando a resposta JSON não puder ser validada.

Os dados dos resumos serão validados, assumindo como padrão null para os campos que não forem retornados. Ele pode usar threads com o ThreadPoolExecutor quando houver vários resumos para recuperar.

Parâmetro	Tipo	Descrição
`http_helper`	`HttpRetry`	Injeta o `HttpRetryHelper` para fazer as solicitações
`url_builder`	`UrlBuilder`	Injeta o `UrlBuilderHelper` para construir as URLs

retrieve_abstracts

def retrieve_abstracts(api_key: str, entry: list[ScopusResult]) -> DataFrame

Recupera resumos Scopus por meio da Scopus Abstract Retrieval API, compila e retorna todos os dados buscados em um Pandas DataFrame.

Parâmetro	Tipo	Descrição
`api_key`	`str`	Parâmetro de pesquisa `Chave de API` validado
`entry`	`list[ScopusResult]`	Lista dos dados dos artigos

ArticlesSimilarityFilter

Filtrar artigos de autores idênticos com títulos semelhantes
código fonte core.usecases
app/core/usecases/articles_similarity_filter.py

class ArticlesSimilarityFilter()

Do DataFrame contendo todas as informações dos artigos já coletadas, os autores são contados, e aqueles que foram repetidos pelo menos duas vezes são selecionados. Então, dos artigos desses autores, seus respectivos títulos são selecionados e comparados usando a função TheFuzz ratio(), e aqueles cuja taxa de similaridade é de pelo menos 80% são coletados e descartados.

Note

Após consideração e testes, definimos a taxa de similaridade para a seleção de artigos em 80%.

Para todos os artigos semelhantes reunidos, o primeiro é mantido e o restante é descartado. Se todos os autores forem únicos, ou seja, nenhum é repetido, ou nenhum título semelhante foi encontrado, ele retornará o mesmo DataFrame.

filter

def filter(dataframe: DataFrame) -> DataFrame

Filtra artigos do DataFrame se eles forem de autores idênticos com títulos semelhantes, e então todos os dados filtrados serão retornados em um Pandas DataFrame.

Parâmetro	Tipo	Descrição
`dataframe`	`DataFrame`	O `DataFrame` contendo todas as informações do artigo coletadas a serem filtradas

ScopusArticlesAggregator

Reúne, filtra e compila dados de artigos Scopus
código fonte core.usecases
app/core/usecases/scopus_articles_aggregator.py

class ScopusArticlesAggregator(
    search_api: SearchAPI,
    abstract_api: AbstractAPI,
    similarity_filter: SimilarityFilter
)

Primeiro, os artigos são pesquisados por meio da Scopus Search API usando os parâmetros de busca fornecidos, e seus resumos Scopus são recuperados por meio da Scopus Abstract Retrieval API.

Em seguida, os artigos que são duplicatas exatas são removidos, aqueles com os mesmos autores e títulos também são descartados, e artigos semelhantes são filtrados usando ArticlesSimilarityFilter.

Um erro é retornado quando nenhum artigo é encontrado.

Parâmetro	Tipo	Descrição
`search_api`	`SearchAPI`	Injeta o `ScopusSearchAPI` para pesquisar e obter os artigos por meio da Scopus Search API
`articles_scraper`	`abstract_api`	Injeta o `ScopusAbstractRetrievalAPI` para recuperar os resumos Scopus por meio da ScopusAbstractRetrievalAPI
`similarity_filter`	`SimilarityFilter`	Injeta o `ArticlesSimilarityFilter` para filtrar os artigos de autores idênticos com títulos semelhantes

get_articles

def get_articles(params: SearchParams) -> FileResponse

Reúne e filtra dados de artigos Scopus, grava e salva todos os artigos restantes em um arquivo CSV e os retorna como um objeto FastAPI FileResponse.

Parâmetro	Tipo	Descrição
`params`	`SearchParams`	Parâmetros de busca Chave da API e Palavras-chave validados

TemplateContextBuilder

Gera valores de contexto para respostas de template
código fonte adapters.presenters
app/adapters/presenters/template_context.py

class TemplateContextBuilder(
    request: Request
)

Compila e cria dados, como valores de contexto, para os templates que o Jinja renderiza, passando-os e carregando-os em templates HTML que são retornados como um objeto Jinja2Templates TemplateResponse.

Parâmetro	Tipo	Descrição
`request`	`Request`	O objeto FastAPI `Request`

get_web_app_context

def get_web_app_context() -> Context

Retorna dados para construir o template da resposta da página web da API, retornando o objeto da solicitação, o nome do template, e os valores de contexto.

Sobre os valores do Contexto:

Campo	Descrição
`request`	O objeto FastAPI `Request`
`version`	Versão da aplicação. Exemplo: `3.0.0`
`repository`	URL do repositório GitHub da aplicação
`swagger_url`	URL da página do Swagger. Default: `/`
`token`	Token da aplicação
`filename`	Nome do arquivo CSV. Default: `articles.csv`
`table_url`	URL da página web da tabela. Default: `/scopus-survey/api/table`
`search_url`	URL da API. Default: `/scopus-survey/api/search-articles`
`description`	Descrição da aplicação

get_table_context

def get_table_context() -> Context

Retorna dados para construir o template da resposta da página web da Tabela, retornando o objeto da solicitação, o nome do template, e os valores de contexto.

Sobre os valores do Contexto:

Campo	Descrição
`request`	O objeto FastAPI `Request`
`version`	Versão da aplicação. Exemplo: `3.0.0`
`repository`	URL do repositório GitHub da aplicação
`swagger_url`	URL da página do Swagger. Default: `/`
`content`	Conteúdo da tabela. Lista dos artigos encontrados ou `None` se não houver artigos
`web_app_url`	URL da página web da aplicação. Default: `/scopus-survey/api`

ExceptionJSON

Gera respostas de representação JSON para exceções
código fonte adapters.presenters
app/adapters/presenters/exception_json.py

class ExceptionJSON(
    request: Request,
    code: int,
    message: str,
    errors: Errors = None
)

Um presenter criado usando FastAPI JSONResponse que gera respostas de representação JSON para exceções. Os detalhes do erro são filtrados para remover o erro PydanticUndefined de Pydantic ValidationError e os dados do objeto Request são recuperados.

O timestamp datetime é definido como uma str no formato ISO e, finalmente, todos os dados são convertidos e codificados usando a função FastAPI jsonable_encoder().

Parâmetro	Tipo	Descrição
`request`	`Request`	O objeto FastAPI `Request`
`code`	`int`	Código de erro de status HTTP
`message`	`str`	Descrição da exceção
`errors`	`Errors`	Metadados e detalhes do erro

Exceções e Erros

Exceções HTTP são modelos criados a partir do FastAPI HTTPException que representam códigos de status de erro HTTP enviados na resposta para notificar o cliente usando sua aplicação de um erro. Os implementados são 401 Unauthorized, 404 NotFound, 422 UnprocessableContent, 500 InternalError, 502 BadGateway e 504 GatewayTimeout.

Erros da aplicação são modelos criados a partir da classe base Exception que indica que ocorreu um erro na parte central da operação/processamento da aplicação. Os implementados são InterruptError para o sinal de interrupção de desligamento/saída e ScopusAPIError para o erro de status HTTP da Scopus Search API.

Manipuladores de exceção são rotinas projetadas para processar e responder rapidamente à ocorrência de exceções/erros ou situações especiais específicas durante a execução de um programa, retornando sua representação JSON. Os manipuladores implementados são para Starlette HTTPException, FastAPI HTTPException, RequestValidationError, ResponseValidationError, ValidationError, HTTPException, ApplicationError e Exception.

Sobre a Resposta JSON de Exceção:

Campo	Tipo	Descrição
`success`	`bool`	Resultado da operação, que é um fracasso já que é uma exceção. Deafult: `False`
`code`	`int`	Código de status de erro HTTP
`message`	`str`	Descrição da exceção/erro
`request`	`dict[str,Any]`	Contém alguns dados de solicitação em um `dict`
`errors`	`Errors`	Contém alguns detalhes da exceção/erro em um `dict`. Deafult: `None`
`timestamp`	`str`	O timestamp de data e hora como uma `str` no formato ISO

Sobre o campo request:

Campo	Descrição
`host`	O host do cliente da solicitação. Default: `127.0.0.1`
`port`	A porta do cliente da solicitação. Default: `8000`
`method`	O method da solicitação
`url`	O caminho da URL da solicitação
`headers`	Os cabeçalhos da solicitação

Sobre e os detalhes do erro ScopusAPIError:

Campo	Descrição
`status`	Código de erro de status HTTP das APIs da Scopus
`api_error`	Descrição do erro de status da resposta das APIs da Scopus. Deafult: `null`
`content`	O próprio conteúdo da resposta JSON das APIs da Scopus

Note

Veja a descrição do erro de status das respostas na documentação.

Middlewares

Middlewares são mecanismos criados a partir do Starlette BaseHTTPMiddleware que funcionam no ciclo de solicitação-resposta da aplicação, interceptando chamadas e processando-as. Eles podem acessar e manipular cada objeto de solicitação antes que ele seja processado por qualquer manipulador de rota, e também cada objeto de resposta antes de retorná-lo. Há três implementados.

O middleware TraceExceptionControl rastreia a solicitação, relatando o cliente, a URL acessada, o código de status da resposta e o tempo de processamento. Ele também lida com quaisquer exceções inesperadas e erros de interrupção de sinal.

O middleware RedirectNotFoundRoutes redireciona qualquer solicitação de rota não encontrada que receba um erro 404 Not Found e não seja uma rota permitida mapeada. Ele também lida com erros de interrupção de sinal.

O middleware FastAPI CORSMiddleware implementa e configura o mecanismo CORS, permitindo qualquer origem, quaisquer credenciais, qualquer cabeçalho e apenas o método GET.

SignalHandler

Defina os manipuladores de sinal para definir o sinalizador do evento de desligamento
código fonte utils
app/utils/signal_handler.py

class SignalHandler(
    for_async: bool = None
)

Crie um objeto de evento, seja um threading Event ou asyncio Event com base no valor do parâmetro, e registre seus manipuladores para os sinais SIGINT e SIGTERM usando a função signal(). Os manipuladores capturarão sinais de desligamento e definirão o sinalizador de evento. Então, operações baseadas em processos ou threads podem ser encerradas graciosamente.

Info

Um desligamento gracioso (graceful shutdown) é um processo controlado e ordenado para executar um desligamento seguro e liberar recursos quando a aplicação é interrompido repentinamente ou recebe um sinal de desligamento/encerramento.

Parâmetro	Tipo	Descrição
`for_async`	`bool`	Indica se o evento será assíncrono ou não. Default: `None`