<commit_before>from flask import Flask, render_template, request, flash, redirect, url_for, jsonify
from flask_dropzone import Dropzone
from datetime import datetime
import json
from natsort import  natsorted, ns
import pprint
import os
import shutil
from loadClusters import *
#from script_fcs import *

app = Flask(__name__, static_folder="static")
dropzone = Dropzone(app)

# get the current folder
app.config['UPLOADED_PATH'] = os.getcwd()

@app.route('/')
def index():
    return render_template('index.html')

@app.route('/visualization')
def visualization():
    return render_template('visualization.html')

@app.route('/', methods=['GET', 'POST'])
def upload():
    if request.method == 'POST':
        path = ""
        if(request.form['name'] == 'dataset'):
            print("request dataset")
            id = str(datetime.now().strftime('%d-%m-%Y/%H:%M:%S'))
            dir = '/uploaded-data/' + id

            if not os.path.exists(app.config['UPLOADED_PATH'] + dir):
                os.makedirs(app.config['UPLOADED_PATH'] + dir)

            for f in request.files.getlist('file'):
                print("request files: ", request.files)
                f.save(os.path.join(app.config['UPLOADED_PATH'] + dir, f.filename))

            datasetlocation = app.config['UPLOADED_PATH'] + dir + '/' + f.filename
            # lê número de objetos do dataset
            with open(datasetlocation) as f:
                numObj = sum(1 for _ in f)-1

            # caso 1: rodar os algoritmos em cima do dataset
            if(request.form['partition'] == 'no'):
                print("request.form['partition'] == 'no'")
                newdirectory = False
                if not os.path.exists(app.config['UPLOADED_PATH'] + '/algResult/'):
                    os.makedirs(app.config['UPLOADED_PATH'] + '/algResult/')
                    newdirectory = True

                if(newdirectory):
                    os.makedirs(app.config['UPLOADED_PATH'] + '/algResult/' + 'cluster_mocle-1')
                    resultfolder = app.config['UPLOADED_PATH'] + '/algResult/' + 'cluster_mocle-1'
                else:
                    # ordena as pastas e pega o número da última pra saber qual o
                    # número da pasta nova
                    root, dirs, files = next(os.walk(app.config['UPLOADED_PATH'] + '/algResult/'))
                    # natsorted serve para ordenar 10+
                    newdir = int((natsorted(dirs)[-1]).split("-")[1]) + 1
                    resultfolder = app.config['UPLOADED_PATH'] + '/algResult/' + 'cluster_mocle-' + str(newdir)
                    os.makedirs(resultfolder)

                if(request.form['basicSelected'] == 'yes'):
                    print("CLUSTERING SELECTED")
                    minK = int(request.form['minKBasic'])
                    maxK = int(request.form['maxKBasic'])

                    # crossover E ou P
                    tipoDistBasic = request.form['tipoDistBasic']
                    # algorithms (1, 2, 3, 4, 5, 6, 7)
                    # se composto, vem com virgula
                    alg = request.form['alg'].split(',')
                    if len(alg) > 1:
                        for algnumber in alg:
                            resultAlg = resultfolder + '/' + algnumber
                            clustering(tipoDistBasic, numObj, minK, maxK, datasetlocation, resultAlg, int(algnumber))

                            print("RESULT FOLDER GENERATE BASIC PARTITIONS: {}".format(resultfolder))
                        dest = resultfolder+'/allPart'
                        os.makedirs(dest)
                        for root, dirs, files in os.walk(resultfolder, topdown=False):
                            for name in files:
                                print(os.path.join(root, name))
                                source = os.path.join(root, name)
                                shutil.copy(source, dest)

                    else:
                        clustering(tipoDistBasic, numObj, minK, maxK, datasetlocation, resultfolder, int(alg[0]))
                        print("RESULT FOLDER GENERATE BASIC PARTITIONS: {}".format(resultfolder))

                if(request.form['basicSelected'] == 'yes' and request.form['mocleSelected'] == 'yes'):
                    print("BASIC + MOCLE SELECTED")
                    # crossover
                    # tratar: se M = 1 ou se B = 2
                    if(request.form['tipoDistMocle'] == 'M'):
                        crossover = 1
                    else:
                        crossover = 2
                    numGen = int(request.form['numGen'])
                    nearNeigh = int(request.form['nearNeigh'])
                    minK = int(request.form['minKMocle'])
                    maxK = int(request.form['maxKMocle'])

                    trueP = os.listdir(resultfolder+'/allPart')
                    print("antes de tudo dar errado:")
                    mocle(crossover, minK, maxK, datasetlocation, resultfolder + '/allPart', resultfolder + '/allPart-mocle', resultfolder + '/allPart/'+trueP[0], nearNeigh, numGen)
                    path = loadCluster(resultfolder + '/allPart-mocle/solutionPopulation', 2)
                else:
                    path = loadCluster(resultfolder + '/allPart', 1)

                # conferir no loadClusters como o caminho tá sendo pegado
                print("path loadCluster = ", path)
                return jsonify(path)

        elif request.form['name'] == 'partition':
            print("request partition")
            #id = str(datetime.now().strftime('%d-%m-%Y/%H:%M'))

            id = 'upload-1'
            dir = '/uploaded-part/' + id
            dirAtual = app.config['UPLOADED_PATH']
            novoDir = dirAtual + dir

            if not os.path.exists(dirAtual + dir):
                os.makedirs(novoDir)
            else:
                root, dirs, files = next(os.walk(dirAtual + '/uploaded-part/'))
                print("natsorted(dirs) ", natsorted(dirs))
                newdir = int((natsorted(dirs)[-1]).split("-")[1]) + 1
                novoDir = dirAtual +'/uploaded-part/' + 'upload-' + str(newdir)
                print("diretório criado: ", novoDir)
                os.makedirs(novoDir)

            for n in request.files.getlist('datasetfile'):
                datasetlocation = novoDir
                n.save(os.path.join(datasetlocation, n.filename))
                datasetlocation += '/' + n.filename

            if not os.path.exists(novoDir + '/partition'):
                os.makedirs(novoDir + '/partition')

            keys = [k for k in request.files if k.startswith('file')]
            #print(keys)

            # loop over files since we allow multiple files
            for name in keys:
                f = request.files[name]
                #salva arquivos na pasta atual + /uploaded
                partitionlocation = novoDir + '/partition'
                f.save(os.path.join(partitionlocation, f.filename));

            # checa numero de arquivos na pasta para saber se é o ultimo post
            qtinfolder = len([name for name in os.listdir(novoDir + '/partition/') if os.path.isfile(os.path.join(novoDir + '/partition', name))])

            newdirectory = False
            if not os.path.exists(app.config['UPLOADED_PATH'] + '/algResult/'):
                os.makedirs(app.config['UPLOADED_PATH'] + '/algResult/')
                newdirectory = True

            if(newdirectory):
                os.makedirs(app.config['UPLOADED_PATH'] + '/algResult/' + 'result_mocle-1')
                # pasta para adicionar resultados tanto do clustering quanto do mocle
                resultfolder = app.config['UPLOADED_PATH'] + '/algResult/' + 'result_mocle-1'
            else:
                # pega nome das pastas e ordena, pega a ultima pasta e adiciona mais um para criar a nova
                root, dirs, files = next(os.walk(app.config['UPLOADED_PATH'] + '/algResult/'))
                newdir = int((natsorted(dirs)[-1]).split("-")[1]) + 1
                os.makedirs(app.config['UPLOADED_PATH'] + '/algResult/' + 'result_mocle-' + str(newdir))

                resultfolder = app.config['UPLOADED_PATH'] + '/algResult/' + 'result_mocle-' + str(newdir)

            # compara numero de arquivos na pasta com numero de arquivos aceitos no dropzone
            if(qtinfolder == int(request.form['qtofdata'])):
                print("Oi! Você fez upload do partitions!");

                if(request.form['mocleSelected'] == 'yes'):
                    print("MOCLE + UPLOAD SELECTED")
                    minK = int(request.form['minKMocle'])
                    maxK = int(request.form['maxKMocle'])
                    print("minK = {}, maxK = {}".format(minK, maxK))

                    # tratar: se M = 1 ou se B = 2
                    if(request.form['tipoDistMocle'] == 'M'):
                        crossover = 1
                    else:
                        crossover = 2
                    # number of generations
                    numGen = request.form['numGen']
                    # nearest neighbours
                    nearNeigh = request.form['nearNeigh']
                    mocle(crossover, minK, maxK, datasetlocation, partitionlocation, resultfolder, datasetlocation, nearNeigh, numGen)
                    path = loadCluster(resultfolder+'/solutionPopulation', 2)
                else:
                    path = loadCluster(partitionlocation, 1)

                print("path loadCluster: ", path)
                return jsonify(path)
    return "Erro"

#!/usr/bin/env python
#-*- coding: utf-8 -*-
# Script para criar as pastas necessárias e rodar os algoritmos de
# clusterização
#
import subprocess

def clustering(tipoDist, numObj, minK, maxK, dataset, expDir, alg):
    """
    Parâmetros:
    ----------
        tipoDist :  char
            E para distância Euclidiana
            P para correlação de Pearson
        numObj  :   int
            número de objetos
        minK    :   int
            número mínimo de clusters
            número máximo de clusters
        dataset :   string
            caminho absoluto para o arquivo com o dataset
        expDir  :   string
            caminho absoluto para o diretório com os resultados
        alg     :   int
            algoritmo de clusterização que será rodado
            1 - todos os algoritmos
            2 - SL
            3 - AL
            4 - CeL
            5 - CoL
            6 - SNN
            7 - KM
    Retorno:
    --------
        todos os arquivos .clu são gerados em subdiretórios, identificados pelo
        algoritmo selecionado, na pasta expDir
    """
    args = ['/home/lasid/programs/clustering/./clustering', tipoDist, numObj, minK, maxK, dataset, expDir, alg]
    processo = ""

    for item in args:
        processo += str(item)
        processo += " "

    subprocess.call(processo, shell=True)
    return

def mocle(crossover, minK, maxK, dataset, popIniDir, resultDir, truePartition, nearNeigh, numGem):
    """
    Parâmetros
    ---------
        crossover  :  int
            1 - mcla
            2 - bipartite
        minK, maxK :  int
        dataset    :  string
            caminho absoluto pro arquivo de dataset
        popIniDir  :  string
            caminho absoluto pro arquivo de população inicial
        resultDir  :  string
            caminho absoluto pro arquivo de resultados
        truePartition : fake
            é inútil
    """
    """
    Usage: ./mocle <Crossover Type: 1- mcla or 2 - bipartite> <minK> <maxK> <Dataset> <Initial Population Directory> <Results Directory> <True Partition (can be a fake one if not known)> [L - Percentage of the number of neighbors for calculating the connectivity - default = 5%] [G - Number of generations - defauld = 100]
    """
    args = ['/home/lasid/programs/MOCLE-v3/./mocle', crossover, minK, maxK, dataset, popIniDir+'/', resultDir+'/', truePartition, nearNeigh, numGem]
    processo = ""

    for item in args:
        processo += str(item)
        processo += " "

    retorno = subprocess.call(processo, shell=True)
    return 1

