def main():
folders = {}
folders["politik"] = "data/politik"
folders["sport"] = "data/sport"
folders["wirtschaft"] = "data/wirtschaft"
bank = ClassBank()
l = Loader()
# train data
for classname, folder in folders.iteritems():
count = 0
content = ""
for file in os.listdir(folder + "/train/"):
if file.endswith(".txt"):
count = count + 1
content = content + " " + l.load_txt(folder + "/train/" + file)
c = Class(classname, content, count)
bank.addClass(c)
bank.train()
c = Classifier()
# test data
for classname, folder in folders.iteritems():
print "\n=== Testing",classname, "===\n"
for file in os.listdir(folder + "/test/"):
if file.endswith(".txt"):
tokenizer = Tokenizer(l.load_txt(folder + "/test/" + file))
classifiedClass = c.classify(tokenizer.getTokens(), bank)
print file,"=",classifiedClass.getName()
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 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 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 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 __init__(self, queue_max=-1, log_queue=None, name=None, timeout=None, timeout_message="", timeout_data=None, queue=None):
if name is None:
name = self.__class__.__name__
threading.Thread.__init__(self, name=name)
Class.__init__(self, log_queue)
self.daemon = True
self.running = False
self.timeout = timeout
self.timeout_message = timeout_message
self.timeout_data = timeout_data
if queue is None:
self.queue = Queue.Queue(queue_max)
else:
self.queue = queue
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 test_selfClass(self):
"""Check for good conversions"""
testData = u"""\
A 000041 Lu
B 000042 Lu
C 000043 Lu
a 000061 Ll
b 000062 Ll
c 000063 Ll
0 000030 Nd
1 000031 Nd
2 000032 Nd
$ 000024 Sc
= 00003d Sm
* 00002a Po
愚 00611a Lo
公 00516c Lo
移 0079fb Lo
山 005c71 Lo
"""
for line in testData.split('\n'):
line = line.strip()
if not line:
break
A, B, C = line.split()
if A and B and C:
codepoint = ord(A)
self.assertEqual(codepoint, int(B, 0x10), Self.doc())
self.assertEqual(Class.classify(codepoint), C, Self.doc())
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 start(self, args):
dirname = os.path.dirname(__file__)
file = open(dirname + "/Compiler_Functions.txt", "r")
default_functions = file.read()
file.close()
code = '.text\n'
code += '.globl main\n'
code += default_functions
code += Class.getConstructors()
code += args[0]['code']
self.data_code += "str_false : .asciiz \"false\" \n"
self.data_code += "str_true : .asciiz \"true\" \n"
self.data_code += "str_bool : .word str_false , str_true\n"
self.data_code += "obj_null : .word 61235\n"
self.data_code += Class.getVtables()
self.log_code(code + "\n\n.data\n" + self.data_code)
return args
def getClasses(self):
sql = "select * from class"
self.cursor.execute(sql)
try:
obj = self.cursor.fetchall()
return Class.CreateClass(obj)
except mysql.connector.Error as err:
print('hata', err)
def call(self , args):
id = args[0].children[0]
value_type = self.function_type(id)
actuals = args[1]
if not self.isClassMethod(id):
code = "# Storing Frame Pointer and Return Address Before Calling the function : " + id + "\n"
code += "addi $sp , $sp , -12\n"
code += "sw $fp , 4($sp)\n"
code += "sw $ra , 8($sp)\n"
code += "sw $s5 , 12($sp)\n"
code += "# Function Arguments\n"
code += actuals['code']
code += "jal " + self.getFunctionLabel(id) + " # Calling Function\n"
code += "# Pop Arguments of function\n"
code += "addi $sp , $sp , " + str(actuals['variable_count']*4) + "\n"
code += "# Load Back Frame Pointer and Return Address After Function call\n"
code += "lw $fp , 4($sp)\n"
code += "lw $ra , 8($sp)\n"
code += "lw $s5 , 12($sp)\n"
code += "addi $sp , $sp , 8\n"
if value_type == 'double':
code += "s.s $f0 , 4($sp) # Push Return Value from function to Stack\n"
else:
code += "sw $v0 , 4($sp) # Push Return Value from function to Stack\n"
return {'code': code , 'value_type' : value_type}
object_type = self.Stack.getVar("this").type;
c = Class.searchClass(object_type)
methodOffset = c.methodOffset(id)
value_type = c.getMethod(id)['type']
code = "# Caliing Method of class\n"
code += "# Storing Frame Pointer and Return Address Before Calling the Method : " + id + "\n"
code += "addi $sp , $sp , -12\n"
code += "sw $fp , 4($sp)\n"
code += "sw $ra , 8($sp)\n"
code += "sw $s5 , 12($sp)\n"
code += "# Function Arguments\n"
code += actuals['code']
code += "# Pushing \"this\" to Method's Arguments\n"
code += self.Stack.getAddress("this")
code += "lw $s7 , 0($s7)\n"
code += "sw $s7 , 0($sp) # Push \"this\"\n"
code += "addi $sp , $sp , -4\n"
code += "lw $s7 , 0($s7) # Loading Vtable of this\n"
code += "addi $s7 , $s7 , " + str(methodOffset) + " # Method offset\n"
code += "lw $s7 , 0($s7)\n"
code += "jal $s7 # Calling Method of this\n"
code += "# Pop Arguments of function\n"
code += "addi $sp , $sp , " + str(actuals['variable_count'] * 4 + 4) + "\n"
code += "# Load Back Frame Pointer and Return Address After Function call\n"
code += "lw $fp , 4($sp)\n"
code += "lw $ra , 8($sp)\n"
code += "lw $s5 , 12($sp)\n"
code += "addi $sp , $sp , 8\n"
if value_type == 'double':
code += "s.s $f0 , 4($sp) # Push Return Value from function to Stack\n"
else:
code += "sw $v0 , 4($sp) # Push Return Value from function to Stack\n"
return {'code': code, 'value_type': value_type}
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 getClasses(self):
sql = 'Select * From Class '
self.cursor.execute(sql)
try:
obj = self.cursor.fetchall()
return Class.CreateClass(obj)
except mysql.connector.Error as err:
print('Hata: ', err)
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 isClassMethod(self , name):
# Search function if its defined in the class
if self.inClass():
this = self.Stack.getVar("this")
c = Class.searchClass(this.type)
if c is None:
raise Exception("Class with name " + this.type + " not exists !")
if c.methodExists(name):
return True
return False
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 _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 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 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 ParseNamespaceCode(NamespaceName,code):
from Class import Class,ClassRegister
from settings import PrivateDefinition,PublicDefinition
from settings import ProtectedDefinition,PartialDefinition
from settings import StaticDefinition
tmp = code
for CLdef in ClassDefinition: #settings.ClassDefinition
CLstart = CLdef[0]
CLend = CLdef[1]
while (tmp.find(CLstart)>-1):
CLstartPos = tmp.find(CLstart)
CLlogBlockStartPos = tmp[CLstartPos:].find(Tag.format(name="LogicalBlockStart",idValue=0)[:19]) + CLstartPos
CLlogBlockID=tmp[CLlogBlockStartPos:]
CLlogBlockID = CLlogBlockID[CLlogBlockID.find("ID=")+3:]
CLlogBlockID = CLlogBlockID[:CLlogBlockID.find(Tag.format(name="LogicalBlockStart",idValue=0)[-3:])]
CLlogBlockEndPos = tmp.find(Tag.format(name="LogicalBlockEnd",idValue=CLlogBlockID)) + len(Tag.format(name="LogicalBlockEnd",idValue=CLlogBlockID))
CLendPos = CLlogBlockEndPos
i = CLstartPos
while not(tmp[i-1] in ['\n',EndlineSeparator] or i==0):
i=i-1
FullClassName=tmp[i:CLlogBlockStartPos].replace(CLstart," "+NamespaceName+".").replace("\n","").replace(" "," ")
if FullClassName[0]==" ":
FullClassName=FullClassName[1:]
cls = Class(FullClassName,tmp[CLlogBlockStartPos:CLlogBlockEndPos])
if (FullClassName.find(PrivateDefinition)>-1):
cls.Private=True
FullClassName = FullClassName.replace(PrivateDefinition,"")
if (FullClassName.find(PublicDefinition)>-1):
cls.Public=True
FullClassName = FullClassName.replace(PublicDefinition,"")
if (FullClassName.find(ProtectedDefinition)>-1):
cls.Protected=True
FullClassName = FullClassName.replace(ProtectedDefinition,"")
if (FullClassName.find(PartialDefinition)>-1):
cls.Partial=True
FullClassName = FullClassName.replace(PartialDefinition,"")
if (FullClassName.find(StaticDefinition)>-1):
cls.Static=True
FullClassName = FullClassName.replace(StaticDefinition,"")
if (len(FullClassName.replace(" ",""))>0):
cls.Name = FullClassName
ParseClassName(cls)
ClassRegister.AddClass(cls)
tmp = tmp[:i]+Tag.format(name="Class",idValue=cls.ID) + tmp[CLendPos:]
return tmp
def create_agents(N, graph, R):
Agents = []
for i in range(N):
# print("crea {0}".format(i))
estr = random.choice([0, 1])
# scr = random.choice([-1, 0, 1])
pol = random.choice([0, 1, 2, 3, 4, 5, 6, 7])
Agents.append(Cl.Agent(estr, None, pol, []))
asignar_vecinos(N, Agents, graph)
n_t = calcular_n_t(Agents)
ro_t = n_t / N
actualizar_puntajes(Agents, ro_t, R)
return Agents
def actualizar_estrategias(agents):
for i in range(len(agents)):
# st = agents[i].estrategias[-1]
# pt = agents[i].scores[-1]
# num_ult_pol = agents[i].politicas[-1]
# ult_pol = Cl.Politica(num_ult_pol)
# new_st = ult_pol.politica[(st, pt)]
# agents[i].estrategias.append(new_st)
st = agents[i].actual_est
pt = agents[i].actual_scr
num_ult_pol = agents[i].actual_pol
ult_pol = Cl.Politica(num_ult_pol)
new_st = ult_pol.politica[(st, pt)]
agents[i].actual_est = new_st
def getFunctionLabel(self , name):
# Search function if its defined in the class
if self.inClass():
this = self.Stack.getVar("this")
c = Class.searchClass(this.type)
if c is None:
raise Exception("Class with name " + this.type + " not exists !")
if c.methodExists(name):
return c.name + "_" + name
# Search in global scope
for function in self.Functions:
if function['name'] == name:
return name
raise Exception("function ( " + name + " ) not found !!!")
def __init__(self, name, classes, parser):
Class.__init__(self)
self.parser = parser
self.name = name
self.is_serialized = True
string_obj = Object()
string_obj.type = 'string'
for class_ in classes:
if class_.is_storage and (class_.side == parser.side or class_.side == 'both'):
object = Object()
object.type = 'map'
object.name = get_data_list_name(get_data_name(class_.name))
object.template_args.append(string_obj)
object.template_args.append(class_)
object.access = AccessSpecifier.public
self.members.append(object)
loaded = Object()
loaded.is_runtime = True
loaded.name = '_loaded'
loaded.type = 'bool'
loaded.initial_value = 'false'
loaded.access = AccessSpecifier.private
self.members.append(loaded)
self.create_shared_method()
function = Function()
function.name = 'initialize'
function.return_type = 'void'
function.is_const = True
function.args.append(['buffer', 'string'])
self.add_initialize_function_operations(function)
self.functions.append(function)
self.create_getters(classes)
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 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 call_obj_method(self , args):
obj_expr = args[0]
function_id = args[1].children[0]
actuals = args[2]
object_type = obj_expr['value_type']
if object_type[-2:] == "[]" and function_id == 'length':
code = "# Array Length\n"
code += "# Array Expr\n"
code += obj_expr['code']
code += "lw $t0 , 4($sp)\n"
code += "lw $t0 , 0($t0)\n"
code += "sw $t0 , 4($sp) # Pushing length of array to stack\n"
return {'code' : code , 'value_type' : 'int'}
c = Class.searchClass(object_type)
methodOffset = c.methodOffset(function_id)
value_type = c.getMethod(function_id)['type']
code = "# Calling Method of Object\n"
code += "# Object Expression\n"
code += obj_expr['code']
code += "lw $t0 , 4($sp)\n"
code += "lw $t0 , 0($t0) # Loading Vtable\n"
code += "addi $t0 , $t0 , " + str(methodOffset) + " # Adding offset of Method in Vtable\n"
code += "lw $t0 , 0($t0) # t0 now contains the address of function\n"
code += "sw $t0 , 0($sp) # Storing Function Address in Stack \n"
code += "addi $sp , $sp , -4\n"
code += "# Storing Frame Pointer and Return Address Before Calling the object's method : " + function_id + "\n"
code += "addi $sp , $sp , -12\n"
code += "sw $fp , 4($sp)\n"
code += "sw $ra , 8($sp)\n"
code += "sw $s5 , 12($sp)\n"
code += "# Method\'s Arguments \n"
code += actuals['code']
code += "lw $t0 , " + str(actuals['variable_count']*4 + 12 + 4 + 4) + "($sp) # Loading Object being called\n"
code += "sw $t0 , 0($sp) # Pushing object as \"this\" as first argument of method\n"
code += "lw $t0 , " + str(actuals['variable_count']*4 + 12 + 4) + "($sp) # Loading Method of object\n"
code += "addi $sp , $sp , -4\n"
code += "jal $t0 # Calling Object's method\n"
code += "addi $sp , $sp , " + str(actuals['variable_count'] * 4 + 4) + " # Pop Arguments of Method\n"
code += "# Load Back Frame Pointer and Return Address After Function call\n"
code += "lw $fp , 4($sp)\n"
code += "lw $ra , 8($sp)\n"
code += "lw $s5 , 12($sp)\n"
code += "addi $sp , $sp , 16\n"
if value_type == 'double':
code += "s.s $f0 , 4($sp) # Push Return Value from Method to Stack\n"
else:
code += "sw $v0 , 4($sp) # Push Return Value from Method to Stack\n"
return {'code': code , 'value_type': value_type}
def left_value_obj_var(self , args):
expr_atomic = args[0]
varID = args[1].children[0]
obj_type = expr_atomic['value_type']
c = Class.searchClass(obj_type);
if c == None:
raise Exception("Trying to access an object of Type (" + obj_type + ") that the class does not exists")
if not c.variableExists(varID):
raise Exception("Trying to access a variable name (" + varID + ") inside class (" + obj_type + ") that does not exists")
varOffset = c.variableOffset(varID);
code = "# Loading Variable of Object\n"
code += expr_atomic['code']
code += "lw $t0 , 4($sp)\n"
code += "addi $t0 , $t0 , " + str(varOffset) + " # add offset of variable to object address\n"
code += "sw $t0 , 4($sp)\n"
return {'code' : code , 'value_type' : c.getVariable(varID)['type']}
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 __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 []
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)
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()
