from django.shortcuts import render
from math import ceil
from django.views.generic import TemplateView
from django.core.urlresolvers import reverse
from django.shortcuts import render_to_response, render
from django.http import HttpResponseRedirect, HttpResponse
from django.template.context import RequestContext
from aplicaciones.proyectos.models import Proyectos
from aplicaciones.fases.models import Fases
from aplicaciones.items.models import Items, ValorItem
from aplicaciones.relaciones.models import Relaciones
from aplicaciones.lineabase.models import LineaBase
from aplicaciones.usuarios.models import Usuarios
from .models import Solicitudes, Votos, Credenciales
from .forms import SolicitudNuevaForm, SolicitudPrimeraForm, votarSolicitudForm
from datetime import datetime, date, timedelta
from django.contrib.auth.decorators import login_required, permission_required
from django.db.models import Q
from aplicaciones.comite.models import Comite
import logging

# Create your views here.
logger = logging.getLogger(__name__)

def administrar_solicitud_recibidas (request):

    """ Recibe un request, se verifica cual es el usuario registrado y se obtiene la lista de solicitudes
    recibidas con los que esta relacionado desplegandolo en pantalla.

    @type request: django.http.HttpRequest.
    @param request: Contiene informacion sobre la solicitud web actual que llamo a esta vista administrar_solicitud_recibidas.

    @rtype: django.shortcuts.render_to_response.
    @return: solicitudesrecibidas.html, donde se listan las solicitudes de modificacion de item recibidas.

    @author: Marcelo Denis.

    """

    comites = Comite.objects.filter(miembros=request.user)
    list_proyect = []
    for comite in comites:
        list_proyect.append(comite.proyecto)
    solicitudes = Solicitudes.objects.filter(proyecto__in=list_proyect, estado='Pendiente')

    pendientes = 0
    lista_solicitud=[]
    for s in solicitudes:
        votantes = s.miembros_que_votaron.all()
        solic_votada = False
        for votante in votantes:
            if votante == request.user:
                solic_votada = True
        tupla = (s, solic_votada)
        if not solic_votada:
            pendientes = pendientes + 1
        lista_solicitud.append(tupla)
    logger.info('Listado de Solicitudes recibidas, hecho por %s' % request.user.username)
    template_name='solicitudes/solicitudesrecibidas.html'
    ctx = {'lista_solicitud':lista_solicitud, 'pendientes':pendientes}
    return render_to_response(template_name, ctx, context_instance=RequestContext(request))

def administrar_solicitud_realizadas (request):

    """ Recibe un request, se verifica cual es el usuario registrado y se obtiene la lista de solicitudes
    realizadas con los que esta relacionado desplegandolo en pantalla.

    @type request: django.http.HttpRequest.
    @param request: Contiene informacion sobre la solicitud web actual que llamo a esta vista administrar_solicitud_realizadas.

    @rtype: django.shortcuts.render_to_response.
    @return: solicitudesrealizadas.html, donde se listan las solicitudes de modificacion de item realizadas.

    @author: Marcelo Denis.

    """

    solicitudes = Solicitudes.objects.filter(usuario=request.user)
    logger.info('Listado de solicitudes realizadas, hecho por %s' % request.user.username)
    template_name='solicitudes/solicitudesrealizadas.html'
    ctx = {'solicitudes':solicitudes}
    return render_to_response(template_name, ctx, context_instance=RequestContext(request))

def crear_solicitud(request, id_proyecto, id_fase, id_item):
    """ Recibe un request, se verifica cual es el usuario registrado y el proyecto del cual se solicita,
    se obtiene la lista de fases con las que estan relacionados el usuario y el proyecto
    desplegandola en pantalla, ademas permite realizar busquedas avanzadas sobre
    las fases que puede mostrar.

    @type request: django.http.HttpRequest.
    @param request: Contiene informacion sobre la solicitud web actual que llamo a esta vista.

    @rtype: django.shortcuts.render_to_response.
    @return: fases.html, donde se listan las fases, ademas de las funcionalidades para cada fase.

    @author: Ysapy Ortiz.

    """
    proyecto = Proyectos.objects.get(id=id_proyecto)
    fase = Fases.objects.get(id=id_fase)
    item = Items.objects.get(id=id_item)
    if proyecto.estado=='Finalizado':
        mensaje = 'El proyecto se encuentra finalizado, no se puede solicitar modificaciones.'
        template_name='./solicitudes/solicitudalerta.html'
        ctx = {'mensaje': mensaje, 'id_proyecto':id_proyecto, 'id_fase': id_fase, 'id_item': id_item, 'proyecto':proyecto, 'fase':fase, 'item': item}
        return render_to_response(template_name, ctx, context_instance=RequestContext(request))
    try:
        credencial = Credenciales.objects.get(item_id=item.id, estado='Habilitado')
    except Credenciales.DoesNotExist:
        credencial = False
    if credencial:
        mensaje = 'Ya existe una solicitud aprobada en proceso para el item seleccionado.'
        template_name='./solicitudes/solicitudalerta.html'
        ctx = {'mensaje': mensaje, 'id_proyecto':id_proyecto, 'id_fase': id_fase, 'id_item': id_item, 'proyecto':proyecto, 'fase':fase, 'item': item}
        return render_to_response(template_name, ctx, context_instance=RequestContext(request))
    usuariosolic = Usuarios.objects.get(user_id=request.user.id)
    solicituditem = Solicitudes.objects.filter(item=item, estado='Pendiente', usuario=usuariosolic)
    if solicituditem:
        mensaje = 'Ya existe una solicitud pendiente para el item seleccionado.'
        template_name='./solicitudes/solicitudalerta.html'
        ctx = {'mensaje': mensaje, 'id_proyecto':id_proyecto, 'id_fase': id_fase, 'id_item': id_item, 'proyecto':proyecto, 'fase':fase, 'item': item}
        return render_to_response(template_name, ctx, context_instance=RequestContext(request))

    if request.method == 'POST':
        form = SolicitudNuevaForm(request.POST)
        if form.is_valid():
            usuarionuevo = request.user
            proyectonuevo = proyecto
            fasenueva = fase
            itemnuevo = item
            fechasolic = datetime.today()
            tiemposolic = form.cleaned_data['Tiempo_Solicitado_en_Dias']
            descripcion = form.cleaned_data['Descripcion']
            observaciones = form.cleaned_data['Observaciones']
            estado = 'Pendiente'
            duracionsolic = form.cleaned_data['Duracion_Solicitud_en_Dias']

            solicitud = Solicitudes()
            solicitud.usuario_id = usuarionuevo.id
            solicitud.proyecto_id = proyectonuevo.id
            solicitud.fase_id = fasenueva.id
            solicitud.item_id = itemnuevo.id
            solicitud.fecha_solicitud = fechasolic
            solicitud.tiempo_solicitado = tiemposolic
            solicitud.descripcion = descripcion
            solicitud.observaciones = observaciones
            solicitud.estado = estado
            solicitud.tiempo_esperado = duracionsolic
            solicitud.votos_rechazado = 0
            solicitud.votos_aprobado = 0
            solicitud.save()
            logger.info('Creacion de Solicitud de cambio id %s, hecho por %s' % (solicitud.id, request.user.username))
            mensaje = 'Solicitud creada con exito.'
            template_name='./solicitudes/solicitudcreada.html'
            ctx = {'mensaje': mensaje, 'id_proyecto':id_proyecto, 'id_fase': id_fase, 'id_item': id_item, 'proyecto':proyecto, 'fase':fase, 'item': item}
            return render_to_response(template_name, ctx, context_instance=RequestContext(request))

            #return render(request, template_name, {'id_proyecto': id_proyecto, 'id_fase': id_fase, 'id_item': id_item, 'id_tipoitem': id_tipoitem, 'lista_valores': lista_valores, 'lista_atributos': lista_atributos})
    else:
        fechasolic = datetime.today()
        estado = 'Pendiente'
        data = {'Proyecto': proyecto, 'Fase': fase, 'Item': item, 'Fecha_de_Solicitud': fechasolic, 'Estado': estado}
        form = SolicitudPrimeraForm(data)

    template_name='./solicitudes/solicitudnueva.html'
    return render(request, template_name, {'form': form, 'id_proyecto':id_proyecto, 'id_fase': id_fase, 'id_item': id_item, 'proyecto':proyecto, 'fase':fase, 'item': item})

def cancelar_solicitud(request, id_solicitud):
    """ Recibe un request, se verifica cual es el usuario registrado y el proyecto del cual se solicita,
    se obtiene la lista de fases con las que estan relacionados el usuario y el proyecto
    desplegandola en pantalla, ademas permite realizar busquedas avanzadas sobre
    las fases que puede mostrar.

    @type request: django.http.HttpRequest.
    @param request: Contiene informacion sobre la solicitud web actual que llamo a esta vista.

    @rtype: django.shortcuts.render_to_response.
    @return: fases.html, donde se listan las fases, ademas de las funcionalidades para cada fase.

    @author: Ysapy Ortiz.

    """
    solicitud = Solicitudes.objects.get(id=id_solicitud)
    solicitud.estado = 'Cancelado'
    solicitud.save()
    proyecto = solicitud.proyecto
    fase = solicitud.fase

    mensaje = 'Solicitud eliminada con exito.'
    logger.info('Cancelacion de solicitud id %s, hecho por %s' % (solicitud.id, request.user.username))
    template_name='./solicitudes/solicitudalerta.html'
    ctx = {'mensaje': mensaje, 'proyecto':proyecto, 'fase':fase}
    return render_to_response(template_name, ctx, context_instance=RequestContext(request))

