Acesse a API do Trello usando scripts Python e Connect Bridge

Aí você simplesmente preenche seu nome de usuário e senha e permite o acesso ao seu Trello.

Chave para aceder ao Trello API com scripts Python rapidamente e sem a necessidade de aprender Trello API? Leia este tutorial e aprenda como é fácil com o Connect Bridge.

Trello API Python - Introdução

Ninguém gosta de aprender documentação longa e complicada para os APIs cada vez que há necessidade de aceder a ela. Este artigo descreve como aceder ao API do Trello através de scripts de linguagem Python (já experimentou na versão 3.3) sem qualquer conhecimento especializado sobre o API do Trello. Para este tutorial é necessária a plataforma de integração Connect Bridge para permitir a comunicação de dados através do Trello API usando na maior parte das vezes simples instruções SQL. As transferências de dados são feitas através da camada ODBC. Consegui isto em Python utilizando o módulo pyodbc ver. 3.0.7 x64

O que é "Connect Bridge"?

Connect Bridge é uma plataforma de integração que permite conectar qualquer software através de ODBC, drivers JDBC e Web Services com mais de 31 conectores (incluindo Trello). Os desenvolvedores podem acessar esses conectores em qualquer linguagem de programação sem a necessidade de ter experiência no sistema alvo, basicamente em minutos. O problema é que você pode usar a ferramenta para acessar não apenas o Trello API via Python, você também pode pegar/portar dados de/para MS Exchange, MS Dynamics CRM, MS SharePoint e muitos outros sistemas.

Pré-requisitos

Agora vamos passar pelo processo de desenvolvimento de um script Python simples que acessa o Trello API usando Connect Bridge através de um driver ODBC em vários passos simples:

1. Instale Connect Bridge (você pode obter teste gratuito aqui)
2. Instale o Python para Windows ver. 3.3+
3. Instale o módulo de pyodbc 3.0.7+ (Já usei o pyodbc-3.0.7.win-amd64-py3.3.exe)
4. Para facilitar a escrita & execução & depuração dos meus scripts, eu usei Eclipse Luna com pydev plugin
5. Conta de configuração para Trello em Connect Bridge (ver parágrafo abaixo)

Configuração do Connect Bridge

Após a instalação do Connect Bridge, você pode ver três aplicações:

• CB Service Controller - serve para arranque e paragem de Connect Bridge
• Ferramenta de Administração CB - aqui você pode configurar suas contas para conexão com o sistema de destino
• CB Query Analyzer - esta ferramenta serve para visualização do esquema da base de dados do sistema alvo e você pode tentar aqui facilmente as suas consultas

Então vamos criar a sua conta para o Trello. Abra a Ferramenta de Administração e na seção Contas crie uma nova conta, na combobox de conectores selecione CBTrelloConnector e clique em Authentication Wizard.

Então é só salvá-lo e temos a nossa conta.
Agora podemos usar a ferramenta CB Query Analyzer para visualizar o esquema. Precisamos adicionar uma nova conexão, como descrito na figura abaixo.

Para a ligação a partir de python script, vamos precisar de uma string de ligação a esta conta.

Para conhecer nossa string de conexão podemos simplesmente clicar com o botão direito do mouse na conexão Trello e depois clicar em "Editar conexão", no editor de conexões escolha a aba "Avançado" e copie o valor da caixa de texto "String de conexão". (Veja as fotos abaixo)

O núcleo e ao mesmo tempo o único arquivo na minha solução é o CBQuery.py. Por favor, encontre o código fonte abaixo.

 #!/usr/local/bin/python2.7
# codificação: utf-8
'''
CBQuery2 -- consultar dados de, escrever dados para SharePoint, Dynamics CRM, Exchange
CBQuery2 é um script que permite executar consultas SQL através do driver Connect Bridge ODBC

@author:     Michal Hainc
@copyright: 2014
@licença:    Apache 2.0

@contacto: michalhainc@gmail.com
@deffield actualizado: 18.8.2014
'''

sistema de importação
importar os
pyodbc de importação

de argparse import ArgumentParser
de argparse import RawDescriptionHelpFormatter

__tudo__ = []
__versão__ = 0.1
__data__ = '2014-08-15
__actualizado__ = '2014-08-15

DEBUG = 1
TESTRUN = 0
PERFIL = 0

classe CLIError(Excepção):
    "''Excepção genérica para levantar e registar diferentes erros fatais'''.
    def __init__(self, msg):
        super(CLIError).__init__(self, msg))
        self.msg = "E: %s" % msg
    def __str__(self):
        return self.msg
    def __unicode__(self):
        return self.msg

