· 5 years ago · Feb 27, 2020, 12:34 AM
1import os
2import re
3import sqlite3
4import sys
5import random
6
7
8class DbProvider:
9
10 def random_features(self, skintype):
11 features = ['face', 'l_ear', 'r_ear', 'l_eye', 'r_eye', 'l_eyebrow', 'r_eyebrow', 'nose', 'mouth', 'hair',
12 'suit']
13 for key in features:
14 if key == 'l_eye' or key == 'r_eye':
15 eyes = self.custom_select("SELECT Path FROM Eye e WHERE e.SkinType=LOWER('{}')".format(skintype))
16 print(eyes.__len__())
17 x = list(eyes.keys())
18 number = random.choice(x)
19 print(number)
20
21 def addEyes(self, size, color, skintype, legacy):
22 self.eye.insert_into_table(size, color, skintype, "left", "Files/Features/" + legacy + "/l_eye.png", legacy)
23 self.eye.insert_into_table(size, color, skintype, "right", "Files/Features/" + legacy + "/r_eye.png", legacy)
24 leftEye = \
25 self.custom_select("SELECT ID FROM Eye e WHERE e.Side=LOWER('left') AND e.Legacy='{}'".format(legacy))[
26 '0'].get(
27 'ID')
28 rightEye = \
29 self.custom_select("SELECT ID FROM Eye e WHERE e.Side=LOWER('right') AND e.Legacy='{}'".format(legacy))[
30 '0'].get('ID')
31 self.eyes.insert_into_table(skintype, leftEye, rightEye)
32
33 def addEars(self, size, skintype, legacy):
34 self.ear.insert_into_table(size, skintype, "left", "Files/Features/" + legacy + "/l_ear.png", legacy)
35 self.ear.insert_into_table(size, skintype, "right", "Files/Features/" + legacy + "/r_ear.png", legacy)
36 leftEar = \
37 self.custom_select(
38 "SELECT ID FROM Ear e WHERE e.Side=LOWER('left') AND e.Legacy='{}'".format(legacy))['0'].get('ID')
39 rightEar = \
40 self.custom_select(
41 "SELECT ID FROM Ear e WHERE e.Side=LOWER('right') AND e.Legacy='{}'".format(legacy))[
42 '0'].get('ID')
43 self.ears.insert_into_table(skintype, leftEar, rightEar)
44
45 def addEyeBrows(self, size, color, skintype, legacy):
46 self.eyeBrow.insert_into_table(size, color, skintype, "left", "Files/Features/" + legacy + "/l_eyebrow.png",
47 legacy)
48 self.eyeBrow.insert_into_table(size, color, skintype, "right", "Files/Features/" + legacy + "/r_eyebrow.png",
49 legacy)
50 leftEyeBrow = self.custom_select(
51 "SELECT ID FROM EyeBrow e WHERE e.Side=LOWER('left') AND e.Legacy='{}'".format(legacy))['0'].get(
52 'ID')
53 rightEyeBrow = self.custom_select(
54 "SELECT ID FROM EyeBrow e WHERE e.Side=LOWER('right') AND e.Legacy='{}'".format(legacy))['0'].get(
55 'ID')
56 self.eyeBrows.insert_into_table(skintype, leftEyeBrow, rightEyeBrow)
57
58 def addNose(self, size, skintype, legacy):
59 self.nose.insert_into_table(size, skintype, "Files/Features/" + legacy + "/nose.png")
60
61 def addMouth(self, size, skintype, legacy):
62 self.mouth.insert_into_table(size, skintype, "Files/Features/" + legacy + "/mouth.png")
63
64 def addHair(self, hairtype, colour, skintype, legacy):
65 self.hair.insert_into_table(hairtype, colour, skintype, "Files/Features/" + legacy + "/hair.png")
66
67 def addFace(self, skintype, size, legacy):
68 self.face.insert_into_table(skintype, size, "Files/Features/" + legacy + "/face.png")
69
70 def addAttributeAssignment(self, faceID, eyesID, eyebrowsID, noseID, mouthID, earsID, hairID):
71 self.AttributeAssignment.insert_into_table(faceID, eyesID, eyebrowsID, noseID, mouthID, earsID, hairID)
72 attribiteAssignmentID = self.custom_select("SELECT ID FROM AttributeAssignment ORDER BY ID DESC LIMIT 1;")[
73 '0'].get('ID')
74 return attribiteAssignmentID
75
76 def addAppearance(self, attributeAssignmentID, skintype, filePath):
77 self.appearance.insert_into_table(attributeAssignmentID, skintype, filePath)
78
79 def database_path(self, relative):
80 p = os.path.join(os.environ.get("_MEIPASS2", os.path.abspath(".")), relative)
81 print("XD", p)
82 return p
83
84 def get_data_from_table(self, table_name):
85 # Get headers of table
86 header_request = '''SELECT name FROM PRAGMA_TABLE_INFO('{}')'''.format(table_name)
87 self.cursor.execute(header_request)
88 headers = self.cursor.fetchall()
89
90 # Get rows of table
91 sql = '''SELECT * FROM {}'''.format(table_name)
92 self.cursor.execute(sql)
93 rows = self.cursor.fetchall()
94
95 # Create dict
96 dataset = {}
97 data = {}
98 j = 0
99 for row in rows:
100 i = 0
101 for item in row:
102 data[str(headers[i][0])] = str(item)
103 i += 1
104 dataset[str(j)] = data.copy()
105 j += 1
106 data.clear()
107 self.dataSet.clear()
108 self.dataSet = dataset
109 return dataset
110
111 def __init__(self):
112 self.path = self.database_path('DB\db.sqlite')
113 print(self.path)
114 self.dataSet = {}
115
116 if not os.path.isfile(self.path):
117 try:
118 os.mkdir(self.database_path("DB"))
119 except:
120 pass
121 # Create database if not exist and get a connection to it
122 self.connection = sqlite3.connect(self.path)
123 # Get a cursor to execute sql statements
124 self.cursor = self.connection.cursor()
125
126 # Create tables
127 self.custom_face = self.CustomFace(self)
128 self.face = self.Face(self)
129 self.eye = self.Eye(self)
130 self.eyes = self.Eyes(self)
131 self.ear = self.Ear(self)
132 self.ears = self.Ears(self)
133 self.eyeBrow = self.EyeBrow(self)
134 self.eyeBrows = self.EyeBrows(self)
135 self.nose = self.Nose(self)
136 self.mouth = self.Mouth(self)
137 self.hair = self.Hair(self)
138 self.AttributeAssignment = self.AttributeAssignment(self)
139 self.appearance = self.Appearance(self)
140
141 def get_dict(self, headers, rows): # Create dict
142 dataset = {}
143 data = {}
144 j = 0
145 for row in rows:
146 i = 0
147 for item in row:
148 data[str(headers[i])] = str(item)
149 i += 1
150 dataset[str(j)] = data.copy()
151 j += 1
152 data.clear()
153 self.dataSet.clear()
154 self.dataSet = dataset
155 return dataset
156
157 def custom_select(self, select_formula):
158 headers = []
159 x = re.split("(?i)FROM", select_formula)
160 headers = re.findall(r'(\w+)+', re.split("(?i)SELECT", x[0])[1], re.IGNORECASE)
161 if headers == []:
162 headers = re.findall(r'([*]+)', re.split("(?i)SELECT", x[0])[1], re.IGNORECASE)
163
164 table_name = re.findall(r'(\w+)+', x[1], re.IGNORECASE)[0]
165 # Get headers of table
166 if (headers[0] == '*'):
167 header_request = '''SELECT name FROM PRAGMA_TABLE_INFO('{}')'''.format(table_name)
168 self.cursor.execute(header_request)
169 headers = self.cursor.fetchall()
170 new_headers = []
171 for h in headers:
172 new_headers.append(h[0])
173 headers = new_headers
174 # Get rows of table
175 sql = select_formula
176 try:
177 self.cursor.execute(sql)
178 except:
179 pass
180 rows = self.cursor.fetchall()
181 return self.get_dict(headers, rows)
182
183 class Face:
184 def insert_into_table(self, skintype, size, path):
185 sql = '''INSERT INTO Face (SkinType, Size, Path) VALUES ('{}','{}','{}');'''.format(skintype, size, path)
186 self.cursor.execute(sql)
187 self.connection.commit()
188
189 def __init__(self, parent):
190 self.connection = parent.connection
191 self.cursor = parent.cursor
192 sql = '''CREATE TABLE IF NOT EXISTS Face
193 (ID INTEGER PRIMARY KEY AUTOINCREMENT,
194 SkinType VARCHAR(100),
195 Size VARCHAR(20),
196 Path VARCHAR(300)
197 )'''
198 self.cursor.execute(sql)
199 self.connection.commit()
200
201 class Eyes:
202 def insert_into_table(self, skintype, L_ID, R_ID):
203 sql = '''INSERT INTO Eyes (SkinType, L_ID, R_ID) VALUES ('{}',{},{});'''.format(skintype, L_ID, R_ID)
204 self.cursor.execute(sql)
205 self.connection.commit()
206
207 def __init__(self, parent):
208 self.connection = parent.connection
209 self.cursor = parent.cursor
210 sql = '''CREATE TABLE IF NOT EXISTS Eyes
211 (ID INTEGER PRIMARY KEY AUTOINCREMENT,
212 SkinType VARCHAR(100),
213 L_ID INT,
214 R_ID INT,
215 FOREIGN KEY(L_ID) references Eye(ID),
216 FOREIGN KEY(R_ID) references Eye(ID)
217 )'''
218 self.cursor.execute(sql)
219 self.connection.commit()
220
221 class Eye:
222 def insert_into_table(self, size, colour, skintype, side, path, legacy):
223 sql = '''INSERT INTO Eye (Size, Colour, SkinType, Side, Path, Legacy) VALUES ('{}', '{}' ,'{}','{}','{}','{}');'''.format(
224 size, colour, skintype, side, path, legacy)
225 self.cursor.execute(sql)
226 self.connection.commit()
227
228 def __init__(self, parent):
229 self.connection = parent.connection
230 self.cursor = parent.cursor
231 sql = '''CREATE TABLE IF NOT EXISTS Eye
232 (ID INTEGER PRIMARY KEY AUTOINCREMENT,
233 Size VARCHAR(100),
234 Colour VARCHAR(100),
235 SkinType VARCHAR(100),
236 Side VARCHAR(100),
237 Path VARCHAR(300),
238 Legacy VARCHAR(100)
239 )'''
240 self.cursor.execute(sql)
241 self.connection.commit()
242
243 class Nose:
244 def insert_into_table(self, size, skintype, path):
245 sql = '''INSERT INTO Nose (Size,SkinType,Path) VALUES ('{}','{}','{}');'''.format(size, skintype, path)
246 self.cursor.execute(sql)
247 self.connection.commit()
248
249 def __init__(self, parent):
250 self.connection = parent.connection
251 self.cursor = parent.cursor
252 sql = '''CREATE TABLE IF NOT EXISTS Nose
253 (ID INTEGER PRIMARY KEY AUTOINCREMENT,
254 Size VARCHAR(100),
255 SkinType VARCHAR(100),
256 Path VARCHAR(300)
257 )'''
258 self.cursor.execute(sql)
259 self.connection.commit()
260
261 class Mouth:
262 def insert_into_table(self, size, skintype, path):
263 sql = '''INSERT INTO Mouth (SkinType, Size, Path) VALUES ('{}','{}','{}');'''.format(size,
264 skintype,
265 path)
266 self.cursor.execute(sql)
267 self.connection.commit()
268
269 def __init__(self, parent):
270 self.connection = parent.connection
271 self.cursor = parent.cursor
272 sql = '''CREATE TABLE IF NOT EXISTS Mouth
273 (ID INTEGER PRIMARY KEY AUTOINCREMENT,
274 SkinType VARCHAR(100),
275 Size VARCHAR(100),
276 Path VARCHAR(300)
277 )'''
278 self.cursor.execute(sql)
279 self.connection.commit()
280
281 class Ears:
282 def insert_into_table(self, skintype, L_ID, R_ID):
283 sql = '''INSERT INTO Ears (SkinType, L_ID, R_ID) VALUES ('{}',{},{});'''.format(skintype, L_ID, R_ID)
284 self.cursor.execute(sql)
285 self.connection.commit()
286
287 def __init__(self, parent):
288 self.connection = parent.connection
289 self.cursor = parent.cursor
290 sql = '''CREATE TABLE IF NOT EXISTS Ears
291 (ID INTEGER PRIMARY KEY AUTOINCREMENT,
292 SkinType VARCHAR(100),
293 L_ID INT,
294 R_ID INT,
295 FOREIGN KEY(L_ID) references Eye(ID),
296 FOREIGN KEY(R_ID) references Eye(ID)
297 )'''
298 self.cursor.execute(sql)
299 self.connection.commit()
300
301 class Ear:
302 def insert_into_table(self, size, skintype, side, path, legacy):
303 sql = '''INSERT INTO Ear (Size, SkinType, Side, Path, Legacy) VALUES ('{}','{}','{}','{}','{}');'''.format(size,
304 skintype,
305 side,
306 path,
307 legacy)
308 self.cursor.execute(sql)
309 self.connection.commit()
310
311 def __init__(self, parent):
312 self.connection = parent.connection
313 self.cursor = parent.cursor
314 sql = '''CREATE TABLE IF NOT EXISTS Ear
315 (ID INTEGER PRIMARY KEY AUTOINCREMENT,
316 Size VARCHAR(100),
317 SkinType VARCHAR(100),
318 Side VARCHAR(100),
319 Path VARCHAR(300),
320 Legacy VARCHAR(100)
321 )'''
322 self.cursor.execute(sql)
323 self.connection.commit()
324
325 class EyeBrows:
326 def insert_into_table(self, skintype, L_ID, R_ID):
327 sql = '''INSERT INTO Ears (SkinType, L_ID, R_ID) VALUES ('{}',{},{});'''.format(skintype, L_ID, R_ID)
328 self.cursor.execute(sql)
329 self.connection.commit()
330
331 def __init__(self, parent):
332 self.connection = parent.connection
333 self.cursor = parent.cursor
334 sql = '''CREATE TABLE IF NOT EXISTS EyeBrows
335 (ID INTEGER PRIMARY KEY AUTOINCREMENT,
336 SkinType VARCHAR(100),
337 L_ID INT,
338 R_ID INT,
339 FOREIGN KEY(L_ID) references EyeBrow(ID),
340 FOREIGN KEY(R_ID) references EyeBrow(ID)
341 )'''
342 self.cursor.execute(sql)
343 self.connection.commit()
344
345 class EyeBrow:
346 def insert_into_table(self, size, colour, skintype, side, path, legacy):
347 sql = '''INSERT INTO EyeBrow (Size, Colour, SkinType, Side, Path, Legacy) VALUES ('{}','{}','{}','{}','{}','{}');'''.format(
348 size, colour, skintype,
349 side,
350 path, legacy)
351 self.cursor.execute(sql)
352 self.connection.commit()
353
354 def __init__(self, parent):
355 self.connection = parent.connection
356 self.cursor = parent.cursor
357 sql = '''CREATE TABLE IF NOT EXISTS EyeBrow
358 (ID INTEGER PRIMARY KEY AUTOINCREMENT,
359 Size VARCHAR(100),
360 Colour VARCHAR(100),
361 SkinType VARCHAR(100),
362 Side VARCHAR(100),
363 Path VARCHAR(300),
364 Legacy VARCHAR(100)
365 )'''
366 self.cursor.execute(sql)
367 self.connection.commit()
368
369 class Hair:
370 def insert_into_table(self, hairtype, colour, skintype, path):
371 sql = '''INSERT INTO Hair (HairType, Colour, SkinType, Path) VALUES ('{}','{}','{}','{}');'''.format(
372 hairtype, colour, skintype, path)
373 self.cursor.execute(sql)
374 self.connection.commit()
375
376 def __init__(self, parent):
377 self.connection = parent.connection
378 self.cursor = parent.cursor
379 sql = '''CREATE TABLE IF NOT EXISTS Hair
380 (ID INTEGER PRIMARY KEY AUTOINCREMENT,
381 HairType VARCHAR(100),
382 Colour VARCHAR(100),
383 SkinType VARCHAR(100),
384 Path VARCHAR(300)
385 )'''
386 self.cursor.execute(sql)
387 self.connection.commit()
388
389 class AttributeAssignment: # AttributeAssignment
390 def insert_into_table(self, faceID, eyesID, eyebrowsID, noseID, mouthID, earsID, hairID):
391 sql = '''INSERT INTO AttributeAssignment (FaceID, EyesID, NoseID, MouthID, EarsID, HairID)
392 VALUES ({},{},{},{},{},{});'''.format(faceID, eyesID, noseID, mouthID, earsID, hairID)
393 self.cursor.execute(sql)
394 self.connection.commit()
395
396 def __init__(self, parent):
397 self.connection = parent.connection
398 self.cursor = parent.cursor
399 sql = '''CREATE TABLE IF NOT EXISTS AttributeAssignment
400 (ID INTEGER PRIMARY KEY AUTOINCREMENT,
401 FaceID INTEGER,
402 EyesID INTEGER,
403 NoseID INTEGER,
404 MouthID INTEGER,
405 EarsID INTEGER,
406 HairID INTEGER,
407 FOREIGN KEY(FaceID) references Face(ID),
408 FOREIGN KEY(EyesID) references Eyes(ID),
409 FOREIGN KEY(NoseID) references Nose(ID),
410 FOREIGN KEY(MouthID) references Mouth(ID),
411 FOREIGN KEY(EarsID) references Ears(ID),
412 FOREIGN KEY(HairID) references Hair(ID)
413 )'''
414 self.cursor.execute(sql)
415 self.connection.commit()
416
417 class Appearance: # Appearance
418 def insert_into_table(self, assignmentID, skintype, filePath):
419 sql = '''INSERT INTO Appearance (AssignmentID, SkinType, Date, Path) VALUES ({},'{}',DATETIME('now','localtime'),'{}');'''.format(
420 assignmentID, skintype, filePath)
421 self.cursor.execute(sql)
422 self.connection.commit()
423
424 def __init__(self, parent):
425 self.connection = parent.connection
426 self.cursor = parent.cursor
427 sql = '''CREATE TABLE IF NOT EXISTS Appearance
428 (ID INTEGER PRIMARY KEY AUTOINCREMENT,
429 AssignmentID INTEGER,
430 SkinType VARCHAR(100),
431 Date VARCHAR(100),
432 Path varchar(300),
433 FOREIGN KEY(AssignmentID) references AttributeAssignment(ID)
434 )'''
435 self.cursor.execute(sql)
436 self.connection.commit()
437
438 class CustomFace:
439 def insert_into_table(self, name, genetic, path):
440 sql = '''INSERT INTO CustomFace (Name, Genetic, Path) VALUES ('{}', '{}','{}');'''.format(name, genetic,
441 path)
442 self.cursor.execute(sql)
443 self.connection.commit()
444
445 def __init__(self, parent):
446 self.connection = parent.connection
447 self.cursor = parent.cursor
448 sql = '''CREATE TABLE IF NOT EXISTS CustomFace
449 (ID INTEGER PRIMARY KEY AUTOINCREMENT,
450 Name varchar(100),
451 Genetic varchar(100),
452 Path varchar(100)
453 )'''
454 self.cursor.execute(sql)
455 self.connection.commit()
456
457
458if __name__ == "__main__":
459 db = DbProvider()
460 # first face
461 db.addEyes("small", "blue", "white", "InputFace-01")
462 db.addEars("small", "white", "InputFace-01")
463 db.addEyeBrows("small", "bright", "white", "InputFace-01")
464 db.addNose("small", "white", "InputFace-01")
465 db.addMouth("small", "white", "InputFace-01")
466 db.addHair("long", "bright", "white", "InputFace-01")
467 db.addFace("white", "small", "InputFace-01")
468 # second face
469 db.addEyes("small", "brown", "white", "InputFace-02")
470 db.addEars("small", "white", "InputFace-02")
471 db.addEyeBrows("small", "dark", "white", "InputFace-02")
472 db.addNose("small", "white", "InputFace-02")
473 db.addMouth("small", "white", "InputFace-02")
474 db.addHair("long", "dark", "white", "InputFace-02")
475 db.addFace("white", "small", "InputFace-02")
476 # third face
477 db.addEyes("small", "blue", "white", "InputFace-03")
478 db.addEars("small", "white", "InputFace-03")
479 db.addEyeBrows("small", "bright", "white", "InputFace-03")
480 db.addNose("small", "white", "InputFace-03")
481 db.addMouth("small", "white", "InputFace-03")
482 db.addHair("long", "bright", "white", "InputFace-03")
483 db.addFace("white", "small", "InputFace-03")
484 # 4th face
485 db.addEyes("small", "blue", "white", "InputFace-04")
486 db.addEars("small", "white", "InputFace-04")
487 db.addEyeBrows("small", "bright", "white", "InputFace-04")
488 db.addNose("small", "white", "InputFace-04")
489 db.addMouth("small", "white", "InputFace-04")
490 db.addHair("long", "bright", "white", "InputFace-04")
491 db.addFace("white", "small", "InputFace-04")
492 # 5th face
493 db.addEyes("small", "blue", "white", "InputFace-05")
494 db.addEars("small", "white", "InputFace-05")
495 db.addEyeBrows("small", "bright", "white", "InputFace-05")
496 db.addNose("small", "white", "InputFace-05")
497 db.addMouth("small", "white", "InputFace-05")
498 db.addHair("long", "bright", "white", "InputFace-05")
499 db.addFace("white", "small", "InputFace-05")
500 # 6th face
501 db.addEyes("medium", "brown", "white", "InputFace-06")
502 db.addEars("medium", "white", "InputFace-06")
503 db.addEyeBrows("medium", "dark", "white", "InputFace-06")
504 db.addNose("medium", "white", "InputFace-06")
505 db.addMouth("medium", "white", "InputFace-06")
506 db.addHair("short", "dark", "white", "InputFace-06")
507 db.addFace("white", "medium", "InputFace-06")
508 # 7th face
509 db.addEyes("medium", "brown", "white", "InputFace-07")
510 db.addEars("medium", "white", "InputFace-07")
511 db.addEyeBrows("medium", "dark", "white", "InputFace-07")
512 db.addNose("medium", "white", "InputFace-07")
513 db.addMouth("medium", "white", "InputFace-07")
514 db.addHair("short", "dark", "white", "InputFace-07")
515 db.addFace("white", "medium", "InputFace-07")
516 # 8th face
517 db.addEyes("medium", "blue", "white", "InputFace-08")
518 db.addEars("medium", "white", "InputFace-08")
519 db.addEyeBrows("medium", "bright", "white", "InputFace-08")
520 db.addNose("medium", "white", "InputFace-08")
521 db.addMouth("medium", "white", "InputFace-08")
522 db.addHair("short", "bright", "white", "InputFace-08")
523 db.addFace("white", "medium", "InputFace-08")
524 # 9th face
525 db.addEyes("medium", "blue", "white", "InputFace-09")
526 db.addEars("medium", "white", "InputFace-09")
527 db.addEyeBrows("medium", "bright", "white", "InputFace-09")
528 db.addNose("medium", "white", "InputFace-09")
529 db.addMouth("medium", "white", "InputFace-09")
530 db.addHair("short", "bright", "white", "InputFace-09")
531 db.addFace("white", "medium", "InputFace-09")
532 # 10th face
533 db.addEyes("medium", "blue", "white", "InputFace-10")
534 db.addEars("medium", "white", "InputFace-10")
535 db.addEyeBrows("medium", "dark", "white", "InputFace-10")
536 db.addNose("medium", "white", "InputFace-10")
537 db.addMouth("medium", "white", "InputFace-10")
538 db.addHair("short", "dark", "white", "InputFace-10")
539 db.addFace("white", "medium", "InputFace-10")
540
541 # # db.eye.insert_into_table("Big", "blue", "white", "left", "dupa")
542 # # db.get_data_from_table("CustomFace")
543 # # db.insert_into_table('Face', 'tempName')
544 # # db.get_data_from_table('Face')
545 # # db.eye.insert_into_table("small", "asd", "asd", "left", "dupa", "qwe")
546 # # db.eye.insert_into_table("small", "blue", "white", "left", "Files/Features/InputFace-00/l_eye.png", "InputFace-00")
547 # # db.eye.insert_into_table("small", "blue", "white", "right", "Files/Features/InputFace-00/r_eye.png", "InputFace-00")
548 # # lefyEye = db.custom_select("SELECT ID FROM Eye e WHERE e.Side=LOWER('left') AND e.Legacy=LOWER('InputFace-00')")[
549 # # '0'].get('ID')
550 # # rightEye = db.custom_select("SELECT ID FROM Eye e WHERE e.Side=LOWER('right') AND e.Legacy=LOWER('InputFace-00')")[
551 # # '0'].get('ID')
552 # # db.eyes.insert_into_table("white", lefyEye, rightEye)
553 #
554 # db.addEyes("small", "blue", "white", "InputFace-00")
555 # db.random_features("white")
556 # # db.addEars()