def consultar_solicitud(request, id_solicitud):
    """ Recibe un request, se verifica cual es el usuario registrado y el proyecto del cual se solicita,
    se obtiene la lista de fases con las que estan relacionados el usuario y el proyecto
    desplegandola en pantalla, ademas permite realizar busquedas avanzadas sobre
    las fases que puede mostrar.

    @type request: django.http.HttpRequest.
    @param request: Contiene informacion sobre la solicitud web actual que llamo a esta vista.

    @rtype: django.shortcuts.render_to_response.
    @return: fases.html, donde se listan las fases, ademas de las funcionalidades para cada fase.

    @author: Ysapy Ortiz.

    """
    solicitud = Solicitudes.objects.get(id=id_solicitud)
    proyecto = solicitud.proyecto
    fase = solicitud.fase
    #item = Items.objects.get(proyecto_id=id_proyecto, fase_id=id_fase, id=id_item)
    # conseguir el contexto de las fases y sus estados
    #fases = Fases.objects.filter(id_proyecto = id_proyecto)
    logger.info('Consultad de solicitud con id %s, hecho por %s' % (solicitud.id, request.user.username))
    template_name = './solicitudes/consultarsolicitud.html'
    return render(request, template_name, {'fase': fase, 'proyecto':proyecto, 'fase':fase, 'solicitud': solicitud})

def votar_solicitud(request, id_solicitud):
    """ Recibe un request y el id de la solicitud  que se quiere  votar.
    Se retorna un html que indica al usuario que proceda a aceptar, rechazar la solicitud o
    cancelar la operacion de votar la solicitud

    @type request: django.http.HttpRequest.
    @param request: Contiene informacion sobre la solicitud web actual que llamo a esta vista.

    @rtype: HttpRequest.HttpResponse
    @return: votar.html, donde se solicita el voto a  favor o en contra del miembro del comite

    @author: Eduardo Gimenez

    """

    if request.method == 'POST':
        form = votarSolicitudForm(request.POST)
        if form.is_valid():
            voto = form.cleaned_data['voto']
            solicitud = Solicitudes.objects.get(id = id_solicitud)
            #Registramos el voto del usuario miembro de comite
            if voto == "A":
                miVoto = Votos(miembro=request.user, solicitud=solicitud, fechaDeVotacion=datetime.today(), voto="A")
            else:
                miVoto = Votos(miembro=request.user, solicitud=solicitud, fechaDeVotacion=datetime.today(), voto="R")
            miVoto.save()
            comite = Comite.objects.get(proyecto=solicitud.proyecto)
            cantidad_miembros = comite.miembros.count()
            promedio = int(ceil(cantidad_miembros/2)) + 1
            #Calculamos la  cantidad de votos a favor  y en contra
            votos = Votos.objects.filter(solicitud=solicitud)
            votosAprobado = 0
            votosRechazado = 0
            for votoMiembro in votos:
                if votoMiembro.voto == 'A':
                    votosAprobado = votosAprobado + 1
                if votoMiembro.voto == 'R':
                    votosRechazado = votosRechazado + 1
            #Verificamos los votos para rechazar o aprobar la  solicitud
            cantidad_votos = votosAprobado + votosRechazado
            if cantidad_votos==cantidad_miembros:
                try:
                    credencialitem = Credenciales.objects.get(item_id=solicitud.item_id, estado='Habilitado')
                except Credenciales.DoesNotExist:
                    credencialitem = False
                if credencialitem:
                    solicitud.estado = 'Cancelado'
                    solicitud.save()
                    mensaje = 'Ya existe una solicitud aprobada en proceso para el item. Esta solicitud ha sido descartada.'
                    template_name='./solicitudes/solicitudalerta.html'
                    ctx = {'mensaje': mensaje}
                    return render_to_response(template_name, ctx, context_instance=RequestContext(request))
                if votosAprobado > votosRechazado:
                    solicitud.estado = 'Aprobada'
                    credencial = Credenciales()
                    credencial.usuario = solicitud.usuario
                    credencial.proyecto = solicitud.proyecto
                    credencial.fase = solicitud.fase
                    credencial.item = solicitud.item
                    credencial.version = solicitud.item.version
                    credencial.fecha_aprobacion = date.today()
                    credencial.fecha_expiracion = date.today()+timedelta(days=solicitud.tiempo_solicitado)
                    credencial.estado = 'Habilitado'
                    solicitud.save()
                    credencial.save()
                    logger.info('Generacion de credencial id %s, hecho por %s' % (credencial.id, request.user.username))
                    habilitar_items(credencial)
                    mensaje = 'Credencial Generada'
                    template_name='./solicitudes/credencialcreada.html'
                    ctx = {'mensaje': mensaje, 'credencial': credencial}
                    return render_to_response(template_name, ctx, context_instance=RequestContext(request))
                else:
                    solicitud.estado = 'Reprobada'
                    mensaje = 'La solicitud ha sido Reprobada'
            else:
                mensaje = 'Su voto ha sido procesado'

            logger.info('Votacion de solicitud con id %d, hecho por %s' % (solicitud.id, request.user.username))
            solicitud.save()
            template_name='./solicitudes/solicitudalerta.html'
            ctx = {'mensaje': mensaje}
            return render_to_response(template_name, ctx, context_instance=RequestContext(request))

    else:
        form = votarSolicitudForm()
    template_name='./solicitudes/votarsolicitud.html'
    return render(request, template_name, {'form': form, 'id_solicitud':id_solicitud})

def impacto(request, id_proyecto, id_fase, id_item):
    """ Recibe un request, se verifica cual es el usuario registrado y el proyecto del cual se solicita,
    se obtiene la lista de fases con las que estan relacionados el usuario y el proyecto
    desplegandola en pantalla, ademas permite realizar busquedas avanzadas sobre
    las fases que puede mostrar.

    @type request: django.http.HttpRequest.
    @param request: Contiene informacion sobre la solicitud web actual que llamo a esta vista.

    @rtype: django.shortcuts.render_to_response.
    @return: fases.html, donde se listan las fases, ademas de las funcionalidades para cada fase.

    @author: Ysapy Ortiz.

    """
    item = Items.objects.get(id=id_item)

    imonetario = impacto_monetario(id_item)
    itemporal = impacto_temporal(id_item)
    items_afectado = calcular_items_afectados(id_item)
    items_afectados = []
    for items_af in items_afectado:
        if items_af.id!=item.id:
            items_afectados.append(items_af)

    logger.info('Calculo de impacto para item %s para la Solicitud de cambio, hecho por %s' % (item.nombre, request.user.username))
    ctx = {'id_proyecto':id_proyecto, 'id_fase': id_fase, 'id_item': id_item, 'impacto_monetario': imonetario, 'impacto_temporal': itemporal, 'items_afectados': items_afectados}
    template_name = './items/impacto.html'
    return render_to_response(template_name, ctx, context_instance=RequestContext(request))

def impacto_monetario(id_item):
    """ Recibe un request, se verifica cual es el usuario registrado y el proyecto del cual se solicita,
    se obtiene la lista de fases con las que estan relacionados el usuario y el proyecto
    desplegandola en pantalla, ademas permite realizar busquedas avanzadas sobre
    las fases que puede mostrar.

    @type request: django.http.HttpRequest.
    @param request: Contiene informacion sobre la solicitud web actual que llamo a esta vista.

    @rtype: django.shortcuts.render_to_response.
    @return: fases.html, donde se listan las fases, ademas de las funcionalidades para cada fase.

    @author: Ysapy Ortiz.

    """
    item = Items.objects.get(id=id_item)
    costo = 0
    try:
        hijos = Items.objects.filter(padre=id_item)
    except Items.DoesNotExist:
        hijos = False
    if hijos:
        for hijo in hijos:
            costo = costo + impacto_monetario(hijo.id)
        costo = costo + item.costoMonetario
        return costo
    else:
        return item.costoMonetario

def impacto_temporal(id_item):
    """ Recibe un request, se verifica cual es el usuario registrado y el proyecto del cual se solicita,
    se obtiene la lista de fases con las que estan relacionados el usuario y el proyecto
    desplegandola en pantalla, ademas permite realizar busquedas avanzadas sobre
    las fases que puede mostrar.

    @type request: django.http.HttpRequest.
    @param request: Contiene informacion sobre la solicitud web actual que llamo a esta vista.

    @rtype: django.shortcuts.render_to_response.
    @return: fases.html, donde se listan las fases, ademas de las funcionalidades para cada fase.

    @author: Ysapy Ortiz.

    """
    item = Items.objects.get(id=id_item)
    costo = 0
    try:
        hijos = Items.objects.filter(padre=id_item)
    except Items.DoesNotExist:
        hijos = False
    if hijos:
        for hijo in hijos:
            costo = costo + impacto_temporal(hijo.id)
        costo = costo + item.costoTemporal
        return costo
    else:
        return item.costoTemporal

def calcular_items_afectados(id_item):
    """ Recibe un request, se verifica cual es el usuario registrado y el proyecto del cual se solicita,
    se obtiene la lista de fases con las que estan relacionados el usuario y el proyecto
    desplegandola en pantalla, ademas permite realizar busquedas avanzadas sobre
    las fases que puede mostrar.

    @type request: django.http.HttpRequest.
    @param request: Contiene informacion sobre la solicitud web actual que llamo a esta vista.

    @rtype: django.shortcuts.render_to_response.
    @return: fases.html, donde se listan las fases, ademas de las funcionalidades para cada fase.

    @author: Ysapy Ortiz.

    """
    item = Items.objects.get(id=id_item)
    lista_hijos = []
    try:
        hijos = Items.objects.filter(padre=id_item)
    except Items.DoesNotExist:
        hijos = False
    if hijos:
        for hijo in hijos:
            lista_hijos.extend(calcular_items_afectados(hijo.id))
        lista_hijos.append(item)
        return lista_hijos
    else:
        lista_hijos.append(item)
        return lista_hijos

