def createClasses(self):
avgv = [13.0,2.34,2.37,19.5,99.74,2.23,2.03,0.36,1.59,5.06,0.96,2.61,746.89]
with open("wine.csv", "r") as f:
reader = csv.reader(f)
for row in reader:
colCount = 0
feats = []
classNum = 0
for col in row:
if colCount == 0:
classNum = int(col)
colCount += 1
continue
if float(col) > avgv[colCount-1]:
feats.append(1)
else:
feats.append(0)
colCount += 1
if classNum == 1:
self.class1.append(Class(feats))
elif classNum == 2:
self.class2.append(Class(feats))
elif classNum == 3:
self.class3.append(Class(feats))
print(len(self.class1))
print(len(self.class2))
print(len(self.class3))
def addClass():
"""
Method add class takes user inputs and adds a class to the ongoing list of classes, sorted
"""
print(
"\nEnter classes by day. For example enter all your Monday classes first, then Tuesday, etc."
)
print(
"When asked to put in class meeting times enter in 24 hr format. Example: 1:00 p.m = 1300 8:00 a.m = 0800"
)
day = input("Day of Class: ")
while not properDayInput(
day
): #While format is not correct, persist on getting the correct entry
print("Please enter a day of the week")
day = input("Day of Class: ")
className = input("Name of Class: ").strip()
if className == "": #If user does not put in a field (or just a bunch of spaces)
className = "EMPTY ENTRY!"
startTime = input("Starting Time: ")
while not properTimeInput(startTime):
startTime = input("StartingTime: ")
endTime = input("Ending Time: ")
while not properTimeInput(endTime):
endTime = input("Ending Time: ")
class_ = Class(className, Day(day), startTime,
endTime) #Creating class object from user's entries
for i in range(0, len(classes),
1): #Checking for overlaping/duplicate classes
classInList = classes[i]
if (class_ == classInList):
print("\nThere is a scheduling conflict with class: " +
str(classInList) + " and " + str(class_))
print(
"The class you just entered was not added to schedule. Please try another entry or edit an existing class\n"
)
return #Break out of function
classes.append(Class(className.upper(), Day(day), startTime, endTime))
print("\nClass added to schedule")
classes.sort()
delay()
clearTerminal()
def load_class_list():
"""
Method load_class_list reads class information from a csv file and adds classes to the
classes list and the classStringList
"""
try:
firstLine = True #keeping track of the first line in the csv file (the header)
index = 0
if os.access("mySchedule.csv", os.F_OK): #If the file exists
f = open("mySchedule.csv")
for row in csv.reader(f):
if firstLine:
firstLine = False
continue #skip first line
classStringList.insert(
index,
row) #load file to classString list and to classes list
classes.insert(
index,
Class(row[1], Day(row[0]), formatFromCSV(row[2]),
formatFromCSV(row[3])))
index += 1
f.close()
except Exception as e:
print("Exception found:" + e)
def cb_fill(self, number): """callback for fill the db""" from User import User from Class import Class import Event for i in range(number): campus = Campus() campus.name = "Campus"+str(i) Event.fill_date = date(date.today().year + i, 1, 1) campus.planning = Planning() campus.planning.cb_fill(number * 10) db.session.add(campus) user = User() user.campus = [campus] user.cb_fill(randint(1, number), campus.name + '_manager') user = User() user.teacher_campus = [campus] user.cb_fill(randint(1, number), campus.name + '_teacher') classe = Class() classe.campus = campus classe.cb_fill(number)
def find_public_methods():
"""
retrieves all public methods of class
"""
try:
fname=lisp.buffer_file_name()
print "remember:" + lisp.buffer_name()
os.environ['BUFFER'] = lisp.buffer_name()
project = Project(fname)
thing, start = thing_at_point(RIGHT3, LEFT3)
thing = thing.replace(".","")
print "thing:"+thing
pos = lisp.point()
type, foundpos = project.find_declaration_type(thing, fname, pos)
typefile = project.find_file_for_thing(type, fname)
c = Class(project, typefile)
public_methods = c.list_all_public()
if (len(public_methods) == 0):
lisp.message("No public methods found")
else:
ready_output()
lisp.insert("\n")
for item in public_methods:
lisp.insert(item)
lisp.insert("\n")
except Exception, e:
lisp.message(e)
def main():
args = parse_args()
class_data = Class(args)
class_data.read_config()
class_data.read_template()
class_data.replace_all()
class_data.create_class_files()
def main():
args = parse_args()
class_data = Class(args)
class_data.read_template()
class_data.replace_all()
add_snippet_data(class_data, args.snippet_name)
create_snippet_file(class_data, args.snippet_dir, args.snippet_name)
def _create_enum_class(self, text):
body, header, text = find_body(text)
cls = Class()
cls.type = 'enum'
cls.parse(header)
if not self.is_side(cls.side):
return text
cls.parse_body(Parser(self.side), body)
self.classes.append(cls)
return text
def cb_tree_plug(self, tree, iter, id): """plug object's childs in the tree""" from Class import Class from User import User from TreeMgmt import TreeRowMgmtSeparator for iclass in self.classes: tree.plug(iter, iclass, self) tree.plug_action(iter, Class(), self, Class.ADD_ACTION) tree.plug_group(iter, User(), self, User.CAMPUS_TEACHERS_GROUP) tree.plug_group(iter, User(), self, User.CAMPUS_MANAGERS_GROUP)
def getClasses(self):
sql = 'select * from class'
self.cursor.execute(sql)
liste = []
try:
obj = self.cursor.fetchall()
# print(obj)
for i in obj:
liste.append(Class(i[0], i[1], i[2]))
return liste
except mysql.connector.Error as err:
print('Error: ', err)
def get_classes(dir):
# Find all C# files in directory (including subdirectories)
file_list = Path(dir).glob('**/*.cs')
classes = dict()
for file_path in file_list:
class_name = file_path.parts[len(file_path.parts) - 1]
temp_class = Class(class_name)
get_class_details(str(file_path), temp_class)
classes[class_name] = temp_class
return classes
def create_visitor_class(self, cls):
visitor_name = self.get_type_of_visitor(cls)
visitor = self.find_class(visitor_name)
if visitor is None:
visitor = Class()
visitor.name = visitor_name
visitor.group = cls.group
visitor.type = "class"
visitor.is_abstract = True
visitor.is_visitor = True
visitor.side = cls.side
self.classes.append(visitor)
def class_decl(self, args):
id = args[0].children[0]
extends = args[1]
fields = args[3]
cls = Class(id, extends)
variables = fields['variables']
functions = fields['functions']
for var in variables:
cls.addVariable(var['id'], var['type'])
for f in functions:
cls.addMethod(f['name'], f['type'])
self.structure.append({'type': 'class', 'name': id})
def main():
args = config()
class_path = args.classes_path # classes_path
train_path = args.train_path # train_path
test_path = args.test_path # test_path
n_gram = args.n_gram # ngram
data = Data(train_path, hash=True, n_gram=n_gram)
classes = Class(class_path)
model = Fasttext_trainer(data,
classes,
dimension=300,
learning_rate=0.05,
epoches=10)
test_model(model, test_path, data.gram2index, classes)
def _create_class(self, text):
body, header, text = find_body(text)
cls = Class()
cls.parse(header)
if not self.is_side(cls.side):
if cls.is_storage:
self.classes_for_data.append(cls)
return text
cls.parse_body(Parser(self.side), body)
if self.find_class(cls.name):
Error.exit(Error.DUBLICATE_CLASS, cls.name)
self.classes.append(cls)
return text
def __init__(self):
"Initialize grammars for antlr4"
self.uniclass = Class()
self.labelled = {label: [] for label in Class.label}
that = None
codepoint, top = 0x0, 0x110000
for codepoint in xrange(top):
this = Class.classify(codepoint)
if that != this:
if that is not None:
self.labelled[that][-1].append(codepoint)
self.labelled[this].append([codepoint])
that = this
that = Class.classify(top - 1)
self.labelled[that][-1].append(codepoint)
with open("local/PropertyValueAliases.txt") as source:
find = 'gc ; '
self.prop = {'__': 'Error'}
for line in source.readlines():
if line.startswith(find):
part = line.split(';')
self.prop[part[1].strip()] = part[2].strip()
self.identify = [0] * top
with open("local/Blocks.txt") as source:
pattern = re.compile(r"([0-9A-F]{4,6})\.\.([0-9A-F]{4,6}); (.*)")
self.block = {}
for line in source:
found = pattern.match(line)
if found:
self.block[found.group(3).replace(' ', '_')] = [
found.group(i) for i in [1, 2]
]
self.noblock = '(Absent from Blocks.txt)'
self.blockname = [self.noblock] + sorted(self.block.keys())
for i, name in enumerate(self.blockname):
self.blockname[i] = name
for i, name in enumerate(self.blockname):
if isinstance(name, str) and name is not self.noblock:
endpoint = self.block[name]
A, B = (int(s, 0x10) for s in endpoint)
for codepoint in xrange(A, B):
self.identify[codepoint] = i
def __readData(self):
data = []
try:
with open("balance-scale.data", 'r') as f:
lines = f.readlines()
for line in lines:
if line != "":
words = line.strip().split(",")
r = words[0].strip()
lw = int(words[1].strip())
ld = int(words[2].strip())
rw = int(words[3].strip())
rd = int(words[4].strip())
c = Class(r, lw, ld, rw, rd)
data.append(c)
except FileNotFoundError:
print("Inexistent file : " + self.__filename)
return data
def initClasses(numberOfClasses,
numberOfFeatures,
featureMeanRange,
randomNumberSeed=None):
featureMeansOfEachClass = initializeFeatureMeans(
numberOfClasses,
numberOfFeatures,
featureMeanRange,
randomNumberSeed=randomNumberSeed)
featureCovsOfEachClass = initializeFeatureCov(
numberOfClasses, numberOfFeatures, randomNumberSeed=randomNumberSeed)
featureDistributionData = np.empty((numberOfClasses, ), dtype=Class)
for i in range(numberOfClasses):
featureDistributionData[i] = Class(featureMeansOfEachClass[i],
featureCovsOfEachClass[i])
return featureDistributionData
def getClass(self, classID):
classes = self._controller.getClass(classID)
#print("classes = ",classes)
cList = []
for course in classes:
c = Class(course[cDict['id']])
c.setName(course[cDict['name']])
c.setSem(course[cDict['sem']])
try:
for s in course[cDict['survey']]:
c.addSurvey(s)
except:
pass
cList.append(c)
if (classID == None):
return cList
else:
try:
return cList[0]
except:
return []
#with open('banner_course_schedule.py') as f:
with open('html_classes_content2.txt') as f:
for line in f:
results1 = pattern1.match(line)
results2 = pattern2.match(line)
if results1 != None:
if current_class != None:
class_list.add_class(current_class)
current_crn = results1.group('crn')
current_dept = results1.group('dept')
current_course_number = results1.group('course_number')
current_section = results1.group('section')
current_class = Class(current_crn, current_dept,
current_course_number, current_section)
elif results2 != None:
new_session = Session(results2.group('days'),
results2.group('start_time'),
results2.group('end_time'),
results2.group('start_date'),
results2.group('end_date'))
current_class.add_session(new_session)
# Don't forget to add the last class
class_list.add_class(current_class)
class_list.remove_no_sessions()
class_list.remove_specialized()
class_list.remove_a_session()
def search(term, year, subjectID, courseNum, daysOfTheWeek, earliestTime, latestTime, breakStart, breakEnd, gened):
# earliestTime = timeConvert(earliestTime)
# latestTime = timeConvert(latestTime)
# breakStart = timeConvert(breakStart)
# breakEnd = timeConvert(breakEnd)
responseYear = None
term_dic = {'spring': 1, 'summer': 5, 'fall': 8, 'winter': 0}
responseSubject = None
responseClass = None
courseList = []
classList = []
response = requests.get("https://courses.illinois.edu/cisapp/explorer/schedule.xml")
root = fromstring(response.content)
List = root.findall('./calendarYears/calendarYear')
# search for the year in all the years
for element in List:
if element.get('id') == year:
responseYear = requests.get(element.attrib['href'])
break
if responseYear == None:
raise KeyError('The year of search doesn\'t exist')
rootYear = fromstring(responseYear.content)
termList = rootYear.findall('./terms/term')
# search for the term in that year
for element in termList:
if element.attrib['id'].endswith(str(term_dic[term])):
responseSubject = requests.get(element.attrib['href'])
break
if responseSubject == None:
raise KeyError('The term of search doesn\'t exist')
rootSubjects = fromstring(responseSubject.content)
subjectList = rootSubjects.findall('./subjects/subject')
# if not looking for specific subject, the list of classes should be all classes of all subjects
if subjectID != None:
for element in subjectList:
if element.attrib['id'] == subjectID:
responseClass = requests.get(element.attrib['href'])
break
if responseClass == None:
raise KeyError('The subject of search doesn\'t exist')
rootClass = fromstring(responseClass.content)
# find course according to courseNum
if courseNum != None:
for course in rootClass.findall('./courses/course'):
if course.get('id') == courseNum:
courseList.append(course)
# if there is no courseNum require, put all courses in there
else:
courseList = rootClass.findall('./courses/course')
if courseList == []:
raise KeyError('The course number of search doesn\'t exist')
for course in courseList:
responseIndiClass = requests.get(course.get('href'))
tempRoot = fromstring(responseIndiClass.content)
tempClass = Class(tempRoot)
# add sections to each class
for section in tempRoot.findall('./sections/section'):
responseSection = requests.get(section.get('href'))
sectionRoot = fromstring(responseSection.content)
#-------filter out sections-------
# days of week
qualified = True
if daysOfTheWeek != None and daysOfTheWeek != '':
sectionTime = sectionRoot.find('./meetings/meeting/daysOfTheWeek')
if sectionTime != None:
sectionTime = sectionTime.text.strip()
if not inString(sectionTime, daysOfTheWeek):
qualified = False
else:
qualified = False
# start and end time
start = sectionRoot.find('./meetings/meeting/start')
end = sectionRoot.find('./meetings/meeting/end')
# filter according to earliest start time
if earliestTime != None:
if qualified and start != None and start.text[:2].isnumeric():
start1 = timeConvert(start.text.strip())
if start1 < earliestTime:
qualified = False
else:
qualified = False
# filter according to Latest start time
if latestTime != None:
if qualified and end != None and end.text[:2].isnumeric():
end1 = timeConvert(end.text.strip())
if end1 > latestTime:
qualified = False
else:
qualified = False
# Break time
if breakStart != None and breakEnd != None:
if qualified and start != None and end != None \
and start.text[:2].isnumeric() and end.text[:2].isnumeric():
start2 = timeConvert(start.text.strip())
end2 = timeConvert(end.text.strip())
if (start2 <= breakStart and end2 > breakStart) \
or (start2 > breakStart and end2 < breakEnd):
qualified = False
if qualified:
tempClass.add_section(sectionRoot)
classList.append(tempClass)
## put in gened requirement here
else:
for element in subjectList:
responseClass = requests.get(element.attrib['href'])
rootClass = fromstring(responseClass.content)
courseList += rootClass.findall('./courses/course')
return classList
os.system("cp " + currdir + "/test/lib/commons-logging.jar /tmp/")
t = Project(currdir + "/./test")
print t.top_src_dir
t.unjar()
t = Project(currdir + "/./test")
print "top src dir " + t.top_src_dir
print t.find_file_for_thing("D", currdir + "/test/test/bla/B.java")
s = "/home/burak/kod/pocketbudda/src/java/com/pocketbudda/UserHandlerBean.java"
print re.sub(r'/\w*.java$', "/UserDao" + ".java", s)
t = Project(currdir + "/./test")
s = t.find_file_for_thing("C", currdir + "/test/test/bla/B.java")
c = Class(t, s)
print c.list_all_public()
'''
# TBD activate after unjar is done
t = Project(currdir + "/./test")
s = t.find_file_for_thing("ARDAGoForward", currdir + "/test/test/bla/B.java")
c = Class(t, s)
print c.list_all_public()
'''
teststr = " Person user;\n "
thing = "user"
for m in re.finditer("([A-Z]\w*?)\s" + thing + "\s*?[;=]", teststr):
print m.group(1)
res = re.search('(ers.*?u)', teststr)
from Class import Class
from Student import Student
import Tokenizer
import docs_API
#pull all class info from docs
#pull all student information from google docs
#First: make a dummy class and a dummy student, first parameter = None
#tokenize and create classes
#tokenize and create students (and) choices
#Push each student onto a heapq as you read using heapq.heappush(q,student) where q is the list
#
dummy_class = Class(None, None, None, None, None, None)
dummy_student = Student(None, None, None, None, None, None)
#########################################
sheet_num = 0
#########################################
Tokenizer.tokenize_class()
Tokenizer.tokenize_students(sheet_num)
for i in range(len(Student.student_list)):
student = dummy_student.pop_student()
student_row = docs_API.row_of_student(sheet_num, student.name)
for class_num in student.class_list:
_class = Class.class_list[class_num]
if student.credits >= _class.get_required_credits(
def visit_file(self, file_dir):
cur_class = None
cur_func = None
func_cross_line = False
with open(file_dir) as fp:
for line in fp:
# independent function
if re.match(r"^def .+:", line):
cur_class = self.add_class(cur_class, file_dir)
""" extract function name """
func_name = _extract_func_name(line)
f = func(func_name)
""" extract arguments of function """
args = _extract_args(line)
f.args = args
if file_dir.replace(self.dir, "") not in self.file_funcs:
self.file_funcs[file_dir.replace(self.dir, "")] = [f]
else:
self.file_funcs[file_dir.replace(self.dir, "")].append(f)
# function within a class or function with more indentations
elif re.search(r"\s+def .+:", line):
if line.find("(") != -1 and line.find(")") != -1:
"""extract function name"""
func_name = _extract_func_name(line)
f = func(func_name)
""" extract arguments of function """
args = _extract_args(line)
f.args = args
if cur_class != None and line.find("self") != -1:
cur_class.add_func(f)
# function header that occupies at leaset 2 lines
elif line.find("(") != -1:
"""extract function name"""
func_name = _extract_func_name(line)
f = func(func_name)
""" extract arguments of function """
args = _extract_args(line)
f.args = args
cur_func = f
func_cross_line = True
# class
elif re.search(r"\s*class .+:", line):
cur_class = self.add_class(cur_class, file_dir)
class_name = _extract_class_name(line)
cur_class = Class(class_name)
elif func_cross_line:
args = _extract_args(line)
if cur_func != None:
for arg in args:
cur_func.add_arg(arg)
if line.find(")") != -1:
func_cross_line = False
if cur_class != None and line.find("self") != -1:
cur_class.add_func(cur_func)
cur_func = None
fp.close()
def formatClass(cls):
c = Class(-1)
c.setName(cls[0])
c.setSem(cls[1])
return c
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2018/3/12 19:08
# @Author : Zhaohang
'''
OBJECT是所有类的基类，这意味着它没有基类。TYPE是的一个子类OBJECT。默认情况下，每个类都是一个实例TYPE。
特别是，无论是TYPE和OBJECT是实例TYPE。但是，程序员也TYPE可以创建一个新的元类来进行子类化：
'''
from Class import Class
# set up the base hierarchy as in Python (the ObjVLisp model)
# the ultimate base class is OBJECT
def OBJECT__setattr__(self, fieldname, value):
self._write_dict(fieldname, value)
OBJECT = Class("object", None, {"__setattr__": OBJECT__setattr__}, None)
#OBJECT = Class(name="object", base_class=None, fields={}, metaclass=None)
# TYPE is a subclass of OBJECT
TYPE = Class(name="type", base_class=OBJECT, fields={}, metaclass=None)
# TYPE is an instance of itself
TYPE.cls = TYPE
# OBJECT is an instance of TYPE
OBJECT.cls = TYPE
bank_crt_path = open('server.crt').read()
# bank_private_key_path = open('server.pem').read()
bank_crt = OpenSSL.crypto.load_certificate(OpenSSL.crypto.FILETYPE_PEM, bank_crt_path)
store_crt = OpenSSL.crypto.load_certificate(OpenSSL.crypto.FILETYPE_PEM, store_crt_path)
customer_crt = OpenSSL.crypto.load_certificate(OpenSSL.crypto.FILETYPE_PEM, customer_crt_path)
# customer_private_key = OpenSSL.crypto.load_privatekey(OpenSSL.crypto.FILETYPE_PEM, bank_private_key_path)
A = []
B = []
C = []
A_ = []
B_ = []
C_ = []
AI = Class(A, A_)
CV = Class(B, B_)
Crypto = Class(C, C_)
class_list = {
'AI': AI,
'CV': CV,
'Crypto': Crypto
}
def verify(data):
# rec_data = eval(data)
rec_data = data
OI = rec_data['OI']
PIMD = rec_data['PIMD']
from tkinter import *
import tkinter as tk
from tkinter import ttk
import matplotlib as plt
from Class import Class
root = Tk()
text = Text(root)
root.title('Calculating Grades')
root.maxsize(1100, 800)
root.config(bg='white')
#UI_frame = tk.Frame(root, width=1000, height=600, bg='white')
#UI_frame.grid(row=0, column=0, padx=5, pady=5)
#UI_class = tk.Frame(root, width=100, height=100, bg='black')
#UI_class.grid(row=1, column=1, padx=1, pady=1)
#tk.Button(UI_frame, text = "Add Class", command="", bg = 'light green').grid(row=1, column=10, padx=10, pady=10)
Complejidad = Class()
Complejidad.CalculateGrades(20, 20)
Complejidad.CalculateGrades(15, 15)
Complejidad.CalculateGrades(10, 10)
print(Complejidad.grades)
print(Complejidad.CalculateAverage(Complejidad.grades))
# root.mainloop()
def tokenize_class():
row = docs_API.get_next_class_row()
while row != []:
print(row)
Class(row[0], row[1], row[2], row[3], row[4], row[6])
row = docs_API.get_next_class_row()
from Class import Class
rf = Class()
'''Registrating and Listing users'''
rf.registration('*****@*****.**', 'ena titok', 'Warrior24')
rf.registration('*****@*****.**', 'ena titok', 'Hedvig')
rf.registration('*****@*****.**', 'ena titok', 'Octavius')
rf.registration('*****@*****.**', 'ena titok', 'Barnabas')
rf.registration('*****@*****.**', 'ena titok', 'Herold')
rf.registration('*****@*****.**', 'ena titok', 'Gondor')
rf.registration('*****@*****.**', 'ena titok', 'Ferko')
rf.registration('*****@*****.**', 'ena titok', 'Eszter')
rf.registration('*****@*****.**', 'ena titok', 'Kuzco')
rf.listAllUsers()
rf.listAllUsersData()
'''Login'''
rf.login('*****@*****.**', 'vmi')
rf.login('*****@*****.**', 'hibas')
rf.login('*****@*****.**', 'ena titok')
rf.login('*****@*****.**', 'ena titok')
rf.login('*****@*****.**', 'ena titok')
rf.login('*****@*****.**', 'ena titok')
rf.login('*****@*****.**', 'ena titok')
rf.login('*****@*****.**', 'ena titok')
print(rf.isLogged('*****@*****.**'))
print(rf.isLogged('*****@*****.**'))
'''Delete Account'''
rf.deleteAccount('*****@*****.**')
rf.listAllUsers()
rf.listTokens()
