Untitled

# coding: utf-8
import pandas as pd
import numpy as np
import collections
import sys
import json, ast
from datetime import datetime, timedelta
sys.path.append('/apps/chickenboy-site/scripts/data_processing/db_connection')
from python_db import DbConnection

class Interpolation(object):


	

	def __init__(self, round_id):
		self.round_id = round_id
		#self.observable_name = observable_name
		self.cnx = DbConnection().connect_to_db()
		self.cursor = self.cnx.cursor()
		self.precision = {
			0: {'float': '{: 0.0f}'.format},
			1: {'float': '{: 0.1f}'.format}
		}
		self.replace_precision = {
			0: ' 0',
			1: ' 0.0'
		}

	# Make sure at least 50 days
	def interpolate_for_pc(self):
		start, end, targets = self.get_pc_details()
		dates = self.between_dates(start, end)
		try:
			targets = (json.loads(targets.decode('utf-8').replace('₂','2')))
		except:
			targets = (json.loads(str(targets).replace('₂','2')))
		curves = []
		for i in range(2, len(targets)):
			curves.append({
				"day": int(targets[i][1]['value']),
				"temperature": targets[i][2]['value'],
				"humidity": targets[i][3]['value'],
				"co2": targets[i][4]['value'],
				"sound_level": targets[i][5]['value'],
				"free_space": targets[i][6]['value'],
				"airspeed": targets[i][7]['value'],
				"ammonia": targets[i][8]['value'],
				"light_intensity": targets[i][9]['value'],
				"weight": targets[i][10]['value'],
			})
		days = len(dates)
		cols = 10
		
		df = pd.DataFrame(curves).sort_values(by=['day'])
		df = df[df['day'] <= days]
		# remember to sort by day cause user can set it in any order
		df.set_index('day',inplace=True)
		data = np.full([days, cols], np.nan)
		target = pd.DataFrame(data, columns=['day', 'temperature', 'humidity', 'co2', 'sound_level', 'free_space', 'airspeed', 'ammonia', 'light_intensity', 'weight'])
		target['day'] = np.arange(days)
		target.set_index('day',inplace=True)
		res = np.nonzero(df.index.isin(target.index) == True)[0]
		df = df.iloc[res, :]
		target.loc[df.index] = df
		for col in target:
			target[col] = pd.to_numeric(target[col], errors='coerce')
		interpolate_target = target.interpolate()
		interpolate_target['time'] = dates
		jsons = interpolate_target.to_json(orient="index")
		return jsons

	def interpolate_for_graphs(self, observable, data, dates):
		parse_dates = json.loads(dates)
		parse_data = json.loads(data)
		target = self.interpolate_for_pc()
		target = pd.read_json(target, orient="index")
		#formatted_dates = [(datetime.strptime(date.split()[0], "%Y-%m-%d").date()) for date in parse_dates]
		formatted_dates = [date.split()[0] for date in parse_dates]
		sub_target = [float(target[target['time'] == date].iloc[0][observable]) for date in formatted_dates]
		precision = self.get_observable_precision(observable)
		np.set_printoptions(threshold = sys.maxsize, precision=2, formatter=self.precision[precision])
		diff = np.subtract((sub_target), (parse_data))
		return sub_target, np.array2string(diff, separator=', ', max_line_width=100000).replace('\n', '').replace('\'', '"')

	def get_curves(self):
		query = "Select targets from round where id ='{}'".format(self.round_id)
		self.cursor.execute(query)
		targets = self.cursor.fetchone()
		return targets

	def get_pc_details(self):
		query = "Select `from`, `to`, targets from round where id ='{}'".format(self.round_id)
		self.cursor.execute(query)
		round = self.cursor.fetchone()
		return round

	def between_dates(self, start, end):
		#start_date = datetime.strptime(start, "%Y-%m-%d").date()
		#end_date = datetime.strptime(end, "%Y-%m-%d").date()
		days = []
		diff = end - start
		for i in range(diff.days + 1):
			day = start + timedelta(days=i)
			days.append(str(day))
		return days

	def get_observable_precision(self, observable):
		query = "SELECT observable_precision FROM observable WHERE code_name ='{}'".format(observable)
		self.cursor.execute(query)
		precision = self.cursor.fetchone()
		return precision[0]

if __name__ == '__main__':
	interpolate = Interpolation(sys.argv[1])
	arg_names = ['file_name', 'round_id', 'observable', 'data', 'dates']
	args = dict(zip(arg_names, sys.argv))
	Arg_list = collections.namedtuple('Arg_list', arg_names)
	args = Arg_list(*(args.get(arg, None) for arg in arg_names))
	if(args.observable == None):
		print(interpolate.interpolate_for_pc())
	else:
		try:
			target, diff = (interpolate.interpolate_for_graphs(args.observable, args.data, args.dates))
			print(target)
			print(diff)
		except:
			print()
			print()