if __name__ == '__main__':
    app.run(debug=True)
    app.config['TRAP_BAD_REQUEST_ERRORS'] = True
<commit_msg>é isso gente agora deu certo<commit_after>from flask import Flask, render_template, request, flash, redirect, url_for, jsonify
from flask_dropzone import Dropzone
from datetime import datetime
import json
from natsort import  natsorted, ns
import pprint
import os
import shutil
from loadClusters import *
#from script_fcs import *

app = Flask(__name__, static_folder="static")
dropzone = Dropzone(app)

# get the current folder
app.config['UPLOADED_PATH'] = os.getcwd()

@app.route('/')
def index():
    return render_template('index.html')

@app.route('/visualization')
def visualization():
    return render_template('visualization.html')

@app.route('/', methods=['GET', 'POST'])
def upload():
    if request.method == 'POST':
        path = ""
        if(request.form['name'] == 'dataset'):
            print("request dataset")
            id = str(datetime.now().strftime('%d-%m-%Y/%H:%M:%S'))
            dir = '/uploaded-data/' + id

            if not os.path.exists(app.config['UPLOADED_PATH'] + dir):
                os.makedirs(app.config['UPLOADED_PATH'] + dir)

            for f in request.files.getlist('file'):
                print("request files: ", request.files)
                f.save(os.path.join(app.config['UPLOADED_PATH'] + dir, f.filename))

            datasetlocation = app.config['UPLOADED_PATH'] + dir + '/' + f.filename
            # lê número de objetos do dataset
            with open(datasetlocation) as f:
                numObj = sum(1 for _ in f)-1

            # caso 1: rodar os algoritmos em cima do dataset
            if(request.form['partition'] == 'no'):
                print("request.form['partition'] == 'no'")
                newdirectory = False
                if not os.path.exists(app.config['UPLOADED_PATH'] + '/algResult/'):
                    os.makedirs(app.config['UPLOADED_PATH'] + '/algResult/')
                    newdirectory = True

                if(newdirectory):
                    os.makedirs(app.config['UPLOADED_PATH'] + '/algResult/' + 'cluster_mocle-1')
                    resultfolder = app.config['UPLOADED_PATH'] + '/algResult/' + 'cluster_mocle-1'
                else:
                    # ordena as pastas e pega o número da última pra saber qual o
                    # número da pasta nova
                    root, dirs, files = next(os.walk(app.config['UPLOADED_PATH'] + '/algResult/'))
                    # natsorted serve para ordenar 10+
                    newdir = int((natsorted(dirs)[-1]).split("-")[1]) + 1
                    resultfolder = app.config['UPLOADED_PATH'] + '/algResult/' + 'cluster_mocle-' + str(newdir)
                    os.makedirs(resultfolder)

                if(request.form['basicSelected'] == 'yes'):
                    print("CLUSTERING SELECTED")
                    minK = int(request.form['minKBasic'])
                    maxK = int(request.form['maxKBasic'])

                    # crossover E ou P
                    tipoDistBasic = request.form['tipoDistBasic']
                    # algorithms (1, 2, 3, 4, 5, 6, 7)
                    # se composto, vem com virgula
                    alg = request.form['alg'].split(',')
                    if len(alg) > 1:
                        dest = resultfolder+'/allPart'
                        os.makedirs(dest)
                        for algnumber in alg:
                            resultAlg = resultfolder + '/' + algnumber
                            clustering(tipoDistBasic, numObj, minK, maxK, datasetlocation, resultAlg, int(algnumber))

                            print("resulAlg: ", resultAlg)
                            for files in os.listdir(resultAlg+'/allPart'):
                                source = os.path.join(resultAlg+'/allPart',files)
                                shutil.copy(source, dest)
                            print("RESULT FOLDER GENERATE BASIC PARTITIONS: {}".format(resultfolder))
                    else:
                        clustering(tipoDistBasic, numObj, minK, maxK, datasetlocation, resultfolder, int(alg[0]))
                        print("RESULT FOLDER GENERATE BASIC PARTITIONS: {}".format(resultfolder))

                if(request.form['basicSelected'] == 'yes' and request.form['mocleSelected'] == 'yes'):
                    print("BASIC + MOCLE SELECTED")
                    # crossover
                    # tratar: se M = 1 ou se B = 2
                    if(request.form['tipoDistMocle'] == 'M'):
                        crossover = 1
                    else:
                        crossover = 2
                    numGen = int(request.form['numGen'])
                    nearNeigh = int(request.form['nearNeigh'])
                    minK = int(request.form['minKMocle'])
                    maxK = int(request.form['maxKMocle'])

                    trueP = os.listdir(resultfolder+'/allPart')
                    print("antes de tudo dar errado:")
                    mocle(crossover, minK, maxK, datasetlocation, resultfolder + '/allPart', resultfolder + '/allPart-mocle', resultfolder + '/allPart/'+trueP[0], nearNeigh, numGen)
                    path = loadCluster(resultfolder + '/allPart-mocle/solutionPopulation', 2)
                else:
                    path = loadCluster(resultfolder + '/allPart', 1)

                # conferir no loadClusters como o caminho tá sendo pegado
                print("path loadCluster = ", path)
                return jsonify(path)

        elif request.form['name'] == 'partition':
            print("request partition")
            #id = str(datetime.now().strftime('%d-%m-%Y/%H:%M'))

            id = 'upload-1'
            dir = '/uploaded-part/' + id
            dirAtual = app.config['UPLOADED_PATH']
            novoDir = dirAtual + dir

            if not os.path.exists(dirAtual + dir):
                os.makedirs(novoDir)
            else:
                root, dirs, files = next(os.walk(dirAtual + '/uploaded-part/'))
                print("natsorted(dirs) ", natsorted(dirs))
                newdir = int((natsorted(dirs)[-1]).split("-")[1]) + 1
                novoDir = dirAtual +'/uploaded-part/' + 'upload-' + str(newdir)
                print("diretório criado: ", novoDir)
                os.makedirs(novoDir)

            for n in request.files.getlist('datasetfile'):
                datasetlocation = novoDir
                n.save(os.path.join(datasetlocation, n.filename))
                datasetlocation += '/' + n.filename

            if not os.path.exists(novoDir + '/partition'):
                os.makedirs(novoDir + '/partition')

            keys = [k for k in request.files if k.startswith('file')]
            #print(keys)

            # loop over files since we allow multiple files
            for name in keys:
                f = request.files[name]
                #salva arquivos na pasta atual + /uploaded
                partitionlocation = novoDir + '/partition'
                f.save(os.path.join(partitionlocation, f.filename));

            # checa numero de arquivos na pasta para saber se é o ultimo post
            qtinfolder = len([name for name in os.listdir(novoDir + '/partition/') if os.path.isfile(os.path.join(novoDir + '/partition', name))])

            newdirectory = False
            if not os.path.exists(app.config['UPLOADED_PATH'] + '/algResult/'):
                os.makedirs(app.config['UPLOADED_PATH'] + '/algResult/')
                newdirectory = True

            if(newdirectory):
                os.makedirs(app.config['UPLOADED_PATH'] + '/algResult/' + 'result_mocle-1')
                # pasta para adicionar resultados tanto do clustering quanto do mocle
                resultfolder = app.config['UPLOADED_PATH'] + '/algResult/' + 'result_mocle-1'
            else:
                # pega nome das pastas e ordena, pega a ultima pasta e adiciona mais um para criar a nova
                root, dirs, files = next(os.walk(app.config['UPLOADED_PATH'] + '/algResult/'))
                newdir = int((natsorted(dirs)[-1]).split("-")[1]) + 1
                os.makedirs(app.config['UPLOADED_PATH'] + '/algResult/' + 'result_mocle-' + str(newdir))

                resultfolder = app.config['UPLOADED_PATH'] + '/algResult/' + 'result_mocle-' + str(newdir)

            # compara numero de arquivos na pasta com numero de arquivos aceitos no dropzone
            if(qtinfolder == int(request.form['qtofdata'])):
                print("Oi! Você fez upload do partitions!");

                if(request.form['mocleSelected'] == 'yes'):
                    print("MOCLE + UPLOAD SELECTED")
                    minK = int(request.form['minKMocle'])
                    maxK = int(request.form['maxKMocle'])
                    print("minK = {}, maxK = {}".format(minK, maxK))

                    # tratar: se M = 1 ou se B = 2
                    if(request.form['tipoDistMocle'] == 'M'):
                        crossover = 1
                    else:
                        crossover = 2
                    # number of generations
                    numGen = request.form['numGen']
                    # nearest neighbours
                    nearNeigh = request.form['nearNeigh']
                    mocle(crossover, minK, maxK, datasetlocation, partitionlocation, resultfolder, datasetlocation, nearNeigh, numGen)
                    path = loadCluster(resultfolder+'/solutionPopulation', 2)
                else:
                    path = loadCluster(partitionlocation, 1)

                print("path loadCluster: ", path)
                return jsonify(path)
    return "Erro"

#!/usr/bin/env python
#-*- coding: utf-8 -*-
# Script para criar as pastas necessárias e rodar os algoritmos de
# clusterização
#
import subprocess

def clustering(tipoDist, numObj, minK, maxK, dataset, expDir, alg):
    """
    Parâmetros:
    ----------
        tipoDist :  char
            E para distância Euclidiana
            P para correlação de Pearson
        numObj  :   int
            número de objetos
        minK    :   int
            número mínimo de clusters
            número máximo de clusters
        dataset :   string
            caminho absoluto para o arquivo com o dataset
        expDir  :   string
            caminho absoluto para o diretório com os resultados
        alg     :   int
            algoritmo de clusterização que será rodado
            1 - todos os algoritmos
            2 - SL
            3 - AL
            4 - CeL
            5 - CoL
            6 - SNN
            7 - KM
    Retorno:
    --------
        todos os arquivos .clu são gerados em subdiretórios, identificados pelo
        algoritmo selecionado, na pasta expDir
    """
    args = ['/home/lasid/programs/clustering/./clustering', tipoDist, numObj, minK, maxK, dataset, expDir, alg]
    processo = ""

    for item in args:
        processo += str(item)
        processo += " "

    subprocess.call(processo, shell=True)
    return

