def insert_email(self, email, corres_id):
"""
Inserts email and it's corresponding person id into the table
"""
with get_connection() as connection:
with connection:
with connection.cursor() as cursor:
cursor.execute(INSERT_EMAIL, (email, corres_id))
def create_tables(self):
"""
Creates the table (copy safe)
"""
with get_connection() as connection:
with connection:
with connection.cursor() as cursor:
cursor.execute(CREATE_TABLE)
cursor.execute(CREATE_TABLE_EMAIL)
def build_data(http_client, article_name, relationships):
# create a new article and get its id and etag
new_article_id = parse_response_body(articles.post_article(http_client, article_name, []))
line = 1
for primary, related, score, relationship in relationships:
try:
print "{0}/{1} Processing primary: {2}".format(line, len(relationships), primary)
line += 1
except UnicodeEncodeError:
pass
try:
# create noun usages and their ids for the primary
existing_primary_noun = noun_usages.get_noun_usages(http_client, primary)
if not existing_primary_noun:
add_noun_usage_response = parse_response_body(
noun_usages.post_noun_usage(http_client, primary, new_article_id))
# create noun usages and their ids for the related
existing_related_noun = noun_usages.get_noun_usages(http_client, primary)
if not existing_related_noun:
add_noun_usage_response = parse_response_body(
noun_usages.post_noun_usage(http_client, related, new_article_id))
# create node for the primary
existing_primary_id = nodes.get_nodes(http_client, primary)
if not existing_primary_id:
add_primary_node_id = parse_response_body(
nodes.post_nodes(http_client, primary, True))
else:
add_primary_node_id = existing_primary_id
# create node for the related
existing_secondary_id = nodes.get_nodes(http_client, related)
if not existing_secondary_id:
add_related_node_id = parse_response_body(
nodes.post_nodes(http_client, related, True))
else:
add_related_node_id = existing_secondary_id
# create connections
existing_connection_id = connections.get_connection(http_client, add_primary_node_id, add_related_node_id)
if not existing_connection_id:
add_connections_id = parse_response_body(
connections.post_connections(http_client, add_primary_node_id, add_related_node_id, relationship))
else:
add_connections_id = existing_connection_id
add_transaction_id = parse_response_body(
transactions.post_transactions(http_client, add_connections_id, score, 'nltk'))
except Exception as e:
print "There was an error"
continue
def main():
arguments = _parse_arguments()
logging.basicConfig(level=arguments.verbose)
# Connection
if arguments.serial:
connection = connections.get_connection(
connections.CONNECTION_TYPE_SERIAL, arguments.serial)
else:
connection = connections.get_connection(
connections.CONNECTION_TYPE_USB)
# Performing the requested action
action = arguments.action
if action == ACTION_GET:
download_track(connection, arguments.dest)
elif action == ACTION_PURGE:
purge(connection)
def menu():
with get_connection() as connection:
database.create_tables(connection)
selection = input(MENU_PROMPT)
while selection != "6":
try:
MENU_OPTIONS[selection]()
except KeyError:
print("Invalid input selected. Please try again.")
selection = input(MENU_PROMPT)
def check_phone_duplicate():
phone = request.args.get('phone', None)
try:
cursor, conn = get_connection()
select_query = "SELECT user_name FROM user WHERE phone_number='{}'".format(phone)
cursor.execute(select_query)
rows = cursor.fetchall()
if rows:
return json.dumps({'status': 'EXISTING'})
except Exception as e:
return json.dumps({'status': str(traceback.format_exc())})
return json.dumps({'status': 'OK'})
def check_uname_duplicate():
user_name = request.args.get('user_name', None)
try:
cursor, conn = get_connection()
select_query = "SELECT user_name FROM user WHERE user_name='{}'".format(user_name)
cursor.execute(select_query)
rows = cursor.fetchall()
if rows:
return json.dumps({'status': 'EXISTING'})
except Exception as e:
return json.dumps({'status': 'ERROR'})
return json.dumps({'status': 'OK'})
def signup():
account_types_dict = {}
select_query = "SELECT * FROM account_types"
try:
cursor, conn = get_connection()
cursour_result = cursor.execute(select_query)
if cursour_result:
rows = cursor.fetchall()
account_types_dict = {id: name for (id, name) in rows}
except Exception as e:
pass
return render_template('auth/signup.html', account_type_dict=account_types_dict)
def select_all(self, person_id):
"""
Selects all data based off the passed person id
Returns: A list of one tuple containing the attributes of the person_id passed
"""
rows = []
with get_connection() as connection:
with connection:
with connection.cursor() as cursor:
cursor.execute(SELECT_INFO, (person_id, ))
rows = cursor.fetchall()
return rows
def check_email_duplicate():
email_id = request.args.get('email', None)
try:
cursor, conn = get_connection()
select_query = "SELECT user_name FROM user WHERE email='{}'".format(email_id)
cursor.execute(select_query)
rows = cursor.fetchall()
if rows:
return json.dumps({'status': 'EXISTING'})
except Exception as e:
print(traceback.format_exc())
return json.dumps({'status': 'ERROR'})
return json.dumps({'status': 'OK'})
def test():
import connections
dev = GT200Dev(connections.get_connection())
dev.identify()
n = dev.count()
# for track in dev.all_tracks():
# print track
for rec in dev.all_records():
print("- ", rec.idx, "/", n, ":", rec)
dev.close()
def load_data(target_name, target_type):
connection = con.get_connection('image_profile')
control_table = 'flickr_' + target_type
control = X_data(connection, control_table)
control_x, X_test, control_y, y_test = train_test_split(
control.df.x.values,
np.zeros(len(control.df.x.values)),
test_size=0.05,
random_state=42,
shuffle=True)
connection.close()
table_name = target_name + '_' + target_type
connection = con.get_connection('image_profile')
target = X_data(connection, table_name)
connection.close()
target.df.loc[target.df['label'] == target_name, 'y'] = 1
X_target = target.df.x.values
y_target = target.df.y.values
X_control = control_x
y_control = control_y
# Each time this function is run, the data conforms closer to the target contrast distribution, at the cost of samples.
for i in range(2):
X_target, y_target, X_control, y_control = fit_training_data(
X_target, y_target, X_control, y_control, target_type)
print('fit_training_data() loop {}'.format((i + 1)))
print('X_target len', len(X_target))
print('X_control len', len(X_control))
X = np.concatenate((X_control, X_target), axis=0)
y = np.concatenate((y_control, y_target), axis=0)
return X, y
def send_message():
form_data = dict()
form_data['email'] = request.form.get('email', None)
form_data['message'] = request.form.get('msg', None)
try:
cursor, conn = get_connection()
insert_query = "INSERT INTO messages (email, message) VALUES (%s,%s)"
args = (form_data['email'], form_data['message'],)
cursor.execute(insert_query, args)
conn.commit()
except Exception as e:
return json.dumps({"status": "ERROR"})
else:
return json.dumps({"status": "OK"})
return json.dumps({'status': 'OK'})
def insert_all(self):
"""
Inserts data for each attribute, must have all data populated. Returns the id of the user for future use
"""
with get_connection() as connection:
with connection:
with connection.cursor() as cursor:
cursor.execute(
INSERT_INFO,
(self.first_name, self.last_name, self.income,
self.debt_total, self.rent, self.prop_tax,
self.phone_number, self.power, self.water,
self.garbage, self.cable, self.prescriptions,
self.doctor_visits, self.carpayment1,
self.carpayment2, self.autoinsurance, self.gasoline,
self.groceries, self.pchi))
return cursor.fetchone()[0]
def _login_attempt_():
if request.method == "POST":
name = request.form['email']
password = request.form['password']
print(name)
connection = con.get_connection('image_profile')
if con.check_credentials(name, password, request.remote_addr,
connection) == True:
session['cred'] = '{0} last authenticated at {1}'.format(
name, time.time())
connection.close()
return render_template('home.html')
connection.close()
return render_template('home.html')
def user_signup():
form_data = dict()
form_data['account_type'] = int(request.form.get('account_type', None))
form_data['fname'] = request.form.get('fname', None)
form_data['sname'] = request.form.get('sname', None)
form_data['uname'] = request.form.get('uname', None)
form_data['gender'] = request.form.get('gender', None)
form_data['dob'] = request.form.get('dob', None)
form_data['email'] = request.form.get('email', None)
form_data['phone'] = request.form.get('phone', None)
form_data['street_apt'] = request.form.get('street_apt', None)
form_data['district'] = request.form.get('district', None)
form_data['city'] = request.form.get('city', None)
form_data['state'] = request.form.get('state', None)
form_data['pin'] = request.form.get('pin', None)
form_data['password'] = request.form.get('password', None)
try:
cursor, conn = get_connection()
insert_query = "INSERT INTO user (account_type_id, fname, sname, user_name, gender, dob, email, phone_number, house_apt, district, city, state, pin, password) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)"
print(form_data)
args = (form_data['account_type'], form_data['fname'], form_data['sname'],
form_data['uname'], form_data['gender'], form_data['dob'],
form_data['email'], form_data['phone'], form_data['street_apt'],
form_data['district'], form_data['city'], form_data['state'],
form_data['pin'], form_data['password'])
cursor.execute(insert_query, args)
conn.commit()
except Exception as e:
return json.dumps({"status": "ERROR"})
else:
session['user_name'] = form_data['uname']
session['points'] = 100
to_address = form_data['email']
message = "Welcome {} {} thanks for signing up on Shadow Fashion. " \
"100 points have been credited your account !".format(form_data['fname'].title(),
form_data['sname'].title())
Mailer(to_address=to_address, message=message)
return json.dumps({"status": "OK"})
def signin():
user_name_or_email = request.form.get('uname_or_email', None)
password = request.form.get('account_password', None)
select_query = "SELECT id, user_name, reward_point FROM user WHERE user_name=%s AND password=%s"
if user_name_or_email.endswith(".com"):
select_query = "SELECT id, user_name, reward_point FROM user WHERE email=%s AND password=%s"
args = (user_name_or_email, password)
try:
cursor, conn = get_connection()
cursor.execute(select_query, args)
rows = cursor.fetchall()
if rows:
((id, user_name, reward_point),) = rows
session['user_name'] = user_name
session['id'] = id
session['points'] = reward_point
return json.dumps({'status': 'OK'})
else:
return json.dumps({'status': 'NU'})
except Exception as e:
print(e)
return json.dumps({'status': 'OK'})
def json_loads(a):
return json.loads(a)
class X_data:
''' This object will contain the models active from the database
active_dfs = Active_dfs()
# Creates: Active_dfs().df_dict[pair] for each active pair
'''
def __init__(self, id, connection, table):
''' This is run whenever the object is first created
'''
self.df = con.get_id_strips(id, connection, table)
self.df['x'] = self.all_models.df(lambda row: json_loads(row['x']),
axis=1)
self.df['tags'] = self.df.apply(lambda row: json_loads(row['tags']),
axis=1)
print('Loaded json models')
id = filename.split('.')[0]
connection = con.get_connection('image_profile')
X = X_data(id, connection, 'imgur_convolution')
connection.close()
# In[42]:
X.df
def save(self):
with get_connection() as connection:
new_option_id = database.add_option(connection, self.text, self.poll_id)
self.id = new_option_id
def get(cls, option_id: int) -> "Option":
with get_connection() as connection:
option = database.get_option(connection, option_id)
return cls(option[1], option[2], option[0])
def vote(self, username: str):
with get_connection() as connection:
current_datetime_utc = datetime.datetime.now(tz=pytz.utc)
current_timestamp = current_datetime_utc.timestamp()
database.add_poll_vote(connection, username, current_timestamp, self.id)
def all(cls) -> List["Poll"]:
with get_connection() as connection:
polls = database.get_polls(connection)
return [cls(poll[1], poll[2], poll[0]) for poll in polls]
def latest(cls) -> "Poll":
with get_connection() as connection:
poll = database.get_latest_poll(connection)
return cls(poll[1], poll[2], poll[0])
def options(self) -> List[Option]:
with get_connection() as connection:
options = database.get_poll_options(connection, self.id)
return [
Option(option[1], option[2], option[0]) for option in options
]
def get(
cls, poll_id: int
) -> "Poll": # Evaluate the return type after the class is finished processing
with get_connection() as connection:
poll = database.get_poll(connection, poll_id)
return cls(poll[1], poll[2], poll[0])
def save(self):
with get_connection() as connection:
new_poll_id = database.create_poll(connection, self.title,
self.owner)
self.id = new_poll_id
def votes(self) -> List[database.Vote]:
with get_connection() as connection:
votes = database.get_votes_for_option(connection, self.id)
return votes
def create_tables(self):
with get_connection() as connection:
with connection:
with connection.cursor() as cursor:
cursor.execute(CREATE_TABLE)
def convolution_strips(self,operation_dict):
'''
Split each section into the image into a 1d array and insert as training data
operation options = {
'operation':['insert_table','classify_image']
'img':None
'table':[None,'imgur_convolution','unsplash_convolution']
'filters': ['grayscale']
'size': [any number between 2 and 253]
}
'''
if operation_dict['operation']=='classify_image':
self.img = operation_dict['img']
self.width = len(self.img[0])
self.height = len(self.img)
if (self.width / self.height) > 1:
self.orientation = 'landscape'
if (self.width / self.height) < 1:
self.orientation = 'portrait'
if (self.width / self.height) == 1:
self.orientation = 'square'
self.shrink(self.side_min_size)
# Redefine size after shrinking image
self.width = len(self.img[0])
self.height = len(self.img)
self.w_loops = self.width // operation_dict['size']
self.h_loops = self.height // operation_dict['size']
self.h_ranges=[]
# Create an array of searchable convolution squares, defined by search 'size'
for j in range(0,((self.h_loops*operation_dict['size'])+1),operation_dict['size']):
self.h_ranges.append(j)
#self.h_ranges.append(self.height)
self.w_ranges=[]
for i in range(0,((self.w_loops*operation_dict['size'])+1),operation_dict['size']):
self.w_ranges.append(i)
#self.w_ranges.append(self.width)
for filter in operation_dict['filters']:
self.img = filters.runfilter(self.img,filter)
if operation_dict['operation']=='insert_table':
strat_connection = con.get_connection('image_profile')
table = operation_dict['table']
x=[]
for i in range(len(self.h_ranges)):
for j in range(len(self.w_ranges)):
# We only want to create records for standardized square shapes. Reject other shapes
if (i < len(self.h_ranges)-1) and (j < len(self.w_ranges)-1):
arr1d = np.array([self.img[k][l] for l in range(self.w_ranges[j],self.w_ranges[j+1]) for k in range(self.h_ranges[i],self.h_ranges[i+1])]).ravel() # make an even
if operation_dict['operation']=='classify_image':
x.append(arr1d)
if operation_dict['operation']=='insert_table':
result = con.insert_strip(arr1d,self.metadata,self.orientation,strat_connection,table)
if operation_dict['operation']=='classify_image':
try:
self.x = np.array(x)
self.x = self.x.reshape(len(self.x),len(self.x[0]))
# Recast in case of pixel errors
except Exception as ValueError:
arr = np.zeros(len(x),dtype=object)
for i in range(len(x)):
x[i] = np.array(x[i].tolist())
arr[i]=x[i].astype(int)
arr = np.array(arr)
x = arr.reshape(len(arr),len(arr[0]))
if operation_dict['operation']=='insert_table':
strat_connection.close()
return self
def insert_contact_info(self):
with get_connection() as connection:
with connection:
with connection.cursor() as cursor:
cursor.execute(INSERT_INFO,
(self.email, self.subject, self.message))