def habilitar_items(credencial):
    """ Recibe un request, se verifica cual es el usuario registrado y el proyecto del cual se solicita,
    se obtiene la lista de fases con las que estan relacionados el usuario y el proyecto
    desplegandola en pantalla, ademas permite realizar busquedas avanzadas sobre
    las fases que puede mostrar.

    @type request: django.http.HttpRequest.
    @param request: Contiene informacion sobre la solicitud web actual que llamo a esta vista.

    @rtype: django.shortcuts.render_to_response.
    @return: fases.html, donde se listan las fases, ademas de las funcionalidades para cada fase.

    @author: Ysapy Ortiz.

    """
    item = Items.objects.get(id=credencial.item_id)
    fase = Items.objects.get(id=credencial.fase_id)
    lineasbase = LineaBase.objects.filter(fase_id=credencial.fase_id)
    items = []
    for lb in lineasbase:
        itemslb = lb.items.all()
        if item in itemslb:
            lineabase = lb
            items = lineabase.items.all()
            lineabase.is_active = False
            lineabase.save()

    for itemhijo in items:
        if itemhijo.estado=='Bloqueado' or itemhijo.estado=='Validado':
            itemhijo.estado='En Revision'
            itemhijo.save()

    lista_hijos = calcular_items_afectados(item.id)
    for hijo in lista_hijos:
        if hijo.estado=='Bloqueado' or hijo.estado=='Validado':
            hijo.estado = 'En Revision'
            hijo.save()
    item.estado = 'Habilitado'
    item.save()

def administrar_credenciales (request):

    """ Recibe un request, se verifica cual es el usuario registrado y se obtiene la lista de credenciales
    habilitadas con los que esta relacionado desplegandolo en pantalla.

    @type request: django.http.HttpRequest.
    @param request: Contiene informacion sobre la solicitud web actual que llamo a esta vista administrar_credenciales.

    @rtype: django.shortcuts.render_to_response.
    @return: credenciales.html, donde se listan las credenciales de modificacion de item habilitadas.

    @author: Marcelo Denis.

    """

    credenciales = Credenciales.objects.filter(usuario=request.user)
    logger.info('Listado de Credenciales, hecho por %s' % request.user.username)
    template_name='solicitudes/credenciales.html'
    ctx = {'lista_credenciales':credenciales}
    return render_to_response(template_name, ctx, context_instance=RequestContext(request))

def consultarCredencial(request, id_credencial):

    """ Recibe un request, se verifica cual es el usuario registrado y despliega los
     datos que pertenece a la credencial que se consulta

    @type request: django.http.HttpRequest.
    @param request: Contiene informacion sobre la solicitud web actual que llamo a esta vista administrar_credenciales.

    @rtype: django.shortcuts.render_to_response.
    @return: consultar_credencial.html, donde se despliega los datos de la credencial.

    @author: Eduardo Gimenez.

    """

    credencial = Credenciales.objects.get(id=id_credencial)
    logger.info('Consulta de credncial con id %s, hecho por %s' % (credencial.id, request.user.username))
    template_name='solicitudes/consultar_credencial.html'
    ctx = {'credencial':credencial}
    return render_to_response(template_name, ctx, context_instance=RequestContext(request))

def cancelar_credencial(request, id_credencial):
    """ Recibe un request, se verifica cual es el usuario registrado y el proyecto del cual se solicita,
    se obtiene la lista de fases con las que estan relacionados el usuario y el proyecto
    desplegandola en pantalla, ademas permite realizar busquedas avanzadas sobre
    las fases que puede mostrar.

    @type request: django.http.HttpRequest.
    @param request: Contiene informacion sobre la solicitud web actual que llamo a esta vista.

    @rtype: django.shortcuts.render_to_response.
    @return: fases.html, donde se listan las fases, ademas de las funcionalidades para cada fase.

    @author: Ysapy Ortiz.

    """
    credencial = Credenciales.objects.get(id=id_credencial)

    lbs = LineaBase.objects.filter(fase_id=credencial.fase.id)
    eslb = False
    for lb in lbs:
        items = lb.items.all()
        for item in items:
            if credencial.item_id==item.id:
                eslb = lb
    if eslb:
        items = eslb.items.all()
        for item in items:
            item.estado = 'Bloqueado'
            item.save()
        eslb.is_active = True
        eslb.save()
    credencial.estado='Finalizado'
    credencial.save()

    revertir_credencial(credencial.proyecto_id, credencial.fase_id, credencial)

    mensaje = 'Credencial cancelada.'
    logger.info('Cancelacion de Credencial con id %s, hecho por %s' % (credencial.id, request.user.username))
    template_name='./solicitudes/solicitudalerta.html'
    ctx = {'mensaje': mensaje}
    return render_to_response(template_name, ctx, context_instance=RequestContext(request))

def revertir_credencial(id_proyecto, id_fase, credencial):
    version_anterior = credencial.version
    item = Items.objects.get(id=credencial.item_id)
    version_actual = item.version
    if version_actual>version_anterior:
        for i in range(version_anterior+1,version_actual+1):
            atributositem = ValorItem.objects.filter(proyecto_id=id_proyecto, fase_id=id_fase, item_id=item.id, version=i)
            if atributositem:
                for atrib in atributositem:
                    atrib.version=0
                    atrib.save()
            try:
                relacionitem = Relaciones.objects.get(item=item.id, version=i)
            except Relaciones.DoesNotExist:
                relacionitem = False
            if relacionitem:
                relacionitem.version = 0
                relacionitem.save()
    item.version = version_anterior
    item.save()


import streamlit as st
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
from sklearn.metrics import f1_score
from sklearn.metrics import recall_score
from sklearn.metrics import precision_score
import numpy as np
from sklearn.model_selection import cross_val_score

def load_data():
    data = pd.read_csv('train.csv')
    return data

data = load_data()

duplicated = data[data.duplicated(keep=False)]
duplicated = duplicated.sort_values(by=['gender', 'height', 'weight'], ascending= False)
duplicated.head()
data.drop_duplicates(keep = 'first', inplace = True)
st.write('Total {} datapoints remaining with {} features'.format(data.shape[0], data.shape[1]))

X = data.drop(['cardio', 'id'], axis=1,)
data.drop('id', axis=1, inplace = True)
y = data['cardio']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=65)

# Обучение модели случайного леса
best_model = None
best_accuracy = 0

for est in range(1,15):
    model = RandomForestClassifier(
        random_state=42,
        n_estimators=est,
        max_depth=5,
        #min_samples_split=8,
        #min_samples_leaf=3,
        #max_features='auto'
    )
    cv_scores = cross_val_score(model, X_test, y_test, cv=5, scoring='accuracy')
    model.fit(X_train, y_train)
    result = model.score(X_test, y_test)

    if result > best_accuracy:
        best_model = model
        best_accuracy = result
st.write('Точность модели на тестовых данных:', best_accuracy)
st.write("Средняя точность:", cv_scores.mean())

test_score = best_model.score(X_test, y_test)
st.write('accuracy on test:', test_score)

y_pred = model.predict(X_test)

def calc_metrics(prefix, model, X_test, y_test, y_pred):

    accuracy = accuracy_score(y_test, y_pred)
    precision = precision_score(y_test, y_pred)
    recall = recall_score(y_test, y_pred)
    f1 = f1_score(y_test, y_pred)

    st.write('Accuracy:', accuracy)
    st.write('Precision:', precision)
    st.write('Recall:', recall)
    st.write('F1-Score:', f1)

calc_metrics('RF', model, X_test, y_test, y_pred)

st.title('Предсказание сердечно-сосудистых заболеваний')

st.sidebar.header('Введите данные пациента:')
# Ввод данных
age = st.sidebar.number_input('Возраст', min_value=1, max_value=100)
gender = st.sidebar.radio('Пол', ('Мужчина', 'Женщина'))
height = st.sidebar.number_input('Рост (в см)', min_value=50, max_value=250)
weight = st.sidebar.number_input('Вес (в кг)', min_value=10, max_value=500)
cholesterol = st.sidebar.selectbox('Холестерин', ('Низкий','Нормальный', 'Высокий'))
smoke = bool(st.sidebar.checkbox('Курит ли пациент?'))
alco = bool(st.sidebar.checkbox('Пьет ли пациент?'))
gluc = st.sidebar.selectbox('Уровень глюкозы', ('Низкий','Нормальный', 'Высокий'))
ap_hi = st.sidebar.number_input('Верхнее давление (ap_hi)', min_value=1)
ap_lo = st.sidebar.number_input('Нижнее давление (ap_lo)', min_value=1)
active = st.sidebar.radio('Активность', ('Активный', 'Не активный'))

# Преобразование входных данных в числовые значения
gender_mapping = {'Мужчина': 1, 'Женщина': 2}
cholesterol_mapping = {'Низкий': 1,'Нормальный': 2, 'Высокий': 3}
gluc_mapping = {'Низкий': 1,'Нормальный': 2, 'Высокий': 3}
active_mapping = {'Активный': 1, 'Не активный': 0}
smoke_mapping = {'Не курит': 0, 'Курит': 1}
alco_mapping = {'Не пьет': 0, 'Пьет': 1}

gender = gender_mapping[gender]
cholesterol = cholesterol_mapping[cholesterol]
gluc = gluc_mapping[gluc]
active = active_mapping[active]
smoke = int(smoke)
alco = int(alco)

# Создание массива с введенными данными
user_data = [age, gender, height, weight, cholesterol, smoke, alco, gluc, ap_hi, ap_lo, active]