def mocle(crossover, minK, maxK, dataset, popIniDir, resultDir, truePartition, nearNeigh, numGem):
    """
    Parâmetros
    ---------
        crossover  :  int
            1 - mcla
            2 - bipartite
        minK, maxK :  int
        dataset    :  string
            caminho absoluto pro arquivo de dataset
        popIniDir  :  string
            caminho absoluto pro arquivo de população inicial
        resultDir  :  string
            caminho absoluto pro arquivo de resultados
        truePartition : fake
            é inútil
    """
    """
    Usage: ./mocle <Crossover Type: 1- mcla or 2 - bipartite> <minK> <maxK> <Dataset> <Initial Population Directory> <Results Directory> <True Partition (can be a fake one if not known)> [L - Percentage of the number of neighbors for calculating the connectivity - default = 5%] [G - Number of generations - defauld = 100]
    """
    args = ['/home/lasid/programs/MOCLE-v3/./mocle', crossover, minK, maxK, dataset, popIniDir+'/', resultDir+'/', truePartition, nearNeigh, numGem]
    processo = ""

    for item in args:
        processo += str(item)
        processo += " "

    retorno = subprocess.call(processo, shell=True)
    return 1

if __name__ == '__main__':
    app.run(debug=True)
    app.config['TRAP_BAD_REQUEST_ERRORS'] = True
<|endoftext|>


<commit_before># -*- coding: utf-8 -*-

from flask import Flask, render_template, jsonify, request, Response, url_for
from functools import wraps
import json
import sys
import logging
import os
import graph
import personal
import requests
import shutil

# DEBUG = False
DEBUG = True

app = Flask(__name__)

def get_request(payload):
    payload['acl:consumerKey'] = os.environ["FRAMEWORX_KEY"]
    return requests.get("https://api.frameworxopendata.jp/api/v3/datapoints", params=payload)

def write_data(data_type):
    payload = {'rdf:type': "frameworx:" + data_type}
    data = get_request(payload)
    with open(data_type + ".json", 'w') as f:
        json.dump(data.json(), f)

def write_map(map_name):
    payload = {'acl:consumerKey': os.environ["FRAMEWORX_KEY"]}
    r = requests.get("https://api.frameworxopendata.jp/api/v3/files/" + map_name, params=payload, stream=True)
    if r.status_code == 200:
        with open(map_name, 'wb') as f:
            r.raw.decode_content = True
            shutil.copyfileobj(r.raw, f)

def read_data(data_type):
    with open(data_type + ".json", 'r') as f:
        data = json.load(f)
    return data

def check_auth(username, password):
    return username == os.environ["APP_USER"] and password == os.environ["APP_PASS"]

def authenticate():
    return Response(
        'Could not verify your access level for that URL.\n',
        401,
        {'WWW-Authenticate': 'Basic realm="Login Required"'})

def requires_auth(f):
    @wraps(f)
    def decorated(*args, **kwargs):
        auth = request.authorization
        if not auth or not check_auth(auth.username, auth.password):
            return authenticate()
        return f(*args, **kwargs)
    return decorated

@app.route('/_get_personal_data', methods=["POST"])
@requires_auth
def _get_personal_data():
    workerId = int(request.json[u'workerId'])
    category = request.json[u'category']
    data = personal.get_data(workerId, category)
    return jsonify(data=json.dumps(data))

@app.route('/_step_graph', methods=["GET", "POST"])
@requires_auth
def _step_graph():
    return jsonify({"test": "aaa"})

@app.route('/_item_ranking', methods=["GET"])
@requires_auth
def _item_ranking():
    return jsonify(graph.getTotalItemNumData(os.environ["FRAMEWORX_KEY"]))

@app.route('/_cal_ranking', methods=["GET"])
@requires_auth
def _cal_ranking():
    return jsonify(graph.getVitalData(os.environ["FRAMEWORX_KEY"], "calorie"))

@app.route('/_step_ranking', methods=["GET"])
@requires_auth
def _step_ranking():
    return jsonify(graph.getVitalData(os.environ["FRAMEWORX_KEY"], "step"))

@app.route('/_get_key', methods=["GET"])
@requires_auth
def _get_key():
    return jsonify({"key": os.environ["FRAMEWORX_KEY"]})

@app.route("/")
@requires_auth
def index():
    return render_template("index.html")

@app.route("/index.html")
@requires_auth
def index_2():
    return render_template("index.html")

@app.route("/log.html")
@requires_auth
def log_page():
    return render_template("log.html")

@app.route("/ranking.html")
@requires_auth
def ranking_page():
    return render_template("ranking.html")

if __name__ == "__main__":
    for data_type in ["WarehouseVital", "WarehouseActivity"]:
        if not os.path.exists(data_type + ".json"):
            write_data(data_type)

    for map_name in ["warehouse_map_1.jpg", "warehouse_map_2.jpg"]:
        if not os.path.exists(map_name):
            write_map(map_name)

    app.debug = True
    app.logger.addHandler(logging.StreamHandler(sys.stdout))
    if DEBUG:
        app.run(host="0.0.0.0", debug=True)
    else:
        app.run(debug=True)<commit_msg>不要な処理を削除<commit_after># -*- coding: utf-8 -*-

from flask import Flask, render_template, jsonify, request, Response, url_for
from functools import wraps
import json
import sys
import logging
import os
import graph
import personal
import requests
import shutil

# DEBUG = False
DEBUG = True

app = Flask(__name__)

def get_request(payload):
    payload['acl:consumerKey'] = os.environ["FRAMEWORX_KEY"]
    return requests.get("https://api.frameworxopendata.jp/api/v3/datapoints", params=payload)

def write_data(data_type):
    payload = {'rdf:type': "frameworx:" + data_type}
    data = get_request(payload)
    with open(data_type + ".json", 'w') as f:
        json.dump(data.json(), f)

def write_map(map_name):
    payload = {'acl:consumerKey': os.environ["FRAMEWORX_KEY"]}
    r = requests.get("https://api.frameworxopendata.jp/api/v3/files/" + map_name, params=payload, stream=True)
    if r.status_code == 200:
        with open(map_name, 'wb') as f:
            r.raw.decode_content = True
            shutil.copyfileobj(r.raw, f)

def read_data(data_type):
    with open(data_type + ".json", 'r') as f:
        data = json.load(f)
    return data

def check_auth(username, password):
    return username == os.environ["APP_USER"] and password == os.environ["APP_PASS"]

def authenticate():
    return Response(
        'Could not verify your access level for that URL.\n',
        401,
        {'WWW-Authenticate': 'Basic realm="Login Required"'})

def requires_auth(f):
    @wraps(f)
    def decorated(*args, **kwargs):
        auth = request.authorization
        if not auth or not check_auth(auth.username, auth.password):
            return authenticate()
        return f(*args, **kwargs)
    return decorated

@app.route('/_get_personal_data', methods=["POST"])
@requires_auth
def _get_personal_data():
    workerId = int(request.json[u'workerId'])
    category = request.json[u'category']
    data = personal.get_data(workerId, category)
    return jsonify(data=json.dumps(data))

@app.route('/_step_graph', methods=["GET", "POST"])
@requires_auth
def _step_graph():
    return jsonify({"test": "aaa"})

@app.route('/_item_ranking', methods=["GET"])
@requires_auth
def _item_ranking():
    return jsonify(graph.getTotalItemNumData(os.environ["FRAMEWORX_KEY"]))

@app.route('/_cal_ranking', methods=["GET"])
@requires_auth
def _cal_ranking():
    return jsonify(graph.getVitalData(os.environ["FRAMEWORX_KEY"], "calorie"))

@app.route('/_step_ranking', methods=["GET"])
@requires_auth
def _step_ranking():
    return jsonify(graph.getVitalData(os.environ["FRAMEWORX_KEY"], "step"))

@app.route('/_get_key', methods=["GET"])
@requires_auth
def _get_key():
    return jsonify({"key": os.environ["FRAMEWORX_KEY"]})

@app.route("/")
@requires_auth
def index():
    return render_template("index.html")

@app.route("/index.html")
@requires_auth
def index_2():
    return render_template("index.html")

@app.route("/log.html")
@requires_auth
def log_page():
    return render_template("log.html")

@app.route("/ranking.html")
@requires_auth
def ranking_page():
    return render_template("ranking.html")

if __name__ == "__main__":
    app.debug = True
    app.logger.addHandler(logging.StreamHandler(sys.stdout))
    if DEBUG:
        app.run(host="0.0.0.0", debug=True)
    else:
        app.run(debug=True)
<|endoftext|>


<commit_before>import argparse
import os
import time
import logging
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.optim
import torch.utils.data
import models
from torch.autograd import Variable
from data import get_dataset
from preprocess import get_transform
from utils import *
from datetime import datetime
from ast import literal_eval
from torchvision.utils import save_image

model_names = sorted(name for name in models.__dict__
    if name.islower() and not name.startswith("__")
    and callable(models.__dict__[name]))

parser = argparse.ArgumentParser(description='PyTorch ConvNet Training')

parser.add_argument('--results_dir', metavar='RESULTS_DIR', default='./results',
                    help='results dir')
parser.add_argument('--save', metavar='SAVE', default='',
                    help='saved folder')
parser.add_argument('--dataset', metavar='DATASET', default='imagenet',
                    help='dataset name or folder')
parser.add_argument('--model', '-a', metavar='MODEL', default='alexnet',
                    choices=model_names,
                    help='model architecture: ' +
                        ' | '.join(model_names) +
                        ' (default: alexnet)')
parser.add_argument('--input_size', type=int, default=None,
                    help='image input size')
parser.add_argument('--model_config', default='',
                    help='additional architecture configuration')
parser.add_argument('--type', default='torch.cuda.FloatTensor',
                    help='type of tensor - e.g torch.cuda.HalfTensor')
parser.add_argument('--gpus', default='0',
                    help='gpus used for training - e.g 0,1,3')
parser.add_argument('-j', '--workers', default=8, type=int, metavar='N',
                    help='number of data loading workers (default: 8)')
parser.add_argument('--epochs', default=90, type=int, metavar='N',
                    help='number of total epochs to run')
parser.add_argument('--start-epoch', default=0, type=int, metavar='N',
                    help='manual epoch number (useful on restarts)')
parser.add_argument('-b', '--batch-size', default=256, type=int,
                    metavar='N', help='mini-batch size (default: 256)')
parser.add_argument('--optimizer', default='SGD', type=str, metavar='OPT',
                    help='optimizer function used')
parser.add_argument('--lr', '--learning_rate', default=0.1, type=float,
                    metavar='LR', help='initial learning rate')
parser.add_argument('--momentum', default=0.9, type=float, metavar='M',
                    help='momentum')
