from fabric.colors import red as _red
from fabric.contrib.files import cd, env, put, run
from fabric.utils import abort
import os

def backup_db_to_s3():
    with cd('builds/adamw523blog'):
        v = (env.s3_access_key, env.s3_secret_key, env.s3_backup_bucket)
        run('fig run util /backup_db_to_s3.sh "%s" "%s" "%s"' % v)

def backup_wp_content_to_s3():
    with cd('builds/adamw523blog'):
        v = (env.s3_access_key, env.s3_secret_key, env.s3_backup_bucket)
        run('fig run util /backup_wp_content_to_s3.sh "%s" "%s" "%s"' % v)

def restore_db_from_url():
    path = os.getenv('DBURL', None)
    if not path:
        abort(_red("Must provide DBURL in environment eg:") + "\n$ DBURL='http://s3server/path/file.gz' fab production restore_db_from_url")
    with cd('builds/adamw523blog'):
        run('fig run util /restore_db_from_url.sh "%s"' % (path))

def restore_wp_content_from_url():
    path = os.getenv('WPURL', None)
    if not path:
        abort(_red("Must provide WPURL in environment eg:") + "\n$ WPURL='http://s3server/path/file.gz' fab production restore_db_from_url")
    with cd('builds/adamw523blog'):
        run('fig run util /restore_wp_content_from_url.sh "%s"' % (path))


#!/usr/bin/env python
# coding: utf-8

# In[462]:

import numpy as np
import pandas as pd
from pandas import read_csv
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
from matplotlib.pyplot import figure
from sklearn.metrics import mean_squared_error
from sklearn.metrics import mean_absolute_error
from sklearn.metrics import r2_score
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import MinMaxScaler
from sklearn.ensemble import RandomForestRegressor
import seaborn as sns
import math

import statistics as stat
from sklearn.neural_network import MLPRegressor

# Seguimos el hilo argumental del [ejercicio 9.1](https://github.com/Gerard-Bonet/Sprint9Tasca1.git) para trabajar con el 9.2. No nos servirán las variables del ejercicio 9.1, ya que
#
# no dividimos el conjunto de datos  en variables independientes y objetivos. Es decir, no vamos a aprobechar nada de él pero si
#
# alguna información, que vamos a pasar a resumir:
#
#

# In[556]:

df = pd.read_csv("DelayedFlights.csv") # este es el conjunto de datos proporcionado en el ejercicio
df

# - Las variables DepTime','CRSDepTime', 'ArrTime', 'CRSArrTime" básicamente son las horas programadas y reales que acaban determinando 'ActualElapsedTime', 'CRSElapsedTime', 'AirTime', 'ArrDelay','DepDelay'. Restar  'ArrTime' y 'CRSArrTime nos da ArrDelay, por ejemplo. Mientras en el otro ejercicio, no nos hicieron falta, para entrenar una red neuronal o un arbol, nos pueden venir bien si no contamos con la variable DepDelay( Ejercicio 3)
#
# - Las variables "CarrierDelay","WeatherDelay","NASDelay","SecurityDelay","LateAircraftDelay" tienen un tercio de valores NaN, y la suma de todas es el retraso general.
#
# - 'FlightNum' y'TailNum' son variables catogóricas que no aportan mucho
#
# - "ActualElapsedTime",  "CRSElapsedTime","AirTime" y "Distance" tienen un coeficiente de correlación lineal entre ellas cercano a 0,95 $\pm 2$ , mientras que ArrDelay y DepDelay, tienen una correlación cercana a cero respecto a estas 4 variables.
#
# - Arrdelay y DepDelay tienen una correlación cercana a 0,8.
#
# - Entre el primer grupo(distance) y el segundo(arrdelay) el Coeficiente de correlación tiende a cero
#
#
# - los aeropuertos donde hay más vuelos hay más minutos acumulados de retrasos. No crece de manera lineal, va creciendo de forma $ax^2 +bx$ de forma muy aplanada. Ésto estaba por corroborar.
#
# - Con las compañías crece de forma lineal. A más vuelos, más minutos acumulados de retrasos.
#
# - Ignoraré las variables Cancelled o Diverted ya que si tienen un valor de 1 ( y no llegan a 8000 casos) tienen valores NaN en ArrDelay y DepDelay
#
#
#
#

# 0. **PREPROCESAMIENTO DE DATOS.**
#
# Vamos a dedicar esta parte a tratar las variables con valores perdidos, transformación de estas variables, selección, y otras
#
# manipulaciones para poder aplicar a las regresiones

# In[464]:

df.columns

# 0.1. **Muestreo de población y tratamiento de valores perdidos**
#
# Primero hacemos un **muestreo de la población** para evitar problemas de memoria, ya que al hacer ciertas operaciones
#
# sobre todo el conjunto de datos, el ordenador da problemas de memoria, incluso vectorizando
#

# In[557]:

df1= df.sample(390000)# el 20% aproximadamente
df1.isnull().sum()# miramos la cantidad de valores perdidos

# Como hicimos en la [ejercicio 9.1](https://github.com/Gerard-Bonet/Sprint9Tasca1.git) vamos a ver si estos valores NaN corresponden a vuelos cancelados o derivados, que no van a servir de nada para calcular el valor de ArrDelay

# In[562]:

# vamos a ver si todos los valores NaN corresponden a todos lo vuelos Cancelados o Derivados
df1_div= df1[df1["Diverted"]==1]
df1_can=df1[df1["Cancelled"]==1]
df1_div.shape#número de vuelos desviados

# In[563]:

df1_can.shape#número de vuelos cancelados

# In[564]:

df1_div.shape[0]+df1_can.shape[0]# número total de cancelados y derivados.

# In[565]:

df1_div["ArrTime"].isnull().sum()+df1_can["ArrTime"].isnull().sum()# que coincide con los valores NaN de ArrTime

# In[566]:

df1_div["ActualElapsedTime"].isnull().sum()+df1_can["ActualElapsedTime"].isnull().sum()# esto daría lo mismos
# para ArrDelay y DepDelay

# Los valores NaN, coinciden con aquellos que el vuelos ha sido Cancelado o Desviado,por lo tanto, no aportan información
#
# al cálculo de la regresión de ArrDelay, optamos por eliminarlos

# In[567]:

df2=df1.dropna( subset=["ArrDelay"]).reset_index(drop=True)
df2.isna().sum()

# 0.2. **Transformación de variables horarias**
#
# En esta parte vamos a convertir las variables DepTime,	CRSDepTime,	ArrTime,	CRSArrTime en la función cíclica.
#
# Estas cuatro variables vienen en formato horario  hh:mm. Lo que haremos será contar todos los minutos transcurridos durante
#
# el día, siendo 0 minutos a las 00:00 y 1440 los minutos transcurridos durante el día a las 23:59.
#
# Más adelante, en el apartado 0.4, transformaremos estas variables en cíclicas.
#
#
#
#
#
#

# In[568]:

# Primero de todo convierto las variables horarias en formato hora y para eso tienen que haber 4 digítos, que los relleno por la
#izquierda con ceros
# Primero tengo que convertir en entero las variables DepTime y ArrTime en enteros para evitar los decimales

df2['DepTime'] = df2['DepTime'].astype(int)

# In[569]:

df2['ArrTime'] = df2['ArrTime'].astype(int)
df2

# In[570]:

#relleno por la izquierda con ceros
df2['DepTime'] = df2['DepTime'].astype(str).str.zfill(4)
df2['CRSDepTime'] = df2['CRSDepTime'].astype(str).str.zfill(4)
df2['ArrTime'] = df2['ArrTime'].astype(str).str .zfill(4)
df2['CRSArrTime'] = df2['CRSArrTime'].astype(str).str.zfill(4)
df2.head()

# In[571]:

# las convierto en formato horario( Nota: en un principio lo pasé a formato horario por si lo necesitaba para datetime, pero
# al final opté por otro tipo de conversión)
df2['DepTime'] = df2['DepTime'].astype(str).str[:2]  + ':' + df2['DepTime'].astype(str).str[2:4] + ':00'
df2['CRSDepTime'] = df2['CRSDepTime'].astype(str).str[:2] + ':' + df2['CRSDepTime'].astype(str).str[2:4] + ':00'
df2['ArrTime'] = df2['ArrTime'].astype(str).str[:2] + ':' + df2['ArrTime'].astype(str).str[2:4]  + ':00'
df2['CRSArrTime'] = df2['CRSArrTime'].astype(str).str[:2] + ':' + df2['CRSArrTime'].astype(str).str[2:4] + ':00'

df2

# In[572]:

# creamos la función minutos, que divide la hora hh:mm con un Split, en una lista ("hh","mm"), reconvierte hh y mm en enteros,
# para luego pasarlos a minutos, y con la reconverión ya comentada aplica la función minutos()
def minutos(x):
    x=x.split( sep=":")
    seg= 60*(int(x[0]))+(int(x[1]))

    return seg

dfhoras= df2[["DepTime", "CRSDepTime", "ArrTime", "CRSArrTime"]]

# In[573]:

dfhoras_DT= dfhoras["DepTime"].apply(minutos)
dfhoras_CRSD=dfhoras["CRSDepTime"].apply(minutos)
dfhoras_AT=dfhoras["ArrTime"].apply(minutos)
dfhoras_CRSA=dfhoras["CRSArrTime"].apply(minutos)

# In[574]:

df2.columns

# In[575]:

df3= df2.drop(['Unnamed: 0', 'Year', 'DepTime',
       'CRSDepTime', 'ArrTime', 'CRSArrTime','FlightNum', 'TailNum', 'Cancelled', 'CancellationCode', "Diverted"], axis=1)
# 'Unnamed: 0' y  'Year" no aportan nada,  TailNum y Flight Num son eliminadas por cuestión de practicidad y para no
# añadir columnas vía Dummies por cada código de vuelo o Tailnum
# Y al Final , Cancelled y Diverted no aportan nada al cálculo de arrdelay

# In[576]:

# ahora añadimos las cuatro columnas nuevas

df4= pd.concat([df3, dfhoras_DT,dfhoras_CRSD , dfhoras_AT, dfhoras_CRSA], axis=1)
df4.columns

# In[578]:

df4[["DepTime", "CRSDepTime", "ArrTime", "CRSArrTime"]].describe()# miramos como quedan para ver si hay alguna anomalía en
# los máximos y mínimos

# In[579]:

df4.isna().sum()#revisamos el número de nulos

# 0.3 **Transformación de Variables Delay.**
#
# Vamos a analizar la variables ArrDelay y DepDelay, rescepto a los motivos del retraso.
#
#

# In[580]:

df_delay= df4[['ArrDelay','DepDelay','CarrierDelay', 'WeatherDelay', 'NASDelay', 'SecurityDelay','LateAircraftDelay',]]

df_delay

# A simple vista vemos que la suma de minutos por fila  de CarrierDelay', 'WeatherDelay', 'NASDelay', 'SecurityDelay',
#
# 'LateAircraftDelay', es igual a ArrDelay

# In[581]:

sns.pairplot( df_delay,kind="reg", x_vars=['CarrierDelay', 'WeatherDelay', 'NASDelay', 'SecurityDelay','LateAircraftDelay'], y_vars="ArrDelay")

# In[582]:

# Tras visualizar el DF veo como posibilidad que si ArrDelay es menor que x minutos ( x podría ser de 10 o 20 minutos ),
# las X_vars tienen valores NaN
# también veo que si se da la condición(min< x), las cinco variables de X_Vars son NaN
df_delay[df_delay["CarrierDelay"].isna()]