# Предсказание
if st.sidebar.button('Предсказать'):
    st.write('user_data:', user_data)
    prediction = model.predict([user_data])
    st.write(prediction)
    if prediction[0] == 1:
        st.error('Пациент имеет риск сердечно-сосудистого заболевания.')
    else:
        st.success('Пациент не имеет риска сердечно-сосудистого заболевания.')
st.subheader('Данные из CSV:')
st.write('Список признаков в данных из CSV:', data.columns.tolist())

st.write(data)


import io
import requests
import datetime
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from functools import lru_cache
import bs4
import json

def get_regions():
    regions_url = 'https://covid-api.com/api/regions'
    response = requests.request("GET", regions_url).json()
    return {i['name']: i['iso'] for i in response['data']}

def get_report(iso, date=datetime.datetime.now().date() - datetime.timedelta(days=2)):
    report_url = 'https://covid-api.com/api/reports'
    response = requests.request("GET", report_url, params={'date': date, 'iso': iso}).json()

    res = {'date': date}
    for i in response['data']:
        res['confirmed'] = res.get('confirmed', 0) + i['confirmed']
        res['deaths'] = res.get('deaths', 0) + i['deaths']
        res['recovered'] = res.get('recovered', 0) + i['recovered']
        res['confirmed_diff'] = res.get('confirmed_diff', 0) + i['confirmed_diff']
        res['deaths_diff'] = res.get('deaths_diff', 0) + i['deaths_diff']
        res['recovered_diff'] = res.get('recovered_diff', 0) + i['recovered_diff']
        res['active'] = res.get('active', 0) + i['active']
        res['active_diff'] = res.get('active_diff', 0) + i['active_diff']

    res['fatality_rate'] = res.get('deaths', 0) / res.get('confirmed', 1)

    return res

def get_total_report(date=datetime.datetime.now().date() - datetime.timedelta(days=1)):
    report_url = 'https://covid-api.com/api/reports/total'
    response = requests.request("GET", report_url, params={'date': date}).json()
    return response['data']

# print(get_regions())
# print(get_report("AUS"))

# получение списка стран, словарь "русское название: ISO" в reg_iso_ru
with open('countries.txt', 'r', encoding='utf-8') as countries_file:
    countries_list = countries_file.read().split('\n')
    countries_dict = {}
    for i in countries_list:
        country = i.split('\t')
        countries_dict[country[1]] = country[0]

reg_dict = get_regions()
reg_iso_ru = {}

for i in reg_dict.keys():
    if i in countries_dict.keys():
        reg_iso_ru[countries_dict[i].lower()] = reg_dict[i]
    else:
        print(f"MISMATCH: {i}")

def get_report_ru(country, *kwargs):
    iso = reg_iso_ru[country]
    return get_report(iso, kwargs)

def get_total_report_ru(country, *kwargs):
    iso = reg_iso_ru[country]
    return get_total_report(iso, kwargs)

def daterange(start_date, end_date):
    for n in range(int((end_date - start_date).days)):
        yield start_date + datetime.timedelta(n)

def get_dynamic_plot(country, end_date=False, start_date=False):

    if not end_date or end_date == datetime.datetime.now().date():
        end_date = datetime.datetime.now().date() - datetime.timedelta(days=2)
    if not start_date:
        start_date = end_date - datetime.timedelta(days=7)

    if start_date > end_date:
        start_date, end_date = end_date, start_date

    data = pd.DataFrame()
    countdate = 0
    for date in daterange(start_date, end_date):
        idata = get_report_ru(country, date.strftime('%Y-%m-%d'))

        idata['date'] = date.strftime('%Y-%m-%d')

        idata = pd.DataFrame({k: [v] for k, v in idata.items()})
        data = data.append(pd.DataFrame(idata)).reset_index(drop=True)[['date', 'confirmed',
                                                                        'recovered', 'deaths', 'active']]

        countdate += 1

    if len(data) == 0:
        return 0

    data = data.rename(columns={
        'confirmed': 'Заражённых всего',
        'active': 'Заражённых сейчас',
        'recovered': 'Выздоровевших',
        'deaths': 'Умерших'
    })

    data = pd.melt(data, id_vars=['date'], value_vars=['Заражённых всего', 'Заражённых сейчас',
                                                       'Выздоровевших', 'Умерших'])

    data = data.rename(columns={'variable': 'Легенда'})

    plt.figure()
    if 10 < countdate <= 20:
        height = 8
    elif 20 < countdate <= 30:
        height = 12
    elif 30 < countdate:
        height = 15
    else:
        height = 5

    g = sns.catplot(x='date', y='value', hue='Легенда', data=data, kind='point', height=height)

    (g.set_axis_labels("", "Кол. человек")
     .set_xticklabels(rotation=60)
     .despine(left=True))

    buf = io.BytesIO()
    g.savefig(buf, format='jpg')
    # g.savefig('test.jpg')

    return buf.getvalue(), get_report_ru(country, end_date.strftime('%Y-%m-%d'))

def get_ru_regions_data(*regions):
    data = requests.get("https://стопкоронавирус.рф/information/").text

    doc = bs4.BeautifulSoup(data, "html.parser")
    objs = json.loads(doc.select_one('cv-spread-overview')[':spread-data'])
    res = []
    if len(regions) > 0:
        for obj in objs:
            if obj['title'] not in regions:
                continue
            res.append({
                'name': obj['title'],
                'confirmed': obj['sick'],
                'recovered': obj['healed'],
                'deaths': obj['died'],
                'active': obj['sick'] - obj['healed'] - obj['died'],
                'confirmed_diff': obj['sick_incr'],
                'recovered_diff': obj['healed_incr'],
                'deaths_diff': obj['died_incr'],
                'active_diff': obj['sick_incr'] - obj['healed_incr'] - obj['died_incr'],
                'fatality_rate': obj['died'] / obj.get('sick', 1)
            })
    else:
        for obj in objs:
            res.append({
                'name': obj['title'],
                'confirmed': obj['sick'],
                'recovered': obj['healed'],
                'deaths': obj['died'],
                'active': obj['sick'] - obj['healed'] - obj['died'],
                'confirmed_diff': obj['sick_incr'],
                'recovered_diff': obj['healed_incr'],
                'deaths_diff': obj['died_incr'],
                'active_diff': obj['sick_incr'] - obj['healed_incr'] - obj['died_incr'],
                'fatality_rate': obj['died'] / obj.get('sick', 1)
            })

    return res

# print(get_dynamic_plot('Россия'))


# -*- coding:utf-8 -*-
import cv2 as cv
import os
import torch
from natsort import natsorted
from torchvision import transforms

def read_cube(path):
    # print(path)
    imgs = []
    names = natsorted(os.listdir(path))
    for name in names:
        img = cv.imread(os.path.join(path, name), cv.IMREAD_COLOR)
        img = img[:,:,:1]
        # print(path, name, img.shape)
        img = transforms.ToTensor()(img)
        imgs.append(img)
    imgs = torch.stack(imgs, dim=1)
    return imgs

def check_interpolation(imgs, target_cube_size):
    if target_cube_size[-1] != imgs.shape[-1] or target_cube_size[-2] != imgs.shape[-2] or target_cube_size[-3] != \
            imgs.shape[-3]:
        imgs = imgs.unsqueeze(0)
        imgs = torch.nn.functional.interpolate(imgs, size=target_cube_size, mode='trilinear', align_corners=True)
        imgs = imgs.squeeze(0)
    return imgs

def augmentation_torch_multi(images):
    #horizontal flip
    if torch.randint(0, 2, (1,)).item()==0:
        for i in range(len(images)):
            images[i] = torch.flip(images[i], dims=(1,))
    #Vertical flip
    if torch.randint(0, 2, (1,)).item()==0:
        for i in range(len(images)):
            images[i] = torch.flip(images[i], dims=(3,))
    #rot90
    if torch.randint(0, 2, (1,)).item()==0:
        k=torch.randint(1, 4, (1,)).item()
        for i in range(len(images)):
            images[i] = torch.flip(images[i], dims=(3,))
            images[i]=torch.rot90(images[i],k,dims=(1,3))
    for i in range(len(images)):
        images[i] = images[i].detach()
    return images


from typing import Any, Iterator
import io

Map = tuple[tuple[int]]

def find_height_edges(forest: Iterator[Iterator[int]]):
    for line in forest:
        seen: list[int | None] = [None for _ in range(10)]
        for index, height in enumerate(line):
            if seen[height] is None:
                seen[height] = index
                for smaller in range(height):
                    if seen[smaller] is None:
                        seen[smaller] = -1
        yield [index if index != -1 else None for index in seen]

def find_visible(edge_left, edge_right, edge_top, edge_bottom, size: int):
    visible = set()
    for line_idx, row_indices in enumerate(edge_left):
        visible.update(
            (line_idx, row_idx) for row_idx in row_indices if row_idx is not None
        )
    for line_idx, row_indices in enumerate(edge_right):
        visible.update(
            (line_idx, size - row_idx - 1) for row_idx in row_indices if row_idx is not None
        )
    for row_idx, line_indices in enumerate(edge_top):
        visible.update(
            (line_idx, row_idx) for line_idx in line_indices if line_idx is not None
        )
    for row_idx, line_indices in enumerate(edge_bottom):
        visible.update(
            (size - line_idx - 1, row_idx) for line_idx in line_indices if line_idx is not None
        )
    return len(visible)

def scenic_score(down: int, right: int, forest: Map) -> int:
    own_height = forest[down][right]
    score = 1
    for line in (
        (row[right] for row in forest[:down][::-1]),  # up
        forest[down][:right][::-1],  # left
        forest[down][right+1:],  # right
        (row[right] for row in forest[down+1:]),  # down
    ):
        distance = 0
        for distance, height in enumerate(line, start=1):
            if height >= own_height:
                break
        score *= distance
    return score