parser.add_argument('--weight-decay', '--wd', default=1e-4, type=float,
                    metavar='W', help='weight decay (default: 1e-4)')
parser.add_argument('--print-freq', '-p', default=10, type=int,
                    metavar='N', help='print frequency (default: 10)')
parser.add_argument('--resume', default='', type=str, metavar='PATH',
                    help='path to latest checkpoint (default: none)')
parser.add_argument('-e', '--evaluate', type=str, metavar='FILE',
                    help='evaluate model FILE on validation set')

def main():
    global args, best_prec1
    best_prec1 = 0
    args = parser.parse_args()

    if args.evaluate:
        args.results_dir = '/tmp'
    if args.save is '':
        args.save = datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
    save_path = os.path.join(args.results_dir, args.save)
    if not os.path.exists(save_path):
        os.makedirs(save_path)

    setup_logging(os.path.join(save_path, 'log.txt'))
    results_file = os.path.join(save_path, 'results.%s')
    results = ResultsLog(results_file % 'csv', results_file % 'html')

    logging.info("saving to %s", save_path)
    logging.debug("run arguments: %s", args)

    if 'cuda' in args.type:
        args.gpus = [int(i) for i in args.gpus.split(',')]
        torch.cuda.set_device(args.gpus[0])
        cudnn.benchmark = True
    else:
        args.gpus = None

    # create model
    logging.info("creating model %s", args.model)
    model = model = models.__dict__[args.model]
    model_config = {'input_size': args.input_size, 'dataset': args.dataset}

    if args.model_config is not '':
        model_config = dict(model_config, **literal_eval(args.model_config))

    model = model(**model_config)
    logging.info("created model with configuration: %s", model_config)

    # optionally resume from a checkpoint
    if args.evaluate:
        if not os.path.isfile(args.evaluate):
            parser.error('invalid checkpoint: {}'.format(args.evaluate))
        checkpoint = torch.load(args.evaluate)
        model.load_state_dict(checkpoint['state_dict'])
        logging.info("loaded checkpoint '%s' (epoch %s)",
                 args.evaluate, checkpoint['epoch'])
    elif args.resume:
        checkpoint_file = args.resume
        if os.path.isdir(checkpoint_file):
            results.load(os.path.join(checkpoint_file, 'results.csv'))
            checkpoint_file = os.path.join(checkpoint_file, 'model_best.pth.tar')
        if os.path.isfile(checkpoint_file):
            logging.info("loading checkpoint '%s'", args.resume)
            checkpoint = torch.load(checkpoint_file)
            args.start_epoch = checkpoint['epoch']-1
            best_prec1 = checkpoint['best_prec1']
            model.load_state_dict(checkpoint['state_dict'])
            logging.info("loaded checkpoint '%s' (epoch %s)",
                    checkpoint_file, checkpoint['epoch'])
        else:
            logging.error("no checkpoint found at '%s'", args.resume)

    num_parameters = sum([l.nelement() for l in model.parameters()])
    logging.info("number of parameters: %d", num_parameters)

    # Data loading code
    default_transform = {
        'train': get_transform(args.dataset,
                               input_size=args.input_size, augment=True),
        'eval': get_transform(args.dataset,
                              input_size=args.input_size, augment=False)
    }
    transform = getattr(model, 'input_transform', default_transform)
    regime = getattr(model, 'regime', {0: {'optimizer': args.optimizer,
                                           'lr': args.lr,
                                           'momentum': args.momentum,
                                           'weight_decay': args.weight_decay}})
    # define loss function (criterion) and optimizer
    criterion = getattr(model, 'criterion', nn.CrossEntropyLoss)()
    criterion.type(args.type)
    model.type(args.type)

    val_data = get_dataset(args.dataset, 'val', transform['eval'])
    val_loader = torch.utils.data.DataLoader(
        val_data,
        batch_size=args.batch_size, shuffle=False,
        num_workers=args.workers, pin_memory=True)

    if args.evaluate:
        validate(val_loader, model, criterion, 0)
        return

    train_data = get_dataset(args.dataset, 'train', transform['train'])
    train_loader = torch.utils.data.DataLoader(
        train_data,
        batch_size=args.batch_size, shuffle=True,
        num_workers=args.workers, pin_memory=True)

    optimizer = torch.optim.SGD(model.parameters(), lr=args.lr)
    logging.info('training regime: %s', regime)

    for epoch in range(args.start_epoch, args.epochs):
        optimizer = adjust_optimizer(optimizer, epoch, regime)

        # train for one epoch
        train_loss, train_prec1, train_prec5 = train(
            train_loader, model, criterion, epoch, optimizer)

        # evaluate on validation set
        val_loss, val_prec1, val_prec5 = validate(
            val_loader, model, criterion, epoch)

        # remember best prec@1 and save checkpoint
        is_best = val_prec1 > best_prec1
        best_prec1 = max(val_prec1, best_prec1)
        save_checkpoint({
            'epoch': epoch + 1,
            'model': args.model,
            'config': args.model_config,
            'state_dict': model.state_dict(),
            'best_prec1': best_prec1,
            'regime': regime
        }, is_best, path=save_path)
        logging.info('\n Epoch: {0}\t'
                 'Training Loss {train_loss:.4f} \t'
                 'Training Prec@1 {train_prec1:.3f} \t'
                 'Training Prec@5 {train_prec5:.3f} \t'
                 'Validation Loss {val_loss:.4f} \t'
                 'Validation Prec@1 {val_prec1:.3f} \t'
                 'Validation Prec@5 {val_prec5:.3f} \n'
                 .format(epoch + 1, train_loss=train_loss, val_loss=val_loss,
                         train_prec1=train_prec1, val_prec1=val_prec1,
                         train_prec5=train_prec5, val_prec5=val_prec5))

        results.add(epoch=epoch + 1, train_loss=train_loss, val_loss=val_loss,
                    train_error1=100 - train_prec1, val_error1=100 - val_prec1,
                    train_error5=100 - train_prec5, val_error5=100 - val_prec5)
        results.plot(x='epoch', y=['train_loss', 'val_loss'],
                     title='Loss', ylabel='loss')
        results.plot(x='epoch', y=['train_error1', 'val_error1'],
                     title='Error@1', ylabel='error %')
        results.plot(x='epoch', y=['train_error5', 'val_error5'],
                     title='Error@5', ylabel='error %')
        results.save()

def forward(data_loader, model, criterion, epoch=0, training=True, optimizer=None):
    model = torch.nn.DataParallel(model, args.gpus)
    batch_time = AverageMeter()
    data_time = AverageMeter()
    losses = AverageMeter()
    top1 = AverageMeter()
    top5 = AverageMeter()

    end = time.time()
    for i, (inputs, target) in enumerate(data_loader):
        # measure data loading time
        data_time.update(time.time() - end)

        target = target.cuda(async=True)
        input_var = Variable(inputs, volatile=not training).type(args.type)
        target_var = Variable(target)

        # compute output
        output = model(input_var)
        loss = criterion(output, target_var)
        if type(output) is list:
            output = output[0]

        # measure accuracy and record loss
        prec1, prec5 = accuracy(output.data, target, topk=(1, 5))
        losses.update(loss.data[0], inputs.size(0))
        top1.update(prec1[0], inputs.size(0))
        top5.update(prec5[0], inputs.size(0))

        if training:
            # compute gradient and do SGD step
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

        # measure elapsed time
        batch_time.update(time.time() - end)
        end = time.time()

        if i % args.print_freq == 0:
            logging.info('{phase} - Epoch: [{0}][{1}/{2}]\t'
                     'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
                     'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
                     'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
                     'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t'
                     'Prec@5 {top5.val:.3f} ({top5.avg:.3f})'.format(
                         epoch, i, len(data_loader),
                         phase='TRAINING' if training else 'EVALUATING',
                         batch_time=batch_time,
                         data_time=data_time, loss=losses, top1=top1, top5=top5))

    return losses.avg, top1.avg, top5.avg

def train(data_loader, model, criterion, epoch, optimizer):
    # switch to train mode
    model.train()
    return forward(data_loader, model, criterion, epoch,
                   training=True, optimizer=optimizer)

def validate(data_loader, model, criterion, epoch):
    # switch to evaluate mode
    model.eval()
    return forward(data_loader, model, criterion, epoch,
                   training=False, optimizer=None)

if __name__ == '__main__':
    main()
<commit_msg>allow cpu type<commit_after>import argparse
import os
import time
import logging
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.optim
import torch.utils.data
import models
from torch.autograd import Variable
from data import get_dataset
from preprocess import get_transform
from utils import *
from datetime import datetime
from ast import literal_eval
from torchvision.utils import save_image

model_names = sorted(name for name in models.__dict__
                     if name.islower() and not name.startswith("__")
                     and callable(models.__dict__[name]))

parser = argparse.ArgumentParser(description='PyTorch ConvNet Training')

parser.add_argument('--results_dir', metavar='RESULTS_DIR', default='./results',
                    help='results dir')
parser.add_argument('--save', metavar='SAVE', default='',
                    help='saved folder')
parser.add_argument('--dataset', metavar='DATASET', default='imagenet',
                    help='dataset name or folder')
parser.add_argument('--model', '-a', metavar='MODEL', default='alexnet',
                    choices=model_names,
                    help='model architecture: ' +
                    ' | '.join(model_names) +
                    ' (default: alexnet)')
parser.add_argument('--input_size', type=int, default=None,
                    help='image input size')
parser.add_argument('--model_config', default='',
                    help='additional architecture configuration')
parser.add_argument('--type', default='torch.cuda.FloatTensor',
                    help='type of tensor - e.g torch.cuda.HalfTensor')
parser.add_argument('--gpus', default='0',
                    help='gpus used for training - e.g 0,1,3')
parser.add_argument('-j', '--workers', default=8, type=int, metavar='N',
                    help='number of data loading workers (default: 8)')
parser.add_argument('--epochs', default=90, type=int, metavar='N',
                    help='number of total epochs to run')
parser.add_argument('--start-epoch', default=0, type=int, metavar='N',
                    help='manual epoch number (useful on restarts)')
parser.add_argument('-b', '--batch-size', default=256, type=int,
                    metavar='N', help='mini-batch size (default: 256)')
parser.add_argument('--optimizer', default='SGD', type=str, metavar='OPT',
                    help='optimizer function used')
parser.add_argument('--lr', '--learning_rate', default=0.1, type=float,
                    metavar='LR', help='initial learning rate')
parser.add_argument('--momentum', default=0.9, type=float, metavar='M',
                    help='momentum')
parser.add_argument('--weight-decay', '--wd', default=1e-4, type=float,
                    metavar='W', help='weight decay (default: 1e-4)')
parser.add_argument('--print-freq', '-p', default=10, type=int,
                    metavar='N', help='print frequency (default: 10)')