# In[583]:

df_delay[df_delay["ArrDelay"]>=20].isna().sum()#miramos varios valores de Arrdelay para ver cuando empiezan a parecer valores NaN

# In[584]:

df_delay[df_delay["ArrDelay"]>18].isna().sum()

# In[585]:

df_delay[df_delay["ArrDelay"]>15].isna().sum()

# In[586]:

df_delay[df_delay["ArrDelay"]>13].isna().sum()

# In[591]:

dfd=df_delay[df_delay["ArrDelay"]>=15]# de manera definitiva
dfd.isna().sum()

# In[592]:

dfd=df_delay[df_delay["ArrDelay"]<15]
dfd.isna().sum()

# Con esto acabamos de demostrar que los valores de **ArrDelay < 15 minutos**, no registran las causas de retraso.
#
# Podriamos sustituir los valores NaN repartiendo lo minutos de Arrdelay<15 entre las cinco variables, pero hay valores de Arrdelay negativos. **Así que asignaremos un valor de 0.0 a todos lo NaN**
#
#

# In[593]:

dfd2=df_delay[df_delay["ArrDelay"]>=15]
dfd2.isna().value_counts()

# In[595]:

delay_not_NAN= df_delay[['CarrierDelay', 'WeatherDelay', 'NASDelay', 'SecurityDelay','LateAircraftDelay']].fillna(0.0)
delay_not_NAN.isna().value_counts()

# In[596]:

delay_not_NAN.describe()

# In[597]:

df5_0= df4.drop(  ["CarrierDelay", 'WeatherDelay', 'NASDelay', 'SecurityDelay','LateAircraftDelay'], axis=1 )# borramos los
#valores con NaN, y añadimos las variables con la sustitución de NaN por cero
df5= pd.concat([df5_0, delay_not_NAN], axis =1)
df5.isna().sum()

# 0.4 **Variables Categóricas y Visualización de variables.**
#
#  En este apartado vamos a ver de que manera se comportan las viarbles para determinar cuales son independientes o no, así como
#  analizar la categóricas.
#
#

# In[598]:

df5.columns

# Cómo recordamos en el [ejercicio 9.1](https://github.com/Gerard-Bonet/Sprint9Tasca1.git), habían 300 **origenes y destinos**, así como 20 **compañías**. El retraso acumulado en ArrDelay
#
# tenía una relación lineal en el número de vuelos por compañías, así que tampoco aportaba mucha más información.
#
# Mientras que por aeropuerto tenía una tendencia lineal, y crecía algo más para aeropuertos con muchos vuelos
#
# Así que hacer un get_dummies nos generaría 640 variables, así que **vamos a eliminarlas**.

# In[599]:

df5.drop(["UniqueCarrier", "Origin", "Dest"], axis=1, inplace=True)

# In[600]:

# Vamos a ver la correlación lineal
df5corr= df5.corr()
f, ax = plt.subplots(figsize=(15,15))
sns.heatmap(df5corr, vmax=1, vmin=-1, square=True,cmap="Blues", annot=True)
plt.show()

#

# Nos permite ver que LateAircraft Delay, NasDelay, WheatherDelay y Depdelay son las variables con alta correlación lineal con ArrDelay, y como vimos en el 9.1 ActualElapsedTime', 'CRSElapsedTime', 'AirTime', y Distance  están altamente correlaiconadas
# entre ellas pero no con ArrDelay
#
# Las variables temporales (mes, dia del mes y dia de la semana ) tienen una correlación casi nula con el resto de
# variables, además de que en este DataSet funcionan como variables categóricas.
#
# Empecemos por ver como se distribuye arrdelay en función de los meses, que cómo ya habíamos visto en el ejercicio 9.1 hay más
# vuelos de Diciembre a Marzo y de Junio a Agosto.
#
# También, si nos fijamos en los días de la semana, vimos en 9.1 que los Jueves, Viernes, Domingos y Lunes tenían más vuelos que los otros días. Siendo el Viernes el día con más vuelos y el sábado el que menos.

# In[601]:

df5ArrMonth= df5[df5["ArrDelay"]<200] # miramos como se distribuye Arrdelay en función del mes
order= []
for i in range(1,13):
    order.append(i)

g = sns.FacetGrid(df5ArrMonth, row="Month", row_order= order,
                  height=2.7, aspect=5,)
g.map( sns.histplot, "ArrDelay", stat="count")

# In[602]:

df5[["ArrDelay", "Month"]].groupby("Month").mean()

# In[603]:

df5ArrMonth= df5[df5["ArrDelay"]<200] # y hacemos lo mismo para el día de la semana
order2= []
for i in range(1,8):
    order2.append(i)

g = sns.FacetGrid(df5ArrMonth, row="DayOfWeek", row_order= order2,
                  height=2.7, aspect=5,)
g.map( sns.histplot, "ArrDelay", stat="count")

# In[604]:

df5[["ArrDelay", "DayOfWeek"]].groupby("DayOfWeek").mean()

# In[605]:

#También mmiramos la distribución del retraso acumulado por meses  y días

df5[["ArrDelay", "Month"]].groupby("Month").sum().plot(kind="bar")
df5[["ArrDelay", "DayOfWeek"]].groupby("DayOfWeek").sum().plot(kind="bar")

# Las últimas distribuciones tienen una distribución casi idéntica al conteo  de vuelos de Month y Dayofweek que vimos
# en [ejercicio 9.1](https://github.com/Gerard-Bonet/Sprint9Tasca1.git); es decir, a más vuelos, más retraso acumulado.
#
# Teniendo en cuenta que los vuelos pueden llegar al día siguiente, como los vuelos salidos el Lunes pueden llegar el Martes,
# la media de atrasos en función de los días de la semana se mantiene en $ 41.5 \pm 2.5 $. Teniendo en cuenta ésto, y que el día
# de la semana tiene un índice de correlación muy bajo, y que como pasaba con las compañías, hay más atrasado acumulado en función del dia de la semana o del mes a causa de que hay más cantidad de vuelos. Vamos a descartar estas dos variables.
#
# No voy a hacer el mismo razonamiento para DayofMonth, ya que puedo usar el mismo argumento que con las otras dos variables.
#
# El día del Mes, el mes y el día de la semana , no influye en los retrasos y además nos generaría contabilizar muchas más columnas, ya que son variables categóricas.
#

# In[606]:

df6= df5.drop(['Month', 'DayofMonth', 'DayOfWeek'], axis=1)

# In[608]:

df6.shape# miramos dimensiones del Data Set

# Las Variables "DepTime", "CRSDepTime", "ArrTime", "CRSArrTime", deberían ser una función cíclica, es decir, cuando las horas de
# Arrtime sea menor que DepTime, habría contar 1440 minutos más, dando igual si es CRS o no

# In[508]:

df6[["DepTime", "CRSDepTime", "ArrTime", "CRSArrTime"]].describe()

# In[609]:

f,axs= plt.subplots(2, 2, figsize=(14,8))
sns.regplot(data=df6, x=  "DepTime",y = "ArrDelay",ax= axs[0,0], ci=None,scatter_kws={"color": "blue"}, line_kws={"color": "red"})

sns.regplot( data=df6, x=  "CRSDepTime",y = "ArrDelay",ax= axs[0,1], ci=None,scatter_kws={"color": "blue"}, line_kws={"color": "red"})

sns.regplot( data=df6, x=  "ArrTime",y = "ArrDelay",ax= axs[1,0]  , ci=None, scatter_kws={"color": "blue"}, line_kws={"color": "red"})

sns.regplot( data=df6, x=  "CRSArrTime",y = "ArrDelay",ax= axs[1,1]  , ci=None, scatter_kws={"color": "blue"}, line_kws={"color": "red"})

# In[614]:

minimo=df[df["ArrDelay"]<0].sort_values("ArrDelay")# miramos los valores más bajos de ArrDelay
zmin=minimo["ArrDelay"].min()
zmin

# In[615]:

# podemos observar una independencia casi total, pero si hacemos lo siguiente.
def rest(z):
    x=z[0]
    y=z[1]
    if (x < y) & ((x-y)<zmin):
        t= (1440+x)-y
        return t
    else:
        t= x-y
        return t

x11= df6[["DepTime","CRSDepTime" ]].apply(rest, axis=1)
x10= df6[["ArrTime","CRSArrTime" ]].apply(rest,axis=1)

f,axs= plt.subplots(2, 1, figsize=(14,8))

sns.regplot(data=df6, x=  x10,y = "ArrDelay",ax= axs[0], ci=None,scatter_kws={"color": "blue"}, line_kws={"color": "red"})

sns.regplot( data=df6, x=  x11,y = "DepDelay",ax= axs[1], ci=None,scatter_kws={"color": "blue"}, line_kws={"color": "red"})

plt.show()

# Sean **x10** y **x11** definidas por
#
# **x10= df6["ArrTime"]-df6["CRSArrTime"]**
#
# **x11= df6["DepTime"]-df6["CRSDepTime"]**
#
# podemos observar una relación lineal.
#
#
#
# Por otro lado, habíamos visto en el ejercicio 9.1 lo siguiente:
#
# "ActualElapsedTime", "CRSElapsedTime","AirTime" y "Distance" tienen un coeficiente de correlación lineal entre ellas cercano a 0,95  ±2  , mientras que ArrDelay y DepDelay, tienen una correlación cercana a cero respecto a estas 4 variables.
#
# Arrdelay y DepDelay tienen una correlación cercana a 0,8.
#
# Por lo que sólo nos queda estudiar Taxiin y taxiout

# In[616]:

f,axs= plt.subplots(2, 1, figsize=(14,8))

sns.regplot(data=df6, x=  "TaxiIn",y = "ArrDelay",ax= axs[0], ci=None,scatter_kws={"color": "blue"}, line_kws={"color": "red"})

sns.regplot( data=df6, x=  "TaxiOut",y = "ArrDelay",ax= axs[1], ci=None,scatter_kws={"color": "blue"}, line_kws={"color": "red"})

plt.show()

# Podemos ver que ambas variables (TaxiIn y TaxiOut)tienen una correlación muy baja respecto a ArrDelay, a pesar de la tendencia
# lineal. Pero hay una gran acumulación de restrasos importantes a pesar de tiempos cortos de tiempos de despegue (TaxiOut) o de
# aterrizaje, lo que hace perder la linealidad para valores bajos de taxiin o taxiouit
#
#

# 0.5 **Transformación y Selección de Variable**
#
# Vamos a usar el coeficiente de correlación para seleccionar las características que mejor nos sirven para la regressión.
#
# Antes de todo, vamos a remodelar el data set, añadiendo x10 y x11, y eliminado 'DepTime', 'CRSDepTime', 'ArrTime', 'CRSArrTime', ya que x10 y x11 son combinaciones lienales de estas 4.
#
# También eliminamos 'ActualElapsedTime', 'CRSElapsedTime', 'AirTime' ya que tienen un 0.95 de correlación o más  con Distance y aportan la misma información.
#
#

# In[617]:

x10=x10.rename("X10")
x11=x11.rename("X11")
x10.describe()

# In[618]:

x11.describe()

# In[619]:

x1= pd.concat([x10,x11,df6["ArrDelay"]],axis=1)
x1.corr()

# In[620]:

#remodelamos el DF con x10 y x11
df6b=df6.drop(['DepTime', 'CRSDepTime', 'ArrTime', 'CRSArrTime', 'ActualElapsedTime', 'CRSElapsedTime', 'AirTime'], axis=1)
df7=pd.concat([df6b, x10,x11], axis =1)
df7

# -Hasta el momento hemos reducido una docena de variables categóricas, bien porque no aportaban nada como Year, bien porque
# nos aumentaban la dimensionalidad del DataSet  como Origen o bien porque no influenciaban en nada  como
# el mes en que se daba el vuelo sobre el ArrDelay.
#
# -Hemos reducido 4 variables continuas a x10 y x11
#
# -Y hemos reducido 4 variables a 1, debido a su alto grado de correlación entre ellas( dejando Distance)
#
# Con las que quedan, vamos a ver el coeficente de correlación de Spearman, pero antes de todo,vamos a estandarizar las variables
#
#

# In[622]:

scaler = StandardScaler()

df8= pd.DataFrame(scaler.fit_transform(df7), columns=df7.columns )

df8.describe().round(3)

# In[623]:

# y aplicamos el coeficiente de correlación de Spearman
df8corr= df8.corr(method="spearman")
f, ax = plt.subplots(figsize=(15,15))
sns.heatmap(df8corr, vmax=1, vmin=-1, square=True,cmap="Blues", annot=True)
plt.show()

# EL coeficiente de correlación de Sperman tampoco no aporta mucho más que el de Pearson. Vamos a mirar un método de selección
# de variables, para ver cuales son las mejores variables. Escogeremos f_regression.

# In[624]:

df8.columns

# In[626]:

from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import f_regression
Xpreseleccion= df8.drop(["ArrDelay"], axis=1)
ypreseleccion= df8["ArrDelay"]
for i in range(1,12): # vamos a mirar como f_selection va escogiendo las variables en función del estadístico F
    fs = SelectKBest(score_func=f_regression, k=i)
    XS=fs.fit(Xpreseleccion,ypreseleccion)

    filter=fs.get_support()
    variables=np.array(Xpreseleccion.columns)
    print(variables[filter])
    print (XS.scores_[filter])
    print ("\n")

# Observamos que la selección de variables por f_Regression nos lleva a unos resultados muy similares al coeficiente correlación
# Pearson. Así que escogeremos la variables con mayor inidce que correlación:
#
#  sean las variables,    ['DepDelay' 'TaxiOut' 'CarrierDelay' 'NASDelay' 'LateAircraftDelay']
#

# In[627]:

df9= df8[["ArrDelay",'DepDelay', 'CarrierDelay', 'NASDelay' ,'LateAircraftDelay', 'X10', 'X11']]
df9.head()

# 0.6 **Separación entre Train y Test**.

# In[669]:

X_= df9.drop(["ArrDelay"], axis=1)

y_= df9["ArrDelay"]

X_train, X_test, y_train, y_test = train_test_split( X_, y_, test_size=0.30, random_state=42, shuffle=True)

# 1.  **Modelos de regresión**
#
# Crea tres modelos de regresión para predecir ArrDelay

# In[670]:

#Creamos los 3 modelos
lin = LinearRegression()
rft=RandomForestRegressor(n_estimators=200, max_depth=10, random_state=42 )
mpl= MLPRegressor(hidden_layer_sizes=(20,20,20), activation="logistic", solver="sgd",max_iter=300 )

# - **Modelo de regresión lineal**

# In[671]:

lin.fit(X_train, y_train)
fx_lin= lin.predict(X_test)# la f(x0,....,xn)predicha

print(fx_lin)# valores de fx predichos
print(fx_lin.shape) #tamaño de la matriz

# In[672]:

r_lin = lin.score(X_test, y_test)
r_lin # podemos ver que el ajuste de correlación es de valor alto

# In[673]:

# sea y = A1X1+A2X2+......+AnXn + b
print('punto de corte del eje y(x=0) ', lin.intercept_) # marca el punto de intercepeción del eje y cuando x=0, b
print( "coeficientes de las variables x", lin.coef_)# marca los coeficientes A1,...:AN de las variables indeondientes

# - **Modelo de bosque aleatorio**

# In[674]:

rft.fit(X_train, y_train)
fx_rft= rft.predict(X_test)# la f(x0,....,xn)predicha
print(fx_rft)# valores de fx predichos

# In[675]:

# miramos la correlación lienal
r_rft = rft.score(X_test, y_test)
r_rft

# In[676]:

# como no calcula coeficientes, ya que los cálculos los hace en función de la ganancia de información de cada arbol del conjunto
# aleatorio, miramos la importancia de cada caracterísitca.
importance = rft.feature_importances_
variables_finales=['DepDelay', 'CarrierDelay', 'NASDelay' ,'LateAircraftDelay', 'X10', 'X11']
for i,j in enumerate(importance):
    print('Feature: %0d, Score: %.5f' % (i,j), variables_finales[i])

# - **Modelo de red neuronal perceptron multicapa**

# In[677]:

mpl.fit(X_train, y_train)
fx_mpl= mpl.predict(X_test)# la f(x0,....,xn)predicha

print(fx_mpl)# valores de fx predichos

# In[678]:

# comprobamos el coeficiente de la regresión
r_mpl= mpl.score(X_test, y_test)
r_mpl

# 2. **Comprueba el error en la métrica de MSE y R2**
#

# Podemos observar, que los coeficientes de correlación tienen muy buenos ajustes.
#
#

# In[679]:

print( "correlación lineal para la regresión lineal ", r_lin)

# In[680]:

print( "correlación lineal para el bosque aleatorio ", r_rft)

# In[681]:

print( "correlación lineal para el perceptrón multicapa ", r_mpl)

# Ahora miramos el error cuadrático medio

# In[703]:

print('Error cuadrático medio de la regresión lineal :', mean_squared_error(y_test, fx_lin))

# In[704]:

print('Error cuadrático medio del bosque aleatorio:', mean_squared_error(y_test, fx_rft))

# In[705]:

print('Error cuadrático medio de la red enurona:', mean_squared_error(y_test, fx_mpl))

# Contando que las variables están estandarizadas, y la media tiende a cero, y el error cuadrático medio reduce las
# discrepancias menores a uno, el que mejor rendimiento saca es el Bosque Aleatorio

# - **Ejercicio 3** :Modificar el modelo para ver el resultado.
#
# Vamos a modificar ciertos parámetros del modelo para ver cómo responden

# ------------------------------------------------------------------------------------

# .  **Regresión lineal**

# Modificamos el témino constante

# In[686]:

#Empecemos modificando, quitando el término constante de la ecuación
lin2 = LinearRegression(fit_intercept= False  )

# In[687]:

lin2.fit(X_train, y_train)
fx_lin2= lin2.predict(X_test)

# In[701]:

r_lin2 = lin2.score(X_test, y_test)
print("coeficiente sin término constante", r_lin2)
print("coeficiente con término constante ", r_lin)
print("diferencia de ajuste  = ", (r_lin-r_lin2))
if r_lin< r_lin2:
    print ( "la regresión sin término constante tiene mejor ajuste ")
else:
    print ( "la regresión con término constante tiene mejor ajuste ")

# In[707]:

print( "coeficientes de las variables x sin término constante ", lin2.coef_)
print( "coeficientes de las variables x con término constante ", lin.coef_)

# In[759]:

print('Error cuadrático medio de la regresión lineal sin término constante:', mean_squared_error(y_test, fx_lin2))
print('Error cuadrático medio de la regresión lineal con término constante:', mean_squared_error(y_test, fx_lin))
if  mean_squared_error(y_test, fx_lin)<  mean_squared_error(y_test, fx_lin2):
    print ( "la regresión con término constante tiene menor error de ajuste ")
else:
    print ( "la regresión sin término constante tiene menor error de ajuste ")

# Tenemos unas discrepancias mínimas, podemos ver que el ajuste sin término constante tiene mejor ajuste con el coeficiente de
# correlación, sin embargo su error es menor en el término constante

# . **Bosque Aleatorio.**

# Empecemos modificando el número de árboles a la mitad

# In[714]:

rft2=RandomForestRegressor( n_estimators=100, max_depth=10, random_state=42 )

# In[715]:

rft2.fit(X_train, y_train)
fx_rft2= rft2.predict(X_test)

# In[722]:

r_rft2 = rft2.score(X_test, y_test)
print("r del bosque  con 100 árboles  ", r_rft2)
print("r del bosque  con 200 árboles  ", r_rft)

# In[723]:

if r_rft< r_rft2:
    print ( "bosque  con 100 árboles, tiene mejor ajuste")
else:
    print ( "bosque  con 200 árboles , tiene mejor ajuste ")

# In[760]:

print('Error cuadrático medio de la regresión lineal con 100 árboles:', mean_squared_error(y_test, fx_rft2))
print('Error cuadrático medio de la regresión lineal con 200 árboles:', mean_squared_error(y_test, fx_rft))
if  mean_squared_error(y_test, fx_rft)<  mean_squared_error(y_test, fx_rft2):
    print ( "la regresión con 200 árboles tiene menor error de ajuste ")
else:
    print ( "la regresión con 100 árboles tiene menor error de ajuste ")

# modificamos el máximo de la profundidad de las capas a la mitad

# In[719]:

rft3=RandomForestRegressor( n_estimators=200, max_depth=5, random_state=42 )

# In[720]:

rft3.fit(X_train, y_train)
fx_rft3= rft3.predict(X_test)

# In[725]:

r_rft3 = rft3.score(X_test, y_test)
print("r del bosque  con 5 capas   ", r_rft3)
print("r del bosque  con 10 capas   ", r_rft)

# In[726]:

if r_rft< r_rft3:
    print ( "bosque  con 5 capas, tiene mejor ajuste")
else:
    print ( "bosque con 10 capas , tiene mejor ajuste ")

# In[761]:

print('Error cuadrático medio de la regresión lineal con 5 capas:', mean_squared_error(y_test, fx_rft3))
print('Error cuadrático medio de la regresión lineal con 10 capas:', mean_squared_error(y_test, fx_rft))
if  mean_squared_error(y_test, fx_rft)<  mean_squared_error(y_test, fx_rft3):
    print ( "la regresión con 10 capas tiene menor error de ajuste ")
else:
    print ( "la regresión con  5 capas tiene menor error de ajuste ")

# - **Red Neuronal**

# Vamos a modificar el número de capas, la tasa de aprendizaje, la función de activación, el método de cálculo del gradiente,

# In[728]:

mpl1= MLPRegressor(hidden_layer_sizes=(20,20), activation="logistic", solver="sgd",max_iter=300 )# número de capas
mpl2= MLPRegressor(hidden_layer_sizes=(20,20,20), activation="relu", solver="sgd",max_iter=300 )# la función de activación
mpl3= MLPRegressor(hidden_layer_sizes=(20,20,20), activation="logistic", solver="sgd",max_iter=300, learning_rate_init=0.01,
                  learning_rate= "invscaling")# modificando la tasa de aprendizaje
mpl4= MLPRegressor(hidden_layer_sizes=(20,20,20), activation="logistic", solver="adam",max_iter=300 )# solventamos por Adam

# En MPL1 hemos quitado una capa

# In[729]:

mpl1.fit(X_train, y_train)#Entrenamos los modelos

# En MPL2 hemos cambiado la función de activación tipo RELU, tal que si x<0 Relu=0 , si x>=0, Relu=x

# In[730]:

mpl2.fit(X_train, y_train)

# En MPL 3 hemos modificado hemos modificado la tasa de aprendizaje de 0.001 a 0.01, y en vez de ser constante será decreciente.

