def profile_pic():
"""
Params: userId = <value>
Request: {'profilePic': <blob>} [POST only]
Response: image or empty
"""
if 'userId' not in request.args:
return jsonify({
'errorMessage':
'Can only search for profile picture by ID'
}), status.HTTP_400_BAD_REQUEST
user = db.get_user_by_id(request.args['userId'])
if user:
if request.method == 'GET':
if hasattr(user, 'profilePic'):
return jsonify({'profilePic': user.profilePic})
else:
return ''
else:
db.update_user_profile_pic(request.args['userId'],
request.json['profilePic'])
return "", status.HTTP_200_OK
else:
return jsonify({
'errorMessage': 'Could not find user with provided ID'
}), status.HTTP_400_BAD_REQUEST
def ApplyAutomatedQCToAppResult(sampleApp):
"""
Assesses the QC status of an app result from a SampleApp
@param sampleApp: (DBOrm.SampleApp)
@return (list of str): descriptions of the failing metrics
@raises AppServicesException: if the app results do not look as expected
"""
thresholds = Repository.SampleAppToQCThresholds(sampleApp)
metricsFile = Repository.SampleAppToMetricsFile(sampleApp)
outputDir = Repository.SampleAppToOutputDirectory(sampleApp)
basespaceId = Repository.SampleAppToBaseSpaceId(sampleApp)
appResultName = Repository.SampleAppToAppResultName(sampleApp)
qcDirName = ConfigurationServices.GetConfig("SAMPLE_LOG_DIR_NAME")
qcPath = os.path.join(outputDir, qcDirName)
# make directory to write qc file into
if not os.path.exists(qcPath):
os.makedirs(qcPath)
logging.debug(
"retrieving basespace files with extension %s from appsession Id %s" %
(metricsFile, basespaceId))
qcFiles = baseSpaceAPI.downloadAppResultFilesByExtension(
basespaceId, metricsFile, qcPath, appResultName, noLimitQP)
if len(qcFiles) != 1:
raise AppServicesException(
"did not get exactly one metrics file for QC!")
qcFile = qcFiles[0]
qcFilePath = os.path.join(qcPath, os.path.basename(qcFile.Path))
logging.debug("got file: %s" % qcFilePath)
qcResults = _ReadQCResult(qcFilePath)
failures = _CompareQCResultToThresholds(qcResults, thresholds)
return failures
def update_rating():
"""
Request: {"userId" : <id>, "rating": <val>}
Response: empty
"""
if 'userId' not in request.json:
return jsonify({'errorMessage':
'No user given'}), status.HTTP_400_BAD_REQUEST
if 'rating' not in request.json:
return jsonify({'errorMessage':
'No rating provided'}), status.HTTP_400_BAD_REQUEST
user = db.get_user_by_id(request.json['userId'])
if not user:
return jsonify({'errorMessage': 'No user found with that id'
}), status.HTTP_400_BAD_REQUEST
if not hasattr(user, 'rating_history') or not user.rating_history:
new_history = [request.json['rating']]
elif len(user.rating_history) >= 20:
new_history = user.rating_history[1:] + [request.json['rating']]
else:
new_history = user.rating_history + [request.json['rating']]
db.update_user_ratings(request.json['userId'], new_history)
return '', status.HTTP_200_OK
def get_open_seats_for_group():
"""
Parameters: groupId = <id>, userId = <id>
Response: {"openSeats": [[<seat>]]}
"""
if 'groupId' not in request.args:
return jsonify({'errorMessage': 'Group id missing from request'}), status.HTTP_400_BAD_REQUEST
if 'userId' not in request.args:
return jsonify({'errorMessage': 'User id missing from request'}), status.HTTP_400_BAD_REQUEST
group = db.get_group_by_id(request.args['groupId'])
if group:
schedules = db.get_schedules_for_group(group._id)
#TODO I'm hardcoding 4 quarters
#initialize all seats to be open in all quarters
open_seats = [[seat for seat in group.seats] for _ in range(4)]
for schedule in schedules:
for avail_quarter, scheduled in zip(open_seats, schedule.time_blocks):
if scheduled in avail_quarter:
avail_quarter.remove(scheduled)
user_sched = db.get_schedule_of_user_in_group(request.args['userId'], request.args['groupId'])
open_seats = [['', selected] + ls for ls, selected in zip(open_seats, user_sched.time_blocks)]
return jsonify({'openSeats': open_seats}), status.HTTP_200_OK
else:
return jsonify({'errorMessage': "Requested group could not be found"}), status.HTTP_400_BAD_REQUEST
def CheckConditionsOnSampleApp(sampleApp, ignoreYield=False):
"""
Evaluate whether a SampleApp is ready to be launched
this is dependent on the app type ("SingleGenome", or "TumourNormal")
@param sampleApp: (DBOrm.SampleApp)
@param ignoreYield: (bool)
@return (bool): whether the conditions are met, (str): any details about why conditions are not met
"""
# unpack some stuff from the objects
projectId = Repository.SampleAppToProjectId(sampleApp)
sampleName = Repository.SampleAppToSampleName(sampleApp)
appType = Repository.SampleAppToAppType(sampleApp)
if appType == "SingleGenome":
# if this is just a build, just check this sample is ready to go
return CheckConditionsOnSample(sampleName, projectId, ignoreYield)
if appType == "TumourNormal":
# if this is a subtraction, look up the two samples and check the readiness of both
tumourName = sampleName
tumourReady, tumourDetails = CheckConditionsOnSample(
tumourName, projectId, ignoreYield)
if not tumourReady:
return False, "(Tumour: %s)" % tumourDetails
normal = Repository.GetNormalForTumour(sampleName)
normalName = Repository.SampleToSampleName(normal)
normalReady, normalDetails = CheckConditionsOnSample(
normalName, projectId, ignoreYield)
if not normalReady:
return False, "(Normal: %s)" % normalDetails
return True, None
def leave_group():
"""
Params: groupId = <id>, userId = <id>
Response: empty
"""
if 'groupId' not in request.json:
return jsonify({'errorMessage': 'Group id missing from request'
}), status.HTTP_400_BAD_REQUEST
if 'userId' not in request.json:
return jsonify({
'errorMessage': 'Leaving user id missing from request'
}), status.HTTP_400_BAD_REQUEST
group = db.get_group_by_id(request.json['groupId'])
if group:
if ObjectId(request.json['userId']) in group.members:
db.remove_user_from_group(request.json['userId'], group)
db.remove_schedule_of_user_in_group(request.json['userId'],
request.json['groupId'])
return "", status.HTTP_200_OK
else:
return jsonify({
'errorMessage':
'User does not belong to specified group'
}), status.HTTP_400_BAD_REQUEST
else:
return jsonify({'errorMessage': 'Requested group could not be found'
}), status.HTTP_400_BAD_REQUEST
def delete_group():
"""
Request: {'groupId': <id>, 'ownerId': <id>}
Response: empty
"""
if 'groupId' not in request.json:
return jsonify({'errorMessage': 'Group id is missing from request'
}), status.HTTP_400_BAD_REQUEST
if 'ownerId' not in request.json:
return jsonify({'errorMessage': 'Owner id is missing from request'
}), status.HTTP_400_BAD_REQUEST
group = db.get_group_by_id(request.json['groupId'])
if group:
if group.owner_id == ObjectId(request.json['ownerId']):
db.remove_group(request.json['groupId'])
return "", status.HTTP_200_OK
else:
return jsonify({
'errorMessage':
'Given owner is not the owner of the given group'
}), status.HTTP_400_BAD_REQUEST
else:
return jsonify({'errorMessage': 'Given group could not be found'
}), status.HTTP_400_BAD_REQUEST
class Test_test1(unittest.TestCase):
def setUp(self):
self.test_board=Repository()
self.test_service=Service(self.test_board)
def test_A(self):
test_validity=self.test_board.GetBoard()
for index in range(0,6):
for elem in test_validity[index]:
if elem!=0:
self.assertEqual(0,1)
self.test_service.PlaceShip("A1A2A3")
test_validity=self.test_board.GetBoard()
self.assertEqual(1,test_validity[1][0])
try:
self.test_service.PlaceShip("A1A2A3")
self.assertFalse()
except Exception as exception:
self.assertEqual(str(exception),"Ships overlaping")
self.test_service.PlaceShip("C2D2E2")
test_validity=self.test_board.GetBoard()
self.assertEqual(1,test_validity[2][2])
self.test_service.PlaceShip("A2A3A4")
test_validity=self.test_board.GetBoard()
self.assertEqual(0,test_validity[1][0])
self.assertEqual(1,test_validity[4][0])
def book():
book = {
"BookId": 1,
"Name": 'cccacascac',
"Descr": '''
У творчому спадку Фридриха Ніцше «Ранкова зоря» – друга з трьох праць, що вирізняють середній («позитивістський») період філософування німецького мислителя. Посідаючи позицію між «Людським, надто людським» і «Веселою наукою», вона знаменує початок майбутнього проекту «переоцінки всіх цінностей». Текст складається з п’яти частин, які містять 575 афоризмів різної довжини й тематики. Ніцше визначає мораль як звичаєвий спосіб учинку й оцінювання. Порушено питання про передсуди, вільнодумство, проблеми істини та знання. Проведено підготовчу роботу з подальшого вивчення моралі та релігії, що розвиватиметься в полемічному трактаті «До генеалогії моралі» та критичній розвідці «Антихрист». В «Ранковій зорі» філософія Ніцше розглядається як експериментальна візія існування й випробування різноманітних перспектив самореалізації людини. Видання супроводжується історико-філософською передмовою й дослідницько-термінологічним коментарем. Українською твір перекладено вперше.
'''
}
comments = [
{'text': 'Я в захваті.',
'author': 'Кочубей',
'avatar': '../static/images/koch.jpeg'},
{'text': 'Книга дуже цікава!',
'author': 'Гість',
'avatar': 'https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQIgycbgAB8-MjaOmORWGZgvHlh-nb0yUteILyub1nu8LJsNQ1_Sw'}
]
regions = [{'RegionId': 1, 'Name': 'dsds'}, {'RegionId': 1, 'Name': 'dsds'}]
book_id = request.args['book_id']
login = ''
if g.user:
login = session['user']
book = Repository.get_full_book_info(book_id, session['user'])
else:
book = Repository.get_full_book_info(book_id)
comments = Repository.get_comments(book_id)
if request.method == 'POST':
print('sdfsdf')
button_value = request.form["button"]
print("test" + request.form["button"])
if button_value == "registration":
print("_register_")
print(request.form["name"])
print(request.form.get("sex"))
print(type(request.form["date"]))
register_data = {
"FirstName": request.form["name"],
"LastName": request.form["surname"],
"Login": request.form["login_box"],
"Password": request.form["password"],
"Email": request.form["email"],
#"Age": request.form["age"],
"Region": request.form["region"],
"Sex": request.form["sex"],
"LanguageId": 0,#request.form["lang"],
"Birthday": str(request.form["age"]).replace('-', ''),#"10/10/2018",
#"IsAdmin": '0',
#"CardId": 1,
"Residence": 0,
"Religion": 0,
"LevelLive": 0
}
print(register_data)
elif button_value == "send":
comment = {'BookId': book_id, 'Login': login, 'Comment': request.form['comment_text']}
Repository.save_comment(comment)
return redirect(url_for("book", book_id = str(book_id)))
return render_template('book_page.html', book = book, comments = comments, regions = regions, is_login = g.user)
def RegisterControllers(self): import Repository return [ Repository.register_object(Player.Script), Repository.register_object(Controller.If), Repository.register_object(Controller.Loop), Repository.register_object(Controller.Block), ]
def slot_exit(slot_number: int) -> (str, int):
details = Repository.get_vn_and_age_details(slot_number=slot_number)
if len(details) == 0:
return "", 0
vn, age = details[0][0], details[0][1]
Repository.update_tickets_to_inactive(slot_number=slot_number)
Repository.update_parking_slots(slot_number=slot_number, is_vacant=True)
return vn, age
def check_if_tables_exists() -> bool:
if not Repository.check_if_tickets_exists():
return False
if not Repository.check_if_parking_slots_exists():
return False
if not Repository.check_if_car_user_details_exists():
return False
return True
def RegisterControllers(self):
import Repository
return [
Repository.register_object(Player.Script),
Repository.register_object(Controller.If),
Repository.register_object(Controller.Loop),
Repository.register_object(Controller.Block),
]
def store(self, data):
isAppExist = Repository().fetchDetailsWithoutJoin('Apps', {'name':data['name']})
if isAppExist:
return False
newApp = Repository().store('apps', data)
if newApp:
return Repository().fetchDetailsWithoutJoin('apps', newApp)
else:
return False
def user_handler():
TollData = Repository()
TollStations = construct_TollsStations(TollData)
data = get_data()
user = User(data['as'], data['lat'], data['lon'], data['query'],
data['city'], data['country'], data['isp'], data['org'],
data['region'], data['regionName'], data['status'],
data['timezone'], data['zip'])
TollData.insert_user(user)
return user.city
def clear_approvals():
"""
Params: "groupId" = <id>
Response: ""
"""
if 'groupId' not in request.json:
return jsonify({'errorMessage': 'Group id missing from request'
}), status.HTTP_400_BAD_REQUEST
db.remove_approvals_for_group(request.json['groupId'])
return "", status.HTTP_200_OK
def clone_project(project):
data = project.repository_internal
project.repository_internal = None #FIXME: should not modify source project
import Repository
new_data = Repository.RepositoryInternal()
import Clone
new_project = Clone.clone(project, Repository.LocalRepository(new_data))
project.repository_internal = data
new_project.repository_internal = new_data
return new_project
def save_patch_in_codeaurora_org(hyperlink, cve):
save_dir = os.path.join(r"D:\tt", cve)
if not os.path.exists(save_dir):
os.makedirs(save_dir)
html = etree.HTML(
parse_page(hyperlink,
timeout=10,
headers={
'User-Agent': random.choice(Repository.user_agent_list)
}).text)
diff_element = html.xpath(
"/html/body/div[2]/div[1]/table[@summary='diff']")
if diff_element:
diff_element = diff_element[0]
vuln_file_name = ""
for element in diff_element.xpath(".//div"):
if element.xpath("./@class") == ['head']:
vuln_file_name = element.xpath("./a[1]/text()")[0].replace(
'/', '#~')
Repository.append_file_with_eol(
os.path.join(save_dir, vuln_file_name),
'\n'.join(element.xpath(".//text()")))
bm_file_context = ''.join(
etree.HTML(
parse_page("https://source.codeaurora.org" +
element.xpath("./a[1]/@href")[0],
timeout=10,
headers={
'User-Agent':
random.choice(
Repository.user_agent_list)
}).text).
xpath(
"/html/body/div[2]/div[2]/table/tr/td[2]/pre/code/div[@class='highlight']//text()"
))
Repository.append_file_with_eol(
os.path.join(save_dir, '(BM)' + vuln_file_name),
bm_file_context)
am_file_context = ''.join(
etree.HTML(
parse_page("https://source.codeaurora.org" +
element.xpath("./a[2]/@href")[0],
timeout=10,
headers={
'User-Agent':
random.choice(
Repository.user_agent_list)
}).text).
xpath(
"/html/body/div[2]/div[2]/table/tr/td[2]/pre/code/div[@class='highlight']//text()"
))
Repository.append_file_with_eol(
os.path.join(save_dir, '(AM)' + vuln_file_name),
am_file_context)
else:
Repository.append_file_with_eol(
os.path.join(save_dir, vuln_file_name),
''.join(element.xpath(".//text()")))
return True
return False
def replace_uuid_back(node):
import Repository
assert node.__class__ not in uncloneable
if isinstance(node, Player):
for i in range(len(node.children)):
if type(node.children[i]) in (str, unicode):
node.children[i] = Repository.lookup(node.children[i])
else:
replace_uuid_back(node.children[i])
for i in range(len(node.scripts)):
if type(node.scripts[i]) in (str, unicode):
node.scripts[i] = Repository.lookup(node.scripts[i])
else:
replace_uuid_back(node.scripts[i])
def replace_uuid_back(node): import Repository assert node.__class__ not in uncloneable if isinstance(node, Player): for i in range(len(node.children)): if type(node.children[i]) in (str, unicode): node.children[i] = Repository.lookup(node.children[i]) else: replace_uuid_back(node.children[i]) for i in range(len(node.scripts)): if type(node.scripts[i]) in (str, unicode): node.scripts[i] = Repository.lookup(node.scripts[i]) else: replace_uuid_back(node.scripts[i])
def bifurcation_create_mesh_TetGen(solidfn, dstdir, bifurcation_mesh_option):
#
# Mesh the solid
#
print("Creating mesh.")
# create meshsim style script file
fp = open(dstdir + '/bifurcation.tgs', 'w+')
fp.write("msinit\n")
fp.write("logon %s \n" % (dstdir + '/bifurcation.logfile'))
fp.write("loadModel %s\n" % solidfn)
fp.write("setSolidModel\n")
fp.write("newMesh\n")
fp.write("option surface 1\n")
fp.write("option volume 1\n")
if bifurcation_mesh_option == 'Coarse Isotropic Mesh':
fp.write("option GlobalEdgeSize 1.2\n")
fp.write("wallFaces wall\n")
elif (bifurcation_mesh_option == 'Refined Mesh'):
fp.write("option GlobalEdgeSize 1.2\n")
fp.write("wallFaces wall\n")
fp.write("sphereRefinement 0.5 10.0 16.0 0.0 -95.0\n")
elif (bifurcation_mesh_option == 'Dense Mesh'):
fp.write("option GlobalEdgeSize 0.75\n")
fp.write("wallFaces wall\n")
fp.write("option QualityRatio 1.4\n")
fp.write("option NoBisect 1\n")
fp.write("generateMesh\n")
fp.write("writeMesh %s vtu 0\n" % (dstdir + '/bifurcation.sms'))
fp.write("deleteMesh\n")
fp.write("deleteModel\n")
fp.write("logoff\n")
fp.close()
try:
Repository.repos_delete("mymesh")
except:
pass
mesh_utils.mesh_readTGS(dstdir + '/bifurcation.tgs', 'mymesh')
print("Writing out mesh surfaces.")
os.mkdir(dstdir + '/mesh-complete')
os.mkdir(dstdir + '/mesh-complete/mesh-surfaces')
mesh_utils.mesh_writeCompleteMesh('mymesh', 'bifurcation', 'bifurcation',
dstdir + '/mesh-complete')
def get_schedules_for_group():
"""
Parameters: groupId = <id>
Response: {"schedules": [[<seat>]]}
"""
if 'groupId' not in request.args:
return jsonify({'errorMessage': 'Group id missing from request'}), status.HTTP_400_BAD_REQUEST
group = db.get_group_by_id(request.args['groupId'])
if group:
schedules = [ViewModel.UserScheduleView(x) for x in db.get_schedules_for_group(group._id)]
return jsonify({'schedules': schedules})
else:
return jsonify({'errorMessage': "Requested group could not be found"}), status.HTTP_400_BAD_REQUEST
def save_bm_code_in_github_com(hyperlink, save_path):
if os.path.exists(save_path):
os.remove(save_path)
content = Repository.requests_get_content(
hyperlink,
timeout=10,
headers={'User-Agent': random.choice(Repository.user_agent_list)})
if content:
soup = bs4.BeautifulSoup(content, 'lxml')
for tag_td in soup.select(
'table.highlight.tab-size.js-file-line-container td.blob-code.blob-code-inner.js-file-line'
):
Repository.append_file_with_eol(save_path, tag_td.get_text())
return True
return False
def add_group_rating():
"""
Params: {"groupId" = <id>, "userId" = <id>}
Response: ""
"""
if 'groupId' not in request.json:
return jsonify({'errorMessage': 'Group id missing from request'
}), status.HTTP_400_BAD_REQUEST
if 'userId' not in request.json:
return jsonify({'errorMessage': 'User id missing from request'
}), status.HTTP_400_BAD_REQUEST
db.add_rated_for_group(request.json['userId'], request.json['groupId'])
return "", status.HTTP_200_OK
def get_repo(self, full_name_or_id, lazy=False):
"""
:calls: `GET /repos/:owner/:repo <http://developer.github.com/v3/repos>`_ or `GET /repositories/:id <http://developer.github.com/v3/repos>`_
:rtype: :class:`github.Repository.Repository`
"""
assert isinstance(full_name_or_id, (str, unicode, int, long)), full_name_or_id
url_base = "/repositories/" if isinstance(full_name_or_id, int) or isinstance(full_name_or_id, long) else "/repos/"
url = "%s%s" % (url_base, full_name_or_id)
if lazy:
return Repository.Repository(self.__requester, {}, {"url": url}, completed=False)
headers, data = self.__requester.requestJsonAndCheck(
"GET",
"%s%s" % (url_base, full_name_or_id)
)
return Repository.Repository(self.__requester, headers, data, completed=True)
def question_form():
login = request.args['login']
if request.method == 'POST':
print(request.form["q2"])
form_result = {
"Login": login,
"LanguageId": request.form["q2"],
"AmountTimeId": request.form["q1"],
"GenreId": request.form["q4"],
"AuthorGenreId": 0
}
print(form_result)
Repository.save_form_answers(form_result)
Repository.save_log(login, request.form["q4"])
return redirect(url_for('home'))
return render_template('questionnaire.html')
def writeUserLink(self, links, login):
# make sure links is an array of strings!!! even if only one
assert not isinstance(links, basestring)
if self.R.users_root is None:
if self.R.users_tree is None:
self.R.users_tree = self.R.parseXml('users.xml',0)
self.R.users_root = self.R.users_tree.getroot()
if login <> '':
for link in links:
self.lock_u.acquire()
try:
hit = self.R.users_root.findtext("./user[@link='" + Repository.encodeXml(link) + "']",'')
finally:
self.lock_u.release()
if hit == '':
self.speak("WriteUserLink : Adding a UserLink : " + login + '// ' + link)
self.lock_u.acquire()
try:
el = ET.SubElement(self.R.users_root,'user')
el.set('link',link)
el.text = login
finally:
self.lock_u.release()
elif login <> hit:
self.speak("USERLINK ERROR : CONFLICT DETECTED IN USERS " + login + '// ' + link)
else:
self.speak("USERLINK ERROR : trying to write an empty string : " + login)
def __init__(self, host, port):
""" Constructs an instance of DeadlineCon.
Params: host name of the web service (string)
port number the web service is listening on (integer)
"""
#Builds the ConnectionProperty object used for sending requests
address = host + ":" + str(port)
self.connectionProperties = ConnectionProperty(address)
#The different request groups use the ConnectionProperty object to send their requests
self.Jobs = Jobs.Jobs(self.connectionProperties)
self.SlavesRenderingJob = SlavesRenderingJob.SlavesRenderingJob(
self.connectionProperties)
self.Tasks = Tasks.Tasks(self.connectionProperties)
self.TaskReports = TaskReports.TaskReports(self.connectionProperties)
self.JobReports = JobReports.JobReports(self.connectionProperties)
self.LimitGroups = Limits.LimitGroups(self.connectionProperties)
self.Pulse = Pulse.Pulse(self.connectionProperties)
self.Repository = Repository.Repository(self.connectionProperties)
self.MappedPaths = MappedPaths.MappedPaths(self.connectionProperties)
self.MaximumPriority = MaximumPriority.MaximumPriority(
self.connectionProperties)
self.Pools = Pools.Pools(self.connectionProperties)
self.Groups = Groups.Groups(self.connectionProperties)
self.Plugins = Plugins.Plugins(self.connectionProperties)
self.Slaves = Slaves.Slaves(self.connectionProperties)
self.Users = Users.Users(self.connectionProperties)
self.Balancer = Balancer.Balancer(self.connectionProperties)
def pRepos(ren,objName):
tag = "%s_%s" % (ren[0],objName)
try:
vis.register(ren,objName)
except:
vis.polyRm(ren,objName)
vis.register(ren,objName)
vtkName = Repository.ExportToVtk(objName)
Map = [None]*2
Map[0] = "p_map_"+tag
Map[1] = vtk.vtkPolyDataMapper()
Map[1].SetInputData(vtkName)
Map[1].ScalarVisibilityOff()
act = [None]*2
act[0] = "p_act_"+tag
act[1] = vtk.vtkActor()
act[1].SetMapper(Map[1])
act[1].GetProperty().SetColor(1,0,0)
vis.renAddActor(ren,act)
vis.render(ren)
#vis.interact(ren)
setattr(vis,Map[0], Map)
setattr(vis,act[0],act)
return act
def open(self):
self.set_nodelay(True)
print('Socket Connected: ' + str(self.request.remote_ip))
repo = Repository.Repository()
# self.write_message(str(repo.get_current_count()))
self.write_message(self.get_current_values())
WebSocketHandler.waiters.add(self)
def _useAttributes(self, attributes):
if "label" in attributes: # pragma no branch
assert attributes["label"] is None or isinstance(
attributes["label"], (str, unicode)), attributes["label"]
self._label = attributes["label"]
if "ref" in attributes: # pragma no branch
assert attributes["ref"] is None or isinstance(
attributes["ref"], (str, unicode)), attributes["ref"]
self._ref = attributes["ref"]
if "repo" in attributes: # pragma no branch
assert attributes["repo"] is None or isinstance(
attributes["repo"], dict), attributes["repo"]
self._repo = None if attributes[
"repo"] is None else Repository.Repository(
self._requester, attributes["repo"], completed=False)
if "sha" in attributes: # pragma no branch
assert attributes["sha"] is None or isinstance(
attributes["sha"], (str, unicode)), attributes["sha"]
self._sha = attributes["sha"]
if "user" in attributes: # pragma no branch
assert attributes["user"] is None or isinstance(
attributes["user"], dict), attributes["user"]
self._user = None if attributes[
"user"] is None else NamedUser.NamedUser(
self._requester, attributes["user"], completed=False)
def get_future_events():
"""
Parameters: none
Response: {'events': [<event>]}
"""
return jsonify({'events': db.get_all_future_events()})
def library():
user = "******"
if g.user:
user = session['user']
print(user)
books = Repository.get_users_book(user)
print(books)
return render_template('user_library.html', user= user, books = books, is_login = g.user)
def GetDataFromUUID(self, uuid): import Repository data = Repository.lookup(uuid) import inspect if inspect.isclass(data): data = data() label = data.__class__.__name__ data.label = label return data
def __init__(self): self.records = [] self.specials = [] self.global_factory = None self.user_factory = None self.iteration_factory = None self.user_count = 1 self.iteration_count = 1 self.current_special = None self.repository_internal = Repository.get_global_repository().data
from metamodels import emof
from metamodels import KM3
from metamodels import PyTl
from Repository import *
source_km3 = Repository(metamodel=KM3)
source_km3.read_from_file("./data/dot.km3")
source_km3.save_to_file("./data/dot-bis.km3")
# target_emof = Repository(metamodel=emof)
# target_emof.create_empty_model()
# transfo = Repository(metamodel=PyTl)
# transfo.read_from_file("./transformations/Class2Package-emof.py")
# transfo.model[0].transform(source_emof,target_emof)
# target_emof.save_to_file("./data/test2.xmi")
from metamodels import emof
from metamodels import PyTl
from Repository import *
source_emof = Repository(metamodel=emof)
source_emof.read_from_file("./data/test.xmi")
target_emof = Repository(metamodel=emof)
target_emof.create_empty_model()
transfo = Repository(metamodel=PyTl)
transfo.read_from_file("./transformations/Class2Package-emof.py")
transfo.model[0].transform(source_emof,target_emof)
target_emof.save_to_file("./data/test2.xmi")
def show_classes(project):
import Repository
Repository.trace_classes(project.repository_internal)
def clean_project(project):
raise NotImplementedError()
def clean_project_in_path(path):
project = load_project(path)
new_project = clone_project(project)
save_project(new_project, path)
##################################################
if __name__ == '__main__':
import pickle
import Player
import Record
p = Project()
p.add_record(Player.Script('print 2'))
p.add_record(Record.Hit(''))
p.save('.load/project.pkl')
p.records = []
p.load_as_global('.load/project.pkl')
print p.records[0].uuid
Repository.lookup(p.records[0].uuid)
def load_as_global(self, path): self.load(path) Repository.get_global_repository().data = self.repository_internal
from metamodels import emof
from metamodels import PyTl
from Repository import *
source_emof = Repository(metamodel=emof)
source_emof.read_from_file("./data/test.xmi")
transfo = Repository(metamodel=PyTl)
transfo.read_from_file("./transformations/Class2PythonSource.py")
transfo.model[0].transform(source_emof, "./output/")
from metamodels import emof
from metamodels import KM3
from metamodels import PyTl
from Repository import *
import Browser
source_emof = Repository(metamodel=emof)
source_emof.read_from_file("./data/test.xmi")
#print source_emof.display_all()
#Browser.browse(KM3)
target_km3 = Repository(metamodel=KM3)
target_km3.create_empty_model()
transfo = Repository(metamodel=PyTl)
transfo.read_from_file("./transformations/Emof_2_KM3.py")
transfo.model[0].transform(source_emof,target_km3)
#Browser.browse(target_km3)
target_km3.save_to_file("./data/Emof_2_KM3.xmi")
from metamodels import KM3
from metamodels import Python
from metamodels import PyTl
from Repository import *
source_km3 = Repository(KM3)
source_km3.read_from_file("data/Book2Publication/Book/Book.km3")
transfo = Repository(metamodel=PyTl)
transfo.read_from_file("./transformations/KM3_2_Python.py")
target_py = Repository(metamodel=Python)
target_py.create_empty_model()
transfo.model[0].transform(source_km3,target_py)
from metamodels import Publication
from metamodels import Book
from metamodels import KM3
from metamodels import PyTl
from Repository import *
mmm = KM3.read_from_file("data/Book2Publication/Book/Book.km3")
print KM3.navigate(mmm)
book = Repository(metamodel=Book)
livre = book.create_instance("Book")
livre.title = "titre du livre"
chap1 = book.create_instance("Chapter")
chap1.title = "titre du chap1"
chap1.nb_pages = 10
chap2 = book.create_instance("Chapter")
chap2.title = "titre du chap2"
chap2.nb_pages = 1
chap3 = book.create_instance("Chapter")
chap3.title = "titre du chap3"
chap3.nb_pages = 20
chap4 = book.create_instance("Chapter")
chap4.title = "titre du chap4"
chap4.nb_pages = 11
livre.chapters = [chap1,chap2,chap3,chap4]
book.model = livre
pub = Repository(metamodel=Publication)
transfo = Repository(metamodel=PyTl)