parser.add_argument('--resume', default='', type=str, metavar='PATH',
                    help='path to latest checkpoint (default: none)')
parser.add_argument('-e', '--evaluate', type=str, metavar='FILE',
                    help='evaluate model FILE on validation set')

def main():
    global args, best_prec1
    best_prec1 = 0
    args = parser.parse_args()

    if args.evaluate:
        args.results_dir = '/tmp'
    if args.save is '':
        args.save = datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
    save_path = os.path.join(args.results_dir, args.save)
    if not os.path.exists(save_path):
        os.makedirs(save_path)

    setup_logging(os.path.join(save_path, 'log.txt'))
    results_file = os.path.join(save_path, 'results.%s')
    results = ResultsLog(results_file % 'csv', results_file % 'html')

    logging.info("saving to %s", save_path)
    logging.debug("run arguments: %s", args)

    if 'cuda' in args.type:
        args.gpus = [int(i) for i in args.gpus.split(',')]
        torch.cuda.set_device(args.gpus[0])
        cudnn.benchmark = True
    else:
        args.gpus = None

    # create model
    logging.info("creating model %s", args.model)
    model = model = models.__dict__[args.model]
    model_config = {'input_size': args.input_size, 'dataset': args.dataset}

    if args.model_config is not '':
        model_config = dict(model_config, **literal_eval(args.model_config))

    model = model(**model_config)
    logging.info("created model with configuration: %s", model_config)

    # optionally resume from a checkpoint
    if args.evaluate:
        if not os.path.isfile(args.evaluate):
            parser.error('invalid checkpoint: {}'.format(args.evaluate))
        checkpoint = torch.load(args.evaluate)
        model.load_state_dict(checkpoint['state_dict'])
        logging.info("loaded checkpoint '%s' (epoch %s)",
                     args.evaluate, checkpoint['epoch'])
    elif args.resume:
        checkpoint_file = args.resume
        if os.path.isdir(checkpoint_file):
            results.load(os.path.join(checkpoint_file, 'results.csv'))
            checkpoint_file = os.path.join(
                checkpoint_file, 'model_best.pth.tar')
        if os.path.isfile(checkpoint_file):
            logging.info("loading checkpoint '%s'", args.resume)
            checkpoint = torch.load(checkpoint_file)
            args.start_epoch = checkpoint['epoch'] - 1
            best_prec1 = checkpoint['best_prec1']
            model.load_state_dict(checkpoint['state_dict'])
            logging.info("loaded checkpoint '%s' (epoch %s)",
                         checkpoint_file, checkpoint['epoch'])
        else:
            logging.error("no checkpoint found at '%s'", args.resume)

    num_parameters = sum([l.nelement() for l in model.parameters()])
    logging.info("number of parameters: %d", num_parameters)

    # Data loading code
    default_transform = {
        'train': get_transform(args.dataset,
                               input_size=args.input_size, augment=True),
        'eval': get_transform(args.dataset,
                              input_size=args.input_size, augment=False)
    }
    transform = getattr(model, 'input_transform', default_transform)
    regime = getattr(model, 'regime', {0: {'optimizer': args.optimizer,
                                           'lr': args.lr,
                                           'momentum': args.momentum,
                                           'weight_decay': args.weight_decay}})
    # define loss function (criterion) and optimizer
    criterion = getattr(model, 'criterion', nn.CrossEntropyLoss)()
    criterion.type(args.type)
    model.type(args.type)

    val_data = get_dataset(args.dataset, 'val', transform['eval'])
    val_loader = torch.utils.data.DataLoader(
        val_data,
        batch_size=args.batch_size, shuffle=False,
        num_workers=args.workers, pin_memory=True)

    if args.evaluate:
        validate(val_loader, model, criterion, 0)
        return

    train_data = get_dataset(args.dataset, 'train', transform['train'])
    train_loader = torch.utils.data.DataLoader(
        train_data,
        batch_size=args.batch_size, shuffle=True,
        num_workers=args.workers, pin_memory=True)

    optimizer = torch.optim.SGD(model.parameters(), lr=args.lr)
    logging.info('training regime: %s', regime)

    for epoch in range(args.start_epoch, args.epochs):
        optimizer = adjust_optimizer(optimizer, epoch, regime)

        # train for one epoch
        train_loss, train_prec1, train_prec5 = train(
            train_loader, model, criterion, epoch, optimizer)

        # evaluate on validation set
        val_loss, val_prec1, val_prec5 = validate(
            val_loader, model, criterion, epoch)

        # remember best prec@1 and save checkpoint
        is_best = val_prec1 > best_prec1
        best_prec1 = max(val_prec1, best_prec1)
        save_checkpoint({
            'epoch': epoch + 1,
            'model': args.model,
            'config': args.model_config,
            'state_dict': model.state_dict(),
            'best_prec1': best_prec1,
            'regime': regime
        }, is_best, path=save_path)
        logging.info('\n Epoch: {0}\t'
                     'Training Loss {train_loss:.4f} \t'
                     'Training Prec@1 {train_prec1:.3f} \t'
                     'Training Prec@5 {train_prec5:.3f} \t'
                     'Validation Loss {val_loss:.4f} \t'
                     'Validation Prec@1 {val_prec1:.3f} \t'
                     'Validation Prec@5 {val_prec5:.3f} \n'
                     .format(epoch + 1, train_loss=train_loss, val_loss=val_loss,
                             train_prec1=train_prec1, val_prec1=val_prec1,
                             train_prec5=train_prec5, val_prec5=val_prec5))

        results.add(epoch=epoch + 1, train_loss=train_loss, val_loss=val_loss,
                    train_error1=100 - train_prec1, val_error1=100 - val_prec1,
                    train_error5=100 - train_prec5, val_error5=100 - val_prec5)
        results.plot(x='epoch', y=['train_loss', 'val_loss'],
                     title='Loss', ylabel='loss')
        results.plot(x='epoch', y=['train_error1', 'val_error1'],
                     title='Error@1', ylabel='error %')
        results.plot(x='epoch', y=['train_error5', 'val_error5'],
                     title='Error@5', ylabel='error %')
        results.save()

def forward(data_loader, model, criterion, epoch=0, training=True, optimizer=None):
    if args.gpus and len(args.gpus) > 1:
        model = torch.nn.DataParallel(model, args.gpus)
    batch_time = AverageMeter()
    data_time = AverageMeter()
    losses = AverageMeter()
    top1 = AverageMeter()
    top5 = AverageMeter()

    end = time.time()
    for i, (inputs, target) in enumerate(data_loader):
        # measure data loading time
        data_time.update(time.time() - end)
        if args.gpus is not None:
            target = target.cuda(async=True)
        input_var = Variable(inputs.type(args.type), volatile=not training)
        target_var = Variable(target)

        # compute output
        output = model(input_var)
        loss = criterion(output, target_var)
        if type(output) is list:
            output = output[0]

        # measure accuracy and record loss
        prec1, prec5 = accuracy(output.data, target, topk=(1, 5))
        losses.update(loss.data[0], inputs.size(0))
        top1.update(prec1[0], inputs.size(0))
        top5.update(prec5[0], inputs.size(0))

        if training:
            # compute gradient and do SGD step
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

        # measure elapsed time
        batch_time.update(time.time() - end)
        end = time.time()

        if i % args.print_freq == 0:
            logging.info('{phase} - Epoch: [{0}][{1}/{2}]\t'
                         'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
                         'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
                         'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
                         'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t'
                         'Prec@5 {top5.val:.3f} ({top5.avg:.3f})'.format(
                             epoch, i, len(data_loader),
                             phase='TRAINING' if training else 'EVALUATING',
                             batch_time=batch_time,
                             data_time=data_time, loss=losses, top1=top1, top5=top5))

    return losses.avg, top1.avg, top5.avg

def train(data_loader, model, criterion, epoch, optimizer):
    # switch to train mode
    model.train()
    return forward(data_loader, model, criterion, epoch,
                   training=True, optimizer=optimizer)

def validate(data_loader, model, criterion, epoch):
    # switch to evaluate mode
    model.eval()
    return forward(data_loader, model, criterion, epoch,
                   training=False, optimizer=None)

if __name__ == '__main__':
    main()
<|endoftext|>


<commit_before>from google.appengine.ext import webapp
from google.appengine.ext.webapp.util import run_wsgi_app

from gae_bingo import cache
from gae_bingo import dashboard
from gae_bingo import middleware
from gae_bingo import blotter

application = webapp.WSGIApplication([
    ("/gae_bingo/persist", cache.PersistToDatastore),
    ("/gae_bingo/dashboard", dashboard.Dashboard),
    ("/gae_bingo/dashboard/control_experiment", dashboard.ControlExperiment),
    ("/gae_bingo/blotter", blotter.Blotter),
])
application = middleware.GAEBingoWSGIMiddleware(application)

def main():
    run_wsgi_app(application)

if __name__ == "__main__":
    main()

<commit_msg>restore plots<commit_after>from google.appengine.ext import webapp
from google.appengine.ext.webapp.util import run_wsgi_app

from gae_bingo import cache
from gae_bingo import dashboard
from gae_bingo import middleware
from gae_bingo import plots
from gae_bingo import blotter

application = webapp.WSGIApplication([
    ("/gae_bingo/persist", cache.PersistToDatastore),
    ("/gae_bingo/log_snapshot", cache.LogSnapshotToDatastore),
    ("/gae_bingo/dashboard", dashboard.Dashboard),
    ("/gae_bingo/dashboard/control_experiment", dashboard.ControlExperiment),
    ("/gae_bingo/dashboard/plot_experiment", plots.Timeline),
    ("/gae_bingo/blotter", blotter.Blotter),
])
application = middleware.GAEBingoWSGIMiddleware(application)

def main():
    run_wsgi_app(application)

if __name__ == "__main__":
    main()

<|endoftext|>


<commit_before>#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# BotFWD - A telegram bot to forward random messages from a channel

"""
Usage:
Press Ctrl-C on the command line or send a signal to the process to stop the
bot.
"""

import random as rd
from telegram.ext import (Updater, CommandHandler, MessageHandler, Filters, Job)
import logging

# Enable logging
logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
                    level=logging.INFO)

logger = logging.getLogger(__name__)

# Define a few command handlers. These usually take the two arguments bot and
# update. Error handlers also receive the raised TelegramError object in error.
def start(bot, update):
    update.message.reply_text('Olá! Eu sou o BotFwd e existo unicamente para'
                              ' causar o desconforto nas pessoas!')
    bot.send_message(chat_id=update.message.chat_id,
                     text="Meus comandos:\n"
                          "Iniciar o bot: /start\n"
                          "Mensagem aleatória: /random\n"
                          "Ajuda: /help")