def solve(data: io.StringIO) -> tuple[Any, Any]:
    board = tuple(tuple(int(tree) for tree in line.strip()) for line in data)
    edge_left = tuple(find_height_edges(board))
    edge_right = tuple(find_height_edges(reversed(line) for line in board))
    edge_top = tuple(find_height_edges(zip(*board)))
    edge_bottom = tuple(find_height_edges(reversed(line) for line in zip(*board)))
    size = len(board)
    max_score = max(
        scenic_score(down, right, board)
        for down in range(1, size)
        for right in range(1, size)
    )
    return find_visible(edge_left, edge_right, edge_top, edge_bottom, size), max_score


# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import datetime as dt
import numpy as np
import matplotlib.pyplot as mp
import matplotlib.dates as md

def dmy2ymd(dmy):
    dmy = str(dmy, encoding='utf-8')
    date = dt.datetime.strptime(dmy, '%d-%m-%Y').date()
    ymd = date.strftime('%Y-%m-%d')
    return ymd
dates, opening_prices, highest_prices, \
    lowest_prices, closing_prices = np.loadtxt(
        '../../data/aapl.csv', delimiter=',',
        usecols=(1, 3, 4, 5, 6), unpack=True,
        dtype='M8[D], f8, f8, f8, f8',
        converters={1: dmy2ymd})
trend_points = (highest_prices + lowest_prices +
                closing_prices) / 3
spreads = highest_prices - lowest_prices
resistance_points = trend_points + spreads
support_points = trend_points - spreads
days = dates.astype(int)
a = np.column_stack((days, np.ones_like(days)))
x = np.linalg.lstsq(a, trend_points)[0]
trend_line = days * x[0] + x[1]
x = np.linalg.lstsq(a, resistance_points)[0]
resistance_line = days * x[0] + x[1]
x = np.linalg.lstsq(a, support_points)[0]
support_line = days * x[0] + x[1]
mp.figure('Trend', facecolor='lightgray')
mp.title('Trend', fontsize=20)
mp.xlabel('Date', fontsize=14)
mp.ylabel('Price', fontsize=14)
ax = mp.gca()
ax.xaxis.set_major_locator(
    md.WeekdayLocator(byweekday=md.MO))
ax.xaxis.set_minor_locator(
    md.DayLocator())
ax.xaxis.set_major_formatter(
    md.DateFormatter('%d %b %Y'))
mp.tick_params(labelsize=10)
mp.grid(linestyle=':')
dates = dates.astype(md.datetime.datetime)
rise = closing_prices - opening_prices >= 0.01
fall = opening_prices - closing_prices >= 0.01
fc = np.zeros(dates.size, dtype='3f4')
ec = np.zeros(dates.size, dtype='3f4')
fc[rise], fc[fall] = (1, 1, 1), (0.85, 0.85, 0.85)
ec[rise], ec[fall] = (0.85, 0.85, 0.85), (0.85, 0.85, 0.85)
mp.bar(dates, highest_prices - lowest_prices, 0,
       lowest_prices, color=fc, edgecolor=ec)
mp.bar(dates, closing_prices - opening_prices, 0.8,
       opening_prices, color=fc, edgecolor=ec)
mp.scatter(dates, trend_points, c='dodgerblue',
           alpha=0.5, s=60, zorder=2)
mp.scatter(dates, resistance_points, c='orangered',
           alpha=0.5, s=60, zorder=2)
mp.scatter(dates, support_points, c='limegreen',
           alpha=0.5, s=60, zorder=2)
mp.plot(dates, trend_line, c='dodgerblue',
        linewidth=3, label='Trend')
mp.plot(dates, resistance_line, c='orangered',
        linewidth=3, label='Resistance')
mp.plot(dates, support_line, c='limegreen',
        linewidth=3, label='Support')
mp.legend()
mp.gcf().autofmt_xdate()
mp.show()


# 1966. 프린터 큐

from sys import stdin
from collections import deque

input = stdin.readline
T = int(input())

for _ in range(T):
    N, M = map(int, input().split())
    ranks = list(map(int, input().split()))
    arr = deque((num, i) for i, num in enumerate(ranks))
    ranks.sort(reverse=True)

    sol = 0
    for rank in ranks:
        while rank != arr[0][0]:
            arr.append(arr.popleft())
        sol += 1

        if arr[0][1] == M: break
        arr.popleft()

    print(sol)


# -*- coding: utf-8 -*-
"""
Created on Thu Dec 26 14:58:57 2019

@author: Administrator

MCD12 LandCover Types：
DBF == 4：DBF,5：MF
EBF == 2：EBF
NF == 1：ENF,3：DNF
CRO == 12: CRO, 14: CRO&NV
GRA == 10: GRA
SHR == 6：CSH, 7：OSH
SAV == 8：WSA, 9：SAV
"""

import numpy as np
import matplotlib.pyplot as plt
import os
from osgeo import gdal_array
import matplotlib.gridspec as gridspec
import warnings
warnings.filterwarnings('ignore')

in_file_path = r"F:\Chlorophyll_Fluorescence\Process\Europe\Step14.Boreal_Map"
landcover_file = r"F:\Chlorophyll_Fluorescence\Process\Europe\Step14.Boreal_Map\MOD12_LandUse_N.tif"
plot_path = r"F:\Chlorophyll_Fluorescence\Process\Europe\Step4.Table\Polygon\4.11.Box_Plot_His"

Products = ["TROPOMI_SC","TROPOMI_SR","NIRv","EVI"]
LandCover = ["DBF", "NF", "SAV", "GRA", "SHR", "CRO"]
LC_CODE = [[4,5],[1,3],[8,9],[10],[6,7],[12,14]]
Metrics = [1,3,5] #1,3,5分别代表SOS,EOS,LOS
Name = ["DBF", "NF", "SAV", "GRA", "SHR", "CRO"]
nrows = 2
ncols = 3
figure_scale_row = nrows * 2.0
figure_scale_col = ncols * 2.0
fig = plt.figure(figsize=(figure_scale_col, figure_scale_row))#, sharey=True)
gs = gridspec.GridSpec(nrows, ncols, wspace=0.1, hspace=0.6)

fs = 5 # fontsize
x_labels = ['SOS', 'EOS', 'GSL'] #'Tropomi_SR', 'MODIS', 'OCO-2']
y_lables = [0, 100, 200, 300]
min_y = 0
max_y = 365
ny = 4 #y轴刻度个数
bar_width = 0.15 #柱状体宽度
capsize = 1.2 #柱状体标准差参数1
capthick = 0.8  #柱状体标准差参数2
elinewidth = 0.8 #柱状体标准差参数3
linewidth = 1.0 #边框线宽度
ftsize = 10 #字体大小
ftfamily = "Times New Roman"
axlength = 2.0 #轴刻度长度
axwidth = 1.2 #轴刻度宽度
legendcols = 5 #图例一行的个数

