def setUp(self): self.server = TSC.Server('http://test') # Fake signin self.server._site_id = 'dad65087-b08b-4603-af4e-2887b8aafc67' self.server._auth_token = 'j80k54ll2lfMZ0tv97mlPvvSCRyD0DOM' self.baseurl = self.server.groups.baseurl
def setUp(self) -> None: self.server = TSC.Server("http://test", False) # Fake signin self.server._site_id = "dad65087-b08b-4603-af4e-2887b8aafc67" self.server._auth_token = "j80k54ll2lfMZ0tv97mlPvvSCRyD0DOM" self.baseurl = self.server.projects.baseurl
def setUp(self): self.server = TSC.Server('http://test') self.server.version = "3.10" # Fake signin self.server._auth_token = 'j80k54ll2lfMZ0tv97mlPvvSCRyD0DOM' self.server._site_id = '0626857c-1def-4503-a7d8-7907c3ff9d9f' self.baseurl = self.server.sites.baseurl
def setUp(self) -> None: self.server = TSC.Server("http://test", False) self.server.version = "3.10" # Fake signin self.server._auth_token = "j80k54ll2lfMZ0tv97mlPvvSCRyD0DOM" self.server._site_id = "0626857c-1def-4503-a7d8-7907c3ff9d9f" self.baseurl = self.server.sites.baseurl
def setUp(self): self.server = TSC.Server("http://test") # Fake Signin self.server._site_id = "dad65087-b08b-4603-af4e-2887b8aafc67" self.server._auth_token = "j80k54ll2lfMZ0tv97mlPvvSCRyD0DOM" self.baseurl = self.server.schedules.baseurl
def open(self, schema): print('INFO: Given data schema {}'.format(schema)) tableau_auth = TSC.TableauAuth(self.username, self.password, site_id=self.site_id) server = TSC.Server(self.server_url, use_server_version=True) print('Using Tableau server version {}'.format(server.version)) s_info = server.server_info.get() print("\nServer info:") print("\tProduct version: {0}".format(s_info.product_version)) print("\tREST API version: {0}".format(s_info.rest_api_version)) print("\tBuild number: {0}".format(s_info.build_number)) server.auth.sign_in(tableau_auth) all_project_items, pagination_item = server.projects.get() project_match = [ proj for proj in all_project_items if proj.name.encode('utf-8') == self.project_name_utf8 ] if len(project_match) > 0: self.project = project_match[0] print('Found project matching {} with id {}'.format( self.project.name.encode('utf8'), self.project.id)) else: #when project is not matched we want to print all accessible projects names for debugging server_project_names = [ proj.name.encode('utf-8') for proj in all_project_items ] print( 'ERROR: No project matches, projects accessible on server are: {}' .format(server_project_names)) raise ValueError('Project {} does not exist on server'.format( self.project_name_utf8)) all_datasources, pagination_item = server.datasources.get() datasource_match = [ d for d in all_datasources if d.name.encode('utf-8') == self.output_table_utf8 ] if len(datasource_match) > 0: self.datasource = datasource_match[0] print( 'WARN: Found existing table {} with id {}, will be overwritten' .format(self.datasource.name.encode('utf-8'), self.datasource.id)) server.auth.sign_out() # Fairly ugly. We create and delete a temporary file while retaining its name with tempfile.NamedTemporaryFile(prefix="output", suffix=".hyper", dir=os.getcwd()) as f: self.output_file = f.name print("Tmp file: {}".format(self.output_file)) self.e = TableauExport(self.output_file, schema['columns'])
def main(): parser = argparse.ArgumentParser(description='Publish a workbook to server.') parser.add_argument('--server', '-s', required=True, help='server address') parser.add_argument('--username', '-u', required=True, help='username to sign into server') parser.add_argument('--filepath', '-f', required=True, help='computer filepath of the workbook to publish') parser.add_argument('--logging-level', '-l', choices=['debug', 'info', 'error'], default='error', help='desired logging level (set to error by default)') parser.add_argument('--as-job', '-a', help='Publishing asynchronously', action='store_true') parser.add_argument('--site', '-S', default='', help='id (contentUrl) of site to sign into') args = parser.parse_args() password = getpass.getpass("Password: "******"mssql.test.com" connection1.connection_credentials = ConnectionCredentials("test", "password", True) connection2 = ConnectionItem() connection2.server_address = "postgres.test.com" connection2.server_port = "5432" connection2.connection_credentials = ConnectionCredentials("test", "password", True) all_connections = list() all_connections.append(connection1) all_connections.append(connection2) # Step 3: If default project is found, form a new workbook item and publish. if default_project is not None: new_workbook = TSC.WorkbookItem(default_project.id) if args.as_job: new_job = server.workbooks.publish(new_workbook, args.filepath, overwrite_true, connections=all_connections, as_job=args.as_job) print("Workbook published. JOB ID: {0}".format(new_job.id)) else: new_workbook = server.workbooks.publish(new_workbook, args.filepath, overwrite_true, connections=all_connections, as_job=args.as_job) print("Workbook published. ID: {0}".format(new_workbook.id)) else: error = "The default project could not be found." raise LookupError(error)
def main(): parser = argparse.ArgumentParser( description= "Update a connection on a datasource or workbook to embed credentials") # Common options; please keep those in sync across all samples parser.add_argument("--server", "-s", required=True, help="server address") parser.add_argument("--site", "-S", help="site name") parser.add_argument( "--token-name", "-p", required=True, help="name of the personal access token used to sign into the server") parser.add_argument( "--token-value", "-v", required=True, help="value of the personal access token used to sign into the server") parser.add_argument( "--logging-level", "-l", choices=["debug", "info", "error"], default="error", help="desired logging level (set to error by default)", ) # Options specific to this sample parser.add_argument("resource_type", choices=["workbook", "datasource"]) parser.add_argument("resource_id") parser.add_argument("connection_id") parser.add_argument("datasource_username") parser.add_argument("datasource_password") args = parser.parse_args() # Set logging level based on user input, or error by default logging_level = getattr(logging, args.logging_level.upper()) logging.basicConfig(level=logging_level) tableau_auth = TSC.PersonalAccessTokenAuth(args.token_name, args.token_value, site_id=args.site) server = TSC.Server(args.server, use_server_version=True) with server.auth.sign_in(tableau_auth): endpoint = { "workbook": server.workbooks, "datasource": server.datasources }.get(args.resource_type) update_function = endpoint.update_connection resource = endpoint.get_by_id(args.resource_id) endpoint.populate_connections(resource) connections = list( filter(lambda x: x.id == args.connection_id, resource.connections)) assert len(connections) == 1 connection = connections[0] connection.username = args.datasource_username connection.password = args.datasource_password connection.embed_password = True print(update_function(resource, connection).__dict__)
def publishToTableau(self): tableau_auth = TSC.TableauAuth(TABLEAU_USER, TABLEAU_PASSWORD) # tableau_auth = TSC.PersonalAccessTokenAuth('TOKEN_NAME','TOKEN_VALUE') server = TSC.Server(TABLEAU_SERVER) with server.auth.sign_in(tableau_auth): wb_item = TSC.WorkbookItem(name=self.wb_name, project_id="") wb_item = server.workbooks.publish(wb_item, self.wb_name + ".twbx", 'Overwrite') print(wb_item.name)
def main(): parser = argparse.ArgumentParser( description='List out the names and LUIDs for different resource types.' ) parser.add_argument('--server', '-s', required=True, help='server address') parser.add_argument( '--site', '-S', default="", help='site to log into, do not specify for default site') parser.add_argument('--token-name', '-n', required=True, help='username to signin under') parser.add_argument('--token', '-t', help='personal access token for logging in') parser.add_argument('--logging-level', '-l', choices=['debug', 'info', 'error'], default='error', help='desired logging level (set to error by default)') parser.add_argument('resource_type', choices=[ 'workbook', 'datasource', 'project', 'view', 'job', 'webhooks' ]) args = parser.parse_args() token = os.environ.get('TOKEN', args.token) if not token: print("--token or TOKEN environment variable needs to be set") sys.exit(1) # Set logging level based on user input, or error by default logging_level = getattr(logging, args.logging_level.upper()) logging.basicConfig(level=logging_level) # SIGN IN tableau_auth = TSC.PersonalAccessTokenAuth(args.token_name, token, site_id=args.site) server = TSC.Server(args.server, use_server_version=True) with server.auth.sign_in(tableau_auth): endpoint = { 'workbook': server.workbooks, 'datasource': server.datasources, 'view': server.views, 'job': server.jobs, 'project': server.projects, 'webhooks': server.webhooks, }.get(args.resource_type) for resource in TSC.Pager(endpoint.get): print(resource.id, resource.name)
def setUp(self) -> None: self.server = TSC.Server("http://test", False) self.server.version = "2.6" # Fake Signin self.server._site_id = "dad65087-b08b-4603-af4e-2887b8aafc67" self.server._auth_token = "j80k54ll2lfMZ0tv97mlPvvSCRyD0DOM" self.baseurl = self.server.subscriptions.baseurl
def setUp(self): self.server = TSC.Server('http://test') # Fake signin self.server._site_id = 'dad65087-b08b-4603-af4e-2887b8aafc67' self.server._auth_token = 'j80k54ll2lfMZ0tv97mlPvvSCRyD0DOM' self.server.version = "3.8" self.baseurl = self.server.data_acceleration_report.baseurl
def __init__(self, url, username, password, noop: bool = True): self.noop = noop self.lgr = logging.getLogger('main.TableauPermissionCleaner') if self.noop: self.lgr.warning('NOOP MODE') self.lgr.debug(f'__init__ url:{url}, username:{username}') self.user = username self.pwd = password self.tsc_server = TSC.Server(server_address=url)
def login(self, srvr, un, pw): """login to server""" server = TSC.Server(srvr) print(type(server)) auth = TSC.TableauAuth(un, pw) print(type(auth)) self._server_information.update({"Server": [srvr, server]}) self._server_information.update({"USER": un}) print(type(server.auth.sign_in(auth)))
def __init__(self, username: str, password: str, site: str = 'gradeup', server_url: str = 'https://eu-west-1a.online.tableau.com', api_version: str = '2.6') -> None: self.tableau_auth = TSC.TableauAuth(username, password, site_id=site) self.server = TSC.Server(server_url) self.server.version = api_version
def main(): # Get parsed arguments args = get_args() # Prompt the user to enter the password if args.p is None: password = getpass.getpass("Password: "******"" tableau_auth = TSC.TableauAuth(args.username, password, site_id=site_id) server = TSC.Server(args.server) # The new endpoint was introduced in Version 2.5 server.version = "2.8" # at least 2.5 for exporting a view image, 2.8 for exporting csv file with server.auth.sign_in(tableau_auth): # Step 2: Query for the view that we want an image/csv of req_option = TSC.RequestOptions() req_option.filter.add( TSC.Filter(TSC.RequestOptions.Field.Name, TSC.RequestOptions.Operator.Equals, args.view_name)) all_views, pagination_item = server.views.get(req_option) if not all_views: raise LookupError("View with the specified name was not found.") view_item = all_views[0] (populate_func_name, option_factory_name, member_name, extension) = args.type populate = getattr(server.views, populate_func_name) option_factory = getattr(TSC, option_factory_name) if args.filter: options = option_factory().vf(*args.filter.split(':')) else: options = None if args.file: filename = args.file else: filename = 'out.{}'.format(extension) populate(view_item, options) # Step 3: Export the file to the specified path/filename with open(filename, 'wb') as f: if member_name == 'csv': f.writelines(getattr(view_item, member_name)) else: f.write(getattr(view_item, member_name))
def setUp(self): self.server = TSC.Server('http://test') # Fake signin self.server._site_id = 'dad65087-b08b-4603-af4e-2887b8aafc67' self.server._auth_token = 'j80k54ll2lfMZ0tv97mlPvvSCRyD0DOM' self.baseurl = '{0}/{1}'.format(self.server.sites._construct_url(), self.server._site_id)
def main(): parser = argparse.ArgumentParser( description= 'Update a connection on a datasource or workbook to embed credentials') # Common options; please keep those in sync across all samples parser.add_argument('--server', '-s', required=True, help='server address') parser.add_argument('--site', '-S', help='site name') parser.add_argument( '--token-name', '-p', required=True, help='name of the personal access token used to sign into the server') parser.add_argument( '--token-value', '-v', required=True, help='value of the personal access token used to sign into the server') parser.add_argument('--logging-level', '-l', choices=['debug', 'info', 'error'], default='error', help='desired logging level (set to error by default)') # Options specific to this sample parser.add_argument('resource_type', choices=['workbook', 'datasource']) parser.add_argument('resource_id') parser.add_argument('connection_id') parser.add_argument('datasource_username') parser.add_argument('datasource_password') args = parser.parse_args() # Set logging level based on user input, or error by default logging_level = getattr(logging, args.logging_level.upper()) logging.basicConfig(level=logging_level) tableau_auth = TSC.PersonalAccessTokenAuth(args.token_name, args.token_value, site_id=args.site) server = TSC.Server(args.server, use_server_version=True) with server.auth.sign_in(tableau_auth): endpoint = { 'workbook': server.workbooks, 'datasource': server.datasources }.get(args.resource_type) update_function = endpoint.update_connection resource = endpoint.get_by_id(args.resource_id) endpoint.populate_connections(resource) connections = list( filter(lambda x: x.id == args.connection_id, resource.connections)) assert (len(connections) == 1) connection = connections[0] connection.username = args.datasource_username connection.password = args.datasource_password connection.embed_password = True print(update_function(resource, connection).__dict__)
def main(): parser = argparse.ArgumentParser(description='Creates sample schedules for each type of frequency.') parser.add_argument('--server', '-s', required=True, help='server address') parser.add_argument('--username', '-u', required=True, help='username to sign into server') parser.add_argument('--logging-level', '-l', choices=['debug', 'info', 'error'], default='error', help='desired logging level (set to error by default)') args = parser.parse_args() password = getpass.getpass("Password: "******"Hourly-Schedule", 50, TSC.ScheduleItem.Type.Extract, TSC.ScheduleItem.ExecutionOrder.Parallel, hourly_interval) hourly_schedule = server.schedules.create(hourly_schedule) print("Hourly schedule created (ID: {}).".format(hourly_schedule.id)) # Daily Schedule # This schedule will run every day at 5AM daily_interval = TSC.DailyInterval(start_time=time(5)) daily_schedule = TSC.ScheduleItem("Daily-Schedule", 60, TSC.ScheduleItem.Type.Subscription, TSC.ScheduleItem.ExecutionOrder.Serial, daily_interval) daily_schedule = server.schedules.create(daily_schedule) print("Daily schedule created (ID: {}).".format(daily_schedule.id)) # Weekly Schedule # This schedule will wun every Monday, Wednesday, and Friday at 7:15PM weekly_interval = TSC.WeeklyInterval(time(19, 15), TSC.IntervalItem.Day.Monday, TSC.IntervalItem.Day.Wednesday, TSC.IntervalItem.Day.Friday) weekly_schedule = TSC.ScheduleItem("Weekly-Schedule", 70, TSC.ScheduleItem.Type.Extract, TSC.ScheduleItem.ExecutionOrder.Serial, weekly_interval) weekly_schedule = server.schedules.create(weekly_schedule) print("Weekly schedule created (ID: {}).".format(weekly_schedule.id)) # Monthly Schedule # This schedule will run on the 15th of every month at 11:30PM monthly_interval = TSC.MonthlyInterval(start_time=time(23, 30), interval_value=15) monthly_schedule = TSC.ScheduleItem("Monthly-Schedule", 80, TSC.ScheduleItem.Type.Subscription, TSC.ScheduleItem.ExecutionOrder.Parallel, monthly_interval) monthly_schedule = server.schedules.create(monthly_schedule) print("Monthly schedule created (ID: {}).".format(monthly_schedule.id))
def lambda_handler(event, context): SERVER_URL = "http://ec2-35-163-18-44.us-west-2.compute.amazonaws.com" SERVER_USER = '******' SERVER_PASS = '******' ec2 = boto3.client('ec2') instances = ec2.describe_instances(Filters=[{ 'Name': 'tag:serverprimary', 'Values': ['true'] }]) url = instances['Reservations'][0]['Instances'][0]['PublicDnsName'] id = instances['Reservations'][0]['Instances'][0]['InstanceId'] print(SERVER_URL) SERVER_URL = "http://" + url print(SERVER_URL) sites = [] workbooks = [] all_users = [] unlicensed_users = [] unlicensed_usernames = [] print('Retrieving information from {} as {}'.format( SERVER_URL, SERVER_USER)) try: authz = TSC.TableauAuth(SERVER_USER, SERVER_PASS) server = TSC.Server(SERVER_URL) server.version = '2.4' with server.auth.sign_in(authz): info = server.server_info.get() sites, _ = server.sites.get() for site in sites: print('Site information: ', site.name, site.id, site.content_url) authz.site_id = site.content_url print(authz.site_id) with server.auth.sign_in(authz): site_details(event, context, server, site, sites, workbooks, all_users, unlicensed_users, unlicensed_usernames) serverinfo = { 'user_count': len(all_users), 'unlicensed_count': len(unlicensed_users), 'unlicensed': unlicensed_usernames, 'tableau_version': info.product_version, 'rest_api': info.rest_api_version, 'workbooks': len(workbooks) } print(info.product_version) print(info.rest_api_version) except: print(' Server information failed!') raise else: print(' Server information passed!') print(serverinfo) return (serverinfo) finally: print(' Server complete at {}'.format(str(datetime.now())))
def main(): parser = argparse.ArgumentParser( description='Export to PDF all of the views in a workbook.') parser.add_argument('--server', '-s', required=True, help='server address') parser.add_argument( '--site', '-S', default=None, help='Site to log into, do not specify for default site') parser.add_argument('--username', '-u', required=True, help='username to sign into server') parser.add_argument('--password', '-p', default=None, help='password for the user') parser.add_argument('--logging-level', '-l', choices=['debug', 'info', 'error'], default='error', help='desired logging level (set to error by default)') parser.add_argument('--file', '-f', default='out.pdf', help='filename to store the exported data') parser.add_argument('resource_id', help='LUID for the workbook') args = parser.parse_args() if args.password is None: password = getpass.getpass("Password: "******"Saving to tempdir: %s", tempdir) tableau_auth = TSC.TableauAuth(args.username, password, args.site) server = TSC.Server(args.server, use_server_version=True) try: with server.auth.sign_in(tableau_auth): get_list = functools.partial(get_views_for_workbook, server) download = functools.partial(download_pdf, server, tempdir) downloaded = (download(x) for x in get_list(args.resource_id)) output = reduce(combine_into, downloaded, PyPDF2.PdfFileMerger()) with file(args.file, 'wb') as f: output.write(f) finally: cleanup(tempdir)
def kill_job(**context): tb_job_id = context['task_instance'].xcom_pull(task_ids='get_job_id') ebi = get_json_secret('ebi_db_conn')['db_connections']['fi_dm_ebi'] auth = TSC.TableauAuth(ebi['user'].split(sep='\\')[1], ebi['password']) server = TSC.Server(Variable.get('tableau_server_url'), use_server_version=True) server.auth.sign_in(auth) resp = server.jobs.cancel(tb_job_id) server.auth.sign_out()
def getServerInstance(serverUrl, user, pwd, site): tableau_auth = TSC.TableauAuth(user, pwd, site) server = TSC.Server(serverUrl) # requestOptions = TSC.RequestOptions(pagesize=1000) server.add_http_options({'verify': False}) #sign in server.auth.sign_in(tableau_auth) header("\nSuccessfully authenticated {} to {} ".format( user, server.baseurl)) return server
def setUp(self): self.server = TSC.Server("http://test", False) self.server.version = "3.2" # Fake sign in self.server._site_id = "dad65087-b08b-4603-af4e-2887b8aafc67" self.server._auth_token = "j80k54ll2lfMZ0tv97mlPvvSCRyD0DOM" self.baseurl = self.server.views.baseurl self.siteurl = self.server.views.siteurl
def setUp(self) -> None: self.server = TSC.Server("http://test", False) # Fake signin self.server.version = "3.10" self.server._site_id = "dad65087-b08b-4603-af4e-2887b8aafc67" self.server._auth_token = "j80k54ll2lfMZ0tv97mlPvvSCRyD0DOM" self.baseurl = "{0}/{1}".format(self.server.sites.baseurl, self.server._site_id)
def __init__(self): TABLEAU_USER = getenv("TABLEAU_USER") TABLEAU_PWD = getenv("TABLEAU_PWD") TABLEAU_SITENAME = getenv("TABLEAU_SITENAME") TABLEAU_SERVER_URL = getenv("TABLEAU_SERVER_URL") self.tableau_auth = TSC.TableauAuth(TABLEAU_USER, TABLEAU_PWD, TABLEAU_SITENAME) self.server = TSC.Server(TABLEAU_SERVER_URL) self.domain = getenv("TABLEAU_DOMAIN") self.server.version = "2.8"
def setUp(self): self.server = TSC.Server("http://test", False) self.server.version = "3.8" # Fake Signin self.server._site_id = "dad65087-b08b-4603-af4e-2887b8aafc67" self.server._auth_token = "j80k54ll2lfMZ0tv97mlPvvSCRyD0DOM" # default task type is extractRefreshes self.baseurl = "{}/{}".format(self.server.tasks.baseurl, "extractRefreshes")
def main(): parser = argparse.ArgumentParser( description= 'Update a connection on a datasource or workbook to embed credentials') parser.add_argument('--server', '-s', required=True, help='server address') parser.add_argument('--username', '-u', required=True, help='username to sign into server') parser.add_argument('--site', '-S', default=None) parser.add_argument('-p', default=None) parser.add_argument('--logging-level', '-l', choices=['debug', 'info', 'error'], default='error', help='desired logging level (set to error by default)') parser.add_argument('resource_type', choices=['workbook', 'datasource']) parser.add_argument('resource_id') parser.add_argument('connection_id') parser.add_argument('datasource_username') parser.add_argument('datasource_password') args = parser.parse_args() if args.p is None: password = getpass.getpass("Password: ") else: password = args.p # Set logging level based on user input, or error by default logging_level = getattr(logging, args.logging_level.upper()) logging.basicConfig(level=logging_level) # SIGN IN tableau_auth = TSC.TableauAuth(args.username, password, args.site) server = TSC.Server(args.server, use_server_version=True) with server.auth.sign_in(tableau_auth): endpoint = { 'workbook': server.workbooks, 'datasource': server.datasources }.get(args.resource_type) update_function = endpoint.update_connection resource = endpoint.get_by_id(args.resource_id) endpoint.populate_connections(resource) connections = list( filter(lambda x: x.id == args.connection_id, resource.connections)) assert (len(connections) == 1) connection = connections[0] connection.username = args.datasource_username connection.password = args.datasource_password connection.embed_password = True print(update_function(resource, connection).content)
def main(): parser = argparse.ArgumentParser(description='Logs in to the server.') # This command is special, as it doesn't take `token-value` and it offer both token-based and password based authentication. # Please still try to keep common options like `server` and `site` consistent across samples # Common options: parser.add_argument('--server', '-s', required=True, help='server address') parser.add_argument('--site', '-S', help='site name') parser.add_argument('--logging-level', '-l', choices=['debug', 'info', 'error'], default='error', help='desired logging level (set to error by default)') # Options specific to this sample group = parser.add_mutually_exclusive_group(required=True) group.add_argument('--username', '-u', help='username to sign into the server') group.add_argument( '--token-name', '-n', help='name of the personal access token used to sign into the server') args = parser.parse_args() # Set logging level based on user input, or error by default. logging_level = getattr(logging, args.logging_level.upper()) logging.basicConfig(level=logging_level) # Make sure we use an updated version of the rest apis. server = TSC.Server(args.server, use_server_version=True) if args.username: # Trying to authenticate using username and password. password = getpass.getpass("Password: "******"\nSigning in...\nServer: {}\nSite: {}\nUsername: {}".format( args.server, args.site, args.username)) tableau_auth = TSC.TableauAuth(args.username, password, site_id=args.site) with server.auth.sign_in(tableau_auth): print('Logged in successfully') else: # Trying to authenticate using personal access tokens. personal_access_token = getpass.getpass("Personal Access Token: ") print("\nSigning in...\nServer: {}\nSite: {}\nToken name: {}".format( args.server, args.site, args.token_name)) tableau_auth = TSC.PersonalAccessTokenAuth( token_name=args.token_name, personal_access_token=personal_access_token, site_id=args.site) with server.auth.sign_in_with_personal_access_token(tableau_auth): print('Logged in successfully')
def main(): parser = argparse.ArgumentParser( description='List out the names and LUIDs for different resource types' ) parser.add_argument('--server', '-s', required=True, help='server address') parser.add_argument( '--site', '-S', default=None, help='site to log into, do not specify for default site') parser.add_argument('--username', '-u', required=True, help='username to sign into server') parser.add_argument('--password', '-p', default=None, help='password for the user') parser.add_argument('--logging-level', '-l', choices=['debug', 'info', 'error'], default='error', help='desired logging level (set to error by default)') parser.add_argument( 'resource_type', choices=['workbook', 'datasource', 'project', 'view', 'job']) args = parser.parse_args() if args.password is None: password = getpass.getpass("Password: ") else: password = args.password # Set logging level based on user input, or error by default logging_level = getattr(logging, args.logging_level.upper()) logging.basicConfig(level=logging_level) # SIGN IN tableau_auth = TSC.TableauAuth(args.username, password, args.site) server = TSC.Server(args.server, use_server_version=True) with server.auth.sign_in(tableau_auth): endpoint = { 'workbook': server.workbooks, 'datasource': server.datasources, 'view': server.views, 'job': server.jobs, 'project': server.projects, }.get(args.resource_type) for resource in TSC.Pager(endpoint.get): print(resource.id, resource.name)