def help(bot, update):
    update.message.reply_text('Sem ajuda malandro!')
    bot.send_message(chat_id=update.message.chat_id,
                     text="Quer ajudar a desenvolver o bot?\n"
                          "https://goo.gl/x3jDri")

def random(bot, update):
    # update.message.reply_text('Em manutenção :(')
    messageID = rd.randint(6, 175)
    try:
        bot.forwardMessage(update.message.chat_id, '@botFwdTeste', messageID)
        print("Success => message_id %d" % messageID)
    except:
        print("Error => message_id %d does not exist" % messageID)
        random(bot, update)

def debug(bot, update):
    print("Chat id %d" % update.message.chat_id)
    print("Message id %d" % update.message.message_id)
    for x in range(0, 175):
        try:
            # bot.forwardMessage(update.message.chat_id, '@ofwdnovo', messageID)
            bot.forwardMessage(update.message.chat_id, '@botFwdTeste', x)
            print("Success => message_id %d" % x)
        except:
            print("Error => message_id %d does not exist" % x)
            continue

def lero(bot, update):
    t0 = [  'Caros amigos, ',
            'Por outro lado, ',
            'Assim mesmo, ',
            'No entanto, não podemos esquecer que ',
            'Do mesmo modo, ',
            'A prática cotidiana prova que ',
            'Nunca é demais lembrar o peso e o significado destes problemas, uma vez que ',
            'As experiências acumuladas demonstram que ',
            'Acima de tudo, é fundamental ressaltar que ',
            'O incentivo ao avanço tecnológico, assim como ',
            'Não obstante, ',
            'Todas estas questões, devidamente ponderadas, levantam dúvidas sobre se ',
            'Pensando mais a longo prazo, ',
            'O que temos que ter sempre em mente é que ',
            'Ainda assim, existem dúvidas a respeito de como ',
            'Gostaria de enfatizar que ',
            'Todavia, ',
            'A nível organizacional, ',
            'O empenho em analisar ',
            'Percebemos, cada vez mais, que ',
            'No mundo atual, ',
            'É importante questionar o quanto ',
            'Neste sentido, ',
            'Evidentemente, ',
            'Por conseguinte, ',
            'É claro que ',
            'Podemos já vislumbrar o modo pelo qual ',
            'Desta maneira, ',
            'O cuidado em identificar pontos críticos n',
            'A certificação de metodologias que nos auxiliam a lidar com ' ]

    t1 = [  'a execução dos pontos do programa ',
            'a complexidade dos estudos efetuados ',
            'a contínua expansão de nossa atividade ',
            'a estrutura atual da organização ',
            'o novo modelo estrutural aqui preconizado ',
            'o desenvolvimento contínuo de distintas formas de atuação ',
            'a constante divulgação das informações ',
            'a consolidação das estruturas ',
            'a consulta aos diversos militantes ',
            'o início da atividade geral de formação de atitudes ',
            'o desafiador cenário globalizado ',
            'a mobilidade dos capitais internacionais ',
            'o fenômeno da Internet ',
            'a hegemonia do ambiente político ',
            'a expansão dos mercados mundiais ',
            'o aumento do diálogo entre os diferentes setores produtivos ',
            'a crescente influência da mídia ',
            'a necessidade de renovação processual ',
            'a competitividade nas transações comerciais ',
            'o surgimento do comércio virtual ',
            'a revolução dos costumes ',
            'o acompanhamento das preferências de consumo ',
            'o comprometimento entre as equipes ',
            'a determinação clara de objetivos ',
            'a adoção de políticas descentralizadoras ',
            'a valorização de fatores subjetivos ',
            'a percepção das dificuldades ',
            'o entendimento das metas propostas ',
            'o consenso sobre a necessidade de qualificação ',
            'o julgamento imparcial das eventualidades ' ]

    t2 = [  'nos obriga à análise ',
            'cumpre um papel essencial na formulação ',
            'exige a precisão e a definição ',
            'auxilia a preparação e a composição ',
            'garante a contribuição de um grupo importante na determinação ',
            'assume importantes posições no estabelecimento ',
            'facilita a criação ',
            'obstaculiza a apreciação da importância ',
            'oferece uma interessante oportunidade para verificação ',
            'acarreta um processo de reformulação e modernização ',
            'pode nos levar a considerar a reestruturação ',
            'representa uma abertura para a melhoria ',
            'ainda não demonstrou convincentemente que vai participar na mudança ',
            'talvez venha a ressaltar a relatividade ',
            'prepara-nos para enfrentar situações atípicas decorrentes ',
            'maximiza as possibilidades por conta ',
            'desafia a capacidade de equalização ',
            'agrega valor ao estabelecimento ',
            'é uma das consequências ',
            'promove a alavancagem ',
            'não pode mais se dissociar ',
            'possibilita uma melhor visão global ',
            'estimula a padronização ',
            'aponta para a melhoria ',
            'faz parte de um processo de gerenciamento ',
            'causa impacto indireto na reavaliação ',
            'apresenta tendências no sentido de aprovar a manutenção ',
            'estende o alcance e a importância ',
            'deve passar por modificações independentemente ',
            'afeta positivamente a correta previsão ' ]

    t3 = [  'das condições financeiras e administrativas exigidas.',
            'das diretrizes de desenvolvimento para o futuro.',
            'do sistema de participação geral.',
            'das posturas dos órgãos dirigentes com relação às suas atribuições.',
            'das novas proposições.',
            'das direções preferenciais no sentido do progresso.',
            'do sistema de formação de quadros que corresponde às necessidades.',
            'das condições inegavelmente apropriadas.',
            'dos índices pretendidos.',
            'das formas de ação.',
            'dos paradigmas corporativos.',
            'dos relacionamentos verticais entre as hierarquias.',
            'do processo de comunicação como um todo.',
            'dos métodos utilizados na avaliação de resultados.',
            'de todos os recursos funcionais envolvidos.',
            'dos níveis de motivação departamental.',
            'da gestão inovadora da qual fazemos parte.',
            'dos modos de operação convencionais.',
            'de alternativas às soluções ortodoxas.',
            'dos procedimentos normalmente adotados.',
            'dos conhecimentos estratégicos para atingir a excelência.',
            'do fluxo de informações.',
            'do levantamento das variáveis envolvidas.',
            'das diversas correntes de pensamento.',
            'do impacto na agilidade decisória.',
            'das regras de conduta normativas.',
            'do orçamento setorial.',
            'do retorno esperado a longo prazo.',
            'do investimento em reciclagem técnica.',
            'do remanejamento dos quadros funcionais.' ]

    leroLero = rd.choice(t0) + rd.choice(t1) + rd.choice(t2) + rd.choice(t3)
    bot.send_message(chat_id=update.message.chat_id, text=leroLero)

def wordGenerate(bot, update):
    consonants = 'bcdfghjlmnpqrstvxz'
    vowels = 'aeiou'
    syllables = rd.randint(2, 10)
    result = ''

    for i in range(syllables):
        consonant = rd.choice(consonants)
        this_vowels = vowels
        if consonant == 'q':
            consonant += 'u'
            this_vowels = 'aeio'
        result += consonant + rd.choice(this_vowels)
        if i > 0 and result[-2] in 'bp' and rd.randint(0, 5) == 0:
            result = result[:-2] + 'm' + result[-2:]
        if i > 0 and result[-2] in 'cglrst' and rd.randint(0, 5) == 0:
            result = result[:-2] + 'n' + result[-2:]

    return result

def word(bot, update):
    result = wordGenerate(bot, update)
    bot.send_message(chat_id=update.message.chat_id, text=result)

def aplicacaonumafrase(bot, update):
    word = wordGenerate(bot, update)

    t0 = [  'Meu livro preferido é aquele entitulado \"Quem mexeu no meu {word}?\"',
            'Já tentou misturar vodka com {word}?',
            '{word} está precisando de um herói!',
            'Queria que tivesse {word} todo dia no bandeco;',
            'Então você curte um {word}, né?',
            'Daria tudo por um {word} agora.',
            'Último jogo produzido pelo FoG: \"As aventuras de {word}.',
            'Quem não curte tomar água com {word} nem fala comigo.',
            'É um país da {word}!',
            'Só não deixe se after por um simples {word}.',
            'Os carros são como as lanchas, e as motos são como um {word}.',
            'Rosas são vermelhas, violetas são azuis. Se eu soubesse rimar, {word}.',
            'Aqui só tem conteúdo bom, padrão {word} de qualidade.',
            'Mal posso esperar pra chegar o dia de {word}.',
            'Queria ser um pássaro, mas um pássaro não posso ser. Só me sobra ser um {word} mesmo.',
            'Que dia lindo. Topa um {word} mais tarde?',
            'Agora sim eu tô {word}.',
            'Se não tiver {word} eu nem quero.',
            'Garçom, me vê um {word} pra viagem?',
            'Se for uma girafa, vai chamar {word}.',
            'Lembra daquela música famosa, a \"Dançando com {word}\"?',
            'Você é tão sensual que me lembra uma {word}.',
            'Se eu fosse funkeiro, seria o Mc {word}.',
            'Ando sonhando muito com {word}. Devo ir no médico?',
            'Ele deu uma {word} na barata dela!',
            'Imagina que louco ter um {word} em casa?',
            'Já teve aula de {word}?',
            'Isso tem gosto de {word}.',
            'Aquele filme de mágica, \"Harry Potter e o {word} de fogo\", sabe?',
            'O nome do meu filho vai ser {word}, acho lindo.' ]

    r = rd.randint(0, len(t0)-1)
    result = t0[r].format(word=word)
    bot.send_message(chat_id=update.message.chat_id, text=result)

def error(bot, update, error):
    logger.warn('Update "%s" caused error "%s"' % (update, error))

def main():
    # Create the EventHandler and pass it your bot's token.
    updater = Updater("390975324:AAG57sa1pBQ9Swk7ry-I4FJijWOc1XZYM5s")

    # Get the dispatcher to register handlers
    dp = updater.dispatcher

    # on different commands - answer in Telegram
    dp.add_handler(CommandHandler("start", start))
    dp.add_handler(CommandHandler("help", help))
    dp.add_handler(CommandHandler("random", random))
    dp.add_handler(CommandHandler("fwd", random))
    dp.add_handler(CommandHandler("lero", lero))
    dp.add_handler(CommandHandler("lerolero", lero))
    dp.add_handler(CommandHandler("word", word))
    dp.add_handler(CommandHandler("palavra", word))
    dp.add_handler(CommandHandler("aplicacaonumafrase", aplicacaonumafrase))
    dp.add_handler(CommandHandler("frase", aplicacaonumafrase))
    dp.add_handler(CommandHandler("debug", debug))

    # log all errors
    dp.add_error_handler(error)

    # Start the Bot
    updater.start_polling()
    print('==== BOT started ====')

    # Run the bot until you press Ctrl-C or the process receives SIGINT,
    # SIGTERM or SIGABRT. This should be used most of the time, since
    # start_polling() is non-blocking and will stop the bot gracefully.
    updater.idle()