def main(argv=Nenhum): # IGNORE:C0111
    '''Opções de linha de comando'''.

    se a argv não for nenhuma:
        argv = sys.argv
    senão:
        sys.argv.extend(argv)

    program_name = os.path.basename(sys.argv[0])
    program_version = "v%s" % __version__
    program_build_date = str(__updated__)
    program_version_message = '%%(prog)s %s (%s)' % (program_version, program_build_date)
    program_shortdesc = __import__('__main__').__doc__.split("n")[1]
    program_license = '''%s

  Criado por Michal Hainc no %s.

  Licenciado ao abrigo da Licença Apache 2.0
  http://www.apache.org/licenses/LICENSE-2.0

  Distribuído numa base "AS IS" sem garantias
  ou condições de qualquer tipo, quer expressas ou implícitas.

UTILIZAÇÃO
''' % (program_shortdesc, str(__date__))

    tentar:
        # Analisador de argumentos de configuração
        parser = ArgumentParser(description=program_license, formatter_class=RawDescriptionHelpFormatter)
        parser.add_argument('connstr')
        parser.add_argument('consulta')
        
        # Argumentos do processo
        args = parser.parse_args()

        consulta = args.consulta
        connstr = args.connstr

        conn = pyodbc.connect(connstr)
        cursor = conn.cursor()
        cursor.execute(consulta)
        enquanto 1:
            fila = Nenhuma
            tentar:
                linha = cursor.fetchone()
            excepto:
                print(sys.exc_info()[1])
                pausa
            se não remar:
                pausa:
            imprimir(fila)
                        
            
    excepto KeyboardInterrupt:
        ### interrupção do teclado ###
        devolução 0
    excepto:
        print(sys.exc_info()[1])
        #indent = len(program_name) * " " " "
        #sys.stderr.write(program_name + ": " + repr(e) + "n")
        #sys.stderr.write(indent + " for help use --help")
        devolução 2

se __nome__ == "__main__":
         
    se TESTRUN:
        doctest de importação
        doctest.testmod()
    se PERFIL:
        importar cProfile
        pstats de importação
        profile_filename = 'CBQuery2_profile.txt
        cProfile.run('main()', profile_filename)
        statsfile = aberto("profile_stats.txt", "wb")
        p = pstats.Stats(profile_filename, stream=statsfile)
        stats = p.strip_dirs().sort_stats('cumulativo')
        stats.print_stats()
        statsfile.close()
        sys.exit(0)
    sys.exit(main())

• connstr (Connection string) contém a string de conexão ODBC que passamos para o módulo pyodbc para criar uma conexão ODBC armazenada na variável conn
• como próximo passo abrimos um cursor de banco de dados usando a conexão armazenada em conn
• então nós executamos a consulta SQL passada através do parâmetro de linha de comando chamado consulta
• como por último usamos um laço para ler os resultados do cursor linha por linha, quando o cursor.fetchone retorna Nenhum, nós quebramos o laço
• se ocorrer uma exceção durante a busca de ODBC, também quebramos o laço e imprimimos o problema para produzir
• se o método fetchone prosseguir e retornar uma linha de dados, iremos imprimir a linha de dados brutos para a saída para fins de demonstração (... poderia ser qualquer tipo de saída... poderíamos formatar como xml ou json, csv... ou qualquer tipo de formato de troca de dados) ou simplesmente usar o objeto da linha de dados brutos para ser usado em lógica de código adicional para realizar tarefas personalizadas

Executando o script CBQuery.py

Eu testei meu script usando o Windows PowerShell, mas você pode rodar qualquer outra shell que você goste de usar...

Sabemos que o nosso CBQuery.py aceita dois argumentos de linha de comando posicionais o "connstr" e o "query".

Podemos ver que o esquema contém uma "tabela" chamada "lista" para que possamos construir a nossa consulta como SELECCIONAR * DA lista LIMITE 10 para seleccionar as primeiras 10 entradas da lista Trello, e executando a consulta como podemos ver na nossa imagem abaixo que a consulta retornou 10 linhas na saída.

Agora podemos tentar criar um novo Cartão Trello na primeira lista 'Blank'. Usaremos para isso a consulta:

INSERIR CARTÃO (nome, idlist) VALORES ('Novo cartão', '565c0d32c75039b07e86b0b3')

Você pode ver em Trello que o novo cartão foi criado com sucesso

Restrições

Até agora tenho conseguido utilizar a ferramenta Connect Bridge apenas a partir de sistemas operativos Windows, devido ao facto do Connecting Software não fornecer nenhuma biblioteca cliente ODBC Linux (se é que isso é sequer possível). Portanto, certifique-se de jogar com seus scripts Python em uma máquina Windows.

Conclusão

Provámos que o acesso ao Trello API em Python pode ser realmente fácil utilizando a ferramenta de integração Connect Bridge. E Trello é apenas um sistema entre muitos outros que o Connect Bridge torna possível a integração. Imagine que pode aceder com segurança a APIs de software e serviços importantes como Dynamics CRM, NAV, AX, Salesforce, Exchange e muitos mais. Se estiver interessado em deixar de perder tempo a aprender centenas de páginas de documentação API cada vez que se deparar com um novo sistema alvo, pedir um teste gratuito, preços e quaisquer perguntas adicionais.

Saúde,
Ondrej

Descarregar CB_Query_Python