One place for hosting & domains

      Utilizar

      Como Utilizar APIs Web no Python 3


      Introdução

      Uma API, ou Interface de Programação de Aplicações, torna fácil para os desenvolvedores integrar um app com outro. Elas expõem alguns dos funcionamentos internos de um programa de maneira limitada.

      Você pode utilizar APIs para obter informações de outros programas ou para automatizar coisas que você faz normalmente em seu navegador. Às vezes você pode usar APIs para fazer coisas que você simplesmente não pode fazer de outra maneira. Um número surpreendente de propriedades web oferecem APIs juntamente com os websites ou apps móveis mais familiares, incluindo o Twitter, Facebook, GitHub, e DigitalOcean.

      Se você já trabalhou em alguns tutoriais sobre como programar em Python 3, e você está confortável com a sintaxe, estrutura, e algumas funções internas do Python, você pode escrever programas em Python que aproveitam as suas APIs favoritas.

      Neste guia, você aprenderá como usar o Python com a API da DigitalOcean para recuperar informações sobre sua conta na DigitalOcean. Em seguida, vamos ver como você pode aplicar o que aprendeu na API do GitHub.

      Quando terminar, você entenderá os conceitos comuns em APIs web e terá um processo passo a passo, bem como exemplos de código de trabalho que você pode usar para testar APIs de outros serviços.

      Pré-requisitos

      Antes de iniciar este guia você vai precisar do seguinte:

      O primeiro passo na utilização de uma nova API é encontrar a documentação, e se orientar. A documentação da API da DigitalOcean começa em https://developers.digitalocean.com/. Para encontrar APIs para outros serviços, pesquise pelo nome do site e “API” — nem todos os serviços promovem suas APIs em suas primeiras páginas.

      Alguns serviços tem API wrappers. Um API wrapper é o código que você instala em seu sistema para facilitar a utilização das APIs em sua linguagem de programação escolhida. Este guia não utiliza quaisquer wrappers porque eles escondem muito do funcionamento interno das APIs, e geralmente não expõem tudo o que uma API pode fazer. Os wrappers podem ser ótimos quando você deseja fazer algo rapidamente, mas ter uma sólida compreensão do que as próprias APIs podem fazer ajudará você a decidir se os wrappers fazem sentido para seus objetivos.

      Primeiro, veja a introdução sobre a API da DigitalOcean em https://developers.digitalocean.com/documentation/v2/ e tente entender apenas o básico sobre como enviar uma solicitação, e o que esperar na resposta. Neste ponto, você está tentando aprender apenas três coisas:

      1- Como é uma solicitação? São todas apenas URLs? Para solicitações mais detalhadas, como os dados são formatados? São geralmente JSON ou parâmetros de querystring como um navegador web utiliza, mas alguns usam XML ou um formato personalizado.
      2- Como é uma resposta? Os documentos da API mostrarão exemplos de solicitações e respostas. Você obterá JSON, XML, ou ou algum outro tipo de resposta?
      3- O que vai nos cabeçalhos de solicitação ou resposta? Geralmente, o cabeçalho de solicitação inclui seu token de autenticação, e os cabeçalhos de resposta fornecem informações atualizadas sobre seu uso do serviço, como quão próximo você está do limite de taxa de solicitações.

      A API da DigitalOcean usa métodos HTTP (às vezes chamados de verbos) para indicar se você está tentando ler informações existentes, criar novas informações, ou deletar algo. Esta parte da documentação explica quais métodos são utilizados, e para quais propósitos. Geralmente, uma solicitação GET é mais simples do que um POST, mas quando você terminar esse tutorial, não notará muita diferença.

      A próxima seção da documentação da API discute como o servidor responderá às suas solicitações. Em geral, uma solicitação é bem-sucedida ou falha. Quando ela falha, a causa ou é algo errado com a solicitação ou um problema com o servidor. Todas essas informações são comunicadas usando códigos de status HTTP, que são números de 3 dígitos divididos em categorias.

      • A série 200 significa “sucesso” – sua solicitação foi válida e a resposta é o que segue logicamente dela.
      • A série 400 significa “solicitação inválida” — algo estava errado com a solicitação, então o servidor não a processou como você queria. Causas comuns para erros de nível HTTP 400 são solicitações mal formatadas e problemas de autenticação.
      • A série 500 significa “erro de servidor” — seu pedido pode ter sido OK, mas o servidor não pôde dar uma boa resposta agora por motivos que estão fora do seu controle. Estes erros devem ser raros, mas você precisa estar ciente da possibilidade para poder tratá-los em seu código.

      Seu código deve sempre verificar o código de status HTTP para qualquer resposta antes de tentar fazer qualquer coisa com ele. Se você não fizer isto, você estará perdendo tempo tentando solucionar problemas com informações incompletas.

      Agora que você tem uma ideia geral de como enviar uma solicitação, e o que procurar na resposta, é hora de enviar a primeira solicitação.

      Passo 2 — Obtendo Informações da API Web

      Sua conta na DigitalOcean inclui algumas informações administrativas que você pode não ter visto na interface de usuário Web. Uma API pode lhe oferecer uma visão diferente de informações familiares. Só de ver essa visualização alternativa pode, às vezes, gerar ideias sobre o que você pode querer fazer com uma API ou revelar serviços e opções desconhecidos.

      Vamos começar criando um projeto para nossos scripts. Crie um novo diretório para o projeto chamado apis:

      Em seguida, navegue para este novo diretório:

      Crie um novo virtualenv para este projeto:

      Ative o virtualenv:

      Então instale a biblioteca requests, que iremos utilizar em nossos scripts para fazer solicitações HTTP:

      Com o ambiente configurado, crie um novo arquivo Python chamado do_get_account.py e abra-o em seu editor de textos. Comece este programa importando bibliotecas para o trabalho com solicitações JSON e HTTP.

      do_get_account.py

      
      import json
      import requests
      

      Estas declarações import carregam códigos Python que facilitam o trabalho com o formato de dados JSON e o protocolo HTTP. Estamos utilizando estas bibliotecas porque não estamos interessados nos detalhes de como enviar solicitações HTTP ou como analisar e criar um JSON válido; queremos apenas utilizá-las para realizar essas tarefas. Todos os nossos scripts neste tutorial começarão assim.

      Em seguida, queremos definir algumas variáveis para armazenar informações que serão as mesmas em todas as solicitações. Isso nos poupa de ter que digitá-las repetidas vezes, e nos fornece um único local para fazer atualizações caso algo mude. Adicione estas linhas ao arquivo após as declarações import.

      do_get_account.py

      
      ...
      api_token = 'seu_api_token'
      api_url_base = 'https://api.digitalocean.com/v2/'
      
      

      A variável api_token é uma string que armazena o seu token de API da DigitalOcean. Substitua o valor no exemplo com o seu próprio token. A variável api_url_base é a string que inicia cada URL na API da DigitalOcean. Iremos acrescentar a ela conforme necessário posteriormente no código.

      Em seguida, precisamos definir os cabeçalhos das solicitações HTTP da forma descrita na documentação da API. Adicione estas linhas ao arquivo para definir um dicionário contendo seus cabeçalhos de solicitação.

      do_get_account.py

      
      ...
      headers = {'Content-Type': 'application/json',
                 'Authorization': 'Bearer {0}'.format(api_token)}
      
      

      Isso define dois cabeçalhos ao mesmo tempo. O cabeçalho Content-Type diz ao servidor para esperar dados no formato JSON no corpo da solicitação. O cabeçalho Authorization precisa incluir nosso token, então usamos a lógica de formatação de strings do Python para inserir nossa variável api_token na string enquanto criamos a string. Poderíamos ter colocado o token aqui como uma string literal, mas separá-lo tornará várias coisas mais fáceis no futuro:

      • Se você precisar substituir o token, é mais fácil ver onde fazer isso quando ele é uma variável separada.
      • Se você quiser compartilhar seu código com alguém, é mais fácil remover seu token de API, e mais fácil para seu amigo ver onde colocar o token dele.
      • É auto documentado. Se o token da API for usado apenas como string literal, alguém que esteja lendo seu código poderá não entender o que está vendo.

      Agora que temos esses detalhes de configuração cobertos, é hora de enviar a solicitação de fato. Sua inclinação pode ser apenas começar a criar e enviar as solicitações, mas há um jeito melhor. Se você colocar essa lógica em uma função que trata o envio da solicitação e lê a resposta, você terá que pensar um pouco mais claramente sobre o que está fazendo. Você também vai acabar tendo um código mais fácil de testar e mais fácil de reutilizar. Isso é o que vamos fazer.

      Essa função usará as variáveis criadas para enviar a solicitação e retornar as informações da conta em um dicionário Python.

      Para manter a lógica clara neste estágio inicial, não faremos nenhum tratamento detalhado de erros ainda, mas adicionaremos isso em breve.

      Defina a função que busca as informações da conta. É sempre uma boa ideia nomear uma função depois do que ela faz: Esta função obtém informações da conta, então vamos chamá-la de get_account_info:

      do_get_account.py

      
      ...
      def get_account_info():
      
          api_url = '{0}account'.format(api_url_base)
      
          response = requests.get(api_url, headers=headers)
      
          if response.status_code == 200:
              return json.loads(response.content.decode('utf-8'))
          else:
              return None
      
      

      Construímos o valor para api_url usando o método de formatação de strings do Python, semelhante ao modo como o usamos nos cabeçalhos; anexamos a URL base da API na frente da string account para obter a URL https://api.digitalocean.com/v2/account, que é a URL que deve retornar as informações da conta.

      A variável response armazena um objeto criado pelo módulo Python requests. Essa linha envia a solicitação para a URL que criamos com os cabeçalhos que definimos no início do script e retorna a resposta da API.

      Em seguida, olhamos para o código de status HTTP da resposta.

      Se é 200, uma resposta bem sucedida, então usamos a função loadsdo módulo json para carregar uma string como JSON. A string que carregamos é o conteúdo do objeto response, response.content. A parte .decode('utf-8') diz ao Python que esse conteúdo está codificado usando o conjunto de caracteres UTF-8, como todas as respostas da API da DigitalOcean serão. O módulo json cria um objeto a partir disso, que usamos como o valor de retorno para esta função.

      Se a resposta não foi 200, então retornamos None, que é um valor especial no Python que podemos verificar quando chamamos essa função. Você vai notar que estamos apenas ignorando quaisquer erros neste momento. Isso é para manter a lógica do "sucesso" clara. Adicionaremos uma verificação de erros mais abrangente em breve.

      Agora chame esta função, verifique se ela obteve uma boa resposta, e imprima os detalhes retornados pela API:

      do_get_account.py

      
      ...
      account_info = get_account_info()
      
      if account_info is not None:
          print("Aqui estão suas informações: ")
          for k, v in account_info['account'].items():
              print('{0}:{1}'.format(k, v))
      
      else:
          print('[!] Solicitação inválida')
      
      

      account_info = get_account_info() define a variável account_info para o que quer que tenha voltado da chamada para get_account_info(), então ou isso vai ser o valor especial None ou será a coleta de informações sobre a conta.

      Se não for None, então imprimimos cada parte de informação em sua própria linha usando o método items()que todo dicionário Python possui.

      Do contrário (isto é, se account_info é None), imprimimos uma mensagem de erro.

      Vamos fazer uma pausa por um minuto aqui. Essa declaração if com um duplo negativo nela pode parecer estranha no começo, mas é um idioma comum em Python. Sua virtude está em manter o código que roda com sucesso muito próximo da condicional em vez de ser após os casos de tratamento de erros.

      Você pode fazer o contrário, se preferir, e pode ser um bom exercício escrever esse código por si próprio. Em vez de if account_info is not None: você pode começar com if account_info is None: e ver como o restante se encaixa.

      Salve o script e experimente:

      A saída será algo assim:

      Output

      Aqui estão suas informações: droplet_limit:25 email:sammy@digitalocean.com status:active floating_ip_limit:3 email_verified:True uuid:123e4567e89b12d3a456426655440000 status_message:

      Agora você sabe como recuperar dados de uma API. Em seguida, vamos passar para algo um pouco mais interessante - a utilização de uma API para alterar dados.

      Passo 3 — Modificando Informações no Servidor

      Depois de praticar com uma solicitação somente leitura, é hora de começar a fazer alterações. Vamos explorar isso usando Python e a API da DigitalOcean para adicionar uma chave SSH à sua conta na DigitalOcean.

      Primeiro, dê uma olhada na documentação da API para chaves SSH, disponível em https://developers.digitalocean.com/documentation/v2/#ssh-keys.

      A API lhe permite listar as chaves SSH atuais em sua conta, e também lhe permite adicionar novas chaves. A solicitação para obter uma lista de chaves SSH é muito parecida com a de obter informações da conta. A resposta é diferente, no entanto: diferentemente de uma conta, você pode ter zero, uma ou várias chaves SSH.

      Crie um novo arquivo para este script chamado do_ssh_keys.py, e comece exatamente como o último. Importe os módulos json e requests para que você não precise se preocupar com os detalhes do JSON ou do protocolo HTTP. Em seguida, adicione seu token de API da DigitalOcean como uma variável e defina os cabeçalhos da solictação em um dicionário.

      do_ssh_keys.py

      
      import json
      import requests
      
      api_token = 'seu_api_token'
      api_url_base = 'https://api.digitalocean.com/v2/'
      headers = {'Content-Type': 'application/json',
                 'Authorization': 'Bearer {0}'.format(api_token)}
      
      

      A função que criaremos para obter as chaves SSH é semelhante à que usamos para obter informações da conta, mas desta vez vamos lidar com erros mais diretamente.

      Primeiro, faremos a chamada da API e armazenaremos a resposta em uma variável de resposta response. No entanto, api_url não será o mesmo que no script anterior; desta vez ela precisa apontar para https://api.digitalocean.com/v2/account/keys.

      Adicione este código ao script:

      do_ssh_keys.py

      
      ...
      def get_ssh_keys():
      
          api_url = '{0}account/keys'.format(api_url_base)
      
          response = requests.get(api_url, headers=headers)
      
      

      Agora vamos adicionar um tratamento de erros, observando o código de status HTTP na resposta. Se for 200, retornaremos o conteúdo da resposta como um dicionário, como fizemos antes. Se for qualquer outra coisa, imprimiremos uma mensagem de erro explicativa associada ao tipo de código de status e, em seguida, retornaremos None.

      Adicione estas linhas à função get_ssh_keys:

      do_ssh_keys.py

      
      ...
      
          if response.status_code >= 500:
              print('[!] [{0}] Erro no Servidor'.format(response.status_code))
              return None
          elif response.status_code == 404:
              print('[!] [{0}] URL não encontrada: [{1}]'.format(response.status_code,api_url))
              return None  
          elif response.status_code == 401:
              print('[!] [{0}] Falha de autenticação'.format(response.status_code))
              return None
          elif response.status_code == 400:
              print('[!] [{0}] Solicitação inválida'.format(response.status_code))
              return None
          elif response.status_code >= 300:
              print('[!] [{0}] Redirecionamento inesperado'.format(response.status_code))
              return None
          elif response.status_code == 200:
              ssh_keys = json.loads(response.content.decode('utf-8'))
              return ssh_keys
          else:
              print('[?] Erro inesperado: [HTTP {0}]: Content: {1}'.format(response.status_code, response.content))
          return None
      
      

      Esse código trata seis condições de erro diferentes, observando o código de status HTTP na resposta.

      • Um código 500 ou superior indica um problema no servidor. Esses códigos devem ser raros e não são causados por problemas com a solicitação, portanto, imprimimos somente o código de status.
      • Um código 404 significa "não encontrado", que provavelmente deriva de um erro de digitação na URL. Para esse erro, imprimimos o código de status e a URL que levou até ele para que você possa ver por que ele falhou.
      • Um código 401 significa que a autenticação falhou. A causa mais provável para isso é um api_key incorreto ou ausente.
      • Um código no intervalo 300 indica um redirecionamento. A API da DigitalOcean não utiliza redirecionamentos, então isso nunca deve acontecer, mas como estamos lidando com erros, não custa nada verificar. Muitos bugs são causados por coisas que o programador acha que nunca deveriam acontecer.
      • Um código 200 significa que a solicitação foi processada com sucesso. Por isso, não imprimimos nada. Apenas retornamos as chaves SSH como um objeto JSON, utilizando a mesma sintaxe que usamos no script anterior.
      • Se o código de resposta foi qualquer outra coisa, imprimimos o código de status como um "erro inesperado".

      Isso deve tratar quaisquer erros que provavelmente receberemos ao chamar a API. Neste ponto, temos ou uma mensagem de erro e o objeto None, ou temos sucesso e um objeto JSON contendo zero ou mais chaves SSH. Nosso próximo passo é imprimi-los:

      do_ssh_keys.py

      
      ...
      
      ssh_keys = get_ssh_keys()
      
      if ssh_keys is not None:
          print('Aqui estão suas chaves: ')
          for key, details in enumerate(ssh_keys['ssh_keys']):
              print('Key {}:'.format(key))
              for k, v in details.items():
                  print('  {0}:{1}'.format(k, v))
      else:
          print('[!] A solicitação falhou')
      
      

      Como a resposta contém uma lista (ou array) de chaves SSH, queremos iterar sobre toda a lista para ver todas as chaves. Usamos o método enumerate do Python para isso. É similar ao método items disponível para dicionários, mas trabalha com listas.

      Utilizamos enumerate e não apenas um loop for, porque queremos ser capazes de dizer o quão longe na lista estamos para qualquer chave dada.

      As informações de cada chave são retornadas como um dicionário, então usamos o mesmo código for k,v in details.items(): que usamos no dicionário de informações de conta no script anterior.

      Execute este script e você obterá uma lista de chaves SSH que já estão em sua conta.

      A saída será algo assim, dependendo de quantas chaves SSH você já tem em sua conta.

      Output

      Aqui estão suas chaves: Kcy 0: id:280518 name:work fingerprint:96:f7:fb:9f:60:9c:9b:f9:a9:95:01:5c:5c:2c:d5:a0 public_key:ssh-rsa AAAAB5NzaC1yc2cAAAADAQABAAABAQCwgr9Fzc/YTD/V2Ka5I52Rx4I+V2Ka5I52Rx4Ir5LKSCqkQ1Cub+... sammy@work Kcy 1: id:290536 name:home fingerprint:90:1c:0b:ac:fa:b0:25:7c:af:ab:c5:94:a5:91:72:54 public_key:ssh-rsa AAAAB5NzaC1yc2cAAAABJQAAAQcAtTZPZmV96P9ziwyr5LKSCqkQ1CubarKfK5r7iNx0RNnlJcqRUqWqSt... sammy@home

      Agora que você pode listar as chaves SSH em sua conta, seu último script aqui será aquele que adiciona uma nova chave à lista.

      Antes de podermos adicionar uma nova chave SSH, precisamos gerar uma. Para um tratamento mais completo desta etapa, dê uma olhada no tutorial How to Set Up SSH Keys.

      Para nossos propósitos, porém, precisamos apenas de uma chave simples. Execute este comando para gerar uma nova chave no Linux, BSD ou MacOS. Você pode fazer isso em um Droplet existente, se quiser.

      Quando solicitado, digite o arquivo para salvar a chave e não forneça uma frase secreta.

      Output

      Generating public/private rsa key pair. Enter file in which to save the key (/home/sammy/.ssh/id_rsa): /home/sammy/.ssh/sammy Created directory '/home/sammy/.ssh'. Enter passphrase (empty for no passphrase): Enter same passphrase again: Your identification has been saved in /home/sammy/.ssh/sammy. Your public key has been saved in /home/sammy/.ssh/sammy.pub. ...

      Observe onde o arquivo da chave pública foi salvo, porque você precisará dele para o script.

      Inicie um novo script Python, e chame-o de add_ssh_key.py, e comece-o assim como os outros:

      add_ssh_key.py

      
      
      import json
      import requests
      
      api_token = 'seu_api_token'
      api_url_base = 'https://api.digitalocean.com/v2/'
      headers = {'Content-Type': 'application/json',
                 'Authorization': 'Bearer {0}'.format(api_token)}
      
      

      Utilizaremos uma função para fazer nossa solicitação, mas esta será ligeiramente diferente.

      Crie uma função chamada add_ssh_key que irá aceitar dois argumentos: o nome a utilizar para a nova chave SSH, e o nome do arquivo dessa chave em seu sistema local. A função irá ler o arquivo, e fazer uma solicitação HTTP POST, em vez de um GET:

      add_ssh_key.py

      
      ...
      
      def add_ssh_key(name, filename):
      
          api_url = '{0}account/keys'.format(api_url_base)
      
          with open(filename, 'r') as f:
              ssh_key = f.readline()
      
          ssh_key = {'name': name, 'public_key': ssh_key}
      
          response = requests.post(api_url, headers=headers, json=ssh_key)
      
      

      A linha with open(filename, 'r') as f: abre o arquivo no modo somente leitura, e a linha seguinte lê a primeira (e única) linha do arquivo, armazenando-a na variável ssh_key.

      Em seguida, fazemos um dicionário Python chamado ssh_key com os nomes e valores que a API espera.

      Quando enviamos a solicitação, porém, há uma novidade aqui. É um POST em vez de um GET, e precisamos enviar a ssh_key no corpo da solicitação POST, codificada como JSON. O módulo requests irá tratar dos detalhes para nós; requests.post lhe diz para usar o método POST, e json=ssh_key lhe diz para enviar a variável ssh_key no corpo da solicitação, codificada como JSON.

      De acordo com a API, a resposta será HTTP 201 para sucesso, em vez de200, e o corpo da resposta conterá os detalhes da chave que acabamos de incluir.

      Adicione o seguinte código de tratamento de erros à função add_ssh_key. Ele é semelhante ao script anterior, exceto que desta vez temos que procurar pelo código 201 em vez de200 para sucesso:

      add_ssh_key.py

      
      ...
        if response.status_code >= 500:
            print('[!] [{0}] Erro no Servidor'.format(response.status_code))
            return None
        elif response.status_code == 404:
            print('[!] [{0}] URL não encontrada: [{1}]'.format(response.status_code,api_url))
            return None
        elif response.status_code == 401:
            print('[!] [{0}] Falha de autenticação'.format(response.status_code))
            return None
        elif response.status_code >= 400:
            print('[!] [{0}] Solicitação inválida'.format(response.status_code))
            print(ssh_key )
            print(response.content )
            return None
        elif response.status_code >= 300:
            print('[!] [{0}] Redirecionamento inesperado.'.format(response.status_code))
            return None
        elif response.status_code == 201:
            added_key = json.loads(response.content)
            return added_key
        else:
            print('[?] Erro inesperado: [HTTP {0}]: Content: {1}'.format(response.status_code, response.content))
            return None
      
      

      Esta função, como as anteriores, retorna None ou o conteúdo da resposta, dessa forma usamos a mesma abordagem de antes para verificar o resultado.

      Em seguida, chame a função e processe o resultado. Passe o caminho para a sua chave SSH recém-criada como o segundo argumento.

      add_ssh_key.py

      
      ...
      add_response = add_ssh_key('tutorial_key', '/home/sammy/.ssh/sammy.pub')
      
      if add_response is not None:
          print('Sua chave foi adicionada: ' )
          for k, v in add_response.items():
              print('  {0}:{1}'.format(k, v))
      else:
          print('[!] A solicitação falhou')
      
      

      Execute este script e você receberá uma resposta informando que sua nova chave foi adicionada.

      A saída será algo assim:

      Output

      Sua chave foi adicionada: ssh_key:{'id': 9458326, 'name': 'tutorial_key', 'fingerprint': '64:76:37:77:c8:c7:26:05:f5:7b:6b:e1:bb:d6:80:da', 'public_key': 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCUtY9aizEcVJ65/O5CE6tY8Xodrkkdh9BB0GwEUE7eDKtTh4NAxVjXc8XdzCLKtdMwfSg9xwxSi3axsVWYWBUhiws0YRxxMNTHCBDsLFTJgCFC0JCmSLB5ZEnKl+Wijbqnu2r8k2NoXW5GUxNVwhYztXZkkzEMNT78TgWBjPu2Tp1qKREqLuwOsMIKt4bqozL/1tu6oociNMdLOGUqXNrXCsOIvTylt6ROF3a5UnVPXhgz0qGbQrSHvCEfuKGZ1kw8PtWgeIe7VIHbS2zTuSDCmyj1Nw1yOTHSAqZLpm6gnDo0Lo9OEA7BSFr9W/VURmTVsfE1CNGSb6c6SPx0NpoN sammy@tutorial-test'}

      Se você se esqueceu de alterar a condição de "sucesso" para procurar por HTTP 201 em vez de 200, você verá um erro relatado, mas a chave ainda terá sido adicionada. Seu tratamento de erros poderia lhe dizer que o código de status era 201. Você deve reconhecer isso como um membro da série 200, o que indica sucesso. Este é um exemplo de como o tratamento básico de erros pode simplificar a solução de problemas.

      Após adicionar a chave com sucesso usando esse script, execute-o novamente para ver o que acontece quando você tenta adicionar uma chave que já está presente.

      A API retornará uma resposta HTTP 422, que seu script traduzirá para uma mensagem dizendo "A chave SSH já está em uso em sua conta.":

      Output

      [!] [422] Solicitação inválida {'name': 'tutorial_key', 'public_key': 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCUtY9aizEcVJ65/O5CE6tY8Xodrkkdh9BB0GwEUE7eDKtTh4NAxVjXc8XdzCLKtdMwfSg9xwxSi3axsVWYWBUhiws0YRxxMNTHCBDsLFTJgCFC0JCmSLB5ZEnKl+Wijbqnu2r8k2NoXW5GUxNVwhYztXZkkzEMNT78TgWBjPu2Tp1qKREqLuwOsMIKt4bqozL/1tu6oociNMdLOGUqXNrXCsOIvTylt6ROF3a5UnVPXhgz0qGbQrSHvCEfuKGZ1kw8PtWgeIe7VIHbS2zTuSDCmyj1Nw1yOTHSAqZLpm6gnDo0Lo9OEA7BSFr9W/VURmTVsfE1CNGSb6c6SPx0NpoN sammy@tutorial-test'} b'{"id":"unprocessable_entity","message":"A chave SSH já está em uso em sua conta."}' [!] Request Failed

      Agora execute seu script get_ssh_keys.py novamente e você verá sua chave recém-adicionada na lista.

      Com pequenas modificações, esses dois scripts podem ser uma forma rápida de adicionar novas chaves SSH à sua conta da DigitalOcean sempre que você precisar. Funções relacionadas nesta API permitem que você renomeie ou exclua uma chave específica usando sua ID exclusiva de chave ou impressão digital.

      Vamos dar uma olhada em outra API e ver como as habilidades que você acabou de aprender podem ser usadas.

      O GitHub tem uma API também. Tudo o que você aprendeu sobre o uso da API da DigitalOcean é diretamente aplicável ao uso da API do GitHub.

      Familiarize-se com a API do GitHub da mesma forma que você fez com a da DigitalOcean. Pesquise a documentação da API, e localize a seção Overview. Você verá que a API do GitHub e a API da DigitalOcean compartilham algumas similaridades.

      Primeiro, você perceberá que há uma raiz comum em todas as URLs da API: https://api.github.com/. Você sabe como usar isso como uma variável em seu código para otimizar e reduzir o potencial de erros.

      A API do GitHub usa o JSON como seu formato de solicitação e resposta, assim como a DigitalOcean, assim você sabe como fazer essas solicitações e lidar com as respostas.

      As respostas incluem informações sobre os limites de taxa de solicitações nos cabeçalhos de resposta HTTP, usando quase os mesmos nomes e exatamente os mesmos valores da DigitalOcean.

      O GitHub usa o OAuth para autenticação e você pode enviar seu token em um cabeçalho de solicitação. Os detalhes desse token são um pouco diferentes, mas o modo como ele é usado é idêntico ao que você fez com a API da DigitalOcean.

      Existem algumas diferenças também. O GitHub incentiva o uso de um cabeçalho de solicitação para indicar a versão da API que você deseja usar. Você sabe como adicionar cabeçalhos às solicitações no Python.

      O GitHub também quer que você use uma string User-Agent exclusiva em solicitações, para que eles possam encontrá-lo mais facilmente se seu código estiver causando problemas. Você lidaria com isso através de um cabeçalho também.

      A API do GitHub usa os mesmos métodos de solicitação HTTP, mas também usa um novo chamado PATCH para certas operações. A API do GitHub usa GET para ler informações,POST para adicionar um novo item e PATCH para modificar um item existente. Esta solicitação PATCH é o tipo de coisa que você vai querer ficar de olho na documentação da API.

      Nem todas as chamadas da API do GitHub exigem autenticação. Por exemplo, você pode obter uma lista dos repositórios de um usuário sem precisar de um token de acesso. Vamos criar um script para fazer essa solicitação e exibir os resultados.

      Vamos simplificar o tratamento de erros neste script e usar apenas uma declaração para lidar com todos os possíveis erros. Você nem sempre precisa de código para lidar com cada tipo de erro separadamente, mas é um bom hábito fazer algo com condições de erro, apenas para lembrar que as coisas nem sempre correm do jeito que você espera.

      Crie um novo arquivo chamado github_list_repos.py em seu editor e adicione o seguinte conteúdo, que deve lhe parecer bastante familiar:

      github_list_repos.py

      
      import json
      import requests
      
      api_url_base = 'https://api.github.com/'
      headers = {'Content-Type': 'application/json',
                 'User-Agent': 'Python Student',
                 'Accept': 'application/vnd.github.v3+json'}
      
      

      As importações são as mesmas que temos utilizado. A api_url_base é onde todas as APIs do GitHub começam.

      Os cabeçalhos incluem dois dos opcionais que o GitHub menciona em sua visão geral, além daquele que diz que estamos enviando dados em formato JSON em nossa solicitação.

      Embora este seja um script pequeno, ainda definiremos uma função para manter nossa lógica modular e encapsular a lógica para fazer a solicitação. Muitas vezes, seus pequenos scripts vão se transformar em scripts maiores, por isso é bom ser cuidadoso com isso. Adicione uma função chamada get_repos que aceita um nome de usuário como seu argumento:

      github_list_repos.py

      
      
      ...
      def get_repos(username):
      
          api_url = '{}orgs/{}/repos'.format(api_url_base, username)
      
          response = requests.get(api_url, headers=headers)
      
          if response.status_code == 200:
              return (response.content)
          else:
              print('[!] HTTP {0} calling [{1}]'.format(response.status_code, api_url))
              return None
      
      

      Dentro da função, construímos a URL com a api_url_base, o nome do usuário no qual estamos interessados e as partes estáticas da URL que informam ao GitHub que queremos a lista de repositórios. Em seguida, verificamos o código de status HTTP da resposta para garantir que ele foi 200 (sucesso). Se foi bem sucedido, retornamos o conteúdo da resposta. Se não foi, então imprimimos o Código de Status real e o URL que criamos para que possamos ter uma ideia de onde podemos ter errado.

      Agora, chame a função e passe o nome de usuário do GitHub que você deseja usar. Vamos usar octokit para este exemplo. Em seguida, imprima os resultados na tela:

      github_list_repos.py

      
      
      ...
      repo_list = get_repos('octokit')
      
      if repo_list is not None:
          print(repo_list)
      else:
          print('No Repo List Found')
      
      

      Salve o arquivo e execute o script para ver os repositórios do usuário que você especificou.

      • python github_list_repos.py

      Você verá muitos dados na saída porque não analisamos a resposta como JSON neste exemplo, nem filtramos os resultados para chaves específicas. Use o que você aprendeu nos outros scripts para fazer isso. Veja os resultados que você está obtendo e veja se você pode imprimir o nome do repositório.

      Uma coisa boa sobre essas APIs do GitHub é que você pode acessar as solicitações para as quais você não precisa de autenticação diretamente no navegador. Isso permite que você compare as respostas com o que você está vendo em seus scripts. Tente visitar https://api.github.com/orgs/octokit/repos em seu navegador para ver a resposta lá.

      A essa altura, você sabe como ler a documentação e escrever o código necessário para enviar solicitações mais específicas para suportar os seus próprios objetivos com a API do GitHub.

      Você pode encontrar o código completo para todos os exemplos desse tutorial nesse repositório do GitHub.

      Conclusão

      Neste tutorial, você aprendeu a usar web APIs para dois serviços diferentes com estilos ligeiramente diferentes. Você viu a importância de incluir código de tratamento de erros para facilitar a depuração e tornar os scripts mais robustos. Você utilizou os módulos requests e json do Python para isolá-lo dos detalhes dessas tecnologias e apenas fazer o seu trabalho, e você encapsulou o processamento de solicitações e respostas em uma função para tornar seus scripts mais modulares.

      E, além disso, agora você tem um processo repetível para seguir ao aprender qualquer nova web API:

      1. Encontre a documentação e leia a introdução para entender os fundamentos de como interagir com a API.
      2. Obtenha um token de autenticação se precisar de um, e escreva um script modular com um tratamento básico de erros para enviar uma solicitação simples, responder a erros e processar a resposta.
      3. Crie as solicitações que lhe darão as informações que você quer do serviço.

      Agora, consolide esse conhecimento recém-adquirido e encontre outra API para utilizar, ou até mesmo outro recurso de uma das APIs que você usou aqui. Um projeto seu o ajudará a solidificar o que você aprendeu aqui.

      Traduzido Por Fernando Pimenta



      Source link

      Como Instalar e Utilizar o TensorFlow no Ubuntu 16.04


      Introdução

      O TensorFlow é um software open-source para machine learning criado pelo Google para treinar redes neurais. As redes neurais do TensorFlow são expressas na forma de grafos de fluxo de dados com estado. Cada nó no gráfico representa a operação realizada por redes neurais em matrizes multidimensionais. Estas matrizes multidimensionais são comumente conhecidas como “tensors” ou “tensores”, daí o nome TensorFlow.

      O TensorFlow é um sistema de software de deep learning ou aprendizagem profunda. O TensorFlow funciona bem para a recuperação de informações, conforme demonstrado pelo Google na forma como eles fazem a classificação em seu sistema de inteligência artificial de machine-learning, RankBrain. O TensorFlow pode realizar reconhecimento de imagem, como mostrado no Inception do Google, bem como reconhecimento da linguagem humana em áudio. Ele também é útil na solução de outros problemas não específicos para machine-learning, como as equações diferenciais parciais.

      A arquitetura do TensorFlow permite a implantação em várias CPUs ou GPUs em um desktop, servidor ou dispositivo móvel. Existem também extensões para integração com CUDA, uma plataforma de computação paralela da Nvidia. Isso dá aos usuários que estão implantando em uma GPU, acesso direto ao conjunto de instruções virtuais e outros elementos da GPU que são necessários para tarefas computacionais paralelas.

      Neste tutorial, você vai instalar a versão “Suporte apenas à CPU” do TensorFlow. Essa instalação é ideal para pessoas que desejam instalar e usar o TensorFlow, mas que não possuem uma placa de vídeo Nvidia ou não precisam executar aplicações de desempenho crítico.

      Você pode instalar o TensorFlow de diversas formas. cada método tem um caso de uso e um ambiente de desenvolvimento diferentes:

      • Python e Virtualenv: Nessa abordagem, você instala o TensorFlow e todos os pacotes necessários para utilizar o TensorFow em um ambiente virtual Python. Isso isola o seu ambiente TensorFlow de outros programas em Python na mesma máquina.
      • pip nativo: Nesse método, você instala o TensorFlow globalmente em seu sistema. Isso é recomendado para pessoas que querem disponibilizar o TensorFlow para todos em um sistema multiusuário. Esse método de instalação não separa o TensorFlow em um ambiente isolado e pode interferir em outras instalações ou bibliotecas do Python.
      • Docker: O Docker é um ambiente de execução de container e isola completamente o seu conteúdo dos pacotes preexistentes em seu sistema. Nesse método, você usa um container Docker que contém o TensorFlow e todas as suas dependências. Esse método é ideal para incorporar o TensorFlow a uma arquitetura de aplicações maior que já esteja usando o Docker. No entanto, o tamanho da imagem do Docker será bem grande.

      Neste tutorial, você vai instalar o TensorFlow em um ambiente virtual Python com o virtualenv. Essa abordagem, isola a instalação do TensorFlow e coloca as coisas em funcionamento rapidamente. Depois de concluir a instalação, você fará a validação executando um pequeno programa do TensorFlow e, em seguida, usando o TensorFlow para executar o reconhecimento de imagem.

      Pré-requisitos

      Antes de começar esse tutorial, você precisará do seguinte:

      Passo 1 — Instalando o TensorFlow

      Nesse passo vamos criar um ambiente virtual e instalar o TensorFlow.

      Primeiro, crie um diretório de projeto chamado tf-demo:

      Navegue até o seu diretório tf-demo recém criado:

      Em seguida crie um novo ambiente virtual chamado tensorflow-dev. Execute o seguinte comando para criar o ambiente:

      • python3 -m venv tensorflow-dev

      Isso cria um novo diretório tensorflow-dev que conterá todos os pacotes que você instalar enquanto esse ambiente estiver ativado. Ele também inclui o pip e uma versão standalone do Python.

      Agora, ative seu ambiente virtual:

      • source tensorflow-dev/bin/activate

      Uma vez ativado, você verá algo semelhante a isso no seu terminal:

      • (tensorflow-dev)username@hostname:~/tf-demo $

      Agora, você pode instalar o TensorFlow em seu ambiente virtual.

      Execute o seguinte comando para instalar e atualizar para a versão mais nova do TensorFlow disponível no PyPi:

      • pip3 install --upgrade tensorflow

      O TensorFlow irá instalar:

      Output

      Collecting tensorflow Downloading tensorflow-1.4.0-cp36-cp36m-macosx_10_11_x86_64.whl (39.3MB) 100% |████████████████████████████████| 39.3MB 35kB/s ... Successfully installed bleach-1.5.0 enum34-1.1.6 html5lib-0.9999999 markdown-2.6.9 numpy-1.13.3 protobuf-3.5.0.post1 setuptools-38.2.3 six-1.11.0 tensorflow-1.4.0 tensorflow-tensorboard-0.4.0rc3 werkzeug-0.12.2 wheel-0.30.0

      Se você quiser desativar seu ambiente virtual a qualquer momento, o comando é:

      Para reativar seu abiente mais tarde, navegue até o diretório do seu projeto e execute source tensorflow-dev/bin/activate.

      Agora que você instalou o TensorFlow, vamos nos certificar de que a instalação dele está funcionando.

      Passo 2 — Validando a Instalação

      Para validar a instalação do TensorFlow, vamos executar um programa simples nele como um usuário não-root. Vamos utilizar o clássico exemplo de iniciante "Hello, world!" como uma forma de validação. Em vez de criar um arquivo Python, criaremos esse programa usando o Console Interativo do Python.

      Para escrever o programa, inicie o seu interpretador Python:

      Você verá o seguinte prompt aparecer em seu terminal:

      >>>
      

      Esse é o prompt para o interpretador Python, e ele indica que está pronto para que você comece a digitar algumas declarações Python.

      Primeiro, digite essa linha para importar o pacote do TensorFlow e torná-lo disponível como a variável local tf. Pressione ENTER depois de digitar a linha de código:

      Em seguida, adicione esta linha de código para definir a mensagem "Hello, world!":

      • hello = tf.constant("Hello, world!")

      Depois, crie uma nova sessão do TensorFlow e a atribua à variável sess:

      Nota: Dependendo do seu ambiente, você poderá ver esta saída:

      Output

      2017-06-18 16:22:45.956946: W tensorflow/core/platform/cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use SSE4.1 instructions, but these are available on your machine and could speed up CPU computations. 2017-06-18 16:22:45.957158: W tensorflow/core/platform/cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use SSE4.2 instructions, but these are available on your machine and could speed up CPU computations. 2017-06-18 16:22:45.957282: W tensorflow/core/platform/cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use AVX instructions, but these are available on your machine and could speed up CPU computations. 2017-06-18 16:22:45.957404: W tensorflow/core/platform/cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use AVX2 instructions, but these are available on your machine and could speed up CPU computations. 2017-06-18 16:22:45.957527: W tensorflow/core/platform/cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use FMA instructions, but these are available on your machine and could speed up CPU computations.

      Isso lhe diz que você tem um instruction set que tem o potencial de ser otimizado para um desempenho melhor com o TensorFlow. Se você vir isso, poderá ignorá-lo com segurança e continuar.

      Por fim, insira essa linha de código para imprimir o resultado da execução da sessão hello do TensorFlow que você construiu em suas linhas de código anteriores:

      Você verá esta saída em seu console:

      Output

      Hello, world!

      Isso indica que tudo está funcionando e que você pode começar a utilizar o TensorFlow para fazer algo mais interessante.

      Saia do console interativo do Python pressionando CTRL+D.

      Agora vamos usar a API de reconhecimento de imagem do TensorFlow para nos familiarizarmos mais com o TensorFlow.

      Passo 3 — Usando o TensorFlow para Reconhecimento de Imagem

      Agora que o TensorFlow está instalado e que você o validou através da execução de um programa simples, vamos dar uma olhada nos recursos de reconhecimento de imagem do TensorFlow.

      Para classificar uma imagem, você precisa treinar um modelo. Depois você precisa escrever algum código para usar o modelo. Para aprender mais sobre esses conceitos dê uma olhada em An Introduction to Machine Learning.

      O TensorFlow fornece um repositório de modelos e exemplos, incluindo código e um modelo treinado para classificar imagens.

      Utilize o Git para clonar o repositório de modelos do TensorFlow a partir do GitHub dentro do seu diretório de projeto:

      • git clone https://github.com/tensorflow/models.git

      Você verá a seguinte saída enquanto o Git baixa o repositório em uma nova pasta chamada models:

      Output

      Cloning into 'models'... remote: Counting objects: 8785, done. remote: Total 8785 (delta 0), reused 0 (delta 0), pack-reused 8785 Receiving objects: 100% (8785/8785), 203.16 MiB | 24.16 MiB/s, done. Resolving deltas: 100% (4942/4942), done. Checking connectivity... done.

      Vá para o diretório models/tutorials/image/imagenet:

      • cd models/tutorials/image/imagenet

      Este diretório contém o arquivo classify_image.py que usa o TensorFlow para reconhecer imagens. Este programa faz o download de um modelo treinado de tensorflow.org em sua primeira execução. O download desse modelo requer que você tenha 200 MB de espaço livre disponível no disco.

      Neste exemplo, vamos classificar uma imagem pré-fabricada de um Panda. Execute este comando para rodar o programa classificador de imagens:

      Você verá uma saída semelhante a esta:

      Output

      giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca (score = 0.89107) indri, indris, Indri indri, Indri brevicaudatus (score = 0.00779) lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens (score = 0.00296) custard apple (score = 0.00147) earthstar (score = 0.00117)

      Você classificou sua primeira imagem usando os recursos de reconhecimento de imagem do TensorFlow.

      Se você quiser usar outra imagem, faça isso adicionando o argumento -- image_file ao seu comando python3 classify_image.py. Para o argumento, você passaria o caminho absoluto do arquivo da imagem.

      Conclusão

      Você instalou o TensorFlow em um ambiente virtual Python e validou o funcionamento do TensorFlow executando alguns exemplos. Agora você possui ferramentas que o possibilitam a exploração de tópicos adicionais, incluindo Convolutional Neural Networks e Word Embeddings.

      O guia do programador do TensorFlow é um ótimo recurso e referência para o desenvolvimento nesse software. Você pode explorar o Kaggle, um ambiente competitivo para aplicação prática de conceitos de machine learning que o colocam contra outros entusiastas de machine learning, ciência de dados e estatística. Eles têm um excelente wiki onde você pode ver e compartilhar soluções, algumas das quais estão na vanguarda das técnicas estatísticas e de machine learning.



      Source link