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)