for i in range(len(LandCover)):
    mean = []
    err = []
    for j in range(len(Metrics)):
        lc_array = gdal_array.LoadFile(landcover_file)
        SIF_SC_array = gdal_array.LoadFile(os.path.join(in_file_path, "14.1.SC_GSL_Mask/SC_{0}.tif".format(Metrics[j])))
        SIF_SR_array = gdal_array.LoadFile(os.path.join(in_file_path, "14.1.SR_GSL_Mask/SR_{0}.tif".format(Metrics[j])))
        dcSIF_array = gdal_array.LoadFile(os.path.join(in_file_path, "14.1.dcSIF_GSL_Mask/dcSIF_{0}.tif".format(Metrics[j])))
        EVI_array = gdal_array.LoadFile(os.path.join(in_file_path, "14.1.EVI_GSL_Mask/EVI_{0}.tif".format(Metrics[j])))
        NIRv_array = gdal_array.LoadFile(os.path.join(in_file_path, "14.1.NIRv_GSL_Mask/NIRv_{0}.tif".format(Metrics[j])))

        SIF_SC = []
        SIF_SR = []
        dcSIF = []
        NIRv = []
        EVI = []

        for m in range(len(lc_array)):
            for n in range(len(lc_array[0])):
               if lc_array[m,n] in LC_CODE[i]:
                  if abs(SIF_SC_array[m,n]) < 999:
                      SIF_SC.append(SIF_SC_array[m,n])
                  if abs(SIF_SR_array[m,n]) < 999:
                      SIF_SR.append(SIF_SR_array[m,n])
                  if abs(dcSIF_array[m,n]) < 999:
                      dcSIF.append(dcSIF_array[m,n])
                  if abs(NIRv_array[m,n]) < 999:
                      NIRv.append(NIRv_array[m,n])
                  if abs(EVI_array[m,n]) < 999:
                      EVI.append(EVI_array[m,n])

        mean.append([np.nanmean(SIF_SC), np.nanmean(SIF_SR), np.nanmean(dcSIF), np.nanmean(NIRv), np.nanmean(EVI)])
        err.append([np.nanstd(SIF_SC), np.nanstd(SIF_SR), np.nanstd(dcSIF), np.nanstd(NIRv), np.nanstd(EVI)])
    mean = np.array(mean)
    err = np.array(err)

    #画直方图
    x = np.arange(int(len(x_labels)))
    col = int(i % ncols)
    row = int(i / ncols)
    axes = fig.add_subplot(gs[row, col])

    SIF_SC = axes.bar(x + 0 * bar_width, mean[:,0], bar_width, yerr = err[:,0],  error_kw = {'ecolor' : '0.2', 'elinewidth':elinewidth, 'capsize' :capsize, 'capthick' :capthick}, color="olivedrab", label = "SIF$_T$$_R$$_O$$_P$$_O$$_M$$_I$$_\_$$_t$$_o$$_t$$_a$$_l$$_-$$_S$$_C$", align="center", alpha=1)
    SIF_SR = axes.bar(x + 1 * bar_width, mean[:,1], bar_width, yerr = err[:,1],  error_kw = {'ecolor' : '0.2', 'elinewidth':elinewidth, 'capsize' :capsize, 'capthick' :capthick}, color="yellowgreen",  label = "SIF$_T$$_R$$_O$$_P$$_O$$_M$$_I$$_\_$$_t$$_o$$_t$$_a$$_l$$_-$$_S$$_R$", align="center", alpha=1)
    dcSIF = axes.bar(x + 2 * bar_width, mean[:,2], bar_width, yerr = err[:,2],  error_kw = {'ecolor' : '0.2', 'elinewidth':elinewidth, 'capsize' :capsize, 'capthick' :capthick}, color="forestgreen",   label = "SIF$_T$$_R$$_O$$_P$$_O$$_M$$_I$$_\_$$_O$$_b$$_s$", align="center", alpha=1)
    NIRv = axes.bar(x + 3 * bar_width, mean[:,3], bar_width, yerr = err[:,3],  error_kw = {'ecolor' : '0.2', 'elinewidth':elinewidth, 'capsize' :capsize, 'capthick' :capthick}, color="darkgoldenrod",   label = "NIRv", align="center", alpha=1)
    EVI = axes.bar(x + 4 * bar_width, mean[:,4], bar_width, yerr = err[:,4],  error_kw = {'ecolor' : '0.2', 'elinewidth':elinewidth, 'capsize' :capsize, 'capthick' :capthick}, color="gold",   label = "EVI", align="center", alpha=1)

    axes.set_title("({0}) {1}".format(chr(97+i),Name[i]), fontsize = ftsize/1.2, family = ftfamily)
    axes.set_xticks(x + 2 * bar_width)
    axes.set_xticklabels(x_labels, fontsize = fs, family = ftfamily)
    axes.set_ylim(min_y, max_y)
    axes.spines['left'].set_linewidth(linewidth)
    axes.spines['right'].set_linewidth(linewidth)
    axes.spines['top'].set_linewidth(linewidth)
    axes.spines['bottom'].set_linewidth(linewidth)
    axes.tick_params(axis='both', length = axlength, width = axwidth, labelsize = ftsize/1.5)
    if col == 0:
        axes.set_ylabel('Day of Year (days)', fontsize = ftsize/1.6, family=ftfamily)
        axes.set_yticks(np.linspace(min_y, max_y - 65, ny))
        axes.set_yticklabels(y_lables, fontsize = fs + 2, family=ftfamily)
    else:
        axes.yaxis.set_visible(False)
    axes.set_xlabel('Phenological Metrics', fontsize = ftsize/1.5, family=ftfamily)

    handles = [SIF_SC, SIF_SR, dcSIF, NIRv, EVI]

    labels = ['SIF$_\mathdefault{total-SC}$',\
              'SIF$_\mathdefault{total-SR}$',\
              'SIF$_\mathdefault{Obs}$',\
              'NIR$_\mathdefault{V}$','EVI']
    """
    if i == 0:
        axes.legend(handles, labels, loc ='upper left', fancybox = False, shadow = False,frameon = False,
                   ncol = legendcols, prop={'family':ftfamily, 'size':ftsize/3})
    """

fig.legend(handles, labels, loc ='lower center', fancybox = False, shadow = False,frameon = False,
          ncol = legendcols, handletextpad = 0.2, columnspacing = 1.5, prop={'family':"Times New Roman", 'size':ftsize/1.3})
fig.tight_layout()
fig.subplots_adjust(left = None, right = None, bottom = 0.15)
Plot_path = os.path.join(plot_path, "Rs2-Global.jpg")
plt.show()
fig.savefig(Plot_path, dpi=600, quality=100,bbox_inches='tight')


from PIL import Image, ImageFont, ImageDraw
from io import BytesIO
import os

font_size = {
    'big': 12,
    'small': 10
}

text_margin = {
    'big': 7,
    'small': 6
}

img_margin = {
    'big': 20,
    'small': 10
}

config = {}

def init_font(size='small'):
    if 'font' not in config:
        config['font'] = {}

    if size not in config['font']:
        config['font'][size] = ImageFont.truetype(os.path.dirname(os.path.realpath(__file__)) + "/Helvetica Bold.ttf", font_size[size])

    return config['font'][size]

def read_image(_type, direction, size):
    if _type not in config:
        config[_type] = {}
    if direction not in config[_type]:
        config[_type][direction] = {}
    if size not in config[_type][direction]:
        config[_type][direction][size] = Image.open(os.path.dirname(os.path.realpath(__file__)) + "/imgs/%s_%s_%s.png" % (_type, direction, size))

    return config[_type][direction][size]

def draw_single_img(number, image_left, image_right, font, _size='small'):
    number = to_text(number)

    text_size = font.getsize(number)
    size = (image_left.size[0] + text_size[0] + image_right.size[0], image_left.size[1])

    text_pos = (image_left.size[0], text_margin[_size])
    text_rec = (image_left.size[0], 0, image_left.size[0] + text_size[0], size[1])
    line_top_rec = (image_left.size[0], 0, text_rec[2], 0)
    line_bot_rec = (image_left.size[0], size[1] - 1, text_rec[2], size[1])
    left_rec = (0,0,image_left.size[0], size[1])
    right_rec = (text_rec[2], 0, size[0], size[1])

    img = Image.new("RGBA", size, None)

    img.paste(image_left, left_rec)
    img.paste(image_right, right_rec)

    draw = ImageDraw.Draw(img)

    draw.rectangle(text_rec, fill=(250,250,250))

    draw.rectangle(line_top_rec, fill=(213,213,213))
    draw.rectangle(line_bot_rec, fill=(213,213,213))
    draw.text(text_pos, number, (54,54,54), font=font)

    return img

def draw_stars(stars, size='small', save=False):
    image_left = read_image('star', 'left', size)
    image_right = read_image('star', 'right', size)
    font = init_font(size)

    img = draw_single_img(stars, image_left, image_right, font, size)

    if save:
        img.save("stars.png")

    return img

def draw_folks(folks, size='small', save=False):
    image_left = read_image('folk', 'left', size)
    image_right = read_image('folk', 'right', size)
    font = init_font(size)

    img = draw_single_img(folks, image_left, image_right, font, size)

    if save:
        img.save("folks.png")

    return img

def draw_watches(watches, size='small', save=False):
    image_left = read_image('watch', 'left', size)
    image_right = read_image('watch', 'right', size)
    font = init_font(size)

    img = draw_single_img(watches, image_left, image_right, font, size)

    if save:
        img.save("watches.png")

    return img

def draw_image(watches=None, stars=None, folks=None, _size='small', save=False):
    imgs = []
    if watches != None:
        imgs.append(draw_watches(watches, _size, save))

    if stars != None:
        imgs.append(draw_stars(stars, _size, save))

    if folks != None:
        imgs.append(draw_folks(folks, _size, save))

    if not imgs:
        return None

    size = [0,0]

    for img in imgs:
        size[0] += img.size[0]
        size[1] = img.size[1]

    size[0] += (len(imgs) - 1) * img_margin[_size]
    size = (size[0], size[1])

    result_img = Image.new('RGBA', size, None)
    result_img.paste(imgs[0], (0,0) + imgs[0].size)

    left = imgs[0].size[0] + img_margin[_size]
    for img in imgs[1:]:
        result_img.paste(img, (left, 0, left + img.size[0], img.size[1]))
        left += img_margin[_size] + img.size[0]

    if save:
        result_img.save('out.png')

    out = BytesIO()
    result_img.save(out, 'PNG')

    out.seek(0)
    return out

def to_text(stars):
    stars = str(stars)
    result = []
    while stars:
        result.append(stars[-3:])
        stars = stars[:-3]

    result.reverse()
    return ','.join(result) + ' '

if __name__ == '__main__':
    draw_image(434545,2325,34325,save=True)


from controllers import RandomController
import numpy as np
from utils import sample, compute_normalization
from dynamics import NNDynamicsModel
from cheetah_env import HalfCheetahEnvNew
from cost_function import cheetah_cost_fn
import matplotlib.pyplot as plt

env = HalfCheetahEnvNew()
cost_fn = cheetah_cost_fn

random_controller = RandomController(env)
data = sample(env, random_controller, horizon=100, num_paths=1)
normalization = compute_normalization(data)

dyn_model = NNDynamicsModel(env=env,
                            batch_size=512,
                            iterations=60,
                            learning_rate=1e-3,
                            normalization=normalization
                            )
dyn_model.load_params()

s = np.concatenate([d["state"] for d in data])  # (timestep, 8)
a = np.concatenate([d["action"] for d in data])
s_ = np.concatenate([d["next_state"] for d in data])

pre_s=[]
obs = [s[0,:]]
for i in range(100):
    obs=dyn_model.predict(np.array(obs), np.array([a[i,:]]))
    pre_s.append(obs)

pre_s = np.array(pre_s).reshape(100,20)

t=np.linspace(0,100,100)

plt.plot(t, s_[:,5], linewidth=0.4, linestyle='-')
plt.plot(t, pre_s[:,5], linewidth=0.4, linestyle='--')
# plt.plot(t, pre_s, color='blue', linewidth=0.4, linestyle='.')
plt.show()


#!/usr/bin/env python3.6

import sqlite3