if __name__ == '__main__':
    main()
<commit_msg>Comment the debug command<commit_after>#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# BotFWD - A telegram bot to forward random messages from a channel

"""
Usage:
Press Ctrl-C on the command line or send a signal to the process to stop the
bot.
"""

import random as rd
from telegram.ext import (Updater, CommandHandler, MessageHandler, Filters, Job)
import logging

# Enable logging
logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
                    level=logging.INFO)

logger = logging.getLogger(__name__)

# Define a few command handlers. These usually take the two arguments bot and
# update. Error handlers also receive the raised TelegramError object in error.
def start(bot, update):
    update.message.reply_text('Olá! Eu sou o BotFwd e existo unicamente para'
                              ' causar o desconforto nas pessoas!')
    bot.send_message(chat_id=update.message.chat_id,
                     text="Meus comandos:\n"
                          "Iniciar o bot: /start\n"
                          "Mensagem aleatória: /random\n"
                          "Ajuda: /help")

def help(bot, update):
    update.message.reply_text('Sem ajuda malandro!')
    bot.send_message(chat_id=update.message.chat_id,
                     text="Quer ajudar a desenvolver o bot?\n"
                          "https://goo.gl/x3jDri")

def random(bot, update):
    # update.message.reply_text('Em manutenção :(')
    messageID = rd.randint(6, 175)
    try:
        bot.forwardMessage(update.message.chat_id, '@botFwdTeste', messageID)
        print("Success => message_id %d" % messageID)
    except:
        print("Error => message_id %d does not exist" % messageID)
        random(bot, update)

def debug(bot, update):
    print("Chat id %d" % update.message.chat_id)
    print("Message id %d" % update.message.message_id)
    for x in range(0, 175):
        try:
            # bot.forwardMessage(update.message.chat_id, '@ofwdnovo', messageID)
            bot.forwardMessage(update.message.chat_id, '@botFwdTeste', x)
            print("Success => message_id %d" % x)
        except:
            print("Error => message_id %d does not exist" % x)
            continue

def lero(bot, update):
    t0 = [  'Caros amigos, ',
            'Por outro lado, ',
            'Assim mesmo, ',
            'No entanto, não podemos esquecer que ',
            'Do mesmo modo, ',
            'A prática cotidiana prova que ',
            'Nunca é demais lembrar o peso e o significado destes problemas, uma vez que ',
            'As experiências acumuladas demonstram que ',
            'Acima de tudo, é fundamental ressaltar que ',
            'O incentivo ao avanço tecnológico, assim como ',
            'Não obstante, ',
            'Todas estas questões, devidamente ponderadas, levantam dúvidas sobre se ',
            'Pensando mais a longo prazo, ',
            'O que temos que ter sempre em mente é que ',
            'Ainda assim, existem dúvidas a respeito de como ',
            'Gostaria de enfatizar que ',
            'Todavia, ',
            'A nível organizacional, ',
            'O empenho em analisar ',
            'Percebemos, cada vez mais, que ',
            'No mundo atual, ',
            'É importante questionar o quanto ',
            'Neste sentido, ',
            'Evidentemente, ',
            'Por conseguinte, ',
            'É claro que ',
            'Podemos já vislumbrar o modo pelo qual ',
            'Desta maneira, ',
            'O cuidado em identificar pontos críticos n',
            'A certificação de metodologias que nos auxiliam a lidar com ' ]

    t1 = [  'a execução dos pontos do programa ',
            'a complexidade dos estudos efetuados ',
            'a contínua expansão de nossa atividade ',
            'a estrutura atual da organização ',
            'o novo modelo estrutural aqui preconizado ',
            'o desenvolvimento contínuo de distintas formas de atuação ',
            'a constante divulgação das informações ',
            'a consolidação das estruturas ',
            'a consulta aos diversos militantes ',
            'o início da atividade geral de formação de atitudes ',
            'o desafiador cenário globalizado ',
            'a mobilidade dos capitais internacionais ',
            'o fenômeno da Internet ',
            'a hegemonia do ambiente político ',
            'a expansão dos mercados mundiais ',
            'o aumento do diálogo entre os diferentes setores produtivos ',
            'a crescente influência da mídia ',
            'a necessidade de renovação processual ',
            'a competitividade nas transações comerciais ',
            'o surgimento do comércio virtual ',
            'a revolução dos costumes ',
            'o acompanhamento das preferências de consumo ',
            'o comprometimento entre as equipes ',
            'a determinação clara de objetivos ',
            'a adoção de políticas descentralizadoras ',
            'a valorização de fatores subjetivos ',
            'a percepção das dificuldades ',
            'o entendimento das metas propostas ',
            'o consenso sobre a necessidade de qualificação ',
            'o julgamento imparcial das eventualidades ' ]

    t2 = [  'nos obriga à análise ',
            'cumpre um papel essencial na formulação ',
            'exige a precisão e a definição ',
            'auxilia a preparação e a composição ',
            'garante a contribuição de um grupo importante na determinação ',
            'assume importantes posições no estabelecimento ',
            'facilita a criação ',
            'obstaculiza a apreciação da importância ',
            'oferece uma interessante oportunidade para verificação ',
            'acarreta um processo de reformulação e modernização ',
            'pode nos levar a considerar a reestruturação ',
            'representa uma abertura para a melhoria ',
            'ainda não demonstrou convincentemente que vai participar na mudança ',
            'talvez venha a ressaltar a relatividade ',
            'prepara-nos para enfrentar situações atípicas decorrentes ',
            'maximiza as possibilidades por conta ',
            'desafia a capacidade de equalização ',
            'agrega valor ao estabelecimento ',
            'é uma das consequências ',
            'promove a alavancagem ',
            'não pode mais se dissociar ',
            'possibilita uma melhor visão global ',
            'estimula a padronização ',
            'aponta para a melhoria ',
            'faz parte de um processo de gerenciamento ',
            'causa impacto indireto na reavaliação ',
            'apresenta tendências no sentido de aprovar a manutenção ',
            'estende o alcance e a importância ',
            'deve passar por modificações independentemente ',
            'afeta positivamente a correta previsão ' ]

    t3 = [  'das condições financeiras e administrativas exigidas.',
            'das diretrizes de desenvolvimento para o futuro.',
            'do sistema de participação geral.',
            'das posturas dos órgãos dirigentes com relação às suas atribuições.',
            'das novas proposições.',
            'das direções preferenciais no sentido do progresso.',
            'do sistema de formação de quadros que corresponde às necessidades.',
            'das condições inegavelmente apropriadas.',
            'dos índices pretendidos.',
            'das formas de ação.',
            'dos paradigmas corporativos.',
            'dos relacionamentos verticais entre as hierarquias.',
            'do processo de comunicação como um todo.',
            'dos métodos utilizados na avaliação de resultados.',
            'de todos os recursos funcionais envolvidos.',
            'dos níveis de motivação departamental.',
            'da gestão inovadora da qual fazemos parte.',
            'dos modos de operação convencionais.',
            'de alternativas às soluções ortodoxas.',
            'dos procedimentos normalmente adotados.',
            'dos conhecimentos estratégicos para atingir a excelência.',
            'do fluxo de informações.',
            'do levantamento das variáveis envolvidas.',
            'das diversas correntes de pensamento.',
            'do impacto na agilidade decisória.',
            'das regras de conduta normativas.',
            'do orçamento setorial.',
            'do retorno esperado a longo prazo.',
            'do investimento em reciclagem técnica.',
            'do remanejamento dos quadros funcionais.' ]

    leroLero = rd.choice(t0) + rd.choice(t1) + rd.choice(t2) + rd.choice(t3)
    bot.send_message(chat_id=update.message.chat_id, text=leroLero)

def wordGenerate(bot, update):
    consonants = 'bcdfghjlmnpqrstvxz'
    vowels = 'aeiou'
    syllables = rd.randint(2, 10)
    result = ''

    for i in range(syllables):
        consonant = rd.choice(consonants)
        this_vowels = vowels
        if consonant == 'q':
            consonant += 'u'
            this_vowels = 'aeio'
        result += consonant + rd.choice(this_vowels)
        if i > 0 and result[-2] in 'bp' and rd.randint(0, 5) == 0:
            result = result[:-2] + 'm' + result[-2:]
        if i > 0 and result[-2] in 'cglrst' and rd.randint(0, 5) == 0:
            result = result[:-2] + 'n' + result[-2:]

    return result

def word(bot, update):
    result = wordGenerate(bot, update)
    bot.send_message(chat_id=update.message.chat_id, text=result)

def aplicacaonumafrase(bot, update):
    word = wordGenerate(bot, update)

    t0 = [  'Meu livro preferido é aquele entitulado \"Quem mexeu no meu {word}?\"',
            'Já tentou misturar vodka com {word}?',
            '{word} está precisando de um herói!',
            'Queria que tivesse {word} todo dia no bandeco;',
            'Então você curte um {word}, né?',
            'Daria tudo por um {word} agora.',
            'Último jogo produzido pelo FoG: \"As aventuras de {word}.',
            'Quem não curte tomar água com {word} nem fala comigo.',
            'É um país da {word}!',
            'Só não deixe se after por um simples {word}.',
            'Os carros são como as lanchas, e as motos são como um {word}.',
            'Rosas são vermelhas, violetas são azuis. Se eu soubesse rimar, {word}.',
            'Aqui só tem conteúdo bom, padrão {word} de qualidade.',
            'Mal posso esperar pra chegar o dia de {word}.',
            'Queria ser um pássaro, mas um pássaro não posso ser. Só me sobra ser um {word} mesmo.',
            'Que dia lindo. Topa um {word} mais tarde?',
            'Agora sim eu tô {word}.',
            'Se não tiver {word} eu nem quero.',
            'Garçom, me vê um {word} pra viagem?',
            'Se for uma girafa, vai chamar {word}.',
            'Lembra daquela música famosa, a \"Dançando com {word}\"?',
            'Você é tão sensual que me lembra uma {word}.',
            'Se eu fosse funkeiro, seria o Mc {word}.',
            'Ando sonhando muito com {word}. Devo ir no médico?',
            'Ele deu uma {word} na barata dela!',
            'Imagina que louco ter um {word} em casa?',
            'Já teve aula de {word}?',
            'Isso tem gosto de {word}.',
            'Aquele filme de mágica, \"Harry Potter e o {word} de fogo\", sabe?',
            'O nome do meu filho vai ser {word}, acho lindo.' ]

    r = rd.randint(0, len(t0)-1)
    result = t0[r].format(word=word)
    bot.send_message(chat_id=update.message.chat_id, text=result)

