DEV Community: Marcus Andrade

Como Conectar ao Azure Table Storage e Manipular Dados com PySpark

Marcus Andrade — Tue, 13 Aug 2024 02:11:54 +0000

Neste artigo, vamos explorar como conectar ao Azure Table Storage, realizar consultas para extrair dados específicos e, em seguida, utilizar o PySpark para manipular e exibir esses dados em um formato tabular. Este guia é ideal para desenvolvedores e engenheiros de dados que trabalham com grandes volumes de dados no Azure e querem aproveitar a flexibilidade do PySpark.

1. Configuração do Ambiente
Antes de começarmos, é necessário configurar algumas bibliotecas e informações de acesso. Neste exemplo, utilizamos as seguintes bibliotecas:

azure.data.tables: Para conectar e interagir com o Azure Table Storage.
pandas: Para manipulação de dados (caso necessário).
pyspark.sql: Para manipulação de dados utilizando PySpark.

2. Configurando as Credenciais de Acesso

Para acessar o Azure Table Storage, você precisará do nome do ambiente de acesso e da chave da conta, que são armazenados em variáveis para garantir a segurança:

account_name = "seu_ambiente_acesso"
account_key = "sua_chave"
table_name = "tabela_a_qual_deseja"

3. Conectando ao Azure Table Storage

O primeiro passo é estabelecer a conexão com o Azure Table Storage. Para isso, criamos uma connection_string e utilizamos o TableServiceClient para iniciar a conexão:

from azure.data.tables import TableServiceClient
from azure.data.tables import TableClient

def get_table_data():
    connection_string = f"DefaultEndpointsProtocol=https;AccountName={account_name};AccountKey={account_key};TableEndpoint=https://{account_name}.table.core.windows.net/;"
    table_service = TableServiceClient.from_connection_string(conn_str=connection_string)
    table_client = table_service.get_table_client(table_name)

4. Filtrando e Selecionando Colunas

Uma vez conectado, podemos realizar consultas no Azure Table Storage. No exemplo abaixo, filtramos os dados para obter apenas as entidades que possuem PartitionKey igual a '2024-08-02'. Além disso, selecionamos colunas específicas para extrair apenas os dados que são relevantes para a nossa análise:

  query_filter = "PartitionKey eq '2024-08-02'"
    columns = ['PartitionKey','RowKey','client','depot','margin_max','max_comparable_price','min_comparable_price','product','validity_date','volume_tier']
    entities = table_client.query_entities(query_filter, select=columns)

5. Convertendo Dados para DataFrame do PySpark

Após recuperar os dados do Azure Table Storage, convertemos as entidades em um DataFrame do PySpark. Isso é útil para manipular grandes volumes de dados de forma eficiente:

rows = [entity for entity in entities]
    from pyspark.sql import SparkSession
    spark = SparkSession.builder.appName("AzureTable").getOrCreate()
    df_spark = spark.createDataFrame(rows)

6. Exibindo os Dados

Finalmente, podemos exibir os dados no formato tabular utilizando o método show() do PySpark. Neste caso, optamos por mostrar até 40 registros sem truncar os valores das colunas:

    df_spark.show(n=40, truncate=False)

    return df_spark

# Chamando a função para obter os dados e exibir
get_table_data()

LangFuse - Overview

Marcus Andrade — Sun, 14 Jul 2024 03:56:45 +0000

LangFuse

LangFuse é uma ferramenta desenvolvida para observabilidade de linguagens naturais (NLP – Natural Language Process).
Possui como seu objetivo base e premissa principal que as empresas monitorem seus modelos de linguagem assim utilizados tal como modelos para métricas de latência e também como precisão de recursos.
O LangFuse proporciona visibilidade detalhada sobre como os modelos estão operando e quais integrações ocorrem no momento do processamento onde podem haver problemas ou áreas correlatas.

Às principais funcionalidades do LangFuse retiradas do seu site : https://langfuse.com/, estão compostas por:

Monitoramento de Desempenho:

-Acompanhamento em tempo real das métricas de desempenho dos modelos de linguagem.

-Identificação de gargalos de desempenho e problemas de latência.
Análise de Uso:
-Insights sobre como os modelos estão sendo utilizados pelos usuários.
-Rastreamento de interações para entender melhor os padrões de uso e comportamento.
Gestão de Recursos:
-Monitoramento do uso de recursos computacionais.
-Identificação de oportunidades para otimização de recursos e redução de custos.
Detecção de Anomalias:
-Ferramentas para identificar comportamentos anômalos ou inesperados nos modelos.
-Alertas automáticos para problemas críticos.
Relatórios e Visualizações
-Ferramentas de visualização para facilitar a interpretação dos dados.

Com a ferramenta podemos também efetuar o processo de criação e customização de alguns painéis para podermos verificar o andamento e processamento de toda nossa aplicação.

Existe um contexto de mercado muito forte referente a utilização do langfuse no mercado tecnológico, onde, grandes empresas que operam com grandes volumes de dados (BigData, DW), com linguagens naturais tal como a própria OpenAI (GPT), e utilização de ChatBot’s, assistentes virtuais (Watson IBM) como exemplo, e serviços vinculados a atendimento ao cliente, tal como automações que rodam em cores de WhatsAps, e atendimentos robóticos com persona humanizada, odem se beneficiar significativamente do LangFuse. Ele é particularmente útil em ambientes onde a confiabilidade e a eficiência dos modelos de linguagem são críticas para a operação.

Abaixo temos algumas imagens da aplicação do processo :

Segue abaixo alguns pontos relacionados sobre os prompt’s que podem ser utilizados tal como OpenAI (Davinci)