################################################################################
# Initialization
################################################################################

rdb_conn = sqlite3.connect('data/feedback.db')
rdb_cur  = rdb_conn.cursor()
rdb_cur2 = rdb_conn.cursor()

################################################################################
# Main
################################################################################

# going through the lines of key, values

# load the AFINN dictionary
AFINN = {}
with open('data/AFINN-111.txt', 'r') as AFINN_file:
    for line in AFINN_file:
        AFINN[line.split('\t')[0].strip()] = int(line.split('\t')[1])

# going through the EN messages, calculating the overall tweet sentiment
processed_count = 0
for row in rdb_cur.execute('select rowid, tweet_text from tweet where upper(lang) like "EN%"'):
    sentiment_total = 0
    word_count = 0
    for word in row[1].split():
        sentiment_total += int(AFINN.get(word, 0))
        word_count += 1
    rdb_cur2.execute('update tweet set tweet_sentiment = ? where rowid = ?', [round(sentiment_total/word_count,2), row[0]])
    processed_count += 1
    if processed_count % 1000 == 0:
        rdb_conn.commit()

rdb_conn.commit()
rdb_conn.close()

print('Processed: ' + str(processed_count))


#!/usr/bin/env python3
#  coding=utf-8
__author__ = 'Guoliang Lin'
Softwarename = "junction_generator"
version = '0.0.1'
bugfixs = ''
__date__ = "2017/6/26"
import optparse
import time
from functools import reduce

GTFDict = {}
JunctionList = []

def printinformations():
    print("%s software version is %s in %s" % (Softwarename, version, __date__))
    print(bugfixs)
    print('Starts at :' + time.strftime('%Y-%m-%d %H:%M:%S'))

def programends():
    print('Ends at :' + time.strftime('%Y-%m-%d %H:%M:%S'))

class GTFfile:
    def __init__(self, listitem):
        self.GeneID = ''
        self.TranscriptID = ''
        self.ExonStart = int(listitem[3]) - 1
        self.ExonEnd = int(listitem[4]) + 1
        self.Scaffold1 = listitem[0]
        self.Fpkm = []
        self.Chain = listitem[6]
        self.Getinfo(listitem[8])

    def Getinfo(self, info):
        tmp = info.split('; ')
        self.GeneID=tmp[0].split(' ')[1].replace('"', '')
        self.TranscriptID=tmp[1].split(' ')[1].replace('"', '')
        mm=tmp[3].split(' ')[1]
        self.Fpkm=float(tmp[3].split(' ')[1].replace('"', ''))

class Junction:
    def __init__(self,listitem:list) -> None:
        """
        :param listitem:list [scaffold,pos,chain,depth]

        """
        super().__init__()
        self.GeneID=[]
        self.Scaffold=listitem[0]
        self.Pos=int(listitem[1])
        self.Chain=listitem[2]
        # self.Depth=listitem[3]
        self.Fpkm=[]
        self.TranscriptID=[]

    def AddGeneID(self,GeneID:str):   # type: (Junction, str) -> None
        if GeneID not in self.GeneID:
            self.GeneID.append(GeneID)

    def AddTranscriptID(self,TranscriptID:str):    # type: (Junction, str) -> None
        if TranscriptID not in self.TranscriptID:
            self.TranscriptID.append(TranscriptID)

    def AddFpkm(self,Fpkm:float):
        self.Fpkm.append(Fpkm)

    def ToString(self):  # type: (Junction) -> str
        String = '\t'.join([self.Scaffold, str(self.Pos), self.Chain, '@'.join(self.GeneID), str((len(self.Fpkm) and max(self.Fpkm)) or "0"),
                            str((len(self.Fpkm) and reduce(lambda x,y:x+y,self.Fpkm)) or "0")])
        return String

class JunctionCombie:
    def __init__(self, listitem):
        self.JunctionS=Junction(listitem)
        self.JunctionE=Junction(listitem[3:])

    def AddGeneID(self, m: list, GeneId):
        if GeneId not in m:
            m.append(GeneId)

    def AddTranscriptID(self, m: list, TranscriptID):
        if TranscriptID not in m:
            m.append(TranscriptID)

    def ToString(self):
        String = '\t'.join([self.JunctionS.ToString(),self.JunctionE.ToString()])
        return String

    def Iscontain(self,GTFitem: GTFfile, Junctionitem: Junction):
        if GTFitem.ExonStart <= Junctionitem.Pos <= GTFitem.ExonEnd:
            Junctionitem.AddGeneID(GTFitem.GeneID)
            Junctionitem.AddTranscriptID(GTFitem.TranscriptID)
            Junctionitem.Fpkm.append(GTFitem.Fpkm)

def _parse_args():
    """Parse the command line for options."""
    usage = 'usage: %prog -i junctionfile  -g gtffile -o OUTPREFIX'
    parser = optparse.OptionParser(usage)
    parser.add_option('-i',
                      '--input', dest='input', type='string',
                      help='input junction file ')
    #    parser.add_option('-f','--fpkm',dest='fpkm_file',type='string',help='input fpkm file')
    #    parser.add_option('-v','--variation', dest='variation', type='string', help='input variation information file')
    parser.add_option('-g', '--gtf', dest='gtf', help='gtf file')
    parser.add_option('-o', '--output', dest='output', type='string', help='input variation information file')
    parser.add_option('-d', '--depth', dest='depth', type='int', default=5, help='depth')
    options, args = parser.parse_args()
    # positional arguments are ignored
    return options

if __name__ == '__main__':
    options = _parse_args()
    with open(options.gtf) as gtffile:
        with open(options.input) as junctionfile:
            with open(options.output, 'w') as outputfile:
                for item in gtffile:
                    item = item.strip()
                    itemlist = item.split('\t')
                    assert isinstance(itemlist, list)
                    if itemlist[2] == 'exon':
                        tmpgtf = GTFfile(itemlist)
                        if tmpgtf.Scaffold1 in GTFDict:
                            GTFDict[tmpgtf.Scaffold1][tmpgtf.Chain].append(tmpgtf)
                        else:
                            GTFDict[tmpgtf.Scaffold1] = {}
                            GTFDict[tmpgtf.Scaffold1]['-'] = []
                            GTFDict[tmpgtf.Scaffold1]['+'] = []
                            GTFDict[tmpgtf.Scaffold1]['.'] = []
                            GTFDict[tmpgtf.Scaffold1][tmpgtf.Chain].append(tmpgtf)
                for key in GTFDict.keys():
                    GTFDict[key]['+'].sort(key=lambda x: (x.ExonStart, x.ExonEnd))
                    GTFDict[key]['-'].sort(key=lambda x: (x.ExonStart, x.ExonEnd))
                for item in junctionfile:
                    itemlist = item.split('\t')
                    junctionlist=[itemlist[0],itemlist[1],itemlist[3],itemlist[0],itemlist[2],itemlist[3]]
                    tmpjunction = JunctionCombie(junctionlist)
                    for Gtfitem in GTFDict[tmpjunction.JunctionS.Scaffold][tmpjunction.JunctionS.Chain]:
                        tmpjunction.Iscontain(Gtfitem, tmpjunction.JunctionS)
                    for Gtfitem in GTFDict[tmpjunction.JunctionE.Scaffold][tmpjunction.JunctionE.Chain]:
                        tmpjunction.Iscontain(Gtfitem, tmpjunction.JunctionE)
                    string = tmpjunction.ToString()
                    outputfile.write(string + '\n')


from datetime import date, timedelta
from tarea_operativa.models import PeriodoChequeo

def is_your_turn(tarea_op, perio_ch, tareas_ops):
    # if tomorrow = periodo_chequeo day
    if weekday(perio_ch):
        tareas_ops.append({
            'inicio': tarea_op.fecha_start.strftime("%Y-%m-%d"),
            'final': tarea_op.fecha_ended.strftime("%Y-%m-%d"),
            'numero': tarea_op.get_numero(),
            'descripcion': tarea_op.descripcion,
            'nota': '-'
        })
    return tareas_ops

# get day of week
def weekday(perio_ch):
    # get tomorrow day
    tomorrow = date.today() + timedelta(days=1)
    # get weekday
    for day in perio_ch.dia_semana.split('|'):
        if day == 'Lu':  # Monday
            week_day = 0
        elif day == 'Ma':
            week_day = 1  # Tuesday
        elif day == 'Mi':
            week_day = 2  # Wednesday
        elif day == 'Ju':
            week_day = 3  # Thursday
        elif day == 'Vi':
            week_day = 4  # Friday
        elif day == 'Sa':
            week_day = 5  # Saturday
        else:
            week_day = 6  # Sunday
        # if tomorrow = weekday
        if week_day == date.weekday(tomorrow):
            # update ultimo_chequeo from PeriodoChequeo
            p_ch = PeriodoChequeo.objects.get(pk=perio_ch.id)
            p_ch.ultimo_chequeo = date.today()
            p_ch.save()
            return True
    return False


from sklearn.cluster import KMeans
import numpy as np
import matplotlib.pyplot as plt
import cv2
import pandas as pd
import glob
import os
from skimage import morphology

square = np.ones((3,3))

def prepare_image(img):
  '''
  This function extracts, from an image of size (n,p), the 3 channels RGB and concatenate them as features in a new matrix of size (n*p , 3)
  '''
  # la transformer en grayscale
  gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
  rouge = img[:,:,0]
  vert = img[:,:,1]
  bleu = img[:,:,2]

  # For Kmeans Segmentation
  n,p = gray.shape
  size = n * p
  R = rouge.flatten()
  G = vert.flatten()
  B= bleu.flatten()

  R = np.reshape(R, (size,1))
  G = np.reshape(G, (size,1))
  B = np.reshape(B, (size,1))

  image = np.concatenate((R,G,B), axis=1)
  return image