def error(bot, update, error):
    logger.warn('Update "%s" caused error "%s"' % (update, error))

def main():
    # Create the EventHandler and pass it your bot's token.
    updater = Updater("390975324:AAG57sa1pBQ9Swk7ry-I4FJijWOc1XZYM5s")

    # Get the dispatcher to register handlers
    dp = updater.dispatcher

    # on different commands - answer in Telegram
    dp.add_handler(CommandHandler("start", start))
    dp.add_handler(CommandHandler("help", help))
    dp.add_handler(CommandHandler("random", random))
    dp.add_handler(CommandHandler("fwd", random))
    dp.add_handler(CommandHandler("lero", lero))
    dp.add_handler(CommandHandler("lerolero", lero))
    dp.add_handler(CommandHandler("word", word))
    dp.add_handler(CommandHandler("palavra", word))
    dp.add_handler(CommandHandler("aplicacaonumafrase", aplicacaonumafrase))
    dp.add_handler(CommandHandler("frase", aplicacaonumafrase))
    #dp.add_handler(CommandHandler("debug", debug))

    # log all errors
    dp.add_error_handler(error)

    # Start the Bot
    updater.start_polling()
    print('==== BOT started ====')

    # Run the bot until you press Ctrl-C or the process receives SIGINT,
    # SIGTERM or SIGABRT. This should be used most of the time, since
    # start_polling() is non-blocking and will stop the bot gracefully.
    updater.idle()

if __name__ == '__main__':
    main()
<|endoftext|>


<commit_before>import calendar
import datetime
import logging
import pickle
import sqlite3
from requests import HTTPError
import sys
import time

import get_todays_book
import pushover_notifications

logging.basicConfig(level=logging.INFO,
                    filename='packetpub_grabber.log',
                    format='%(asctime)s - %(levelname)s: %(message)s')

def get_tomorrow():
    return datetime.datetime.replace(datetime.datetime.utcnow() + datetime.timedelta(days=1),
                                     hour=0, minute=0, second=0)

def sleep_till_tomorrow():
    tomorrow = get_tomorrow()
    delta = tomorrow - datetime.datetime.utcnow()
    logging.info("Sleeping till {0}".format(tomorrow.ctime()))
    time.sleep(delta.seconds)
    return

def get_last_book():
    conn = sqlite3.connect('get_book.db')
    c = conn.cursor()
    try:
        sql_result = c.execute("SELECT * FROM last_book ORDER BY ID DESC LIMIT 1;")
        return sql_result.fetchone()
    except sqlite3.OperationalError:
        c.execute("CREATE TABLE last_book (id integer primary key autoincrement,nid integer, title text, date blob)")
        get_last_book()

def write_book_to_sql(book_data):
    with sqlite3.connect('get_book.db') as conn:
        c = conn.cursor()
        c.execute("INSERT INTO last_book (title, nid, date) VALUES (?, ?, ?)", (book_data['title'], book_data['nid'], pickle.dumps(datetime.datetime.utcnow().date())))
        conn.commit()
        logging.info("Grabbed {0} at {1}".format(book_data['title'], datetime.datetime.utcnow().ctime()))

def check_book_or_retry(book_sess, retrys=0):
    if retrys == 3:
        logging.error("Unbale to fetch book. We have reached max attempts. Bailing out.")
        try:
            pushover_notifications.make_pushover_call("Error getting today's book. Please check this out.")
        except HTTPError:
            logging.error("Pushover notificaion not working as expected.")
        sys.exit()
    my_last_book = get_todays_book.verify_todays_book(book_sess)
    if not my_last_book:
        logging.fatal("Email or Password appears invalid! Cannot continue. Exiting.")
        sys.exit()
    book_id, nid, title, date = get_last_book()
    if nid != int(my_last_book['nid']):
        logging.error("Book '{0}' with id {1} was not fetched on {2}. Trying again.".format(title, nid,
                                                                                pickle.loads(date).ctime()))
        retrys += 1
        check_book_or_retry(book_sess, retrys=retrys)
    logging.info("Todays book '{0}' was verified".format(title))
    return True

def check_last_book():
    last_book = get_last_book()
    todays_book = get_todays_book.get_todays_title()

    if not last_book:
        book_get = get_todays_book.login_and_request_book(todays_book['url'])
        if not book_get:
            logging.log(logging.ERROR, "Error getting todays book!")
            return False
        write_book_to_sql(todays_book)
        sleep_till_tomorrow()

    today_utc = datetime.datetime.utcnow().date()
    book_id, nid, title, date = last_book
    last_book_get = pickle.loads(date)
    # If todays book has already been grabbed
    if last_book_get == today_utc and todays_book['title'] == title:
        logging.info("Today's book \"{0}\", as already grabbed.".format(todays_book['title'].encode('utf-8', 'ignore'),))
        sleep_till_tomorrow()
    # If we have the date the same as the last grab, but the title is differnt, we try to grab the book
    elif last_book_get == today_utc and todays_book['title'] != title:
        book_get = get_todays_book.login_and_request_book(todays_book['url'])
        if not book_get:
            logging.log(logging.ERROR, "Error getting todays book!")
            return False
        write_book_to_sql(todays_book)
        sleep_till_tomorrow()
    # This is where we should end up for everyday
    else:
        try:
            book_get = get_todays_book.login_and_request_book(todays_book['url'])
        except get_todays_book.login_invalid:
            logging.fatal("Email or Password appears invalid! Cannot continue. Exiting.")
            sys.exit()
        if not book_get:
            logging.error("Error getting todays book!")
            return False
        write_book_to_sql(todays_book)
        check_book_or_retry(book_get)
        logging.info("{0} grabbed on {1}.".format(title, date))
        try:
            pushover_notifications.make_pushover_call("Todays book is '{0}'. Enjoy!".format(title))
        except HTTPError:
            logging.error("Pushover notificaion not working as expected.")
        sleep_till_tomorrow()

if __name__ == "__main__":
    check_last_book()<commit_msg>fixing a possible logic error<commit_after>import calendar
import datetime
import logging
import pickle
import sqlite3
from requests import HTTPError
import sys
import time

import get_todays_book
import pushover_notifications

logging.basicConfig(level=logging.INFO,
                    filename='packetpub_grabber.log',
                    format='%(asctime)s - %(levelname)s: %(message)s')

def get_tomorrow():
    return datetime.datetime.replace(datetime.datetime.utcnow() + datetime.timedelta(days=1),
                                     hour=0, minute=0, second=0)

def sleep_till_tomorrow():
    tomorrow = get_tomorrow()
    delta = tomorrow - datetime.datetime.utcnow()
    logging.info("Sleeping till {0}".format(tomorrow.ctime()))
    time.sleep(delta.seconds)
    return

def get_last_book():
    conn = sqlite3.connect('get_book.db')
    c = conn.cursor()
    try:
        sql_result = c.execute("SELECT * FROM last_book ORDER BY ID DESC LIMIT 1;")
        return sql_result.fetchone()
    except sqlite3.OperationalError:
        c.execute("CREATE TABLE last_book (id integer primary key autoincrement,nid integer, title text, date blob)")
        get_last_book()

def write_book_to_sql(book_data):
    with sqlite3.connect('get_book.db') as conn:
        c = conn.cursor()
        c.execute("INSERT INTO last_book (title, nid, date) VALUES (?, ?, ?)", (book_data['title'], book_data['nid'], pickle.dumps(datetime.datetime.utcnow().date())))
        conn.commit()
        logging.info("Grabbed {0} at {1}".format(book_data['title'], datetime.datetime.utcnow().ctime()))

def check_book_or_retry(book_sess, retrys=0):
    if retrys == 3:
        logging.error("Unbale to fetch book. We have reached max attempts. Bailing out.")
        try:
            pushover_notifications.make_pushover_call("Error getting today's book. Please check this out.")
        except HTTPError:
            logging.error("Pushover notificaion not working as expected.")
        sys.exit()
    my_last_book = get_todays_book.verify_todays_book(book_sess)
    if not my_last_book:
        logging.fatal("Email or Password appears invalid! Cannot continue. Exiting.")
        sys.exit()
    book_id, nid, title, date = get_last_book()
    if nid != int(my_last_book['nid']):
        logging.error("Book '{0}' with id {1} was not fetched on {2}. Trying again.".format(title, nid,
                                                                                pickle.loads(date).ctime()))
        retrys += 1
        check_book_or_retry(book_sess, retrys=retrys)
    logging.info("Todays book '{0}' was verified".format(title))
    return True

def check_last_book():
    last_book = get_last_book()
    todays_book = get_todays_book.get_todays_title()

    if not last_book:
        book_get = get_todays_book.login_and_request_book(todays_book['url'])
        if not book_get:
            logging.log(logging.ERROR, "Error getting todays book!")
            return False
        write_book_to_sql(todays_book)
        sleep_till_tomorrow()

    today_utc = datetime.datetime.utcnow().date()
    book_id, nid, title, date = last_book
    last_book_get = pickle.loads(date)
    # If todays book has already been grabbed
    if last_book_get == today_utc and todays_book['title'] == title:
        logging.info("Today's book \"{0}\", as already grabbed.".format(todays_book['title'].encode('utf-8', 'ignore'),))
        sleep_till_tomorrow()
    # If we have the date the same as the last grab, but the title is different, we try to grab the book
    elif last_book_get == today_utc and todays_book['title'] != title:
        logging.warning("We are seeing the same day, with differnt titles\n"
                        "Old Date:{0}\nNew Date:{1}".format(last_book_get, today_utc))
        book_get = get_todays_book.login_and_request_book(todays_book['url'])
        if not book_get:
            logging.log(logging.ERROR, "Error getting todays book!")
            return False
    # This is where we should end up for everyday
    else:
        try:
            book_get = get_todays_book.login_and_request_book(todays_book['url'])
        except get_todays_book.login_invalid:
            logging.fatal("Email or Password appears invalid! Cannot continue. Exiting.")
            sys.exit()
        if not book_get:
            logging.error("Error getting todays book!")
            return False

    write_book_to_sql(todays_book)
    check_book_or_retry(book_get)
    logging.info("{0} grabbed on {1}.".format(title, date))
    try:
        pushover_notifications.make_pushover_call("Todays book is '{0}'. Enjoy!".format(title))
    except HTTPError:
        logging.error("Pushover notificaion not working as expected.")
    sleep_till_tomorrow()

if __name__ == "__main__":
    check_last_book()<|endoftext|>