# In[731]:

mpl3.fit(X_train, y_train)

# En mpl4 hemos cambiado la manera de solventart el cálculo de pesos, pasando de una solución por gradiente a una por gradiente
# en que la tasa de aprendizaje es adaptativa(ADAM)

# In[732]:

mpl4.fit(X_train, y_train)

# **Red con dos capas en vez de tres**

# In[736]:

# Analizamos la red con una capa menos
fx_mpl1= mpl1.predict(X_test)

# In[737]:

r_mpl1 = mpl1.score(X_test, y_test)
print("r de red con dos capas  ", r_mpl1)
print("r de red  con 3 capas   ", r_mpl)
if r_mpl< r_mpl1:
     print ( "red con dos capas ocultas tiene mejor ajuste")
else:
    print ( "red con tres capas ocultas tiene mejor ajuste")

# In[762]:

print('Error cuadrático medio de la regresión lineal con 2 capas:', mean_squared_error(y_test, fx_mpl1))
print('Error cuadrático medio de la regresión lineal con 3 capas:', mean_squared_error(y_test, fx_mpl))
if  mean_squared_error(y_test, fx_mpl)<  mean_squared_error(y_test, fx_mpl1):
    print ( "la regresión con 3 capas tiene menor error de ajuste ")
else:
    print ( "la regresión con  2 capas tiene menor error de ajuste ")

# Podemos ver que la red de 3 capas  tiene un mejor ajuste y menor error

# ---------------------------------------------

# - **Red con función de activación RELU**

# In[739]:

fx_mpl2= mpl2.predict(X_test)

# In[741]:

r_mpl2 = mpl2.score(X_test, y_test)
print("r de red con función de activación RELU  ", r_mpl2)
print("r de red  con función de activación logística  ", r_mpl)
if r_mpl< r_mpl2:
     print ( "red con función de activación RELU tiene mejor ajuste")
else:
    print ( "red con función de activación logística tiene mejor ajuste")

# In[763]:

print('Error cuadrático medio de la regresión lineal con función de activación Relu:', mean_squared_error(y_test, fx_mpl2))
print('Error cuadrático medio de la regresión lineal con función de activación logísitca:', mean_squared_error(y_test, fx_mpl))
if  mean_squared_error(y_test, fx_mpl)<  mean_squared_error(y_test, fx_mpl2):
    print ( "la regresión con función de activación logísitca tiene menor error de ajuste ")
else:
    print ( "la regresión con  función de activación Relu: tiene menor error de ajuste ")

# - **red con tasa de aprendizaje descendiente**

# In[743]:

fx_mpl3= mpl3.predict(X_test)

# In[749]:

r_mpl3 = mpl3.score(X_test, y_test)
print("r de red con tasa de aprendizaje descendiente  ", r_mpl3)
print("r de red  con tasa de aprendizaje constante  ", r_mpl)
if r_mpl< r_mpl3:
     print ( "red con tasa de aprendizaje descendiente tiene mejor ajuste")
else:
    print ( "red con tasa de aprendizaje constante tiene mejor ajuste")

# In[764]:

print('Error cuadrático medio de la regresión lineal con tasa de aprendizaje descendiente:', mean_squared_error(y_test, fx_mpl3))
print('Error cuadrático medio de la regresión lineal con tasa de aprendizaje constante :', mean_squared_error(y_test, fx_mpl))
if  mean_squared_error(y_test, fx_mpl)<  mean_squared_error(y_test, fx_mpl3):
    print ( "la regresión con tasa de aprendizaje constante tiene menor error de ajuste ")
else:
    print ( "la regresión con  tasa de aprendizaje descendiente tiene menor error de ajuste ")

# Con estos dos cambios, pasar de la tasa de aprendizaje a 0.01 y hacerla descendiente, hemos perdido calidad en el ajuste y en el
# error

# - **Red que calcula los pesos con el método de adam**

# In[748]:

fx_mpl4= mpl4.predict(X_test)

# In[752]:

r_mpl4 = mpl4.score(X_test, y_test)
print("r de red con método de ADAM  ", r_mpl4)
print("r de red  con método de SGD  ", r_mpl)
if r_mpl< r_mpl4:
     print ( "red con método de ADAM tiene mejor ajuste")
else:
    print ( "red con método de SGD tiene mejor ajuste")

# In[765]:

print('Error cuadrático medio de la regresión lineal con método de ADAM:', mean_squared_error(y_test, fx_mpl4))
print('Error cuadrático medio de la regresión lineal con método de SGD :', mean_squared_error(y_test, fx_mpl))
if  mean_squared_error(y_test, fx_mpl)<  mean_squared_error(y_test, fx_mpl4):
    print ( "la regresión  con método de SGD tiene menor error de ajuste ")
else:
    print ( "la regresión con método de ADAM tiene menor error de ajuste ")

# ------------------------------------------------------------------------

# - **Ejercicio 4.**  Validación Interna.
#
# Vamos a ha hacer las mismas pruebas pero sin hacer entrenamiento

# In[753]:

linvi = LinearRegression()
rftvi=RandomForestRegressor(n_estimators=200, max_depth=10, random_state=42 )
mplvi= MLPRegressor(hidden_layer_sizes=(20,20,20), activation="logistic", solver="sgd",max_iter=300 )

# - **Regresión lineal**

# In[754]:

linvi.fit(X_, y_)
fx_linvi= linvi.predict(X_)

# In[816]:

r_linvi = linvi.score(X_, y_)
print("r de regresión lineal sin entrenamiento  ", r_linvi)
print("r de regresión lineal con entrenamiento ", r_lin)
if r_lin< r_linvi:
     print ( "regresion sin entrenamiento tiene  mejor ajuste")
else:
    print ( "regresion con entrenamiento tiene mejor ajuste")

# In[766]:

print('Error cuadrático medio de la regresión lineal sin entrenamiento :', mean_squared_error(y_, fx_linvi))
print('Error cuadrático medio de la regresión lineal con entrenamiento :', mean_squared_error(y_test, fx_lin))
if  mean_squared_error(y_test, fx_lin)<  mean_squared_error(y_, fx_linvi):
    print ( "la regresión  con entrenamiento tiene menor error de ajuste ")
else:
    print ( "la regresión sin entrenar tiene menor error de ajuste ")

# - **Bosque aleatorio**

# In[768]:

rftvi.fit(X_, y_)
fx_rftvi= rftvi.predict(X_)

# In[817]:

r_rftvi = rftvi.score(X_, y_)
print("r de regresión lineal sin entrenamiento  ", r_rftvi)
print("r de regresión lineal con entrenamiento ", r_rft)
if r_rft< r_rftvi:
     print ( "bosque aleatorio sin entrenamiento tiene mejor ajuste")
else:
    print ( "bosque aleatorio con entrenamiento tiene mejor ajuste")

# In[773]:

print('Error cuadrático medio de la regresión lineal sin entrenamiento :', mean_squared_error(y_, fx_rftvi))
print('Error cuadrático medio de la regresión lineal con entrenamiento :', mean_squared_error(y_test, fx_rft))
if  mean_squared_error(y_test, fx_rft)<  mean_squared_error(y_, fx_rftvi):
    print ( "la regresión  con entrenamiento tiene menor error de ajuste ")
else:
    print ( "la regresión sin entrenar tiene menor error de ajuste ")

# - **Red Neuronal**

# In[774]:

mplvi.fit(X_, y_)
fx_mplvi= mplvi.predict(X_)

# In[783]:

r_mplvi = mplvi.score(X_, y_)
print("r de regresión lineal sin entrenamiento  ", r_mplvi)
print("r  de regresión lineal con entrenamiento ", r_mpl)
if r_mpl< r_mplvi:
     print ( "red sin entrenamiento tiene mejor ajuste")
else:
    print ( "red con entrenamiento tiene mejor ajuste")

# In[776]:

print('Error cuadrático medio de la regresión lineal sin entrenamiento :', mean_squared_error(y_, fx_mplvi))
print('Error cuadrático medio de la regresión lineal con entrenamiento :', mean_squared_error(y_test, fx_mpl))
if  mean_squared_error(y_test, fx_mpl)<  mean_squared_error(y_, fx_mplvi):
    print ( "la regresión  con entrenamiento tiene menor error de ajuste ")
else:
    print ( "la regresión sin entrenar tiene menor error de ajuste ")

# **NIVEL 2.**
#
# "Realiza  algún proceso de ingeniería para mejorar el proceso."
#
# En verdad, esto ya lo he hecho en el apartado 0, preproceso.
#
# Así que vamos intentar ver que pasa si en vez de Estandarizar, normalizamos

# In[798]:

from sklearn.preprocessing import Normalizer
norm= Normalizer()
df8norm= pd.DataFrame(norm.fit_transform(df7), columns=df7.columns )
df8norm.head(10)

# In[799]:

df9norm= df8norm[["ArrDelay",'DepDelay', 'CarrierDelay', 'NASDelay' ,'LateAircraftDelay', 'X10', 'X11']]
Xn= df9norm.drop(["ArrDelay"], axis=1)

yn= df9norm["ArrDelay"]

Xntrain, Xntest, yntrain, yntest = train_test_split( Xn, yn, test_size=0.30, random_state=42, shuffle=True)

# In[800]:

linn = LinearRegression()
rftn=RandomForestRegressor(n_estimators=200, max_depth=10, random_state=42 )
mpln= MLPRegressor(hidden_layer_sizes=(20,20,20), activation="logistic", solver="sgd",max_iter=300 )

# - **REGRESIÓN LINEAL**

# In[801]:

linn.fit(Xntrain, yntrain)
fx_linn= linn.predict(Xntest)

# In[804]:

r_linn = linn.score(Xntest, yntest)
print("r de regresión lineal  sobre variables normalizadas  ", r_linn)
print("r de regresión lineal sobre variables estandarizadas ", r_lin)
if r_lin< r_linn:
     print ( "regresión sobre variables normalizadas  tiene  mejor ajuste")
else:
    print ( "regresión sobre variables estandarizadas tiene mejor ajuste")

# In[807]:

print('Error cuadrático medio de la regresión lineal  sobre variables normalizadas :', mean_squared_error(yntest, fx_linn))
print('Error cuadrático medio de la regresión lineal sobre variables estandarizadas :', mean_squared_error(y_test, fx_lin))
if  mean_squared_error(y_test, fx_lin)<  mean_squared_error(yntest, fx_linn):
    print ( "la regresión sobre variables estandarizadas tiene menor error de ajuste ")
else:
    print ( "la regresión sobre variables normalizadas tiene menor error de ajuste ")

# - **Bosque Aleatorio**

# In[806]:

rftn.fit(Xntrain, yntrain)
fx_rftn= rftn.predict(Xntest)

# In[808]:

r_rftn = rftn.score(Xntest, yntest)
print("r de regresión lineal  sobre variables normalizadas  ", r_rftn)
print("r de regresión lineal sobre variables estandarizadas ", r_rft)
if r_rft< r_rftn:
     print ( "regresión sobre variables normalizadas  tiene  mejor ajuste")
else:
    print ( "regresión sobre variables estandarizadas tiene mejor ajuste")

# In[809]:

print('Error cuadrático medio de la regresión lineal  sobre variables normalizadas :', mean_squared_error(yntest, fx_rftn))
print('Error cuadrático medio de la regresión lineal sobre variables estandarizadas :', mean_squared_error(y_test, fx_rft))
if  mean_squared_error(y_test, fx_rft)<  mean_squared_error(yntest, fx_rftn):
    print ( "la regresión  estándar tiene menor error de ajuste ")
