def onRecentPrjMenu(self, evt):
itemId = evt.GetId()
p = self.recentPrjMenu.FindItemById(itemId).GetItemLabelText()
print 'onRecentPrjMenu: name [%s]; id [%d]' % (p, itemId)
if self.project.isPrjLoaded(p): return
project = Project(p)
self.project.populateGui(project, self.project.root)
prj = self.project.latest()
self.loadProject(prj)
self.menu.Enable(PROJECT_SAVE, True)
self.menu.Enable(PROJECT_SAVE_AS, True)
def UpdateProjectList(self):
new_project_paths = []
for project in self.manifest.projects.values():
if project.relpath:
new_project_paths.append(project.relpath)
file_name = 'project.list'
file_path = os.path.join(self.manifest.repodir, file_name)
old_project_paths = []
if os.path.exists(file_path):
fd = open(file_path, 'r')
try:
old_project_paths = fd.read().split('\n')
finally:
fd.close()
for path in old_project_paths:
if not path:
continue
if path not in new_project_paths:
project = Project(
manifest=self.manifest,
name=path,
remote=RemoteSpec('origin'),
gitdir=os.path.join(self.manifest.topdir, path,
'.git'),
worktree=os.path.join(self.manifest.topdir, path),
relpath=path,
revisionExpr='HEAD',
revisionId=None)
if project.IsDirty():
print >> sys.stderr, 'error: Cannot remove project "%s": \
uncommitted changes are present' % project.relpath
print >> sys.stderr, ' commit changes, then run sync again'
return -1
else:
print >> sys.stderr, 'Deleting obsolete path %s' % project.worktree
shutil.rmtree(project.worktree)
# Try deleting parent subdirs if they are empty
dir = os.path.dirname(project.worktree)
while dir != self.manifest.topdir:
try:
os.rmdir(dir)
except OSError:
break
dir = os.path.dirname(dir)
new_project_paths.sort()
fd = open(file_path, 'w')
try:
fd.write('\n'.join(new_project_paths))
fd.write('\n')
finally:
fd.close()
return 0
def save():
projectOne = Project(title =request.form['titleForm'],
type = request.form['typeForm'],
start_from = request.form['startDateForm'],
end_at = request.form['endDateForm'],
description = request.form['descriptionForm'],
amount = request.form['amountForm'],
status = 1)
projectOne.save()
flash('SUCCESSFUL!')
return redirect(url_for('home'))
def create_project_run():
""" Runs functions in order for user to create projectself.
@returns dictionary containing project name, team size, names of team
members and their votes (which are initialised to {} here)
"""
team_size = get_team_size()
project_members = get_member_names(team_size)
project = Project(project_name, team_size, project_members)
projects_dict[project.name] = project
existing_projects = [i for i in projects_dict]
def shift_to_this(self):
if not self.selected_videos:
return
progress_global = QProgressDialog('Total progress shifting all files',
'Abort', 0, 100, self)
progress_global.setAutoClose(True)
progress_global.setMinimumDuration(0)
def callback_global(x):
progress_global.setValue(x * 100)
QApplication.processEvents()
callback_global(0)
manips = []
for i, video_path in enumerate(self.selected_videos):
callback_global(i / float(len(self.selected_videos)))
progress = QProgressDialog('Shifting ' + video_path, 'Abort', 0,
100, self)
progress.setAutoClose(True)
progress.setMinimumDuration(0)
def callback(x):
progress.setValue(x * 100)
QApplication.processEvents()
project_from = Project(os.path.dirname(self.selected_videos[i]))
frames = file_io.load_file(video_path)
[x_shift_from, y_shift_from] = project_from['origin']
x_shift = self.x - x_shift_from
y_shift = y_shift_from - self.y
shift = [y_shift, x_shift]
shifted_frames = self.apply_shift(frames, shift, callback)
# and save to project
pre_shifted_basename = os.path.splitext(
os.path.basename(video_path))[0]
manip = '_shift_from_' + project_from.name
manips = manips + [manip]
path_after = str(
os.path.join(self.project.path, pre_shifted_basename + manip) +
'.npy')
file_io.save_file(path_after, shifted_frames)
name_after = os.path.splitext(os.path.basename(path_after))[0]
if path_after in [f['path'] for f in self.project.files]:
raise FileAlreadyInProjectError(path_after)
self.project.files.append({
'name': name_after,
'path': path_after,
'type': 'video',
'manipulations': str([manip])
})
self.project.save()
# self.save_project(path_after, self.project, shifted_frames, manip, 'video')
self.refresh_all_list(self.project, self.list_shifted, manips)
callback_global(1)
def main(project, output):
p = Project()
p.read_data_from_xml(project)
number_of_gcps = len(p.gcps)
area_covered_by_gcps = p.gcps.polygon().area
processing_area = p.processing_area.area
ratio = float(area_covered_by_gcps) / processing_area
data = [[number_of_gcps, area_covered_by_gcps, processing_area, ratio]]
write_data_to_csv(output, data)
def deprecated_light_project(tmpdir):
project = Project('light-deprecated-project', tmpdir, 'cartridge')
remove_dependency(project, 'cartridge')
remove_dependency(project, 'luatest')
add_dependency_submodule(project)
use_deprecated_files(project)
return project
def UpdateProjectList(self, opt):
new_project_paths = []
for project in self.GetProjects(None, missing_ok=True):
if project.relpath:
new_project_paths.append(project.relpath)
file_name = 'project.list'
file_path = os.path.join(self.manifest.repodir, file_name)
old_project_paths = []
if os.path.exists(file_path):
with open(file_path, 'r') as fd:
old_project_paths = fd.read().split('\n')
# In reversed order, so subfolders are deleted before parent folder.
for path in sorted(old_project_paths, reverse=True):
if not path:
continue
if path not in new_project_paths:
# If the path has already been deleted, we don't need to do it
gitdir = os.path.join(self.manifest.topdir, path, '.git')
if os.path.exists(gitdir):
project = Project(manifest=self.manifest,
name=path,
remote=RemoteSpec('origin'),
gitdir=gitdir,
objdir=gitdir,
worktree=os.path.join(
self.manifest.topdir, path),
relpath=path,
revisionExpr='HEAD',
revisionId=None,
groups=None)
if project.IsDirty() and opt.force_remove_dirty:
print(
'WARNING: Removing dirty project "%s": uncommitted changes '
'erased' % project.relpath,
file=sys.stderr)
self._DeleteProject(project.worktree)
elif project.IsDirty():
print(
'error: Cannot remove project "%s": uncommitted changes '
'are present' % project.relpath,
file=sys.stderr)
print(' commit changes, then run sync again',
file=sys.stderr)
return 1
elif self._DeleteProject(project.worktree):
return 1
new_project_paths.sort()
with open(file_path, 'w') as fd:
fd.write('\n'.join(new_project_paths))
fd.write('\n')
return 0
def createProject():
projectName = getProjectName()
teamSize = getTeamSize()
members = getTeamNames(teamSize)
## Create Project class instance to store project details
project = Project(projectName, teamSize, members)
print("\n \t\tProject Name: " + project.name)
print("\n \t\tProject Members Size" + str(project.size))
print("\n \t\tProject Members" + str(project.members))
def project_ignore_sigterm(cartridge_cmd, short_tmpdir):
project = Project(cartridge_cmd, 'ignore-sigterm', short_tmpdir,
'cartridge')
remove_all_dependencies(project)
replace_project_file(project, 'init.lua', INIT_IGNORE_SIGTERM_FILEPATH)
replace_project_file(project, 'stateboard.init.lua',
INIT_IGNORE_SIGTERM_FILEPATH)
return project
def project_without_dependencies(cartridge_cmd, short_tmpdir):
project = Project(cartridge_cmd, 'empty-project', short_tmpdir,
'cartridge')
remove_all_dependencies(project)
replace_project_file(project, 'init.lua', INIT_NO_CARTRIDGE_FILEPATH)
replace_project_file(project, 'stateboard.init.lua',
INIT_NO_CARTRIDGE_FILEPATH)
return project
def _build(args):
'''Build project, obfuscate all files in the project'''
project = Project()
project.open(args.project)
logging.info('Build project %s ...', args.project)
capsule = build_path(project.capsule, args.project)
if not args.only_runtime:
output = project.output
mode = project.get_obfuscate_mode()
files = project.get_build_files(args.force)
src = project.src
filepairs = [(os.path.join(src, x), os.path.join(output, x))
for x in files]
logging.info('%s increment build',
'Disable' if args.force else 'Enable')
logging.info('Search scripts from %s', src)
logging.info('Obfuscate %d scripts with mode %s', len(files), mode)
for x in files:
logging.info('\t%s', x)
logging.info('Save obfuscated scripts to %s', output)
obfuscate_scripts(filepairs, mode, capsule, output)
# for x in targets:
# output = os.path.join(project.output, x)
# pairs = [(os.path.join(src, x), os.path.join(output, x))
# for x in files]
# for src, dst in pairs:
# try:
# shutil.copy2(src, dst)
# except Exception:
# os.makedirs(os.path.dirname(dst))
# shutil.copy2(src, dst)
project['build_time'] = time.time()
project.save(args.project)
if not args.no_runtime:
logging.info('Make runtime files')
make_runtime(capsule, output)
if project.entry:
for x in project.entry.split(','):
filename = os.path.join(output, x.strip())
logging.info('Update entry script %s', filename)
make_entry(filename, project.runtime_path)
else:
logging.info('\tIn order to import obfuscated scripts, insert ')
logging.info('\t2 lines in entry script:')
logging.info('\t\tfrom pytransfrom import pyarmor_runtime')
logging.info('\t\tpyarmor_runtime()')
logging.info('Build project OK.')
def main():
project_dir = sys.argv[1]
model_filename = os.path.join(project_dir, "project.json")
project = Project(model_filename)
residuals = compute_residuals(project, 0)
plt.plot(residuals[:,0], residuals[:,1], '.', color="k")
residuals = compute_residuals(project, -1)
plt.plot(residuals[:,0], residuals[:,1], '+', color="k")
plt.show()
def test_no_stats(self):
a_project = Project('project name')
a_client = Client('a_client')
listener = ServerListener( client=a_client, project=a_project )
generator = WebGenerator(project_name= a_project.name)
listener.current_time = lambda : "2006-04-04-00-00-00"
task = Task(a_project, a_client, 'task')
task.add_subtask("subtask", ["echo no stats"] )
Runner(task, testinglisteners=[listener])
self.assertEquals( {'a_client': {} }, generator.collect_stats() )
def test_create_project_without_params():
project = Project()
assert project.name == None
assert project.edit_date == None
assert project.description == None
assert project.protocol == None
assert project.change_protocol == None
assert project.src_port == None
assert project.dst_port == None
assert project.author == None
assert project.path == None
assert project.dissector == None
def new_project(self, menu):
path = fefactory_api.choose_dir("选择工程文件夹")
if path:
project = Project(path)
if project.exists():
# TODO
fefactory_api.confirm_yes("此工程已存在，是否覆盖", fefactory_api.NO)
else:
# TODO
project.title = input("请输入工程名称", Path.basename(path))
app.onChangeProject(project)
self.on_open_project(project)
def UpdateProjectList(self):
new_project_paths = []
for project in self.GetProjects(None, missing_ok=True):
if project.relpath:
new_project_paths.append(project.relpath)
file_name = 'project.list'
file_path = os.path.join(self.manifest.repodir, file_name)
old_project_paths = []
if os.path.exists(file_path):
fd = open(file_path, 'r')
try:
old_project_paths = fd.read().split('\n')
finally:
fd.close()
for path in old_project_paths:
if not path:
continue
if path not in new_project_paths:
# If the path has already been deleted, we don't need to do it
gitdir = os.path.join(self.manifest.topdir, path, '.git')
if os.path.exists(gitdir):
project = Project(manifest=self.manifest,
name=path,
remote=RemoteSpec('origin'),
gitdir=gitdir,
objdir=gitdir,
worktree=os.path.join(
self.manifest.topdir, path),
relpath=path,
revisionExpr='HEAD',
revisionId=None,
groups=None)
if project.IsDirty():
print(
'error: Cannot remove project "%s": uncommitted changes '
'are present' % project.relpath,
file=sys.stderr)
print(' commit changes, then run sync again',
file=sys.stderr)
return -1
elif self._DeleteProject(project.worktree):
return -1
new_project_paths.sort()
fd = open(file_path, 'w')
try:
fd.write('\n'.join(new_project_paths))
fd.write('\n')
finally:
fd.close()
return 0
def _target(args):
project = Project()
project.open(args.project)
name = args.name[0]
if args.remove:
logging.info('Remove target from project %s ...', args.project)
project.remove_target(name)
else:
logging.info('Add target to project %s ...', args.project)
project.add_target(name, args.platform, args.license)
project.save(args.project)
def get_project(self):
# tiedoston merkkijonomuotoinen sisältö
content = request.urlopen(self._url).read().decode("utf-8")
# deserialisoi TOML-formaatissa oleva merkkijono ja muodosta Project-olio sen tietojen perusteella
parsed_toml = toml.loads(content)
name = parsed_toml['tool']['poetry']['name']
description = parsed_toml['tool']['poetry']['description']
dependencies = parsed_toml['tool']['poetry']['dependencies']
dev_dependencies = parsed_toml['tool']['poetry']['dev-dependencies']
return Project(name, description, dependencies, dev_dependencies)
def list(self):
"""
List the Project Resources on the Zanata server
@return: list of Project object
"""
res, content = self.restclient.request(self.base_url+'/seam/resource/restv1/projects',
"get",
None,
self.http_headers)
projects_json = self.messages(res,content)
projects = [ Project(p) for p in projects_json]
return projects
def load_pdef(self, pdef):
tables = []
try:
tables = pdef['dbinfo']['tables']
except:
pass
# print pdef
# 加载项目定义信息
if not pdef['project'].has_key('group'):
pdef['project']['group'] = "qdingweb-pro"
self.project = Project(pdef['project']['folder_name'],
pdef['project']['name'],
pdef['project']['desc'], pdef['dbinfo']['host'],
pdef['dbinfo']['port'], pdef['dbinfo']['name'],
pdef['dbinfo']['username'],
pdef['dbinfo']['password'], tables,
pdef['project']['packageName'],
self.group_def[pdef['project']['group']])
engine = create_engine(
'mysql://%s:%s@%s:%s/%s' %
(self.project.db_username, self.project.db_password,
self.project.db_host, self.project.db_port, self.project.db_name))
insp = reflection.Inspector.from_engine(engine)
# print insp.get_table_names()
self.dbconn = MySQLdb.connect(host=self.project.db_host,
port=int(self.project.db_port),
user=self.project.db_username,
passwd=self.project.db_password,
connect_timeout=6000,
charset='utf8')
self.cur = self.dbconn.cursor()
self.field_dict = {}
try:
sql = """
select TABLE_SCHEMA,TABLE_NAME,COLUMN_NAME,COLUMN_COMMENT
from information_schema.`COLUMNS` where
TABLE_SCHEMA = '%s'
"""
results = self.cur.fetchmany(
self.cur.execute(sql % self.project.db_name))
for r in results:
# print r[3].encode('utf-8')
self.field_dict[(r[1], r[2])] = r[3].encode('utf-8')
except Exception, e:
print e
print sql
def test_sprint(self):
delete_db.delete_data_in_db()
user = self.create_user_and_login()
project = Project(user.get_cookie(), user.get_user_id(), "1")
project.create_project()
sprint = Sprint(user.get_cookie(), project.get_id())
sprint.add_sprint()
sprint.update_sprint()
sprint.get_all_sprint()
sprint.get_sprint()
sprint.get_tasks_of_sprint()
sprint.delete_sprint()
def _config(args):
'''Update project settings.'''
for x in ('obf-module-mode', 'obf-code-mode', 'disable-restrict-mode'):
if getattr(args, x.replace('-', '_')) is not None:
logging.warning('Option --%s has been deprecated', x)
project = Project()
project.open(args.project)
logging.info('Update project %s ...', args.project)
def _relpath(p):
return p if os.path.isabs(p) \
else relpath(os.path.abspath(p), project._path)
if args.src is not None:
args.src = _relpath(args.src)
logging.info('Format src to %s', args.src)
if args.output is not None:
args.output = _relpath(args.output)
logging.info('Format output to %s', args.output)
if args.license_file is not None:
args.license_file = _relpath(args.license_file)
logging.info('Format license file to %s', args.license_file)
if args.entry is not None:
src = os.path.abspath(args.src) if args.src else project.src
args.entry = _format_entry(args.entry, src)
logging.info('Format entry: %s', args.entry)
if args.capsule is not None:
logging.warning('The capsule %s is ignored', args.capsule)
if args.plugins is not None:
if ('clear' in args.plugins) or ('' in args.plugins):
logging.info('Clear all plugins')
args.plugins = []
if args.platforms is not None:
if '' in args.platforms:
logging.info('Clear platforms')
args.platform = ''
else:
args.platform = ','.join(args.platforms)
if args.disable_restrict_mode is not None:
if args.restrict_mode is not None:
logging.warning('Option --disable_restrict_mode is ignored')
else:
args.restrict_mode = 0 if args.disable_restrict_mode else 1
keys = project._update(dict(args._get_kwargs()))
for k in keys:
logging.info('Change project %s to "%s"', k, getattr(project, k))
if keys:
project.save(args.project)
logging.info('Update project OK.')
else:
logging.info('Nothing changed.')
def test_requirement(self):
delete_db.delete_data_in_db()
user = self.create_user_and_login()
project = Project(user.get_cookie(), user.get_user_id(), "1")
project.create_project()
project.create_project()
req = Requirement(user.get_cookie(), project.get_id())
req.add_req(project.get_id())
req.update_req()
req.get_all_req()
req.get_req()
req.delete_req()
def test_executions__one_green_execution(self):
a_project = Project('project name')
listener = ServerListener( project = a_project)
listener.current_time = lambda : "a date"
generator = WebGenerator(project_name= a_project.name)
a_client = Client('client name')
task = Task(a_project, a_client, 'task')
task.add_subtask('subtask1', [])
Runner(task, testinglisteners=[listener])
self.assertEquals(
{'testing_client' : [('a date', 'a date', 'task', 'stable')]},
generator.get_executions() )
def test_create_project_firstparam():
project = Project("New project")
assert project.name == "New project"
assert project.edit_date == None
assert project.description == None
assert project.protocol == None
assert project.change_protocol == None
assert project.src_port == None
assert project.dst_port == None
assert project.author == None
assert project.path == None
assert project.dissector == None
def _ParseProject(self, node):
"""
reads a <project> element from the manifest file
"""
name = self._reqatt(node, 'name')
remote = self._get_remote(node)
if remote is None:
remote = self._default.remote
if remote is None:
raise ManifestParseError, \
"no remote for project %s within %s" % \
(name, self._manifestFile)
revisionExpr = node.getAttribute('revision')
if not revisionExpr:
revisionExpr = self._default.revisionExpr
if not revisionExpr:
raise ManifestParseError, \
"no revision for project %s within %s" % \
(name, self._manifestFile)
path = node.getAttribute('path')
if not path:
path = name
if path.startswith('/'):
raise ManifestParseError, \
"project %s path cannot be absolute in %s" % \
(name, self._manifestFile)
if self.IsMirror:
relpath = None
worktree = None
gitdir = os.path.join(self.topdir, '%s.git' % name)
else:
worktree = os.path.join(self.topdir, path).replace('\\', '/')
gitdir = os.path.join(self.repodir, 'projects/%s.git' % path)
project = Project(manifest = self,
name = name,
remote = remote.ToRemoteSpec(name),
gitdir = gitdir,
worktree = worktree,
relpath = path,
revisionExpr = revisionExpr,
revisionId = None)
for n in node.childNodes:
if n.nodeName == 'copyfile':
self._ParseCopyFile(project, n)
return project
def create_model():
dataset = None
dataset_processed = None
models = None
scores = None
best_model = None
if request.method == 'POST':
print(request.form)
project_path = f'{PROJECTS_FOLDER}{request.form.get("project_name")}'
if not os.path.exists(project_path):
os.mkdir(project_path)
dataset = pd.read_csv(request.form.get('dataset_path'))
columns_types = [key for key in request.form.keys() if '_type' in key]
for column in columns_types:
col_data = column.split('_')
dataset[col_data[0]] = dataset[col_data[0]].astype(request.form.get(column))
dataset.to_csv(f'{project_path}/dataset.csv', index=False)
dataBot = DataBot(dataset=dataset,
project_path=project_path,
target_name=request.form.get('target'),
null_threshold=float(request.form.get('null_threshold')) / 100,
cardinal_threshold=float(request.form.get('cardinal_threshold')) / 100)
dataBot.pre_process()
dataset_processed = dataBot.get_dataset()
dataset_processed.to_csv(f'{project_path}/dataset_processed.csv', index=False)
model = Model(dataset_processed, request.form.get('target'))
model.train_models()
best_model = model.save_best_model(f'{project_path}/model.joblib')
models = list(model.training_results['learner'].values)
scores = list(model.training_results['test_score'].values)
project_info = {
'project_name': [request.form.get("project_name")],
'project_path': [project_path],
'model_name': [best_model.learner.__class__.__name__],
'model_score': [best_model.test_score],
'target': [request.form.get("target")],
'null_threshold': [request.form.get("null_threshold")],
'cardinal_threshold': [request.form.get("cardinal_threshold")]
}
project = Project(project_info)
project.save()
return render_template(
'model_info.html',
dataset=dataset.head(3),
dataset_processed=dataset_processed.head(),
models=models,
scores=scores)
def getProjects(self):
"""
Obtains all the projects and their items.
Returns the a project dictionary.
:return: a project dictionary {key=project_name, object=Project}
:rtype: dict
.. note:: This function is called in the constructor of this class.
"""
total_projects = (self.api.project().get(
limit=1, format=json))["meta"]["total_count"]
json_projects_array = []
#each element of the array is one get API call (if there are more than 1000 projects)
i = 0
while i < total_projects:
json_projects_array.append(
(self.api.project().get(offset=i, limit=1000,
format=json))["objects"])
i += 1000
json_projects = []
#array that is going to content all the projects
for i in json_projects_array:
for j in i:
json_projects.append(j)
projects_dict = {}
for i in json_projects:
projects_dict[i["name"]] = Project(i, self.api)
for p in projects_dict.values():
array_items = []
total_project_items = (self.api.project(p.getIdd()).items.get(
limit=1, format=json))["meta"]["total_count"]
j = 0
while j < total_project_items:
array_items.append((self.api.project(p.getIdd()).items.get(
limit=1000, offset=j, format=json))["objects"])
j += 1000
for j in array_items:
for k in j:
p.addItem(Item(k, self.api))
self._projects = projects_dict
return projects_dict
def project_ignore_sigterm(cartridge_cmd, short_tmpdir):
project = Project(cartridge_cmd, 'ignore-sigterm', short_tmpdir,
'cartridge')
remove_all_dependencies(project)
# This is necessary, because default app config has parameter `stateboard: true`
remove_project_file(project, '.cartridge.yml')
replace_project_file(project, 'init.lua', INIT_IGNORE_SIGTERM_FILEPATH)
replace_project_file(project, 'stateboard.init.lua',
INIT_IGNORE_SIGTERM_FILEPATH)
return project
