def _sync_site_groups(self):
self.logger.debug('Revision groups on site')
ad_site_groups = [
g.name.value for g in self.ad.get_site_groups(self.site_name)
]
tableau_site_groups = [g.name for g in TSC.Pager(self.tab.groups)]
new_groups = set(ad_site_groups) - set(tableau_site_groups)
old_groups = set(tableau_site_groups) - set(ad_site_groups)
old_groups.remove('All Users')
# This ugly code, but I was forced to write this.
if self.site_name == 'ERS':
self.logger.info(f"Site ERS. Remove from old_groups F_* and A_*")
old_groups = [
t for t in old_groups
if not (t.startswith('F_') or t.startswith('A_'))
]
# End ugly code
if new_groups:
self.logger.info("New groups {0}".format(new_groups))
if old_groups:
self.logger.info("Old groups {0}".format(old_groups))
for group in new_groups:
new_group = TSC.GroupItem(group)
self.logger.info(f"Creating group {group}")
if self.noop:
self.tab.groups.create(new_group)
for group in old_groups:
group_id = [
g.id for g in TSC.Pager(self.tab.groups) if g.name == group
].pop()
self.logger.info(f"Removing group {group}")
if self.noop:
self.tab.groups.delete(group_id)
def _clear_site_from_user(self, ignore_tag, user_id):
self.lgr.debug(
f'Run _clear_site_from_user with ignore_tag:{ignore_tag}, group_id:{user_id}'
)
workbooks = [
w for w in list(TSC.Pager(self.tsc_server.workbooks))
if ignore_tag not in w.tags
]
for w in workbooks:
self.tsc_server.workbooks.populate_permissions(w)
for p in w.permissions:
if p.grantee.id == user_id and p.grantee.tag_name == 'user':
self.lgr.info(
f'Remove {str(p.capabilities)} permissions from wb: "{w.name}" , project: "{w.project_name})"'
)
if not self.noop:
self.tsc_server.workbooks.delete_permission(w, p)
datasources = [
d for d in list(TSC.Pager(self.tsc_server.datasources))
if ignore_tag not in d.tags
]
for d in datasources:
self.tsc_server.datasources.populate_permissions(d)
for p in d.permissions:
if p.grantee.id == user_id and p.grantee.tag_name == 'user':
self.lgr.info(
f'Remove {str(p.capabilities)} permissions from datasource: "{d.name}" , project: "{d.project_name})"'
)
if not self.noop:
self.tsc_server.datasources.delete_permission(w, p)
def show_materialized_views_status(args, password, site_content_url):
tableau_auth = TSC.TableauAuth(args.username,
password,
site_id=site_content_url)
server = TSC.Server(args.server, use_server_version=True)
enabled_sites = set()
with server.auth.sign_in(tableau_auth):
# For server admin, this will prints all the materialized views enabled sites
# For other users, this only prints the status of the site they belong to
print("Materialized views is enabled on sites:")
# only server admins can get all the sites in the server
# other users can only get the site they are in
for site in TSC.Pager(server.sites):
if site.materialized_views_mode != "disable":
enabled_sites.add(site)
print("Site name: {}".format(site.name))
print('\n')
print("Materialized views is enabled on workbooks:")
# Individual workbooks can be enabled only when the sites they belong to are enabled too
for site in enabled_sites:
site_auth = TSC.TableauAuth(args.username, password, site.content_url)
with server.auth.sign_in(site_auth):
for workbook in TSC.Pager(server.workbooks):
if workbook.materialized_views_config[
'materialized_views_enabled']:
print("Workbook: {} from site: {}".format(
workbook.name, site.name))
def update_project(project, server, materialized_views_config):
all_projects = list(TSC.Pager(server.projects))
project_ids = find_project_ids_to_update(all_projects, project)
for workbook in TSC.Pager(server.workbooks):
if workbook.project_id in project_ids:
workbook.materialized_views_config = materialized_views_config
server.workbooks.update(workbook)
print("Updated materialized views settings for project: {}".format(
project.name))
print('\n')
def _sync_site_memberships(self):
self.logger.debug('Revision group members on site')
tableau_groups = [g for g in TSC.Pager(self.tab.groups)]
opts = TSC.RequestOptions(pagesize=1000)
# This ugly code, but I was forced to write this.
if self.site_name == 'ERS':
self.logger.info(
"Site ERS. Remove from tableau_groups F_* and A_*")
tableau_groups = [
t for t in tableau_groups
if not (t.name.startswith('F_') or t.name.startswith('A_'))
]
# End ugly code
tableau_site_users = [u for u in TSC.Pager(self.tab.users)]
for group in [g for g in tableau_groups if g.name != 'All Users']:
self.tab.groups.populate_users(group, opts)
tableau_members_set = set([user.name for user in group.users])
ad_members = self.ad.get_members_by_groupname(group.name)
ad_members_set = set([u.sAMAccountName.value for u in ad_members])
new_members_set = ad_members_set - tableau_members_set
old_members_set = tableau_members_set - ad_members_set
if new_members_set:
self.logger.info("{0}, new members:{1} ".format(
group.name, new_members_set))
if old_members_set:
self.logger.info("{0}, old members{1}".format(
group.name, old_members_set))
for new_member in new_members_set:
self.logger.info(f"Adding {new_member} to {group.name}")
user_id = [
user.id for user in tableau_site_users
if user.name == new_member
]
if user_id:
if self.noop:
self.tab.groups.add_user(user_id=user_id.pop(),
group_item=group)
else:
self.logger.warning(
f"Can't add {new_member} to {group.name}. User not found"
)
for old_member in old_members_set:
self.logger.info(f"Removing {old_member} to {group.name}")
user_id = [
user.id for user in tableau_site_users
if user.name == old_member
].pop()
if self.noop:
self.tab.groups.remove_user(user_id=user_id,
group_item=group)
def update_project_by_path(args, materialized_views_config, password,
site_content_url):
if args.project_path is None:
print(
"Use --project_path <project path> to specify the path of the project"
)
return False
tableau_auth = TSC.TableauAuth(args.username, password, site_content_url)
server = TSC.Server(args.server, use_server_version=True)
project_name = args.project_path.split('/')[-1]
with server.auth.sign_in(tableau_auth):
if not assert_site_enabled_for_materialized_views(
server, site_content_url):
return False
projects = [
project for project in TSC.Pager(server.projects)
if project.name == project_name
]
if not assert_project_valid(args.project_path, projects):
return False
possible_paths = get_project_paths(server, projects)
update_project(possible_paths[args.project_path], server,
materialized_views_config)
return True
def publish_to_server(site_name, server_address, project_name, tdsx_name,
tableau_token_name, tableau_token):
'''Publishes updated, local .tdsx to Tableau, overwriting the original file.'''
# Creates the auth object based on the config file.
tableau_auth = TSC.PersonalAccessTokenAuth(
token_name=tableau_token_name,
personal_access_token=tableau_token,
site_id=site_name)
server = TSC.Server(server_address)
print(f"Signing into to site: {site_name}.")
# Signs in and find the specified project.
with server.auth.sign_in(tableau_auth):
all_projects, pagination_item = server.projects.get()
for project in TSC.Pager(server.projects):
if project.name == project_name:
project_id = project.id
if project_id == None:
message = "Could not find project. Please update the config file."
sys.exit(message)
print(f"Publishing to {project_name}.")
# Publishes the data source.
overwrite_true = TSC.Server.PublishMode.Overwrite
datasource = TSC.DatasourceItem(project_id)
file_path = os.path.join(os.getcwd(), tdsx_name)
datasource = server.datasources.publish(datasource, file_path,
overwrite_true)
print(f"Publishing of datasource '{tdsx_name}' complete.")
def get_datasources(tableau_server, tableau_authentication):
tableau_server.auth.sign_in(tableau_authentication)
df = pd.DataFrame()
for ds in TSC.Pager(tableau_server.datasources):
ls = [[
ds.id, ds.name, ds.certified, ds.project_name, ds.datasource_type
]]
df = df.append(pd.DataFrame(
ls, columns=['id', 'name', 'cert', 'project', 'ds_type']),
ignore_index=True)
tableau_server.auth.sign_out()
df = df[(df.ds_type == 'sqlserver') & (df.project == 'Datasource')]
ds_to_remove = [
# tds that point to procs, not views
'New E&M Provider Clarity',
'Patient Trajectory Clarity',
'CFIM Charges',
# embedded joins or custom sql; remove or recreate to use a view
'EBI_Call_Light (FI_DM_EBI)',
'Via Onc + Charges- Patient Level',
'Via Onc + Charges- Visit Level'
]
for ds in ds_to_remove:
df = df[df.name != ds]
df = df.reset_index().drop(['index'], axis=1)
return df.to_json()
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', 'view'])
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
}.get(args.resource_type)
for resource in TSC.Pager(endpoint.get):
print(resource.id, resource.name, resource.content_url)
def publish_hyper():
"""
Shows how to leverage the Tableau Server Client (TSC) to sign in and publish an extract directly to Tableau Online/Server
"""
# Sign in to server
tableau_auth = TSC.PersonalAccessTokenAuth(token_name=token_name, personal_access_token=token_value, site_id=site_name)
server = TSC.Server(server_address, use_server_version=True)
print(f"Signing into {site_name} at {server_address}")
with server.auth.sign_in(tableau_auth):
# Define publish mode - Overwrite, Append, or CreateNew
publish_mode = TSC.Server.PublishMode.Overwrite
# Get project_id from project_name
all_projects, pagination_item = server.projects.get()
for project in TSC.Pager(server.projects):
if project.name == project_name:
project_id = project.id
# Create the datasource object with the project_id
datasource = TSC.DatasourceItem(project_id)
print(f"Publishing {hyper_name} to {project_name}...")
# Publish datasource
datasource = server.datasources.publish(datasource, path_to_hyper, publish_mode)
print("Datasource published. Datasource ID: {0}".format(datasource.id))
def extract_ds(server, project):
datasources = {}
for ds in TSC.Pager(server.datasources.get):
if ds.project_name == project.name:
server.datasources.populate_connections(ds)
datasources[ds.name] = ds
return datasources
def main():
parser = argparse.ArgumentParser(description='Cancel all of the running background jobs.')
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)')
args = parser.parse_args()
if args.password is None:
password = getpass.getpass("Password: "******"progress", TSC.RequestOptions.Operator.LessThanOrEqual, 0))
for job in TSC.Pager(server.jobs, request_opts=req):
print(server.jobs.cancel(job.id), job.id, job.status, job.type)
def create_webhook(token, event_type):
tableau_auth = TSC.PersonalAccessTokenAuth(token_name=TABLEAU_TOKEN_NAME,
personal_access_token=token,
site_id=TABLEAU_SITE_NAME)
server = TSC.Server(TABLEAU_SERVER)
# Set http options to disable verifying SSL
server.add_http_options({'verify': False})
server.use_server_version()
with server.auth.sign_in_with_personal_access_token(tableau_auth):
new_webhook = TSC.WebhookItem()
new_webhook.name = "Webooks created from Heroku"
new_webhook.url = HEROKU_URL
new_webhook.event = event_type
# Check if identical webhook is already created
exists = False
for existing_webhook in TSC.Pager(server.webhooks):
exists = compare_webhook(new_webhook, existing_webhook)
if exists:
break
if not exists:
new_webhook = server.webhooks.create(new_webhook)
print("Webhook created: {}".format(new_webhook))
return True, new_webhook
else:
print("Webhook already exists: {}".format(new_webhook))
return False, new_webhook
def main():
parser = argparse.ArgumentParser(description="Cancel all of the running background jobs.")
# 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
# This sample has no additional options, yet. If you add some, please add them here
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):
req = TSC.RequestOptions()
req.filter.add(TSC.Filter("progress", TSC.RequestOptions.Operator.LessThanOrEqual, 0))
for job in TSC.Pager(server.jobs, request_opts=req):
print(server.jobs.cancel(job.id), job.id, job.status, job.type)
def update_workbook(args, materialized_views_config, password,
site_content_url):
if args.path_list is None and args.name_list is None:
print(
"Use '--path-list <filename>' or '--name-list <filename>' to specify the path of a list of workbooks"
)
print('\n')
return False
tableau_auth = TSC.TableauAuth(args.username,
password,
site_id=site_content_url)
server = TSC.Server(args.server, use_server_version=True)
with server.auth.sign_in(tableau_auth):
if not assert_site_enabled_for_materialized_views(
server, site_content_url):
return False
if args.path_list is not None:
workbook_path_mapping = parse_workbook_path(args.path_list)
all_projects = {
project.id: project
for project in TSC.Pager(server.projects)
}
update_workbooks_by_paths(all_projects, materialized_views_config,
server, workbook_path_mapping)
elif args.name_list is not None:
update_workbooks_by_names(args.name_list, server,
materialized_views_config)
return True
def update_project_by_name(args, materialized_views_config, password,
site_content_url):
if args.project_name is None:
print(
"Use --project-name <project name> to specify the name of the project"
)
return False
tableau_auth = TSC.TableauAuth(args.username, password, site_content_url)
server = TSC.Server(args.server, use_server_version=True)
with server.auth.sign_in(tableau_auth):
if not assert_site_enabled_for_materialized_views(
server, site_content_url):
return False
# get all projects with given name
projects = [
project for project in TSC.Pager(server.projects)
if project.name == args.project_name
]
if not assert_project_valid(args.project_name, projects):
return False
if len(projects) > 1:
possible_paths = get_project_paths(server, projects)
print("Project name is not unique, use '--project_path <path>'")
print("Possible project paths:")
print_paths(possible_paths)
print('\n')
return False
else:
update_project(projects[0], server, materialized_views_config)
return True
def test_pager_with_no_options(self):
with open(GET_XML_PAGE1, "rb") as f:
page_1 = f.read().decode("utf-8")
with open(GET_XML_PAGE2, "rb") as f:
page_2 = f.read().decode("utf-8")
with open(GET_XML_PAGE3, "rb") as f:
page_3 = f.read().decode("utf-8")
with requests_mock.mock() as m:
# Register Pager with default request options
m.get(self.baseurl, text=page_1)
# Register Pager with some pages
m.get(self.baseurl + "?pageNumber=1&pageSize=1", text=page_1)
m.get(self.baseurl + "?pageNumber=2&pageSize=1", text=page_2)
m.get(self.baseurl + "?pageNumber=3&pageSize=1", text=page_3)
# No options should get all 3
workbooks = list(TSC.Pager(self.server.workbooks))
self.assertTrue(len(workbooks) == 3)
# Let's check that workbook items aren't duplicates
wb1, wb2, wb3 = workbooks
self.assertEqual(wb1.name, "Page1Workbook")
self.assertEqual(wb2.name, "Page2Workbook")
self.assertEqual(wb3.name, "Page3Workbook")
def load_workbooks():
"""
:return:
"""
# authorize user
tableau_auth = TSC.TableauAuth(config.username, config.password)
# connect to server
server = TSC.Server(config.server_name)
with server.auth.sign_in(tableau_auth):
for wb in TSC.Pager(server.workbooks):
try:
path = server.workbooks.download(wb.id, filepath=config.twb_path)
# из коробки не сохраняет кирилицу - даём нормальное имя и на всякий случай удаляем расширение,
# т.к. не всегда оно сохраняется и заменяем слеши
wb_name = re.sub(r'\.twbx?', '', str(wb.name.encode('utf-8'))).replace('/', '\\')
os.rename(path, '{}{}'.format(config.twb_path, wb_name))
# если отчёт скачался вместе с экстрактом - выпиливаем экстракт
if zipfile.is_zipfile('{}{}'.format(config.twb_path, wb_name)):
os.rename('{}{}'.format(config.twb_path, wb_name), '{}{}.twbx'.format(config.twb_path, wb_name))
else:
os.rename('{}{}'.format(config.twb_path, wb_name), '{}{}.twb'.format(config.twb_path, wb_name))
except TSC.server.endpoint.exceptions.ServerResponseError:
pass
def update_all_workbook_connections(self,
curr_server_address,
curr_username,
new_server_address=None,
new_server_port=None,
new_username=None,
new_password=None,
new_embed_password: bool = None):
log.info('Updating "%s" Connections! server :' %
str(self.server.server_address))
for resource in TSC.Pager(self.server.workbooks):
self.server.workbooks.populate_connections(resource)
log.debug("Updating Connections for '%s' " % str(resource.name))
for conn in resource.connections:
if conn.server_address == curr_server_address and conn.username == curr_username:
log.info("Updating Connection " + str(conn))
if new_server_address is not None:
conn.server_address = new_server_address
if new_server_port is not None:
conn.server_port = new_server_port
if new_username is not None:
conn.username = new_username
if new_password is not None:
conn.password = new_password
if new_embed_password is not None:
conn.embed_password = True
self.server.workbooks.update_connection(resource, conn)
log.info(
'Updated Connection of "%s" server_address:%s username:%s '
% (resource.name, curr_server_address, curr_username))
def site_details(event, context, server, site, sites, workbooks, all_users,
unlicensed_users, unlicensed_usernames):
print('Retrieving site information for {} '.format(server.site_id))
try:
for wb in TSC.Pager(server.workbooks):
workbooks.append(wb)
users, _ = server.users.get()
#for user in TSC.Pager(server.users): (this needs a fix to the tableauserverclient)
for user in users:
all_users.append(user)
if user.site_role == 'Unlicensed':
unlicensed_users.append(user)
unlicensed_usernames.append({
'name': user.name,
'site': site.name,
'site_role': user.site_role
})
print(['{},{}'.format(user.site_role, user.name) for user in users])
for user in unlicensed_users:
print(user.name)
except:
print(' Site information failed!')
raise
else:
print(' Site information passed!')
finally:
print(' Site complete at {}'.format(str(datetime.now())))
def getSites(serverName):
sites = []
try:
# Step 1: Sign in to server.
if args.si:
tableau_auth = TSC.TableauAuth(args.u, password, site_id=args.si)
else:
tableau_auth = TSC.TableauAuth(args.u, password, site_id="")
server = TSC.Server(serverName)
server.add_http_options({'verify': False})
# The new endpoint was introduced in Version 2.4
server.version = APIVERSION
with server.auth.sign_in(tableau_auth):
# query the sites
if args.si:
sites.append(server.sites.get_by_name(args.si))
else:
sites.extend(list(TSC.Pager(server.sites)))
return sites
except Exception as e:
log.logger.error(f"{sys.exc_info()[0]}, {e}")
os._exit(1)
return False
def main():
parser = argparse.ArgumentParser(description='Demonstrate pagination on the list of workbooks on the server.')
# 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', '-n', 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
# This sample has no additional options, yet. If you add some, please add them here
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)
# Sign in to server
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):
# Pager returns a generator that yields one item at a time fetching
# from Server only when necessary. Pager takes a server Endpoint as its
# first parameter. It will call 'get' on that endpoint. To get workbooks
# pass `server.workbooks`, to get users pass` server.users`, etc
# You can then loop over the generator to get the objects one at a time
# Here we print the workbook id for each workbook
print("Your server contains the following workbooks:\n")
for wb in TSC.Pager(server.workbooks):
print(wb.name)
def main():
parser = argparse.ArgumentParser(description='List out the names and LUIDs for different resource types.')
# 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', '-n', 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', 'project', 'view', 'job', 'webhooks'])
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)
# Sign in to server
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,
'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 get_workbook_group(server, tableau_auth):
with server.auth.sign_in(tableau_auth):
all_workbooks_items, pagination_item = server.workbooks.get()
abc = []
for workbook in all_workbooks_items:
print(workbook.name)
ds = server.workbooks.get_by_id(workbook.id)
server.workbooks.populate_permissions(ds)
permissions = ds.permissions
i = -1
for rule in permissions:
i += 1
group_user_type = permissions[i].grantee.tag_name
group_user_id = permissions[i].grantee.id
group_user_capabilities = permissions[i].capabilities
if group_user_type == 'user':
user_item = server.users.get_by_id(
permissions[i].grantee.id)
group_user_name = user_item.name
elif group_user_type == 'group':
for group_item in TSC.Pager(server.groups):
if group_item.id == group_user_id:
group_user_name = group_item.name
break
# print('Type: %s\tName: %s\tCapabilities: %s' %(group_user_type, group_user_name, group_user_capabilities))
abc.append([
workbook.name, group_user_type, group_user_name,
group_user_capabilities
])
abc = pd.DataFrame(abc)
abc.columns = [
'workbook_name', 'group_type', 'user_name', 'capabilities'
]
return abc
def list_workbook_ids(self,
checkpoint: Union[datetime, str] = None,
limit: int = None) -> List[str]:
# Create client filter object
req_option = tsc.RequestOptions()
req_option.sort.add(
tsc.Sort(tsc.RequestOptions.Field.UpdatedAt,
tsc.RequestOptions.Direction.Asc))
if checkpoint:
# Format datetime for filter
if isinstance(checkpoint, datetime):
cp = self.format_checkpoint_datetime(checkpoint)
else:
cp = self.format_checkpoint_datetime(parse(checkpoint))
req_option.filter.add(
tsc.Filter(tsc.RequestOptions.Field.UpdatedAt,
tsc.RequestOptions.Operator.GreaterThanOrEqual, cp))
# Get filtered id's
server = self.server
with server.auth.sign_in(self.authentication):
workbook_ids = [
wb.id for wb in tsc.Pager(server.workbooks, req_option)
]
else:
# Get all workbook id's
workbook_ids = self.list_all_workbook_ids()
# Return, with optional applied limit
if limit:
return workbook_ids[:limit]
else:
return workbook_ids
def __get_flow_item(self, flow_name, project_name=None):
item = None
items_list = list()
if not self.all_flows:
self.all_flows = list(TSC.Pager(self.tsclient.flows))
for fl in self.all_flows:
if project_name:
if fl.project_name == project_name and fl.name == flow_name:
item = fl
else:
if fl.name == flow_name:
item = fl
items_list.append(fl)
if len(items_list) > 1:
raise LookupError(
f'More than one flow matched to: {flow_name}. Please specify Project Name for Distinct Match'
)
if item:
return item
else:
raise LookupError(
f'Prep Flow with the specified name was not found: {flow_name}'
)
def __get_datasource_item(self, datasource_name, project_name=None):
item = None
items_list = list()
if not self.all_datasources:
self.all_datasources = list(TSC.Pager(self.tsclient.datasources))
for ds in self.all_datasources:
if project_name:
if ds.project_name == project_name and ds.name == datasource_name:
item = ds
else:
if ds.name == datasource_name:
item = ds
items_list.append(ds)
if len(items_list) > 1:
raise LookupError(
f'More than one datasource matched to: {datasource_name}. Please specify Project Name for Distinct Match'
)
if item:
return item
else:
raise LookupError(
f'Datasource with the specified name was not found: {datasource_name}'
)
def __get_workbook_item(self, workbook_name, project_name=None):
workbook_item = None
items_list = list()
if not self.all_workbooks:
self.all_workbooks = list(TSC.Pager(self.tsclient.workbooks))
for wb in self.all_workbooks:
if project_name:
if wb.project_name == project_name and wb.name == workbook_name:
workbook_item = wb
else:
if wb.name == workbook_name:
workbook_item = wb
items_list.append(wb)
if len(items_list) > 1:
raise LookupError(
f'More than one workbook matched to: {workbook_name}. Please specify Project Name for Distinct Match'
)
if workbook_item:
return workbook_item
else:
raise LookupError(
f'Workbook with the specified name was not found: {workbook_name}'
)
def _get_group_id_by_name(self, name):
groups = [
g.id for g in list(TSC.Pager(self.tsc_server.groups))
if g.name == name
]
if groups:
return groups.pop()
return None
def _get_user_id_by_name(self, name):
users = [
i.id for i in list(TSC.Pager(self.tsc_server.users))
if i.name == name
]
if users:
return users.pop()
return None