O mesmo prompt torna-se muito similar aos promt’s da empresa OpenAI (ChatGPT)

Em uma pesquisa Mercadológica sobre o tema podemos obter algumas explicações sobre cada tema :

Python SDK
Descrição: SDK para a linguagem de programação Python.
Utilização: Desenvolvedores podem utilizar este SDK para integrar a ferramenta central com aplicativos Python.

JS/TS SDK
Descrição: SDK para JavaScript e TypeScript.
Utilização: Permite a integração com aplicações web desenvolvidas em JavaScript ou TypeScript.

OpenAI SDK
Descrição: SDK fornecido pela OpenAI.
Utilização: Facilita a integração com os serviços e modelos de IA da OpenAI.
Langchain
Descrição: Ferramenta para construção de pipelines de processamento de linguagem natural.
Utilização: Utilizada para criar fluxos de trabalho complexos envolvendo NLP.

Llama-Index
Descrição: Ferramenta de indexação e consulta para dados processados por modelos de linguagem.
Utilização: Permite a criação de índices eficientes para busca e recuperação de informações.
LiteLLM (proxy)
Descrição: Proxy leve para modelos de linguagem.
Utilização: Facilita a integração com modelos de linguagem de forma otimizada.

Haystack
Descrição: Framework de pesquisa de código aberto.
Utilização: Utilizado para construir sistemas de busca e recuperação de informações robustos

API
Descrição: Interface de Programação de Aplicações.
Utilização: Fornece endpoints para integração direta via chamadas de API.

Conexões
Cada aplicabilidade mostrada acima, está vinculada a um core de inteligência artificial ao qual poderá ser usado ou não de acordo com a sua necessidade ou promt dentro das comunicações com sua API.

Abaixo trago alguns pontos fortes referente a utilização da ferramenta através de estudo Mercadológico levantado.

Estudo Mercadológico sobre a Utilização do LangFuse no Mercado Atual (2024)

Pontos Fortes (Prós)
1.Flexibilidade de Integração
Exemplo: LangFuse pode ser integrado com diversas ferramentas e plataformas, facilitando seu uso em diferentes ambientes de TI.
2.Monitoramento em Tempo Real
Exemplo: Empresas podem detectar e resolver problemas de desempenho imediatamente, minimizando o tempo de inatividade.
3.Análise Detalhada de Uso
Exemplo: LangFuse oferece insights profundos sobre como os modelos de linguagem são utilizados, permitindo melhorias baseadas em dados concretos.
4.Otimização de Recursos
Exemplo: Com a gestão eficiente de recursos, as empresas podem reduzir custos operacionais.
5.Detecção Precoce de Anomalias
Exemplo: Identificação e correção de comportamentos anômalos antes que causem problemas maiores.
6.Relatórios Personalizáveis
Exemplo: Relatórios detalhados e dashboards personalizáveis ajudam na tomada de decisões estratégicas.
7.Suporte a Diversas Linguagens de Programação
Exemplo: Compatível com SDKs de Python, JavaScript/TypeScript, facilitando a integração em diferentes stacks de desenvolvimento.
8.Escalabilidade
Exemplo: LangFuse é projetado para escalar conforme a demanda da empresa cresce, suportando grandes volumes de dados.
9.Redução de Riscos
Exemplo: Com a mitigação de erros com o uso de monitoramento de desempenho, os riscos com mão de obra e monitoramento core são reduzidos pela metade.
10.Melhoria Contínua
Exemplo: As análises detalhadas permitem um ciclo contínuo de feedback e aprimoramento dos modelos de linguagem.

Agora listando alguns pontos para a Não utilização da Ferramenta;

Pontos Fracos (Contras)
11.Curva de Aprendizado
Exemplo: Implementar e usar todas as funcionalidades do LangFuse pode ser desafiador para equipes sem experiência prévia.
12.Custo de Implementação
Exemplo: Os custos iniciais para configurar e integrar LangFuse podem ser altos, especialmente para pequenas empresas.
13.Complexidade na Integração
Exemplo: Integrar LangFuse com sistemas existentes pode exigir tempo e recursos significativos.
14.Dependência de Terceiros
Exemplo: A confiabilidade do LangFuse pode depender de outros serviços de terceiros com os quais está integrado.
15.Necessidade de Manutenção Contínua
Exemplo: Ferramentas de monitoramento e análise como LangFuse requerem manutenção contínua para garantir precisão e eficiência.
16.Impacto na Performance
Exemplo: O monitoramento em tempo real pode adicionar uma carga adicional aos sistemas, afetando sua performance.
17.Complexidade de Dados
Exemplo: Analisar e interpretar grandes volumes de dados coletados pode ser complexo e exigir habilidades especializadas.
18.Segurança de Dados
Exemplo: Garantir a segurança dos dados monitorados e analisados por LangFuse pode ser um desafio adicional.
19.Customização Limitada
Exemplo: Algumas empresas podem encontrar limitações na personalização das funcionalidades do LangFuse para atender necessidades específicas.
20.Dependência de Infraestrutura
Exemplo: LangFuse pode exigir uma infraestrutura robusta para funcionar de maneira ideal, o que pode ser um problema para empresas com recursos limitados.

Automação de Coleta de Dados de CNPJ com Python utilizando ReceitaWS

Marcus Andrade — Mon, 08 Jul 2024 18:45:34 +0000

Neste artigo, vamos explorar como automatizar a coleta de dados de CNPJ usando Python. Utilizaremos a API da ReceitaWS para obter informações detalhadas sobre cada CNPJ e armazenaremos esses dados em um arquivo CSV. Este guia é voltado para desenvolvedores que desejam automatizar a extração e armazenamento de informações de CNPJ.