else:
    print ( "la regresión normalizada tiene menor error de ajuste ")

# - **Nivel 3**.
#
# "Haz los cálculos sin contar con DepDelay"
#

# In[843]:

df11= df9[["ArrDelay", 'CarrierDelay', 'NASDelay' ,'LateAircraftDelay', 'X10', 'X11']]
Xb= df11.drop(["ArrDelay"], axis=1)

yb= df11["ArrDelay"]

Xtrainb, Xtestb, ytrainb, ytestb = train_test_split( Xb, yb, test_size=0.30, random_state=42, shuffle=True)

# In[844]:

mplb= MLPRegressor(hidden_layer_sizes=(20,20,20), activation="logistic", solver="sgd",max_iter=300 )

# In[845]:

mplb.fit(Xtrainb, ytrainb)
fx_mplb= mplb.predict(Xtestb)

# In[846]:

r_mplb = mplb.score(Xtestb, ytestb)
print("r de regresión lineal sin DepDelay  ", r_mplb)
print("r  de regresión lineal con DepDelay ", r_mpl)
if r_mpl< r_mplb:
     print ( "red sin DepDelay tiene mejor ajuste")
else:
    print ( "red con DepDelay tiene mejor ajuste")

# In[847]:

print('Error cuadrático medio de la regresión lineal sin DepDelay :', mean_squared_error(ytestb, fx_mplb))
print('Error cuadrático medio de la regresión lineal con DepDelay :', mean_squared_error(y_test, fx_mpl))
if  mean_squared_error(y_test, fx_mpl)<  mean_squared_error(ytestb, fx_mplb):
    print ( "la regresión  con DepDelay tiene menor error de ajuste ")
else:
    print ( "la regresión sin DepDelay tiene menor error de ajuste ")

# En este último caso podemos observar un coeficiente correlación  muy baja, sin embargo un error igual de bajo que con menor
# error de ajust.
#
#

# In[860]:

df13=pd.DataFrame( { "ytestb": ytestb, "fx_mplb":fx_mplb})
df13.head(50)

# In[ ]:

# In[ ]:

# In[ ]:

# In[ ]:

# In[ ]:

sprint9 tasca2 Aprenantatge supervisat.py


#%%
import matplotlib.pyplot as plt
import matplotlib as mpl
import numpy as np
import random
import math

plt.style.use('_mpl-gallery')

data = []

trials = 50
num_dots = 1000

for i in range(1,num_dots):
    #print(i)
    totalPI = 0
    for k in range(trials):
        circle_points = 0
        square_points = 0
        #print(k)
        for j in range(i):
            rand_x = random.uniform(-1, 1)
            rand_y = random.uniform(-1, 1)
            origin_dist = rand_x**2 + rand_y**2
            if origin_dist <= 1:
                circle_points += 1

            square_points += 1
        totalPI += 4 * circle_points / i
    totalPI =  totalPI / trials
    print(totalPI)
    data.append(pow(-1, 1/(totalPI*1j)))
    #

fig = plt.figure(figsize=(15,10))

ax1 = plt.subplot(331)
for i in data:
    ax1.plot(data, c='k', lw=0.1)

ax1.axhline(np.pi, c='tab:red', label='pi')
#ax1.axhline(math.e, c='tab:red', label="Euler's Number")
ax1.set_xlim(0,num_dots)
#ax1.set_xticklabels([])
ax1.set_ylim(np.pi-(np.pi/2),np.pi+(np.pi/2))
#ax1.set_ylim(math.e-(math.e/2),math.e+(math.e/2))
ax1.set_ylabel("PI Approximation")
#ax1.set_ylabel("Euler's Number Approximation")
ax1.set_xlabel("Number of iterations")
ax1.legend(loc="upper right")

# function to show the plot
plt.show()

# %%


from psd_tools import PSDImage
psd = PSDImage.open('test.psd')
visages = psd[1]
tenues = psd[2]
total_visages = len(visages)
total_tenues = len(tenues)
for i, v in enumerate(visages):
    print(f'Visage {v.name} ({i}/{total_visages})')
    for v2 in visages:
        v2.visible = False
    v.visible = True
    for j, t in enumerate(tenues):
        print(f'\tTenue {t.name} ({j}/{total_tenues})')
        for t2 in tenues:
            t2.visible = False
        t.visible = True
        file_name = f'output/pilots/{t.name}_{v.name}.png'
        psd.composite(layer_filter=lambda x:x.is_visible()).save(file_name)
        t.visible = False
    v.visible = False


import cv2
import matplotlib.pyplot as plt

# içe aktar
einstein = cv2.imread("einstein.jpg", 0)
plt.figure(), plt.imshow(einstein, cmap = "gray"), plt.axis("off")

# sınıflandırıcı
face_cascade = cv2.CascadeClassifier("haarcascade_frontalface_default.xml")

face_rect = face_cascade.detectMultiScale(einstein)

for (x,y,w,h) in face_rect:
    cv2.rectangle(einstein, (x,y),(x+w, y+h),(255,255,255),10)
plt.figure(), plt.imshow(einstein, cmap = "gray"), plt.axis("off")

# barce
# içe aktar
barce = cv2.imread("barcelona.jpg", 0)
plt.figure(), plt.imshow(barce, cmap = "gray"), plt.axis("off")

face_rect = face_cascade.detectMultiScale(barce, minNeighbors = 7)

for (x,y,w,h) in face_rect:
    cv2.rectangle(barce, (x,y),(x+w, y+h),(255,255,255),10)
plt.figure(), plt.imshow(barce, cmap = "gray"), plt.axis("off")

# video
cap = cv2.VideoCapture(0)

while True:

    ret, frame = cap.read()

    if ret:

        face_rect = face_cascade.detectMultiScale(frame, minNeighbors = 7)

        for (x,y,w,h) in face_rect:
            cv2.rectangle(frame, (x,y),(x+w, y+h),(255,255,255),10)
        cv2.imshow("face detect", frame)

    if cv2.waitKey(1) & 0xFF == ord("q"): break

cap.release()
cv2.destroyAllWindows()


import dash
from dash import Dash, dcc, html, Input, Output
from dash.exceptions import PreventUpdate
# import dash_daq as daq
import plotly.express as px
import pandas as pd
from jupyter_dash import JupyterDash

app = Dash(__name__)

light_theme = {
    "main-background": "#ffe7a6",
    "header-text": "#376e00",
    "sub-text": "#0c5703",
}

dark_theme = {
    "main-background": "#000000",
    "header-text": "#ff7575",
    "sub-text": "#ffd175",
}

app.layout = html.Div(
    id="parent_div",
    children=[
        daq.BooleanSwitch(on=False, id="bool-switch-input"),
        html.Div(id="bool-switch-output"),
        html.H1(
            children="This is a heading text",
            id="head-txt",
            style={"color": light_theme["header-text"]},
        ),
        html.H2(
            children="This is a subtext",
            id="sub-txt",
            style={"color": light_theme["sub-text"]},
        ),
    ],
    style={"backgroundColor": light_theme["main-background"]},
)

@app.callback(
    [
        Output("parent_div", "style"),
        Output("head-txt", "style"),
        Output("sub-txt", "style"),
    ],
    Input("bool-switch-input", "on"),
)
def update_output(on):
    theme = dark_theme if on else light_theme

    return (
        {"backgroundColor": theme["main-background"]},
        {"color": theme["header-text"]},
        {"color": theme["sub-text"]},
    )

if __name__ == "__main__":
    app.run_server(mode="inline")


import requests
import re
import pandas as pd

# Import Data

# Define a function to clean characters
def clean_string(s):
    return str(s).replace('\r', '').replace('"', '')

def ImportData_rent():
    url = "https://ws.cso.ie/public/api.jsonrpc?data=%7B%22jsonrpc%22:%222.0%22,%22method%22:%22PxStat.Data.Cube_API.ReadDataset%22,%22params%22:%7B%22class%22:%22query%22,%22id%22:%5B%5D,%22dimension%22:%7B%7D,%22extension%22:%7B%22pivot%22:null,%22codes%22:false,%22language%22:%7B%22code%22:%22en%22%7D,%22format%22:%7B%22type%22:%22JSON-stat%22,%22version%22:%222.0%22%7D,%22matrix%22:%22RIA02%22%7D,%22version%22:%222.0%22%7D%7D"
    # Define the JSON-RPC request payload
    payload_rent = {
        "jsonrpc": "2.0",
        "method": "PxStat.Data.Cube_API.ReadDataset",
        "params": {
            "class": "query",
            "id": [],
            "dimension": {},
            "extension": {
                "language": {
                    "code": "en"
                },
                "format": {
                    "type": "CSV",
                    "version": "1.0"
                },
                "matrix": "RIA02"
            },
            "version": "2.0"
        }
    }

    # Make the POST request
    response_rent = requests.post(url, json=payload_rent)

    # Check if the request was successful (status code 200)
    if response_rent.status_code == 200:
        data = response_rent.json()
        data_result = data['result']
        lines = data_result.split('\r')
        data_result = [re.findall(r'"([^"]*)"', line) for line in lines[1:]]
        df = pd.DataFrame(data_result,
                          columns=['STATISTIC Label', 'Year', 'Number of Bedrooms', 'Property Type', 'Location', 'UNIT',
                                   'VALUE'])
    else:
        print(f"Error connecting to API. Status code: {response_rent.status_code}")

    return df

def ImportData_census():
    payload_census = {
        "jsonrpc": "2.0",
        "method": "PxStat.Data.Cube_API.ReadDataset",
        "params": {
            "class": "query",
            "id": [],
            "dimension": {},
            "extension": {
                "pivot": "C02199V02655",
                "codes": 1,
                "language": {
                    "code": "en"
                },
                "format": {
                    "type": "CSV",
                    "version": "1.0"
                },
                "matrix": "F1001"
            },
            "version": "2.0"
        }
    }
    url = "https://ws.cso.ie/public/api.jsonrpc?data=%7B%22jsonrpc%22:%222.0%22,%22method%22:%22PxStat.Data.Cube_API.ReadDataset%22,%22params%22:%7B%22class%22:%22query%22,%22id%22:%5B%5D,%22dimension%22:%7B%7D,%22extension%22:%7B%22pivot%22:null,%22codes%22:false,%22language%22:%7B%22code%22:%22en%22%7D,%22format%22:%7B%22type%22:%22JSON-stat%22,%22version%22:%222.0%22%7D,%22matrix%22:%22RIA02%22%7D,%22version%22:%222.0%22%7D%7D"
    # Make the POST request
    response_census = requests.post(url, json=payload_census)

    if response_census.status_code == 200:
        data_census = response_census.json()
        data_result_census = data_census['result']
        lines_census = data_result_census.split('\r')
        data_result_census = [re.findall(r'"([^"]*)"', line) for line in lines_census[1:]]
        df_census = pd.DataFrame(data_result_census,
                                 columns=['STATISTIC', 'Statistic', 'TLIST(A1)', 'CensusYear', 'C02779V03348', 'County',
                                          'UNI', 'Both sexes', 'Male', 'Female'])
    else:
        print(f"Error connecting to API. Status code: {response_census.status_code}")

    return df_census