def segment_image(img, colors):
  '''This function segment the original image based on a set of colors (legend)'''

  kmeans = KMeans(n_clusters=7, n_init=10, random_state=1)
  train = prepare_image(colors)
  test = prepare_image(img)

  # Here we train the KMeans model using the set of colors (legend)
  model = kmeans.fit(train)
  labels_test = model.predict(test)

  # Here we restore the original shape of the segmented images (both the legend and the original image)
  segmented_test = np.reshape(labels_test, img.shape[:2])
  segmented_train = np.reshape(model.labels_, colors.shape[:2])

  # Here we fix the colors displayed in the legend to have a correct mapping between the colors of clusters returned by KMeans and the colors of the original image
  blue_c = segmented_train[100,0]
  light_blue_c = segmented_train[200,0]
  green_c = segmented_train[400,0]
  yellow_c = segmented_train[600,0]
  red_c = segmented_train[800,0]
  background_c = segmented_train[0,200]
  black_c = segmented_train[900,100]

  # Here, we seperate the clusters (colors) from the segmented image. Each sub-image contains a certain color.
  all_parcel = morphology.binary_opening(((segmented_test == background_c) | (segmented_test == black_c)) ==0)
  green = segmented_test == green_c
  red = segmented_test == red_c
  light_blue = segmented_test == light_blue_c
  yellow = segmented_test == yellow_c
  blue = segmented_test == blue_c
  black = segmented_test == black_c

  # return all the sub-images as a list
  return [all_parcel, green, blue, light_blue, red, yellow, black]

def calcul_surface(images):
  '''
  This function calculates the surface using the list of sub-images
  '''
  black = np.sum(images[6])
  scale = 625 / black

  surfaces = []
  for img in images :
    surfaces.append(np.sum(img)*scale* 0.0001)

  return surfaces

def calcul_percentage(images):
  '''
  This function calculates the percentages of each color considering the total surface of the farm
  '''
  percentages = []
  surfaces = calcul_surface(images)
  S_all_parcel = surfaces[0]

  for img in surfaces[1:6]:
    percentages.append(np.round((img) / S_all_parcel , 3))
  return percentages

colors = cv2.imread('colors.png')
colors = cv2.cvtColor(colors, cv2.COLOR_BGR2RGB)

# Automate the process for all the images, save the data in an Excel file and return it to the user
for map in glob.glob('/content/*.png'):
  base = os.path.basename(map)
  name = os.path.splitext(base)[0]
  if name != 'colors' :
    img2 = cv2.imread(name +'.png')
    img2 = cv2.cvtColor(img2, cv2.COLOR_BGR2RGB)

    images = segment_image(img2, colors)
    percentages = calcul_percentage(images)
    surfaces = calcul_surface(images)
    areas = pd.DataFrame([percentages, surfaces[1:6]], columns=['Green', 'Blue', 'Light blue', 'Red', 'Yellow'], index = ['Percentage of area', 'Surfaces (Ha)'])
    areas.to_excel(name+ ".xls")


import datetime
import logging
import os

import discord
from dateutil import parser, tz

import api
import util
import watcher

# Fetch environment variables

def _bool(e):
    return e.lower() not in ('false', 'no', 'off', '0')

DISCORD_TOKEN = os.environ['DISCORD_TOKEN']
DISCORD_CHANNEL = int(os.environ['DISCORD_CHANNEL'])
DRY_RUN = _bool(os.environ.get('DRY_RUN', 'true'))

FOCUS_TEAM_ID = int(os.environ['FOCUS_TEAM_ID'])
PATTERNS_FILE = os.environ['PATTERNS_FILE']

SKIP_CURRENT = _bool(os.environ.get('SKIP_CURRENT', 'true'))

# set up logging

logging.basicConfig(
    format='%(asctime)s %(levelname)-8s:%(name)-16s: %(message)s',
    level='WARNING',
    datefmt='%Y-%m-%d %H:%M:%S',
)

logging.getLogger('trash').setLevel('INFO')
logging.getLogger('trash.main').setLevel('DEBUG')
logging.getLogger('trash.watch').setLevel('DEBUG')
logging.getLogger('trash.api.plays').setLevel('DEBUG')

# main logic. this is the only place we have to worry about discord

log = logging.getLogger('trash.main')

dcli = discord.Client()

@dcli.event
async def on_ready():
    channel: discord.TextChannel = dcli.get_channel(DISCORD_CHANNEL)

    # print to log if dry run
    if not DRY_RUN:
        send = channel.send
    else:
        _dry = logging.getLogger('trash.dry')

        async def send(text):
            _dry.info(text)

    while True:
        game = await api.next_game(FOCUS_TEAM_ID)
        if not game:
            log.warning('could not find a live or scheduled game.')
            await util.sleep(days=1)
            continue

        title = f'{game.teams.home.team.name} vs. {game.teams.away.team.name}'

        date = parser.parse(game.gameDate)
        utcnow = datetime.datetime.now(tz.tzutc())

        delay = date - utcnow - datetime.timedelta(seconds=30)
        log.info('waiting for game %s (%s)', game.gamePk, title)

        # if we didn't have to sleep, game is in progress
        in_progress = not await util.sleep(delay)
        log.info('watching game %s (%s)', game.gamePk, title)

        # send the message if the game is new or we aren't skipping
        if in_progress and SKIP_CURRENT:
            log.debug('not notifying because game is already in progress')
        else:
            await send(f'watching {title}')

        # game watching logic is here.
        # send is a callback so we don't have to worry about discord in that module
        await watcher.watch(
            game=game,
            focus_id=FOCUS_TEAM_ID,
            patterns_file=open(PATTERNS_FILE),
            send=send,
            skip=SKIP_CURRENT
        )

if __name__ == '__main__':
    dcli.run(DISCORD_TOKEN)


import numpy as np
import librosa
import pyaudio
import time
import requests
import json

import chainer
import chainer.links as L
import chainer.functions as F

IFTTT_EVENT = 'laser_machine_state'
IFTTT_KEY = '*********************'
IFTTT_URL = 'https://maker.ifttt.com/trigger/{event}/with/key/{key}'.format(
    event=IFTTT_EVENT, key=IFTTT_KEY)

def make_web_request(state):
    data = {}
    data['value1'] = state
    try:
        response = requests.post(IFTTT_URL, data=data)
        print('{0.status_code}: {0.text}'.format(response))
    except:
        print('Failed to make a web request')

SAMPLING_RATE = 16000
CHUNK = 1 * SAMPLING_RATE
FFT_SIZE = 256
THRESHOLD = 0.8

with open('state_names.json', 'r') as file_to_load:
    STATES = json.load(file_to_load)
    STATES.append('unknown')

N_STATES = len(STATES) - 1

last_state = STATES.index('unknown')

class LaserMachineListener(chainer.Chain):

    def __init__(self, n_mid_units, n_out):
        super(LaserMachineListener, self).__init__()

        with self.init_scope():
            self.l1 = L.Linear(None, n_mid_units)
            self.l2 = L.Linear(None, n_mid_units // 2)
            self.l3 = L.Linear(None, n_out)

    def __call__(self, x):
        h1 = F.relu(self.l1(x))
        h2 = F.relu(self.l2(h1))
        return self.l3(h2)

# NOTE:
# If you changed the value of n_mid_units from the initial value
# at the time of learning, change here also
model = L.Classifier(LaserMachineListener(n_mid_units=128,
                                          n_out=N_STATES))
chainer.serializers.load_npz('laser_machine_listener.model', model)

count = 0
predictions_in_60_sec = np.empty((0, N_STATES))

audio_interface = pyaudio.PyAudio()
audio_stream = audio_interface.open(format=pyaudio.paInt16,
                                    channels=1,
                                    rate=SAMPLING_RATE,
                                    input=True,
                                    frames_per_buffer=CHUNK)

try:
    while True:
        data = np.fromstring(audio_stream.read(CHUNK),
                             dtype=np.int16)

        audio_stream.stop_stream()

        start = time.time()

        state = last_state

        D = librosa.stft(librosa.util.normalize(data),
                         n_fft=FFT_SIZE,
                         window='hamming')
        magnitude = np.abs(D).transpose()

        predictions = F.softmax(model.predictor(magnitude)).data
        predictions_mean = predictions.mean(axis=0)
        predictions_in_60_sec = np.vstack([predictions_in_60_sec, predictions])
        count = count + 1

        elapsed_time = time.time() - start

        localtime = '{0.tm_hour:02d}:{0.tm_min:02d}:{0.tm_sec:02d}'.format(
            time.localtime(time.time()))
        print('{0:s} {1:s} ({2:.3f}, processed in {3:.3f} seconds)'.format(
            localtime,
            STATES[predictions_mean.argmax()],
            predictions_mean.max(),
            elapsed_time))

        if predictions_mean.max() > THRESHOLD:
            state = predictions_mean.argmax()

        if last_state != state:
            print('Changed: {0} > {1}'.format(
                STATES[last_state], STATES[state]))
            last_state = state

        if (count == 60):
            start = time.time()
            state_in_60_sec = predictions_in_60_sec.mean(axis=0).argmax()
            make_web_request(STATES[state_in_60_sec])
            predictions_in_60_sec = np.empty((0, N_STATES))
            count = 0
            elapsed_time = time.time() - start
            print('Made a request in {0:.3f} seconds)'.format(elapsed_time))

        audio_stream.start_stream()

except KeyboardInterrupt:
    print('Requested to terminate')

finally:
    audio_stream.stop_stream()
    audio_stream.close()
    audio_interface.terminate()
    print('Terminated')