diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml
index 4df1778..01d3d3a 100644
--- a/.github/workflows/python-package.yml
+++ b/.github/workflows/python-package.yml
@@ -32,6 +32,10 @@ jobs:
flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
# exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
+ - name: Run Pytest on the tests in tests/
+ run:
+ pytest tests/ -p no:warnings -vv
- name: Run pytest on tableau-utilities
run: |
cd tableau_utilities && pytest -v
+
diff --git a/.gitignore b/.gitignore
index bcbe97d..e6ca506 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,6 +4,7 @@ sheets.googleapis.com-python.json
.idea
.DS_Store
tmp_tdsx_and_config/
+development_test_files/
# Byte-compiled / optimized / DLL files
__pycache__/
diff --git a/README.md b/README.md
index c3d536e..bc7e9f4 100644
--- a/README.md
+++ b/README.md
@@ -20,6 +20,7 @@ This extra package depends on the tableauhyperapi which is incompatible with App
#### Locally using pip
- `cd tableau-utilities`
- `pip install ./`
+- `pip install --upgrade ./` to overwrite the existing installation without having to uninstall first
#### Confirm installation
- `which tableau_utilities`
diff --git a/airflow_example/dags/tableau_datasource_update/tableau_datasource_update.py b/airflow_example/dags/tableau_datasource_update/tableau_datasource_update.py
index 7d38f40..d740ae1 100644
--- a/airflow_example/dags/tableau_datasource_update/tableau_datasource_update.py
+++ b/airflow_example/dags/tableau_datasource_update/tableau_datasource_update.py
@@ -314,54 +314,54 @@ def __compare_folders(self, datasource_id, tds_folders, cfg_folders):
def execute(self, context):
""" Update Tableau datasource according to config. """
- github_conn = BaseHook.get_connection(self.github_conn_id)
- config = cfg.Config(
- githup_token=github_conn.password,
- repo_name=github_conn.extra_dejson.get('repo_name'),
- repo_branch=github_conn.extra_dejson.get('repo_branch'),
- subfolder=github_conn.extra_dejson.get('subfolder')
- )
-
- ts = get_tableau_server(self.tableau_conn_id)
- expected_conn_attrs = self.__set_connection_attributes()
-
- # Get the ID for each datasource in the config
- for ds in ts.get.datasources():
- if ds not in config.datasources:
- continue
- config.datasources[ds].id = ds.id
-
- for datasource in config.datasources:
- if not datasource.id:
- logging.error('!! Datasource not found in Tableau Online: %s / %s',
- datasource.project_name, datasource.name)
- continue
- dsid = datasource.id
+ # github_conn = BaseHook.get_connection(self.github_conn_id)
+ # config = cfg.Config(
+ # githup_token=github_conn.password,
+ # repo_name=github_conn.extra_dejson.get('repo_name'),
+ # repo_branch=github_conn.extra_dejson.get('repo_branch'),
+ # subfolder=github_conn.extra_dejson.get('subfolder')
+ # )
+ #
+ # ts = get_tableau_server(self.tableau_conn_id)
+ # expected_conn_attrs = self.__set_connection_attributes()
+ #
+ # # Get the ID for each datasource in the config
+ # for ds in ts.get.datasources():
+ # if ds not in config.datasources:
+ # continue
+ # config.datasources[ds].id = ds.id
+ #
+ # # for datasource in config.datasources:
+ # if not datasource.id:
+ # logging.error('!! Datasource not found in Tableau Online: %s / %s',
+ # datasource.project_name, datasource.name)
+ # continue
+ # dsid = datasource.id
# Set default dict attributes for tasks, for each datasource
self.tasks[dsid] = {a: [] for a in UPDATE_ACTIONS}
self.tasks[dsid]['project'] = datasource.project_name
self.tasks[dsid]['datasource_name'] = datasource.name
- if not config.in_maintenance_window and AIRFLOW_ENV not in ['STAGING', 'DEV']:
- self.tasks[dsid]['skip'] = 'Outside maintenance window'
- logging.info('(SKIP) Outside maintenance window: %s', datasource.name)
- continue
- elif datasource.name in EXCLUDED_DATASOURCES:
- self.tasks[dsid]['skip'] = 'Marked to exclude'
- logging.info('(SKIP) Marked to exclude: %s', datasource.name)
- continue
- logging.info('Checking Datasource: %s', datasource.name)
- # Download the Datasource for comparison
- dl_path = f"downloads/{dsid}/"
- os.makedirs(dl_path, exist_ok=True)
- ds_path = ts.download.datasource(dsid, file_dir=dl_path, include_extract=False)
- tds = Datasource(ds_path)
- # Cleanup downloaded file after assigning the Datasource
- shutil.rmtree(dl_path, ignore_errors=True)
- # Add connection task, if there is a difference
- self.__compare_connection(dsid, datasource.name, tds.connection, expected_conn_attrs)
- # Add folder tasks, if folders need to be added/deleted
- self.__compare_folders(dsid, tds.folders_common, datasource.folders)
- # Add Column tasks, if there are missing columns, or columns need to be updated
+ # if not config.in_maintenance_window and AIRFLOW_ENV not in ['STAGING', 'DEV']:
+ # self.tasks[dsid]['skip'] = 'Outside maintenance window'
+ # logging.info('(SKIP) Outside maintenance window: %s', datasource.name)
+ # continue
+ # elif datasource.name in EXCLUDED_DATASOURCES:
+ # self.tasks[dsid]['skip'] = 'Marked to exclude'
+ # logging.info('(SKIP) Marked to exclude: %s', datasource.name)
+ # continue
+ # logging.info('Checking Datasource: %s', datasource.name)
+ # # Download the Datasource for comparison
+ # dl_path = f"downloads/{dsid}/"
+ # os.makedirs(dl_path, exist_ok=True)
+ # ds_path = ts.download.datasource(dsid, file_dir=dl_path, include_extract=False)
+ # tds = Datasource(ds_path)
+ # # Cleanup downloaded file after assigning the Datasource
+ # shutil.rmtree(dl_path, ignore_errors=True)
+ # # Add connection task, if there is a difference
+ # self.__compare_connection(dsid, datasource.name, tds.connection, expected_conn_attrs)
+ # # Add folder tasks, if folders need to be added/deleted
+ # self.__compare_folders(dsid, tds.folders_common, datasource.folders)
+ # # Add Column tasks, if there are missing columns, or columns need to be updated
for column in datasource.columns:
# Check if the column metadata needs to be updated
self.__compare_column_metadata(dsid, tds, column)
diff --git a/setup.py b/setup.py
index eac0708..7380dd4 100644
--- a/setup.py
+++ b/setup.py
@@ -12,7 +12,7 @@
long_description=readme,
long_description_content_type='text/markdown',
name="tableau_utilities",
- version="2.2.11",
+ version="2.2.12",
requires_python=">=3.8",
packages=[
'tableau_utilities',
diff --git a/tableau_utilities/scripts/apply_configs.py b/tableau_utilities/scripts/apply_configs.py
new file mode 100644
index 0000000..fa49640
--- /dev/null
+++ b/tableau_utilities/scripts/apply_configs.py
@@ -0,0 +1,309 @@
+from copy import deepcopy
+import os
+import pprint
+import shutil
+from typing import Dict, Any, List
+from time import time
+
+
+from tableau_utilities.tableau_file.tableau_file import Datasource
+from tableau_utilities.general.cli_styling import Color, Symbol
+from tableau_utilities.general.config_column_persona import personas
+from tableau_utilities.scripts.datasource import add_metadata_records_as_columns
+from tableau_utilities.scripts.gen_config import build_configs
+from tableau_utilities.scripts.merge_config import read_file
+
+color = Color()
+symbol = Symbol()
+
+class ApplyConfigs:
+ """Applies a set of configs to a datasource. Configs prefixed with target_ will be applied to the datasource.
+ Configs prefixed with datasource_ represent the current state of the datasource before changes.
+ """
+
+ def __init__(self,
+ datasource_name: str,
+ datasource_path: str,
+ target_column_config: Dict[str, Any],
+ target_calculated_column_config: Dict[str, Any],
+ debugging_logs: bool) -> None:
+ self.datasource_name: str = datasource_name
+ self.datasource_path: str = datasource_path
+ self.target_column_config: Dict[str, Any] = target_column_config
+ self.target_calculated_column_config: Dict[str, Any] = target_calculated_column_config
+ self.debugging_logs: bool = debugging_logs
+
+
+ def select_matching_datasource_config(self, config: Dict[str, Any]) -> Dict[str, Any]:
+ """ Limit
+
+ Args:
+ comfig:
+
+ Returns:
+ A config with any datasource that is not self.datasource_name removed
+
+ """
+
+ config = config[self.datasource_name]
+ return config
+
+ def invert_config(self, config: Dict[str, Any]) -> Dict[str, Any]:
+ """Helper function to invert the column config and calc config.
+ Output -> {datasource: {column: info}}
+
+ Args:
+ config (dict): The config to invert.
+
+ Returns:
+ dict: The inverted config.
+ """
+
+ inverted_config = {}
+
+ for column, i in config.items():
+ for datasource in i['datasources']:
+ new_info = deepcopy(i)
+ del new_info['datasources']
+ new_info['local-name'] = datasource['local-name']
+ new_info['remote_name'] = datasource['sql_alias'] if 'sql_alias' in datasource else None
+ inverted_config.setdefault(datasource['name'], {column: new_info})
+ inverted_config[datasource['name']].setdefault(column, new_info)
+
+ if self.debugging_logs:
+ pp = pprint.PrettyPrinter(indent=4, width=200, depth=None, compact=False)
+ pp.pprint(inverted_config)
+
+ return inverted_config
+
+
+ def prepare_configs(self, config_A: Dict[str, Any], config_B: Dict[str, Any]) -> Dict[str, Any]:
+ """ Takes 2 configs to invert, combine, and remove irrelevant datasource information. Columns in a main config
+ can be in 1 or many Tableau datasources. So when managing multiple datasources it's likely to have columns that
+ need removal
+
+ Args:
+ config_A:
+ config_B:
+
+ Returns:
+
+ """
+
+ # invert the configs
+ config_A = self.invert_config(config_A)
+ config_B = self.invert_config(config_B)
+
+ # Get only the configs to the current datasource
+ config_A = self.select_matching_datasource_config(config_A)
+ config_B = self.select_matching_datasource_config(config_B)
+
+ # Combine configs
+ combined_config = {**config_A, **config_B}
+
+ if self.debugging_logs:
+ print(f'{color.fg_yellow}AFTER COMBINING CONFIGS{color.reset}')
+ pp = pprint.PrettyPrinter(indent=4, width=200, depth=None, compact=False)
+ pp.pprint(combined_config)
+
+ return combined_config
+
+
+ def flatten_to_list_of_fields(self, nested_dict: Dict[str, Dict[str, Any]]) -> List[Dict[str, Any]]:
+ """
+ Flattens a nested dictionary by removing one level of nesting and adding a "Caption" key.
+
+ Args:
+ nested_dict (Dict[str, Dict[str, Any]]): The nested dictionary to flatten.
+
+ Returns:
+ List[Dict[str, Any]]: A list of dictionaries with "Caption" as a key.
+ """
+ flattened_list = []
+ for key, value in nested_dict.items():
+ flattened_entry = {"caption": key}
+ flattened_entry.update(value)
+ flattened_list.append(flattened_entry)
+
+ if self.debugging_logs:
+ print(f'{color.fg_yellow}AFTER FLATTENING{color.reset}')
+ for field_config in flattened_list:
+ print(field_config)
+
+ return flattened_list
+ #
+ # def merge_configs(self, target_config: List[Dict[str, Any]], datasource_config: List[Dict[str, Any]]) -> List[
+ # Dict[str, Any]]:
+ # """Merges two lists of dictionaries ensuring all 'local-name' from both lists are present.
+ #
+ # If the 'local-name' is in both lists, the values from `target_config` are used.
+ #
+ # Args:
+ # target_config (List[Dict[str, Any]]): The target configuration list of dictionaries.
+ # datasource_config (List[Dict[str, Any]]): The datasource configuration list of dictionaries.
+ #
+ # Returns:
+ # List[Dict[str, Any]]: A merged list of dictionaries.
+ # """
+ # merged_dict = {}
+ #
+ # # Add all entries from datasource_config to merged_dict
+ # for entry in datasource_config:
+ # local_name = entry['local-name']
+ # merged_dict[local_name] = entry
+ #
+ # # Update or add entries from target_config to merged_dict
+ # for entry in target_config:
+ # local_name = entry['local-name']
+ # merged_dict[local_name] = entry
+ #
+ # # Convert merged_dict back to a list of dictionaries
+ # merged_list = list(merged_dict.values())
+ #
+ # # if self.debugging_logs:
+ # print(f'{color.fg_yellow}AFTER MERGING{color.reset}')
+ # for field_config in merged_list:
+ # print(field_config)
+ #
+ # return merged_list
+
+
+ def compare_columns(self, target_config: List[Dict[str, Any]], datasource_config: List[Dict[str, Any]]) -> List[
+ Dict[str, Any]]:
+ """Compares the target config to the datasource config and generates a list of changes to make the datasource match the target config.
+
+ Args:
+ target_config (List[Dict[str, Any]]): The target configuration list of dictionaries.
+ datasource_config (List[Dict[str, Any]]): The datasource configuration list of dictionaries.
+
+ Returns:
+ List[Dict[str, Any]]: A list of dictionaries with the columns that need updating.
+ """
+ changes_to_make = []
+
+ for target_entry in target_config:
+ if target_entry not in datasource_config:
+ changes_to_make.append(target_entry)
+
+ print(f'{color.fg_yellow}AFTER MERGING{color.reset}')
+ for field_config in changes_to_make:
+ print(field_config)
+
+ return changes_to_make
+
+ def execute_changes(self, columns_list: List[Dict[str, Any]], datasource):
+ """ Applies changes to make
+
+ Args:
+ columns_list:
+ datasource:
+
+ Returns:
+
+ """
+
+ print(f'{color.fg_cyan}...Applying Changes to {self.datasource_name}...{color.reset}')
+
+ for each_column in columns_list:
+ if self.debugging_logs:
+ print(f'{color.fg_yellow}column:{color.reset}{each_column}')
+
+ #
+
+ column = datasource.columns.get(each_column['local-name'])
+
+ persona = personas.get(each_column['persona'].lower(), {})
+
+ if self.debugging_logs:
+ print(f'{color.fg_yellow}persona:{color.reset}{persona}')
+
+ column.caption = each_column['caption'] or column.caption
+ column.role = persona.get('role') or column.role
+ column.type = persona.get('role_type') or column.type
+ column.datatype = persona.get('datatype') or column.datatype
+ column.desc = each_column['description'] or column.desc
+
+ if 'calculation' in each_column:
+ column.calculation = each_column['calculation']
+
+ if self.debugging_logs:
+ print(f'{color.fg_yellow}column:{color.reset}{each_column}')
+
+ datasource.enforce_column(column, remote_name=each_column['remote_name'], folder_name=each_column['folder'])
+
+ start = time()
+ print(f'{color.fg_cyan}...Saving datasource changes...{color.reset}')
+ datasource.save()
+ print(f'{color.fg_green}{symbol.success} (Done in {round(time() - start)} sec) '
+ f'Saved datasource changes: {color.fg_yellow}{self.datasource_path}{color.reset}')
+
+
+ def apply_config_to_datasource(self):
+ """ Applies a set of configs (column_config and calculated_column_config) to a datasource.
+ If a column is in a datasource but NOT in the config that column will be unchanged.
+
+ Args:
+ datasource_name:
+ datasource_path:
+ column_config:
+ calculated_field_config:
+ debugging_logs:
+
+ Returns:
+ None
+
+ """
+
+ datasource = Datasource(self.datasource_path)
+
+
+ # Run column init on the datasource to make sure columns aren't hiding in Metadata records
+ datasource = add_metadata_records_as_columns(datasource, self.debugging_logs)
+
+ # Build the config dictionaries from the datasource
+ datasource_column_config, datasource_calculated_column_config = build_configs(datasource, self.datasource_name)
+
+ # if self.debugging_logs:
+ # print('Target Column Config:', self.target_column_config)
+ # print('Target Column Config:', type(self.target_column_config))
+ # print('Target Calculated Column Config:', self.target_calculated_column_config)
+ # # print('Datasource Column Config:', datasource_column_config)
+
+ # Prepare the configs by inverting, combining and removing configs for other datasources
+ target_config = self.prepare_configs(self.target_column_config, self.target_calculated_column_config)
+ datasource_config = self.prepare_configs(datasource_column_config, datasource_calculated_column_config)
+
+ target_config = self.flatten_to_list_of_fields(target_config)
+ datasource_config = self.flatten_to_list_of_fields(datasource_config)
+
+ # merged_config = self.merge_configs(target_config, datasource_config)
+ changes_to_make = self.compare_columns(target_config, datasource_config)
+
+ self.execute_changes(changes_to_make, datasource)
+
+ #
+ #
+ #
+ # # Get the changes to make for the column config
+ # # Get the changes to make for the calculation config
+ #
+ # # Apply the changes for the column config
+ # # Apply the changes for the calc config
+ #
+ # # Clean up the empty folders
+ #
+ # # Save the file
+ # pass
+
+
+def apply_configs(args):
+ # Set variables from the args
+ debugging_logs = args.debugging_logs
+ datasource_name = args.name
+ datasource_path = args.file_path
+ target_column_config = read_file(args.column_config)
+ target_calculated_column_config = read_file(args.calculated_column_config)
+
+ AC = ApplyConfigs(datasource_name, datasource_path, target_column_config, target_calculated_column_config, debugging_logs)
+
+ AC.apply_config_to_datasource()
diff --git a/tableau_utilities/scripts/cli.py b/tableau_utilities/scripts/cli.py
index e02651d..55c7b93 100644
--- a/tableau_utilities/scripts/cli.py
+++ b/tableau_utilities/scripts/cli.py
@@ -15,6 +15,7 @@
from tableau_utilities.scripts.server_operate import server_operate
from tableau_utilities.scripts.datasource import datasource
from tableau_utilities.scripts.csv_config import csv_config
+from tableau_utilities.scripts.apply_configs import apply_configs
__version__ = importlib.metadata.version('tableau_utilities')
@@ -163,6 +164,9 @@
help='Deletes data from the extract based on the condition string provided. '
"""E.g. "CREATED_AT" < '1/1/2024'""")
parser_datasource.add_argument('-ci', '--column_init', action='store_true', help="Adds Columns from all Metadata Records, if they don't already exist.")
+parser_datasource.add_argument('-cf', '--clean_folders', action='store_true', help="Removes any empty folders without columns")
+# parser_datasource.add_argument('-cc', '--column_config', help='The path to the column configs file')
+# parser_datasource.add_argument('-cac', '--calculated_column_config', help='The path to the calculated field config file.')
parser_datasource.set_defaults(func=datasource)
# GENERATE CONFIG
@@ -200,6 +204,14 @@
'Use with --merge_with generate_merge_all')
parser_config_merge.set_defaults(func=merge_configs)
+# APPLY CONFIGS
+parser_config_apply = subparsers.add_parser(
+ 'apply_configs', help='Applies a config to a datasource. Writes over any datasource attributes to make it '
+ 'conform to the config.', formatter_class=RawTextHelpFormatter)
+parser_config_apply.add_argument('-cc', '--column_config', help='The path to the column configs file')
+parser_config_apply.add_argument('-cac', '--calculated_column_config', help='The path to the calculated field config file.')
+parser_config_apply.set_defaults(func=apply_configs)
+
def validate_args_server_operate(args):
""" Validate that combinations of args are present """
@@ -263,6 +275,11 @@ def validate_args_command_merge_config(args):
parser.error(f'--merge_with {args.merge_with} requires --target_directory')
+def validate_args_command_apply_configs(args):
+ if args.file_path is None or args.name is None or args.column_config is None or args.calculated_column_config is None:
+ parser.error(f'{args.command} requires --name and --file_path for a datasource and --column_config and --calculated_column_config')
+
+
def validate_subpackage_hyper():
""" Checks that the hyper subpackage is installed for functions that use it """
@@ -455,6 +472,8 @@ def main():
validate_args_command_datasource(args)
if args.command == 'merge_config':
validate_args_command_merge_config(args)
+ if args.command == 'apply_configs':
+ validate_args_command_apply_configs(args)
# Set/Reset the directory
tmp_folder = args.output_dir
diff --git a/tableau_utilities/scripts/datasource.py b/tableau_utilities/scripts/datasource.py
index adc4d8b..0e1e1f5 100644
--- a/tableau_utilities/scripts/datasource.py
+++ b/tableau_utilities/scripts/datasource.py
@@ -11,6 +11,10 @@
from tableau_utilities.tableau_server.tableau_server import TableauServer
+# Define color and symbol as globals
+color = Color()
+symbol = Symbol()
+
def create_column(name: str, persona: dict):
""" Creates the tfo column object with the minimum required fields to add a column
@@ -32,6 +36,73 @@ def create_column(name: str, persona: dict):
return column
+
+def add_metadata_records_as_columns(ds, debugging_logs=False):
+ """ Adds records when they are only present in the
+
+ When you create your Tableau extract the first time all columns will be present in Metadata records like this:
+
+
+ MY_COLUMN
+ 131
+ [MY_COLUMN]
+ [Custom SQL Query]
+ MY_COLUMN
+ 5
+ integer
+ Sum
+ 38
+ 0
+ true
+
+ "SQL_DECIMAL"
+ "SQL_C_NUMERIC"
+
+ <_.fcp.ObjectModelEncapsulateLegacy.true...object-id>[_62A667B34C534415B10B2075B0DC36DC]
+
+
+ Separately some columns may have a column like this:
+
+
+
+ Manipulating Tableau columns requires a record.
+
+ Args:
+ ds: A Datasource object
+ color: The cli color styling class
+ debugging_logs: True to print debugging information to the console
+
+ Returns:
+ ds: An altered datasource. You'll still need to save this ds to apply the changes.
+
+ """
+
+ # Create the list of columns to add
+ columns_to_add = [
+ m for m in ds.connection.metadata_records
+ if m.local_name not in [c.name for c in ds.columns]
+ ]
+ print(f'{color.fg_yellow}Adding missing columns from Metadata Records:{color.reset} '
+ f'{[m.local_name for m in columns_to_add]}')
+
+ # Add the columns making the best guess of the proper persona
+ for m in columns_to_add:
+ if debugging_logs:
+ print(f'{color.fg_magenta}Metadata Record -> {m.local_name}:{color.reset} {m}')
+
+ persona = get_persona_by_metadata_local_type(m.local_type)
+ persona_dict = personas.get(persona, {})
+ if debugging_logs:
+ print(f' - {color.fg_blue}Persona -> {persona}:{color.reset} {persona_dict}')
+
+ column = create_column(m.local_name, persona_dict)
+
+ if debugging_logs:
+ print(f' - {color.fg_cyan}Creating Column -> {column.name}:{color.reset} {column.dict()}')
+ ds.enforce_column(column, remote_name=m.remote_name)
+
+ return ds
+
def datasource(args, server=None):
""" Updates a Tableau Datasource locally
@@ -67,6 +138,7 @@ def datasource(args, server=None):
remote_name = args.remote_name
list_objects = args.list.title() if args.list else None
column_init = args.column_init
+ clean_folders = args.clean_folders
# Datasource Connection Args
conn_type = args.conn_type
@@ -77,9 +149,6 @@ def datasource(args, server=None):
conn_schema = args.conn_schema
conn_warehouse = args.conn_warehouse
- # Print Styling
- color = Color()
- symbol = Symbol()
# Downloads the datasource from Tableau Server if the datasource is not local
if location == 'online':
@@ -146,28 +215,7 @@ def datasource(args, server=None):
# Column Init - Add columns for any column in Metadata records but not in columns
if column_init:
- columns_to_add = [
- m for m in ds.connection.metadata_records
- if m.local_name not in [c.name for c in ds.columns]
- ]
- print(f'{color.fg_yellow}Adding missing columns from Metadata Records:{color.reset} '
- f'{[m.local_name for m in columns_to_add]}')
-
- for m in columns_to_add:
- if debugging_logs:
- print(f'{color.fg_magenta}Metadata Record -> {m.local_name}:{color.reset} {m}')
-
- persona = get_persona_by_metadata_local_type(m.local_type)
- persona_dict = personas.get(persona, {})
- if debugging_logs:
- print(f' - {color.fg_blue}Persona -> {persona}:{color.reset} {persona_dict}')
-
- column = create_column(m.local_name, persona_dict)
-
- if debugging_logs:
- print(f' - {color.fg_cyan}Creating Column -> {column.name}:{color.reset} {column.dict()}')
- ds.enforce_column(column, remote_name=m.remote_name)
-
+ ds = add_metadata_records_as_columns(ds, color, debugging_logs)
# Add / modify a specified column
if column_name and not delete:
@@ -213,6 +261,11 @@ def datasource(args, server=None):
if delete == 'folder':
ds.folders_common.folder.delete(folder_name)
+ # Clean folders
+ if clean_folders:
+ cleaned = ds.remove_empty_folders()
+ print(f'Removed this list of folders: {color.fg_cyan}{cleaned}{color.reset}')
+
# Enforce Connection
if enforce_connection:
if debugging_logs:
@@ -231,7 +284,7 @@ def datasource(args, server=None):
ds.connection.update(connection)
# Save the datasource if an edit may have happened
- if column_name or folder_name or delete or enforce_connection or empty_extract or column_init:
+ if column_name or folder_name or delete or enforce_connection or empty_extract or column_init or clean_folders:
start = time()
print(f'{color.fg_cyan}...Saving datasource changes...{color.reset}')
ds.save()
diff --git a/tableau_utilities/scripts/gen_config.py b/tableau_utilities/scripts/gen_config.py
index ab8c367..8bc9ef5 100644
--- a/tableau_utilities/scripts/gen_config.py
+++ b/tableau_utilities/scripts/gen_config.py
@@ -10,22 +10,28 @@
from tableau_utilities.tableau_server.tableau_server import TableauServer
-def load_csv_with_definitions(file=None):
+def load_csv_with_definitions(file=None, debugging_logs=False):
""" Returns a dictionary with the definitions from a csv. The columns are expected to include column_name and description
Args:
file: The path to the .csv file with the definitions. The csv must include a column_name and description.
+ debugging_logs: Prints information to consolde if true
Returns:
dictionary mapping column name to definition
+
"""
definitions_mapping = dict()
df = pd.read_csv(file)
+
df.columns = df.columns.str.lower()
definitions = df.to_dict('records')
+ if debugging_logs:
+ print(definitions)
+
# Check that the csv contains column_name and description headers
column_names = list(df.columns)
if 'column_name' not in column_names or 'description' not in column_names:
@@ -37,7 +43,6 @@ def load_csv_with_definitions(file=None):
return definitions_mapping
-
def choose_persona(role, role_type, datatype, caption):
""" The config relies on a persona which is a combination of role, role_type and datatype for each column.
This returns the persona name or raises an exception if the combination is not found
@@ -253,6 +258,51 @@ def build_folder_mapping(folders):
return mappings
+def build_configs(datasource, datasource_name, debugging_logs=False, definitions_csv_path=None):
+ """
+
+ Args:
+ datasource: A Tableau utilities datasource object
+ datasource_name: The name of the datasource
+ debugging_logs: True to print debugging logs to the console
+ definitions_csv_path: The path to a .csv with data definitions
+
+ Returns:
+ column_configs: A dictionary with the column configs
+ calculated_column_configs = A dictionary with the calculated field configs
+
+ """
+
+ # Get column information from the metadata records
+ metadata_record_config = get_metadata_record_config(
+ datasource.connection.metadata_records,
+ datasource_name,
+ debugging_logs
+ )
+
+ # Get the mapping of definitions from the csv
+ definitions_mapping = dict()
+ if definitions_csv_path is not None:
+ definitions_mapping = load_csv_with_definitions(file=definitions_csv_path)
+
+ # Extract the columns and folders. Build the new config
+ folder_mapping = build_folder_mapping(datasource.folders_common)
+ column_configs, calculated_column_configs = create_column_config(
+ columns=datasource.columns,
+ datasource_name=datasource_name,
+ folder_mapping=folder_mapping,
+ metadata_record_columns=metadata_record_config,
+ definitions_mapping=definitions_mapping,
+ debugging_logs=debugging_logs
+ )
+
+ # Sort configs
+ column_configs = dict(sorted(column_configs.items()))
+ calculated_column_configs = dict(sorted(calculated_column_configs.items()))
+
+ return column_configs, calculated_column_configs
+
+
def generate_config(args, server: TableauServer = None):
""" Downloads a datasource and saves configs for that datasource
@@ -293,34 +343,14 @@ def generate_config(args, server: TableauServer = None):
print(f'{color.fg_yellow}BUILDING CONFIG {symbol.arrow_r} '
f'{color.fg_grey}{datasource_name} {symbol.sep} {datasource_path}{color.reset}')
- datasource = Datasource(datasource_path)
- # Get column information from the metadata records
- metadata_record_config = get_metadata_record_config(
- datasource.connection.metadata_records,
- datasource_name,
- debugging_logs
- )
-
- # Get the mapping of definitions from the csv
- definitions_mapping = dict()
- if definitions_csv_path is not None:
- definitions_mapping = load_csv_with_definitions(file=definitions_csv_path)
- # Extract the columns and folders. Build the new config
- folder_mapping = build_folder_mapping(datasource.folders_common)
- column_configs, calculated_column_configs = create_column_config(
- columns=datasource.columns,
- datasource_name=datasource_name,
- folder_mapping=folder_mapping,
- metadata_record_columns=metadata_record_config,
- definitions_mapping=definitions_mapping,
- debugging_logs=debugging_logs
- )
+ datasource = Datasource(datasource_path)
- # Sort configs
- column_configs = dict(sorted(column_configs.items()))
- calculated_column_configs = dict(sorted(calculated_column_configs.items()))
+ # Build the config dictionaries
+ column_configs, calculated_column_configs = build_configs(datasource, datasource_name, debugging_logs,
+ definitions_csv_path)
+ # Output the configs to files
datasource_name_snake = convert_to_snake_case(datasource_name)
output_file_column_config = 'column_config.json'
output_file_calculated_column_config = 'tableau_calc_config.json'
diff --git a/tableau_utilities/scripts/merge_config.py b/tableau_utilities/scripts/merge_config.py
index 1535a55..22af11f 100644
--- a/tableau_utilities/scripts/merge_config.py
+++ b/tableau_utilities/scripts/merge_config.py
@@ -112,7 +112,7 @@ def sort_config(config, debugging_logs):
if debugging_logs:
print('KEY', k)
- print('CONGIG', v)
+ print('CONFIG', v)
print('DATASOURCES', v['datasources'])
sorted_datasources = sorted(v['datasources'], key=lambda d: d['name'])
@@ -177,13 +177,15 @@ def merge_configs(args, server=None):
elif merge_with == 'csv':
# Read files
existing_config = read_file(existing_config)
- definitions_mapping = load_csv_with_definitions(file=definitions_csv_path)
+ definitions_mapping = load_csv_with_definitions(file=definitions_csv_path, debugging_logs=debugging_logs)
# Merge
new_config = add_definitions_mapping(existing_config, definitions_mapping)
# Sort and write the merged config
new_config = sort_config(new_config, debugging_logs)
write_file(file_name=file_name, config=new_config, debugging_logs=debugging_logs)
+ print(f'{color.fg_yellow}DEFINITIONS CSV {symbol.arrow_r} '
+ f'{color.fg_grey}{definitions_csv_path}{color.reset}')
print(f'{color.fg_yellow}EXISTING CONFIG {symbol.arrow_r} '
f'{color.fg_grey}{existing_config_path}{color.reset}')
print(f'{color.fg_yellow}ADDITIONAL CONFIG {symbol.arrow_r} '
diff --git a/tableau_utilities/tableau_file/tableau_file.py b/tableau_utilities/tableau_file/tableau_file.py
index 8d55d56..63f6f56 100644
--- a/tableau_utilities/tableau_file/tableau_file.py
+++ b/tableau_utilities/tableau_file/tableau_file.py
@@ -301,6 +301,42 @@ def enforce_column(self, column, folder_name=None, remote_name=None):
if not found:
self.extract.connection.cols.append(extract_col)
+ def remove_empty_folders(self):
+ """ Removes any folder without a column in it
+
+ Example:
+ The "Folder - 2 columns" will be unchanged and the xml line for "Folder - Empty" will be removed
+
+ <_.fcp.SchemaViewerObjectModel.true...folders-common>
+
+
+
+
+
+
+
+
+ Returns:
+ The list of folders that were removed
+
+ """
+
+ # Identify empty folders
+ empty_folder_list = []
+
+ for folder in self.folders_common.folder:
+ number_columns_in_folder = len(folder.folder_item)
+
+ if number_columns_in_folder == 0:
+ empty_folder_list.append(folder.name)
+
+ # Remove Empty Folders
+ for empty_folder in empty_folder_list:
+ self.folders_common.folder.delete(empty_folder)
+
+ return empty_folder_list
+
+
def save(self):
""" Save all changes made to each section of the Datasource """
parent = self._root.find('.')
diff --git a/tests/conftest.py b/tests/conftest.py
new file mode 100644
index 0000000..33e282d
--- /dev/null
+++ b/tests/conftest.py
@@ -0,0 +1,25 @@
+import pytest
+
+file_test_count = {}
+
+@pytest.hookimpl(tryfirst=True)
+def pytest_sessionstart(session):
+ global file_test_count
+ file_test_count = {}
+
+@pytest.hookimpl(tryfirst=True)
+def pytest_runtestloop(session):
+ global file_test_count
+ for item in session.items:
+ file_path = str(item.fspath)
+ if file_path not in file_test_count:
+ file_test_count[file_path] = 0
+ file_test_count[file_path] += 1
+
+@pytest.hookimpl(trylast=True)
+def pytest_terminal_summary(terminalreporter, exitstatus):
+ terminalreporter.write_sep("=", "test count summary")
+ for file_path, count in file_test_count.items():
+ terminalreporter.write_line(f"{file_path}: {count} test(s)")
+ terminalreporter.write_line(f"Total number of test files: {len(file_test_count)}")
+ terminalreporter.write_line(f"Total number of tests: {sum(file_test_count.values())}")
diff --git a/tests/test_apply_configs.py b/tests/test_apply_configs.py
new file mode 100644
index 0000000..8981f66
--- /dev/null
+++ b/tests/test_apply_configs.py
@@ -0,0 +1,292 @@
+import pytest
+from typing import Dict, Any
+from tableau_utilities.scripts.apply_configs import ApplyConfigs
+
+
+@pytest.fixture
+def apply_configs():
+ return ApplyConfigs(datasource_name="my_datasource_1", datasource_path="", target_column_config={},
+ target_calculated_column_config={}, debugging_logs=False)
+
+
+def test_invert_config_single_datasource(apply_configs):
+ sample_config = {
+ "Column1": {
+ "description": "Description of Column1",
+ "folder": "Folder1",
+ "persona": "string_dimension",
+ "datasources": [
+ {
+ "name": "my_datasource_1",
+ "local-name": "MY_COLUMN_1",
+ "sql_alias": "MY_COLUMN_1_ALIAS"
+ }
+ ]
+ }
+ }
+
+ expected_output = {
+ "my_datasource_1": {
+ "Column1": {
+ "description": "Description of Column1",
+ "folder": "Folder1",
+ "persona": "string_dimension",
+ "local-name": "MY_COLUMN_1",
+ "remote_name": "MY_COLUMN_1_ALIAS"
+ }
+ }
+ }
+
+ result = apply_configs.invert_config(sample_config)
+ assert result == expected_output
+
+
+def test_invert_config_multiple_datasources(apply_configs):
+ sample_config = {
+ "Column2": {
+ "description": "Description of Column2",
+ "folder": "Folder2",
+ "persona": "string_dimension",
+ "datasources": [
+ {
+ "name": "my_datasource_1",
+ "local-name": "MY_COLUMN_1",
+ "sql_alias": "MY_COLUMN_1_ALIAS"
+ },
+ {
+ "name": "my_datasource_2",
+ "local-name": "MY_COLUMN_2",
+ "sql_alias": "MY_COLUMN_2_ALIAS"
+ }
+ ]
+ }
+ }
+
+ expected_output = {
+ "my_datasource_1": {
+ "Column2": {
+ "description": "Description of Column2",
+ "folder": "Folder2",
+ "persona": "string_dimension",
+ "local-name": "MY_COLUMN_1",
+ "remote_name": "MY_COLUMN_1_ALIAS"
+ }
+ },
+ "my_datasource_2": {
+ "Column2": {
+ "description": "Description of Column2",
+ "folder": "Folder2",
+ "persona": "string_dimension",
+ "local-name": "MY_COLUMN_2",
+ "remote_name": "MY_COLUMN_2_ALIAS"
+ }
+ }
+ }
+
+ result = apply_configs.invert_config(sample_config)
+ assert result == expected_output
+
+def test_flatten_to_list_of_fields(apply_configs):
+
+ sample_dict = {
+ 'My Caption 1': {
+ 'description': 'A perfect description',
+ 'folder': 'My Folder',
+ 'local-name': 'MY_FIELD_1',
+ 'persona': 'string_dimension',
+ 'remote_name': 'MY_FIELD_1'
+ },
+ 'My Caption 2': {
+ 'description': 'Another perfect description',
+ 'folder': 'My Folder',
+ 'local-name': 'MY_FIELD_2',
+ 'persona': 'string_dimension',
+ 'remote_name': 'MY_FIELD_2'
+ }
+ }
+
+ expected_output = [
+ {
+ 'Caption': 'My Caption 1',
+ 'description': 'A perfect description',
+ 'folder': 'My Folder',
+ 'local-name': 'MY_FIELD_1',
+ 'persona': 'string_dimension',
+ 'remote_name': 'MY_FIELD_1'
+ },
+ {
+ 'Caption': 'My Caption 2',
+ 'description': 'Another perfect description',
+ 'folder': 'My Folder',
+ 'local-name': 'MY_FIELD_2',
+ 'persona': 'string_dimension',
+ 'remote_name': 'MY_FIELD_2'
+ }
+ ]
+
+ result = apply_configs.flatten_to_list_of_fields(sample_dict)
+ assert result == expected_output
+
+
+def test_prepare_configs(apply_configs):
+ sample_config_A = {
+ "Column1": {
+ "description": "Description of Column1",
+ "folder": "Folder1",
+ "persona": "string_dimension",
+ "datasources": [
+ {
+ "name": "my_datasource_1",
+ "local-name": "MY_COLUMN_1",
+ "sql_alias": "MY_COLUMN_1_ALIAS"
+ }
+ ]
+ },
+ "Column2": {
+ "description": "Description of Column2",
+ "folder": "Folder2",
+ "persona": "string_dimension",
+ "datasources": [
+ {
+ "name": "my_datasource_1",
+ "local-name": "MY_COLUMN_1",
+ "sql_alias": "MY_COLUMN_1_ALIAS"
+ },
+ {
+ "name": "my_datasource_2",
+ "local-name": "MY_COLUMN_2",
+ "sql_alias": "MY_COLUMN_2_ALIAS"
+ }
+ ]
+ }
+ }
+
+ sample_config_B = {
+ "# ID": {
+ "description": "Distinct Count of the ID",
+ "calculation": "COUNTD([ID])",
+ "folder": "My Data",
+ "persona": "continuous_number_measure",
+ "datasources": [
+ {
+ "name": "my_datasource_1",
+ "local-name": "MY_COLUMN_1",
+ "sql_alias": "MY_COLUMN_1_ALIAS"
+ },
+ {
+ "name": "my_datasource_2",
+ "local-name": "MY_COLUMN_2",
+ "sql_alias": "MY_COLUMN_2_ALIAS"
+ }
+ ],
+ "default_format": "n#,##0;-#,##0"
+ }
+ }
+
+ expected_output = {
+ "Column1": {
+ "description": "Description of Column1",
+ "folder": "Folder1",
+ "persona": "string_dimension",
+ "local-name": "MY_COLUMN_1",
+ "remote_name": "MY_COLUMN_1_ALIAS"
+ },
+ "Column2": {
+ "description": "Description of Column2",
+ "folder": "Folder2",
+ "persona": "string_dimension",
+ "local-name": "MY_COLUMN_1",
+ "remote_name": "MY_COLUMN_1_ALIAS"
+ },
+ "# ID": {
+ "description": "Distinct Count of the ID",
+ "calculation": "COUNTD([ID])",
+ "default_format": "n#,##0;-#,##0",
+ "folder": "My Data",
+ "persona": "continuous_number_measure",
+ "local-name": "MY_COLUMN_1",
+ "remote_name": "MY_COLUMN_1_ALIAS"
+ }
+ }
+
+ result = apply_configs.prepare_configs(sample_config_A, sample_config_B)
+ assert result == expected_output
+
+def test_flatten_to_list_of_fields(apply_configs):
+
+ sample_dict = {
+ 'My Caption 1': {
+ 'description': 'A perfect description',
+ 'folder': 'My Folder',
+ 'local-name': 'MY_FIELD_1',
+ 'persona': 'string_dimension',
+ 'remote_name': 'MY_FIELD_1'
+ },
+ 'My Caption 2': {
+ 'description': 'Another perfect description',
+ 'folder': 'My Folder',
+ 'local-name': 'MY_FIELD_2',
+ 'persona': 'string_dimension',
+ 'remote_name': 'MY_FIELD_2'
+ }
+ }
+
+ expected_output = [
+ {
+ 'caption': 'My Caption 1',
+ 'description': 'A perfect description',
+ 'folder': 'My Folder',
+ 'local-name': 'MY_FIELD_1',
+ 'persona': 'string_dimension',
+ 'remote_name': 'MY_FIELD_1'
+ },
+ {'caption': 'My Caption 2',
+ 'description': 'Another perfect description',
+ 'folder': 'My Folder',
+ 'local-name': 'MY_FIELD_2',
+ 'persona': 'string_dimension',
+ 'remote_name': 'MY_FIELD_2'
+ }
+ ]
+
+ result = apply_configs.flatten_to_list_of_fields(sample_dict)
+ assert result == expected_output
+
+def test_select_matching_datasource_config(apply_configs):
+
+ sample_config = {
+ "my_datasource_1": {
+ "Column1": {
+ "description": "Description of Column1",
+ "folder": "Folder1",
+ "persona": "string_dimension",
+ "local-name": "MY_COLUMN_1",
+ "remote_name": "MY_COLUMN_1_ALIAS"
+ }
+ },
+ "my_datasource_2": {
+ "Column2": {
+ "description": "Description of Column2",
+ "folder": "Folder2",
+ "persona": "string_dimension",
+ "local-name": "MY_COLUMN_2",
+ "remote_name": "MY_COLUMN_2_ALIAS"
+ }
+ }
+ }
+
+ expected_output = {
+ "Column1": {
+ "description": "Description of Column1",
+ "folder": "Folder1",
+ "persona": "string_dimension",
+ "local-name": "MY_COLUMN_1",
+ "remote_name": "MY_COLUMN_1_ALIAS"
+ }
+ }
+ result = apply_configs.select_matching_datasource_config(sample_config)
+ assert result == expected_output
+
+
+if __name__ == '__main__':
+ pytest.main()
diff --git a/tests/test_datasource_remove_empty_folders.py b/tests/test_datasource_remove_empty_folders.py
new file mode 100644
index 0000000..bce4a20
--- /dev/null
+++ b/tests/test_datasource_remove_empty_folders.py
@@ -0,0 +1,58 @@
+import pytest
+from unittest.mock import patch
+from tableau_utilities.tableau_file.tableau_file_objects import FoldersCommon, Folder, FolderItem
+from tableau_utilities.tableau_file.tableau_file import Datasource
+
+@pytest.fixture
+def mock_datasource():
+ with patch('tableau_utilities.tableau_file.tableau_file.Datasource.__init__', lambda x, file_path: None):
+ datasource = Datasource(file_path='dummy_path')
+
+ # Create the mock data
+ mock_folders = [
+ Folder(
+ name='Folder - 2 columns',
+ tag='folder',
+ role=None,
+ folder_item=[
+ FolderItem(name='[COLUMN_1]', type='field', tag='folder-item'),
+ FolderItem(name='[COLUMN_2]', type='field', tag='folder-item')
+ ]
+ ),
+ Folder(
+ name='Folder - Empty',
+ tag='folder',
+ role=None,
+ folder_item=[]
+ ),
+ Folder(
+ name='People',
+ tag='folder',
+ role=None,
+ folder_item=[
+ FolderItem(name='[COLUMN_2+3]', type='field', tag='folder-item')
+ ]
+ )
+ ]
+
+ # Assign the mock folders to the folders_common attribute
+ folders_common = FoldersCommon(folder=mock_folders)
+ datasource.folders_common = folders_common
+
+ return datasource
+
+def test_remove_empty_folders_removed_folders(mock_datasource):
+ removed_folders = mock_datasource.remove_empty_folders()
+ assert removed_folders == ['Folder - Empty']
+
+def test_remove_empty_folders_folder_count(mock_datasource):
+ mock_datasource.remove_empty_folders()
+ assert len(mock_datasource.folders_common.folder) == 2
+
+def test_remove_empty_folders_folder_names(mock_datasource):
+ mock_datasource.remove_empty_folders()
+ folder_names = [folder.name for folder in mock_datasource.folders_common.folder]
+ assert 'Folder - Empty' not in folder_names
+
+if __name__ == '__main__':
+ pytest.main()