import os
import pandas as pd
import numpy as np
import nltk
from bs4 import BeautifulSoup
nltk.download('stopwords')
nltk.download('wordnet')
from nltk.stem import PorterStemmer #not used due to poor performance
from nltk.stem import WordNetLemmatizer
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
from nltk.corpus.reader.plaintext import PlaintextCorpusReader
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.model_selection import train_test_split, KFold, cross_val_score
from sklearn.linear_model import LogisticRegression
#from sklearn.model_selection import cross_val_score

def construct_file_list(directory):
	file_list = []
	for text_file in sorted(os.listdir(directory)):
		os.chdir(directory)
		if text_file.endswith(".txt"):
	    	#print(os.getcwd())
			file_list.append(text_file)
	if(directory == '/Users/Tausal21/Desktop/comp_551/mini_peoject_02/test'):
		#file_list.sort(key=lambda f: int(filter(str.isdigit, f)))
		file_list = sorted(file_list , key=lambda x: int(os.path.splitext(x)[0]))
	return file_list

def construct_feature_matrix_countVectorizer(directory, maximum_features, target_column_value, boolean_train):
	file_list = construct_file_list(directory)

	cv = CountVectorizer(input='filename', stop_words='english', max_df=0.75, min_df=5, max_features=maximum_features)
	vec = cv.fit(file_list)

	bag_of_words = vec.transform(file_list)
	feature_matrix_withoutTarget = pd.DataFrame(bag_of_words.toarray(), columns=vec.get_feature_names())

	if(boolean_train == False):
		file_list_df = pd.DataFrame({'col': file_list})
		#print(file_list_df)
		return [feature_matrix_withoutTarget, file_list_df] #This returns the test_set feature matrix
	else:
		if(target_column_value == 1):
			Y_raw = np.ones((12500,), dtype=float)
			target_column_Y = pd.DataFrame(Y_raw, columns=['TARGET_Y']) #appends target column for positive review
		else:
			Y_raw = np.zeros((12500,), dtype=float)
			target_column_Y = pd.DataFrame(Y_raw, columns=['TARGET_Y']) #appends target column for positive review

		feature_matrix = pd.concat([feature_matrix_withoutTarget, target_column_Y], axis=1)
		return feature_matrix #returns pos/neg training feature matrix with labels

def kFold_LogisticRegression(feature_matrix_input, no_of_folds):
	model = LogisticRegression()
	scores = cross_val_score(model, feature_matrix_input.loc[:, feature_matrix_input.columns != 'TARGET_Y'], feature_matrix_input.TARGET_Y, cv=no_of_folds)
	return scores

def Logistic_reg(train_X, train_Y, test_X):
	print("train_X shape: ", train_X.shape)
	print("train_Y shape: ", train_Y.shape)
	model = LogisticRegression()
	model.fit(train_X, train_Y)

	prediction_list = model.predict(test_X)
	return prediction_list

pos_dir = '/Users/Tausal21/Desktop/comp_551/mini_peoject_02/train/pos'
neg_dir = '/Users/Tausal21/Desktop/comp_551/mini_peoject_02/train/neg'
test_dir = '/Users/Tausal21/Desktop/comp_551/mini_peoject_02/test'

pos_features = construct_feature_matrix_countVectorizer(pos_dir, 5000, 1, True)
print("Pos_features shape: ", pos_features.shape)
neg_features = construct_feature_matrix_countVectorizer(neg_dir, 5000, 0, True)
print("Neg_features shape: ", neg_features.shape)

feature_matrix_list = [pos_features, neg_features]
feature_matrix_final = pd.concat(feature_matrix_list, sort=False).fillna(0)
print("final_feature shape: ", feature_matrix_final.shape)
no_of_features = len(feature_matrix_final.columns) - 1
print("number of features: ", no_of_features)

[test_set, file_list_df] = construct_feature_matrix_countVectorizer(test_dir, no_of_features, 0, False)
print("test_set shape: ", test_set.shape)
print(file_list_df)

#scores = kFold_LogisticRegression(feature_matrix_final, 10)
prediction_list = Logistic_reg(feature_matrix_final.loc[:, feature_matrix_final.columns != 'TARGET_Y'], feature_matrix_final.TARGET_Y, test_set)
prediction_list_df = pd.DataFrame(prediction_list)

output_df = pd.concat([file_list_df, prediction_list_df], axis=1)
output_df.to_csv('output2.csv')
print(output_df)


from __future__ import annotations
from alpaca.clr import AST

from alpaca.utils import Visitor

import eisen.adapters as adapters
from eisen.state.state_postinstancevisitor import State_PostInstanceVisitor
from eisen.state.state_postspreadvisitor import State_PostSpreadVisitor
from eisen.state.memcheckstate import MemcheckState

from eisen.__memory.spreads import Spread, SpreadVisitor
from eisen.__memory.deps import FunctionDepsDatabase, Deps

State = MemcheckState

class MemCheck(Visitor):
    def __init__(self, debug: bool = False):
        super().__init__(debug=debug)
        self.get_deps = None

    def run(self, state: State_PostInstanceVisitor) -> State_PostSpreadVisitor:
        self.get_deps = GetDeps(state)
        internal_state = MemcheckState.create_from_basestate(state)

        self.get_deps.of_function(internal_state.but_with(ast=MemCheck.get_main_function(state.get_ast())))
        # self.apply(internal_state)
        return State_PostSpreadVisitor.create_from_basestate(state, self.get_deps.cache)

    def apply(self, state: State):
        self._route(state.get_ast(), state)

    @Visitor.for_ast_types("start")
    def _start(fn, state: State):
        state.apply_fn_to_all_children(fn)

    @Visitor.for_ast_types("mod")
    def _mod(fn, state: State):
        adapters.Mod(state).enter_module_and_apply(fn)

    @Visitor.for_ast_types("def", "create", "is_fn")
    def _def(fn, state: State):
        fn.get_deps.of_function(state)

    @Visitor.for_ast_types("struct")
    def _create(fn, state: State):
        node = adapters.Struct(state)
        if node.has_create_ast():
            fn.apply(state.but_with(ast=node.get_create_ast()))

    @Visitor.for_ast_types("variant")
    def _variant(fn, state: State):
        node = adapters.Variant(state)
        fn.apply(state.but_with(ast=node.get_is_ast()))

    @Visitor.for_ast_types("interface")
    def _nothing(fn, state: State):
        return

    @classmethod
    def get_main_function(cls, full_ast: AST) -> AST:
        for child in full_ast:
            if child.type == "def" and child.first().value == "main":
                return child

class GetDeps():
    """Representation of the function GET_DEPS: F -> F_Deps with local caching and DP to prevent
    unnecessary lookups.
    """
    def __init__(self, state: State):
        self.cache = FunctionDepsDatabase()
        self.spread_visitor = SpreadVisitor(self)
        self._add_builtin_function_deps(state)

    def _add_builtin_function_deps(self, state: State):
        for builtin_func_instance in state.get_all_builtins():
            self.cache.add_deps_for(builtin_func_instance, F_deps=Deps(
                R = [[0]],
                A = [[0], []]))

    def _try_cache_lookup(self, state: State) -> Deps | None:
        node = adapters.Def(state)
        if not state.get_inherited_fns():
            return self.cache.lookup_deps_of(node.get_function_instance())

    def _add_to_cache(self, state: State, F_deps: Deps):
        node = adapters.Def(state)
        if not state.get_inherited_fns():
            self.cache.add_deps_for(node.get_function_instance(), F_deps)

    def _add_new_spreads_for_inputs(self, state: State):
        """Add new spreads for argument/return values to the function. Argument spreads default
        to only be the argument number, as their lifetime is only dictated by theirselves. Return
        spreads default to the empty set, as there is no information on which arguments dictate
        their lifetimes yet.
        """
        node = adapters.Def(state)
        arg_node = adapters.ArgsRets(state.but_with(ast=node.get_args_ast()))
        for i, name in enumerate(arg_node.get_names()):
            SpreadVisitor.add_spread(state, name, Spread(values={i}, depth=0))

        ret_node = adapters.ArgsRets(state.but_with(ast=node.get_rets_ast()))
        for name in ret_node.get_names():
            SpreadVisitor.add_spread(state, name, Spread(values=set(), depth=0, is_return_value=True))

    def _construct_RVS(self, state: State) -> list[Spread]:
        node = adapters.Def(state)
        ret_node = adapters.ArgsRets(state.but_with(ast=node.get_rets_ast()))
        RVS: list[Spread] = []
        for name in ret_node.get_names():
            spread_for_this_return_value = SpreadVisitor.get_spread(state, name)
            RVS.append(spread_for_this_return_value)

        return RVS

    def _construct_AS(self, state: State) -> list[Spread]:
        node = adapters.Def(state)
        arg_node = adapters.ArgsRets(state.but_with(ast=node.get_args_ast()))
        AS: list[Spread] = []
        for name in arg_node.get_names():
            spread_for_this_argument = SpreadVisitor.get_spread(state, name)
            AS.append(spread_for_this_argument)

        return AS

    def of_function(self, state: State) -> Deps:
        """State should have state.get_ast() return an abstract syntax list of type 'def'. This is
        the pointer to F, and this function will return F_deps. Cache lookups will be performed if
        F takes no free function parameters; else novel computation is required.
        """
        # print("getting deps for", adapters.Def(state).get_function_name())
        cached_f_deps = self._try_cache_lookup(state)
        if cached_f_deps is not None: return cached_f_deps
        # print("no cache found")

        # all processing must occur inside an isolate context, to avoid name collisions from
        # previous functions.
        state = state.but_with(context=state.create_isolated_context())
        node = adapters.Def(state)
        self._add_new_spreads_for_inputs(state)

        # invoke the SpreadVisitor to populate all spreads with the correct values after the
        # function call. Depth counts down, starting at -2 (it is underneath the first argument
        # value), and decreasing for each if/while context entered.
        # note: a depth of -1 indicates a literal/token
        self.spread_visitor.apply(state.but_with(
            ast=node.get_seq_ast(),
            depth=-2))

        RVS = self._construct_RVS(state)
        AS = self._construct_AS(state)

        # # need to keep this here to examine code inside this function, even though we know
        # # it has no return value
        # if not node.has_return_value():
        #     return Deps()

        F_deps = Deps.create_from_return_value_spreads(RVS, AS)
        self._add_to_cache(state, F_deps)
        return F_deps


from odoo import models, fields
import xmlrpc.client
from bs4 import BeautifulSoup
import requests
from multiprocessing import Pool