Bibliotecas Utilizadas
requests: Para fazer requisições HTTP à API da ReceitaWS.
pandas: Para manipulação e formatação de dados.
time: Para controlar o intervalo entre as requisições e respeitar os limites da API.
Código Completo

Utilizando https://receitaws.com.br

import requests
import pandas as pd
import time

def get_cnpj_data(cnpj):
    """
    Faz uma requisição à API da ReceitaWS para obter dados do CNPJ.

    Args:
        cnpj (str): O número do CNPJ a ser consultado.

    Returns:
        dict: Dados do CNPJ em formato JSON se a requisição for bem-sucedida.
        None: Se a requisição falhar.
    """
    url = f"https://receitaws.com.br/v1/cnpj/{cnpj}"
    response = requests.get(url)
    if response.status_code == 200:
        return response.json()
    else:
        return None

def process_cnpj_data(cnpj_list):
    """
    Processa uma lista de CNPJs, obtendo os dados de cada um e respeitando o limite de requisições da API.

    Args:
        cnpj_list (list): Lista de números de CNPJ a serem consultados.

    Returns:
        list: Lista de dados de CNPJ obtidos da API.
    """
    data = []
    for cnpj in cnpj_list:
        cnpj_data = get_cnpj_data(cnpj)
        if cnpj_data:
            data.append(cnpj_data)
        time.sleep(20)  # Espera 20 segundos entre cada requisição para respeitar o limite de 3 requisições por minuto

    return data

def format_data_for_sql(data):
    """
    Formata os dados de CNPJ em um DataFrame do pandas, adequado para exportação.

    Args:
        data (list): Lista de dados de CNPJ obtidos da API.

    Returns:
        pandas.DataFrame: DataFrame com os dados formatados.
    """
    df_rows = []
    for item in data:
        row = {
            'cnpj': item.get('cnpj', ''),
            'nome': item.get('nome', ''),
            'fantasia': item.get('fantasia', ''),
            'logradouro': item.get('logradouro', ''),
            'numero': item.get('numero', ''),
            'complemento': item.get('complemento', ''),
            'cep': item.get('cep', ''),
            'bairro': item.get('bairro', ''),
            'municipio': item.get('municipio', ''),
            'uf': item.get('uf', ''),
            'telefone': item.get('telefone', ''),
            'email': item.get('email', ''),
        }
        df_rows.append(row)

    df = pd.DataFrame(df_rows)
    return df

def save_to_csv(df, file_name='cnpj_data.csv'):
    """
    Salva o DataFrame em um arquivo CSV.

    Args:
        df (pandas.DataFrame): DataFrame contendo os dados de CNPJ.
        file_name (str): Nome do arquivo CSV a ser salvo.
    """
    df.to_csv(file_name, index_label='ID')

if __name__ == "__main__":
    cnpj_list = [
        '10869047000140', #CNPJ GERADO PELO 4DEVS
        # Adicione mais CNPJs conforme necessário
    ]

    cnpj_data = process_cnpj_data(cnpj_list)
    df = format_data_for_sql(cnpj_data)
    save_to_csv(df)

Explicação do Código
Função get_cnpj_data(cnpj):

Faz uma requisição à API da ReceitaWS com o CNPJ fornecido.
Retorna os dados em formato JSON se a requisição for bem-sucedida, ou None se falhar.
Função process_cnpj_data(cnpj_list):

Itera sobre uma lista de CNPJs, chamando get_cnpj_data para cada CNPJ.
Respeita o limite de requisições da API, esperando 20 segundos entre cada requisição.
Retorna uma lista de dados de CNPJ.
Função format_data_for_sql(data):

Formata os dados de CNPJ em um DataFrame do pandas, com colunas relevantes para armazenar informações.
Prepara os dados para exportação.
Função save_to_csv(df, file_name='cnpj_data.csv'):

Salva o DataFrame em um arquivo CSV, com o nome especificado.
Bloco if name == "main"::

Define uma lista de CNPJs para processamento.
Chama as funções para processar os dados e salvar em um arquivo CSV.

Conectando ao Azure Blob Storage com Python para Listar Arquivos em um Diretório

Marcus Andrade — Mon, 08 Jul 2024 12:27:15 +0000

Neste artigo, vou mostrar como você pode se conectar ao Azure Blob Storage usando o Python e listar arquivos em um diretório específico. Vamos utilizar bibliotecas como azure.storage.blob e mssparkutils para interagir com o serviço de armazenamento e obter segredos do Azure Key Vault.

Configurações Iniciais
Primeiramente, precisamos definir algumas configurações iniciais, como o nome do container, o caminho relativo dos arquivos e o serviço vinculado que vamos usar.

`from azure.storage.blob import BlobServiceClient
import json

# Configurações iniciais
blob_container_name = 'container_aqui'  # seu nome do container
blob_relative_path_enriched = 'caminho_aqui'  # caminho com barra no final
linked_service_enriched = 'Linked_service_aqui'  # seu linked service
`

Obtendo Propriedades do Key Vault
Vamos utilizar o mssparkutils para obter as propriedades do Key Vault e a chave de acesso necessária.

`# Obtendo propriedades do Key Vault
ls_keyvault = mssparkutils.credentials.getPropertiesAll('Linked_service_aqui')
converter_dic_kv = json.loads(ls_keyvault)

# Coletando o endpoint do Key Vault
end_point_kv = (converter_dic_kv['Endpoint'].split("/"))[2]
kv_name = (end_point_kv.split("."))[0]

# Obtendo a chave de acesso do Key Vault
access_key = mssparkutils.credentials.getSecret(kv_name, 'seu_storage_aqui', 'Linked_service_aqui')
`

