我们从Python开源项目中，提取了以下46个代码示例，用于说明如何使用version.VERSION。
def getname(self): s = 'v' + VERSION + ' ' if self.pruning: s += 'p' + self.pruning_limit + ' ' def add_port(letter, number): DEFAULT_PORTS = {'t':'50001', 's':'50002', 'h':'8081', 'g':'8082'} if not number: return '' if DEFAULT_PORTS[letter] == number: return letter + ' ' else: return letter + number + ' ' s += add_port('t',self.stratum_tcp_port) s += add_port('h',self.stratum_http_port) s += add_port('s',self.stratum_tcp_ssl_port) s += add_port('g',self.stratum_http_ssl_port) return s
def Network_playerid(self, data): # either player has supplied their unique player ID, in which case we remember it # TODO: check against server's clientData to make sure they supplied a valid ID if data.has_key("id"): self.playerID = data['id'] # or client has asked for a new unique, persistent, secret UUID # creates the player's unique id and sends it back to them # this id is secret and persistent, and not known by any other client else: self.playerID = self._server.GetNewPlayerID(self) # check that the client protocol version is new enough to play with us clientversion = data.get('version', -1) if clientversion < VERSION: self.Send({"action": "badversion", "message": "You are running version %d of the client protocol, but the server is %d." % (clientversion, VERSION), "version": VERSION}) #self.close_when_done() self._server.Log("VERSION MISMATCH: %d / server %d" % (clientversion, VERSION)) else: self._server.Log("VERSION: Player %d has ID %s" % (self.ID, self.playerID)) self.Send({"action": "playerid", "id": self.playerID, "version": VERSION})
def get_workbook_id(server, auth_token, user_id, site_id, workbook_name): """ Gets the id of the desired workbook to relocate. 'server' specified server address 'auth_token' authentication token that grants user access to API calls 'user_id' ID of user with access to workbook 'site_id' ID of the site that the user is signed into 'workbook_name' name of workbook to get ID of Returns the workbook id and the project id that contains the workbook. """ url = server + "/api/{0}/sites/{1}/users/{2}/workbooks".format(VERSION, site_id, user_id) server_response = requests.get(url, headers={'x-tableau-auth': auth_token}) _check_status(server_response, 200) xml_response = ET.fromstring(_encode_for_display(server_response.text)) workbooks = xml_response.findall('.//t:workbook', namespaces=xmlns) for workbook in workbooks: if workbook.get('name') == workbook_name: source_project_id = workbook.find('.//t:project', namespaces=xmlns).get('id') return source_project_id, workbook.get('id') error = "Workbook named '{0}' not found.".format(workbook_name) raise LookupError(error)
def move_workbook(server, auth_token, site_id, workbook_id, project_id): """ Moves the specified workbook to another project. 'server' specified server address 'auth_token' authentication token that grants user access to API calls 'site_id' ID of the site that the user is signed into 'workbook_id' ID of the workbook to move 'project_id' ID of the project to move workbook into """ url = server + "/api/{0}/sites/{1}/workbooks/{2}".format(VERSION, site_id, workbook_id) # Build the request to move workbook xml_request = ET.Element('tsRequest') workbook_element = ET.SubElement(xml_request, 'workbook') ET.SubElement(workbook_element, 'project', id=project_id) xml_request = ET.tostring(xml_request) server_response = requests.put(url, data=xml_request, headers={'x-tableau-auth': auth_token}) _check_status(server_response, 200)
def get_workbook_id(server, auth_token, user_id, site_id, workbook_name): """ Gets the id of the desired workbook to relocate. 'server' specified server address 'auth_token' authentication token that grants user access to API calls 'user_id' ID of user with access to workbook 'site_id' ID of the site that the user is signed into 'workbook_name' name of workbook to get ID of Returns the workbook id and the project id that contains the workbook. """ url = server + "/api/{0}/sites/{1}/users/{2}/workbooks".format(VERSION, site_id, user_id) server_response = requests.get(url, headers={'x-tableau-auth': auth_token}) _check_status(server_response, 200) xml_response = ET.fromstring(_encode_for_display(server_response.text)) workbooks = xml_response.findall('.//t:workbook', namespaces=xmlns) for workbook in workbooks: if workbook.get('name') == workbook_name: return workbook.get('id') error = "Workbook named '{0}' not found.".format(workbook_name) raise LookupError(error)
def download(server, auth_token, site_id, workbook_id): """ Downloads the desired workbook from the server (temp-file). 'server' specified server address 'auth_token' authentication token that grants user access to API calls 'site_id' ID of the site that the user is signed into 'workbook_id' ID of the workbook to download Returns the filename of the workbook downloaded. """ print("\tDownloading workbook to a temp file") url = server + "/api/{0}/sites/{1}/workbooks/{2}/content".format(VERSION, site_id, workbook_id) server_response = requests.get(url, headers={'x-tableau-auth': auth_token}) _check_status(server_response, 200) # Header format: Content-Disposition: name="tableau_workbook"; filename="workbook-filename" filename = re.findall(r'filename="(.*)"', server_response.headers['Content-Disposition'])[0] with open(filename, 'wb') as f: f.write(server_response.content) return filename
def get_workbook_id(server, auth_token, user_id, site_id, workbook_name): """ Gets the id of the desired workbook to relocate. 'server' specified server address 'auth_token' authentication token that grants user access to API calls 'user_id' ID of the user with access to workbooks 'site_id' ID of the site that the user is signed into 'workbook_name' name of workbook to get ID of Returns the workbook id and the project id that contains the workbook. """ url = server + "/api/{0}/sites/{1}/users/{2}/workbooks".format(VERSION, site_id, user_id) server_response = requests.get(url, headers={'x-tableau-auth': auth_token}) _check_status(server_response, 200) xml_response = ET.fromstring(_encode_for_display(server_response.text)) workbooks = xml_response.findall('.//t:workbook', namespaces=xmlns) for workbook in workbooks: if workbook.get('name') == workbook_name: return workbook.get('id') error = "Workbook named '{0}' not found.".format(workbook_name) raise LookupError(error)
def get_workbook_id(server, auth_token, user_id, site_id, workbook_name): """ Gets the id of the desired workbook to relocate. 'server' specified server address 'auth_token' authentication token that grants user access to API calls 'user_id' ID of user with access to workbooks 'site_id' ID of the site that the user is signed into 'workbook_name' name of workbook to get ID of Returns the workbook id and the project id that contains the workbook. """ url = server + "/api/{0}/sites/{1}/users/{2}/workbooks".format(VERSION, site_id, user_id) server_response = requests.get(url, headers={'x-tableau-auth': auth_token}) _check_status(server_response, 200) xml_response = ET.fromstring(_encode_for_display(server_response.text)) # Find all workbooks in the site and look for the desired one workbooks = xml_response.findall('.//t:workbook', namespaces=xmlns) for workbook in workbooks: if workbook.get('name') == workbook_name: return workbook.get('id') error = "Workbook named '{0}' not found.".format(workbook_name) raise LookupError(error)
def get_user_id(server, auth_token, site_id, username_to_audit): """ Returns the user id of the user to audit permissions for, if found. 'server' specified server address 'auth_token' authentication token that grants user access to API calls 'site_id' ID of the site that the user is signed into 'username_to_audit' username to audit permission for on server """ url = server + "/api/{0}/sites/{1}/users".format(VERSION, site_id) server_response = requests.get(url, headers={'x-tableau-auth': auth_token}) _check_status(server_response, 200) server_response = ET.fromstring(_encode_for_display(server_response.text)) # Find all user tags in the response and look for matching id users = server_response.findall('.//t:user', namespaces=xmlns) for user in users: if user.get('name') == username_to_audit: return user.get('id') error = "User id for {0} not found".format(username_to_audit) raise LookupError(error)
def delete_permission(server, auth_token, site_id, workbook_id, user_id, permission_name, existing_mode): """ Deletes a specific permission from the workbook. 'server' specified server address 'auth_token' authentication token that grants user access to API calls 'site_id' ID of the site that the user is signed into 'workbook_id' ID of workbook to audit permission in 'user_id' ID of the user to audit 'permission_name' name of permission to add or update 'existing_mode' is the mode of the permission already set for the workbook """ url = server + "/api/{0}/sites/{1}/workbooks/{2}/permissions/users/{3}/{4}/{5}".format(VERSION, site_id, workbook_id, user_id, permission_name, existing_mode) server_response = requests.delete(url, headers={'x-tableau-auth': auth_token}) _check_status(server_response, 204) return
def get_user_id(server, auth_token, site_id, username_to_update): """ Returns the user id of the user to update permissions for, if found. 'server' specified server address 'auth_token' authentication token that grants user access to API calls 'site_id' ID of the site that the user is signed into 'username_to_update' username to update permission for on server """ url = server + "/api/{0}/sites/{1}/users".format(VERSION, site_id) server_response = requests.get(url, headers={'x-tableau-auth': auth_token}) _check_status(server_response, 200) server_response = ET.fromstring(_encode_for_display(server_response.text)) # Find all user tags in the response and look for matching id users = server_response.findall('.//t:user', namespaces=xmlns) for user in users: if user.get('name') == username_to_update: return user.get('id') error = "User id for {0} not found".format(username_to_update) raise LookupError(error)
def query_permission(server, auth_token, site_id, workbook_id, user_id): """ Returns a list of all permissions for the specified user. 'server' specified server address 'auth_token' authentication token that grants user access to API calls 'site_id' ID of the site that the user is signed into 'workbook_id' ID of workbook to update permission in 'user_id' ID of the user to update """ url = server + "/api/{0}/sites/{1}/workbooks/{2}/permissions".format(VERSION, site_id, workbook_id) server_response = requests.get(url, headers={'x-tableau-auth': auth_token}) _check_status(server_response, 200) server_response = _encode_for_display(server_response.text) # Reads and parses the response parsed_response = ET.fromstring(server_response) # Find all the capabilities for a specific user capabilities = parsed_response.findall('.//t:granteeCapabilities', namespaces=xmlns) for capability in capabilities: user = capability.find('.//t:user', namespaces=xmlns) if user is not None and user.get('id') == user_id: return capability.findall('.//t:capability', namespaces=xmlns) return None
def delete_permission(server, auth_token, site_id, workbook_id, user_id, permission_name, existing_mode): """ Deletes a specific permission from the workbook. 'server' specified server address 'auth_token' authentication token that grants user access to API calls 'site_id' ID of the site that the user is signed into 'workbook_id' ID of workbook to update permission in 'user_id' ID of the user to update 'permission_name' name of permission to update 'existing_mode' is the existing mode for the permission """ url = server + "/api/{0}/sites/{1}/workbooks/{2}/permissions/users/{3}/{4}/{5}".format(VERSION, site_id, workbook_id, user_id, permission_name, existing_mode) print("\tDeleting existing permission") server_response = requests.delete(url, headers={'x-tableau-auth': auth_token}) _check_status(server_response, 204) return
def query_groups(server, auth_token, site_id, page_size, page_number): """ Queries for all groups in the site URI GET /api/api-version/sites/site-id/groups GET /api/api-version/sites/site-id/groups?pageSize=page-size&pageNumber=page-number """ if page_size == 0: url = server + "/api/{0}/sites/{1}/groups".format(VERSION, site_id) else: url = server + "/api/{0}/sites/{1}/groups?pageSize={2}&pageNumber={3}".format(VERSION, site_id, page_size, page_number) server_response = requests.get(url, headers={'x-tableau-auth': auth_token}) _check_status(server_response, 200) xml_response = ET.fromstring(_encode_for_display(server_response.text)) groups = xml_response.findall('.//t:group', namespaces=XMLNS) return groups
def get_users_in_group(server, auth_token, site_id, group_id, page_size, page_number): """ Get all the users in the group using group id GET /api/api-version/sites/site-id/groups/group-id/users GET /api/api-version/sites/site-id/groups/group-id/users?pageSize=page-size&pageNumber=page-number """ if page_size == 0: url = server + "/api/{0}/sites/{1}/groups/{2}/users".format(VERSION, site_id, group_id) else: url = server + "/api/{0}/sites/{1}/groups/{2}/users?pageSize={3}&pageNumber={4}".format(VERSION, site_id, group_id, page_size, page_number) server_response = requests.get(url, headers={'x-tableau-auth': auth_token}) #_check_status(server_response, 200) xml_response = ET.fromstring(_encode_for_display(server_response.text)) users = xml_response.findall('.//t:user', namespaces=XMLNS) return users
def index(request): form = DownloadModForm(request.POST or None) if form.is_valid(): cleaned_data = form.cleaned_data zip_data = create_mod({ "top": cleaned_data["top"], "right": cleaned_data["right"], "bottom": cleaned_data["bottom"], "left": cleaned_data["left"] }) response = HttpResponse(zip_data, content_type="application/zip") response["Content-Disposition"] = "attachment; filename=ui_reposition.zip" response["Content-Length"] = len(zip_data) return response return render(request, "index.html", { "version": VERSION, "presets": SCREEN_PRESETS })
def _create_makefile(index_dir, k, library_dir, mask_repeats=False): """Create a Makefile for k-mer propagation. Args: index_dir (str): Index directory. k (int): K-mer size. library_dir (library_dir): Library directory. mask_repeats (bool): Mask repeats using DustMasker. TODO: * Add checking of params.mk """ pro.message('Creating Makefile for k-mer propagation') propagation_dir = os.path.join(index_dir, 'propagation') pro.makedirs(propagation_dir) makefile = os.path.join(propagation_dir, 'Makefile') tree_fn = os.path.join(index_dir, 'tree.preliminary.nw') _test_tree(tree_fn) # pro.test_files(NEWICK2MAKEFILE, tree_fn) command = [NEWICK2MAKEFILE, '-k', k, tree_fn, os.path.abspath(library_dir), './', makefile] config = collections.OrderedDict() config['prophyle-version'] = version.VERSION config['prophyle-revision'] = version.REVCOUNT config['prophyle-commit'] = version.SHORTHASH config['k'] = k pro.save_index_config(index_dir, config) with open(os.path.join(propagation_dir, "params.mk"), "w+") as f: f.write('PRG_ASM="{}"\n'.format(ASM)) f.write("K={}\n".format(k)) if mask_repeats: f.write("MASKREP=1\n") pro.run_safe(command) _log_file_md5(makefile)
def print_sam_header(self): """Print SAM headers. """ print("@HD", "VN:1.5", "SO:unsorted", sep="\t", file=self.output_fo) print("@PG", "PN:prophyle", "ID:prophyle", "VN:{}".format(version.VERSION), sep="\t", file=self.output_fo) for node in self.tree_index.tree.traverse("postorder"): try: ur = "\tUR:{}".format(node.fastapath) except: ur = "" try: sp = "\tSP:{}".format(node.sci_name) except: sp = "" try: as_ = "\tAS:{}".format(node.gi) except: as_ = "" if node.name != '': print( "@SQ\tSN:{rname}\tLN:{rlen}{as_}{ur}{sp}".format( rname=node.name, rlen=CONFIG['FAKE_CONTIG_LENGTH'], as_=as_, ur=ur, sp=sp, ), file=self.output_fo )
def initUI(self): """ Description: Sets the size of the widget, the window title, centers the window, connects signals to methods and opens the Credentials dialog if needed. Arguments: None Returns: Nothing. """ global conf, MAXWIDTH, MAXHEIGHT, IMGDIR, VERSION self.setFixedSize(MAXWIDTH, MAXHEIGHT) self.center() self.setWindowTitle(_('apptitle') + ' ' + VERSION) self.setWindowIcon(QIcon(IMGDIR + 'appicon.png')) self.show() self.updatesignal.connect(self.update_status_icon) self.logoutsignal.connect(self.logout) self.warnlogoutsignal.connect(self.logout_warn) self.reloadsignal.connect(self.load_vms) if not conf.USERNAME: creds = Credentials(self) creds.finished.connect(self.start_vmpane) creds.exec_()
def subscribe(self): ret = yield from self.call('mining.subscribe', VERSION, None, self.server.host, self.server.port) nonce1 = binascii.unhexlify(ret['result'][1]) print("Successfully subscribed for jobs") self.solvers.set_nonce(nonce1) return nonce1
def sign_in(server, username, password, site=""): """ Signs in to the server specified with the given credentials 'server' specified server address 'name' is the name (not ID) of the user to sign in as. Note that most of the functions in this example require that the user have server administrator permissions. 'password' is the password for the user. 'site' is the ID (as a string) of the site on the server to sign in to. The default is "", which signs in to the default site. Returns the authentication token and the site ID. """ url = server + "/api/{0}/auth/signin".format(VERSION) # Builds the request xml_request = ET.Element('tsRequest') credentials_element = ET.SubElement(xml_request, 'credentials', name=username, password=password) ET.SubElement(credentials_element, 'site', contentUrl=site) xml_request = ET.tostring(xml_request) # Make the request to server server_response = requests.post(url, data=xml_request) _check_status(server_response, 200) # ASCII encode server response to enable displaying to console server_response = _encode_for_display(server_response.text) # Reads and parses the response parsed_response = ET.fromstring(server_response) # Gets the auth token and site ID token = parsed_response.find('t:credentials', namespaces=xmlns).get('token') site_id = parsed_response.find('.//t:site', namespaces=xmlns).get('id') user_id = parsed_response.find('.//t:user', namespaces=xmlns).get('id') return token, site_id, user_id
def sign_out(server, auth_token): """ Destroys the active session and invalidates authentication token. 'server' specified server address 'auth_token' authentication token that grants user access to API calls """ url = server + "/api/{0}/auth/signout".format(VERSION) server_response = requests.post(url, headers={'x-tableau-auth': auth_token}) _check_status(server_response, 204) return
def get_project_id(server, auth_token, site_id, dest_project): """ Returns the project ID of the desired project 'server' specified server address 'auth_token' authentication token that grants user access to API calls 'site_id' ID of the site that the user is signed into 'dest_project' name of destination project to get ID of """ page_num, page_size = 1, 100 # Default paginating values # Builds the request url = server + "/api/{0}/sites/{1}/projects".format(VERSION, site_id) paged_url = url + "?pageSize={0}&pageNumber={1}".format(page_size, page_num) server_response = requests.get(paged_url, headers={'x-tableau-auth': auth_token}) _check_status(server_response, 200) xml_response = ET.fromstring(_encode_for_display(server_response.text)) # Used to determine if more requests are required to find all projects on server total_projects = int(xml_response.find('t:pagination', namespaces=xmlns).get('totalAvailable')) max_page = int(math.ceil(total_projects / page_size)) projects = xml_response.findall('.//t:project', namespaces=xmlns) # Continue querying if more projects exist on the server for page in range(2, max_page + 1): paged_url = url + "?pageSize={0}&pageNumber={1}".format(page_size, page) server_response = requests.get(paged_url, headers={'x-tableau-auth': auth_token}) _check_status(server_response, 200) xml_response = ET.fromstring(_encode_for_display(server_response.text)) projects.extend(xml_response.findall('.//t:project', namespaces=xmlns)) # Look through all projects to find the 'default' one for project in projects: if project.get('name') == dest_project: return project.get('id') error = "Project named '{0}' was not found on server".format(dest_project) raise LookupError(error)
def start_upload_session(server, auth_token, site_id): """ Creates a POST request that initiates a file upload session. 'server' specified server address 'auth_token' authentication token that grants user access to API calls 'site_id' ID of the site that the user is signed into Returns a session ID that is used by subsequent functions to identify the upload session. """ url = server + "/api/{0}/sites/{1}/fileUploads".format(VERSION, site_id) server_response = requests.post(url, headers={'x-tableau-auth': auth_token}) _check_status(server_response, 201) xml_response = ET.fromstring(_encode_for_display(server_response.text)) return xml_response.find('t:fileUpload', namespaces=xmlns).get('uploadSessionId')
def get_default_project_id(server, auth_token, site_id): """ Returns the project ID for the 'default' project on the Tableau server. 'server' specified server address 'auth_token' authentication token that grants user access to API calls 'site_id' ID of the site that the user is signed into """ page_num, page_size = 1, 100 # Default paginating values # Builds the request url = server + "/api/{0}/sites/{1}/projects".format(VERSION, site_id) paged_url = url + "?pageSize={0}&pageNumber={1}".format(page_size, page_num) server_response = requests.get(paged_url, headers={'x-tableau-auth': auth_token}) _check_status(server_response, 200) xml_response = ET.fromstring(_encode_for_display(server_response.text)) # Used to determine if more requests are required to find all projects on server total_projects = int(xml_response.find('t:pagination', namespaces=xmlns).get('totalAvailable')) max_page = int(math.ceil(total_projects / page_size)) projects = xml_response.findall('.//t:project', namespaces=xmlns) # Continue querying if more projects exist on the server for page in range(2, max_page + 1): paged_url = url + "?pageSize={0}&pageNumber={1}".format(page_size, page) server_response = requests.get(paged_url, headers={'x-tableau-auth': auth_token}) _check_status(server_response, 200) xml_response = ET.fromstring(_encode_for_display(server_response.text)) projects.extend(xml_response.findall('.//t:project', namespaces=xmlns)) # Look through all projects to find the 'default' one for project in projects: if project.get('name') == 'default' or project.get('name') == 'Default': return project.get('id') print("\tProject named 'default' was not found in {0}".format(server))
def sign_in(server, username, password, site=""): """ Signs in to the server specified with the given credentials 'server' specified server address 'username' is the name (not ID) of the user to sign in as. Note that most of the functions in this example require that the user have server administrator permissions. 'password' is the password for the user. 'site' is the ID (as a string) of the site on the server to sign in to. The default is "", which signs in to the default site. Returns the authentication token and the site ID. """ url = server + "/api/{0}/auth/signin".format(VERSION) # Builds the request xml_request = ET.Element('tsRequest') credentials_element = ET.SubElement(xml_request, 'credentials', name=username, password=password) ET.SubElement(credentials_element, 'site', contentUrl=site) xml_request = ET.tostring(xml_request) # Make the request to server server_response = requests.post(url, data=xml_request) _check_status(server_response, 200) # ASCII encode server response to enable displaying to console server_response = _encode_for_display(server_response.text) # Reads and parses the response parsed_response = ET.fromstring(server_response) # Gets the auth token and site ID token = parsed_response.find('t:credentials', namespaces=xmlns).get('token') site_id = parsed_response.find('.//t:site', namespaces=xmlns).get('id') user_id = parsed_response.find('.//t:user', namespaces=xmlns).get('id') return token, site_id, user_id
def get_default_project_id(server, auth_token, site_id): """ Returns the project ID for the 'default' project on the Tableau server. 'server' specified server address 'auth_token' authentication token that grants user access to API calls 'site_id' ID of the site that the user is signed into """ page_num, page_size = 1, 100 # Default paginating values # Builds the request url = server + "/api/{0}/sites/{1}/projects".format(VERSION, site_id) paged_url = url + "?pageSize={0}&pageNumber={1}".format(page_size, page_num) server_response = requests.get(paged_url, headers={'x-tableau-auth': auth_token}) _check_status(server_response, 200) xml_response = ET.fromstring(_encode_for_display(server_response.text)) # Used to determine if more requests are required to find all projects on server total_projects = int(xml_response.find('t:pagination', namespaces=xmlns).get('totalAvailable')) max_page = int(math.ceil(total_projects / page_size)) projects = xml_response.findall('.//t:project', namespaces=xmlns) # Continue querying if more projects exist on the server for page in range(2, max_page + 1): paged_url = url + "?pageSize={0}&pageNumber={1}".format(page_size, page) server_response = requests.get(paged_url, headers={'x-tableau-auth': auth_token}) _check_status(server_response, 200) xml_response = ET.fromstring(_encode_for_display(server_response.text)) projects.extend(xml_response.findall('.//t:project', namespaces=xmlns)) # Look through all projects to find the 'default' one for project in projects: if project.get('name') == 'default' or project.get('name') == 'Default': return project.get('id') error = "Project named 'default' was not found in destination site" raise LookupError(error)
def delete_workbook(server, auth_token, site_id, workbook_id): """ Deletes the workbook from the source project. 'server' specified server address 'auth_token' authentication token that grants user access to API calls 'site_id' ID of the site that the user is signed into 'workbook_id' ID of workbook to delete """ # Builds the request to delete workbook from the source project on server url = server + "/api/{0}/sites/{1}/workbooks/{2}".format(VERSION, site_id, workbook_id) server_response = requests.delete(url, headers={'x-tableau-auth': auth_token}) _check_status(server_response, 204)
def add_new_permission(server, auth_token, site_id, workbook_id, user_id, permission_name, permission_mode): """ Adds the specified permission to the workbook for the desired user. 'server' specified server address 'auth_token' authentication token that grants user access to API calls 'site_id' ID of the site that the user is signed into 'workbook_id' ID of workbook to audit permission in 'user_id' ID of the user to audit 'permission_name' name of permission to add or update 'permission_mode' mode to set the permission """ url = server + "/api/{0}/sites/{1}/workbooks/{2}/permissions".format(VERSION, site_id, workbook_id) # Build the request xml_request = ET.Element('tsRequest') permissions_element = ET.SubElement(xml_request, 'permissions') ET.SubElement(permissions_element, 'workbook', id=workbook_id) grantee_element = ET.SubElement(permissions_element, 'granteeCapabilities') ET.SubElement(grantee_element, 'user', id=user_id) capabilities_element = ET.SubElement(grantee_element, 'capabilities') ET.SubElement(capabilities_element, 'capability', name=permission_name, mode=permission_mode) xml_request = ET.tostring(xml_request) server_request = requests.put(url, data=xml_request, headers={'x-tableau-auth': auth_token}) _check_status(server_request, 200) print("\tSuccessfully added/updated permission") return
def add_permission(server, auth_token, site_id, workbook_id, user_id, permission_name, permission_mode): """ Adds the specified permission to the workbook for the desired user. 'server' specified server address 'auth_token' authentication token that grants user access to API calls 'site_id' ID of the site that the user is signed into 'workbook_id' ID of workbook to update permission in 'user_id' ID of the user to update 'permission_name' name of permission to add or update 'permission_mode' mode to set the permission """ url = server + "/api/{0}/sites/{1}/workbooks/{2}/permissions".format(VERSION, site_id, workbook_id) # Build the request xml_request = ET.Element('tsRequest') permissions_element = ET.SubElement(xml_request, 'permissions') ET.SubElement(permissions_element, 'workbook', id=workbook_id) grantee_element = ET.SubElement(permissions_element, 'granteeCapabilities') ET.SubElement(grantee_element, 'user', id=user_id) capabilities_element = ET.SubElement(grantee_element, 'capabilities') ET.SubElement(capabilities_element, 'capability', name=permission_name, mode=permission_mode) xml_request = ET.tostring(xml_request) server_request = requests.put(url, data=xml_request, headers={'x-tableau-auth': auth_token}) _check_status(server_request, 200) return
def sign_in(server, username, password, site): """ Signs in to the server specified with the given credentials 'server' specified server address 'username' is the name (not ID) of the user to sign in as. Note that most of the functions in this example require that the user have server administrator permissions. 'password' is the password for the user. 'site' is the ID (as a string) of the site on the server to sign in to. The default is "", which signs in to the default site. Returns the authentication token and the site ID. """ url = server + "/api/{0}/auth/signin".format(VERSION) # Builds the request xml_request = ET.Element('tsRequest') credentials_element = ET.SubElement(xml_request, 'credentials', name=username, password=password) ET.SubElement(credentials_element, 'site', contentUrl=site) xml_request = ET.tostring(xml_request) # Make the request to server server_response = requests.post(url, data=xml_request) _check_status(server_response, 200) # ASCII encode server response to enable displaying to console server_response = _encode_for_display(server_response.text) # Reads and parses the response parsed_response = ET.fromstring(server_response) # Gets the auth token and site ID token = parsed_response.find('t:credentials', namespaces=XMLNS).get('token') site_id = parsed_response.find('.//t:site', namespaces=XMLNS).get('id') # user_id = parsed_response.find('.//t:user', namespaces=XMLNS).get('id') return token, site_id
def get_users_in_group_count(server, auth_token, site_id, group_id): """ Find out how many users are available in the group GET /api/api-version/sites/site-id/groups/group-id/users """ url = server + "/api/{0}/sites/{1}/groups/{2}/users".format(VERSION, site_id, group_id) server_response = requests.get(url, headers={'x-tableau-auth': auth_token}) #_check_status(server_response, 200) xml_response = ET.fromstring(_encode_for_display(server_response.text)) total_available = xml_response.find('.//t:pagination', namespaces=XMLNS).attrib['totalAvailable'] # Note! Need to convert "total_available" to integer total_available = int(total_available) return total_available
def sign_in(server, username, password, site=""): """ Signs in to the server specified with the given credentials 'server' specified server address 'username' is the name (not ID) of the user to sign in as. Note that most of the functions in this example require that the user have server administrator permissions. 'password' is the password for the user. 'site' is the ID (as a string) of the site on the server to sign in to. The default is "", which signs in to the default site. Returns the authentication token and the site ID. """ url = server + "/api/{0}/auth/signin".format(VERSION) # Builds the request xml_request = ET.Element('tsRequest') credentials_element = ET.SubElement(xml_request, 'credentials', name=username, password=password) ET.SubElement(credentials_element, 'site', contentUrl=site) xml_request = ET.tostring(xml_request) # Make the request to server server_response = requests.post(url, data=xml_request) _check_status(server_response, 200) # ASCII encode server response to enable displaying to console server_response = _encode_for_display(server_response.text) # Reads and parses the response parsed_response = ET.fromstring(server_response) # Gets the auth token and site ID token = parsed_response.find('t:credentials', namespaces=xmlns).get('token') site_id = parsed_response.find('.//t:site', namespaces=xmlns).get('id') return token, site_id
def get_default_project_id(server, auth_token, site_id): """ Returns the project ID for the 'default' project on the Tableau server. 'server' specified server address 'auth_token' authentication token that grants user access to API calls 'site_id' ID of the site that the user is signed into """ page_num, page_size = 1, 100 # Default paginating values # Builds the request url = server + "/api/{0}/sites/{1}/projects".format(VERSION, site_id) paged_url = url + "?pageSize={0}&pageNumber={1}".format(page_size, page_num) server_response = requests.get(paged_url, headers={'x-tableau-auth': auth_token}) _check_status(server_response, 200) xml_response = ET.fromstring(_encode_for_display(server_response.text)) # Used to determine if more requests are required to find all projects on server total_projects = int(xml_response.find('t:pagination', namespaces=xmlns).get('totalAvailable')) max_page = int(math.ceil(total_projects / page_size)) projects = xml_response.findall('.//t:project', namespaces=xmlns) # Continue querying if more projects exist on the server for page in range(2, max_page + 1): paged_url = url + "?pageSize={0}&pageNumber={1}".format(page_size, page) server_response = requests.get(paged_url, headers={'x-tableau-auth': auth_token}) _check_status(server_response, 200) xml_response = ET.fromstring(_encode_for_display(server_response.text)) projects.extend(xml_response.findall('.//t:project', namespaces=xmlns)) # Look through all projects to find the 'default' one for project in projects: if project.get('name') == 'default' or project.get('name') == 'Default': return project.get('id') raise LookupError("Project named 'default' was not found on server")
def initUI(self): """ Description: Simply shows the dialog Arguments: None Returns: Nothing """ global conf self.resize(450, 150) # About image filename = 'imgs/about.png' image = QImage(filename) imageLabel = QLabel() imageLabel.setPixmap(QPixmap.fromImage(image)) imageLabel.setAlignment(Qt.AlignCenter) # Labels for info lab_appname = QLabel("<font color='#0000FF'>" + _('apptitle') + ' ' + VERSION + "</font>") lab_appname.setAlignment(Qt.AlignLeft | Qt.AlignVCenter) lab_desc = QLabel(_('appdesc')) lab_desc.setAlignment(Qt.AlignLeft | Qt.AlignVCenter) lab_desc.setWordWrap(True) lab_author = QLabel(_('written_by') + ' nKn (<a href=\'http://github.com/nkovacne\'>http://github.com/nkovacne</a>)') lab_author.setAlignment(Qt.AlignLeft | Qt.AlignVCenter) lab_unoff = QLabel('<b>' + _('unofficial_project') + '</b>') lab_unoff.setAlignment(Qt.AlignLeft | Qt.AlignVCenter) lab_unoff.setWordWrap(True) # OK button okButton = QPushButton(_("ok")) okButton.setMaximumWidth(100) okButton.setDefault(True) okButton.clicked.connect(self.done) # Grid layout with all the elements grid = QGridLayout() grid.addWidget(imageLabel, 1, 0, 4, 1) # About image grid.addWidget(lab_appname, 1, 1, 1, 2) # Several QLabels grid.addWidget(lab_desc, 2, 1, 1, 2) grid.addWidget(lab_author, 3, 1, 1, 2) grid.addWidget(lab_unoff, 4, 1, 1, 2) grid.addWidget(okButton, 6, 1) # Button self.setLayout(grid) self.setModal(True) self.center() self.setWindowTitle(_('about')) self.show()
def __init__(self, server): print 'Logs will be written to %s' % self.LOG_FOLDER self.USERNAME = DEFAULT_USERNAME self.PASSWORD = DEFAULT_PASSWORD if not os.path.exists(self.LOG_FOLDER): os.makedirs(self.LOG_FOLDER) self.log_folder = self.LOG_FOLDER self.server = server self.hostname = socket.gethostname() self.ip = socket.gethostbyname(socket.gethostname()) self.container = JobContainer(self.log_folder, server) self.status_changed = True self.info = cpuinfo.get_cpu_info() self.s = requests.Session() self.first_update = True self.need_restart = False self.cpu_percent = 0.0 # Log File Logger self.logger = logging.getLogger('JobClientLogger') self.logger.setLevel(logging.DEBUG) handler = logging.FileHandler(os.path.join(self.log_folder, 'JobClient.log')) formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s") handler.setFormatter(formatter) self.logger.addHandler(handler) # Console handler ch = logging.StreamHandler() ch.setLevel(logging.INFO) self.logger.addHandler(ch) self.logger.info('Launching JobClient (Code Version %d)' % VERSION) try: import vhtrack self.cuda_device_count = vhtrack.query_cuda_device_count() except: self.cuda_device_count = 0 self.logger.info('%d CUDA GPU Detected' % self.cuda_device_count) self.available_job_classes = create_available_job_list(self.logger)
def phone_home(self): payload = { 'machine_name': self.hostname, 'ip_address': self.ip, 'status': 'accepting', 'restarted': self.first_update, 'code_version': VERSION, 'running_jobs': self.container.running_jobs.keys(), 'running_jobs_progress': [(key,self.container.running_jobs[key][1].status) for key in self.container.running_jobs], 'finished_jobs': [j.result for j in self.container.finished_jobs.values()], 'system' : platform.system(), 'system_bits' : self.info['bits'], 'cpu_brand' : self.info['brand'], 'cpu_cores' : self.info['count'], 'cuda_device_count' : self.cuda_device_count, 'available_jobs' : self.available_job_classes, 'cpu_percent' : self.cpu_percent } for j in payload['finished_jobs']: self.logger.info('Job Finished: %s' % (j)) r = self.s.post('%s/jobs/client_discover/' % self.server, json=payload, auth=(self.USERNAME, self.PASSWORD), verify=False) if (r.status_code==200): self.first_update = False # Purge local list of finished jobs for x in payload['finished_jobs']: del self.container.finished_jobs[x['job_id']] # Launch new jobs we just recieved try: data = r.json() if 'req_restart' in data and data['req_restart']: if not self.need_restart: self.logger.info('Received Restart Request') self.need_restart = True if 'jobs' in data: for new_job in data['jobs']: self.logger.info('Job recieved: #%d %s' % (new_job['job_id'], new_job['job_class'])) self.container.submit_job(**new_job) self.status_changed = True if 'jobs_to_kill' in data: for job_id in data['jobs_to_kill']: self.container.terminate_job(job_id) except Exception as e: self.logger.error('Recieved invalid data from server. %s' % e) else: self.logger.error("Unexpected return code while contacting server %s (%d)" % (self.server, r.status_code)) self.logger.error(r.text)