class InheritResPartner(models.Model):
    _inherit = 'res.partner'

    region = fields.Char(string='Регион')
    nas_punkt = fields.Char(string='Населенный пункт')
    url = fields.Char(string='URL address')
    vid_deyatelnosti = fields.Char(string='Вид деятельности')
    ur_address = fields.Char(string='Юридический адрес')
    fact_address = fields.Char(string='Фактический адрес')
    sector_econ = fields.Char(string='Сектор экономики')
    org_right_form = fields.Char(string='Организационно-правовая форма')
    form_sobs = fields.Char(string='Форма собственности')
    status_pred = fields.Char(string='Статус предприятия')
    bin = fields.Char(string='БИН')
    year_form = fields.Char(string='Год образования')
    status_platelshik = fields.Char(string='Статус плательщика')
    klaster = fields.Char(string='Кластер')
    otrasl = fields.Selection([
        ('0', 'Строительство зданий и жилых помещений'),
        ('1', 'Финансовые услуги'),
        ('2', 'Дизайн и Архитектура')
    ], default='0', index=True, string="Отрасль компании")

    def create_company_odoo(self, data):

        val = self.sudo().search([['url', '=', self.url]])
        if len(val) > 0:
            val.region = data.get('Регион:', 'default value')
            val.nas_punkt = data.get('Населенный пункт:', 'default value')
            val.vid_deyatelnosti = data.get('Вид деятельности:', 'default value')
            val.ur_address = data.get('Юридический адрес:', 'default value')
            val.fact_address = data.get('Фактический адрес:', 'default value')
            val.sector_econ = data.get('Сектор экономики:', 'default value')
            val.org_right_form = data.get('Организационно-правовая форма:', 'default value')
            val.form_sobs = data.get('Форма собственности:', 'default value')
            val.status_pred = data.get('Статус предприятия:', 'default value')
            val.bin = data.get('БИН:', 'default value')
            val.year_form = data.get('Год образования:', 'default value')
            val.status_platelshik = data.get('Статус плательщика:', 'default value')
            val.klaster = data.get('Кластер:', 'default value')
            val.otrasl = '0'

    def get_company_data(self):
        req = requests.get(self.url)
        soup = BeautifulSoup(req.text, 'html.parser')
        soup = soup.find('table', id='reestr_items').find_all('td')
        data = {}
        for i in range(len(soup)):
            if i % 2 == 0:
                data[soup[i].text] = soup[i + 1].text
        self.create_company_odoo(data)
    def simple_method(self):
        print("Hello")

    def get_company_data2(self, pair):
        url, name = pair
        print(url, name)
        name = str(name).replace('ТОВАРИЩЕСТВО С ОГРАНИЧЕННОЙ ОТВЕТСТВЕННОСТЬЮ', 'ТОО')
        name = str(name).replace('ТОВАРИЩЕСТВА С ОГРАНИЧЕННОЙ ОТВЕТСТВЕННОСТЬЮ', 'ТОО')
        r = requests.get(url)
        soup = BeautifulSoup(r.content, 'html.parser')
        table = soup.find('table', id='reestr_items')
        if table is not None:
            data = {
                'Наименование:': name
            }
            for tr in table.find_all('tr'):
                td = [td.text.strip() for td in tr.find_all('td')]
                data[td[0]] = td[1]

            val = self.sudo().search([['url', '=', url]])
            if len(val) == 0:

                self.env['res.partner'].sudo().create({
                    'name': data.get('Наименование:', 'default value'), 'display_name': data.get('Наименование:', 'default value'),
                    'url': url,
                    'is_company': 'company',
                    'region': data.get('Регион:', 'default value'),
                    'nas_punkt': data.get('Населенный пункт:', 'default value'),
                    'vid_deyatelnosti': data.get('Вид деятельности:', 'default value'),
                    'ur_address': data.get('Юридический адрес:', 'default value'),
                    'fact_address': data.get('Фактический адрес:', 'default value'),
                    'sector_econ': data.get('Сектор экономики:', 'default value'),
                    'org_right_form': data.get('Организационно-правовая форма:', 'default value'),
                    'form_sobs': data.get('Форма собственности:', 'default value'),
                    'status_pred': data.get('Статус предприятия:', 'default value'),
                    'bin': data.get('БИН:', 'default value'),
                    'year_form': data.get('Год образования:', 'default value'),
                    'status_platelshik': data.get('Статус плательщика:', 'default value'),
                    'klaster': data.get('Кластер:', 'default value'),
                    'otrasl': '0',
                })

    def get_all_url(self, url, i):
        if i >= 2:
            return []
        data = []
        r = requests.get(url + str(i) + '&SIZEN_1=100')
        soup = BeautifulSoup(r.content, 'html.parser')
        for a in soup.find('tbody').find_all('a'):
            if a.text != 'Подробнее':
                data.append(('http://businessnavigator.kz' + a['href'], a.text))

        if soup.find('a', title='Следующая страница') is None:
            return data
        else:
            data.extend(self.get_all_url(url, i + 1))
        return data

    def data_collector(self):
        base_urls = {
            'Финансовые услуги': 'http://businessnavigator.kz/ru/branch/?OKED_5=&lang=ru&BIN=&NAME=&KATO_1%5B0%5D=467773'
                                 '&OKED_2%5B0%5D=468074&submit-map=&search=%D0%9F%D1%80%D0%B8%D0%BC%D0%B5%D0%BD%D0%B8%D1'
                                 '%82%D1%8C&PAGEN_1=',
            'Строительство зданий': 'http://businessnavigator.kz/ru/branch/?OKED_5=&lang=ru&BIN=&NAME=&KATO_1%5B0%5D'
                                    '=467773&OKED_2%5B0%5D=468055&submit-map=&search=%D0%9F%D1%80%D0%B8%D0%BC%D0%B5%D0%BD'
                                    '%D0%B8%D1%82%D1%8C&PAGEN_1=',
            'Дизайн': 'http://businessnavigator.kz/ru/branch/?OKED_5=&lang=ru&BIN=&NAME=&KATO_1%5B0%5D'
                      '=467773&OKED_2%5B0%5D=468080&submit-map=&search=%D0%9F%D1%80%D0%B8%D0%BC%D0%B5'
                      '%D0%BD%D0%B8%D1%82%D1%8C&PAGEN_1='

        }
        all_url = []
        all_url.extend(self.get_all_url(base_urls['Финансовые услуги'], 1))
        all_url.extend(self.get_all_url(base_urls['Строительство зданий'], 1))
        all_url.extend(self.get_all_url(base_urls['Дизайн'], 1))

        for i in all_url:
            self.get_company_data2(i)


import Adafruit_DHT
import json
from threading import *
import threading
import time
import random

class Sensor:
    def __init__(self):
        self.TemperatureUnit = "Celsius"
        self.sensorDHT111 = SensorCore()
        self.humidity, self.temperature = Adafruit_DHT.read_retry(11, 4)
        #self.settingsFile = open('settings.json','w')
    def getHumidity(self):
        self.sensorDHT111 = SensorCore()
        humidity = self.sensorDHT111.getHumidity()
        return humidity

    def readSensor():
        self.sensorDHT111 = SensorCore()
        return self.sensorDHT111
    def setTemperatureUnit(self,unit):
        print("Unit to set is: " + unit)
        if(unit == "Celsius" or unit == "celsius"):
            self.TemperatureUnit = "Celsius"
            #data = json.load(self.settingsFile)
            #data['temperatureUnit']="Celsius"
        elif(unit == "Farenheit" or unit == "farenheit"):
            self.TemperatureUnit = "Farenheit"
            #data = json.load(self.settingsFile)
            #data['temperatureUnit'] = "Farenheit"
        elif(unit == "Kelvin" or unit == "kelvin"):
            self.TemperatureUnit = "Kelvin"
            #data = json.load(self.settingsFile)
            #data['temperatureUnit'] = "Kelvin"
        else:
            print ("please specify valid unit of temperature")

    def getTemperatureUnit(self):
        #data = json.load(self.settingsFile)
        return self.TemperatureUnit
        #return data['temperatureUnit']

    def getTemperature(self):
        self.sensorDHT111 = SensorCore()
        unit = self.TemperatureUnit
        with open('/home/pi/Documents/DjangoProjects/core/pages/static/pages/settings.txt', 'r') as outfile:
            data = json.load(outfile)
            Nunit = data['TemperatureUnit']
        print("Sensor unit is: " + unit)
        #d = random.randint(0, 100)
        if unit == "Celsius":
            #return d
            return self.sensorDHT111.getTemperature()
        elif unit == "Farenheit":

            #d = self.requestReading()
            tTemp = self.sensorDHT111.getTemperature() * 9/5 + 32
            #tTemp =random.randint(0, 100) * 9/5 + 32
            return tTemp
        elif unit == "Kelvin":
            return self.sensorDHT111.getTemperature() + 273.15
        else:
            print ("temperature unit not specified")
            return None

class SensorCore:
    def __init__(self):
        self.humidity = 0
        self.temperature = 0
        try:
            self.humidity, self.temperature = Adafruit_DHT.read_retry(11, 4)
        except:
            print('Sensor is not connect, check wiring')
    def getTemperature(self):
        return self.temperature
    def getHumidity(self):
        return self.humidity

class temperatureUnits:
    FARENHEIT = 0
    CELSIUS = 1
    KELVIN = 2


import glob
import io
import logging
import os
import pstats
import signal
import sys
import time

from common import util
from collector import Collector

# todo the collector has daemon code but is always run in foreground mode
# from the supervisor, is there a reason for the daemon code then?
class CollectorDaemon():

    """The agent class is a daemon that runs the collector in a background process.

    """
    def __init__(self):
        self.run_forever = True
        self.collector = None
        self.start_event = True

    def run(self, config):
        # Load the checks_d checks
        checksd = util.load_check_directory()

        print("-- check directory was loaded")
        print("Cheksd : {x}".format(x=checksd))

        self.collector = Collector(config, checksd)

        check_frequency = 15

        # Initialize the auto-restarter
        self.agent_start = time.time()

        # Run the main loop.
        while self.run_forever:
            collection_start = time.time()

            # Do the work.
            print("Collector run at {x}".format(x = collection_start))
            self.collector.run(check_frequency)

            # Only plan for the next loop if we will continue,
            # otherwise just exit quickly.
            if self.run_forever:
                collection_time = time.time() - collection_start
                if collection_time < check_frequency:
                    time.sleep(check_frequency - collection_time)

def main():
    print("-- Main function started")
    collector_config = {'Main': {'check_freq': 15,
                'forwarder_url': 'http://localhost:17123',
                'hostname': None,
                'dimensions': None,
                'listen_port': None,
                'version': '',
                'additional_checksd': '/usr/lib/monasca/agent/custom_checks.d',
                'limit_memory_consumption': None,
                'skip_ssl_validation': False,
                'autorestart': True,
                'non_local_traffic': False,
                'sub_collection_warn': 6,
                'collector_restart_interval': 24},
        'Api': {'is_enabled': False,
                'url': '',
                'project_name': '',
                'project_id': '',
                'project_domain_name': '',
                'project_domain_id': '',
                'ca_file': '',
                'insecure': False,
                'username': '',
                'password': '',
                'use_keystone': True,
                'keystone_timeout': 20,
                'keystone_url': '',
                'max_buffer_size': 1000,
                'max_measurement_buffer_size': -1,
                'write_timeout': 10,
                'backlog_send_rate': 5,
                'max_batch_size': 0},
        'Statsd': {'recent_point_threshold': None,
                    'monasca_statsd_interval': 20,
                    'monasca_statsd_forward_host': None,
                    'monasca_statsd_forward_port': 8125,
                    'monasca_statsd_port': 8125},
        'Logging': {'disable_file_logging': False,
                    'log_level': None,
                    'collector_log_file': '/collector.log',
                    'forwarder_log_file': '/forwarder.log',
                    'statsd_log_file':  '/statsd.log',
                    'jmxfetch_log_file': '/jmxfetch.log',
                    'enable_logrotate': True,
                    'log_to_event_viewer': False,
                    'log_to_syslog': False,
                    'syslog_host': None,
                    'syslog_port': None}}

    agent = CollectorDaemon()

    print("-- agent object was created by using CollectorDaemon")

    agent.run(collector_config)

    return 0

if __name__ == '__main__':

    sys.exit(main())


"""
Server for obtaining integrated and integrated directional gradients from specific image models.
"""

import click
from collections import OrderedDict
from flask import Flask, request, send_file
import gzip
from io import BytesIO
import numpy as np
import shutil
import torch