Configurando o Cliente do Blob Storage
Agora que temos a chave de acesso, vamos configurar o cliente do Blob Storage.

# Obtendo propriedades do linked service
ls_enriched = mssparkutils.credentials.getPropertiesAll(Linked_service_aqui_enriched)
converter_dic_enriched = json.loads(ls_enriched)

# Coletando o endpoint do linked service
end_point_enriched = (converter_dic_enriched['Endpoint'].split("/"))[2]

# Configurando o cliente do Blob Storage
storage_account = end_point_enriched.split(".")[0]
print(f"Storage Account: {storage_account}")
print(f"Access Key: {access_key[:4]}...{access_key[-4:]}")  # Mostrar apenas início e fim da chave por segurança

blob_service_client = BlobServiceClient(account_url=f"https://{storage_account}.blob.core.windows.net", credential=access_key)
container_client = blob_service_client.get_container_client(blob_container_name)

Função para Listar Arquivos
Vamos criar uma função para listar os nomes dos arquivos em um diretório específico no Blob Storage.

def list_files_in_directory(container_client, directory_path):
    """ Função para listar os nomes dos arquivos em um diretório específico """
    try:
        print(f"Tentando acessar o container: {container_client.container_name}")
        blob_list = container_client.list_blobs(name_starts_with=directory_path)
        file_names = [blob.name for blob in blob_list]
        if not file_names:
            print(f"Nenhum arquivo encontrado em {directory_path}.")
        return file_names
    except Exception as e:
        print(f"Erro ao listar arquivos no diretório especificado: {e}")
        return []

Listando os Arquivos
Agora podemos usar a função list_files_in_directory para listar os arquivos no diretório especificado.

# Listando os nomes dos arquivos no diretório especificado
print(f"Tentando listar arquivos no diretório: {blob_relative_path_enriched}")

file_names = list_files_in_directory(container_client, blob_relative_path_enriched)

# Verificando se a lista de arquivos não está vazia
if not file_names:
    print("Nenhum arquivo encontrado no diretório especificado.")
else:
    # Exibindo os nomes dos arquivos
    print(f"Arquivos encontrados no diretório {blob_relative_path_enriched}:")
    for file_name in file_names:
        print(file_name)

print("Processo finalizado.")

Com isto podemos listar todos os dados dentro de um blob utilizando um notebook com Synapase junto a Microsoft Azure.

Agradecimento Especial à André Luiz dos Santos Junior pelo apoio na solução : https://www.linkedin.com/in/andrelsjunior/

Agradecimento Especial à Adilton Costa Anna pelo apoio na solução : https://www.linkedin.com/in/adiltoncantos/

Como Excluir Cursos no Google Classroom Usando a API do Google

Marcus Andrade — Mon, 03 Jun 2024 12:42:48 +0000

Neste artigo, vamos documentar como usar a API do Google Classroom para listar e excluir cursos. Vamos detalhar o passo a passo necessário para configurar e executar o código Python que realiza essas operações.

Passo a Passo

Autenticação: O código verifica se o arquivo token.json existe para utilizar credenciais armazenadas previamente. Caso contrário, ele inicia o fluxo de autenticação OAuth 2.0.

Listar Cursos: O código chama a API do Google Classroom para listar todos os cursos disponíveis.

Excluir Curso: O código solicita o ID do curso a ser excluído e chama a API para excluir o curso especificado.

Execução
Execute o Script: Execute o script Python.
Autenticação Inicial: Se for a primeira execução, você será redirecionado para uma página de login do Google para conceder permissões ao aplicativo.
Listar Cursos: Após a autenticação, o script listará todos os cursos disponíveis.
Excluir Curso: Insira o ID do curso que você deseja excluir.

Pré-requisitos

Conta do Google: Certifique-se de ter uma conta do Google.
Google Cloud Project: Crie um projeto no Google Cloud Console.
API do Google Classroom: Ative a API do Google Classroom para o seu projeto.
Credenciais OAuth 2.0: Configure as credenciais OAuth 2.0 para o seu projeto.

Configuração do Ambiente

Instale as bibliotecas necessárias: Execute o comando abaixo para instalar as bibliotecas necessárias.
```
pip install google-auth google-auth-oauthlib google-auth-httplib2 google-api-python-client
```
Crie um arquivo credentials.json: Baixe as credenciais OAuth 2.0 do Google Cloud Console e salve-as como credentials.json no diretório do seu projeto.

Código Python

Aqui está o código completo para listar e excluir cursos no Google Classroom:


python
import os.path
from google.auth.transport.requests import Request
from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError

# Escopos necessários para listar cursos, adicionar alunos e professores, criar e excluir cursos no Google Classroom
SCOPES = [
    "https://www.googleapis.com/auth/classroom.courses",
    "https://www.googleapis.com/auth/classroom.courses.readonly",
    "https://www.googleapis.com/auth/classroom.rosters"
]

def main():
    """
    Código usado para excluir um curso do Google Classroom.
    """
    creds = None
    if os.path.exists("token.json"):
        creds = Credentials.from_authorized_user_file("token.json", SCOPES)
    # Vai pedir autenticação 
    if not creds or not creds.valid:
        if creds and creds.expired and creds.refresh_token:
            creds.refresh(Request())
        else:
            flow = InstalledAppFlow.from_client_secrets_file(
                "credentials.json", SCOPES
            )
            creds = flow.run_local_server(port=0)
        # Salva as credenciais e mostra os cursos
        with open("token.json", "w") as token:
            token.write(creds.to_json())

    try:
        service = build("classroom", "v1", credentials=creds)

        # Lista todos os cursos disponíveis
        list_courses(service)

        # Solicita o ID do curso a ser excluído
        course_id = input("Digite o ID do curso a ser excluído: ")
        delete_course(service, course_id)

    except HttpError as error:
        print(f"An error occurred: {error}")

