def download_from_url(url):
proxy = env_server.get_proxy()
if proxy['enabled']:
server = proxy['server'].replace('http://', '')
proxy_dict = {
'http': 'http://{login}:{pass}@{0}'.format(server, **proxy)
}
proxy_handler = urllib2.ProxyHandler(proxy_dict)
auth = urllib2.HTTPBasicAuthHandler()
opener = urllib2.build_opener(proxy_handler, auth, urllib2.HTTPHandler)
urllib2.install_opener(opener)
def url_open_agent(url=url, timeout=1):
return urllib2.urlopen(url=url, timeout=timeout)
query_worker = gf.get_thread_worker(
url_open_agent,
error_func=gf.error_handle
)
query_worker.try_start()
thread_pool = query_worker.get_thread_pool()
thread_pool.waitForDone()
if query_worker.is_failed():
return False
def get_stypes(self, result=None, run_thread=False):
if result:
if self.project.stypes:
self.create_checkin_checkout_ui()
self.toggle_loading_label()
self.ui_checkin_checkout.setHidden(False)
env_inst.ui_main.set_info_status_text('')
if run_thread:
env_inst.ui_main.set_info_status_text(
'<span style=" font-size:8pt; color:#00ff00;">Getting Search Types</span>')
def get_stypes_agent():
return self.project.get_stypes()
env_inst.set_thread_pool(None, 'server_query/server_thread_pool')
stypes_items_worker = gf.get_thread_worker(
get_stypes_agent,
env_inst.get_thread_pool('server_query/server_thread_pool'),
result_func=self.get_stypes,
error_func=gf.error_handle
)
stypes_items_worker.start()
def query_projects(self, result=None, run_thread=False):
if result:
self.restore_opened_projects()
self.fill_projects_to_menu()
env_inst.ui_main.set_info_status_text('')
if run_thread:
env_inst.ui_main.set_info_status_text(
'<span style=" font-size:8pt; color:#00ff00;">Getting projects</span>')
def get_all_projects_agent():
return tc.get_all_projects()
# projects_cache = self.load_object('projects_items')
projects_cache = None
if projects_cache:
# self.projects_items = projects_cache
if not self.projects_items_thread.isRunning():
self.projects_items_thread.kwargs = dict(result=env_inst.projects)
self.projects_items_thread.routine = self.empty_return
self.projects_items_thread.start(QtCore.QThread.NormalPriority)
else:
server_thread_pool = QtCore.QThreadPool()
server_thread_pool.setMaxThreadCount(env_tactic.max_threads())
env_inst.set_thread_pool(server_thread_pool, 'server_query/server_thread_pool')
projects_items_worker = gf.get_thread_worker(
get_all_projects_agent,
env_inst.get_thread_pool('server_query/server_thread_pool'),
result_func=self.query_projects,
error_func=gf.error_handle
)
projects_items_worker.start()
def refresh_virtual_snapshot(self):
self.update_args_dict()
def refresh_virtual_snapshot_agent():
info_dict = {
'status_text': 'Updating Snapshot Info',
'total_count': 2
}
virtual_snapshot_worker.emit_progress(0, info_dict)
virtual_snapshot = tc.get_virtual_snapshot(
search_key=self.args_dict['search_key'],
context=self.args_dict['context'],
snapshot_type=self.args_dict['snapshot_type'],
files_dict=self.args_dict['files_dict'],
is_revision=self.args_dict['is_revision'],
keep_file_name=self.args_dict['keep_file_name'],
explicit_filename=self.args_dict['explicit_filename'],
version=self.args_dict['version'],
checkin_type=self.args_dict['checkin_type'],
ignore_keep_file_name=self.args_dict['ignore_keep_file_name'],
)
virtual_snapshot_worker.emit_progress(1, info_dict)
return virtual_snapshot
virtual_snapshot_worker = gf.get_thread_worker(
refresh_virtual_snapshot_agent,
thread_pool=env_inst.get_thread_pool('commit_queue/server_thread_pool'),
result_func=self.fill_virtual_snapshot,
progress_func=self.checkin_progress,
error_func=gf.error_handle
)
virtual_snapshot_worker.start()
def search_suggestions(self, key=None):
state = self.validator.validate(key, 0)[0].name
if state == 'Invalid':
key = None
if key:
code = self.stype.info.get('code')
project = self.project.info.get('code')
columns = [self.suggest_column, 'keywords']
# print columns
filters = [(self.suggest_column, 'EQI', key)]
def assets_query_new_agent():
return tc.server_query(
filters=filters,
stype=code,
columns=columns,
project=project,
limit=self.display_limit,
offset=0,
)
env_inst.set_thread_pool(None, 'server_query/server_thread_pool')
search_suggestions_worker = gf.get_thread_worker(
assets_query_new_agent,
thread_pool=env_inst.get_thread_pool('server_query/server_thread_pool'),
result_func=self.search_suggestions_end,
error_func=gf.error_handle
)
search_suggestions_worker.try_start()
def listen(self):
def listen_agent():
from array import array
address = ('localhost', 6000) # family is deduced to be 'AF_INET'
listener = Listener(address, authkey='secret password')
conn = listener.accept()
print 'connection accepted from', listener.last_accepted
conn.send([2.25, None, 'junk', float])
conn.send_bytes('hello')
conn.send_bytes(array('i', [42, 1729]))
conn.close()
listener.close()
return 'Done'
env_inst.set_thread_pool(None, 'server_query/server_thread_pool')
worker = gf.get_thread_worker(
listen_agent,
env_inst.get_thread_pool('server_query/server_thread_pool'),
self.create_ui, gf.error_handle)
worker.start()
def search_suggestions(self, key=None):
if key:
code = self.stype.info.get('code')
project = self.project.info.get('code')
columns = [self.suggest_column]
filters = [(self.suggest_column, 'EQI', key)]
def assets_query_new_agent():
return tc.server_query(
filters=filters,
stype=code,
columns=columns,
project=project,
limit=self.display_limit,
offset=0,
)
server_thread_pool = QtCore.QThreadPool()
server_thread_pool.setMaxThreadCount(env_tactic.max_threads())
env_inst.set_thread_pool(server_thread_pool,
'server_query/server_thread_pool')
search_suggestions_worker = gf.get_thread_worker(
assets_query_new_agent,
thread_pool=env_inst.get_thread_pool(
'server_query/server_thread_pool'),
result_func=self.search_suggestions_end,
error_func=gf.error_handle)
search_suggestions_worker.try_start()
def threads_fill_items(self, kwargs):
def get_files_objects_agent():
return self.get_files_objects(kwargs)
worker = gf.get_thread_worker(get_files_objects_agent)
worker.result_func(self.append_items_to_tree)
worker.error_func(gf.error_handle)
worker.try_start()
def threads_fill_items(self, kwargs, exec_after_added=None):
def get_files_objects_agent():
return self.get_files_objects(kwargs)
worker = gf.get_thread_worker(get_files_objects_agent)
worker.result_func(self.append_items_to_tree)
if exec_after_added:
worker.finished_func(exec_after_added)
worker.error_func(gf.error_handle)
worker.try_start()
def get_widgets(self, kwargs):
def query_widgets_agent():
return self.query_widgets(kwargs)
env_inst.set_thread_pool(None, 'server_query/server_thread_pool')
worker = gf.get_thread_worker(
query_widgets_agent,
env_inst.get_thread_pool('server_query/server_thread_pool'),
self.create_widgets_ui, gf.error_handle)
worker.start()
def query_tasks(self):
def get_tasks_sobjects_agent():
return self.sobject.get_tasks_sobjects()
env_inst.set_thread_pool(None, 'server_query/server_thread_pool')
get_tasks_sobjects_worker = gf.get_thread_worker(
get_tasks_sobjects_agent,
env_inst.get_thread_pool('server_query/server_thread_pool'),
result_func=self.fill_tasks,
error_func=gf.error_handle,
)
get_tasks_sobjects_worker.try_start()
def startup():
app = QtGui.QApplication(sys.argv)
env_inst.ui_super = app
app.setStyle("plastique")
setPaletteFromDct(palette)
def server_ping_agent():
return tc.server_ping()
ping_worker = gf.get_thread_worker(
server_ping_agent, finished_func=lambda: create_ui(ping_worker))
ping_worker.try_start()
sys.exit(app.exec_())
def inplace_chekin(self):
if self.args_dict['checkin_app'] == 'standalone':
def inplace_checkin_agent():
# for in-place checkin
check_ok = tc.inplace_checkin(
self.args_dict['file_paths'],
self.virtual_snapshot,
self.args_dict['repo_name'],
self.args_dict['update_versionless'],
self.args_dict['only_versionless'],
self.args_dict['create_icon'],
self.args_dict['files_objects'],
self.args_dict['padding'],
progress_callback=inplace_checkin_worker.emit_progress,
)
return check_ok
inplace_checkin_worker = gf.get_thread_worker(
inplace_checkin_agent,
thread_pool=env_inst.get_thread_pool('commit_queue/server_thread_pool'),
result_func=self.inplace_checkin_done,
finished_func=self.chekin_snapshot,
progress_func=self.checkin_progress,
error_func=gf.error_handle
)
inplace_checkin_worker.start()
if self.args_dict['checkin_app'] == 'maya':
import thlib.maya_functions as mf
mf.set_info_to_scene(self.args_dict['search_key'], self.args_dict['context'])
# for in-place checkin
check_ok, files_objects = mf.inplace_checkin(
self.virtual_snapshot,
self.args_dict['repo_name'],
self.args_dict['update_versionless'],
self.args_dict['only_versionless'],
self.args_dict['create_icon'],
selected_objects=self.args_dict['selected_objects'],
ext_type=self.args_dict['ext_type'],
setting_workspace=self.args_dict['setting_workspace'],
)
if check_ok:
self.args_dict['files_objects'] = files_objects
self.chekin_snapshot()
else:
self.commit_item.set_progress_indicator_on()
self.commit_item.set_commit_failed()
def update_desctiption(self):
def update_desctiption_agent():
return tc.update_description(
search_key=self.item.get_search_key(),
description=self.descriptionTextEdit.toPlainText()
# description=gf.simplify_html(self.descriptionTextEdit.toHtml())
)
query_sobjects_worker = gf.get_thread_worker(
update_desctiption_agent,
finished_func=self.description_update_finished,
error_func=gf.error_handle)
self.item.update_description(self.descriptionTextEdit.toPlainText())
query_sobjects_worker.start()
def get_widgets(self, kwargs):
def query_widgets_agent():
return tc.execute_procedure_serverside(tq.query_EditWdg,
kwargs,
project=kwargs['project'])
env_inst.set_thread_pool(None, 'server_query/server_thread_pool')
worker = gf.get_thread_worker(
query_widgets_agent,
env_inst.get_thread_pool('server_query/server_thread_pool'),
self.create_widgets_ui, gf.error_handle)
worker.start()
def get_widgets(self, kwargs):
def query_widgets_agent():
return self.query_widgets(kwargs)
server_thread_pool = QtCore.QThreadPool()
server_thread_pool.setMaxThreadCount(env_tactic.max_threads())
env_inst.set_thread_pool(server_thread_pool,
'server_query/server_thread_pool')
worker = gf.get_thread_worker(
query_widgets_agent,
env_inst.get_thread_pool('server_query/server_thread_pool'),
self.create_widgets_ui, gf.error_handle)
worker.start()
def startup():
env_inst.ui_super = QtGui.QApplication(sys.argv)
env_inst.ui_super.setApplicationName('TacticHandler_Client')
env_inst.ui_super.setStyle('plastique')
setPaletteFromDct(palette)
def server_ping_agent():
return tc.server_ping()
ping_worker = gf.get_thread_worker(server_ping_agent,
finished_func=create_ui,
error_func=create_ui)
ping_worker.start()
sys.exit(env_inst.ui_super.exec_())
def query_projects(self):
env_inst.ui_main.set_info_status_text(
'<span style=" font-size:8pt; color:#00ff00;">Getting projects</span>')
def get_all_projects_and_logins_agent():
return tc.get_all_projects_and_logins()
env_inst.set_thread_pool(None, 'server_query/server_thread_pool')
projects_items_worker = gf.get_thread_worker(
get_all_projects_and_logins_agent,
env_inst.get_thread_pool('server_query/server_thread_pool'),
result_func=self.query_projects_finished,
error_func=gf.error_handle
)
projects_items_worker.start()
def get_stypes(self, result=None, run_thread=False):
if result:
self.stypes_items = result
self.create_checkin_checkout_ui()
# self.create_ui_my_tactic()
# self.create_ui_float_notify()
# self.create_ui_assets_browser()
self.toggle_loading_label()
if env_mode.get_mode() == 'maya':
dl.log('Handling Maya Hotkeys', group_id='Maya')
env_inst.ui_maya_dock.handle_hotkeys()
self.ui_checkin_checkout.setHidden(False)
env_inst.ui_main.set_info_status_text('')
if run_thread:
env_inst.ui_main.set_info_status_text(
'<span style=" font-size:8pt; color:#00ff00;">Getting Search Types</span>')
def get_stypes_agent():
return self.project.get_stypes()
stypes_cache = None
if stypes_cache:
self.stypes_items = stypes_cache
if not self.stypes_items_thread.isRunning():
self.stypes_items_thread.kwargs = dict(result=self.stypes_items)
self.stypes_items_thread.routine = self.empty_return
self.stypes_items_thread.start(QtCore.QThread.NormalPriority)
else:
server_thread_pool = QtCore.QThreadPool()
server_thread_pool.setMaxThreadCount(env_tactic.max_threads())
env_inst.set_thread_pool(server_thread_pool, 'server_query/server_thread_pool')
stypes_items_worker = gf.get_thread_worker(
get_stypes_agent,
env_inst.get_thread_pool('server_query/server_thread_pool'),
result_func=self.get_stypes,
error_func=gf.error_handle
)
stypes_items_worker.start()
def startup(restart=False, hotkeys=None):
if restart:
close_all_instances()
env_inst.ui_super = mf.get_maya_window()
try:
main_tab = mf.get_maya_dock_window()[0]
main_tab.hotkeys_dict = hotkeys
main_tab.handle_hotkeys()
main_tab.show()
main_tab.raise_()
except:
def server_ping_agent():
return tc.server_ping()
ping_worker = gf.get_thread_worker(server_ping_agent, finished_func=lambda: create_ui(ping_worker, hotkeys))
ping_worker.try_start()
def startup(restart=False, *args, **kwargs):
if restart:
close_all_instances()
env_inst.ui_super = mf.get_maya_window()
try:
main_tab = mf.get_maya_dock_window()[0]
main_tab.show()
main_tab.raise_()
except:
def server_ping_agent():
return tc.server_ping()
ping_worker = gf.get_thread_worker(
server_ping_agent,
finished_func=lambda: create_ui(None),
error_func=create_ui)
ping_worker.start()
def perform_update(self):
def get_subscriptions_and_messages_agent():
current_login = env_inst.get_current_login_object()
return current_login.get_subscriptions_and_messages(True)
env_inst.set_thread_pool(None,
'server_query/server_update_thread_pool')
env_inst.set_thread_pool(None, 'server_query/server_thread_pool')
query_worker, thread_pool = gf.get_thread_worker(
get_subscriptions_and_messages_agent,
thread_pool=env_inst.get_thread_pool(
'server_query/server_update_thread_pool'),
result_func=self.updating,
error_func=self.start_update_timer)
if thread_pool.activeThreadCount() == 0:
self.stop_update_timer()
# print query_worker.start(priority=1)
# for i in range(50):
thread_pool.try_start(query_worker)
def chekin_snapshot(self):
self.update_args_dict()
def inplace_checkin_agent():
info_dict = {
'status_text': 'Saving Snapshot To DB',
'total_count': 2
}
snapshot_checkin_worker.emit_progress(0, info_dict)
snapshot = tc.checkin_snapshot(
search_key=self.args_dict['search_key'],
context=self.args_dict['context'],
snapshot_type=self.args_dict['snapshot_type'],
is_revision=self.args_dict['is_revision'],
description=self.args_dict['description'],
version=self.args_dict['version'],
update_versionless=self.args_dict['update_versionless'],
only_versionless=self.args_dict['only_versionless'],
keep_file_name=self.args_dict['keep_file_name'],
repo_name=self.args_dict['repo_name'],
virtual_snapshot=self.virtual_snapshot,
files_dict=self.args_dict['files_dict'],
mode=self.args_dict['mode'],
create_icon=self.args_dict['create_icon'],
files_objects=self.args_dict['files_objects'],
)
snapshot_checkin_worker.emit_progress(1, info_dict)
return snapshot
snapshot_checkin_worker = gf.get_thread_worker(
inplace_checkin_agent,
thread_pool=env_inst.get_thread_pool('commit_queue/server_thread_pool'),
result_func=self.checkin_done,
progress_func=self.checkin_progress,
error_func=gf.error_handle
)
snapshot_checkin_worker.start()