from . import cli_main
from .load_models import load_models
from .run_models import run_models

app = Flask(__name__)
MODEL_DICT = {}
DEVICE = None
THRESHOLD = 0.5

@app.route("/model/", methods=["POST"])
def run_model():
    """
    Obtain the gradients from running the specified model on the input image tensor.
    The outputs are saved as a gzipped dictionary with the keys:
    "pred_masks": torch.tensor(num_segmentations,height,width).
    """
    if request.method == 'POST':
        print(request)
        data = request.json

        img_data = data["img_data"]

        img = np.array(img_data, dtype=np.uint8)

        preds_dict = run_models(MODEL_DICT["model_name"],
                                MODEL_DICT["model"],
                                DEVICE,
                                img,
                                THRESHOLD)

        temp_bytes, temp_gzip = BytesIO(), BytesIO()

        torch.save(preds_dict, temp_bytes)
        temp_bytes.seek(0)

        with gzip.GzipFile(fileobj=temp_gzip, mode='wb') as f_out:
            shutil.copyfileobj(temp_bytes, f_out)

        temp_gzip.seek(0)

        return send_file(temp_gzip, as_attachment=True, mimetype="/application/gzip", attachment_filename="returned_gradients.gzip")

@cli_main.command(help="Start a server and initialize the models for calculating image segmentation.")
@click.option(
    "-h",
    "--host",
    required=False,
    default="localhost",
    help="Host to bind to. Default localhost"
)
@click.option(
    "-p",
    "--port",
    default=8888,
    required=False,
    help="Port to bind to. Default 8888"
)
@click.option(
    "--tensormask-path",
    "-tp",
    required=True,
    help="Path to the pretrained TensorMask model",
    default=None,
)
@click.option(
    "--configuration-path",
    "-cp",
    required=True,
    help="Path to the model's configuration file.  Located in the tensormask_segmentation_server/configs folder.",
    default=None,
)
@click.option(
    "--threshold",
    "-t",
    required=False,
    help="",
    default=0.5,
)
def serve(
        host,
        port,
        tensormask_path,
        configuration_path,
        threshold=0.5,
):
    global MODEL_DICT, DEVICE, THRESHOLD

    if not (0 < float(threshold) < 1):
        raise ValueError("Threshold must be between 0 and 1")

    THRESHOLD = float(threshold)
    DEVICE = torch.device("cuda:0")
    # TensorMask will always load inputs on this device
    try:
        MODEL_DICT = load_models(DEVICE, tensormask_path, configuration_path)
    except Exception as e:
        print("An Error occurred: ", e)
        raise e

    app.run(host=host, port=port, debug=True)


"""Асинхронные задачи Celery."""
from flask import current_app
from sqlalchemy.exc import DBAPIError, SQLAlchemyError

from webapp import celery
from webapp.account.models import Account
from webapp.account.schemas import account_schema
from webapp.db import db
from webapp.item.models import Description, Item

@celery.task(name="account.save_info")
def save_acc_info(user_id, username, **kwargs):
    """Добавляем подключенный аккаунт Steam в БД.

    Если аккаунт уже существует - обновляем данные, которые изменились.
    """
    current_app.logger.info("Save account info function")
    # Создаем список аргументов переданных функции
    args = {}
    for key, value in kwargs.items():
        args[key] = value
    db_steam_acc = Account.query.filter_by(username=username,
                                           user_id=user_id).first()

    if db_steam_acc:
        current_app.logger.info(f"Account {username} already exists. "
                                f"Trying to update data.")
        for arg, value in args.items():
            # Если содержимое ячейки изменилось - перезаписываем его
            if value is not None:
                if getattr(db_steam_acc, arg) != value:
                    current_app.logger.info(
                        f"Old account {arg} is: "
                        f"{getattr(db_steam_acc, arg)}")
                    setattr(db_steam_acc, arg, value)
                    current_app.logger.info(
                        f"New account {arg} is: "
                        f"{getattr(db_steam_acc, arg)}")
    else:
        current_app.logger.info("Create account %s", username)
        db_steam_acc = Account(
            username=username,
            user_id=user_id,
        )
        for arg, value in args.items():
            setattr(db_steam_acc, arg, value)
        try:
            db.session.add(db_steam_acc)
        except (DBAPIError, SQLAlchemyError) as err:
            current_app.logger.info(err)
    db.session.commit()
    current_app.logger.info("Successful DB injection")
    return None

@celery.task(name="account.save_items")
def save_items(db_acc_json, items):
    """Пишем в БД перечень имеющихся предметов в инвентаре."""
    current_app.logger.info("write items")

    # Преобразуем полученный словарь обратно в модель sqlalchemy
    db_steam_acc = account_schema.load(db_acc_json)

    account_id = db_steam_acc.account_id
    db_inventory = Item.query.filter_by(account_id=account_id).all()

    # Сохраняем данные о предметах в инвентаре в БД
    for item in items:
        exists = Item.query.filter_by(asset_id=item).first() is not None
        current_app.logger.info(f'{item} exist {exists}')
        if not exists:
            db_item = Item(
                asset_id=int(item),
                class_id=int(items[item]['classid']),
                account_id=account_id,
            )
            db.session.add(db_item)

    current_app.logger.info("delete stale items")
    # Если в БД есть предмет, которого нет в инвентаре - удаляем
    for item in db_inventory:
        if str(item.asset_id) not in items:
            current_app.logger.info(f"delete {item.asset_id}")
            db.session.delete(item)
    db.session.commit()

@celery.task(name="account.save_descriptions")
def save_descriptions(descriptions):
    """Добавляем в БД описания предметов, которых там нет."""
    current_app.logger.info("write descriptions")

    tags = {}
    # Наличие описания в БД проверяется по уникальному ключу classid
    for class_id in descriptions:
        exists = Description.query.filter_by(
            class_id=int(descriptions[class_id][
                         'classid'])).first() is not None
        current_app.logger.info(f"{descriptions[class_id]['classid']} "
                                f"exist {exists}")
        if not exists:
            # Перечень тэгов для записи в БД
            categories = [
                "Редкость",
                "Игра",
                "Оформление карточки",
                "Тип предмета",
            ]

            classid = int(descriptions[class_id]["classid"])
            appid = int(descriptions[class_id]["appid"])
            icon_url_large = descriptions[class_id][
                "icon_url_large"]
            market_hash_name = descriptions[class_id][
                "market_hash_name"]
            market_name = descriptions[class_id][
                "market_name"]
            type_ = descriptions[class_id]["type"]
            value = descriptions[class_id]["descriptions"][0]["value"]

            # Собираем тэги в отдельный словарь для удобства
            tags[classid] = {}
            for category in categories:
                for tag in descriptions[class_id]['tags']:
                    if tag['category_name'] == category:
                        tags[classid][category] = tag['name']

            rarity = tags[classid]["Редкость"]
            game = tags[classid]["Игра"]
            item_type = tags[classid]["Тип предмета"]
            card_border = tags[classid]["Оформление карточки"] \
                if "Оформление карточки" in tags[classid].keys() else None

            db_description = Description(
                class_id=classid,
                app_id=appid,
                icon_url_large=icon_url_large,
                market_hash_name=market_hash_name,
                market_name=market_name,
                item_type=type_,
                value=value,
                rarity_tag=rarity,
                game_tag=game,
                item_type_tag=item_type,
                card_border_tag=card_border,
            )
            db.session.add(db_description)
    db.session.commit()


#! python3

import json

from snap7.client import Client
import snap7.util

from color import BLUE, RED, GREEN, YELLOW, YELLOW_BRIGHT

class PLCConnector:
    '''
    Connect and communicate with PLC
    '''
    def __init__(self, verbose=True, info=False, debug=False):
        # Verbosity
        self.verbose = verbose
        self.info = info
        self.debug = debug

        # Import credentials
        with open('credentials.json', 'r') as file:
            self.credentials = json.load(file)

        # PLC IP address from credentials
        ip = self.credentials['plc']['ip']['local']

        # Create client
        print('Connecting to PLC... ', end='')
        self.client = Client()
        self.client.connect(ip, 0, 2, 102)
        if self.client.get_connected():
            print(GREEN + 'Connected')

    def list_blocks(self):
        # List blocks
        print('List blocks... ')
        blockslist = self.client.list_blocks() # returns snap7.types.BlocksList
        print(blockslist)
        print(GREEN + 'Done')

    def read_db(self):
        print('Read from DB99... ')
        data = self.client.db_read(99, 5, 1)
        float = snap7.util.get_byte(data,0)
        print(float)
        print(GREEN + 'Done')

    def write_int_to_db(self, db, offset, value):
        '''
        Write INT to PLC DB

        Arguments
        ---------
        db      (int)   :  db number
        offset  (int)   :  byte offset (within db)
        value   (int)   :  value to write as INT
        '''
        # Progress print
        if self.verbose:
            print('Write to DB%i... ' % db)

        # Prepare data
        data = bytearray(2)
        snap7.util.set_int(data, 0, value)

        # Write data to PLC
        try:
            self.client.db_write(db, offset, data)
        except snap7.exceptions.Snap7Exception as ex:
            #print(ex)
            raise Exception(RED + 'Write to PLC Failed')

        # Progress print
        if self.verbose:
            print(GREEN + 'Done')

    def write_real_to_db(self, db, offset, value):
        '''
        Write REAL to PLC DB

        Arguments
        ---------
        db      (int)   :  db number
        offset  (int)   :  byte offset (within db)
        value   (float) :  value to write as REAL
        '''
        # Progress print
        if self.verbose:
            print('Write to DB%i... ' % db)

        # Prepare data
        data = bytearray(4)
        snap7.util.set_real(data, 0, value)

        # Write data to PLC
        try:
            self.client.db_write(db, offset, data)
        except snap7.exceptions.Snap7Exception as ex:
            #print(ex)
            raise Exception(RED + 'Write to PLC Failed')

        # Progress print
        if self.verbose:
            print(GREEN + 'Done')

    def write_db_layout(self):
        # DB layout test
        from plc_db_layouts import db99_layout
        db_number = 99
        db_data = self.client.db_get(db_number)
        db99 = snap7.util.DB(
            db_number,              # the db we use
            db_data,                # bytearray from the plc
            db99_layout,            # layout specification
            446,                    # size of the specification (last index + size of last var)
            1,                      # number of row's / specifications (how often the specification is repeated)
            layout_offset=0,        # sometimes specification does not start a 0
            db_offset=0             # At which point in db_data should we start parsing for data
        )
        print(db99)

            # id_field='RC_IF_NAME',  # field we can use to make row
        print(db99[0]['Optimizers'])
        db99[0]['Optimizers'] = 7

        print(db99.specification) # string
        print(db99[0]._specification) # resulting dict

        # Bytearray: db99._bytearray

        db99[0].write(self.client) # ! NEEDS TO BE DB-ROW, so must index object

    def write_data_db(db_number, db_data, start=0):
        area = snap7.types.S7AreaDB
        #self.client.write_area(area, db_number, 0, size, db_data)
        self.client.write_area(snap7.types.Areas.DB, db_number, start, db_data)

if __name__ == '__main__':
    plc = PLCConnector()
    plc.list_blocks()
    #plc.read_db()
    #plc.write_db() # gone for now

    # Write single value:
    #write_int_to_db()
    #write_real_to_db()

    # Write layout:
    #plc.write_db_layout()
    #plc.write_data_db(db_number, db99._bytearray)
    #plc.write_data_db()