def list_courses(service):
    try:
        # Chama a API Do classroom para ver os cursos
        results = service.courses().list(pageSize=1000).execute()
        courses = results.get("courses", [])

        if not courses:
            print("No courses found.")
            return

        # Mostra na tela o nome dos cursos criados e salas
        print("Courses:")
        for course in courses:
            print(f'{course["name"]} (ID: {course["id"]})')

    except HttpError as error:
        print(f"An error occurred: {error}")

def delete_course(service, course_id):
    try:
        service.courses().delete(id=course_id).execute()
        print(f"Course with ID {course_id} deleted successfully.")
    except HttpError as error:
        print(f"An error occurred: {error}")

if __name__ == "__main__":
    # Apagar o arquivo token.json para forçar a reautenticação
    if os.path.exists("token.json"):
        os.remove("token.json")
    main()

Adição de Alunos ao Google Classroom com Python

Marcus Andrade — Mon, 20 May 2024 14:35:56 +0000

Olá pessoal tudo bem?,
Conteúdo com objetivo de explicar passo a passo o funcionamento de um script Python que autentica um usuário, lista cursos no Google Classroom e permite a adição de alunos aos cursos. Este script utiliza várias bibliotecas da API do Google para autenticação e acesso ao Google Classroom.

E com isto nos é exibido também o ID da sala criada.

Bibliotecas Utilizadas :
os.path: Para verificar a existência de arquivos.
google.auth.transport.requests.Request: Para fazer solicitações de autenticação.
google.oauth2.credentials.Credentials: Para gerenciar credenciais OAuth 2.0.
google_auth_oauthlib.flow.InstalledAppFlow: Para gerenciar o fluxo de OAuth 2.0.
googleapiclient.discovery.build: Para construir o serviço de API do Google.
googleapiclient.errors.HttpError: Para tratar erros da API do Google.



Escopos necessários para pesquisa de módulos de ensalamento :

SCOPES = [
    "https://www.googleapis.com/auth/classroom.courses.readonly",
    "https://www.googleapis.com/auth/classroom.rosters"
]

Função Principal
Definição e Objetivo
A função main() é responsável por gerenciar todo o fluxo de autenticação e execução das ações principais do script:



def main():
    """
    Código usado para poder criar e exibir as salas do Google criadas e adicionar alunos aos cursos e exibir também o ID do curso criado.
    """

Autenticação
Verificação de Credenciais Existentes:

Verifica se o arquivo token.json (contendo credenciais salvas) existe.
Se existir, carrega as credenciais a partir desse arquivo.



creds = None
if os.path.exists("token.json"):
    creds = Credentials.from_authorized_user_file("token.json", SCOPES)

*A token JSON é gerada na hora de autorizar o aplicativo para tal, existe uma, as tokens são diferentes das chaves criadas no ambiente *

**Autenticação e Renovação de Credenciais:

Se as credenciais não existem ou são inválidas, o script solicita autenticação.
Utiliza o fluxo de autenticação OAuth 2.0 para obter novas credenciais e salva em token.json.



if not creds or not creds.valid:
    if creds and creds.expired and creds.refresh_token:
        creds.refresh(Request())
    else:
        flow = InstalledAppFlow.from_client_secrets_file(
            "credentials.json", SCOPES
        )
        creds = flow.run_local_server(port=0)
    with open("token.json", "w") as token:
        token.write(creds.to_json())

*Construção do Serviço e Listagem de Cursos
*

**Construção do Serviço:

Usa as credenciais para construir o serviço da API do Google Classroom.



service = build("classroom", "v1", credentials=creds)

Listagem de Cursos:

Chama a API para listar até 1000 cursos. (lembrando que este valor de 1000, foi utilizado de exemplos, mas você pode definir qual valor quiser).
Verifica se há cursos e imprime os nomes e IDs dos cursos encontrados.



results = service.courses().list(pageSize=1000).execute()
courses = results.get("courses", [])

if not courses:
    print("No courses found.")
    return
print("Courses:")
for course in courses:
    print(f'{course["name"]} (ID: {course["id"]})')

Adição de Aluno ao Curso

Solicitação de Dados do Usuário:

Solicita ao usuário o ID do curso e o e-mail do aluno a ser adicionado.



course_id = input("Digite o ID do curso para adicionar um aluno: ")
student_email = input("Digite o e-mail do aluno: ")

Chamada da Função de Adição:

Chama a função add_student_to_course passando o serviço, o ID do curso e o e-mail do aluno.



add_student_to_course(service, course_id, student_email)

Tratamento de Erros

Qualquer erro na execução da API é capturado e impresso no console.



except HttpError as error:
    print(f"An error occurred: {error}")

Função para Adicionar Aluno

Definição e Execução

A função add_student_to_course adiciona um aluno a um curso específico:



def add_student_to_course(service, course_id, student_email):
    try:
        student = {
            'userId': student_email
        }
        student = service.courses().students().create(courseId=course_id, body=student).execute()
        print(f"Student {student_email} added to course {course_id}")
    except HttpError as error:
        print(f"An error occurred: {error}")

Passos

Criação do Corpo da Requisição:
Define o corpo da requisição com o e-mail do aluno.



student = {
    'userId': student_email
}

Chamada da API para Adicionar o Aluno:

Usa a API do Classroom para adicionar o aluno ao curso.



student = service.courses().students().create(courseId=course_id, body=student).execute()

Execução do Script

Ao executar o script, ele primeiro remove qualquer arquivo token.json existente para forçar a reautenticação, garantindo que as credenciais estão atualizadas:



if __name__ == "__main__":
    if os.path.exists("token.json"):
        os.remove("token.json")
    main()

CÓDIGO COMPLETO



import os.path
from google.auth.transport.requests import Request
from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError

# Escopos necessários para listar cursos e adicionar alunos no Google Classroom
SCOPES = [
    "https://www.googleapis.com/auth/classroom.courses.readonly",
    "https://www.googleapis.com/auth/classroom.rosters"
]

def main():
    """
    Código usado para poder criar e exibir as salas do Google criadas e adicionar alunos aos cursos.
    """
    creds = None
    if os.path.exists("token.json"):
        creds = Credentials.from_authorized_user_file("token.json", SCOPES)
    # Vai pedir autenticação 
    if not creds or not creds.valid:
        if creds and creds.expired and creds.refresh_token:
            creds.refresh(Request())
        else:
            flow = InstalledAppFlow.from_client_secrets_file(
                "credentials.json", SCOPES
            )
            creds = flow.run_local_server(port=0)
        # Salva as credenciais e mostra os cursos
        with open("token.json", "w") as token:
            token.write(creds.to_json())

    try:
        service = build("classroom", "v1", credentials=creds)

        # Chama a API Do classroom para ver os cursos deixar em 1000
        results = service.courses().list(pageSize=1000).execute()
        courses = results.get("courses", [])

        if not courses:
            print("No courses found.")
            return
        # Mostra na tela o nome dos cursos criados e salas
        print("Courses:")
        for course in courses:
            print(f'{course["name"]} (ID: {course["id"]})')

        # Adicionar aluno ao curso
        course_id = input("Digite o ID do curso para adicionar um aluno: ")
        student_email = input("Digite o e-mail do aluno: ")
        add_student_to_course(service, course_id, student_email)

    except HttpError as error:
        print(f"An error occurred: {error}")

def add_student_to_course(service, course_id, student_email):
    try:
        student = {
            'userId': student_email
        }
        student = service.courses().students().create(courseId=course_id, body=student).execute()
        print(f"Student {student_email} added to course {course_id}")
    except HttpError as error:
        print(f"An error occurred: {error}")

if __name__ == "__main__":
    # Apagar o arquivo token.json para forçar a reautenticação
    if os.path.exists("token.json"):
        os.remove("token.json")
    main()

Exibição de Imagem com ID dos Cursos

Instalando Docker, Docker -CE em VM-CORE UBUNTU

Marcus Andrade — Wed, 29 Nov 2023 02:44:13 +0000

Fala galera tudo bem?

Trazendo para vocês aqui hoje um passo a passo de como instalar o DOCKER para podermos trabalhar em vm's com interface core juntamente ao sistema operacional Linux Ubuntu.

Neste primeiro momento inicie sua VM e vá até o console de comandos ou xTERMINAL ou TERMINAL, como assim preferir chamar.

Após início de sua VM necessitamos utilizar o comando: sudo su apenas para podermos acessar às pastas raízes

Após digitar e pressionar enter ficará desta forma:

Vamos agora criar uma pasta para nossa instalação e Projeto

Criando nossa pasta mkdir nome_da_sua_pasta

Após este processo vamos listar o diretório com o comando LS

Vamos navegar para nosso diretório agora com o comando cd nome_da_sua_pasta

3.Removendo quaisquer vestígios do Docker

Vamos garantir que não possuímos nenhum vestígio do Docker instalado em nosso equipamento ou VM com o seguinte comando :

sudo apt-get remove docker docker-engine docker.io containerd runc

Podemos verificar que foi removido todo e qualquer conteúdo referente ao docker

Agora vamos instalar os componentes necessários para instalar o Docker:
sudo apt-get install apt-transport-https ca-certificates curl software-properties-common

Agora vamos instalar os componentes e chaves necessárias
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add - sudo apt-key fingerprint 0EBFCD88

Agora iremos adicionar o repositório necessário:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add - sudo apt-key fingerprint 0EBFCD88

Agora, adicionando o repositório APT
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu bionic stable" sudo apt-get update

aguarde a instalação....
Em seguida atualize
sudo apt-get update

Agora vamos instalar o nosso Docker
sudo apt-get install docker-ce

Pressione Y, para confirmar a instalação.
e aguarde

E vamos completar a instalação com o Docker Compose
sudo curl -L "https://github.com/docker/compose/releases/download/v2.15.1/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose sudo chmod +x /usr/local/bin/docker-compose

Com isto podemos ver a versão que foi instalada.
docker --version

Agora de antemão vamos iniciar nosso docker com o comando docker compose up

Aguarde o download das informações e o push

E pronto nosso docker foi iniciado

Para finalizar o processo basta utilizar o comando
docker compose down

sudo apt-get remove docker docker-engine docker.io containerd runc sudo apt-get install apt-transport-https ca-certificates curl software-properties-common curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add - sudo apt-key fingerprint 0EBFCD88 sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu bionic stable" sudo apt-get update sudo apt-get install docker-ce sudo useradd -g docker ${USER}

Obrigado por ficarem até aqui !!
Abraços
Marcus Andrade
TEC-IT BETTER SOLUTION FOR YOUR DATA

CARGA DE DADOS PYTHON PARA MYSQL USANDO MOVIDESK

Marcus Andrade — Tue, 19 Sep 2023 19:31:50 +0000

Neste processo irei demonstrar o código de como consumir e enviar dados para dentro de um banco MySQL para que seja consumido dados através de uma aplicação chamada MoviDesk.

Movidesk, ferramenta de ITSM utilizada para podermos acompanhar os chamados de nossa companhia.

O processo abaixo já está completo e funcional, comentado, necessitamos apenas alterar as conexões e nomes para podermos dar sequência nas cargas para o banco.

`import requests
import pymysql

Conexão com o banco de dados

conn = pymysql.connect(host='SEU IP OU NOME DO SERVIDOR', user='USUARIO DO AMBIENTE', password='SENHA DO AMBIENTE', db='NOME DA SUA DATABASE')
cursor = conn.cursor()

Consumir a API

response = requests.get("URL DE CHAMADA DO SEU GET")
data = response.json()

try:
for ticket in data:
for client in ticket['clients']:
for action in ticket['actions']:
cursor.execute("""
INSERT INTO TicketsSummaryConsolidado
(ticket_id, ticket_origin, ticket_ownerTeam, ticket_createdDate, ticket_subject, ticket_urgency, ticket_status,
client_id, client_personType, client_profileType, client_businessName, client_email, client_phone,
action_id, action_type, action_origin, action_description, action_htmlDescription, action_status, action_justification, action_createdDate, action_isDeleted)
VALUES
(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
ON DUPLICATE KEY UPDATE
summary_id = summary_id -- Isto é apenas um placeholder; você não está realmente atualizando nada.
""",
(ticket['id'], ticket['origin'], ticket['ownerTeam'], ticket['createdDate'], ticket['subject'], ticket['urgency'], ticket['status'],
client['id'], client['personType'], client['profileType'], client['businessName'], client['email'], client['phone'],
action['id'], action['type'], action['origin'], action['description'], action['htmlDescription'], action['status'], action['justification'], action['createdDate'], action['isDeleted']))

# Commitar as inserções
conn.commit()

finally:
# Fechar conexão
cursor.close()
conn.close()`

Enviando SMS utilizando Python e Twilio

Marcus Andrade — Mon, 06 Mar 2023 14:54:48 +0000

Olá pessoal tudo bem?, neste pequeno post irei mostrar para vocês como podemos automatizar o envio de SMS utilizando o Twilio !!

Site para acesso ao Twilio

Então vamos lá, primeiro passo devemos criar nossa conta junto a plataforma Twilio .

Após criar nossa conta e escolhermos os serviços desejados tal como, utilizar aplicações para bot e envio de SMS com python.

Vamos fazer a seguinte estruturação:

Acessar a plataforma da Twilio e buscar nossas credenciais chaves de API
Ao acessarmos a conta seremos direcionados para o painel principal, ao qual devemos buscar nossa Account SID e também nossa
Auth Token (como mencionamos outras vezes, tokens, podem ser estilo Bearer, e afins).

E buscar também nosso Twilio Phone, para podermos disparar as mensagens.

Feito isto, vamos abrir nosso VSCODE, e vamos criar dois arquivos chamados :

Keys.py e Main.py

No arquivo Key.py vamos estruturar todas as nossas chamadas e também onde iremos adicionar nossa Account SID e também o AuthToken

vamos começar da seguinte forma:

account_sid = 'Insira aqui sua Account SID'
auth_token = 'Insira aqui sua Seu Token'

twilio_number = 'Insira aqui o registro do seu número twilio'
target_number = 'Insira aqui o número ao qual deseja enviar a SMS'

Ficando então da seguinte forma:

Agora vamos ao conteúdo MAIN.PY

Vamos primeiro efetuar a instalação da lib twilio

pip install twilio

Feito isto, vamos agora montar nossa estrutura:

from twilio.rest import Client

import keys


client = Client(keys.account_sid, keys.auth_token)
message = client.messages.create(

    body="Insira aqui o que deseja que seja enviado ao destinatário",
    from_=keys.twilio_number,
    to=keys.target_number



)

print(message.body)

Feito isto agora iremos enviar nossa SMS

Ao executar, caso tenha feito corretamente verá da seguinte forma:

E em seu celular chegará desta forma:

E ao acessarmos o Twilio novamente podemos verificar todas as mensagens enviadas:

Obrigado, por lerem e acompanharem este passo a passo.

Como Integrar ChatGPT + SAP

Marcus Andrade — Sun, 26 Feb 2023 15:24:17 +0000

ara conectar o ChatGPT ao SAP, você pode seguir os seguintes passos:

Determine o tipo de integração necessária: o SAP é um sistema complexo com várias funcionalidades e módulos. Determine qual é o objetivo da integração com o ChatGPT para definir os requisitos específicos.
Selecione a plataforma de chatbot: existem várias plataformas de chatbot disponíveis, incluindo Dialogflow, Botpress, Microsoft Bot Framework e outros. Escolha a plataforma que melhor atenda às suas necessidades e habilidades.
Configure o chatbot: uma vez que você escolha a plataforma de chatbot, configure-o para atender às necessidades de integração. Configure a lógica do chatbot e suas ações, assim como as APIs e integrações que serão usadas para conectar o chatbot ao SAP.
Configure a integração com o SAP: utilize as APIs do SAP para conectar o chatbot. As APIs mais comuns são as APIs REST e OData. As APIs permitem que o chatbot se comunique com o SAP para realizar ações específicas, como consultar dados, criar pedidos, verificar status, entre outros.
Teste a integração: teste a integração para garantir que tudo está funcionando conforme o esperado. Verifique se as respostas do chatbot estão corretas, se as ações do SAP são realizadas corretamente, e se o fluxo de conversação está de acordo com o esperado.
Implemente o chatbot: após o teste, implemente o chatbot em um ambiente de produção. Teste novamente para garantir que tudo está funcionando corretamente.
Monitore e atualize: monitore o chatbot para garantir que ele está funcionando conforme o esperado e atualize-o conforme necessário para garantir que ele permaneça relevante e eficaz.

Esses são os passos básicos para conectar o ChatGPT ao SAP. É importante lembrar que a integração pode ser complexa e pode exigir habilidades específicas de desenvolvimento. Se necessário, busque a ajuda de um desenvolvedor ou consultor experiente em integração de sistemas.

PowerFX - Pelo ChatGPT

Marcus Andrade — Sun, 26 Feb 2023 14:50:17 +0000

Este artigo foi criado utilizando uma chamada via python usando Anaconda + JupyterNoteboook, a fins de educação e testes de comunicação com a API, (ressalto que este conteúdo não foi de autoria própria e sim de uma chamada via python utilizando chatgpt)

import openai
import os

openai.api_key = os.environ["sua chave de API aqui"]

def generate_response(prompt):
    completions = openai.Completion.create(
        engine="davinci",
        prompt=prompt, < sua pergunta aqui
        max_tokens=2048,
        n=1,
        stop=None,
        temperature=0.7,
    )
    message = completions.choices[0].text
    return message.strip()

Acima a chamada utilizada

A linguagem PowerFX é uma linguagem de programação de baixo código criada pela Microsoft. Ela foi projetada para permitir que usuários e desenvolvedores criem aplicativos e fluxos de trabalho de forma rápida e fácil, sem a necessidade de habilidades avançadas de codificação.

PowerFX é baseado na linguagem de programação Excel, utilizando fórmulas e funções para criar expressões que definem o comportamento dos aplicativos. Isso torna a linguagem fácil de entender para usuários familiarizados com planilhas do Excel.

Uma das principais vantagens da PowerFX é sua facilidade de uso. Ela permite que usuários e desenvolvedores criem aplicativos simplesmente arrastando e soltando componentes e conectando-os com expressões. Além disso, ela é altamente integrada com o Microsoft Power Platform, permitindo que os aplicativos criados na PowerFX sejam facilmente implantados em uma variedade de serviços e plataformas, incluindo o Microsoft Teams e o Dynamics 365.

A PowerFX também é altamente escalável e extensível. Ela pode ser usada para criar aplicativos simples de uma única página ou aplicativos complexos de várias páginas com recursos avançados, como banco de dados e integração com outras ferramentas e serviços.

Uma das principais limitações da PowerFX é que ela é uma linguagem relativamente nova e, portanto, não possui a mesma quantidade de recursos e documentação disponíveis como outras linguagens de programação mais estabelecidas. No entanto, a Microsoft está investindo em recursos para aumentar a adoção da linguagem, incluindo tutoriais, documentação e uma comunidade ativa de usuários e desenvolvedores.

Em resumo, a PowerFX é uma linguagem de programação de baixo código que oferece uma maneira fácil e rápida de criar aplicativos e fluxos de trabalho para usuários e desenvolvedores sem habilidades avançadas de codificação. É altamente integrada com o Microsoft Power Platform e pode ser usada para criar aplicativos simples e complexos com recursos avançados. Embora seja relativamente nova, a Microsoft está investindo em recursos para aumentar sua adoção e expandir sua funcionalidade.

O que é o protocolo GraphQL?

Marcus Andrade — Sun, 26 Feb 2023 14:30:47 +0000

O protocolo GraphQL é uma linguagem de consulta de API e ambiente de tempo de execução, criado pela equipe do Facebook em 2012. Ele foi projetado para ser uma alternativa mais eficiente e flexível aos protocolos tradicionais de API, como o REST. Desde então, o GraphQL foi adotado por muitas empresas, incluindo grandes empresas de tecnologia, como GitHub, Shopify e Twitter.

O GraphQL permite que os clientes solicitem apenas os dados necessários em uma única solicitação, em vez de várias solicitações para diferentes endpoints como no REST. Com o GraphQL, os clientes podem especificar as informações de que precisam e a estrutura dos dados retornados, em vez de receber todas as informações disponíveis em uma API.

Isso é possível devido ao sistema de tipos de dados do GraphQL, que permite definir os tipos de objetos e campos em uma API. Cada tipo de objeto pode ter vários campos, que podem ser escalares (como números ou strings) ou referências a outros objetos. Com o GraphQL, os clientes podem especificar quais campos de um objeto eles precisam, e a API retornará apenas esses campos.

Por exemplo, suponha que uma API forneça informações sobre usuários e suas postagens. Usando o GraphQL, um cliente pode solicitar todas as postagens de um usuário específico e apenas os campos que são relevantes, como o título e a data da postagem. A solicitação seria semelhante a esta:

A resposta seria um objeto JSON contendo apenas os campos solicitados:

O GraphQL também oferece recursos avançados, como fragmentos, que permitem que os clientes reutilizem partes de uma consulta em várias solicitações, e variáveis, que permitem que os clientes enviem valores dinâmicos para uma consulta.

Em resumo, o protocolo GraphQL é uma linguagem de consulta de API que permite que os clientes solicitem apenas os dados necessários em uma única solicitação. Ele oferece recursos avançados, como tipos de dados, fragmentos e variáveis, para tornar as consultas mais eficientes e flexíveis. Com sua adoção crescente, o GraphQL está se tornando uma ferramenta essencial para o desenvolvimento de API moderno.