import os
import domolibrary.client.DomoAuth as dmda
import domolibrary.client.DomoError as dmde
import domolibrary.routes.jupyter as dmjr
from pprint import pprintQuery Domo Jupyter with Python
Python
DomoJupyter
read in standard creds
auth = dmda.DomoTokenAuth(
domo_instance=os.environ['DOMO_INSTANCE'],
domo_access_token= os.environ['DOMO_ACCESS_TOKEN']
)
await auth.print_is_token()🎉 token_auth token retrieved from domo-community ⚙️Trueworkspace_id = "1cfe9db4-5937-4889-beb3-a311fc42f246" # learn_domo
# currently must scrape from the API
jupyter_token = "jlf9tqkmlwReBFalE11Q6MCSnULBJ6"
token_auth = dmda.DomoTokenAuth(
domo_instance=os.environ['DOMO_INSTANCE'],
domo_access_token=os.environ["DOMO_ACCESS_TOKEN"],
)
workspace_params = await dmjr.get_workspace_auth_token_params(
workspace_id=workspace_id, auth=token_auth
)
print(workspace_params)
# converts a token_auth into DomoJupyterTokenAuth with a new generate_header function for authenticating jupyter requests
dj_auth = dmda.DomoJupyterTokenAuth.convert_auth(
auth=token_auth, jupyter_token=jupyter_token, **workspace_params
)
try:
res = await dmjr.get_jupyter_content(
auth=dj_auth,
# content_path = 'my_terrible_demo.txt',
# content_path="datatypes.ipynb",
debug_api=False,
)
pprint(res.response["content"][0])
except dmde.DomoError as e:
print(e){'service_location': 'jupyter-prod1.domodatascience.com', 'service_prefix': '/user/domo-community-1893952720/1cfe9db4/'}
{'content': None,
'created': '2024-03-25T03:39:25.824000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T03:39:25.824000Z',
'mimetype': None,
'name': 'tutorial',
'path': 'tutorial',
'size': None,
'type': 'directory',
'writable': True}update jupyter content
improve code maintenance by implementing a factory design patternx
sample implementation of update_content
try:
res = await dmjr.update_jupyter_file(
auth=dj_auth,
content_path="new_folder/my_great_demo.txt",
new_content="jae is excellent at demoes",
debug_api=False,
)
pprint(res.response)
except dmde.DomoError as e:
print(e){'content': None,
'created': '2025-03-11T18:02:01.885000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-11T18:02:01.885000Z',
'mimetype': 'text/plain',
'name': 'my_great_demo.txt',
'path': 'new_folder/my_great_demo.txt',
'size': 26,
'type': 'file',
'writable': True}recursive get_content
x = ["this will work"] # a1
def my_fake_recursion(x=None):
x = x or [] # a1
x.append("new_record") # a1
print("i am in a function i have been passed by reference", x)
my_fake_recursion(x=x)
x # a1i am in a function i have been passed by reference ['this will work', 'new_record']['this will work', 'new_record']sample implementation of get_content_recursive
try:
res = await dmjr.get_jupyter_content(auth=dj_auth, content_path="")
print([content["name"] for content in res.response["content"]])
except dmde.DomoError as e:
print(e)['tutorial', 'Untitled.ipynb', 'admin', 'Untitled Folder', 'new_folder', 'README.md', 'test_domolibrary', 'domo_jupyter_examples']try:
res = await dmjr.get_content(
auth=dj_auth,
debug_api=False,
return_raw=False,
)
pprint(res.response)
except dmde.DomoError as e:
print(e)[{'content': [{'content': None,
'created': '2024-03-25T03:39:25.824000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T03:39:25.824000Z',
'mimetype': None,
'name': 'tutorial',
'path': 'tutorial',
'size': None,
'type': 'directory',
'writable': True},
{'content': None,
'created': '2025-03-11T13:38:43.433000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-11T13:38:43.433000Z',
'mimetype': None,
'name': 'Untitled.ipynb',
'path': 'Untitled.ipynb',
'size': 757,
'type': 'notebook',
'writable': True},
{'content': None,
'created': '2025-03-10T19:44:09.232000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T19:44:09.232000Z',
'mimetype': None,
'name': 'admin',
'path': 'admin',
'size': None,
'type': 'directory',
'writable': True},
{'content': None,
'created': '2025-03-10T19:30:41.339000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T19:30:41.339000Z',
'mimetype': None,
'name': 'Untitled Folder',
'path': 'Untitled Folder',
'size': None,
'type': 'directory',
'writable': True},
{'content': None,
'created': '2025-03-11T18:02:01.890000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-11T18:02:01.890000Z',
'mimetype': None,
'name': 'new_folder',
'path': 'new_folder',
'size': None,
'type': 'directory',
'writable': True},
{'content': None,
'created': '2025-03-11T13:36:21.950000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-11T13:36:21.950000Z',
'mimetype': 'text/markdown',
'name': 'README.md',
'path': 'README.md',
'size': 3847,
'type': 'file',
'writable': True},
{'content': None,
'created': '2024-06-04T00:59:23.527000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-06-04T00:59:23.527000Z',
'mimetype': None,
'name': 'test_domolibrary',
'path': 'test_domolibrary',
'size': None,
'type': 'directory',
'writable': True},
{'content': None,
'created': '2024-02-22T17:17:48.269000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-02-22T17:17:48.269000Z',
'mimetype': None,
'name': 'domo_jupyter_examples',
'path': 'domo_jupyter_examples',
'size': None,
'type': 'directory',
'writable': False}],
'created': '2025-03-11T13:38:43.437000Z',
'format': 'json',
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-11T13:38:43.437000Z',
'mimetype': None,
'name': '',
'path': '',
'size': None,
'type': 'directory',
'writable': True},
{'content': [{'content': None,
'created': '2025-03-10T21:52:02.073000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T21:52:02.073000Z',
'mimetype': None,
'name': 'song',
'path': 'admin/song',
'size': None,
'type': 'directory',
'writable': True}],
'created': '2025-03-10T19:44:09.232000Z',
'format': 'json',
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T19:44:09.232000Z',
'mimetype': None,
'name': 'admin',
'path': 'admin',
'size': None,
'type': 'directory',
'writable': True},
{'content': [{'content': None,
'created': '2024-03-25T21:42:31.550000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T21:42:31.550000Z',
'mimetype': None,
'name': 'domopalooza-24',
'path': 'tutorial/domopalooza-24',
'size': None,
'type': 'directory',
'writable': True}],
'created': '2024-03-25T03:39:25.824000Z',
'format': 'json',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T03:39:25.824000Z',
'mimetype': None,
'name': 'tutorial',
'path': 'tutorial',
'size': None,
'type': 'directory',
'writable': True},
{'content': {'cells': [{'cell_type': 'markdown',
'id': 'a1ec428a-5370-4e5b-a75f-651fc8e5b2eb',
'metadata': {},
'source': '```mermaid\n'
'flowchart LR\n'
'\n'
'A[Hard] -->|Text| B(Round)\n'
'B --> C{Decision}\n'
'C -->|One| D[Result 1]\n'
'C -->|Two| E[Result 2]\n'
'```'}],
'metadata': {'kernelspec': {'display_name': 'Python',
'language': 'python',
'name': 'python_3_9'},
'language_info': {'codemirror_mode': {'name': 'ipython',
'version': 3},
'file_extension': '.py',
'mimetype': 'text/x-python',
'name': 'python',
'nbconvert_exporter': 'python',
'pygments_lexer': 'ipython3',
'version': '3.9.13'}},
'nbformat': 4,
'nbformat_minor': 5},
'created': '2025-03-11T13:38:43.433000Z',
'format': 'json',
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-11T13:38:43.433000Z',
'mimetype': None,
'name': 'Untitled.ipynb',
'path': 'Untitled.ipynb',
'size': 757,
'type': 'notebook',
'writable': True},
{'content': [],
'created': '2025-03-10T19:30:41.339000Z',
'format': 'json',
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T19:30:41.339000Z',
'mimetype': None,
'name': 'Untitled Folder',
'path': 'Untitled Folder',
'size': None,
'type': 'directory',
'writable': True},
{'content': [{'content': None,
'created': '2025-03-11T18:02:01.885000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-11T18:02:01.885000Z',
'mimetype': 'text/plain',
'name': 'my_great_demo.txt',
'path': 'new_folder/my_great_demo.txt',
'size': 26,
'type': 'file',
'writable': True},
{'content': None,
'created': '2024-08-26T20:06:53.080000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-08-26T20:06:53.080000Z',
'mimetype': 'text/plain',
'name': 'updated_2024-08-26.txt',
'path': 'new_folder/updated_2024-08-26.txt',
'size': 60,
'type': 'file',
'writable': True},
{'content': None,
'created': '2025-03-10T19:33:21.148000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T19:33:21.148000Z',
'mimetype': 'text/plain',
'name': 'updated_2025-03-10.txt',
'path': 'new_folder/updated_2025-03-10.txt',
'size': 26,
'type': 'file',
'writable': True},
{'content': None,
'created': '2024-08-26T19:33:03.415000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-08-26T19:33:03.415000Z',
'mimetype': 'text/plain',
'name': 'updated_2024-03-06.txt',
'path': 'new_folder/updated_2024-03-06.txt',
'size': 60,
'type': 'file',
'writable': True}],
'created': '2025-03-11T18:02:01.890000Z',
'format': 'json',
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-11T18:02:01.890000Z',
'mimetype': None,
'name': 'new_folder',
'path': 'new_folder',
'size': None,
'type': 'directory',
'writable': True},
{'content': [{'content': None,
'created': '2025-03-10T21:08:22.510000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T21:08:22.510000Z',
'mimetype': None,
'name': 'untitled7',
'path': 'admin/song/untitled7',
'size': 0,
'type': 'file',
'writable': True},
{'content': None,
'created': '2025-03-10T20:53:34.527000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T20:53:34.527000Z',
'mimetype': None,
'name': 'untitled3',
'path': 'admin/song/untitled3',
'size': 0,
'type': 'file',
'writable': True},
{'content': None,
'created': '2025-03-10T21:35:14.774000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T21:35:14.774000Z',
'mimetype': None,
'name': 'untitled12',
'path': 'admin/song/untitled12',
'size': 0,
'type': 'file',
'writable': True},
{'content': None,
'created': '2025-03-10T20:16:42.347000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T20:16:42.347000Z',
'mimetype': 'text/plain',
'name': 'help5.txt',
'path': 'admin/song/help5.txt',
'size': 11,
'type': 'file',
'writable': True},
{'content': None,
'created': '2025-03-10T21:30:53.185000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T21:30:53.185000Z',
'mimetype': None,
'name': 'untitled9',
'path': 'admin/song/untitled9',
'size': 0,
'type': 'file',
'writable': True},
{'content': None,
'created': '2025-03-10T20:52:49.698000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T20:52:49.698000Z',
'mimetype': None,
'name': 'untitled1',
'path': 'admin/song/untitled1',
'size': 0,
'type': 'file',
'writable': True},
{'content': None,
'created': '2025-03-10T21:31:27.954000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T21:31:27.954000Z',
'mimetype': None,
'name': 'untitled10',
'path': 'admin/song/untitled10',
'size': 0,
'type': 'file',
'writable': True},
{'content': None,
'created': '2025-03-10T20:57:02.779000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T20:57:02.779000Z',
'mimetype': None,
'name': 'untitled5',
'path': 'admin/song/untitled5',
'size': 0,
'type': 'file',
'writable': True},
{'content': None,
'created': '2025-03-10T21:46:09.977000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T21:46:09.977000Z',
'mimetype': None,
'name': 'untitled14',
'path': 'admin/song/untitled14',
'size': 0,
'type': 'file',
'writable': True},
{'content': None,
'created': '2025-03-10T21:09:36.630000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T21:09:36.630000Z',
'mimetype': None,
'name': 'untitled8',
'path': 'admin/song/untitled8',
'size': 0,
'type': 'file',
'writable': True},
{'content': None,
'created': '2025-03-10T20:17:07.175000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T20:17:07.175000Z',
'mimetype': None,
'name': 'untitled',
'path': 'admin/song/untitled',
'size': 0,
'type': 'file',
'writable': True},
{'content': None,
'created': '2025-03-10T20:56:00.472000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T20:56:00.472000Z',
'mimetype': None,
'name': 'untitled4',
'path': 'admin/song/untitled4',
'size': 0,
'type': 'file',
'writable': True},
{'content': None,
'created': '2025-03-10T20:28:31.157000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T20:28:31.157000Z',
'mimetype': 'text/plain',
'name': 'help6.txt',
'path': 'admin/song/help6.txt',
'size': 11,
'type': 'file',
'writable': True},
{'content': None,
'created': '2025-03-10T21:43:12.468000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T21:43:12.468000Z',
'mimetype': None,
'name': 'untitled13',
'path': 'admin/song/untitled13',
'size': 0,
'type': 'file',
'writable': True},
{'content': None,
'created': '2025-03-10T20:53:13.577000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T20:53:13.577000Z',
'mimetype': None,
'name': 'untitled2',
'path': 'admin/song/untitled2',
'size': 0,
'type': 'file',
'writable': True},
{'content': None,
'created': '2025-03-10T21:34:45.832000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T21:34:45.832000Z',
'mimetype': None,
'name': 'untitled11',
'path': 'admin/song/untitled11',
'size': 0,
'type': 'file',
'writable': True},
{'content': None,
'created': '2025-03-10T21:05:52.203000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T21:05:52.203000Z',
'mimetype': None,
'name': 'untitled6',
'path': 'admin/song/untitled6',
'size': 0,
'type': 'file',
'writable': True},
{'content': None,
'created': '2025-03-10T21:52:02.073000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T21:52:02.073000Z',
'mimetype': None,
'name': 'untitled15',
'path': 'admin/song/untitled15',
'size': 0,
'type': 'file',
'writable': True}],
'created': '2025-03-10T21:52:02.073000Z',
'format': 'json',
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T21:52:02.073000Z',
'mimetype': None,
'name': 'song',
'path': 'admin/song',
'size': None,
'type': 'directory',
'writable': True},
{'content': [{'content': None,
'created': '2024-03-25T13:12:42.992000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T13:12:42.992000Z',
'mimetype': None,
'name': 'solutions',
'path': 'tutorial/domopalooza-24/solutions',
'size': None,
'type': 'directory',
'writable': True},
{'content': None,
'created': '2024-03-25T21:17:56.354000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T21:17:56.354000Z',
'mimetype': None,
'name': 'Tut3 - Generate a DomoStats style Dataset.ipynb',
'path': 'tutorial/domopalooza-24/Tut3 - Generate a DomoStats '
'style Dataset.ipynb',
'size': 33949,
'type': 'notebook',
'writable': True},
{'content': None,
'created': '2024-03-25T20:01:02.879000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T20:01:02.879000Z',
'mimetype': None,
'name': 'Tut1 - Authentication In Domo.ipynb',
'path': 'tutorial/domopalooza-24/Tut1 - Authentication In '
'Domo.ipynb',
'size': 31309,
'type': 'notebook',
'writable': True},
{'content': None,
'created': '2024-03-25T19:00:23.365000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T19:00:23.365000Z',
'mimetype': 'text/markdown',
'name': 'Introduction.md',
'path': 'tutorial/domopalooza-24/Introduction.md',
'size': 3493,
'type': 'file',
'writable': True},
{'content': None,
'created': '2024-03-25T03:39:26.808000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T03:39:26.808000Z',
'mimetype': None,
'name': 'functions',
'path': 'tutorial/domopalooza-24/functions',
'size': None,
'type': 'directory',
'writable': True},
{'content': None,
'created': '2024-03-25T03:39:26.824000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T03:39:26.824000Z',
'mimetype': None,
'name': 'implementations',
'path': 'tutorial/domopalooza-24/implementations',
'size': None,
'type': 'directory',
'writable': True},
{'content': None,
'created': '2024-03-25T20:59:33.903000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T20:59:33.903000Z',
'mimetype': None,
'name': 'Tut2 - Working with Objects and Domo Integration.ipynb',
'path': 'tutorial/domopalooza-24/Tut2 - Working with Objects '
'and Domo Integration.ipynb',
'size': 22890,
'type': 'notebook',
'writable': True},
{'content': None,
'created': '2024-03-25T03:39:26.747000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T03:39:26.747000Z',
'mimetype': 'text/markdown',
'name': 'README.md',
'path': 'tutorial/domopalooza-24/README.md',
'size': 2805,
'type': 'file',
'writable': True},
{'content': None,
'created': '2024-03-25T03:39:26.798000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T03:39:26.798000Z',
'mimetype': 'text/plain',
'name': 'env.txt',
'path': 'tutorial/domopalooza-24/env.txt',
'size': 31,
'type': 'file',
'writable': True},
{'content': None,
'created': '2024-03-25T21:42:31.544000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T21:42:31.544000Z',
'mimetype': None,
'name': 'Tut4 - Using Access Token Authentication and Updating '
'Domo via API.ipynb',
'path': 'tutorial/domopalooza-24/Tut4 - Using Access Token '
'Authentication and Updating Domo via API.ipynb',
'size': 33989,
'type': 'notebook',
'writable': True}],
'created': '2024-03-25T21:42:31.550000Z',
'format': 'json',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T21:42:31.550000Z',
'mimetype': None,
'name': 'domopalooza-24',
'path': 'tutorial/domopalooza-24',
'size': None,
'type': 'directory',
'writable': True},
{'content': '# Jupyter Workspaces - Python\n'
'\n'
'\n'
'## Intro\n'
'\n'
'Jupyter Workspaces in Domo are a web-based interactive '
'development environment for Jupyter notebooks, code, and data. '
'Workspaces are tightly integrated with Domo to allow users to '
'easily explore their Domo DataSets, leverage instantaneous code '
'execution to develop pipelines for data science and machine '
'learning, document their processes, create custom '
'visualizations, and write transformed data back into Domo.\n'
'\n'
'See the Domo [Knowledge '
'Base](https://domo-support.domo.com/s/article/36004740075?language=en_US)\n'
'for more information on using Jupyter Workspaces: \n'
'\n'
'Having issues with your workspace? Check out our '
'[troubleshooting '
'guide](https://domo-support.domo.com/s/article/7440921035671?language=en_US)!\n'
'\n'
'---\n'
'\n'
'## Exploring Your Data in Jupyter\n'
'\n'
'Any dataset that has been configured as an *Input* to your '
'Jupyter Workspace in Domo can be read into a dataframe in '
'Jupyter. In order to do this, import the domojupyter library and '
"call the `read_dataframe()` function with the alias you've "
'configured for your input dataset.\n'
'\n'
'```python\n'
' import domojupyter as domo\n'
" # Read the dataset configured with alias 'BMX I' as a pandas "
'dataframe\n'
" bmx = domo.read_dataframe('BMX I')\n"
' bmx.head()\n'
'```\n'
'\n'
"domo.read_dataframe will cast the column's dtypes based on the "
'provided schema. However, the user can override the default '
'dtypes. \n'
'When using the domo.read_dataframe function you are able to use '
'any parameter that is included in '
'[pandas.read_csv](https://pandas.pydata.org/docs/reference/api/pandas.read_csv.html):\n'
'\n'
"Here's an example utilizing multiple args, overriding a few of "
'the column\'s dypes and changing the "date" column into a '
'datetime64 dtype: \n'
'```python\n'
"read_dataframe('Test_DataSource', query='SELECT * FROM table', "
"dtype={'P': 'int64', 'D': 'object', 'price': 'float64'}, "
"parse_dates=['date'], na_filter=False)\n"
'```\n'
'\n'
'\n'
'---\n'
'\n'
'## Query Data Using SQL\n'
'\n'
'Datasets can be queried with SQL-like syntax. This can be used '
'to limit the size of the data returned for large datasets or to '
'leverage the power of Domo to perform aggregations on the fly.\n'
'\n'
'```python\n'
' import domojupyter as domo\n'
" demo = domo.read_dataframe('DEMO I', query='SELECT SEQN, "
'RIAGENDR AS Gender, RIDAGEYR AS Age FROM table WHERE RIDAGEYR > '
"20')\n"
' demo.head()\n'
'```\n'
'---\n'
'\n'
'## Write Data Back to Domo\n'
'\n'
"If you've made some transformations that you'd like to preserve "
'as a separate dataset in Domo, configure your workspace to '
'include an *Output* dataset. Then use the `write_dataframe()` '
"function with your dataframe and the alias you've configured for "
'your output dataset as parameters.\n'
'\n'
'\n'
'```python\n'
' import domojupyter as domo\n'
' # Write dataframe to Domo dataset configured with alias '
"'Jupyter Data'\n"
" domo.write_dataframe(df, 'Jupyter Data')\n"
'```\n'
'\n'
'To leverage Append, Upsert and or Partition functionality, use '
'the following commands to update a DataSet:\n'
'\n'
'```python\n'
'domo.write_dataframe(df, output_dataset)\n'
'domo.write_dataframe(df, output_dataset, '
'update_method="APPEND")\n'
'domo.write_dataframe(df, output_dataset, update_method="UPSERT", '
'update_key=column_name)\n'
'domo.write_dataframe(df, output_dataset, '
'update_method="PARTITION", partition_name=’Example Name’)\n'
'```\n'
'\n'
'---\n'
'\n'
'## Updating or checking your sdk version\n'
'You can check your domojupyter version by running the following '
'command in a cell:\n'
'```python\n'
' import domojupyter as domo\n'
' domo.__version__\n'
'```\n'
'\n'
'Update to the latest version by running:\n'
'```commandline\n'
'conda install -c {conda_channel} domojupyter={latest}\n'
'```\n'
'\n'
'Ex:\n'
'```commandline\n'
'conda install -c $DOMO_CONDA_CHANNEL domojupyter=1.1.0\n'
'```\n'
'\n'
'---\n'
'\n'
'## Installing Additional Libraries\n'
'\n'
'3rd party libraries not already included in the workspace can be '
'installed using pip for Python, CRAN for R or Conda for both.\n'
'\n'
'```bash\n'
' pip install requests-toolbelt\n'
' \n'
' OR\n'
'\n'
' conda install requests-toolbelt\n'
'```',
'created': '2025-03-11T13:36:21.950000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-11T13:36:21.950000Z',
'mimetype': 'text/markdown',
'name': 'README.md',
'path': 'README.md',
'size': 3847,
'type': 'file',
'writable': True},
{'content': [{'content': None,
'created': '2024-03-21T05:25:37.580000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-21T05:25:37.580000Z',
'mimetype': None,
'name': 'assembly.ipynb',
'path': 'test_domolibrary/assembly.ipynb',
'size': 63771,
'type': 'notebook',
'writable': True},
{'content': None,
'created': '2024-06-04T00:59:23.522000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-06-04T00:59:23.522000Z',
'mimetype': None,
'name': 'Untitled.ipynb',
'path': 'test_domolibrary/Untitled.ipynb',
'size': 1216,
'type': 'notebook',
'writable': True},
{'content': None,
'created': '2024-03-21T14:07:18.508000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-21T14:07:18.508000Z',
'mimetype': None,
'name': 'assembly_implementation.ipynb',
'path': 'test_domolibrary/assembly_implementation.ipynb',
'size': 51215,
'type': 'notebook',
'writable': True},
{'content': None,
'created': '2024-03-20T19:31:23.183000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-20T19:31:23.183000Z',
'mimetype': None,
'name': 'Untitled(1).ipynb',
'path': 'test_domolibrary/Untitled(1).ipynb',
'size': 28131,
'type': 'notebook',
'writable': True},
{'content': None,
'created': '2024-03-20T15:15:47.590000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-20T15:15:47.590000Z',
'mimetype': 'text/plain',
'name': 'env.txt',
'path': 'test_domolibrary/env.txt',
'size': 63,
'type': 'file',
'writable': True},
{'content': None,
'created': '2024-03-20T15:13:33.590000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-20T15:13:33.590000Z',
'mimetype': None,
'name': 'Tut4 - Using Access Token Authentication and Updating '
'Domo via API.ipynb',
'path': 'test_domolibrary/Tut4 - Using Access Token '
'Authentication and Updating Domo via API.ipynb',
'size': 14982,
'type': 'notebook',
'writable': True}],
'created': '2024-06-04T00:59:23.527000Z',
'format': 'json',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-06-04T00:59:23.527000Z',
'mimetype': None,
'name': 'test_domolibrary',
'path': 'test_domolibrary',
'size': None,
'type': 'directory',
'writable': True},
{'content': 'jae is excellent at demoes',
'created': '2025-03-11T18:02:01.885000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-11T18:02:01.885000Z',
'mimetype': 'text/plain',
'name': 'my_great_demo.txt',
'path': 'new_folder/my_great_demo.txt',
'size': 26,
'type': 'file',
'writable': True},
{'content': "jae rocks at debugging. he's superfly -- updated 2024-08-26",
'created': '2024-08-26T19:33:03.415000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-08-26T19:33:03.415000Z',
'mimetype': 'text/plain',
'name': 'updated_2024-03-06.txt',
'path': 'new_folder/updated_2024-03-06.txt',
'size': 60,
'type': 'file',
'writable': True},
{'content': "jae rocks at debugging. he's superfly -- updated 2024-08-26",
'created': '2024-08-26T20:06:53.080000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-08-26T20:06:53.080000Z',
'mimetype': 'text/plain',
'name': 'updated_2024-08-26.txt',
'path': 'new_folder/updated_2024-08-26.txt',
'size': 60,
'type': 'file',
'writable': True},
{'content': 'jae is excellent at demoes',
'created': '2025-03-10T19:33:21.148000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T19:33:21.148000Z',
'mimetype': 'text/plain',
'name': 'updated_2025-03-10.txt',
'path': 'new_folder/updated_2025-03-10.txt',
'size': 26,
'type': 'file',
'writable': True},
{'content': '',
'created': '2025-03-10T21:35:14.774000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T21:35:14.774000Z',
'mimetype': 'text/plain',
'name': 'untitled12',
'path': 'admin/song/untitled12',
'size': 0,
'type': 'file',
'writable': True},
{'content': 'hello world',
'created': '2025-03-10T20:16:42.347000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T20:16:42.347000Z',
'mimetype': 'text/plain',
'name': 'help5.txt',
'path': 'admin/song/help5.txt',
'size': 11,
'type': 'file',
'writable': True},
{'content': '',
'created': '2025-03-10T20:53:34.527000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T20:53:34.527000Z',
'mimetype': 'text/plain',
'name': 'untitled3',
'path': 'admin/song/untitled3',
'size': 0,
'type': 'file',
'writable': True},
{'content': '',
'created': '2025-03-10T21:08:22.510000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T21:08:22.510000Z',
'mimetype': 'text/plain',
'name': 'untitled7',
'path': 'admin/song/untitled7',
'size': 0,
'type': 'file',
'writable': True},
{'content': '',
'created': '2025-03-10T21:30:53.185000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T21:30:53.185000Z',
'mimetype': 'text/plain',
'name': 'untitled9',
'path': 'admin/song/untitled9',
'size': 0,
'type': 'file',
'writable': True},
{'content': [{'content': None,
'created': '2024-03-25T12:37:00.563000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T12:37:00.563000Z',
'mimetype': 'text/x-python',
'name': 'utils.py',
'path': 'tutorial/domopalooza-24/solutions/utils.py',
'size': 1536,
'type': 'file',
'writable': True},
{'content': None,
'created': '2024-03-25T12:57:25.935000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T12:57:25.935000Z',
'mimetype': 'text/x-python',
'name': 'access_tokens.py',
'path': 'tutorial/domopalooza-24/solutions/access_tokens.py',
'size': 2801,
'type': 'file',
'writable': True},
{'content': None,
'created': '2024-03-25T03:39:26.888000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T03:39:26.888000Z',
'mimetype': 'text/x-python',
'name': 'get_accounts_v1.py',
'path': 'tutorial/domopalooza-24/solutions/get_accounts_v1.py',
'size': 357,
'type': 'file',
'writable': True},
{'content': None,
'created': '2024-03-25T03:39:26.905000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T03:39:26.905000Z',
'mimetype': 'text/x-python',
'name': 'get_session_token.py',
'path': 'tutorial/domopalooza-24/solutions/get_session_token.py',
'size': 670,
'type': 'file',
'writable': True},
{'content': None,
'created': '2024-03-25T03:39:26.879000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T03:39:26.879000Z',
'mimetype': 'text/x-python',
'name': 'client.py',
'path': 'tutorial/domopalooza-24/solutions/client.py',
'size': 1011,
'type': 'file',
'writable': True},
{'content': None,
'created': '2024-03-25T03:39:26.922000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T03:39:26.922000Z',
'mimetype': 'text/x-python',
'name': 'read_domo_jupyter_account_v2.py',
'path': 'tutorial/domopalooza-24/solutions/read_domo_jupyter_account_v2.py',
'size': 458,
'type': 'file',
'writable': True},
{'content': None,
'created': '2024-03-25T12:58:36.889000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T12:58:36.889000Z',
'mimetype': 'text/x-python',
'name': 'users.py',
'path': 'tutorial/domopalooza-24/solutions/users.py',
'size': 833,
'type': 'file',
'writable': True},
{'content': None,
'created': '2024-03-25T03:39:26.870000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T03:39:26.870000Z',
'mimetype': 'text/x-python',
'name': 'auth.py',
'path': 'tutorial/domopalooza-24/solutions/auth.py',
'size': 1191,
'type': 'file',
'writable': True},
{'content': None,
'created': '2024-03-25T12:36:12.724000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T12:36:12.724000Z',
'mimetype': 'text/x-python',
'name': 'read_domo_jupyter_account_v1.py',
'path': 'tutorial/domopalooza-24/solutions/read_domo_jupyter_account_v1.py',
'size': 430,
'type': 'file',
'writable': True},
{'content': None,
'created': '2024-03-25T03:39:26.897000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T03:39:26.897000Z',
'mimetype': 'text/x-python',
'name': 'get_accounts_v2.py',
'path': 'tutorial/domopalooza-24/solutions/get_accounts_v2.py',
'size': 771,
'type': 'file',
'writable': True},
{'content': None,
'created': '2024-03-25T03:39:26.842000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T03:39:26.842000Z',
'mimetype': 'text/x-python',
'name': '__init__.py',
'path': 'tutorial/domopalooza-24/solutions/__init__.py',
'size': 0,
'type': 'file',
'writable': True},
{'content': None,
'created': '2024-03-25T13:12:42.987000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T13:12:42.987000Z',
'mimetype': 'text/x-python',
'name': 'accounts.py',
'path': 'tutorial/domopalooza-24/solutions/accounts.py',
'size': 5758,
'type': 'file',
'writable': True}],
'created': '2024-03-25T13:12:42.992000Z',
'format': 'json',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T13:12:42.992000Z',
'mimetype': None,
'name': 'solutions',
'path': 'tutorial/domopalooza-24/solutions',
'size': None,
'type': 'directory',
'writable': True},
{'content': '# Intro to Jupyter Workspaces\n'
'\n'
'Presented by [Jae Wilson](https://www.linkedin.com/in/jaewor/) '
'and [Riley '
'Stahura](https://www.linkedin.com/in/riley-stahura-022128121) @ '
'[Domopalooza 24](https://www.domo.com/domopalooza)\n'
'\n'
'**Login @ domo-training-jupyter OR domo-community**\n'
'\n'
'for domo-training-jupyter email = '
'"<your_prefix>@domosoftware.net, password = Training!<br>\n'
"for domo-community if you don't know your login ask a TA to add "
'you\n'
'```\n'
'git clone https://github.com/jaewilson07/domopalooza-24.git\n'
'```\n'
'\n'
'### Audience\n'
'\n'
'Domo Data Specialists with Intermediate to advanced Python '
'coding experience\n'
'\n'
'### Prerequisite Domo University Courses\n'
'\n'
'- Working with DataSets in Domo\n'
'- Transforming Data in Domo\n'
'\n'
'You can enroll in these courses at any time though Domo '
'University.\n'
'\n'
'### Description\n'
'\n'
'Jupyter Workspaces in Domo is a web-based interactive '
'development environment for Jupyter notebooks, code, and data. '
'In this course, you’ll learn how to integrate Jupyter into your '
'Domo data connection and transformation pipeline.\n'
'\n'
'## 🥅 Learning Objectives\n'
'\n'
'---\n'
'\n'
'Upon completing this course learners should be able to:\n'
'\n'
'- Create and run a Jupyter Workspace DataFlow in Domo\n'
'- Integrate input and output DataSets with Jupyter Workspaces\n'
'- Create accounts in Domo for secure programmatic credential '
'access\n'
'- Setup scheduling/triggering for Jupyter Workspaces DataFlows\n'
'\n'
'## 📋 Agenda\n'
'\n'
'---\n'
'\n'
'### Welcome and Introduction to Jupyter\n'
'\n'
'#### 1300 - Introduction & Workspaces Setup\n'
'\n'
'- Introductions & Objectives\n'
'- Jupyter and Domo\n'
'- Where is Jupyter located in Domo?\n'
'- Workspace Configuration\n'
'- Optional Configuration Steps\n'
'\n'
' - Input Datasets\n'
' - Output Datasets\n'
' - Accounts\n'
' - File Share\n'
' <br>\n'
'\n'
'- **Jupyter Workspaces Setup**\n'
' - ▶️Login at '
'[domo-training-jupyter](https://domo-training-jupyter.domo.com) '
'OR [domo-community](http://domo-community.domo.com) -- if you '
"need to be domo'ed to the community instance let the TAs know.\n"
' - ▶️ Spin up a Jupyter Workspace\n'
' - ▶️ Clone [GitHub '
'repo](https://github.com/jaewilson07/domopalooza-24.git) via '
'terminal\n'
' \n'
' ```\n'
' git clone '
'https://github.com/jaewilson07/domopalooza-24.git\n'
' ``` \n'
' <br>\n'
'\n'
'#### Tutorial 1 - Authentication in Domo\n'
'\n'
'- API request basics\n'
'- token-based authentication\n'
'- network monitoring for API discovery\n'
'\n'
'### 1400 - Workspace Management\n'
'\n'
'- Changing Workspace Ownership\n'
'- Enabling Sharing and Sharing a Workspace\n'
' <br>\n'
'- ▶️ Create a "DomoAccessToken" and "Abstract Credentials Store" '
'account containing userame & password. Share w. JupyerWorkspace\n'
'- ▶️ Add an Output Dataset - "AccountList" to JupyterWorkspace\n'
' <br>\n'
'- Creating a Jupyter Notebook\n'
'- Left-hand navigation - Files, Input/Output Datasets, Accounts\n'
'- Domo Jupyter Library\n'
' - Reading and Writing to a Dataset\n'
' - Getting Account Credentials\n'
'\n'
'#### Tutorial 2 & Break - Workspace Management, Working with '
'Accounts & Domo Integration\n'
'\n'
'- Read Account Objects in Jupyter Workspaces\n'
'- Export a dataframe to a Domo Dataset\n'
'\n'
'### 1500 - Using DomoJupyter for Automation\n'
'\n'
'- Trigger from Dataset\n'
'- Trigger on Schedule\n'
'\n'
'#### Tutorial 3 - Generate a DomoStats style dataset\n'
'\n'
'- Get Accounts from DomoAccounts and format as a dataset\n'
'- Merging API requests in a dataset\n'
'\n'
'#### Tutorial 4 - (EXTRA) Access Token Authentication and '
'updating Domo via API\n'
'\n'
'- generate an access_token and update an Account Object in Domo\n'
'\n'
'### 1545 - Q&A Wrapup\n'
'\n'
'- Common Use Cases\n'
'- Q&A\n'
'- [End of course Survey '
'Link](https://domo.az1.qualtrics.com/jfe/form/SV_6QjzvNqLHyuDcai)\n',
'created': '2024-03-25T19:00:23.365000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T19:00:23.365000Z',
'mimetype': 'text/markdown',
'name': 'Introduction.md',
'path': 'tutorial/domopalooza-24/Introduction.md',
'size': 3493,
'type': 'file',
'writable': True},
{'content': {'cells': [{'cell_type': 'markdown',
'id': '416e4643-3929-401a-a290-c16f5fa669d3',
'metadata': {},
'source': '# 🚀 How do I send a API requests?\n'
'\n'
"1. How can I reverse engineer 'the "
"correct' API request when there is no "
'documentation?\n'
'\n'
' - Monitor network traffic in the '
'browser\n'
' - use the `log-api` command in [Domo '
'Java '
'CLI](https://domo-support.domo.com/s/article/360043437733?language=en_US)\n'
' - see [✨ Jae Wilsons '
'TreasureTrove](./README.md#helpful-links)\n'
'<br>\n'
'\n'
'2. How does the internet handle '
'authentication?\n'
' - pass authentication in cookies\n'
' - pass authentication via request '
'headers\n'
' - different APIs support different '
'authentication schemes'},
{'cell_type': 'markdown',
'id': 'e1fad5b8',
'metadata': {},
'source': '## ▶️ How to Monitor Network Traffic\n'
'\n'
'1. Go to [Domo > Data > '
'Accounts](https://domo-community.domo.com/datacenter/accounts) '
'to view a list of all accounts you have '
'access to.\n'
'\n'
'2. To Monitor network traffic > Inspect > '
'Network. \n'
'\n'
'3. Find the API request.\n'
' - Filter for "providers".\n'
' - Examine the URL, headers, request '
'Method (GET, PUT, POST, DELETE) and '
'body<br>\n'
' - Copy the query into a text editor.\n'},
{'cell_type': 'markdown',
'id': '6e2bc323',
'metadata': {},
'source': '### 3 ways to Authenticate the same API '
'request'},
{'cell_type': 'raw',
'id': 'e2bec108-314d-4d95-9921-ecf26f57de7b',
'metadata': {},
'source': '# cookie extracted from browser\n'
'curl '
"'https://domo-community.domo.com/api/data/v2/datasources/providers' "
'\\\n'
" -H 'accept-language: en' \\\n"
" -H 'cookie: <REMOVED>\n"
'\n'
'# session_token generated by username + '
'password Auth Flow\n'
'curl '
"'https://domo-community.domo.com/api/data/v2/datasources/providers' "
'\\\n'
" -H 'accept-language: en' \\\n"
" -H 'X-Domo-Authentication: "
'<session_token>\n'
'\n'
'# access_token generated in Domo > Admin > '
'Authentication > Access Tokens\n'
'curl '
"'https://domo-community.domo.com/api/data/v2/datasources/providers' "
'\\\n'
" -H 'accept-language: en' \\\n"
" -H 'x-domo-developer-token: "
'<access_token>'},
{'cell_type': 'markdown',
'id': 'c2319cc6-ca05-4fe5-b4b1-4f3eb0dd6773',
'metadata': {},
'source': '### ▶️🍪 convert an API request into a '
'function\n'
'\n'
'> Functions improve code legibility, '
'recycle-ability, and maintainability by '
'being *callable* and *parameterized*\n'
'\n'
'1. modify the starter function below '
'receive `headers: dict` and modify the '
'request.\n'
'```\n'
"headers = {'cookie': <your_header>}\n"
'```\n'
'2. Use the `requests` library to send an '
'API request to the providers endpoint.\n'
'3. test by scraping your browser cookie '
'and passing it into `headers`\n'
'\n'
'4. copy your finished function into a new '
'file `./functions/accounts.py`.\n'
'\n'
'5. modify your test to import your '
'function from the module\n'
'\n'
'```\n'
'from functions.accounts import '
'get_accounts()\n'
'```'},
{'cell_type': 'code',
'execution_count': None,
'id': '0b6f6c57',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': '# uncomment to install the requests '
'library\n'
'# %pip install requests'},
{'cell_type': 'code',
'execution_count': 17,
'id': '94c0d58d-df1c-491a-b0f8-afa5a4ad4078',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'import requests\n'
'\n'
'# FIX ME -- then move me into '
'./functions/accounts.py\n'
'def get_accounts(domo_instance : str,\n'
' headers : dict = None,\n'
' debug_api: bool = False,\n'
' return_raw: bool = '
'False,\n'
' ):\n'
' \n'
' url = '
'f"https://{domo_instance}.domo.com/api/data/v2/datasources/providers"\n'
' \n'
" method = 'get'\n"
' \n'
' if debug_api:\n'
' print({"url": url,\n'
' "method" : method,\n'
' "headers" : headers})\n'
' \n'
' res = requests.request(method=method, '
'headers = headers, url=url)\n'
' \n'
' if return_raw:\n'
' return res\n'
' \n'
' if not res.ok:\n'
' return res\n'
' \n'
' return res.json()'},
{'cell_type': 'markdown',
'id': '027cb022',
'metadata': {},
'source': '#### Test Implementation of get_accounts'},
{'cell_type': 'code',
'execution_count': 16,
'id': '2ca59628',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'name': 'stdout',
'output_type': 'stream',
'text': "{'url': "
"'https://domo-community.domo.com/api/data/v2/datasources/providers', "
"'method': 'get', 'headers': "
'None}\n'},
{'data': {'text/plain': '<Response '
'[401]>'},
'execution_count': 16,
'metadata': {},
'output_type': 'execute_result'}],
'source': '# from solutions.get_accounts_v1 import '
'get_accounts\n'
'\n'
'DOMO_INSTANCE = (\n'
' "domo-community" ## it\'s common '
'practice to declare constants using all '
'caps.\n'
')\n'
'COOKIE = "did=1590870972; '
's_fid=14027BEDE03AABE3-1D57696C91E228F7; '
's_cc=true; '
'_gcl_au=1.1.798483207.1708976644; '
'ELOQUA=GUID=9F658543F2AF4770B3902A889C3E0149; '
'eb03b5b0dbaeb744_cfid=76aibea92e509b8h4gac3h53682dbc5e02a05354ad0227778da19312207b2d4269c4ai7d25a55h2g80647f0i5ab73333aj041f1d5g1d6a419c97cac24cad082d; '
'eb03b5b0dbaeb744_cffid=8f20296ebdab4c9b8715a8a2262d1e1190c851145274a40f5c452e8j629da51abg93b68j9d281g33497d635j8d4d0fc49a8h6a638h082e17bd251d0b56a7b9bb; '
'_pubweb_is_cus=true; redirectUrl=%2F; '
'PLAY_SESSION=c36fa5593ab7be756ccf9fcecc80563927abcc89-isProxied=false; '
'CENTERVIEWSESSIONID=1893952720-mmmm-0012-0200; '
'SESSION_TOE=QK0KLCFP5A; '
'_dsidv1=f50753ba-1214-4fdd-a12d-fd2b333d91fe; '
's_vnum=1961437443894%26vn%3D4; '
'_clck=1o0ep0c%7C2%7Cfkd%7C0%7C1517; '
'_gid=GA1.2.1726355723.1711337618; '
's_sq=%5B%5BB%5D%5D; '
'_clsk=9qyhg%7C1711337693910%7C3%7C1%7Cd.clarity.ms%2Fcollect; '
'_ga_3RM9SF8PCZ=GS1.1.1711337617.6.1.1711337878.60.0.0; '
'_ga=GA1.1.813433713.1708976644; '
'_ga_KCXF7VX0J3=GS1.1.1711384819.2.0.1711384819.0.0.0; '
'_ga_P3SE4R9WJH=GS1.1.1711389723.4.0.1711389723.0.0.0; '
'mbox=PC#a9a622395a684f72bfe3dd800361498b.35_0#1774634554|session#502b3875024a4a888a1765d0bda5bfd9#1711391614; '
'_pubweb_idc=mmmm-0012-0200_#_standard; '
'DA-SID-prod1-mmmm-0032-6769=eyJjdXN0b21lcklkIjoibW1tbS0wMDMyLTY3NjkiLCJleHBpcmF0aW9uIjoxNzExNDIzNTE1MDAwLCJobWFjU2lnbmF0dXJlIjoiMzQ0ODgwMjdiOWUwOTNhOGMyODVmYTEzZjNjZDI0MjRiYzY2MzQ2OTQzMGMzMTk3NWNkZmMxOGM4YTRhMzNjMCIsInNpZCI6ImIwOWM3YzFhLWU4ODYtNDg5YS05OWJjLTVmZGJhMGNkMmFkNSIsInRpbWVzdGFtcCI6MTcxMTM5NDcxNTAwMCwidG9lcyI6IlVOS05PV05TSUQiLCJ1c2VySWQiOiIxNzQzNTU1MjQyIn0%3D; '
'csrf-token=332add0c-383f-4dd0-a59c-0696f8d0baf9; '
'DA-SID-prod1-mmmm-0012-0200=eyJjdXN0b21lcklkIjoibW1tbS0wMDEyLTAyMDAiLCJleHBpcmF0aW9uIjoxNzExNDIzNjY1MDAwLCJobWFjU2lnbmF0dXJlIjoiZWI1ZjNmMjU5ZmFjMDAwODM1YzFhMjZhYmZmMWQwZTIzM2Q1N2JkY2I2NWVmOTY2NTM5YjFkZDQ4NmIxMDZkMCIsInNpZCI6IjNhMmNjNDMxLWYzNzQtNDEyZS1iMTZkLTA0ZDAzMGRmMzE3MiIsInRpbWVzdGFtcCI6MTcxMTM5NDg2NTAwMCwidG9lcyI6IlVOS05PV05TSUQiLCJ1c2VySWQiOiIxODkzOTUyNzIwIn0%3D; '
'amplitude_id_c68dc3f20888d7c6242144da91c31629domo.com=eyJkZXZpY2VJZCI6IjM4NzlmNWQwLTM3Y2UtNGZhOS05NzQ5LWM5NjVmOTg2OWNjY1IiLCJ1c2VySWQiOiIzOUZCMDBBNEY2MkZDQjRDMzM2QThBNkI3Q0MyMkUzNTg1OEE5NzY3ODAwNEJEOTMwMDQ3QzIwQ0RCMDc3OUE5Iiwib3B0T3V0IjpmYWxzZSwic2Vzc2lvbklkIjoxNzExMzkyMjU4NTA4LCJsYXN0RXZlbnRUaW1lIjoxNzExMzk0ODY2NDQ5LCJldmVudElkIjoyNjEsImlkZW50aWZ5SWQiOjExMCwic2VxdWVuY2VOdW1iZXIiOjM3MX0="\n'
'\n'
'# fix me\n'
'headers = {"cookie" : COOKIE}\n'
'\n'
'res = '
'get_accounts(domo_instance=DOMO_INSTANCE,\n'
' # headers = headers,\n'
' debug_api = True,\n'
' return_raw = True\n'
' )\n'
'res'},
{'cell_type': 'markdown',
'id': '834f5a42',
'metadata': {},
'source': '### 🎓 What is <Response [401]>\n'
'\n'
'1. requests.request [returns an instance '
'of the Response '
'class](https://www.geeksforgeeks.org/response-request-python-requests/) '
'|| `requests.models.Response`\n'
'\n'
'2. classes are `dict` that have attributes '
'(fields) and methods (functions)\n'
' - ex. the `Response` class has '
'attributes like `status_code` and method '
'`.json()`'},
{'cell_type': 'code',
'execution_count': 8,
'id': '54769366-26ab-46a5-9667-248933af6ff0',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'name': 'stdout',
'output_type': 'stream',
'text': '<class '
"'requests.models.Response'>\n"
"{'status': 200, 'is_success': "
'True}\n'
'\n'
'\n'},
{'data': {'text/plain': "[{'key': "
"'abstract-credential-store',\n"
" 'name': "
"'Abstract "
'Credential '
"Store',\n"
' '
"'authenticationScheme': "
"'fields',\n"
' '
"'unassociatedDataSourceCount': "
'0,\n'
" 'accounts': "
"[{'id': 71,\n"
" 'name': "
"'domo_creds',\n"
" 'userId': "
"'1893952720',\n"
' '
"'displayName': "
"'domolibrary "
'test account - '
'updated '
"2024-03-23',\n"
" 'type': "
"'data',\n"
' '
"'dataProviderType': "
"'abstract-credential-store',\n"
" 'valid': "
'True,\n'
' '
"'dateOfExpiration': "
'None,\n'
' '
"'dataSourceCount': "
'0,\n'
' '
"'daysToExpiry': "
'None,\n'
" 'expired': "
'None},\n'
" {'id': 87,\n"
" 'name': "
"'Abstract "
'Credential Store '
"Account',\n"
" 'userId': "
"'1893952720',\n"
' '
"'displayName': "
"'jw_creds',\n"
" 'type': "
"'data',\n"
' '
"'dataProviderType': "
"'abstract-credential-store',\n"
" 'valid': "
'True,\n'
' '
"'dateOfExpiration': "
'None,\n'
' '
"'dataSourceCount': "
'0,\n'
' '
"'daysToExpiry': "
'None,\n'
" 'expired': "
'None},\n'
" {'id': 88,\n"
" 'name': "
"'fake_account',\n"
" 'userId': "
"'1893952720',\n"
' '
"'displayName': "
"'fake_account',\n"
" 'type': "
"'data',\n"
' '
"'dataProviderType': "
"'abstract-credential-store',\n"
" 'valid': "
'True,\n'
' '
"'dateOfExpiration': "
'None,\n'
' '
"'dataSourceCount': "
'0,\n'
' '
"'daysToExpiry': "
'None,\n'
" 'expired': "
'None},\n'
" {'id': 92,\n"
" 'name': "
"'jw_username_password_auth',\n"
" 'userId': "
"'1893952720',\n"
' '
"'displayName': "
"'jw_username_password_auth',\n"
" 'type': "
"'data',\n"
' '
"'dataProviderType': "
"'abstract-credential-store',\n"
" 'valid': "
'True,\n'
' '
"'dateOfExpiration': "
'None,\n'
' '
"'dataSourceCount': "
'0,\n'
' '
"'daysToExpiry': "
'None,\n'
" 'expired': "
'None},\n'
" {'id': 94,\n"
" 'name': "
"'Abstract "
'Credential Store '
"Account',\n"
" 'userId': "
"'1893952720',\n"
' '
"'displayName': "
"'my_domo_community_access_token "
'- updated '
"2024-02-23',\n"
" 'type': "
"'data',\n"
' '
"'dataProviderType': "
"'abstract-credential-store',\n"
" 'valid': "
'True,\n'
' '
"'dateOfExpiration': "
'None,\n'
' '
"'dataSourceCount': "
'0,\n'
' '
"'daysToExpiry': "
'None,\n'
" 'expired': "
'None},\n'
" {'id': 99,\n"
" 'name': "
"'Abstract "
'Credential Store '
"Account',\n"
" 'userId': "
"'1893952720',\n"
' '
"'displayName': "
"'Abstract "
'Credential Store '
"Account',\n"
" 'type': "
"'data',\n"
' '
"'dataProviderType': "
"'abstract-credential-store',\n"
" 'valid': "
'True,\n'
' '
"'dateOfExpiration': "
'None,\n'
' '
"'dataSourceCount': "
'0,\n'
' '
"'daysToExpiry': "
'None,\n'
" 'expired': "
'None},\n'
" {'id': 102,\n"
" 'name': "
"'my_domo_community_access_token "
'- updated '
'2024-03-23 '
"(2)',\n"
" 'userId': "
"'1893952720',\n"
' '
"'displayName': "
"'dp24 - update "
'2024-03-25 '
"13:16:51.271591',\n"
" 'type': "
"'data',\n"
' '
"'dataProviderType': "
"'abstract-credential-store',\n"
" 'valid': "
'True,\n'
' '
"'dateOfExpiration': "
'None,\n'
' '
"'dataSourceCount': "
'0,\n'
' '
"'daysToExpiry': "
'None,\n'
" 'expired': "
'None}]},\n'
" {'key': 'api',\n"
" 'name': "
"'API',\n"
' '
"'unassociatedDataSourceCount': "
'7,\n'
" 'accounts': "
'[]},\n'
" {'key': "
"'dataset-copy',\n"
" 'name': "
"'DataSet Copy',\n"
' '
"'authenticationScheme': "
"'fields',\n"
' '
"'unassociatedDataSourceCount': "
'0,\n'
" 'accounts': "
"[{'id': 1,\n"
" 'name': "
"'DataSet Copy "
"Account',\n"
" 'userId': "
"'1893952720',\n"
' '
"'displayName': "
"'dsa - "
"northshore',\n"
" 'type': "
"'data',\n"
' '
"'dataProviderType': "
"'dataset-copy',\n"
" 'valid': "
'True,\n'
' '
"'dateOfExpiration': "
'None,\n'
' '
"'dataSourceCount': "
'1,\n'
' '
"'daysToExpiry': "
'None,\n'
" 'expired': "
'None}]},\n'
" {'key': "
"'dataset-view',\n"
" 'name': "
"'DataSet View',\n"
' '
"'unassociatedDataSourceCount': "
'7,\n'
" 'accounts': "
'[]},\n'
" {'key': "
"'domo-access-token',\n"
" 'name': 'Domo "
"Access Token',\n"
' '
"'authenticationScheme': "
"'fields',\n"
' '
"'unassociatedDataSourceCount': "
'0,\n'
" 'accounts': "
"[{'id': 96,\n"
" 'name': "
"'Domo Access "
"Token Account',\n"
" 'userId': "
"'1893952720',\n"
' '
"'displayName': "
"'Domo Access "
"Token Account',\n"
" 'type': "
"'data',\n"
' '
"'dataProviderType': "
"'domo-access-token',\n"
" 'valid': "
'True,\n'
' '
"'dateOfExpiration': "
'None,\n'
' '
"'dataSourceCount': "
'0,\n'
' '
"'daysToExpiry': "
'None,\n'
" 'expired': "
'None},\n'
" {'id': 100,\n"
" 'name': "
"'Domo Access "
'Token Account '
"(2)',\n"
" 'userId': "
"'1893952720',\n"
' '
"'displayName': "
"'domo-community',\n"
" 'type': "
"'data',\n"
' '
"'dataProviderType': "
"'domo-access-token',\n"
" 'valid': "
'True,\n'
' '
"'dateOfExpiration': "
'None,\n'
' '
"'dataSourceCount': "
'0,\n'
' '
"'daysToExpiry': "
'None,\n'
" 'expired': "
'None}]},\n'
" {'key': "
"'domo-csv',\n"
" 'name': "
"'DataSet Copy',\n"
' '
"'authenticationScheme': "
"'fields',\n"
' '
"'unassociatedDataSourceCount': "
'0,\n'
" 'accounts': "
"[{'id': 27,\n"
" 'name': "
"'DataSet Copy "
"Account',\n"
" 'userId': "
"'1893952720',\n"
' '
"'displayName': "
"'DataSet Copy "
"Account',\n"
" 'type': "
"'data',\n"
' '
"'dataProviderType': "
"'domo-csv',\n"
" 'valid': "
'True,\n'
' '
"'dateOfExpiration': "
'None,\n'
' '
"'dataSourceCount': "
'0,\n'
' '
"'daysToExpiry': "
'None,\n'
" 'expired': "
'None}]},\n'
" {'key': "
"'domo-jupyterdata',\n"
" 'name': "
"'Jupyter Data',\n"
' '
"'unassociatedDataSourceCount': "
'11,\n'
" 'accounts': "
'[]},\n'
" {'key': "
"'file-upload',\n"
" 'name': 'File "
"Upload',\n"
' '
"'unassociatedDataSourceCount': "
'1,\n'
" 'accounts': "
'[]},\n'
" {'key': "
"'google-spreadsheets',\n"
" 'name': "
"'Google "
"Sheets',\n"
' '
"'authenticationScheme': "
"'oauth',\n"
' '
"'unassociatedDataSourceCount': "
'0,\n'
" 'accounts': "
"[{'id': 45,\n"
" 'name': "
"'onyxReporting@gmail.com',\n"
" 'userId': "
"'1893952720',\n"
' '
"'displayName': "
"'test-goolesheets',\n"
" 'type': "
"'data',\n"
' '
"'dataProviderType': "
"'google-spreadsheets',\n"
" 'valid': "
'True,\n'
' '
"'dateOfExpiration': "
'None,\n'
' '
"'dataSourceCount': "
'1,\n'
' '
"'daysToExpiry': "
'None,\n'
" 'expired': "
'None},\n'
" {'id': 70,\n"
" 'name': "
"'jaemyong.wilson@sony.com',\n"
" 'userId': "
"'1893952720',\n"
' '
"'displayName': "
"'jaemyong.wilson@sony.com',\n"
" 'type': "
"'data',\n"
' '
"'dataProviderType': "
"'google-spreadsheets',\n"
" 'valid': "
'True,\n'
' '
"'dateOfExpiration': "
'None,\n'
' '
"'dataSourceCount': "
'0,\n'
' '
"'daysToExpiry': "
'None,\n'
" 'expired': "
'None}]},\n'
" {'key': "
"'json5',\n"
" 'name': "
"'JSON',\n"
' '
"'authenticationScheme': "
"'fields',\n"
' '
"'unassociatedDataSourceCount': "
'0,\n'
" 'accounts': "
"[{'id': 91,\n"
" 'name': "
"'JSON Account',\n"
" 'userId': "
"'1893952720',\n"
' '
"'displayName': "
"'JSON Account',\n"
" 'type': "
"'data',\n"
' '
"'dataProviderType': "
"'json5',\n"
" 'valid': "
'True,\n'
' '
"'dateOfExpiration': "
'None,\n'
' '
"'dataSourceCount': "
'0,\n'
' '
"'daysToExpiry': "
'None,\n'
" 'expired': "
'None}]},\n'
" {'key': "
"'large-file-upload',\n"
" 'name': 'Large "
"File Upload',\n"
' '
"'unassociatedDataSourceCount': "
'2,\n'
" 'accounts': "
'[]},\n'
" {'key': "
"'sample-data',\n"
" 'name': "
"'Sample Data',\n"
' '
"'unassociatedDataSourceCount': "
'6,\n'
" 'accounts': "
'[]},\n'
" {'key': "
"'webform',\n"
" 'name': 'Domo "
"Webform',\n"
' '
"'unassociatedDataSourceCount': "
'29,\n'
" 'accounts': "
'[]},\n'
" {'key': "
"'workbench-csv',\n"
" 'name': "
"'CSV',\n"
' '
"'unassociatedDataSourceCount': "
'1,\n'
" 'accounts': "
'[]}]'},
'execution_count': 8,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'print(type(res))\n'
'# print(vars(res)) # prints attributes of '
'res \n'
'\n'
'\n'
"# from the error message it's clear we "
'need to pass authentication with our API '
'request\n'
'print({"status": res.status_code, '
'"is_success": res.ok,})\n'
'\n'
'print("\\n")\n'
'type(res.json()) # prints the type of the '
'result of res.json() \n'
'# print("\\n")\n'
'res.json()\n'},
{'cell_type': 'markdown',
'id': 'cd01e1cf',
'metadata': {},
'source': '### ▶️ modify `get_accounts` to return a '
'list of account_objects\n'
'\n'
'The `requests.models.Response` class has a '
'method (function), `.json()` that will '
'convert the response into a dictionary.\n'
'\n'
'\n'
'### 🧪 use tests to communicate '
'assumptions \n'
'- How might we test for API errors?\n'
"- How might we test for 'logic errors' ex. "
'No accounts returned?'},
{'cell_type': 'markdown',
'id': '70e93111-f9a5-461e-9067-5980c301adfe',
'metadata': {},
'source': '## 🚀 Use a username and password '
'authentication flow to handle API '
'Authentication\n'
'\n'
'## 🎓 "full authentication" is not the same '
'as client_id and secret authentication\n'
'\n'
'Client_ID and Secret (AKA developer_token '
'authentication) is for public APIs as '
'documented under '
'<https://developer.domo.com>. \n'
'\n'
'For more information [Get Outta the UI and '
'into APIs - Domo IDEA Exchange '
'2022](https://www.youtube.com/watch?v=hRwrZABP8RE).'},
{'cell_type': 'markdown',
'id': 'd453865c',
'metadata': {},
'source': '### ▶️🤐 implement a function, '
'`get_session_token` to handle username and '
'password authentication\n'
'- function should receive: `domo_instance: '
'str, domo_username: str, domo_password : '
'str, and return_raw: bool = False`\n'
'\n'
'- `get_session_token` should parse the '
'response and return just the '
'`sessionToken`\n'
'\n'
'- store the final function in '
'`./functions/auth.py`\n'
'\n'
'🧪 how might we implement tests to ensure '
'expected / assumed behavior\n'
'- can you test for 400 - 500 errors? '
'(res.ok)\n'
'- what if you get a 200 response but sent '
'an invalid password? \n'
'\n'
'💡 to support debugging, add a parameter '
'`return_raw` before any tests\n'
'```\n'
'if return_raw: return res\n'
'```\n'
"- this helps debugging when there's a gap "
'between expected vs actual API behavior\n'
'\n'},
{'cell_type': 'code',
'execution_count': 22,
'id': '21beb207-e0b2-44d0-909e-6442ea4b2425',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': '# move into ./functions/auth.py\n'
'def get_session_token(domo_instance: '
'str, \n'
' domo_username: str,\n'
' domo_password: str,\n'
' return_raw: bool = '
'False) -> str:\n'
'\n'
' url = '
'f"https://{domo_instance}.domo.com/api/content/v2/authentication"\n'
'\n'
' # fix me\n'
' body = {\n'
' "method": "password",\n'
' "emailAddress": domo_username,\n'
' "password": domo_password,\n'
' }\n'
'\n'
' res = requests.request(method="POST", '
'url=url, json=body, verify=False)\n'
'\n'
' if return_raw:\n'
' return res\n'
' \n'
' if not res.ok:\n'
' raise Exception("something bad")\n'
' \n'
' data = res.json()\n'
" return data['sessionToken']"},
{'cell_type': 'code',
'execution_count': 23,
'id': '0eb28ae6',
'metadata': {'trusted': True},
'outputs': [{'name': 'stderr',
'output_type': 'stream',
'text': '/home/domo/.conda/lib/python3.9/site-packages/urllib3/connectionpool.py:1045: '
'InsecureRequestWarning: '
'Unverified HTTPS request is '
'being made to host '
"'domo-community.domo.com'. "
'Adding certificate verification '
'is strongly advised. See: '
'https://urllib3.readthedocs.io/en/1.26.x/advanced-usage.html#ssl-warnings\n'
' warnings.warn(\n'},
{'data': {'text/plain': "'eyJjdXN0b21lcklkIjoibW1tbS0wMDEyLTAyMDAiLCJleHBpcmF0aW9uIjoxNzExNDI1MDIyODc2LCJobWFjU2lnbmF0dXJlIjoiM2I4NjliZjk0N2NlYTg4ZTNjYjViZTUyZmY1NmVkYTAzMGRjMDY0YmFlOGEyM2U4NzMzNTQ1MmM1MmQ3YWUzYyIsInNpZCI6IjJjOTFiOGFhLTAzMGUtNDAzYy1iMWYzLWVkZjQ2OWQ5ZjBkZiIsInRpbWVzdGFtcCI6MTcxMTM5NjIyMjg3NiwidG9lcyI6IlVOS05PV05TSUQiLCJ1c2VySWQiOiI4NTY1NDI5MyJ9'"},
'execution_count': 23,
'metadata': {},
'output_type': 'execute_result'}],
'source': '# from solutions.get_session_token import '
'get_session_token\n'
'\n'
"# these are 'real creds'\n"
'get_session_token(\n'
" domo_instance = 'domo-community',\n"
" domo_username = 'dp24@test.com',\n"
" domo_password = 'thisisinsecure',\n"
')'},
{'cell_type': 'markdown',
'id': 'b125aa59',
'metadata': {},
'source': '### ▶️ modify get_accounts() to optionally '
'receive session_token.\n'
'\n'
'1. modify get_accounts to receive '
'`headers: dict = None, session_token : str '
'= None`\n'
'\n'
'2. combine headers and session_token and '
'pass to request\n'
'\n'
'```\n'
"# handle if users don't pass headers\n"
'headers = headers or {} \n'
'\n'
' # use the .update() method to update a '
'dictionary\n'
'headers.update({"session_token": '
'session_token})\n'
'```\n'
'\n'
'3. retrieve `session_token` from '
'`get_full_auth()` then pass it to your '
'modified `get_accounts`\n'
'\n'
'[solution](./solutions/get_accounts_v2.py)'},
{'cell_type': 'markdown',
'id': '45bc66f5',
'metadata': {},
'source': '### ▶️ Put it all together!'},
{'cell_type': 'code',
'execution_count': None,
'id': 'a3d889b8-19bd-4497-8077-b64bfe57288e',
'metadata': {'trusted': True},
'outputs': [],
'source': ''},
{'cell_type': 'code',
'execution_count': 27,
'id': '2a42ae8f-6156-40ad-a373-1e95c4636605',
'metadata': {'trusted': True},
'outputs': [],
'source': '# copy your implementation of get_accounts '
'from abvoe\n'
'# modify, and test using sample below\n'
'# update your source code in '
'./functions.accounts.py\n'
'\n'
'def get_accounts(domo_instance : str,\n'
' headers : dict = None,\n'
' session_token : str = '
'None,\n'
' access_token : str = '
'None,\n'
' debug_api: bool = False,\n'
' return_raw: bool = '
'False,\n'
' ):\n'
' \n'
' headers = headers or {}\n'
' \n'
' if session_token:\n'
' '
'headers.update({"X-Domo-Authentication" : '
'session_token})\n'
' \n'
' if access_token:\n'
' '
'headers.update({"x-domo-developer-token": '
'access_token})\n'
' \n'
' url = '
'f"https://{domo_instance}.domo.com/api/data/v2/datasources/providers"\n'
' \n'
" method = 'get'\n"
' \n'
' if debug_api:\n'
' print({"url": url,\n'
' "method" : method,\n'
' "headers" : headers})\n'
' \n'
' res = requests.request(method=method, '
'headers = headers, url=url)\n'
' \n'
' if return_raw:\n'
' return res\n'
' \n'
' if not res.ok:\n'
' return res\n'
' \n'
' return res.json()'},
{'cell_type': 'code',
'execution_count': 28,
'id': '3d0665f6-e734-426e-a0c5-0dd2bd0678e5',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'name': 'stderr',
'output_type': 'stream',
'text': '/home/domo/.conda/lib/python3.9/site-packages/urllib3/connectionpool.py:1045: '
'InsecureRequestWarning: '
'Unverified HTTPS request is '
'being made to host '
"'domo-community.domo.com'. "
'Adding certificate verification '
'is strongly advised. See: '
'https://urllib3.readthedocs.io/en/1.26.x/advanced-usage.html#ssl-warnings\n'
' warnings.warn(\n'},
{'data': {'text/plain': '[]'},
'execution_count': 28,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'session_token = get_session_token(\n'
" domo_instance = 'domo-community',\n"
" domo_username = 'dp24@test.com',\n"
" domo_password = 'thisisinsecure',\n"
')\n'
'\n'
'\n'
'get_accounts(domo_instance=DOMO_INSTANCE,\n'
' session_token=session_token\n'
' )'},
{'cell_type': 'markdown',
'id': '0dfcd9da',
'metadata': {},
'source': '## 🧪 Extra Credit - uses layers and '
'classes to introduce consistency to your '
'code\n'
'\n'
"Let's envision our codebase as having "
'three layers. \n'
'\n'
'| Layer / Class | Returns | Calls | '
'Logic\n'
'| -------- | ------- | ------- |------- |\n'
'|api_function |ResponseClass| calls API '
'directly | Just calls APIs and tests for '
'Errors\n'
'|DomoClass| DomoClass| calls API_Functions '
'| no implementation specific logic \n'
'|implementation_function|Log | calls '
'class_functions or implementation_function '
'| one time use\n'
'\n'
'### separating API calls from '
'implementation protects us from API '
'changes / versioning\n'
'We separate API functions from Class '
'functions so when Domo changes the API '
'(from V1 to V2) we just have to implement '
'a new API function, and call a different '
'function in the class_function. \n'
'\n'
'\n'
'Implementing class functions is outside '
'the scope of this course, but this design '
'pattern was used in '
'[DomoLibrary](https://jaewilson07.github.io/domolibrary/)<br>\n'
'[Route Functions for '
'Accounts](https://github.com/jaewilson07/domolibrary/blob/main/domolibrary/routes/account.py)<br>\n'
'[Class Implementation of '
'Accounts](https://github.com/jaewilson07/domolibrary/blob/main/domolibrary/classes/DomoAccount.py)\n'
'\n'
'<br>\n'
'\n'
'\n'
'- create a file `./functions/client.py` \n'
'- create a `@dataclass ResponseClass` with '
'attributes `status: int, is_success: bool '
', response: Union[dict, str]` \n'
'\n'
'- add classmethod that converts a '
'`requests.models.Response` into an '
'instance of `ResponseClass`\n'
'\n'
'- modify `get_accounts` to return '
'`ResponseClass`\n'
' \n'
'This ensures that each `api_function` '
'always returns the same format response '
'(which simplifies testing downstream) even '
'if you switch do a different library (like '
'HTTPX).\n'
'\n'
'Note: To keep with the `api_Function` '
'design pattern, we could convert '
'`get_session_token()` to return a '
'`ResponseClass` where the response has '
'been modified to return just the '
'session_token\n'
'\n'
'[Solution](./solutions/client.py)'},
{'cell_type': 'code',
'execution_count': None,
'id': '1f3c018e',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': '# from solutions.client import '
'ResponseClass\n'
'\n'
'from dataclasses import dataclass\n'
'\n'
'# finish me and move to '
'./functions/client.py\n'
'@dataclass\n'
'class ResponseClass:\n'
' status: int\n'
' # parameters go here.\n'
'\n'
' @classmethod\n'
' def from_request_response(cls, res: '
'requests.models.Response):\n'
' return cls(\n'
' status = res.status_code\n'
' # more parameters go here\n'
' )\n'
' \n'
'\n'},
{'cell_type': 'code',
'execution_count': None,
'id': '07c38ac8',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'ResponseClass.from_request_response(res)'},
{'cell_type': 'markdown',
'id': '9c9c409d',
'metadata': {},
'source': '## 🚀 Solution'},
{'cell_type': 'code',
'execution_count': None,
'id': '8c12a50a',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': '# from solutions.accounts import '
'get_accounts\n'
'# from solutions.auth import '
'get_session_token\n'
'\n'
'\n'
'session_token = get_session_token(\n'
" domo_instance = 'domo-community',\n"
" # domo_username = 'dp24@test.com',\n"
" # domo_password = 'thisisinsecure',\n"
')\n'
'\n'
'get_accounts(domo_instance=DOMO_INSTANCE,\n'
' # '
'session_token=session_token,\n'
' debug_api= False\n'
' )\n'}],
'metadata': {'domo': {'notebook_id': '1583ff81-e46e-4a58-bc02-e967883db73b'},
'kernelspec': {'display_name': 'Python',
'language': 'python',
'name': 'python_3_9'},
'language_info': {'codemirror_mode': {'name': 'ipython',
'version': 3},
'file_extension': '.py',
'mimetype': 'text/x-python',
'name': 'python',
'nbconvert_exporter': 'python',
'pygments_lexer': 'ipython3',
'version': '3.9.13'}},
'nbformat': 4,
'nbformat_minor': 5},
'created': '2024-03-25T20:01:02.879000Z',
'format': 'json',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T20:01:02.879000Z',
'mimetype': None,
'name': 'Tut1 - Authentication In Domo.ipynb',
'path': 'tutorial/domopalooza-24/Tut1 - Authentication In Domo.ipynb',
'size': 31309,
'type': 'notebook',
'writable': True},
{'content': [{'content': None,
'created': '2024-03-25T03:39:26.808000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T03:39:26.808000Z',
'mimetype': 'text/x-python',
'name': '__init__.py',
'path': 'tutorial/domopalooza-24/functions/__init__.py',
'size': 0,
'type': 'file',
'writable': True}],
'created': '2024-03-25T03:39:26.808000Z',
'format': 'json',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T03:39:26.808000Z',
'mimetype': None,
'name': 'functions',
'path': 'tutorial/domopalooza-24/functions',
'size': None,
'type': 'directory',
'writable': True},
{'content': {'cells': [{'cell_type': 'markdown',
'id': '70e93111-f9a5-461e-9067-5980c301adfe',
'metadata': {'tags': []},
'source': '# 🚀 Generate a DomoStats style Dataset\n'
'\n'
'This tutorial covers 3 use cases!\n'
'- using DomoJupyter for ETL\n'
'- using DomoJupyter as a replacement for '
'custom connectors\n'
'- using DomoJupyter to generate DomoStats '
'reports\n'
'\n'
'Once you can hit APIs, everything else '
'comes into focus! All you need is a '
'little Google and a lot of data wrangling '
'skills!\n'
'\n'
'💡 Mentally (and physically) separate the '
'act of retrieving data from an API vs '
'restructuring your data for use. (generic '
'api_function vs. specific '
'implementation)\n'},
{'cell_type': 'markdown',
'id': 'f34f8e47',
'metadata': {},
'source': '## ▶️ Where do we begin?\n'
'\n'
'PROBLEM: "I want a dataset that shows me '
'information about accounts"\n'
'\n'
'CONVERT that into\n'
'- a statement of granularity: "what does '
'one row of the dataset represent"\n'
'- a more specific definition of '
'"information about accounts"\n'
'\n'
'PLAN the project.\n'
'\n'
'- look at the data you receive. describe '
'how it differs from what you want it to '
'look like.\n'
'- stub out some function names\n'
'- add appropriate parameters and expected '
'response object\n'},
{'cell_type': 'code',
'execution_count': None,
'id': '9a7d9aad',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': '###\n'
'# start by describing the strucutre. is '
'it a list or a dictionary?\n'
'# look for the stuff you want. is it '
'nested somehow?\n'
'\n'
'# this is nested dictionary represents one '
"of many 'data_provider_type' where each "
'data_provider_type has multpiple accounts '
'associated with it\n'
'# is all the information i want inside the '
'account obj or is there stuff i want from '
'the data_provider?\n'
'\n'
'test = [\n'
' {\n'
' "key": '
'"abstract-credential-store",\n'
' "name": "Abstract Credential '
'Store",\n'
' "authenticationScheme": "fields",\n'
' "unassociatedDataSourceCount": 0,\n'
' "accounts": [\n'
' {\n'
' "id": 71,\n'
' "name": "domo_creds",\n'
' "userId": "1893952720",\n'
' "displayName": '
'"DomoLibrary - testrename 2024-03-20",\n'
' "type": "data",\n'
' "dataProviderType": '
'"abstract-credential-store",\n'
' "valid": True,\n'
' "dateOfExpiration": None,\n'
' "dataSourceCount": 0,\n'
' "daysToExpiry": None,\n'
' "expired": None,\n'
' },\n'
' {\n'
' "id": 87,\n'
' "name": "Abstract '
'Credential Store Account",\n'
' "userId": "1893952720",\n'
' "displayName": '
'"jw_creds",\n'
' "type": "data",\n'
' "dataProviderType": '
'"abstract-credential-store",\n'
' "valid": True,\n'
' "dateOfExpiration": None,\n'
' "dataSourceCount": 0,\n'
' "daysToExpiry": None,\n'
' "expired": None,\n'
' },\n'
' {\n'
' "id": 88,\n'
' "name": "fake_account",\n'
' "userId": "1893952720",\n'
' "displayName": '
'"fake_account",\n'
' "type": "data",\n'
' "dataProviderType": '
'"abstract-credential-store",\n'
' "valid": True,\n'
' "dateOfExpiration": None,\n'
' "dataSourceCount": 0,\n'
' "daysToExpiry": None,\n'
' "expired": None,\n'
' },\n'
' {\n'
' "id": 94,\n'
' "name": "Abstract '
'Credential Store Account",\n'
' "userId": "1893952720",\n'
' "displayName": '
'"my_domo_community_access_token - updated '
'2024-02-23",\n'
' "type": "data",\n'
' "dataProviderType": '
'"abstract-credential-store",\n'
' "valid": True,\n'
' "dateOfExpiration": None,\n'
' "dataSourceCount": 0,\n'
' "daysToExpiry": None,\n'
' "expired": None,\n'
' },\n'
' ],\n'
' }\n'
']'},
{'cell_type': 'markdown',
'id': 'bba41863-cb0c-4f93-9d8c-d06fab7c1555',
'metadata': {'tags': []},
'source': '### utils\n'
'\n'
'because the `api_response` contains nested '
'lists, we have to do a double list '
'comprehension to flatten into a list of '
'dictionaries.\n'},
{'cell_type': 'code',
'execution_count': 1,
'id': '2d63b13e',
'metadata': {'trusted': True},
'outputs': [{'data': {'text/plain': "['a', 'b', 'c', "
"1, 2, 3, 'john', "
"'jacob', "
"'jingle']"},
'execution_count': 1,
'metadata': {},
'output_type': 'execute_result'}],
'source': '# add me to functions/utils.py\n'
'\n'
'from typing import Any, List\n'
'\n'
'\n'
'def flatten_list_of_lists(list_of_lists) '
'-> List[Any]:\n'
' # these are the same.\n'
'\n'
' gather = []\n'
' for list in list_of_lists: # for '
'each dataprovider_type in entire_list.\n'
' for row in list: # for '
'each account in dataprovider_type.\n'
' gather.append(row) # '
'accumulate the account in a new list '
'called gather\n'
'\n'
' gather = [row for ls in list_of_lists '
'for row in ls] # nested list '
'comprehension\n'
' return gather\n'
'\n'
'\n'
'flatten_list_of_lists([["a", "b", "c"], '
'[1, 2, 3], ["john", "jacob", "jingle"]])'},
{'cell_type': 'markdown',
'id': 'f92688c4',
'metadata': {},
'source': 'DEVELOPER_NOTE\n'
'\n'
'- while it is common for APIs to return '
'JSON in `camelCase`, in python we will '
'rewrite everything in `snake_case`.\n'
'- we can also take the liberty of renaming '
'properties to something user friendly\n'},
{'cell_type': 'code',
'execution_count': 2,
'id': '00a77352-c7c3-4428-bcbc-9fd4ca1d5947',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'name': 'stdout',
'output_type': 'stream',
'text': 'does_this_work?\n'
'what_about_this?\n'}],
'source': 'import re\n'
'\n'
'\n'
'def format_str_camel_case(text):\n'
' # '
'https://www.w3resource.com/python-exercises/string/python-data-type-string-exercise-97.php\n'
' # Replace hyphens with spaces, then '
'apply regular expression substitutions for '
'title case conversion\n'
' # and add an underscore between words, '
'finally convert the result to lowercase\n'
'\n'
' return "_".join(\n'
' re.sub(\n'
' "([A-Z][a-z]+)", r" \\1", '
're.sub("([A-Z]+)", r" \\1", '
'text.replace("-", " "))\n'
' ).split()\n'
' ).lower()\n'
'\n'
'\n'
'print(format_str_camel_case("doesThisWork?"))\n'
'print(format_str_camel_case("what about '
'This?"))'},
{'cell_type': 'markdown',
'id': '775d889b',
'metadata': {},
'source': '### make a new notebook for your solution '
'in implementations/monit_accounts.ipynb\n'},
{'cell_type': 'code',
'execution_count': 20,
'id': '660bf1aa',
'metadata': {'trusted': True},
'outputs': [{'data': {'text/html': '<div>\n'
'<style scoped>\n'
' .dataframe '
'tbody tr '
'th:only-of-type '
'{\n'
' '
'vertical-align: '
'middle;\n'
' }\n'
'\n'
' .dataframe '
'tbody tr th {\n'
' '
'vertical-align: '
'top;\n'
' }\n'
'\n'
' .dataframe '
'thead th {\n'
' '
'text-align: '
'right;\n'
' }\n'
'</style>\n'
'<table border="1" '
'class="dataframe">\n'
' <thead>\n'
' <tr '
'style="text-align: '
'right;">\n'
' <th></th>\n'
' '
'<th>id</th>\n'
' '
'<th>name</th>\n'
' '
'<th>userId</th>\n'
' '
'<th>displayName</th>\n'
' '
'<th>type</th>\n'
' '
'<th>dataProviderType</th>\n'
' '
'<th>valid</th>\n'
' '
'<th>dateOfExpiration</th>\n'
' '
'<th>dataSourceCount</th>\n'
' '
'<th>daysToExpiry</th>\n'
' '
'<th>expired</th>\n'
' </tr>\n'
' </thead>\n'
' <tbody>\n'
' <tr>\n'
' <th>0</th>\n'
' '
'<td>71</td>\n'
' '
'<td>domo_creds</td>\n'
' '
'<td>1893952720</td>\n'
' '
'<td>domolibrary '
'test account - '
'updated '
'2024-03-23</td>\n'
' '
'<td>data</td>\n'
' '
'<td>abstract-credential-store</td>\n'
' '
'<td>True</td>\n'
' '
'<td>None</td>\n'
' <td>0</td>\n'
' '
'<td>None</td>\n'
' '
'<td>None</td>\n'
' </tr>\n'
' <tr>\n'
' <th>1</th>\n'
' '
'<td>87</td>\n'
' '
'<td>Abstract '
'Credential Store '
'Account</td>\n'
' '
'<td>1893952720</td>\n'
' '
'<td>jw_creds</td>\n'
' '
'<td>data</td>\n'
' '
'<td>abstract-credential-store</td>\n'
' '
'<td>True</td>\n'
' '
'<td>None</td>\n'
' <td>0</td>\n'
' '
'<td>None</td>\n'
' '
'<td>None</td>\n'
' </tr>\n'
' <tr>\n'
' <th>2</th>\n'
' '
'<td>88</td>\n'
' '
'<td>fake_account</td>\n'
' '
'<td>1893952720</td>\n'
' '
'<td>fake_account</td>\n'
' '
'<td>data</td>\n'
' '
'<td>abstract-credential-store</td>\n'
' '
'<td>True</td>\n'
' '
'<td>None</td>\n'
' <td>0</td>\n'
' '
'<td>None</td>\n'
' '
'<td>None</td>\n'
' </tr>\n'
' <tr>\n'
' <th>3</th>\n'
' '
'<td>92</td>\n'
' '
'<td>jw_username_password_auth</td>\n'
' '
'<td>1893952720</td>\n'
' '
'<td>jw_username_password_auth</td>\n'
' '
'<td>data</td>\n'
' '
'<td>abstract-credential-store</td>\n'
' '
'<td>True</td>\n'
' '
'<td>None</td>\n'
' <td>0</td>\n'
' '
'<td>None</td>\n'
' '
'<td>None</td>\n'
' </tr>\n'
' <tr>\n'
' <th>4</th>\n'
' '
'<td>94</td>\n'
' '
'<td>Abstract '
'Credential Store '
'Account</td>\n'
' '
'<td>1893952720</td>\n'
' '
'<td>my_domo_community_access_token '
'- updated '
'2024-...</td>\n'
' '
'<td>data</td>\n'
' '
'<td>abstract-credential-store</td>\n'
' '
'<td>True</td>\n'
' '
'<td>None</td>\n'
' <td>0</td>\n'
' '
'<td>None</td>\n'
' '
'<td>None</td>\n'
' </tr>\n'
' <tr>\n'
' <th>5</th>\n'
' '
'<td>99</td>\n'
' '
'<td>Abstract '
'Credential Store '
'Account</td>\n'
' '
'<td>1893952720</td>\n'
' '
'<td>Abstract '
'Credential Store '
'Account</td>\n'
' '
'<td>data</td>\n'
' '
'<td>abstract-credential-store</td>\n'
' '
'<td>True</td>\n'
' '
'<td>None</td>\n'
' <td>0</td>\n'
' '
'<td>None</td>\n'
' '
'<td>None</td>\n'
' </tr>\n'
' <tr>\n'
' <th>6</th>\n'
' '
'<td>102</td>\n'
' '
'<td>my_domo_community_access_token '
'- updated '
'2024-...</td>\n'
' '
'<td>1893952720</td>\n'
' <td>dp24 - '
'update 2024-03-25 '
'13:16:51.271591</td>\n'
' '
'<td>data</td>\n'
' '
'<td>abstract-credential-store</td>\n'
' '
'<td>True</td>\n'
' '
'<td>None</td>\n'
' <td>0</td>\n'
' '
'<td>None</td>\n'
' '
'<td>None</td>\n'
' </tr>\n'
' <tr>\n'
' <th>7</th>\n'
' <td>1</td>\n'
' <td>DataSet '
'Copy '
'Account</td>\n'
' '
'<td>1893952720</td>\n'
' <td>dsa - '
'northshore</td>\n'
' '
'<td>data</td>\n'
' '
'<td>dataset-copy</td>\n'
' '
'<td>True</td>\n'
' '
'<td>None</td>\n'
' <td>1</td>\n'
' '
'<td>None</td>\n'
' '
'<td>None</td>\n'
' </tr>\n'
' <tr>\n'
' <th>8</th>\n'
' '
'<td>96</td>\n'
' <td>Domo '
'Access Token '
'Account</td>\n'
' '
'<td>1893952720</td>\n'
' <td>Domo '
'Access Token '
'Account</td>\n'
' '
'<td>data</td>\n'
' '
'<td>domo-access-token</td>\n'
' '
'<td>True</td>\n'
' '
'<td>None</td>\n'
' <td>0</td>\n'
' '
'<td>None</td>\n'
' '
'<td>None</td>\n'
' </tr>\n'
' <tr>\n'
' <th>9</th>\n'
' '
'<td>100</td>\n'
' <td>Domo '
'Access Token '
'Account (2)</td>\n'
' '
'<td>1893952720</td>\n'
' '
'<td>domo-community</td>\n'
' '
'<td>data</td>\n'
' '
'<td>domo-access-token</td>\n'
' '
'<td>True</td>\n'
' '
'<td>None</td>\n'
' <td>0</td>\n'
' '
'<td>None</td>\n'
' '
'<td>None</td>\n'
' </tr>\n'
' <tr>\n'
' '
'<th>10</th>\n'
' '
'<td>113</td>\n'
' <td>Domo '
'Access Token '
'Account (2)</td>\n'
' '
'<td>1893952720</td>\n'
' <td>Domo '
'Access Token '
'Account (2)</td>\n'
' '
'<td>data</td>\n'
' '
'<td>domo-access-token</td>\n'
' '
'<td>True</td>\n'
' '
'<td>None</td>\n'
' <td>0</td>\n'
' '
'<td>None</td>\n'
' '
'<td>None</td>\n'
' </tr>\n'
' <tr>\n'
' '
'<th>11</th>\n'
' '
'<td>27</td>\n'
' <td>DataSet '
'Copy '
'Account</td>\n'
' '
'<td>1893952720</td>\n'
' <td>DataSet '
'Copy '
'Account</td>\n'
' '
'<td>data</td>\n'
' '
'<td>domo-csv</td>\n'
' '
'<td>True</td>\n'
' '
'<td>None</td>\n'
' <td>0</td>\n'
' '
'<td>None</td>\n'
' '
'<td>None</td>\n'
' </tr>\n'
' <tr>\n'
' '
'<th>12</th>\n'
' '
'<td>45</td>\n'
' '
'<td>onyxReporting@gmail.com</td>\n'
' '
'<td>1893952720</td>\n'
' '
'<td>test-goolesheets</td>\n'
' '
'<td>data</td>\n'
' '
'<td>google-spreadsheets</td>\n'
' '
'<td>True</td>\n'
' '
'<td>None</td>\n'
' <td>1</td>\n'
' '
'<td>None</td>\n'
' '
'<td>None</td>\n'
' </tr>\n'
' <tr>\n'
' '
'<th>13</th>\n'
' '
'<td>70</td>\n'
' '
'<td>jaemyong.wilson@sony.com</td>\n'
' '
'<td>1893952720</td>\n'
' '
'<td>jaemyong.wilson@sony.com</td>\n'
' '
'<td>data</td>\n'
' '
'<td>google-spreadsheets</td>\n'
' '
'<td>True</td>\n'
' '
'<td>None</td>\n'
' <td>0</td>\n'
' '
'<td>None</td>\n'
' '
'<td>None</td>\n'
' </tr>\n'
' <tr>\n'
' '
'<th>14</th>\n'
' '
'<td>91</td>\n'
' <td>JSON '
'Account</td>\n'
' '
'<td>1893952720</td>\n'
' <td>JSON '
'Account</td>\n'
' '
'<td>data</td>\n'
' '
'<td>json5</td>\n'
' '
'<td>True</td>\n'
' '
'<td>None</td>\n'
' <td>0</td>\n'
' '
'<td>None</td>\n'
' '
'<td>None</td>\n'
' </tr>\n'
' </tbody>\n'
'</table>\n'
'</div>',
'text/plain': ' '
'id '
'name '
'userId \\\n'
'0 '
'71 '
'domo_creds '
'1893952720 \n'
'1 '
'87 '
'Abstract '
'Credential Store '
'Account '
'1893952720 \n'
'2 '
'88 '
'fake_account '
'1893952720 \n'
'3 '
'92 '
'jw_username_password_auth '
'1893952720 \n'
'4 '
'94 '
'Abstract '
'Credential Store '
'Account '
'1893952720 \n'
'5 '
'99 '
'Abstract '
'Credential Store '
'Account '
'1893952720 \n'
'6 102 '
'my_domo_community_access_token '
'- updated '
'2024-... '
'1893952720 \n'
'7 '
'1 '
'DataSet Copy '
'Account '
'1893952720 \n'
'8 '
'96 '
'Domo Access '
'Token Account '
'1893952720 \n'
'9 '
'100 '
'Domo Access '
'Token Account '
'(2) '
'1893952720 \n'
'10 '
'113 '
'Domo Access '
'Token Account '
'(2) '
'1893952720 \n'
'11 '
'27 '
'DataSet Copy '
'Account '
'1893952720 \n'
'12 '
'45 '
'onyxReporting@gmail.com '
'1893952720 \n'
'13 '
'70 '
'jaemyong.wilson@sony.com '
'1893952720 \n'
'14 '
'91 '
'JSON Account '
'1893952720 \n'
'\n'
' '
'displayName '
'type \\\n'
'0 '
'domolibrary test '
'account - '
'updated '
'2024-03-23 '
'data \n'
'1 '
'jw_creds '
'data \n'
'2 '
'fake_account '
'data \n'
'3 '
'jw_username_password_auth '
'data \n'
'4 '
'my_domo_community_access_token '
'- updated '
'2024-... '
'data \n'
'5 '
'Abstract '
'Credential Store '
'Account '
'data \n'
'6 '
'dp24 - update '
'2024-03-25 '
'13:16:51.271591 '
'data \n'
'7 '
'dsa - '
'northshore '
'data \n'
'8 '
'Domo Access '
'Token Account '
'data \n'
'9 '
'domo-community '
'data \n'
'10 '
'Domo Access '
'Token Account '
'(2) data \n'
'11 '
'DataSet Copy '
'Account '
'data \n'
'12 '
'test-goolesheets '
'data \n'
'13 '
'jaemyong.wilson@sony.com '
'data \n'
'14 '
'JSON Account '
'data \n'
'\n'
' '
'dataProviderType '
'valid '
'dateOfExpiration '
'dataSourceCount '
'\\\n'
'0 '
'abstract-credential-store '
'True '
'None '
'0 \n'
'1 '
'abstract-credential-store '
'True '
'None '
'0 \n'
'2 '
'abstract-credential-store '
'True '
'None '
'0 \n'
'3 '
'abstract-credential-store '
'True '
'None '
'0 \n'
'4 '
'abstract-credential-store '
'True '
'None '
'0 \n'
'5 '
'abstract-credential-store '
'True '
'None '
'0 \n'
'6 '
'abstract-credential-store '
'True '
'None '
'0 \n'
'7 '
'dataset-copy '
'True '
'None '
'1 \n'
'8 '
'domo-access-token '
'True '
'None '
'0 \n'
'9 '
'domo-access-token '
'True '
'None '
'0 \n'
'10 '
'domo-access-token '
'True '
'None '
'0 \n'
'11 '
'domo-csv '
'True '
'None '
'0 \n'
'12 '
'google-spreadsheets '
'True '
'None '
'1 \n'
'13 '
'google-spreadsheets '
'True '
'None '
'0 \n'
'14 '
'json5 '
'True '
'None '
'0 \n'
'\n'
' daysToExpiry '
'expired \n'
'0 '
'None None \n'
'1 '
'None None \n'
'2 '
'None None \n'
'3 '
'None None \n'
'4 '
'None None \n'
'5 '
'None None \n'
'6 '
'None None \n'
'7 '
'None None \n'
'8 '
'None None \n'
'9 '
'None None \n'
'10 '
'None None \n'
'11 '
'None None \n'
'12 '
'None None \n'
'13 '
'None None \n'
'14 '
'None None '},
'execution_count': 20,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'from solutions.utils import '
'read_domo_jupyter_account\n'
'from solutions.auth import '
'get_session_token\n'
'from solutions.accounts import '
'get_accounts\n'
'\n'
'from typing import Callable\n'
'\n'
'import pandas as pd\n'
'\n'
'def format_api_accounts_v1(api_response):\n'
' return [account_obj for '
'dataprovider_obj in api_response for '
'account_obj in '
"dataprovider_obj['accounts']]\n"
'\n'
'def format_api_accounts_v2(api_response):\n'
' return ["stuff" for dataprovider_obj '
'in api_response for account_obj in '
"dataprovider_obj['accounts']]\n"
'\n'
'\n'
'def main(account_name, func : Callable, '
'output_name ):\n'
' creds = '
'read_domo_jupyter_account(account_name, \n'
' '
'is_abstract = True)\n'
'\n'
' domo_username = '
"creds.get('DOMO_USERNAME')\n"
' domo_password = '
"creds.get('DOMO_PASSWORD')\n"
' domo_instance = '
"creds.get('DOMO_INSTANCE')\n"
' \n'
'\n'
' session_token = '
'get_session_token(domo_username=domo_username, \n'
' '
'domo_password=domo_password, domo_instance '
'= domo_instance )\n'
' res = get_accounts(domo_instance = '
'domo_instance , session_token= '
'session_token)\n'
'\n'
' account_ls = res.response\n'
' \n'
' format_ls = func(account_ls)\n'
' \n'
' df= pd.DataFrame(format_ls)\n'
' \n'
' dj.write_dataframe(df, output_name)\n'
' \n'
'\n'
'main(account_name = '
"'username_password_auth', func = "
'format_api_accounts_v1 , \n'
" output_name= 'DomoStats - Accounts')\n"
'\n'
'\n'
'main(account_name = '
"'username_password_auth', func = "
'format_api_accounts_v2 , \n'
" output_name = 'jae rando dataset')\n"},
{'cell_type': 'markdown',
'id': '995dbd30',
'metadata': {},
'source': '## 🚀 SOLUTION\n'},
{'cell_type': 'markdown',
'id': '0ef64e9f',
'metadata': {},
'source': '### STEP 1. handle authentication\n'},
{'cell_type': 'code',
'execution_count': None,
'id': '621be635',
'metadata': {'trusted': True},
'outputs': [],
'source': 'from dotenv import load_dotenv\n'
'\n'
'load_dotenv(".env")'},
{'cell_type': 'code',
'execution_count': None,
'id': '8c6a0dbf',
'metadata': {'trusted': True},
'outputs': [],
'source': 'from solutions.auth import '
'get_session_token\n'
'import os\n'
'\n'
'DOMO_INSTANCE = "domo-community"\n'
'domo_password = '
'os.environ["DOMO_PASSWORD"]\n'
'domo_username = '
'os.environ["DOMO_USERNAME"]\n'
'\n'
'\n'
'def '
'get_instance_session_token(domo_username, '
'domo_password, domo_instance):\n'
' return get_session_token(\n'
' domo_instance=domo_instance,\n'
' domo_password=domo_password,\n'
' domo_username=domo_username,\n'
' )\n'
'\n'
'\n'
'test_session_token = '
'get_instance_session_token(\n'
' domo_username, '
'domo_password=domo_password, '
'domo_instance=DOMO_INSTANCE\n'
')'},
{'cell_type': 'markdown',
'id': 'c1ab9999',
'metadata': {},
'source': '### Step 2. Get Data\n'},
{'cell_type': 'code',
'execution_count': None,
'id': '834ff043',
'metadata': {'trusted': True},
'outputs': [],
'source': 'from solutions.accounts import '
'get_accounts\n'
'from typing import List\n'
'\n'
'\n'
'def get_instance_accounts(\n'
' session_token, domo_instance, '
'debug_api: bool = False\n'
') -> List[dict]:\n'
'\n'
' res = get_accounts(\n'
' domo_instance=domo_instance, '
'session_token=session_token, '
'debug_api=debug_api\n'
' )\n'
'\n'
' account_ls = res.response\n'
'\n'
' return account_ls\n'
'\n'
'\n'
'test_dataproviders_ls = '
'get_instance_accounts(\n'
' session_token=test_session_token, '
'domo_instance=DOMO_INSTANCE, '
'debug_api=False\n'
')[0:1]\n'
'\n'
'test_dataproviders_ls'},
{'cell_type': 'markdown',
'id': 'f917f73c-615a-4074-923b-4e6f3e1ccd3b',
'metadata': {'tags': []},
'source': 'instead of complex nested `for loops`, we '
'will build a function to handle data '
'transformation at the row '
'granularity.<br>\n'
'This approach improves testabilty because '
'we can test the output of one row\n'},
{'cell_type': 'code',
'execution_count': None,
'id': '46b15d7d-b737-4ac0-9509-e4ca5fcfe06e',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': '"get_instance_accounts returns a list of '
"account types which we'll capture as "
'account_ls"\n'
'"each member of account_ls is a '
'data_provider_type"\n'
'"each data_provider_type has a list of '
'accounts"\n'
'\n'
'test_dataprovider_obj = '
'test_dataproviders_ls[0]\n'
'test_dataprovider_obj'},
{'cell_type': 'code',
'execution_count': None,
'id': 'e5f27591-3fc8-4a16-980e-db562303cc10',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'test_account = '
'test_dataprovider_obj["accounts"][0]\n'
'test_account'},
{'cell_type': 'markdown',
'id': '1f42dc0d',
'metadata': {},
'source': '## Step 3: Format Data\n'},
{'cell_type': 'code',
'execution_count': None,
'id': '35702d2b-5f9a-4d2f-ae68-b10b9414d78d',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'def format_account_v1(account_obj, '
'dataprovider_obj, **kwargs):\n'
' """most granular level"""\n'
'\n'
' s = {**account_obj, '
'"data_provider_name": '
'dataprovider_obj["name"]}\n'
'\n'
' # rename a field and remove the old '
'field\n'
' s["account_id"] = s.pop("id")\n'
' s["account_name"] = '
's.pop("displayName")\n'
'\n'
' # remove fields\n'
' s.pop("name")\n'
' s.pop("type")\n'
' s.pop("daysToExpiry")\n'
' s.pop("valid")\n'
' s.pop("expired")\n'
'\n'
' return {format_str_camel_case(key): '
'value for key, value in s.items()}\n'
'\n'
'\n'
'format_account_v1(account_obj=test_account, '
'dataprovider_obj=test_dataprovider_obj)'},
{'cell_type': 'code',
'execution_count': None,
'id': '473dc6a2',
'metadata': {'trusted': True},
'outputs': [],
'source': 'def format_account_v2(account_obj, '
'dataprovider_obj, **kwargs):\n'
' """most granular level"""\n'
'\n'
' s = {**account_obj, '
'"data_provider_name": '
'dataprovider_obj["name"]}\n'
'\n'
' # rename a field and remove the old '
'field\n'
' s["account_id"] = s.pop("id")\n'
' s["account_name"] = '
's.pop("displayName")\n'
'\n'
' # remove fields\n'
' s.pop("name")\n'
' s.pop("valid")\n'
'\n'
' return {format_str_camel_case(key): '
'value for key, value in s.items()}\n'
'\n'
'\n'
'format_account_v2(account_obj=test_account, '
'dataprovider_obj=test_dataprovider_obj)'},
{'cell_type': 'code',
'execution_count': None,
'id': 'a67547d6',
'metadata': {'trusted': True},
'outputs': [],
'source': '# %pip install pandas'},
{'cell_type': 'code',
'execution_count': None,
'id': '35324fb1',
'metadata': {'trusted': True},
'outputs': [],
'source': 'import pandas as pd\n'
'from typing import Callable\n'
'\n'
'def '
'format_domostats_accounts(api_response,format_fn: '
'Callable, is_dataframe: bool = True):\n'
'\n'
' account_ls = [\n'
' format_fn(account_obj=account_obj, '
'dataprovider_obj=dataprovider_obj)\n'
' for dataprovider_obj in '
'api_response\n'
' for account_obj in '
'dataprovider_obj["accounts"]\n'
' ] # produces nested list of lists\n'
'\n'
' if not is_dataframe:\n'
' return account_ls\n'
'\n'
' return pd.DataFrame(account_ls)\n'
'\n'
'\n'
'format_domostats_accounts(test_dataproviders_ls,format_fn=format_account_v1, '
'is_dataframe=True)[0:5]\n'
'\n'
'# passing functions into functions allow '
'us to have configurable results without '
'significantly refactoring code.\n'
'# notice that by passing the format '
'function as a function (instead of calling '
'it outside of '
'format_domostats_accounts), \n'
'# we can have different permutations of '
'the accounts report!\n'
'# any idea what adding kwargs does for '
'us?\n'
'\n'
'format_domostats_accounts(test_dataproviders_ls,format_fn=format_account_v2, '
'is_dataframe=True)[0:5]'},
{'cell_type': 'code',
'execution_count': None,
'id': '5e657a24-090b-4ead-842e-3cd411d6f99c',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'def generate_monit_instance_accounts(\n'
' session_token : str,\n'
' domo_instance : str,\n'
' format_fn : callable,\n'
' is_dataframe: bool = True,\n'
' return_raw: bool = False,\n'
' debug_api: bool = False,\n'
') -> pd.DataFrame:\n'
'\n'
' api_response = get_instance_accounts(\n'
' domo_instance=domo_instance, '
'session_token=session_token, '
'debug_api=debug_api\n'
' )\n'
'\n'
' if return_raw:\n'
' return api_response\n'
'\n'
' return format_domostats_accounts(\n'
' api_response=api_response, '
'is_dataframe=is_dataframe, '
'format_fn=format_fn\n'
' )\n'
'\n'
'generate_monit_instance_accounts(\n'
' domo_instance=DOMO_INSTANCE,\n'
' session_token= test_session_token,\n'
' format_fn = format_account_v1,\n'
' is_dataframe=True,\n'
')[0:5]'},
{'cell_type': 'markdown',
'id': '3a423d80-8464-44d2-a856-0149e9514415',
'metadata': {},
'source': '### 🎓 USE CASES TO CONSIDER\n'
'\n'
'1. Recall, `session_token` will mimic the '
'access rights and permissions of the user '
'the session token is based off of. Under '
'what circumstances would the list of '
'account_objects retrieved NOT represent '
'the entire list of account objects '
'existent in the instance? How might you '
'address that issue?\n'
'\n'
'2. Recall, the base behavior in Domo of '
'updating datasets is a full REPLACE '
'operation. How would that impact your '
'ability to track changes over time in '
'account objects? What steps might you take '
'to modify your code to track history?\n'
'\n'
'3. Notice that `get_accounts()` does not '
"retrieve account configuration (that's a "
'different API) how might you approach '
'building a dataset that monitors account '
'configuration?\n'
'\n'
'- Recall, that you cannot see account '
'secret fields in plain text unless you are '
'in DomoJupyter. What kind of workflow '
'might you need to accurately see account '
'configuration and build a dataset off of '
'it?\n'
'\n'
'\n'
'### 🧪 Extra Challenge\n'
'\n'
'Notice that the named user_id is just a '
'user_id is just a name.\n'
'\n'
'1. Construct a function, `get_user_by_id` '
'that retrieves user information\n'
'2. Create a function `format_account` that '
'receives an account_obj and adds decorator '
'information (like the user '
'display_name),\n'},
{'cell_type': 'code',
'execution_count': None,
'id': 'da3a6832',
'metadata': {'trusted': True},
'outputs': [],
'source': 'import domojupyter as dj\n'
'\n'
'\n'
'def main(session_token, domo_instance):\n'
'\n'
' df = '
'generate_monit_instance_accounts(\n'
' domo_instance=domo_instance,\n'
' session_token=session_token,\n'
' format_fn=format_account_v1,\n'
' is_dataframe=True,\n'
' )\n'
'\n'
' dj.write_dataframe(df, '
'"YOUR_DATASET_NAME_v1")\n'
'\n'
' df = '
'generate_monit_instance_accounts(\n'
' domo_instance=domo_instance,\n'
' session_token=session_token,\n'
' format_fn=format_account_v2,\n'
' is_dataframe=True,\n'
' )\n'
'\n'
' dj.write_dataframe(df, '
'"YOUR_DATASET_NAME_v2")'}],
'metadata': {'domo': {'notebook_id': '8d2bce99-82e9-4038-ace1-0043f595c661'},
'kernelspec': {'display_name': 'Python',
'language': 'python',
'name': 'python_3_9'},
'language_info': {'codemirror_mode': {'name': 'ipython',
'version': 3},
'file_extension': '.py',
'mimetype': 'text/x-python',
'name': 'python',
'nbconvert_exporter': 'python',
'pygments_lexer': 'ipython3',
'version': '3.9.13'}},
'nbformat': 4,
'nbformat_minor': 5},
'created': '2024-03-25T21:17:56.354000Z',
'format': 'json',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T21:17:56.354000Z',
'mimetype': None,
'name': 'Tut3 - Generate a DomoStats style Dataset.ipynb',
'path': 'tutorial/domopalooza-24/Tut3 - Generate a DomoStats style '
'Dataset.ipynb',
'size': 33949,
'type': 'notebook',
'writable': True},
{'content': {'cells': [{'cell_type': 'code',
'execution_count': 1,
'id': '22225df2-51f9-4d3b-8c00-6613397e2e0f',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': '# %pip install domolibrary --upgrade\n'
'# %pip install domolibrary_extensions '
'--upgrade\n'
'# %pip install xkcdpass'},
{'cell_type': 'code',
'execution_count': 2,
'id': 'fcd3420e-4340-491e-ac2d-c16b1cb12c85',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'data': {'text/plain': "{'domolibrary': "
"'4.0.20', "
"'extensions': "
"'0.0.26'}"},
'execution_count': 2,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'import domolibrary\n'
'import domolibrary_extensions\n'
'\n'
'{"domolibrary": domolibrary.__version__, '
'"extensions" : '
'domolibrary_extensions.__version__}\n'},
{'cell_type': 'code',
'execution_count': 3,
'id': '1a1b67f7-22e9-45ff-9360-167b9d7dbee9',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'data': {'text/plain': 'True'},
'execution_count': 3,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'from dotenv import load_dotenv\n'
'\n'
"load_dotenv('env.txt', override = True)"},
{'cell_type': 'code',
'execution_count': 4,
'id': 'f849e51b-ed71-40ee-9f51-3b925184e5c6',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'name': 'stdout',
'output_type': 'stream',
'text': 'warning this token has not been '
'validated by who_am_i, run '
'get_auth_token first\n'},
{'data': {'text/plain': 'ResponseGetData(status=200, '
"response={'id': "
'1893952720, '
"'invitorUserId': "
'587894148, '
"'displayName': "
"'Jae Wilson1', "
"'department': "
"'Business "
"Improvement', "
"'userName': "
"'jae@onyxreporting.com', "
"'emailAddress': "
"'jae@onyxreporting.com', "
"'avatarKey': "
"'c605f478-0cd2-4451-9fd4-d82090b71e66', "
"'accepted': "
'True, '
"'userType': "
"'USER', "
"'modified': "
'1710870541105, '
"'created': "
'1588960518, '
"'active': True, "
"'pending': "
'False, '
"'anonymous': "
'False, '
"'systemUser': "
'False}, '
'is_success=True, '
"parent_class='DomoTokenAuth')"},
'execution_count': 4,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'import domolibrary.client.DomoAuth as '
'dmda\n'
'import os\n'
'\n'
'auth = dmda.DomoTokenAuth(\n'
' domo_access_token = '
"os.environ['ACCESS_TOKEN'],\n"
" domo_instance = 'domo-community'\n"
')\n'
'\n'
'await auth.who_am_i()'},
{'cell_type': 'code',
'execution_count': 18,
'id': '8d3c205b-5f84-4f9c-a470-bef520330f52',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'data': {'text/html': '<div>\n'
'<style scoped>\n'
' .dataframe '
'tbody tr '
'th:only-of-type '
'{\n'
' '
'vertical-align: '
'middle;\n'
' }\n'
'\n'
' .dataframe '
'tbody tr th {\n'
' '
'vertical-align: '
'top;\n'
' }\n'
'\n'
' .dataframe '
'thead th {\n'
' '
'text-align: '
'right;\n'
' }\n'
'</style>\n'
'<table border="1" '
'class="dataframe">\n'
' <thead>\n'
' <tr '
'style="text-align: '
'right;">\n'
' <th></th>\n'
' '
'<th>function_name</th>\n'
' '
'<th>stage</th>\n'
' '
'<th>id</th>\n'
' '
'<th>is_success</th>\n'
' '
'<th>message</th>\n'
' '
'<th>response</th>\n'
' </tr>\n'
' </thead>\n'
' <tbody>\n'
' <tr>\n'
' <th>0</th>\n'
' '
'<td>foo</td>\n'
' '
'<td>bar</td>\n'
' '
'<td>simba@me.com</td>\n'
' '
'<td>True</td>\n'
' <td>we did '
'something</td>\n'
' '
'<td>hello</td>\n'
' </tr>\n'
' <tr>\n'
' <th>1</th>\n'
' '
'<td>foo</td>\n'
' '
'<td>something</td>\n'
' '
'<td>simba@me.com</td>\n'
' '
'<td>True</td>\n'
' '
'<td>init</td>\n'
' '
'<td>hello</td>\n'
' </tr>\n'
' </tbody>\n'
'</table>\n'
'</div>',
'text/plain': ' '
'function_name '
'stage '
'id '
'is_success '
'message \\\n'
'0 '
'foo bar '
'simba@me.com '
'True we did '
'something \n'
'1 foo '
'something '
'simba@me.com '
'True '
'init \n'
'\n'
' response \n'
'0 hello \n'
'1 hello '},
'execution_count': 18,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'import '
'domolibrary_extensions.utils.factory as '
'dlef\n'
'from dataclasses import dataclass\n'
'import pandas as pd\n'
'\n'
'import httpx\n'
'\n'
'@dlef.factory_function(config_id_col = '
"'email')\n"
'async def foo(config, \n'
' logs: dlef.FactoryLogs,\n'
' res : '
'dlef.FactoryResponse, \n'
' debug_api: bool = False):\n'
' \n'
' # stage1 = bar\n'
' message = dlef.FactoryMessage(stage = '
"'bar')\n"
' res.add_message(message)\n'
' \n'
' try: \n'
' # do something\n'
' message.is_success = True\n'
" message.message = 'we did "
"something'\n"
" # raise Exception('random api "
"error')\n"
' \n'
' except Exception as e:\n'
' message.message = e\n'
' message.is_success = False\n'
' \n'
' \n'
' #stage2 = something\n'
' message = dlef.FactoryMessage(stage = '
"'something')\n"
' res.add_message(message)\n'
' \n'
' #do something\n'
' message.is_success = True\n'
' \n'
' # UPDATE config\n'
" config.token_name = 'hello'\n"
' \n'
' # UPDATE response\n'
" res.response = 'hello'\n"
' \n'
' return res\n'
' \n'
'@dataclass\n'
'class '
'MyFactoryConfig(dlef.FactoryConfig):\n'
' email : str = None\n'
' token_name: str = None\n'
' \n'
' \n'
'logs = dlef.FactoryLogs()\n'
'\n'
'config = MyFactoryConfig(\n'
" email = 'simba@me.com',\n"
' auth = auth,\n'
' session = httpx.AsyncClient(),\n'
' logs = logs\n'
')\n'
'\n'
'\n'
'res = await foo(config = config,\n'
' logs = logs)\n'
'\n'
'pd.DataFrame(res.to_json())'},
{'cell_type': 'code',
'execution_count': 44,
'id': 'a5ee98eb-f469-455d-aea9-ad822d79296c',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'import datetime as dt\n'
'\n'
'@dataclass\n'
'class '
'MyFactoryConfig(dlef.FactoryConfig):\n'
' display_name : str = None\n'
' email : str = None\n'
' role_id : int = None\n'
' token_name : str = None\n'
' \n'
'logs = dlef.FactoryLogs()\n'
'\n'
'config = MyFactoryConfig(\n'
' display_name = f"Test User - updated '
'{dt.datetime.now()}", \n'
' email = "test_automate@sony.com",\n'
' role_id = 2097317660,\n'
' token_name = "token_factory",\n'
' auth = auth,\n'
' session = httpx.AsyncClient(),\n'
' logs = logs\n'
')'},
{'cell_type': 'code',
'execution_count': 39,
'id': 'bf554b19-0cae-443e-b74a-818027c76e5e',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'data': {'text/html': '<div>\n'
'<style scoped>\n'
' .dataframe '
'tbody tr '
'th:only-of-type '
'{\n'
' '
'vertical-align: '
'middle;\n'
' }\n'
'\n'
' .dataframe '
'tbody tr th {\n'
' '
'vertical-align: '
'top;\n'
' }\n'
'\n'
' .dataframe '
'thead th {\n'
' '
'text-align: '
'right;\n'
' }\n'
'</style>\n'
'<table border="1" '
'class="dataframe">\n'
' <thead>\n'
' <tr '
'style="text-align: '
'right;">\n'
' <th></th>\n'
' '
'<th>function_name</th>\n'
' '
'<th>stage</th>\n'
' '
'<th>id</th>\n'
' '
'<th>is_success</th>\n'
' '
'<th>message</th>\n'
' '
'<th>response</th>\n'
' </tr>\n'
' </thead>\n'
' <tbody>\n'
' <tr>\n'
' <th>0</th>\n'
' '
'<td>generate_password_fn</td>\n'
' '
'<td>generate_password</td>\n'
' '
'<td>test_automate@sony.com</td>\n'
' '
'<td>True</td>\n'
' '
'<td>password_generated</td>\n'
' '
'<td>flock_ahoy_clerk_early_2024!@#</td>\n'
' </tr>\n'
' </tbody>\n'
'</table>\n'
'</div>',
'text/plain': ' '
'function_name '
'stage '
'id \\\n'
'0 '
'generate_password_fn '
'generate_password '
'test_automate@sony.com \n'
'\n'
' '
'is_success '
'message '
'response \n'
'0 True '
'password_generated '
'flock_ahoy_clerk_early_2024!@# '},
'execution_count': 39,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'from xkcdpass import xkcd_password as xp\n'
'import string\n'
'import secrets\n'
'import datetime as dt\n'
'\n'
"@dlef.factory_function(config_id_col='email')\n"
'async def generate_password_fn(config : '
'dlef.FactoryConfig,\n'
' logs : '
'dlef.FactoryLogs,\n'
' res : '
'dlef.FactoryResponse,\n'
' digit_len = '
'5,\n'
' '
'use_random_digit=False,\n'
' debug_api: '
'bool = False):\n'
' \n'
' # INIT message\n'
' message = dlef.FactoryMessage(stage = '
"'generate_password')\n"
' res.add_message(message)\n'
' \n'
' # STAGE1 = generate_password\n'
' if use_random_digit:\n'
' alphabet = string.punctuation + '
'string.digits\n'
' password = '
"''.join(secrets.choice(alphabet) for i in "
'range(digit_len))\n'
' \n'
' default = '
"dt.date.today().strftime('%Y')+'!@#'\n"
' \n'
' wordfile = xp.locate_wordfile()\n'
' mywords = '
'xp.generate_wordlist(wordfile=wordfile, '
'min_length=3, max_length=5)\n'
'\n'
' # create a password with the acrostic '
'"face"\n'
' \n'
' password = '
'xp.generate_xkcdpassword(mywords, '
'delimiter = \'_\', acrostic="face", case = '
'\'lower\') + "_" + default\n'
' \n'
' # UPDATE message\n'
' message.message = '
"'password_generated'\n"
' message.is_success = True\n'
' \n'
' # UPDATE config\n'
' config.password = password\n'
' \n'
' # UPDATE response\n'
' res.response = password\n'
' \n'
' return res\n'
'\n'
'logs = dlef.FactoryLogs()\n'
'\n'
'config = MyFactoryConfig(\n'
' auth = auth,\n'
" email = 'test_automate@sony.com',\n"
' session = httpx.AsyncClient(),\n'
' logs = logs\n'
')\n'
'\n'
'pd.DataFrame((await '
'generate_password_fn(config = config, logs '
'= logs)).to_json())'},
{'cell_type': 'code',
'execution_count': 47,
'id': '1117ca48-7327-42d3-9caa-6ace0eafe1b9',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'data': {'text/html': '<div>\n'
'<style scoped>\n'
' .dataframe '
'tbody tr '
'th:only-of-type '
'{\n'
' '
'vertical-align: '
'middle;\n'
' }\n'
'\n'
' .dataframe '
'tbody tr th {\n'
' '
'vertical-align: '
'top;\n'
' }\n'
'\n'
' .dataframe '
'thead th {\n'
' '
'text-align: '
'right;\n'
' }\n'
'</style>\n'
'<table border="1" '
'class="dataframe">\n'
' <thead>\n'
' <tr '
'style="text-align: '
'right;">\n'
' <th></th>\n'
' '
'<th>function_name</th>\n'
' '
'<th>stage</th>\n'
' '
'<th>id</th>\n'
' '
'<th>is_success</th>\n'
' '
'<th>message</th>\n'
' '
'<th>response</th>\n'
' </tr>\n'
' </thead>\n'
' <tbody>\n'
' <tr>\n'
' <th>0</th>\n'
' '
'<td>upsert_user_fn</td>\n'
' '
'<td>upsert_user</td>\n'
' '
'<td>test_automate@sony.com</td>\n'
' '
'<td>True</td>\n'
' <td>user '
'1853825438 '
'upserted</td>\n'
' '
"<td>DomoUser(id='1853825438', "
"display_name='update...</td>\n"
' </tr>\n'
' </tbody>\n'
'</table>\n'
'</div>',
'text/plain': ' '
'function_name '
'stage '
'id is_success '
'\\\n'
'0 '
'upsert_user_fn '
'upsert_user '
'test_automate@sony.com '
'True \n'
'\n'
' '
'message '
'response \n'
'0 user '
'1853825438 '
'upserted '
"DomoUser(id='1853825438', "
"display_name='update... "},
'execution_count': 47,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'import domolibrary.classes.DomoUser as '
'dmdu\n'
'\n'
'@dlef.factory_function(config_id_col = '
"'email')\n"
'async def upsert_user_fn(config : '
'dlef.FactoryConfig,\n'
' logs: '
'dlef.FactoryLogs,\n'
' res : '
'dlef.FactoryResponse,\n'
' debug_api: bool = '
'False ):\n'
' #INIT message\n'
' message = dlef.FactoryMessage(stage = '
"'upsert_user')\n"
' res.add_message(message)\n'
' \n'
" config.test_required_attr( ['email', "
"'display_name', 'role_id'], "
'upsert_user_fn.__name__)\n'
' \n'
' # STAGE1 = upsert_user\n'
' domo_user = await '
'dmdu.DomoUsers.upsert_user(\n'
' auth = config.auth,\n'
' email_address = config.email,\n'
' display_name = '
'config.display_name,\n'
' session = config.session,\n'
' role_id = config.role_id,\n'
' debug_api = debug_api,\n'
' )\n'
' \n'
' # UPDATE message\n'
' message.message = f"user '
'{domo_user.id} upserted"\n'
' message.is_success = True\n'
' \n'
' # UPDATE config\n'
' config.user_id = domo_user.id\n'
' \n'
' # UPDATE response\n'
' res.response = domo_user\n'
' \n'
' return res\n'
'\n'
'logs = dlef.FactoryLogs()\n'
'\n'
'config = MyFactoryConfig(\n'
' auth = auth,\n'
' display_name = f"updated '
'{dt.date.today()}",\n'
' role_id = 2097317660,\n'
" email = 'test_automate@sony.com',\n"
' session = httpx.AsyncClient(),\n'
' logs = logs\n'
')\n'
'res = await upsert_user_fn(config = '
'config, logs = logs, debug_api = False)\n'
'pd.DataFrame(res.to_json())\n'},
{'cell_type': 'code',
'execution_count': 52,
'id': 'e560dac3-2997-48dd-96ed-1c77c2dc879c',
'metadata': {'trusted': True},
'outputs': [{'data': {'text/html': '<div>\n'
'<style scoped>\n'
' .dataframe '
'tbody tr '
'th:only-of-type '
'{\n'
' '
'vertical-align: '
'middle;\n'
' }\n'
'\n'
' .dataframe '
'tbody tr th {\n'
' '
'vertical-align: '
'top;\n'
' }\n'
'\n'
' .dataframe '
'thead th {\n'
' '
'text-align: '
'right;\n'
' }\n'
'</style>\n'
'<table border="1" '
'class="dataframe">\n'
' <thead>\n'
' <tr '
'style="text-align: '
'right;">\n'
' <th></th>\n'
' '
'<th>function_name</th>\n'
' '
'<th>stage</th>\n'
' '
'<th>id</th>\n'
' '
'<th>is_success</th>\n'
' '
'<th>message</th>\n'
' '
'<th>response</th>\n'
' </tr>\n'
' </thead>\n'
' <tbody>\n'
' <tr>\n'
' <th>0</th>\n'
' '
'<td>upsert_user_fn</td>\n'
' '
'<td>upsert_user</td>\n'
' '
'<td>test_automate@sony.com</td>\n'
' '
'<td>True</td>\n'
' <td>user '
'1853825438 '
'upserted</td>\n'
' '
"<td>DomoUser(id='1853825438', "
"display_name='update...</td>\n"
' </tr>\n'
' <tr>\n'
' <th>1</th>\n'
' '
'<td>generate_password_fn</td>\n'
' '
'<td>generate_password</td>\n'
' '
'<td>test_automate@sony.com</td>\n'
' '
'<td>True</td>\n'
' '
'<td>password_generated</td>\n'
' '
'<td>frays_among_crust_each_2024!@#</td>\n'
' </tr>\n'
' <tr>\n'
' <th>2</th>\n'
' '
'<td>user_reset_password_fn</td>\n'
' '
'<td>get_user_by_id</td>\n'
' '
'<td>test_automate@sony.com</td>\n'
' '
'<td>True</td>\n'
' <td>user '
'1853825438 '
'retrieved</td>\n'
' '
"<td>DomoUser(id='1853825438', "
"display_name='update...</td>\n"
' </tr>\n'
' <tr>\n'
' <th>3</th>\n'
' '
'<td>user_reset_password_fn</td>\n'
' '
'<td>reset_password</td>\n'
' '
'<td>test_automate@sony.com</td>\n'
' '
'<td>True</td>\n'
' '
'<td>password '
'reset to '
'frays_among_crust_each_2024!@#</td>\n'
' '
"<td>DomoUser(id='1853825438', "
"display_name='update...</td>\n"
' </tr>\n'
' </tbody>\n'
'</table>\n'
'</div>',
'text/plain': ' '
'function_name '
'stage '
'id \\\n'
'0 '
'upsert_user_fn '
'upsert_user '
'test_automate@sony.com \n'
'1 '
'generate_password_fn '
'generate_password '
'test_automate@sony.com \n'
'2 '
'user_reset_password_fn '
'get_user_by_id '
'test_automate@sony.com \n'
'3 '
'user_reset_password_fn '
'reset_password '
'test_automate@sony.com \n'
'\n'
' '
'is_success '
'message \\\n'
'0 '
'True '
'user 1853825438 '
'upserted \n'
'1 '
'True '
'password_generated \n'
'2 '
'True '
'user 1853825438 '
'retrieved \n'
'3 True '
'password reset '
'to '
'frays_among_crust_each_2024!@# \n'
'\n'
' '
'response \n'
'0 '
"DomoUser(id='1853825438', "
"display_name='update... \n"
'1 '
'frays_among_crust_each_2024!@# \n'
'2 '
"DomoUser(id='1853825438', "
"display_name='update... \n"
'3 '
"DomoUser(id='1853825438', "
"display_name='update... "},
'execution_count': 52,
'metadata': {},
'output_type': 'execute_result'}],
'source': "@dlef.factory_function(config_id_col='email')\n"
'async def user_reset_password_fn(config : '
'dlef.FactoryConfig, \n'
' res : '
'dlef.FactoryResponse,\n'
' logs : '
'dlef.FactoryLogs,\n'
' '
'debug_api: bool = False):\n'
' \n'
" config.test_required_attr( ['user_id', "
"'password'], "
'user_reset_password_fn.__name__)\n'
' \n'
' \n'
' message = dlef.FactoryMessage(stage = '
"'get_user_by_id')\n"
' res.add_message(message)\n'
' \n'
' domo_user = await '
'dmdu.DomoUser.get_by_id(user_id = '
'config.user_id, \n'
' '
'auth= config.auth, \n'
' '
'session = config.session, debug_api = '
'debug_api)\n'
' \n'
" message.message = f'user "
"{domo_user.id} retrieved'\n"
' message.is_success = True\n'
' \n'
' \n'
' message = dlef.FactoryMessage(stage = '
"'reset_password')\n"
' res.add_message(message)\n'
' await '
'domo_user.reset_password(new_password = '
'config.password, \n'
' '
'debug_api = debug_api,\n'
' # '
'session = session\n'
' )\n'
" message.message = f'password reset to "
"{config.password}'\n"
' message.is_success = True\n'
' \n'
' res.response = domo_user\n'
' \n'
' return res\n'
'\n'
'\n'
'logs = dlef.FactoryLogs()\n'
'\n'
'config = MyFactoryConfig(\n'
' auth = auth,\n'
' display_name = f"updated '
'{dt.date.today()}",\n'
' role_id = 2097317660,\n'
" email = 'test_automate@sony.com',\n"
' session = httpx.AsyncClient(),\n'
' logs = logs,\n'
' factory_fn_ls = [upsert_user_fn, '
'generate_password_fn, '
'user_reset_password_fn ]\n'
')\n'
'\n'
'await config.run( debug_api = False)\n'
'\n'
'pd.DataFrame(config.logs.to_json())\n'},
{'cell_type': 'code',
'execution_count': 54,
'id': '57f65aeb-37f0-4cba-8d81-abea23aaadb9',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'data': {'text/html': '<div>\n'
'<style scoped>\n'
' .dataframe '
'tbody tr '
'th:only-of-type '
'{\n'
' '
'vertical-align: '
'middle;\n'
' }\n'
'\n'
' .dataframe '
'tbody tr th {\n'
' '
'vertical-align: '
'top;\n'
' }\n'
'\n'
' .dataframe '
'thead th {\n'
' '
'text-align: '
'right;\n'
' }\n'
'</style>\n'
'<table border="1" '
'class="dataframe">\n'
' <thead>\n'
' <tr '
'style="text-align: '
'right;">\n'
' <th></th>\n'
' '
'<th>function_name</th>\n'
' '
'<th>stage</th>\n'
' '
'<th>id</th>\n'
' '
'<th>is_success</th>\n'
' '
'<th>message</th>\n'
' '
'<th>response</th>\n'
' </tr>\n'
' </thead>\n'
' <tbody>\n'
' <tr>\n'
' <th>0</th>\n'
' '
'<td>upsert_user_fn</td>\n'
' '
'<td>upsert_user</td>\n'
' '
'<td>test_automate@sony.com</td>\n'
' '
'<td>True</td>\n'
' <td>user '
'1853825438 '
'upserted</td>\n'
' '
"<td>DomoUser(id='1853825438', "
"display_name='update...</td>\n"
' </tr>\n'
' <tr>\n'
' <th>1</th>\n'
' '
'<td>regenerate_access_token_fn</td>\n'
' '
'<td>get_by_id</td>\n'
' '
'<td>test_automate@sony.com</td>\n'
' '
'<td>True</td>\n'
' '
'<td>retrieve '
'1853825438</td>\n'
' '
'<td>DomoAccessToken(id=186899, '
"name='token_DEMO', "
'...</td>\n'
' </tr>\n'
' <tr>\n'
' <th>2</th>\n'
' '
'<td>regenerate_access_token_fn</td>\n'
' <td>get '
'access_tokens</td>\n'
' '
'<td>test_automate@sony.com</td>\n'
' '
'<td>True</td>\n'
' <td>all '
'access_tokens '
'retrieved</td>\n'
' '
'<td>DomoAccessToken(id=186899, '
"name='token_DEMO', "
'...</td>\n'
' </tr>\n'
' <tr>\n'
' <th>3</th>\n'
' '
'<td>regenerate_access_token_fn</td>\n'
' '
'<td>regenerate '
'access_token</td>\n'
' '
'<td>test_automate@sony.com</td>\n'
' '
'<td>True</td>\n'
' '
'<td>regenerated '
'token - '
'a9026db86a06d592e619e62028...</td>\n'
' '
'<td>DomoAccessToken(id=186899, '
"name='token_DEMO', "
'...</td>\n'
' </tr>\n'
' </tbody>\n'
'</table>\n'
'</div>',
'text/plain': ' '
'function_name '
'stage \\\n'
'0 '
'upsert_user_fn '
'upsert_user \n'
'1 '
'regenerate_access_token_fn '
'get_by_id \n'
'2 '
'regenerate_access_token_fn '
'get '
'access_tokens \n'
'3 '
'regenerate_access_token_fn '
'regenerate '
'access_token \n'
'\n'
' '
'id is_success '
'\\\n'
'0 '
'test_automate@sony.com '
'True \n'
'1 '
'test_automate@sony.com '
'True \n'
'2 '
'test_automate@sony.com '
'True \n'
'3 '
'test_automate@sony.com '
'True \n'
'\n'
' '
'message \\\n'
'0 '
'user 1853825438 '
'upserted \n'
'1 '
'retrieve '
'1853825438 \n'
'2 '
'all '
'access_tokens '
'retrieved \n'
'3 regenerated '
'token - '
'a9026db86a06d592e619e62028... \n'
'\n'
' '
'response \n'
'0 '
"DomoUser(id='1853825438', "
"display_name='update... \n"
'1 '
'DomoAccessToken(id=186899, '
"name='token_DEMO', "
'... \n'
'2 '
'DomoAccessToken(id=186899, '
"name='token_DEMO', "
'... \n'
'3 '
'DomoAccessToken(id=186899, '
"name='token_DEMO', "
'... '},
'execution_count': 54,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'import '
'domolibrary.classes.DomoInstanceConfig as '
'dmic\n'
'import domolibrary.classes.DomoAccessToken '
'as dmat\n'
'import domolibrary.classes.DomoUser as '
'dmdu\n'
'\n'
'@dlef.factory_function(config_id_col = '
"'email')\n"
'async def '
'regenerate_access_token_fn(config : '
'dlef.FactoryConfig,\n'
' logs '
': dlef.FactoryLogs,\n'
' res : '
'dlef.FactoryResponse,\n'
' '
'duration_in_days = 90,\n'
' '
'debug_api: bool = False):\n'
' \n'
" config.test_required_attr( ['user_id', "
"'token_name'], "
'regenerate_access_token_fn.__name__)\n'
' \n'
' \n'
' message = dlef.FactoryMessage(stage = '
"'get_by_id')\n"
' res.add_message(message)\n'
' domo_user = await '
'dmdu.DomoUser.get_by_id(user_id = '
'config.user_id, auth=config.auth, session '
'= config.session)\n'
" message.message = f'retrieve "
"{domo_user.id}'\n"
' message.is_success = True\n'
' \n'
" message = dlef.FactoryMessage('get "
"access_tokens')\n"
' res.add_message(message)\n'
' \n'
' domo_config = '
'dmic.DomoInstanceConfig(auth = auth)\n'
' access_tokens = await '
'domo_config.get_access_tokens()\n'
" message.message = 'all access_tokens "
"retrieved'\n"
' message.is_success = True\n'
' \n'
' message = '
"dlef.FactoryMessage('regenerate "
"access_token')\n"
' res.add_message(message)\n'
' \n'
' access_token = next(( token for token '
'in access_tokens if token.owner == '
'domo_user and token.name == '
'config.token_name ), None)\n'
' if not access_token:\n'
' access_token = await '
'dmat.DomoAccessToken.generate(\n'
' duration_in_days = '
'duration_in_days,\n'
' token_name = '
'config.token_name,\n'
' auth = auth,\n'
' owner = domo_user, # '
'DomoUser\n'
' debug_api = debug_api,\n'
' session = config.session,\n'
' )\n'
' \n'
' access_token = await '
'access_token.regenerate()\n'
" message.message = f'regenerated token "
"- {access_token.token}'\n"
' message.is_success = True\n'
' \n'
' config.access_token = '
'access_token.token\n'
' res.response = access_token\n'
' \n'
' return res\n'
'\n'
'factory_fn_ls = [upsert_user_fn, '
'regenerate_access_token_fn ]\n'
'\n'
'logs = dlef.FactoryLogs()\n'
'\n'
'config = MyFactoryConfig(\n'
' auth = auth,\n'
' display_name = f"updated '
'{dt.date.today()}",\n'
' role_id = 2097317660,\n'
' token_name = "token_DEMO",\n'
" email = 'test_automate@sony.com',\n"
' session = httpx.AsyncClient(),\n'
' logs = logs,\n'
' factory_fn_ls = [upsert_user_fn, '
'generate_password_fn, '
'user_reset_password_fn ]\n'
')\n'
'\n'
'await '
'config.run(factory_fn_ls=factory_fn_ls, '
'debug_api = False)\n'
'\n'
'pd.DataFrame(config.logs.to_json())'},
{'cell_type': 'code',
'execution_count': 67,
'id': '3d37f0e5-5bc1-414b-b9cb-eae96b942132',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'data': {'text/plain': '<AccountConfig.domo_access_token: '
'<class '
"'domolibrary.classes.DomoAccount_Config.DomoAccount_Config_DomoAccessToken'>>"},
'execution_count': 67,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'import domolibrary.classes.DomoAccount as '
'dmacc\n'
'\n'
'dmacc.AccountConfig.domo_access_token'},
{'cell_type': 'code',
'execution_count': 69,
'id': '30334335-6c53-4af3-a8a6-6b0cd4cdbc29',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'ename': 'TypeError',
'evalue': "non-default argument 'email' "
'follows default argument',
'output_type': 'error',
'traceback': ['\x1b[0;31m---------------------------------------------------------------------------\x1b[0m',
'\x1b[0;31mTypeError\x1b[0m '
'Traceback (most recent '
'call last)',
'Cell \x1b[0;32mIn[69], '
'line 6\x1b[0m\n'
'\x1b[1;32m 1\x1b[0m '
'\x1b[38;5;129m@dlef\x1b[39m\x1b[38;5;241m.\x1b[39mfactory_function(config_id_col '
'\x1b[38;5;241m=\x1b[39m '
"\x1b[38;5;124m'\x1b[39m\x1b[38;5;124memail\x1b[39m\x1b[38;5;124m'\x1b[39m)\n"
'\x1b[1;32m 2\x1b[0m '
'\x1b[38;5;28;01masync\x1b[39;00m '
'\x1b[38;5;28;01mdef\x1b[39;00m '
'\x1b[38;5;21mupsert_account_obj\x1b[39m(logs: '
'dlef\x1b[38;5;241m.\x1b[39mFactoryLogs, '
'res : '
'dlef\x1b[38;5;241m.\x1b[39mFactoryResponse):\n'
'\x1b[1;32m '
'3\x1b[0m '
'\x1b[38;5;28;01mpass\x1b[39;00m\n'
'\x1b[1;32m 5\x1b[0m '
'\x1b[38;5;129;43m@dataclass\x1b[39;49m\n'
'\x1b[0;32m----> 6\x1b[0m '
'\x1b[38;5;28;43;01mclass\x1b[39;49;00m\x1b[43m '
'\x1b[49m\x1b[38;5;21;43;01mMyFactoryConfig\x1b[39;49;00m\x1b[43m(\x1b[49m\x1b[43mdlef\x1b[49m\x1b[38;5;241;43m.\x1b[39;49m\x1b[43mFactoryConfig\x1b[49m\x1b[43m)\x1b[49m\x1b[43m:\x1b[49m\n'
'\x1b[1;32m 7\x1b[0m '
'\x1b[43m '
'\x1b[49m\x1b[43memail\x1b[49m\x1b[43m '
'\x1b[49m\x1b[43m:\x1b[49m\x1b[43m '
'\x1b[49m\x1b[38;5;28;43mstr\x1b[39;49m\n'
'\x1b[1;32m 8\x1b[0m '
'\x1b[43m '
'\x1b[49m\x1b[43mtoken_name\x1b[49m\x1b[43m '
'\x1b[49m\x1b[43m:\x1b[49m\x1b[43m '
'\x1b[49m\x1b[38;5;28;43mstr\x1b[39;49m\n',
'File '
'\x1b[0;32m~/.conda/lib/python3.9/dataclasses.py:1021\x1b[0m, '
'in '
'\x1b[0;36mdataclass\x1b[0;34m(cls, '
'init, repr, eq, order, '
'unsafe_hash, '
'frozen)\x1b[0m\n'
'\x1b[1;32m '
'1018\x1b[0m '
'\x1b[38;5;28;01mreturn\x1b[39;00m '
'wrap\n'
'\x1b[1;32m 1020\x1b[0m '
"\x1b[38;5;66;03m# We're "
'called as @dataclass '
'without '
'parens.\x1b[39;00m\n'
'\x1b[0;32m-> 1021\x1b[0m '
'\x1b[38;5;28;01mreturn\x1b[39;00m '
'\x1b[43mwrap\x1b[49m\x1b[43m(\x1b[49m\x1b[38;5;28;43mcls\x1b[39;49m\x1b[43m)\x1b[49m\n',
'File '
'\x1b[0;32m~/.conda/lib/python3.9/dataclasses.py:1013\x1b[0m, '
'in '
'\x1b[0;36mdataclass.<locals>.wrap\x1b[0;34m(cls)\x1b[0m\n'
'\x1b[1;32m 1012\x1b[0m '
'\x1b[38;5;28;01mdef\x1b[39;00m '
'\x1b[38;5;21mwrap\x1b[39m(\x1b[38;5;28mcls\x1b[39m):\n'
'\x1b[0;32m-> '
'1013\x1b[0m '
'\x1b[38;5;28;01mreturn\x1b[39;00m '
'\x1b[43m_process_class\x1b[49m\x1b[43m(\x1b[49m\x1b[38;5;28;43mcls\x1b[39;49m\x1b[43m,\x1b[49m\x1b[43m '
'\x1b[49m\x1b[43minit\x1b[49m\x1b[43m,\x1b[49m\x1b[43m '
'\x1b[49m\x1b[38;5;28;43mrepr\x1b[39;49m\x1b[43m,\x1b[49m\x1b[43m '
'\x1b[49m\x1b[43meq\x1b[49m\x1b[43m,\x1b[49m\x1b[43m '
'\x1b[49m\x1b[43morder\x1b[49m\x1b[43m,\x1b[49m\x1b[43m '
'\x1b[49m\x1b[43munsafe_hash\x1b[49m\x1b[43m,\x1b[49m\x1b[43m '
'\x1b[49m\x1b[43mfrozen\x1b[49m\x1b[43m)\x1b[49m\n',
'File '
'\x1b[0;32m~/.conda/lib/python3.9/dataclasses.py:927\x1b[0m, '
'in '
'\x1b[0;36m_process_class\x1b[0;34m(cls, '
'init, repr, eq, order, '
'unsafe_hash, '
'frozen)\x1b[0m\n'
'\x1b[1;32m '
'923\x1b[0m '
'\x1b[38;5;66;03m# Include '
'InitVars and regular '
'fields (so, not '
'ClassVars).\x1b[39;00m\n'
'\x1b[1;32m '
'924\x1b[0m flds '
'\x1b[38;5;241m=\x1b[39m '
'[f '
'\x1b[38;5;28;01mfor\x1b[39;00m '
'f '
'\x1b[38;5;129;01min\x1b[39;00m '
'fields\x1b[38;5;241m.\x1b[39mvalues()\n'
'\x1b[1;32m '
'925\x1b[0m '
'\x1b[38;5;28;01mif\x1b[39;00m '
'f\x1b[38;5;241m.\x1b[39m_field_type '
'\x1b[38;5;129;01min\x1b[39;00m '
'(_FIELD, '
'_FIELD_INITVAR)]\n'
'\x1b[1;32m '
'926\x1b[0m '
'_set_new_attribute(\x1b[38;5;28mcls\x1b[39m, '
"\x1b[38;5;124m'\x1b[39m\x1b[38;5;124m__init__\x1b[39m\x1b[38;5;124m'\x1b[39m,\n"
'\x1b[0;32m--> '
'927\x1b[0m '
'\x1b[43m_init_fn\x1b[49m\x1b[43m(\x1b[49m\x1b[43mflds\x1b[49m\x1b[43m,\x1b[49m\n'
'\x1b[1;32m 928\x1b[0m '
'\x1b[43m '
'\x1b[49m\x1b[43mfrozen\x1b[49m\x1b[43m,\x1b[49m\n'
'\x1b[1;32m 929\x1b[0m '
'\x1b[43m '
'\x1b[49m\x1b[43mhas_post_init\x1b[49m\x1b[43m,\x1b[49m\n'
'\x1b[1;32m 930\x1b[0m '
'\x1b[43m '
'\x1b[49m\x1b[38;5;66;43;03m# '
'The name to use for the '
'"self"\x1b[39;49;00m\n'
'\x1b[1;32m 931\x1b[0m '
'\x1b[43m '
'\x1b[49m\x1b[38;5;66;43;03m# '
'param in __init__. Use '
'"self"\x1b[39;49;00m\n'
'\x1b[1;32m 932\x1b[0m '
'\x1b[43m '
'\x1b[49m\x1b[38;5;66;43;03m# '
'if '
'possible.\x1b[39;49;00m\n'
'\x1b[1;32m 933\x1b[0m '
'\x1b[43m '
"\x1b[49m\x1b[38;5;124;43m'\x1b[39;49m\x1b[38;5;124;43m__dataclass_self__\x1b[39;49m\x1b[38;5;124;43m'\x1b[39;49m\x1b[43m "
'\x1b[49m\x1b[38;5;28;43;01mif\x1b[39;49;00m\x1b[43m '
"\x1b[49m\x1b[38;5;124;43m'\x1b[39;49m\x1b[38;5;124;43mself\x1b[39;49m\x1b[38;5;124;43m'\x1b[39;49m\x1b[43m "
'\x1b[49m\x1b[38;5;129;43;01min\x1b[39;49;00m\x1b[43m '
'\x1b[49m\x1b[43mfields\x1b[49m\n'
'\x1b[1;32m 934\x1b[0m '
'\x1b[43m '
'\x1b[49m\x1b[38;5;28;43;01melse\x1b[39;49;00m\x1b[43m '
"\x1b[49m\x1b[38;5;124;43m'\x1b[39;49m\x1b[38;5;124;43mself\x1b[39;49m\x1b[38;5;124;43m'\x1b[39;49m\x1b[43m,\x1b[49m\n"
'\x1b[1;32m 935\x1b[0m '
'\x1b[43m '
'\x1b[49m\x1b[38;5;28;43mglobals\x1b[39;49m\x1b[43m,\x1b[49m\n'
'\x1b[1;32m 936\x1b[0m '
'\x1b[43m '
'\x1b[49m\x1b[43m)\x1b[49m)\n'
'\x1b[1;32m 938\x1b[0m '
'\x1b[38;5;66;03m# Get the '
'fields as a list, and '
'include only real '
'fields. This '
'is\x1b[39;00m\n'
'\x1b[1;32m 939\x1b[0m '
'\x1b[38;5;66;03m# used in '
'all of the following '
'methods.\x1b[39;00m\n'
'\x1b[1;32m 940\x1b[0m '
'field_list '
'\x1b[38;5;241m=\x1b[39m '
'[f '
'\x1b[38;5;28;01mfor\x1b[39;00m '
'f '
'\x1b[38;5;129;01min\x1b[39;00m '
'fields\x1b[38;5;241m.\x1b[39mvalues() '
'\x1b[38;5;28;01mif\x1b[39;00m '
'f\x1b[38;5;241m.\x1b[39m_field_type '
'\x1b[38;5;129;01mis\x1b[39;00m '
'_FIELD]\n',
'File '
'\x1b[0;32m~/.conda/lib/python3.9/dataclasses.py:504\x1b[0m, '
'in '
'\x1b[0;36m_init_fn\x1b[0;34m(fields, '
'frozen, has_post_init, '
'self_name, '
'globals)\x1b[0m\n'
'\x1b[1;32m '
'502\x1b[0m '
'seen_default '
'\x1b[38;5;241m=\x1b[39m '
'\x1b[38;5;28;01mTrue\x1b[39;00m\n'
'\x1b[1;32m '
'503\x1b[0m '
'\x1b[38;5;28;01melif\x1b[39;00m '
'seen_default:\n'
'\x1b[0;32m--> '
'504\x1b[0m '
'\x1b[38;5;28;01mraise\x1b[39;00m '
"\x1b[38;5;167;01mTypeError\x1b[39;00m(\x1b[38;5;124mf\x1b[39m\x1b[38;5;124m'\x1b[39m\x1b[38;5;124mnon-default "
'argument '
'\x1b[39m\x1b[38;5;132;01m{\x1b[39;00mf\x1b[38;5;241m.\x1b[39mname\x1b[38;5;132;01m!r}\x1b[39;00m\x1b[38;5;124m '
"\x1b[39m\x1b[38;5;124m'\x1b[39m\n"
'\x1b[1;32m '
'505\x1b[0m '
"\x1b[38;5;124m'\x1b[39m\x1b[38;5;124mfollows "
'default '
"argument\x1b[39m\x1b[38;5;124m'\x1b[39m)\n"
'\x1b[1;32m 507\x1b[0m '
'\x1b[38;5;28mlocals\x1b[39m '
'\x1b[38;5;241m=\x1b[39m '
"{\x1b[38;5;124mf\x1b[39m\x1b[38;5;124m'\x1b[39m\x1b[38;5;124m_type_\x1b[39m\x1b[38;5;132;01m{\x1b[39;00mf\x1b[38;5;241m.\x1b[39mname\x1b[38;5;132;01m}\x1b[39;00m\x1b[38;5;124m'\x1b[39m: "
'f\x1b[38;5;241m.\x1b[39mtype '
'\x1b[38;5;28;01mfor\x1b[39;00m '
'f '
'\x1b[38;5;129;01min\x1b[39;00m '
'fields}\n'
'\x1b[1;32m 508\x1b[0m '
'\x1b[38;5;28mlocals\x1b[39m\x1b[38;5;241m.\x1b[39mupdate({\n'
'\x1b[1;32m '
'509\x1b[0m '
"\x1b[38;5;124m'\x1b[39m\x1b[38;5;124mMISSING\x1b[39m\x1b[38;5;124m'\x1b[39m: "
'MISSING,\n'
'\x1b[1;32m '
'510\x1b[0m '
"\x1b[38;5;124m'\x1b[39m\x1b[38;5;124m_HAS_DEFAULT_FACTORY\x1b[39m\x1b[38;5;124m'\x1b[39m: "
'_HAS_DEFAULT_FACTORY,\n'
'\x1b[1;32m 511\x1b[0m '
'})\n',
'\x1b[0;31mTypeError\x1b[0m: '
'non-default argument '
"'email' follows default "
'argument']}],
'source': '\n'
'\n'
'@dlef.factory_function(config_id_col = '
"'email')\n"
'async def upsert_account_obj(logs: '
'dlef.FactoryLogs, res : '
'dlef.FactoryResponse):\n'
' pass\n'
'\n'
'@dataclass\n'
'class '
'MyFactoryConfig(dlef.FactoryConfig):\n'
' email : str\n'
' token_name : str\n'
' password : str\n'
' account_config : dmacc.AccountConfig\n'
' \n'
'config = MyFactoryConfig(\n'
' auth = auth,\n'
" email = 'test_automate@sony.com',\n"
' session = httpx.AsyncClient(),\n'
' token_name = None,\n'
' password = None,\n'
' account_config = '
'dmacc.AccountConfig.domo_access_token,\n'
' logs = logs,\n'
' factory_fn_ls = [upsert_account_obj ]\n'
')\n'
'await upsert_account_obj()'},
{'cell_type': 'code',
'execution_count': None,
'id': '172c919f-f77d-49b7-9ff9-0e209926c4b7',
'metadata': {'trusted': True},
'outputs': [],
'source': 'config = MyFactoryConfig(\n'
' auth = auth,\n'
" email = 'test_automate@sony.com',\n"
' session = httpx.AsyncClient(),\n'
' logs = logs,\n'
' factory_fn_ls = [upsert_account_obj ]\n'
')'},
{'cell_type': 'markdown',
'id': '93bdc6e5-aa58-43eb-aebe-cf5f9883d627',
'metadata': {'tags': []},
'source': '# SAMPLE IMPLEMENTATION'},
{'cell_type': 'code',
'execution_count': 56,
'id': '68a934ef-7545-40c6-8322-21941a2f66be',
'metadata': {'trusted': True},
'outputs': [{'data': {'text/html': '<div>\n'
'<style scoped>\n'
' .dataframe '
'tbody tr '
'th:only-of-type '
'{\n'
' '
'vertical-align: '
'middle;\n'
' }\n'
'\n'
' .dataframe '
'tbody tr th {\n'
' '
'vertical-align: '
'top;\n'
' }\n'
'\n'
' .dataframe '
'thead th {\n'
' '
'text-align: '
'right;\n'
' }\n'
'</style>\n'
'<table border="1" '
'class="dataframe">\n'
' <thead>\n'
' <tr '
'style="text-align: '
'right;">\n'
' <th></th>\n'
' '
'<th>function_name</th>\n'
' '
'<th>stage</th>\n'
' '
'<th>id</th>\n'
' '
'<th>is_success</th>\n'
' '
'<th>message</th>\n'
' '
'<th>response</th>\n'
' </tr>\n'
' </thead>\n'
' <tbody>\n'
' <tr>\n'
' <th>0</th>\n'
' '
'<td>upsert_user_fn</td>\n'
' '
'<td>upsert_user</td>\n'
' '
'<td>test_automate@sony.com</td>\n'
' '
'<td>True</td>\n'
' <td>user '
'1853825438 '
'upserted</td>\n'
' '
"<td>DomoUser(id='1853825438', "
"display_name='Test "
'U...</td>\n'
' </tr>\n'
' <tr>\n'
' <th>1</th>\n'
' '
'<td>generate_password_fn</td>\n'
' '
'<td>generate_password</td>\n'
' '
'<td>test_automate@sony.com</td>\n'
' '
'<td>True</td>\n'
' '
'<td>password_generated</td>\n'
' '
'<td>finer_aide_chimp_equal_2024!@#</td>\n'
' </tr>\n'
' <tr>\n'
' <th>2</th>\n'
' '
'<td>user_reset_password_fn</td>\n'
' '
'<td>get_user_by_id</td>\n'
' '
'<td>test_automate@sony.com</td>\n'
' '
'<td>True</td>\n'
' <td>user '
'1853825438 '
'retrieved</td>\n'
' '
"<td>DomoUser(id='1853825438', "
"display_name='Test "
'U...</td>\n'
' </tr>\n'
' <tr>\n'
' <th>3</th>\n'
' '
'<td>user_reset_password_fn</td>\n'
' '
'<td>reset_password</td>\n'
' '
'<td>test_automate@sony.com</td>\n'
' '
'<td>True</td>\n'
' '
'<td>password '
'reset to '
'finer_aide_chimp_equal_2024!@#</td>\n'
' '
"<td>DomoUser(id='1853825438', "
"display_name='Test "
'U...</td>\n'
' </tr>\n'
' <tr>\n'
' <th>4</th>\n'
' '
'<td>regenerate_access_token_fn</td>\n'
' '
'<td>get_by_id</td>\n'
' '
'<td>test_automate@sony.com</td>\n'
' '
'<td>True</td>\n'
' '
'<td>retrieve '
'1853825438</td>\n'
' '
'<td>DomoAccessToken(id=186900, '
"name='token_DEMO', "
'...</td>\n'
' </tr>\n'
' <tr>\n'
' <th>5</th>\n'
' '
'<td>regenerate_access_token_fn</td>\n'
' <td>get '
'access_tokens</td>\n'
' '
'<td>test_automate@sony.com</td>\n'
' '
'<td>True</td>\n'
' <td>all '
'access_tokens '
'retrieved</td>\n'
' '
'<td>DomoAccessToken(id=186900, '
"name='token_DEMO', "
'...</td>\n'
' </tr>\n'
' <tr>\n'
' <th>6</th>\n'
' '
'<td>regenerate_access_token_fn</td>\n'
' '
'<td>regenerate '
'access_token</td>\n'
' '
'<td>test_automate@sony.com</td>\n'
' '
'<td>True</td>\n'
' '
'<td>regenerated '
'token - '
'800ee88906cd71fccb5806544a...</td>\n'
' '
'<td>DomoAccessToken(id=186900, '
"name='token_DEMO', "
'...</td>\n'
' </tr>\n'
' <tr>\n'
' <th>7</th>\n'
' '
'<td>upsert_user_fn</td>\n'
' '
'<td>upsert_user</td>\n'
' '
'<td>test_automate2@sony.com</td>\n'
' '
'<td>True</td>\n'
' <td>user '
'1228812242 '
'upserted</td>\n'
' '
"<td>DomoUser(id='1228812242', "
"display_name='Test "
'U...</td>\n'
' </tr>\n'
' <tr>\n'
' <th>8</th>\n'
' '
'<td>generate_password_fn</td>\n'
' '
'<td>generate_password</td>\n'
' '
'<td>test_automate2@sony.com</td>\n'
' '
'<td>True</td>\n'
' '
'<td>password_generated</td>\n'
' '
'<td>fox_audio_canon_evict_2024!@#</td>\n'
' </tr>\n'
' <tr>\n'
' <th>9</th>\n'
' '
'<td>user_reset_password_fn</td>\n'
' '
'<td>get_user_by_id</td>\n'
' '
'<td>test_automate2@sony.com</td>\n'
' '
'<td>True</td>\n'
' <td>user '
'1228812242 '
'retrieved</td>\n'
' '
"<td>DomoUser(id='1228812242', "
"display_name='Test "
'U...</td>\n'
' </tr>\n'
' <tr>\n'
' '
'<th>10</th>\n'
' '
'<td>user_reset_password_fn</td>\n'
' '
'<td>reset_password</td>\n'
' '
'<td>test_automate2@sony.com</td>\n'
' '
'<td>True</td>\n'
' '
'<td>password '
'reset to '
'fox_audio_canon_evict_2024!@#</td>\n'
' '
"<td>DomoUser(id='1228812242', "
"display_name='Test "
'U...</td>\n'
' </tr>\n'
' <tr>\n'
' '
'<th>11</th>\n'
' '
'<td>regenerate_access_token_fn</td>\n'
' '
'<td>get_by_id</td>\n'
' '
'<td>test_automate2@sony.com</td>\n'
' '
'<td>True</td>\n'
' '
'<td>retrieve '
'1228812242</td>\n'
' '
'<td>DomoAccessToken(id=186901, '
"name='token_DEMO', "
'...</td>\n'
' </tr>\n'
' <tr>\n'
' '
'<th>12</th>\n'
' '
'<td>regenerate_access_token_fn</td>\n'
' <td>get '
'access_tokens</td>\n'
' '
'<td>test_automate2@sony.com</td>\n'
' '
'<td>True</td>\n'
' <td>all '
'access_tokens '
'retrieved</td>\n'
' '
'<td>DomoAccessToken(id=186901, '
"name='token_DEMO', "
'...</td>\n'
' </tr>\n'
' <tr>\n'
' '
'<th>13</th>\n'
' '
'<td>regenerate_access_token_fn</td>\n'
' '
'<td>regenerate '
'access_token</td>\n'
' '
'<td>test_automate2@sony.com</td>\n'
' '
'<td>True</td>\n'
' '
'<td>regenerated '
'token - '
'6c7aea2c3d94fcbacfae42eeeb...</td>\n'
' '
'<td>DomoAccessToken(id=186901, '
"name='token_DEMO', "
'...</td>\n'
' </tr>\n'
' </tbody>\n'
'</table>\n'
'</div>',
'text/plain': ' '
'function_name '
'stage \\\n'
'0 '
'upsert_user_fn '
'upsert_user \n'
'1 '
'generate_password_fn '
'generate_password \n'
'2 '
'user_reset_password_fn '
'get_user_by_id \n'
'3 '
'user_reset_password_fn '
'reset_password \n'
'4 '
'regenerate_access_token_fn '
'get_by_id \n'
'5 '
'regenerate_access_token_fn '
'get '
'access_tokens \n'
'6 '
'regenerate_access_token_fn '
'regenerate '
'access_token \n'
'7 '
'upsert_user_fn '
'upsert_user \n'
'8 '
'generate_password_fn '
'generate_password \n'
'9 '
'user_reset_password_fn '
'get_user_by_id \n'
'10 '
'user_reset_password_fn '
'reset_password \n'
'11 '
'regenerate_access_token_fn '
'get_by_id \n'
'12 '
'regenerate_access_token_fn '
'get '
'access_tokens \n'
'13 '
'regenerate_access_token_fn '
'regenerate '
'access_token \n'
'\n'
' '
'id is_success '
'\\\n'
'0 '
'test_automate@sony.com '
'True \n'
'1 '
'test_automate@sony.com '
'True \n'
'2 '
'test_automate@sony.com '
'True \n'
'3 '
'test_automate@sony.com '
'True \n'
'4 '
'test_automate@sony.com '
'True \n'
'5 '
'test_automate@sony.com '
'True \n'
'6 '
'test_automate@sony.com '
'True \n'
'7 '
'test_automate2@sony.com '
'True \n'
'8 '
'test_automate2@sony.com '
'True \n'
'9 '
'test_automate2@sony.com '
'True \n'
'10 '
'test_automate2@sony.com '
'True \n'
'11 '
'test_automate2@sony.com '
'True \n'
'12 '
'test_automate2@sony.com '
'True \n'
'13 '
'test_automate2@sony.com '
'True \n'
'\n'
' '
'message \\\n'
'0 '
'user 1853825438 '
'upserted \n'
'1 '
'password_generated \n'
'2 '
'user 1853825438 '
'retrieved \n'
'3 password '
'reset to '
'finer_aide_chimp_equal_2024!@# \n'
'4 '
'retrieve '
'1853825438 \n'
'5 '
'all '
'access_tokens '
'retrieved \n'
'6 regenerated '
'token - '
'800ee88906cd71fccb5806544a... \n'
'7 '
'user 1228812242 '
'upserted \n'
'8 '
'password_generated \n'
'9 '
'user 1228812242 '
'retrieved \n'
'10 password '
'reset to '
'fox_audio_canon_evict_2024!@# \n'
'11 '
'retrieve '
'1228812242 \n'
'12 '
'all '
'access_tokens '
'retrieved \n'
'13 regenerated '
'token - '
'6c7aea2c3d94fcbacfae42eeeb... \n'
'\n'
' '
'response \n'
'0 '
"DomoUser(id='1853825438', "
"display_name='Test "
'U... \n'
'1 '
'finer_aide_chimp_equal_2024!@# \n'
'2 '
"DomoUser(id='1853825438', "
"display_name='Test "
'U... \n'
'3 '
"DomoUser(id='1853825438', "
"display_name='Test "
'U... \n'
'4 '
'DomoAccessToken(id=186900, '
"name='token_DEMO', "
'... \n'
'5 '
'DomoAccessToken(id=186900, '
"name='token_DEMO', "
'... \n'
'6 '
'DomoAccessToken(id=186900, '
"name='token_DEMO', "
'... \n'
'7 '
"DomoUser(id='1228812242', "
"display_name='Test "
'U... \n'
'8 '
'fox_audio_canon_evict_2024!@# \n'
'9 '
"DomoUser(id='1228812242', "
"display_name='Test "
'U... \n'
'10 '
"DomoUser(id='1228812242', "
"display_name='Test "
'U... \n'
'11 '
'DomoAccessToken(id=186901, '
"name='token_DEMO', "
'... \n'
'12 '
'DomoAccessToken(id=186901, '
"name='token_DEMO', "
'... \n'
'13 '
'DomoAccessToken(id=186901, '
"name='token_DEMO', "
'... '},
'execution_count': 56,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'users_to_create= [\n'
' { \'display_name\': f"Test User 1 - '
'updated {dt.datetime.now()}", \n'
" 'email' : "
'"test_automate@sony.com",\n'
" 'role_id': 2097317660\n"
' },\n'
' { \'display_name\': f"Test User 2 - '
'updated {dt.datetime.now()}", \n'
" 'email' : "
'"test_automate2@sony.com",\n'
" 'role_id': 2097317660}\n"
']\n'
'\n'
'logs = dlef.FactoryLogs()\n'
'\n'
'factory_fn_ls = [\n'
' upsert_user_fn, \n'
' generate_password_fn,\n'
' user_reset_password_fn,\n'
' '
'regenerate_access_token_fn \n'
' ]\n'
'\n'
'for user in users_to_create:\n'
' config = MyFactoryConfig(\n'
' **user,\n'
' token_name = "token_DEMO",\n'
' auth = auth,\n'
' session = httpx.AsyncClient(),\n'
' factory_fn_ls = factory_fn_ls,\n'
' logs = logs\n'
' )\n'
' await config.run()\n'
'\n'
'pd.DataFrame(logs.to_json())'}],
'metadata': {'kernelspec': {'display_name': 'Python',
'language': 'python',
'name': 'python_3_9'},
'language_info': {'codemirror_mode': {'name': 'ipython',
'version': 3},
'file_extension': '.py',
'mimetype': 'text/x-python',
'name': 'python',
'nbconvert_exporter': 'python',
'pygments_lexer': 'ipython3',
'version': '3.9.13'}},
'nbformat': 4,
'nbformat_minor': 5},
'created': '2024-03-21T14:07:18.508000Z',
'format': 'json',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-21T14:07:18.508000Z',
'mimetype': None,
'name': 'assembly_implementation.ipynb',
'path': 'test_domolibrary/assembly_implementation.ipynb',
'size': 51215,
'type': 'notebook',
'writable': True},
{'content': '',
'created': '2025-03-10T21:31:27.954000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T21:31:27.954000Z',
'mimetype': 'text/plain',
'name': 'untitled10',
'path': 'admin/song/untitled10',
'size': 0,
'type': 'file',
'writable': True},
{'content': '',
'created': '2025-03-10T20:52:49.698000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T20:52:49.698000Z',
'mimetype': 'text/plain',
'name': 'untitled1',
'path': 'admin/song/untitled1',
'size': 0,
'type': 'file',
'writable': True},
{'content': 'ACCESS_TOKEN = 83ece44f1451d4b581e1191f98cd411164f0b5b6ad2755b3',
'created': '2024-03-20T15:15:47.590000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-20T15:15:47.590000Z',
'mimetype': 'text/plain',
'name': 'env.txt',
'path': 'test_domolibrary/env.txt',
'size': 63,
'type': 'file',
'writable': True},
{'content': {'cells': [{'cell_type': 'code',
'execution_count': 1,
'id': '22225df2-51f9-4d3b-8c00-6613397e2e0f',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': '# %pip install domolibrary --upgrade\n'
'# %pip install domolibrary_extensions '
'--upgrade\n'
'# %pip install xkcdpass'},
{'cell_type': 'code',
'execution_count': 2,
'id': '0dec358c-6816-43b5-809d-37125d91ef29',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'from typing import Any, Awaitable\n'
'\n'
'async def run_sequence(\n'
' *functions: Awaitable[Any], # comma '
'separated list of functions\n'
') -> None: # no explicit return\n'
' """executes a sequence of '
'functions"""\n'
'\n'
' return [await function for function in '
'functions]'},
{'cell_type': 'code',
'execution_count': 3,
'id': 'a4476451-00e8-4fb7-937d-eb5b949f946a',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'from nbdev.showdoc import patch_to\n'
'from typing import List\n'
'\n'
'import '
'domolibrary_extensions.utils.process as '
'pr\n'
'\n'
'@patch_to(pr.ProcessMessage)\n'
'def __eq__(self, other):\n'
' if not isinstance(other, '
'ProcessMessage):\n'
' return False\n'
' return (self.stage == '
'other.stage)\n'
'\n'
' \n'
'@patch_to(pr.ProcessResponse)\n'
'def __eq__(self, other):\n'
' \n'
' if not isinstance(other, '
'pr.ProcessResponse):\n'
' return False\n'
'\n'
' return (self.id == other.id and '
'self.function_name == '
'other.function_name)'},
{'cell_type': 'code',
'execution_count': 4,
'id': '845c89af-f6be-4952-a348-78a2f3c35db6',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': '\n'
'@patch_to(pr.ProcessLogs)\n'
'def to_json(self) -> List[dict]:\n'
' return [{"execution": index , '
'**message} for index, log in '
'enumerate(self.logs) for message in '
'log.to_json()]\n'
' \n'
'@patch_to(pr.ProcessLogs)\n'
'def append(self, message):\n'
' if message in self.logs:\n'
" print('message already in logs')\n"
' \n'
' self.logs.append(message)\n'
' '},
{'cell_type': 'code',
'execution_count': 5,
'id': 'fcd3420e-4340-491e-ac2d-c16b1cb12c85',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'data': {'text/plain': "{'domolibrary': "
"'4.0.20', "
"'extensions': "
"'0.0.23'}"},
'execution_count': 5,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'import domolibrary\n'
'import domolibrary_extensions\n'
'\n'
'{"domolibrary": domolibrary.__version__, '
'"extensions" : '
'domolibrary_extensions.__version__}\n'},
{'cell_type': 'code',
'execution_count': 6,
'id': '1a1b67f7-22e9-45ff-9360-167b9d7dbee9',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'data': {'text/plain': 'True'},
'execution_count': 6,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'from dotenv import load_dotenv\n'
'\n'
"load_dotenv('env.txt', override = True)"},
{'cell_type': 'code',
'execution_count': 7,
'id': 'f849e51b-ed71-40ee-9f51-3b925184e5c6',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'name': 'stdout',
'output_type': 'stream',
'text': 'warning this token has not been '
'validated by who_am_i, run '
'get_auth_token first\n'},
{'data': {'text/plain': 'ResponseGetData(status=200, '
"response={'id': "
'1893952720, '
"'invitorUserId': "
'587894148, '
"'displayName': "
"'Jae Wilson1', "
"'department': "
"'Business "
"Improvement', "
"'userName': "
"'jae@onyxreporting.com', "
"'emailAddress': "
"'jae@onyxreporting.com', "
"'avatarKey': "
"'c605f478-0cd2-4451-9fd4-d82090b71e66', "
"'accepted': "
'True, '
"'userType': "
"'USER', "
"'modified': "
'1710870541105, '
"'created': "
'1588960518, '
"'active': True, "
"'pending': "
'False, '
"'anonymous': "
'False, '
"'systemUser': "
'False}, '
'is_success=True, '
"parent_class='DomoTokenAuth')"},
'execution_count': 7,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'import domolibrary.client.DomoAuth as '
'dmda\n'
'import os\n'
'\n'
'auth = dmda.DomoTokenAuth(\n'
' domo_access_token = '
"os.environ['ACCESS_TOKEN'],\n"
" domo_instance = 'domo-community'\n"
')\n'
'\n'
'await auth.who_am_i()'},
{'cell_type': 'code',
'execution_count': 8,
'id': 'fd3434f6-afb3-4b8d-aa8a-d73856b06bae',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'data': {'text/plain': 'DomoRole(id=2, '
"name='Privileged', "
"description='Full "
'access except '
'for editing '
'users and '
'settings '
"owners', "
'is_system_role=True, '
'is_default_role=True, '
'grant_ls=[], '
'membership_ls=[])'},
'execution_count': 8,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'import httpx\n'
'\n'
'import domolibrary.routes.role as '
'role_routes\n'
'import domolibrary.classes.DomoRole as '
'dmr\n'
'\n'
'from domolibrary.classes.DomoRole import '
'DomoRoles, DomoRole\n'
'from nbdev.showdoc import patch_to\n'
'\n'
'@patch_to(DomoRoles, cls_method = True)\n'
'async def get_default_role(cls, auth : '
'dmda.DomoAuth,\n'
' return_raw: '
'bool = False,\n'
' debug_api : '
'bool = False,\n'
' '
'debug_num_stacks_to_drop = 2,\n'
' session: '
'httpx.AsyncClient = None,\n'
' ):\n'
' res = await '
'role_routes.get_default_role(auth=auth, '
'session = session,\n'
' '
'parent_class = cls.__name__,\n'
' '
'debug_num_stacks_to_drop = '
'debug_num_stacks_to_drop,\n'
' '
'debug_api = debug_api)\n'
' if return_raw:\n'
' return res\n'
'\n'
' domo_role = await '
'DomoRole.get_by_id(role_id = res.response, '
'auth = auth,\n'
' '
'debug_api = debug_api,\n'
' # '
'parent_class = cls.__name__,\n'
' '
'session = session,\n'
' '
'debug_num_stacks_to_drop = '
'debug_num_stacks_to_drop,\n'
' )\n'
' domo_role.is_default_role = True\n'
' \n'
' return domo_role\n'
'\n'
'await DomoRoles.get_default_role(auth = '
'auth)'},
{'cell_type': 'code',
'execution_count': 9,
'id': 'bf554b19-0cae-443e-b74a-818027c76e5e',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'data': {'text/plain': "'fang_amiss_croak_evoke_2024!@#'"},
'execution_count': 9,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'from xkcdpass import xkcd_password as xp\n'
'import string\n'
'import secrets\n'
'import datetime as dt\n'
'\n'
'def generate_password(digit_len = 5, '
'use_random_digit=False):\n'
' if use_random_digit:\n'
' alphabet = string.punctuation + '
'string.digits\n'
' password = '
"''.join(secrets.choice(alphabet) for i in "
'range(digit_len))\n'
' \n'
' password = '
"dt.date.today().strftime('%Y')+'!@#'\n"
' \n'
' # create a wordlist from the default '
'wordfile\n'
' # use words between 5 and 8 letters '
'long\n'
' \n'
' wordfile = xp.locate_wordfile()\n'
' mywords = '
'xp.generate_wordlist(wordfile=wordfile, '
'min_length=3, max_length=5)\n'
'\n'
' # create a password with the acrostic '
'"face"\n'
' return '
'"_".join(xp.generate_xkcdpassword(mywords, '
'delimiter = \'_\', acrostic="face", case = '
'\'lower\').split(" ")) + "_" + password\n'
'\n'
'generate_password()'},
{'cell_type': 'code',
'execution_count': 10,
'id': '9a8021f5-65bb-417e-bf83-d2875387c730',
'metadata': {'trusted': True},
'outputs': [],
'source': '# import domolibrary.classes.DomoRole as '
'dmr\n'
'\n'
'# async def sync_roles(auth : '
'dmda.DomoAuth,):\n'
'# domo_role = '
'dmr.Domo_Roles.upsert_role(\n'
'# auth = auth,\n'
'# name: str,\n'
'# description: str = None,\n'
'# grant_ls: [dmg.DomoGrant] = '
'None,\n'
'# debug_api: bool = False,\n'
'# debug_prn: bool = False,\n'
'# session: httpx.AsyncClient = '
'None,'},
{'cell_type': 'code',
'execution_count': 11,
'id': 'a5ee98eb-f469-455d-aea9-ad822d79296c',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'config_ds = {"display_name": f"Test User - '
'updated {dt.datetime.now()}", \n'
' "email" : '
'"test_automate@sony.com", \'password\' : '
'generate_password(), \n'
" 'role_id' : 2097317660,\n"
' "token_name" : '
'"token_factory",\n'
" 'auth': auth, 'session': "
'httpx.AsyncClient()\n'
' }'},
{'cell_type': 'code',
'execution_count': 12,
'id': '1117ca48-7327-42d3-9caa-6ace0eafe1b9',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'async def upsert_user_fn(display_name,\n'
' role_id,\n'
' email,\n'
' auth,\n'
' session,\n'
' config_ds,\n'
' debug_api: bool = '
'False,\n'
' **kwargs ):\n'
'\n'
' domo_user = await '
'dmdu.DomoUsers.upsert_user(\n'
' auth = auth,\n'
' email_address = email,\n'
' display_name = display_name,\n'
' session = session,\n'
' role_id = role_id,\n'
' debug_api = debug_api,\n'
' )\n'
' \n'
' config_ds.update({"user_id" : '
'domo_user.id})\n'
'\n'
' \n'
'async def user_reset_password_fn(user_id, '
'password, auth, session, debug_api: bool = '
'False,\n'
' '
'**kwargs):\n'
' domo_user = await '
'dmdu.DomoUser.get_by_id(user_id = user_id, '
'auth=auth, session = session)\n'
'\n'
' await '
'domo_user.reset_password(new_password = '
'password, \n'
' '
'debug_api = debug_api,\n'
' '
'# session = session\n'
' '
')'},
{'cell_type': 'markdown',
'id': '4dcf2971-dfec-4bb6-b78d-41c16dc0f499',
'metadata': {},
'source': '# TEST BASE ASSEMBLY'},
{'cell_type': 'code',
'execution_count': 13,
'id': '1788a1e7-d86a-44a4-8367-7bfc82b41860',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'import '
'domolibrary.classes.DomoInstanceConfig as '
'dmic\n'
'import domolibrary.classes.DomoAccessToken '
'as dmat\n'
'import domolibrary.classes.DomoUser as '
'dmdu\n'
'\n'
'async def '
'regenerate_access_token_fn(user_id, '
'token_name, auth, config_ds, session= '
'None, \n'
' '
'duration_in_days = 90, debug_api: bool = '
'False, \n'
' '
'return_raw: bool = False, **kwargs):\n'
' \n'
' domo_user = await '
'dmdu.DomoUser.get_by_id(user_id = user_id, '
'auth=auth, session = session)\n'
' \n'
' domo_config = '
'dmic.DomoInstanceConfig(auth = auth)\n'
' access_tokens = await '
'domo_config.get_access_tokens()\n'
' \n'
' access_token = next(( token for token '
'in access_tokens if token.owner == '
'domo_user and token.name == token_name ), '
'None)\n'
' \n'
' if not access_token:\n'
' access_token = await '
'dmat.DomoAccessToken.generate(\n'
' duration_in_days = '
'duration_in_days,\n'
' token_name = token_name,\n'
' auth = auth,\n'
' owner = domo_user, # '
'DomoUser\n'
' debug_api = debug_api,\n'
' session = session,\n'
' return_raw = return_raw\n'
' )\n'
' \n'
' access_token = await '
'access_token.regenerate()\n'
" config_ds.update({'access_token' : "
'access_token.token})\n'
' return access_token\n'
' \n'
'# await regenerate_access_token(\n'
'# # user_id = 587894148, # for '
'test_match\n'
'# **config_ds,\n'
'# config_ds = config_ds\n'
'# )\n'},
{'cell_type': 'code',
'execution_count': 14,
'id': '16475b38-be10-415a-bd63-d37c83769f7a',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'data': {'text/plain': "{'display_name': "
"'Test User - "
'updated '
'2024-03-20 '
"19:30:56.904971',\n"
" 'email': "
"'test_automate@sony.com',\n"
" 'password': "
"'flaky_abide_crop_elude_2024!@#',\n"
" 'role_id': "
'2097317660,\n'
" 'token_name': "
"'token_factory',\n"
" 'auth': "
"DomoTokenAuth(domo_instance='domo-community', "
"token_name='token_auth', "
'is_valid_token=True, '
"url_manual_login='https://domo-community.domo.com/auth/index?domoManualLogin=true'),\n"
" 'session': "
'<httpx.AsyncClient '
'at '
'0x7f218813e3a0>,\n'
" 'user_id': "
"'1853825438',\n"
" 'access_token': "
"'70e31b556fe1fe280c57123a46c739cae13e4e2d1c6a83f4'}"},
'execution_count': 14,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'config_ds\n'
'\n'
'assembly_fn_ls = [upsert_user_fn, '
'user_reset_password_fn, '
'regenerate_access_token_fn]\n'
'\n'
'for fn in assembly_fn_ls:\n'
' await fn(**config_ds, config_ds= '
'config_ds, debug_api = False)\n'
' \n'
'config_ds'},
{'cell_type': 'markdown',
'id': '6971d5a6-ddf3-4a68-b099-ebdc2124105d',
'metadata': {},
'source': '# OTHER STUFF'},
{'cell_type': 'code',
'execution_count': 15,
'id': 'd3bb7ca0-bbcf-4954-aac6-f97006e9cb9e',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'import domolibrary.classes.DomoUser as '
'dmdu\n'
'\n'
'import httpx\n'
'\n'
'config_ds = {"display_name": "Test User", '
'"email" : "test_automate@sony.com"}\n'
'\n'
'@pr.process_function\n'
'async def sync_user(display_name,\n'
' email,\n'
' auth : dmda.DomoAuth,\n'
' logs,\n'
' process: '
'pr.ProcessResponse = None,\n'
' domo_role = None,\n'
' password = None,\n'
' debug_api: bool = '
'False,\n'
' session : '
'httpx.AsyncClient = None) -> '
'pr.ProcessResponse:\n'
' \n'
' #STAGE1 - DEFINE ROLE\n'
' message = pr.ProcessMessage(\n'
' stage_num = 1,\n'
" stage = 'define role',\n"
' message = f"supplied role: '
'{domo_role.id} - {domo_role.name}" if '
"domo_role else 'init')\n"
' \n'
' process.add_message(message)\n'
' \n'
' if not domo_role:\n'
' domo_role = await '
'DomoRoles.get_default_role(auth = '
'auth,debug_api = debug_api, session = '
'session)\n'
' message.message = f"default role: '
'{domo_role.id} - {domo_role.name}"\n'
' \n'
' message.is_success = True\n'
'\n'
' # STAGE2 - UPSERT USER\n'
' message = pr.ProcessMessage(\n'
' stage_num = 2,\n'
" stage = 'upsert user')\n"
' process.add_message(message)\n'
' \n'
' domo_user = None\n'
' try:\n'
' domo_user = await '
'dmdu.DomoUsers.upsert_user(\n'
' auth = auth,\n'
' email_address = email,\n'
' display_name = display_name,\n'
' session = session,\n'
' role_id = domo_role.id,\n'
' )\n'
' \n'
' message.is_success = True\n'
' message.message = f"upsert user '
'{domo_user.id}"\n'
' \n'
' except Exception as e:\n'
' message.message = e\n'
' message.is_success = False\n'
' process.is_success = False\n'
' return process\n'
'\n'
' process.response = domo_user\n'
' process.is_success = True\n'
' \n'
' # STAGE3 - OPTIONAL - RESET PASSWORD\n'
' message = pr.ProcessMessage(\n'
' stage_num = 3,\n'
" stage = 'reset_password'\n"
' )\n'
' process.add_message(message)\n'
' \n'
' if not password:\n'
' message.message = "set password '
'not requested"\n'
' message.is_success = True\n'
' return process\n'
' \n'
' domo_user.password = password\n'
' \n'
' try:\n'
' await '
'domo_user.reset_password(new_password = '
'password, \n'
' '
'debug_api = debug_api,\n'
' # '
'session = session\n'
' )\n'
' message.message= f"set password '
'{password}"\n'
' message.is_success = True\n'
' \n'
' except Exception as e:\n'
' message.message = e\n'
' message.is_success = False\n'
' process.is_success = False\n'
' \n'
' return process'},
{'cell_type': 'code',
'execution_count': None,
'id': 'cfc84694-a959-46e5-b28b-979488e0bbec',
'metadata': {'trusted': True},
'outputs': [],
'source': ''},
{'cell_type': 'markdown',
'id': '172b24de-d128-4dae-b442-551e36276cec',
'metadata': {},
'source': '# OTHER STUFF'},
{'cell_type': 'code',
'execution_count': 16,
'id': 'a6c0b8d7-4506-44ca-a6b3-f06f665e4641',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'ename': 'AttributeError',
'evalue': "'NoneType' object has no "
"attribute 'add_message'",
'output_type': 'error',
'traceback': ['\x1b[0;31m---------------------------------------------------------------------------\x1b[0m',
'\x1b[0;31mAttributeError\x1b[0m '
'Traceback (most recent '
'call last)',
'Cell \x1b[0;32mIn[16], '
'line 5\x1b[0m\n'
'\x1b[1;32m 1\x1b[0m '
'\x1b[38;5;28;01mimport\x1b[39;00m '
'\x1b[38;5;21;01mpandas\x1b[39;00m '
'\x1b[38;5;28;01mas\x1b[39;00m '
'\x1b[38;5;21;01mpd\x1b[39;00m \n'
'\x1b[1;32m 3\x1b[0m '
'logs '
'\x1b[38;5;241m=\x1b[39m '
'pr\x1b[38;5;241m.\x1b[39mProcessLogs()\n'
'\x1b[0;32m----> 5\x1b[0m '
'res '
'\x1b[38;5;241m=\x1b[39m '
'\x1b[38;5;28;01mawait\x1b[39;00m '
'sync_user(display_name '
'\x1b[38;5;241m=\x1b[39m '
"config_ds[\x1b[38;5;124m'\x1b[39m\x1b[38;5;124mdisplay_name\x1b[39m\x1b[38;5;124m'\x1b[39m],\n"
'\x1b[1;32m '
'6\x1b[0m '
'email '
'\x1b[38;5;241m=\x1b[39m '
"config_ds[\x1b[38;5;124m'\x1b[39m\x1b[38;5;124memail\x1b[39m\x1b[38;5;124m'\x1b[39m],\n"
'\x1b[1;32m '
'7\x1b[0m '
'auth '
'\x1b[38;5;241m=\x1b[39m '
'auth,\n'
'\x1b[1;32m '
'8\x1b[0m '
'session '
'\x1b[38;5;241m=\x1b[39m '
'httpx\x1b[38;5;241m.\x1b[39mAsyncClient(),\n'
'\x1b[1;32m '
'9\x1b[0m '
'debug_api '
'\x1b[38;5;241m=\x1b[39m '
'\x1b[38;5;28;01mNone\x1b[39;00m,\n'
'\x1b[1;32m '
'10\x1b[0m '
'logs '
'\x1b[38;5;241m=\x1b[39m '
'logs,\n'
'\x1b[1;32m '
'11\x1b[0m '
')\n'
'\x1b[1;32m 13\x1b[0m '
'pd\x1b[38;5;241m.\x1b[39mDataFrame(res\x1b[38;5;241m.\x1b[39mto_json())\n',
'File '
'\x1b[0;32m~/.conda/lib/python3.9/site-packages/domolibrary_extensions/utils/process.py:195\x1b[0m, '
'in '
'\x1b[0;36mprocess_function.<locals>.wrapper\x1b[0;34m(auth, '
'session, debug_api, logs, '
'*args, **kwargs)\x1b[0m\n'
'\x1b[1;32m 186\x1b[0m '
'\x1b[38;5;129m@wraps\x1b[39m(func)\n'
'\x1b[1;32m 187\x1b[0m '
'\x1b[38;5;28;01masync\x1b[39;00m '
'\x1b[38;5;28;01mdef\x1b[39;00m '
'\x1b[38;5;21mwrapper\x1b[39m(\n'
'\x1b[1;32m '
'188\x1b[0m '
'\x1b[38;5;241m*\x1b[39margs: '
'Any,\n'
'\x1b[0;32m '
'(...)\x1b[0m\n'
'\x1b[1;32m '
'193\x1b[0m '
'\x1b[38;5;241m*\x1b[39m\x1b[38;5;241m*\x1b[39mkwargs: '
'Any,\n'
'\x1b[1;32m 194\x1b[0m '
') '
'\x1b[38;5;241m-\x1b[39m\x1b[38;5;241m>\x1b[39m '
'Any:\n'
'\x1b[0;32m--> '
'195\x1b[0m result '
'\x1b[38;5;241m=\x1b[39m '
'\x1b[38;5;28;01mawait\x1b[39;00m '
'func(\n'
'\x1b[1;32m '
'196\x1b[0m '
'\x1b[38;5;241m*\x1b[39margs,\n'
'\x1b[1;32m '
'197\x1b[0m '
'auth\x1b[38;5;241m=\x1b[39mauth,\n'
'\x1b[1;32m '
'198\x1b[0m '
'debug_api\x1b[38;5;241m=\x1b[39mdebug_api,\n'
'\x1b[1;32m '
'199\x1b[0m '
'session\x1b[38;5;241m=\x1b[39msession,\n'
'\x1b[1;32m '
'200\x1b[0m '
'logs\x1b[38;5;241m=\x1b[39mlogs,\n'
'\x1b[1;32m '
'201\x1b[0m '
'\x1b[38;5;241m*\x1b[39m\x1b[38;5;241m*\x1b[39mkwargs,\n'
'\x1b[1;32m '
'202\x1b[0m )\n'
'\x1b[1;32m '
'204\x1b[0m '
'\x1b[38;5;28;01mif\x1b[39;00m '
'\x1b[38;5;129;01mnot\x1b[39;00m '
'\x1b[38;5;28misinstance\x1b[39m(result, '
'ProcessResponse):\n'
'\x1b[1;32m '
'205\x1b[0m '
'\x1b[38;5;28;01mraise\x1b[39;00m '
'ProcessFunction_ResponseTypeError(result)\n',
'Cell \x1b[0;32mIn[15], '
'line 24\x1b[0m, in '
'\x1b[0;36msync_user\x1b[0;34m(display_name, '
'email, auth, logs, '
'process, domo_role, '
'password, debug_api, '
'session)\x1b[0m\n'
'\x1b[1;32m 7\x1b[0m '
'\x1b[38;5;129m@pr\x1b[39m\x1b[38;5;241m.\x1b[39mprocess_function\n'
'\x1b[1;32m 8\x1b[0m '
'\x1b[38;5;28;01masync\x1b[39;00m '
'\x1b[38;5;28;01mdef\x1b[39;00m '
'\x1b[38;5;21msync_user\x1b[39m(display_name,\n'
'\x1b[1;32m '
'9\x1b[0m '
'email,\n'
'\x1b[0;32m '
'(...)\x1b[0m\n'
'\x1b[1;32m '
'17\x1b[0m \n'
'\x1b[1;32m '
'18\x1b[0m '
'\x1b[38;5;66;03m#STAGE1 - '
'DEFINE ROLE\x1b[39;00m\n'
'\x1b[1;32m '
'19\x1b[0m message '
'\x1b[38;5;241m=\x1b[39m '
'pr\x1b[38;5;241m.\x1b[39mProcessMessage(\n'
'\x1b[1;32m '
'20\x1b[0m '
'stage_num '
'\x1b[38;5;241m=\x1b[39m '
'\x1b[38;5;241m1\x1b[39m,\n'
'\x1b[1;32m '
'21\x1b[0m stage '
'\x1b[38;5;241m=\x1b[39m '
"\x1b[38;5;124m'\x1b[39m\x1b[38;5;124mdefine "
"role\x1b[39m\x1b[38;5;124m'\x1b[39m,\n"
'\x1b[1;32m '
'22\x1b[0m message '
'\x1b[38;5;241m=\x1b[39m '
'\x1b[38;5;124mf\x1b[39m\x1b[38;5;124m"\x1b[39m\x1b[38;5;124msupplied '
'role: '
'\x1b[39m\x1b[38;5;132;01m{\x1b[39;00mdomo_role\x1b[38;5;241m.\x1b[39mid\x1b[38;5;132;01m}\x1b[39;00m\x1b[38;5;124m '
'- '
'\x1b[39m\x1b[38;5;132;01m{\x1b[39;00mdomo_role\x1b[38;5;241m.\x1b[39mname\x1b[38;5;132;01m}\x1b[39;00m\x1b[38;5;124m"\x1b[39m '
'\x1b[38;5;28;01mif\x1b[39;00m '
'domo_role '
'\x1b[38;5;28;01melse\x1b[39;00m '
"\x1b[38;5;124m'\x1b[39m\x1b[38;5;124minit\x1b[39m\x1b[38;5;124m'\x1b[39m)\n"
'\x1b[0;32m---> '
'24\x1b[0m '
'\x1b[43mprocess\x1b[49m\x1b[38;5;241;43m.\x1b[39;49m\x1b[43madd_message\x1b[49m(message)\n'
'\x1b[1;32m '
'26\x1b[0m '
'\x1b[38;5;28;01mif\x1b[39;00m '
'\x1b[38;5;129;01mnot\x1b[39;00m '
'domo_role:\n'
'\x1b[1;32m '
'27\x1b[0m '
'domo_role '
'\x1b[38;5;241m=\x1b[39m '
'\x1b[38;5;28;01mawait\x1b[39;00m '
'DomoRoles\x1b[38;5;241m.\x1b[39mget_default_role(auth '
'\x1b[38;5;241m=\x1b[39m '
'auth,debug_api '
'\x1b[38;5;241m=\x1b[39m '
'debug_api, session '
'\x1b[38;5;241m=\x1b[39m '
'session)\n',
'\x1b[0;31mAttributeError\x1b[0m: '
"'NoneType' object has no "
'attribute '
"'add_message'"]}],
'source': 'import pandas as pd \n'
'\n'
'logs = pr.ProcessLogs()\n'
'\n'
'res = await sync_user(display_name = '
"config_ds['display_name'],\n"
' email = '
"config_ds['email'],\n"
' auth = auth,\n'
' session = '
'httpx.AsyncClient(),\n'
' debug_api = None,\n'
' logs = logs,\n'
' )\n'
'\n'
'pd.DataFrame(res.to_json())'},
{'cell_type': 'code',
'execution_count': None,
'id': 'ae8b1828-bad6-4551-91ad-c202fea44b2d',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': '@pr.process_function\n'
'async def process_user(display_name, \n'
' email,\n'
' auth : '
'dmda.DomoAuth,\n'
' logs : '
'pr.ProcessLogs,\n'
' password = None,\n'
' '
'is_generate_password: bool = False\n'
' debug_api: bool = '
'False,\n'
' session '
':httpx.AsyncClient = None):\n'
' \n'
' process = '
'pr.ProcessResponse(function_name = '
"'process_user',\n"
' id = email)\n'
' logs.append(process)\n'
' \n'
' # STAGE1 - GENERATE PASSWORD\n'
' message = pr.ProcessMessage(\n'
" stage = 'generate_password',\n"
' stage_num = 1)\n'
' process.add_message(message)\n'
' \n'
' password = generate_password()\n'
' \n'
' message.message = password\n'
' message.is_success = True\n'
' \n'
' # STAGE 2 - SYNC USER\n'
' message = pr.ProcessMessage(\n'
" stage = 'sync_user',\n"
' stage_num = 2)\n'
' process.add_message(message)\n'
' \n'
' process_su = await sync_user(\n'
' display_name = display_name,\n'
' email = email,\n'
' auth = auth,\n'
' debug_api = debug_api,\n'
' session = session,\n'
' password = password,\n'
' logs = logs)\n'
' \n'
' domo_user = process_su.response\n'
' message.is_success = '
'process_su.is_success\n'
" message.message = f'sync_user { "
'"successful" if process_su.is_success else '
'"failed"}\'\n'
' \n'
' if not process_su.is_success:\n'
' raise pr.ProcessFunction_Error(\n'
' process = process,\n'
' message = '
'process_su.message[-1]\n'
' )\n'
' \n'
' process.is_success = True\n'
' process.response = domo_user\n'
' \n'
' return process'},
{'cell_type': 'code',
'execution_count': None,
'id': '62441e9b-bb74-47c1-874a-b4e18731b998',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'logs = pr.ProcessLogs()\n'
'\n'
'res = await process_user(\n'
' display_name = '
"config_ds['display_name'],\n"
" email = config_ds['email'],\n"
' auth = auth,\n'
' debug_api = False,\n'
' session = None, \n'
' logs = logs\n'
')\n'
'\n'
'pd.DataFrame(logs.to_json())'},
{'cell_type': 'code',
'execution_count': None,
'id': '60679e5d-13bd-4839-9f47-15497c11257b',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'async def request_api_token(domo_user):\n'
' pass'}],
'metadata': {'kernelspec': {'display_name': 'Python',
'language': 'python',
'name': 'python_3_9'},
'language_info': {'codemirror_mode': {'name': 'ipython',
'version': 3},
'file_extension': '.py',
'mimetype': 'text/x-python',
'name': 'python',
'nbconvert_exporter': 'python',
'pygments_lexer': 'ipython3',
'version': '3.9.13'}},
'nbformat': 4,
'nbformat_minor': 5},
'created': '2024-03-20T19:31:23.183000Z',
'format': 'json',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-20T19:31:23.183000Z',
'mimetype': None,
'name': 'Untitled(1).ipynb',
'path': 'test_domolibrary/Untitled(1).ipynb',
'size': 28131,
'type': 'notebook',
'writable': True},
{'content': {'cells': [{'cell_type': 'code',
'execution_count': 6,
'id': 'eb8094df-6fd1-456a-beaa-6069920d533d',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'data': {'text/plain': "'123 buckle my "
"shoe'"},
'execution_count': 6,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'import domojupyter as domo\n'
'# Requires domojupyter Python version '
'1.0.3\n'
'account_properties = '
"domo.get_account_property_keys('fake_account')\n"
"domo.get_account_property_value('fake_account', "
'account_properties[0])'},
{'cell_type': 'code',
'execution_count': None,
'id': 'cb8d98b3-37be-4b7d-afac-f571595dbeb3',
'metadata': {'trusted': True},
'outputs': [],
'source': ''}],
'metadata': {'kernelspec': {'display_name': 'Python',
'language': 'python',
'name': 'python_3_9'},
'language_info': {'codemirror_mode': {'name': 'ipython',
'version': 3},
'file_extension': '.py',
'mimetype': 'text/x-python',
'name': 'python',
'nbconvert_exporter': 'python',
'pygments_lexer': 'ipython3',
'version': '3.9.13'}},
'nbformat': 4,
'nbformat_minor': 5},
'created': '2024-06-04T00:59:23.522000Z',
'format': 'json',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-06-04T00:59:23.522000Z',
'mimetype': None,
'name': 'Untitled.ipynb',
'path': 'test_domolibrary/Untitled.ipynb',
'size': 1216,
'type': 'notebook',
'writable': True},
{'content': 'import requests\n'
'\n'
'\n'
'def get_session_token(\n'
' domo_instance: str, domo_username: str, domo_password: str, '
'return_raw: bool = False\n'
') -> str:\n'
'\n'
' url = '
'f"https://{domo_instance}.domo.com/api/content/v2/authentication"\n'
'\n'
' body = {\n'
' "method": "password",\n'
' "emailAddress": domo_username,\n'
' "password": domo_password,\n'
' }\n'
'\n'
' res = requests.request(method="POST", url=url, json=body, '
'verify=False)\n'
'\n'
' data = res.json()\n'
'\n'
' if return_raw:\n'
' return res\n'
'\n'
' if not res.ok:\n'
' raise Exception(data["message"])\n'
'\n'
' token = data.get("sessionToken")\n'
'\n'
' if not token:\n'
' raise Exception("No token returned from API")\n'
'\n'
' return token\n',
'created': '2024-03-25T03:39:26.905000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T03:39:26.905000Z',
'mimetype': 'text/x-python',
'name': 'get_session_token.py',
'path': 'tutorial/domopalooza-24/solutions/get_session_token.py',
'size': 670,
'type': 'file',
'writable': True},
{'content': 'import requests\n'
'\n'
'\n'
'def get_accounts(domo_instance: str, headers: dict) -> '
'requests.models.Response:\n'
' """fuction queries providers api and returns a list of all '
'accounts authenticated user has access to"""\n'
'\n'
' url = '
'f"https://{domo_instance}.domo.com/api/data/v2/datasources/providers"\n'
'\n'
' return requests.request(method="GET", url=url, '
'headers=headers)\n',
'created': '2024-03-25T03:39:26.888000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T03:39:26.888000Z',
'mimetype': 'text/x-python',
'name': 'get_accounts_v1.py',
'path': 'tutorial/domopalooza-24/solutions/get_accounts_v1.py',
'size': 357,
'type': 'file',
'writable': True},
{'content': '',
'created': '2024-03-25T03:39:26.808000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T03:39:26.808000Z',
'mimetype': 'text/x-python',
'name': '__init__.py',
'path': 'tutorial/domopalooza-24/functions/__init__.py',
'size': 0,
'type': 'file',
'writable': True},
{'content': '',
'created': '2025-03-10T20:57:02.779000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T20:57:02.779000Z',
'mimetype': 'text/plain',
'name': 'untitled5',
'path': 'admin/song/untitled5',
'size': 0,
'type': 'file',
'writable': True},
{'content': '',
'created': '2025-03-10T21:46:09.977000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T21:46:09.977000Z',
'mimetype': 'text/plain',
'name': 'untitled14',
'path': 'admin/song/untitled14',
'size': 0,
'type': 'file',
'writable': True},
{'content': '',
'created': '2025-03-10T21:09:36.630000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T21:09:36.630000Z',
'mimetype': 'text/plain',
'name': 'untitled8',
'path': 'admin/song/untitled8',
'size': 0,
'type': 'file',
'writable': True},
{'content': 'Domo API and Authentication Tutorials 📊🔐\n'
'==============\n'
'\n'
'This repo contains a set of Jupyter notebooks designed to guide '
'you through various aspects of working with the Domo API. Each '
'tutorial builds upon the previous, providing an intuitive '
'learning path.\n'
'\n'
'# Getting Started 🚀\n'
'\n'
'Before diving into the tutorials, ensure you have cloned this '
'repository into your Jupyter environment. You can do so by '
'opening a new Terminal in Jupyter and running the following '
'command:\n'
'\n'
'```bash\n'
'git clone https://github.com/jaewilson07/domopalooza-24.git\n'
'```\n'
'\n'
'For more details on cloning repositories, visit [Creating and '
'Managing Repositories from '
'GitHub](https://docs.github.com/en/repositories/creating-and-managing-repositories/cloning-a-repository).\n'
'\n'
'# Tutorial Overview 📚\n'
'\n'
'## Tutorial 1: Authentication in Domo ⬅️ *Start Here*\n'
'\n'
"- **What you'll learn**: How to authenticate API requests in "
'Domo using username and password to generate a token. This '
"tutorial covers the basics of Domo's authentication.\n"
'- **Key Concepts**: API request basics, token-based '
'authentication, network monitoring for API discovery.\n'
'\n'
'## Tutorial 2: Working with Objects & Domo Integration\n'
'\n'
"- **What you'll learn**: Using Account Objects and Datasets in "
'DomoJupyter.\n'
'- **Key Concepts**: Sending API requests, function abstraction '
'for reusability, full authentication vs. developer_token '
'authentication.\n'
'\n'
'## Tutorial 3: Generate a DomoStats Style Dataset\n'
'\n'
"- **What you'll learn**: Steps to create and structure a dataset "
'in the style of DomoStats, including data retrieval and storage '
'practices.\n'
'- **Key Concepts**: Dataset creation and structuring, more '
'access token authentication nuances, data management in Domo.\n'
'\n'
'## Tutorial 4: Using Access Token Authentication and Updating '
'Domo via API\n'
'\n'
"- **What you'll learn**: Advanced techniques for using access "
'tokens for authentication and methods for updating datasets '
'within Domo through the API.\n'
'- **Key Concepts**: Secure credential storage, dataset updating, '
'abstract account management for token storage.\n'
'\n'
'## Helpful Links 🌐\n'
'\n'
'- [Domo Developer '
'Portal](https://developer.domo.com/portal/8ba9aedad3679-ap-is)\n'
'- [Domo Community '
'Forums](https://community-forums.domo.com/main) \n'
'- [Domo KB Jupyter '
'Basics](https://domo-support.domo.com/s/article/36004740075?language=en_US#jupyter_basics)\n'
'\n'
'\n'
'## ✨ Jae Wilsons Treasure Trove 🗺️\n'
'\n'
'- [👥 Unofficial Domo Community '
'Slack](https://domousergroup.carrd.co/) \n'
'- [🐍 Python '
'domolibrary](https://github.com/jaewilson07/domolibrary) and '
'[Code '
'Samples](https://github.com/jaewilson07/domolibrary/tree/main/nbs/blog/posts)\n'
'- [📧 Postman '
'Collection](https://documenter.getpostman.com/view/5049119/UyxbppB2)\n'
'- [▶️ YouTube Channel](https://www.youtube.com/@datacrew)\n'
'- [📰 DataCrew](https://datacrew.circle.so/getting-started)\n',
'created': '2024-03-25T03:39:26.747000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T03:39:26.747000Z',
'mimetype': 'text/markdown',
'name': 'README.md',
'path': 'tutorial/domopalooza-24/README.md',
'size': 2805,
'type': 'file',
'writable': True},
{'content': 'from typing import List, Any\n'
'\n'
'import domojupyter as dj\n'
'import json\n'
'import re\n'
'import datetime as dt\n'
'import time\n'
'\n'
'def read_domo_jupyter_account(account_name, is_abstract: bool = '
'False):\n'
'\n'
' account_properties = '
'dj.get_account_property_keys(account_name)\n'
'\n'
' creds = {\n'
' prop: dj.get_account_property_value(account_name, prop)\n'
' for prop in account_properties\n'
' }\n'
'\n'
' if not is_abstract:\n'
' return creds\n'
'\n'
' return json.loads(\n'
' creds["credentials"]\n'
' ) # converts credentials string into a dictionary\n'
'\n'
'\n'
'def flatten_list_of_lists(list_of_lists) -> List[Any]:\n'
' return [row for ls in list_of_lists for row in ls]\n'
'\n'
'\n'
'def format_str_camel_case(text):\n'
' return "_".join(\n'
' re.sub(\n'
' "([A-Z][a-z]+)", r" \\1", re.sub("([A-Z]+)", r" '
'\\1", text.replace("-", " "))\n'
' ).split()\n'
' ).lower()\n'
'\n'
'\n'
'def convert_domo_utc_to_datetime(timestamp):\n'
' """Domo returns token expiration date in unix time"""\n'
' return dt.datetime.fromtimestamp(timestamp / 1000, '
'dt.timezone.utc)\n'
'\n'
'\n'
'def generate_domo_expiration_unixtimestamp(\n'
' duration_in_days: int = 15, debug_prn: bool = False\n'
'):\n'
' """the expiration date of the access token is calculated '
'based off of x days into the future which must then be converted '
'into a unix timestamp"""\n'
'\n'
' today = dt.datetime.today()\n'
' expiration_date = today + '
'dt.timedelta(days=duration_in_days)\n'
'\n'
' if debug_prn:\n'
' print(f"expiration_date is {duration_in_days} from today '
'{expiration_date}")\n'
'\n'
' return int(time.mktime(expiration_date.timetuple()) * '
'1000)\n',
'created': '2024-03-25T12:37:00.563000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T12:37:00.563000Z',
'mimetype': 'text/x-python',
'name': 'utils.py',
'path': 'tutorial/domopalooza-24/solutions/utils.py',
'size': 1536,
'type': 'file',
'writable': True},
{'content': [{'content': None,
'created': '2024-03-25T03:39:26.827000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T03:39:26.827000Z',
'mimetype': None,
'name': 'monit_accounts.ipynb',
'path': 'tutorial/domopalooza-24/implementations/monit_accounts.ipynb',
'size': 119,
'type': 'notebook',
'writable': True},
{'content': None,
'created': '2024-03-25T03:39:26.817000Z',
'format': None,
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T03:39:26.817000Z',
'mimetype': 'text/x-python',
'name': '__init__.py',
'path': 'tutorial/domopalooza-24/implementations/__init__.py',
'size': 0,
'type': 'file',
'writable': True}],
'created': '2024-03-25T03:39:26.824000Z',
'format': 'json',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T03:39:26.824000Z',
'mimetype': None,
'name': 'implementations',
'path': 'tutorial/domopalooza-24/implementations',
'size': None,
'type': 'directory',
'writable': True},
{'content': 'from dataclasses import dataclass\n'
'from typing import Union\n'
'import requests\n'
'\n'
'\n'
'class DomoAPIRequest_Error(Exception):\n'
' """a customized Exception class for handing Domo errors"""\n'
'\n'
' def __init__(self, function_name, message):\n'
' super().__init__(f"{function_name} | {message} ")\n'
'\n'
'\n'
'@dataclass\n'
'class ResponseClass:\n'
' status: int # API response status code\n'
' is_success: bool\n'
' response: dict\n'
'\n'
' @classmethod\n'
' def from_request_response(\n'
' cls, res: requests.models.Response, response: '
'Union[list, dict] = None\n'
' ):\n'
'\n'
' is_success = res.ok\n'
'\n'
' response = (\n'
' response or res.json() if '
'res.headers.get("Content-Length") != "0" else None\n'
' )\n'
'\n'
" # if there's an API errror, the Response class stores "
"the error in the 'message' field of the response object\n"
' if not is_success:\n'
' response = response["message"]\n'
'\n'
' return cls(\n'
' status=res.status_code,\n'
' is_success=is_success,\n'
' response=response,\n'
' )\n',
'created': '2024-03-25T03:39:26.879000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T03:39:26.879000Z',
'mimetype': 'text/x-python',
'name': 'client.py',
'path': 'tutorial/domopalooza-24/solutions/client.py',
'size': 1011,
'type': 'file',
'writable': True},
{'content': 'import requests\n'
'from solutions.client import ResponseClass\n'
'from solutions.utils import (\n'
' convert_domo_utc_to_datetime,\n'
' generate_domo_expiration_unixtimestamp,\n'
')\n'
'\n'
'from pprint import pprint\n'
'\n'
'\n'
'def get_all_access_tokens(\n'
' domo_instance,\n'
' session_token: str=None,\n'
' access_token: str = None,\n'
' headers : dict =None,\n'
' return_raw: bool = False,\n'
' debug_api: bool = False,\n'
'):\n'
'\n'
' url = '
'f"https://{domo_instance}.domo.com/api/data/v1/accesstokens"\n'
'\n'
' headers = headers or {}\n'
'\n'
' if session_token:\n'
' headers.update({"x-domo-authentication": '
'session_token})\n'
' \n'
' if access_token:\n'
' headers.update({"x-domo-developer-token": '
'access_token})\n'
'\n'
' if debug_api:\n'
' print({"url": url, "headers": headers})\n'
'\n'
' res = requests.request(\n'
' url=url,\n'
' method="GET",\n'
' headers=headers,\n'
' )\n'
'\n'
' res = ResponseClass.from_request_response(res)\n'
'\n'
' if return_raw:\n'
' return res\n'
'\n'
' [\n'
' token.update({"expires": '
'convert_domo_utc_to_datetime(token["expires"])})\n'
' for token in res.response\n'
' ]\n'
'\n'
' return res\n'
'\n'
'\n'
'def generate_access_token(\n'
' domo_instance,\n'
' token_name: str,\n'
' user_id,\n'
' duration_in_days: 15,\n'
' session_token=None,\n'
' access_token = None,\n'
' headers=None,\n'
' return_raw: bool = False,\n'
' debug_api: bool = False,\n'
'):\n'
' url = '
'f"https://{domo_instance}.domo.com/api/data/v1/accesstokens"\n'
'\n'
' expiration_timestamp = '
'generate_domo_expiration_unixtimestamp(\n'
' duration_in_days=duration_in_days\n'
' )\n'
'\n'
' body = {"name": token_name, "ownerId": user_id, "expires": '
'expiration_timestamp}\n'
'\n'
' headers = headers or {}\n'
'\n'
' if session_token:\n'
' headers.update({"x-domo-authentication": '
'session_token})\n'
' \n'
' if access_token:\n'
' headers.update({"x-domo-developer-token": '
'access_token})\n'
'\n'
' if debug_api:\n'
' print({"url": url, "headers": headers, "body": body})\n'
' \n'
' res = requests.request(method="post", url=url, json=body, '
'headers=headers)\n'
'\n'
' res = ResponseClass.from_request_response(res)\n'
' if return_raw:\n'
' return res\n'
'\n'
' return res\n'
'\n'
'\n'
'def revoke_access_token(\n'
' domo_instance,\n'
' access_token_id,\n'
' session_token : str=None,\n'
' access_token: str = None,\n'
' headers: dict =None,\n'
' return_raw: bool = False,\n'
' debug_api: bool = False,\n'
'):\n'
'\n'
' url = '
'f"https://{domo_instance}.domo.com/api/data/v1/accesstokens/{access_token_id}"\n'
'\n'
' headers = headers or {}\n'
'\n'
' if session_token:\n'
' headers.update({"x-domo-authentication": '
'session_token})\n'
'\n'
' if debug_api:\n'
' pprint({"url": url, "headers": headers})\n'
'\n'
' res = requests.request(method="DELETE", url=url, '
'headers=headers)\n'
'\n'
' res = ResponseClass.from_request_response(res)\n'
' if return_raw:\n'
' return res\n'
'\n'
' res.response = f"access token {access_token_id} deleted"\n'
' return res\n',
'created': '2024-03-25T12:57:25.935000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T12:57:25.935000Z',
'mimetype': 'text/x-python',
'name': 'access_tokens.py',
'path': 'tutorial/domopalooza-24/solutions/access_tokens.py',
'size': 2801,
'type': 'file',
'writable': True},
{'content': {'cells': [{'cell_type': 'code',
'execution_count': 1,
'id': '22225df2-51f9-4d3b-8c00-6613397e2e0f',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': '# %pip install domolibrary --upgrade\n'
'# %pip install domolibrary_extensions '
'--upgrade\n'
'# %pip install xkcdpass'},
{'cell_type': 'code',
'execution_count': 2,
'id': 'fcd3420e-4340-491e-ac2d-c16b1cb12c85',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'data': {'text/plain': "{'domolibrary': "
"'4.0.20', "
"'extensions': "
"'0.0.23'}"},
'execution_count': 2,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'import domolibrary\n'
'import domolibrary_extensions\n'
'\n'
'{"domolibrary": domolibrary.__version__, '
'"extensions" : '
'domolibrary_extensions.__version__}\n'},
{'cell_type': 'code',
'execution_count': 3,
'id': '1a1b67f7-22e9-45ff-9360-167b9d7dbee9',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'data': {'text/plain': 'True'},
'execution_count': 3,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'from dotenv import load_dotenv\n'
'\n'
"load_dotenv('env.txt', override = True)"},
{'cell_type': 'code',
'execution_count': 4,
'id': 'f849e51b-ed71-40ee-9f51-3b925184e5c6',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'name': 'stdout',
'output_type': 'stream',
'text': 'warning this token has not been '
'validated by who_am_i, run '
'get_auth_token first\n'},
{'data': {'text/plain': 'ResponseGetData(status=200, '
"response={'id': "
'1893952720, '
"'invitorUserId': "
'587894148, '
"'displayName': "
"'Jae Wilson1', "
"'department': "
"'Business "
"Improvement', "
"'userName': "
"'jae@onyxreporting.com', "
"'emailAddress': "
"'jae@onyxreporting.com', "
"'avatarKey': "
"'c605f478-0cd2-4451-9fd4-d82090b71e66', "
"'accepted': "
'True, '
"'userType': "
"'USER', "
"'modified': "
'1710870541105, '
"'created': "
'1588960518, '
"'active': True, "
"'pending': "
'False, '
"'anonymous': "
'False, '
"'systemUser': "
'False}, '
'is_success=True, '
"parent_class='DomoTokenAuth')"},
'execution_count': 4,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'import domolibrary.client.DomoAuth as '
'dmda\n'
'import os\n'
'\n'
'auth = dmda.DomoTokenAuth(\n'
' domo_access_token = '
"os.environ['ACCESS_TOKEN'],\n"
" domo_instance = 'domo-community'\n"
')\n'
'\n'
'await auth.who_am_i()'},
{'cell_type': 'markdown',
'id': '68c0f0c6-8d61-4c7a-a074-8226a57e14e9',
'metadata': {},
'source': '# ASSEMBLY FUNCTIONS'},
{'cell_type': 'code',
'execution_count': 5,
'id': 'c9978796-626f-4f79-b151-b98e38a7f758',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'name': 'stderr',
'output_type': 'stream',
'text': '/tmp/ipykernel_5819/3318074004.py:1: '
'DeprecationWarning: \n'
'Pyarrow will become a required '
'dependency of pandas in the '
'next major release of pandas '
'(pandas 3.0),\n'
'(to allow more performant data '
'types, such as the Arrow string '
'type, and better '
'interoperability with other '
'libraries)\n'
'but was not found to be '
'installed on your system.\n'
'If this would cause problems '
'for you,\n'
'please provide us feedback at '
'https://github.com/pandas-dev/pandas/issues/54466\n'
' \n'
' import pandas as pd\n'}],
'source': 'import pandas as pd\n'
'from pprint import pprint'},
{'cell_type': 'code',
'execution_count': 6,
'id': 'ce91d226-80b7-48da-ad83-ab7a8cb74589',
'metadata': {'trusted': True},
'outputs': [],
'source': 'from typing import Any,List\n'
'from dataclasses import dataclass, field'},
{'cell_type': 'code',
'execution_count': 7,
'id': '94f2f35d-a368-4217-a32d-4dabea461f68',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': '@dataclass\n'
'class FactoryMessage:\n'
' stage: str # description of the stage '
'of a process\n'
' message: str = "init" # outcome\n'
' is_success: bool = False\n'
'\n'
' """class for logging a stage of a '
'process"""\n'
'\n'
' def to_json(self):\n'
' return self.__dict__\n'
' \n'
' def to_string(self):\n'
' return " | ".join( [ f"{key} - '
'{str(value)}" for key, value in '
'self.__dict__.items()])\n'
' \n'
' def __eq__(self, other):\n'
' if not isinstance(other, '
'FactoryMessage):\n'
' return False\n'
' return (self.stage == '
'other.stage)'},
{'cell_type': 'code',
'execution_count': 8,
'id': '1626cc6e-b9f2-458d-ba26-ac13c25985e4',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': '\n'
' \n'
'@dataclass\n'
'class FactoryResponse:\n'
' function_name: str\n'
' id: str # identify a set of log '
'entries\n'
' \n'
' messages: List[FactoryMessage] = '
'field(default_factory=lambda: []) # '
'capture intermediate steps of the '
'process_function\n'
' response: Any = field(repr=False, '
'default=None) # final object to return '
'from the process_function\n'
' is_success: bool = False\n'
'\n'
' """Response class for handling logging '
'of a process function.\n'
' Accumulates messages as the process '
'unfolds\n'
' """\n'
' \n'
' def to_json(self) -> List[dict]:\n'
" columns = ['function_name', "
"'stage', 'id', 'is_success', 'message', "
"'response']\n"
' s= [{**self.__dict__, '
'**msg.to_json()} for msg in '
'self.messages]\n'
'\n'
' return [{col: obj[col] for col in '
'columns} for obj in s]\n'
' \n'
' def add_message(self, message: '
'FactoryMessage):\n'
' self.messages.append(message)\n'
' \n'
' def test_success(self):\n'
' self.is_success = all([ '
'message.is_success for message in '
'self.messages])\n'
' return self.is_success\n'
' \n'
' def __eq__(self, other):\n'
' if not '
'isinstance(other,FactoryResponse ):\n'
' return False\n'
' \n'
' return (self.id == other.id and '
'self.function_name == '
'other.function_name)'},
{'cell_type': 'code',
'execution_count': 9,
'id': '2fd445be-d7d0-45cf-8148-01dde85ac63d',
'metadata': {'trusted': True},
'outputs': [],
'source': '@dataclass\n'
'class FactoryLogs:\n'
' """process logs are the complete logs '
'of an entire process or script"""\n'
'\n'
' logs: List[FactoryResponse] = '
'field(default_factory=lambda: []) \n'
'\n'
' def add_response(self, res: '
'FactoryResponse):\n'
' if res in self.logs:\n'
" print('message already in "
"logs')\n"
' self.logs.append(res)\n'
' return self.logs\n'
' \n'
' def to_json(self) -> List[dict]:\n'
' return [{"execution": index , '
'**message} for index, log in '
'enumerate(self.logs) for message in '
'log.to_json()]'},
{'cell_type': 'code',
'execution_count': 10,
'id': '4777052c-36e4-443e-aafb-08fb4bbc745c',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'from dataclasses import dataclass, field\n'
'from typing import List, Callable\n'
'\n'
'import datetime as dt\n'
'import httpx\n'
'\n'
'@dataclass\n'
'class AssemblyConfig:\n'
' """create a dataclass which will have '
'all the fields used in your config '
'event""" \n'
' auth :dmda.DomoAuth = field(repr = '
'False)\n'
' \n'
' display_name: str = None\n'
' email :str = None\n'
' role_id :str = None\n'
' token_name : str = None\n'
' password : str = field(default = '
'None)\n'
' session :httpx.AsyncClient = '
'field(repr= False, default = None)\n'
' access_token : str = field(default= '
'None)\n'
'\n'
' factory_fn_ls : List[Callable] = None\n'
' \n'
' logs: FactoryLogs = None\n'
' \n'
' def __post_init__(self):\n'
' if not self.logs:\n'
' self.logs = FactoryLogs()\n'
' \n'
' def test_required_attr(self, attr_ls : '
'List[str], function_name):\n'
' for attr in attr_ls:\n'
' if not getattr(self, attr):\n'
' raise '
'FactoryFunction_MissingParameter( attr, '
'function_name)\n'
'\n'
' async def run(self ,\n'
' factory_fn_ls = None,\n'
' debug_api: bool = False '
'): \n'
' \n'
' factory_fn_ls = factory_fn_ls or '
'self.factory_fn_ls\n'
' \n'
' for fn in factory_fn_ls:\n'
' await fn(config= self,\n'
' debug_api = '
'debug_api,\n'
' logs = self.logs) \n'
'\n'
' return config\n'},
{'cell_type': 'code',
'execution_count': 92,
'id': 'fc58350e-131e-4bf5-825c-f2b88361fa7d',
'metadata': {'trusted': True},
'outputs': [],
'source': 'from typing import Any, Callable\n'
'from functools import wraps\n'
'import inspect\n'
'\n'
'class '
'FactoryFunction_ResponseTypeError(TypeError):\n'
' """a function wrapped in '
'`process_function` must return '
'FactoryResponse class"""\n'
' def __init__(self, result):\n'
' super().__init__(\n'
' f"Expected function to return '
'an instance of FactoryResponse. Got '
'{type(result)} instead. Refactor function '
'to return FactoryResponse class"\n'
' )\n'
'\n'
'class '
'FactoryFunction_MissingParameter(Exception):\n'
' def __init__(self, parameter, '
'function_name):\n'
' \n'
' super().__init__( f"missing '
'parameter - {parameter} - while calling '
'{function_name}")\n'
'\n'
' \n'
'class '
'FactoryFunction_ResponseError(Exception):\n'
' def __init__(self, message):\n'
' super().__init__( message )\n'
'\n'
'class '
'FactoryFunction_NotSuccess(Exception):\n'
' def __init__(self, messages : '
'List[FactoryMessage]):\n'
' super().__init__( "\\n".join( [ '
'message.to_string() for message in '
'messages if not message.is_success ]) )\n'
'\n'
'\n'
'def factory_function(**kwargs):\n'
' def inner(func):\n'
' \n'
' @wraps(func)\n'
' async def wrapper(*args,\n'
' res_config = '
'kwargs,\n'
' **kwargs): \n'
' \n'
" if not kwargs.get('logs'):\n"
' print(kwargs)\n'
' raise '
"FactoryFunction_MissingParameter( 'logs', "
'func.__name__)\n'
' \n'
" logs = kwargs['logs']\n"
' \n'
' res = FactoryResponse( '
'function_name = func.__name__, id = '
"getattr(kwargs['config'], "
"res_config['id']))\n"
' logs.add_response(res)\n'
' \n'
' result = await func(*args, \n'
' **kwargs,\n'
' res = '
'res,\n'
' )\n'
' \n'
' \n'
' if not isinstance(result, '
'FactoryResponse):\n'
' raise '
'FactoryFunction_ResponseTypeError(result)\n'
' \n'
' if not result.response:\n'
' raise '
'FactoryFunction_ResponseError("factory '
'response must return res.response")\n'
' \n'
' if not result.messages or '
'len(result.messages) == 0:\n'
' raise '
'FactoryFunction_ResponseError("factory '
'response must have messages")\n'
' \n'
' result.test_success()\n'
' \n'
' if not result.is_success:\n'
' raise '
'FactoryFunction_NotSuccess(result.messages)\n'
' \n'
' return result\n'
' return wrapper\n'
' return inner\n'
'\n'},
{'cell_type': 'code',
'execution_count': 107,
'id': '8d3c205b-5f84-4f9c-a470-bef520330f52',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'name': 'stdout',
'output_type': 'stream',
'text': 'AssemblyConfig(display_name=None, '
"email='test@me.com', "
'role_id=None, '
"token_name='hello', "
'password=None, '
'access_token=None, '
'factory_fn_ls=None, '
'logs=FactoryLogs(logs=[]))\n'}],
'source': "@factory_function(id = 'email')\n"
'async def foo(config, \n'
' logs: FactoryLogs,\n'
' res : FactoryResponse, \n'
' debug_api: bool = False):\n'
' \n'
' # stage1 = bar\n'
' message = FactoryMessage(stage = '
"'bar')\n"
' res.add_message(message)\n'
' \n'
' try: \n'
' # do something\n'
' message.is_success = True\n'
" message.message = 'we did "
"something'\n"
" # raise Exception('random api "
"error')\n"
' \n'
' except Exception as e:\n'
' message.message = e\n'
' message.is_success = False\n'
' \n'
' \n'
' #stage2 = something\n'
' message = FactoryMessage(stage = '
"'something')\n"
' res.add_message(message)\n'
' \n'
' #do something\n'
' message.is_success = True\n'
' \n'
' # UPDATE config\n'
" config.token_name = 'hello'\n"
' \n'
' # UPDATE response\n'
" res.response = 'hello'\n"
' \n'
' return res\n'
' \n'
'\n'
'config = AssemblyConfig(email = '
"'test@me.com', auth = auth)\n"
'logs = FactoryLogs()\n'
'\n'
'# try:\n'
'res = await foo(config = config,\n'
' logs = logs)\n'
'\n'
'res\n'
'\n'
'print(config)\n'
'# res.messages\n'
'\n'
'# except Exception as e:\n'
"# print('outside exception')\n"
'# print(e)\n'
' \n'
'# pd.DataFrame(logs.to_json())'},
{'cell_type': 'code',
'execution_count': 96,
'id': 'bc65f799-5189-4f62-abb6-43dda48cf56f',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'name': 'stdout',
'output_type': 'stream',
'text': 'if explicit changes are made to '
'the config object they will '
'accumulate after function '
'execution, this can be used to '
'pass values to sequentially '
'executed functions\n'},
{'data': {'text/html': '<div>\n'
'<style scoped>\n'
' .dataframe '
'tbody tr '
'th:only-of-type '
'{\n'
' '
'vertical-align: '
'middle;\n'
' }\n'
'\n'
' .dataframe '
'tbody tr th {\n'
' '
'vertical-align: '
'top;\n'
' }\n'
'\n'
' .dataframe '
'thead th {\n'
' '
'text-align: '
'right;\n'
' }\n'
'</style>\n'
'<table border="1" '
'class="dataframe">\n'
' <thead>\n'
' <tr '
'style="text-align: '
'right;">\n'
' <th></th>\n'
' '
'<th>function_name</th>\n'
' '
'<th>stage</th>\n'
' '
'<th>id</th>\n'
' '
'<th>is_success</th>\n'
' '
'<th>message</th>\n'
' '
'<th>response</th>\n'
' </tr>\n'
' </thead>\n'
' <tbody>\n'
' <tr>\n'
' <th>0</th>\n'
' '
'<td>foo</td>\n'
' '
'<td>bar</td>\n'
' '
'<td>test@me.com</td>\n'
' '
'<td>True</td>\n'
' <td>we did '
'something</td>\n'
' '
'<td>hello</td>\n'
' </tr>\n'
' <tr>\n'
' <th>1</th>\n'
' '
'<td>foo</td>\n'
' '
'<td>something</td>\n'
' '
'<td>test@me.com</td>\n'
' '
'<td>True</td>\n'
' '
'<td>init</td>\n'
' '
'<td>hello</td>\n'
' </tr>\n'
' </tbody>\n'
'</table>\n'
'</div>',
'text/plain': ' '
'function_name '
'stage '
'id '
'is_success '
'message '
'response\n'
'0 '
'foo bar '
'test@me.com '
'True we did '
'something '
'hello\n'
'1 foo '
'something '
'test@me.com '
'True '
'init hello'},
'execution_count': 96,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'print("if explicit changes are made to the '
'config object they will accumulate after '
'function execution, this can be used to '
'pass values to sequentially executed '
'functions")\n'
'pd.DataFrame(res.to_json())'},
{'cell_type': 'code',
'execution_count': 14,
'id': '26a23722-f38b-4938-93a2-62db78b383f4',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'name': 'stdout',
'output_type': 'stream',
'text': 'function response returns '
'`FactoryResponse` object\n'
'\n'
'\n'},
{'data': {'text/html': '<div>\n'
'<style scoped>\n'
' .dataframe '
'tbody tr '
'th:only-of-type '
'{\n'
' '
'vertical-align: '
'middle;\n'
' }\n'
'\n'
' .dataframe '
'tbody tr th {\n'
' '
'vertical-align: '
'top;\n'
' }\n'
'\n'
' .dataframe '
'thead th {\n'
' '
'text-align: '
'right;\n'
' }\n'
'</style>\n'
'<table border="1" '
'class="dataframe">\n'
' <thead>\n'
' <tr '
'style="text-align: '
'right;">\n'
' <th></th>\n'
' '
'<th>function_name</th>\n'
' '
'<th>stage</th>\n'
' '
'<th>id</th>\n'
' '
'<th>is_success</th>\n'
' '
'<th>message</th>\n'
' '
'<th>response</th>\n'
' </tr>\n'
' </thead>\n'
' <tbody>\n'
' <tr>\n'
' <th>0</th>\n'
' '
'<td>foo</td>\n'
' '
'<td>bar</td>\n'
' '
'<td>test@me.com</td>\n'
' '
'<td>True</td>\n'
' '
'<td>init</td>\n'
' '
'<td>hello</td>\n'
' </tr>\n'
' <tr>\n'
' <th>1</th>\n'
' '
'<td>foo</td>\n'
' '
'<td>something</td>\n'
' '
'<td>test@me.com</td>\n'
' '
'<td>True</td>\n'
' '
'<td>init</td>\n'
' '
'<td>hello</td>\n'
' </tr>\n'
' </tbody>\n'
'</table>\n'
'</div>',
'text/plain': ' '
'function_name '
'stage '
'id is_success '
'message '
'response\n'
'0 '
'foo bar '
'test@me.com '
'True init '
'hello\n'
'1 foo '
'something '
'test@me.com '
'True init '
'hello'},
'execution_count': 14,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'print("function response returns '
'`FactoryResponse` object")\n'
'print("\\n")\n'
'pd.DataFrame(res.to_json())'},
{'cell_type': 'code',
'execution_count': 15,
'id': '805449e2-25d5-4182-8448-2f3b66f72937',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'name': 'stdout',
'output_type': 'stream',
'text': 'the logs are auto updated too '
'and will accumulate messages '
'from all factory_function '
'responses\n'},
{'data': {'text/html': '<div>\n'
'<style scoped>\n'
' .dataframe '
'tbody tr '
'th:only-of-type '
'{\n'
' '
'vertical-align: '
'middle;\n'
' }\n'
'\n'
' .dataframe '
'tbody tr th {\n'
' '
'vertical-align: '
'top;\n'
' }\n'
'\n'
' .dataframe '
'thead th {\n'
' '
'text-align: '
'right;\n'
' }\n'
'</style>\n'
'<table border="1" '
'class="dataframe">\n'
' <thead>\n'
' <tr '
'style="text-align: '
'right;">\n'
' <th></th>\n'
' '
'<th>execution</th>\n'
' '
'<th>function_name</th>\n'
' '
'<th>stage</th>\n'
' '
'<th>id</th>\n'
' '
'<th>is_success</th>\n'
' '
'<th>message</th>\n'
' '
'<th>response</th>\n'
' </tr>\n'
' </thead>\n'
' <tbody>\n'
' <tr>\n'
' <th>0</th>\n'
' <td>0</td>\n'
' '
'<td>foo</td>\n'
' '
'<td>bar</td>\n'
' '
'<td>test@me.com</td>\n'
' '
'<td>True</td>\n'
' '
'<td>init</td>\n'
' '
'<td>hello</td>\n'
' </tr>\n'
' <tr>\n'
' <th>1</th>\n'
' <td>0</td>\n'
' '
'<td>foo</td>\n'
' '
'<td>something</td>\n'
' '
'<td>test@me.com</td>\n'
' '
'<td>True</td>\n'
' '
'<td>init</td>\n'
' '
'<td>hello</td>\n'
' </tr>\n'
' </tbody>\n'
'</table>\n'
'</div>',
'text/plain': ' execution '
'function_name '
'stage '
'id is_success '
'message \\\n'
'0 '
'0 '
'foo bar '
'test@me.com '
'True init \n'
'1 '
'0 foo '
'something '
'test@me.com '
'True init \n'
'\n'
' response \n'
'0 hello \n'
'1 hello '},
'execution_count': 15,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'print("the logs are auto updated too and '
'will accumulate messages from all '
'factory_function responses")\n'
'"\\n"\n'
'pd.DataFrame(logs.to_json())'},
{'cell_type': 'code',
'execution_count': 16,
'id': 'a5ee98eb-f469-455d-aea9-ad822d79296c',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'config = AssemblyConfig(\n'
' display_name = f"Test User - updated '
'{dt.datetime.now()}", \n'
' email = "test_automate@sony.com",\n'
' role_id = 2097317660,\n'
' token_name = "token_factory",\n'
' auth = auth,\n'
' session = httpx.AsyncClient(),\n'
')'},
{'cell_type': 'code',
'execution_count': 17,
'id': '1dea0b86-3aa6-4b7f-b7d6-3746d4c27332',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'data': {'text/plain': "FactoryResponse(function_name='foo', "
"id='test_automate@sony.com', "
"messages=[FactoryMessage(stage='bar', "
"message='init', "
'is_success=True), '
"FactoryMessage(stage='something', "
"message='init', "
'is_success=True)], '
'is_success=True)'},
'execution_count': 17,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'from enum import Enum\n'
'from aenum import extend_enum\n'
'\n'
'class FactoryFunction_Enum(Enum):\n'
' test = foo\n'
'\n'
'await FactoryFunction_Enum.test(config = '
'config,logs = logs)'},
{'cell_type': 'code',
'execution_count': 85,
'id': 'bf554b19-0cae-443e-b74a-818027c76e5e',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'data': {'text/html': '<div>\n'
'<style scoped>\n'
' .dataframe '
'tbody tr '
'th:only-of-type '
'{\n'
' '
'vertical-align: '
'middle;\n'
' }\n'
'\n'
' .dataframe '
'tbody tr th {\n'
' '
'vertical-align: '
'top;\n'
' }\n'
'\n'
' .dataframe '
'thead th {\n'
' '
'text-align: '
'right;\n'
' }\n'
'</style>\n'
'<table border="1" '
'class="dataframe">\n'
' <thead>\n'
' <tr '
'style="text-align: '
'right;">\n'
' <th></th>\n'
' '
'<th>function_name</th>\n'
' '
'<th>stage</th>\n'
' '
'<th>id</th>\n'
' '
'<th>is_success</th>\n'
' '
'<th>message</th>\n'
' '
'<th>response</th>\n'
' </tr>\n'
' </thead>\n'
' <tbody>\n'
' <tr>\n'
' <th>0</th>\n'
' '
'<td>generate_password_fn</td>\n'
' '
'<td>generate_password</td>\n'
' '
'<td>test_automate@sony.com</td>\n'
' '
'<td>True</td>\n'
' '
'<td>password_generated</td>\n'
' '
'<td>fool_apply_conch_exert_2024!@#</td>\n'
' </tr>\n'
' </tbody>\n'
'</table>\n'
'</div>',
'text/plain': ' '
'function_name '
'stage '
'id \\\n'
'0 '
'generate_password_fn '
'generate_password '
'test_automate@sony.com \n'
'\n'
' '
'is_success '
'message '
'response \n'
'0 True '
'password_generated '
'fool_apply_conch_exert_2024!@# '},
'execution_count': 85,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'from xkcdpass import xkcd_password as xp\n'
'import string\n'
'import secrets\n'
'import datetime as dt\n'
'\n'
"@factory_function(id='email')\n"
'async def generate_password_fn(config : '
'AssemblyConfig,\n'
' logs : '
'FactoryLogs,\n'
' res : '
'FactoryResponse,\n'
' digit_len = '
'5,\n'
' '
'use_random_digit=False,\n'
' debug_api: '
'bool = False):\n'
' \n'
' # INIT message\n'
' message = FactoryMessage(stage = '
"'generate_password')\n"
' res.add_message(message)\n'
' \n'
' # STAGE1 = generate_password\n'
' if use_random_digit:\n'
' alphabet = string.punctuation + '
'string.digits\n'
' password = '
"''.join(secrets.choice(alphabet) for i in "
'range(digit_len))\n'
' \n'
' default = '
"dt.date.today().strftime('%Y')+'!@#'\n"
' \n'
' wordfile = xp.locate_wordfile()\n'
' mywords = '
'xp.generate_wordlist(wordfile=wordfile, '
'min_length=3, max_length=5)\n'
'\n'
' # create a password with the acrostic '
'"face"\n'
' \n'
' password = '
'xp.generate_xkcdpassword(mywords, '
'delimiter = \'_\', acrostic="face", case = '
'\'lower\') + "_" + default\n'
' \n'
' # UPDATE message\n'
' message.message = '
"'password_generated'\n"
' message.is_success = True\n'
' \n'
' # UPDATE config\n'
' config.password = password\n'
' \n'
' # UPDATE response\n'
' res.response = password\n'
' \n'
' return res\n'
'\n'
'logs = FactoryLogs()\n'
'\n'
'config = AssemblyConfig(\n'
' auth = auth,\n'
" email = 'test_automate@sony.com'\n"
')\n'
'\n'
'pd.DataFrame((await '
'generate_password_fn(config = config, logs '
'= logs)).to_json())'},
{'cell_type': 'code',
'execution_count': 19,
'id': '1117ca48-7327-42d3-9caa-6ace0eafe1b9',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'data': {'text/html': '<div>\n'
'<style scoped>\n'
' .dataframe '
'tbody tr '
'th:only-of-type '
'{\n'
' '
'vertical-align: '
'middle;\n'
' }\n'
'\n'
' .dataframe '
'tbody tr th {\n'
' '
'vertical-align: '
'top;\n'
' }\n'
'\n'
' .dataframe '
'thead th {\n'
' '
'text-align: '
'right;\n'
' }\n'
'</style>\n'
'<table border="1" '
'class="dataframe">\n'
' <thead>\n'
' <tr '
'style="text-align: '
'right;">\n'
' <th></th>\n'
' '
'<th>function_name</th>\n'
' '
'<th>stage</th>\n'
' '
'<th>id</th>\n'
' '
'<th>is_success</th>\n'
' '
'<th>message</th>\n'
' '
'<th>response</th>\n'
' </tr>\n'
' </thead>\n'
' <tbody>\n'
' <tr>\n'
' <th>0</th>\n'
' '
'<td>upsert_user_fn</td>\n'
' '
'<td>upsert_user</td>\n'
' '
'<td>test_automate@sony.com</td>\n'
' '
'<td>True</td>\n'
' <td>user '
'1853825438 '
'upserted</td>\n'
' '
"<td>DomoUser(id='1853825438', "
"display_name='Test "
'U...</td>\n'
' </tr>\n'
' </tbody>\n'
'</table>\n'
'</div>',
'text/plain': ' '
'function_name '
'stage '
'id is_success '
'\\\n'
'0 '
'upsert_user_fn '
'upsert_user '
'test_automate@sony.com '
'True \n'
'\n'
' '
'message '
'response \n'
'0 user '
'1853825438 '
'upserted '
"DomoUser(id='1853825438', "
"display_name='Test "
'U... '},
'execution_count': 19,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'import domolibrary.classes.DomoUser as '
'dmdu\n'
'\n'
"@factory_function(id = 'email')\n"
'async def upsert_user_fn(config,\n'
' logs: '
'FactoryLogs,\n'
' res : '
'FactoryResponse,\n'
' debug_api: bool = '
'False ):\n'
' #INIT message\n'
' message = FactoryMessage(stage = '
"'upsert_user')\n"
' res.add_message(message)\n'
' \n'
" config.test_required_attr( ['email', "
"'display_name', 'role_id'], "
'upsert_user_fn.__name__)\n'
' \n'
' # STAGE1 = upsert_user\n'
' domo_user = await '
'dmdu.DomoUsers.upsert_user(\n'
' auth = config.auth,\n'
' email_address = config.email,\n'
' display_name = '
'config.display_name,\n'
' session = config.session,\n'
' role_id = config.role_id,\n'
' debug_api = debug_api,\n'
' )\n'
' \n'
' # UPDATE message\n'
' message.message = f"user '
'{domo_user.id} upserted"\n'
' message.is_success = True\n'
' \n'
' # UPDATE config\n'
' config.user_id = domo_user.id\n'
' \n'
' # UPDATE response\n'
' res.response = domo_user\n'
' \n'
' return res\n'
'\n'
'logs = FactoryLogs()\n'
'res = await upsert_user_fn(config = '
'config, logs = logs, debug_api = False)\n'
'pd.DataFrame(res.to_json())\n'},
{'cell_type': 'code',
'execution_count': 20,
'id': 'e560dac3-2997-48dd-96ed-1c77c2dc879c',
'metadata': {'trusted': True},
'outputs': [{'data': {'text/html': '<div>\n'
'<style scoped>\n'
' .dataframe '
'tbody tr '
'th:only-of-type '
'{\n'
' '
'vertical-align: '
'middle;\n'
' }\n'
'\n'
' .dataframe '
'tbody tr th {\n'
' '
'vertical-align: '
'top;\n'
' }\n'
'\n'
' .dataframe '
'thead th {\n'
' '
'text-align: '
'right;\n'
' }\n'
'</style>\n'
'<table border="1" '
'class="dataframe">\n'
' <thead>\n'
' <tr '
'style="text-align: '
'right;">\n'
' <th></th>\n'
' '
'<th>execution</th>\n'
' '
'<th>function_name</th>\n'
' '
'<th>stage</th>\n'
' '
'<th>id</th>\n'
' '
'<th>is_success</th>\n'
' '
'<th>message</th>\n'
' '
'<th>response</th>\n'
' </tr>\n'
' </thead>\n'
' <tbody>\n'
' <tr>\n'
' <th>0</th>\n'
' <td>0</td>\n'
' '
'<td>upsert_user_fn</td>\n'
' '
'<td>upsert_user</td>\n'
' '
'<td>test_automate@sony.com</td>\n'
' '
'<td>True</td>\n'
' <td>user '
'1853825438 '
'upserted</td>\n'
' '
"<td>DomoUser(id='1853825438', "
"display_name='Test "
'U...</td>\n'
' </tr>\n'
' <tr>\n'
' <th>1</th>\n'
' <td>1</td>\n'
' '
'<td>generate_password_fn</td>\n'
' '
'<td>generate_password</td>\n'
' '
'<td>test_automate@sony.com</td>\n'
' '
'<td>True</td>\n'
' '
'<td>password_generated</td>\n'
' '
'<td>frame_anger_cheek_easel_2024!@#</td>\n'
' </tr>\n'
' <tr>\n'
' <th>2</th>\n'
' <td>2</td>\n'
' '
'<td>user_reset_password_fn</td>\n'
' '
'<td>get_user_by_id</td>\n'
' '
'<td>test_automate@sony.com</td>\n'
' '
'<td>True</td>\n'
' <td>user '
'1853825438 '
'retrieved</td>\n'
' '
"<td>DomoUser(id='1853825438', "
"display_name='Test "
'U...</td>\n'
' </tr>\n'
' <tr>\n'
' <th>3</th>\n'
' <td>2</td>\n'
' '
'<td>user_reset_password_fn</td>\n'
' '
'<td>reset_password</td>\n'
' '
'<td>test_automate@sony.com</td>\n'
' '
'<td>True</td>\n'
' '
'<td>password '
'reset to '
'frame_anger_cheek_easel_2024!@#</td>\n'
' '
"<td>DomoUser(id='1853825438', "
"display_name='Test "
'U...</td>\n'
' </tr>\n'
' </tbody>\n'
'</table>\n'
'</div>',
'text/plain': ' '
'execution '
'function_name '
'stage \\\n'
'0 '
'0 '
'upsert_user_fn '
'upsert_user \n'
'1 1 '
'generate_password_fn '
'generate_password \n'
'2 2 '
'user_reset_password_fn '
'get_user_by_id \n'
'3 2 '
'user_reset_password_fn '
'reset_password \n'
'\n'
' '
'id is_success '
'\\\n'
'0 '
'test_automate@sony.com '
'True \n'
'1 '
'test_automate@sony.com '
'True \n'
'2 '
'test_automate@sony.com '
'True \n'
'3 '
'test_automate@sony.com '
'True \n'
'\n'
' '
'message \\\n'
'0 '
'user 1853825438 '
'upserted \n'
'1 '
'password_generated \n'
'2 '
'user 1853825438 '
'retrieved \n'
'3 password '
'reset to '
'frame_anger_cheek_easel_2024!@# \n'
'\n'
' '
'response \n'
'0 '
"DomoUser(id='1853825438', "
"display_name='Test "
'U... \n'
'1 '
'frame_anger_cheek_easel_2024!@# \n'
'2 '
"DomoUser(id='1853825438', "
"display_name='Test "
'U... \n'
'3 '
"DomoUser(id='1853825438', "
"display_name='Test "
'U... '},
'execution_count': 20,
'metadata': {},
'output_type': 'execute_result'}],
'source': "@factory_function(id='email')\n"
'async def user_reset_password_fn(config, \n'
' res : '
'FactoryResponse,\n'
' logs : '
'FactoryLogs,\n'
' '
'debug_api: bool = False):\n'
' \n'
" config.test_required_attr( ['user_id', "
"'password'], "
'user_reset_password_fn.__name__)\n'
' \n'
' \n'
' message = FactoryMessage(stage = '
"'get_user_by_id')\n"
' res.add_message(message)\n'
' \n'
' domo_user = await '
'dmdu.DomoUser.get_by_id(user_id = '
'config.user_id, \n'
' '
'auth= config.auth, \n'
' '
'session = config.session, debug_api = '
'debug_api)\n'
' \n'
" message.message = f'user "
"{domo_user.id} retrieved'\n"
' message.is_success = True\n'
' \n'
' \n'
' message = FactoryMessage(stage = '
"'reset_password')\n"
' res.add_message(message)\n'
' await '
'domo_user.reset_password(new_password = '
'config.password, \n'
' '
'debug_api = debug_api,\n'
' # '
'session = session\n'
' )\n'
" message.message = f'password reset to "
"{config.password}'\n"
' message.is_success = True\n'
' \n'
' res.response = domo_user\n'
' \n'
' return res\n'
'\n'
'factory_fn_ls = [upsert_user_fn, '
'generate_password_fn, '
'user_reset_password_fn ]\n'
'config.logs.logs = []\n'
'\n'
'await '
'config.run(factory_fn_ls=factory_fn_ls, '
'debug_api = False)\n'
'\n'
'pd.DataFrame(config.logs.to_json())\n'},
{'cell_type': 'code',
'execution_count': 1,
'id': '57f65aeb-37f0-4cba-8d81-abea23aaadb9',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'ename': 'NameError',
'evalue': "name 'factory_function' is "
'not defined',
'output_type': 'error',
'traceback': ['\x1b[0;31m---------------------------------------------------------------------------\x1b[0m',
'\x1b[0;31mNameError\x1b[0m '
'Traceback (most recent '
'call last)',
'Cell \x1b[0;32mIn[1], '
'line 5\x1b[0m\n'
'\x1b[1;32m 2\x1b[0m '
'\x1b[38;5;28;01mimport\x1b[39;00m '
'\x1b[38;5;21;01mdomolibrary\x1b[39;00m\x1b[38;5;21;01m.\x1b[39;00m\x1b[38;5;21;01mclasses\x1b[39;00m\x1b[38;5;21;01m.\x1b[39;00m\x1b[38;5;21;01mDomoAccessToken\x1b[39;00m '
'\x1b[38;5;28;01mas\x1b[39;00m '
'\x1b[38;5;21;01mdmat\x1b[39;00m\n'
'\x1b[1;32m 3\x1b[0m '
'\x1b[38;5;28;01mimport\x1b[39;00m '
'\x1b[38;5;21;01mdomolibrary\x1b[39;00m\x1b[38;5;21;01m.\x1b[39;00m\x1b[38;5;21;01mclasses\x1b[39;00m\x1b[38;5;21;01m.\x1b[39;00m\x1b[38;5;21;01mDomoUser\x1b[39;00m '
'\x1b[38;5;28;01mas\x1b[39;00m '
'\x1b[38;5;21;01mdmdu\x1b[39;00m\n'
'\x1b[0;32m----> 5\x1b[0m '
'\x1b[38;5;129m@factory_function\x1b[39m(\x1b[38;5;28mid\x1b[39m '
'\x1b[38;5;241m=\x1b[39m '
"\x1b[38;5;124m'\x1b[39m\x1b[38;5;124memail\x1b[39m\x1b[38;5;124m'\x1b[39m)\n"
'\x1b[1;32m 6\x1b[0m '
'\x1b[38;5;28;01masync\x1b[39;00m '
'\x1b[38;5;28;01mdef\x1b[39;00m '
'\x1b[38;5;21mregenerate_access_token_fn\x1b[39m(config,\n'
'\x1b[1;32m '
'7\x1b[0m '
'logs : FactoryLogs,\n'
'\x1b[1;32m '
'8\x1b[0m '
'res : FactoryResponse,\n'
'\x1b[1;32m '
'9\x1b[0m '
'duration_in_days '
'\x1b[38;5;241m=\x1b[39m '
'\x1b[38;5;241m90\x1b[39m,\n'
'\x1b[1;32m '
'10\x1b[0m '
'debug_api: '
'\x1b[38;5;28mbool\x1b[39m '
'\x1b[38;5;241m=\x1b[39m '
'\x1b[38;5;28;01mFalse\x1b[39;00m):\n'
'\x1b[1;32m '
'12\x1b[0m '
'config\x1b[38;5;241m.\x1b[39mtest_required_attr( '
"[\x1b[38;5;124m'\x1b[39m\x1b[38;5;124muser_id\x1b[39m\x1b[38;5;124m'\x1b[39m, "
"\x1b[38;5;124m'\x1b[39m\x1b[38;5;124mtoken_name\x1b[39m\x1b[38;5;124m'\x1b[39m], "
'regenerate_access_token_fn\x1b[38;5;241m.\x1b[39m\x1b[38;5;18m__name__\x1b[39m)\n'
'\x1b[1;32m '
'15\x1b[0m message '
'\x1b[38;5;241m=\x1b[39m '
'FactoryMessage(stage '
'\x1b[38;5;241m=\x1b[39m '
"\x1b[38;5;124m'\x1b[39m\x1b[38;5;124mget_by_id\x1b[39m\x1b[38;5;124m'\x1b[39m)\n",
'\x1b[0;31mNameError\x1b[0m: '
"name 'factory_function' "
'is not defined']}],
'source': 'import '
'domolibrary.classes.DomoInstanceConfig as '
'dmic\n'
'import domolibrary.classes.DomoAccessToken '
'as dmat\n'
'import domolibrary.classes.DomoUser as '
'dmdu\n'
'\n'
"@factory_function(id = 'email')\n"
'async def '
'regenerate_access_token_fn(config,\n'
' logs '
': FactoryLogs,\n'
' res : '
'FactoryResponse,\n'
' '
'duration_in_days = 90,\n'
' '
'debug_api: bool = False):\n'
' \n'
" config.test_required_attr( ['user_id', "
"'token_name'], "
'regenerate_access_token_fn.__name__)\n'
' \n'
' \n'
' message = FactoryMessage(stage = '
"'get_by_id')\n"
' res.add_message(message)\n'
' domo_user = await '
'dmdu.DomoUser.get_by_id(user_id = '
'config.user_id, auth=config.auth, session '
'= config.session)\n'
" message.message = f'retrieve "
"{domo_user.id}'\n"
' message.is_success = True\n'
' \n'
" message = FactoryMessage('get "
"access_tokens')\n"
' res.add_message(message)\n'
' \n'
' domo_config = '
'dmic.DomoInstanceConfig(auth = auth)\n'
' access_tokens = await '
'domo_config.get_access_tokens()\n'
" message.message = 'all access_tokens "
"retrieved'\n"
' message.is_success = True\n'
' \n'
" message = FactoryMessage('regenerate "
"access_token')\n"
' res.add_message(message)\n'
' \n'
' access_token = next(( token for token '
'in access_tokens if token.owner == '
'domo_user and token.name == '
'config.token_name ), None)\n'
' if not access_token:\n'
' access_token = await '
'dmat.DomoAccessToken.generate(\n'
' duration_in_days = '
'duration_in_days,\n'
' token_name = '
'config.token_name,\n'
' auth = auth,\n'
' owner = domo_user, # '
'DomoUser\n'
' debug_api = debug_api,\n'
' session = config.session,\n'
' )\n'
' \n'
' access_token = await '
'access_token.regenerate()\n'
" message.message = f'regenerated token "
"- {access_token.token}'\n"
' message.is_success = True\n'
' \n'
' config.access_token = '
'access_token.token\n'
' res.response = access_token\n'
' \n'
' return res\n'
'\n'
'factory_fn_ls = [upsert_user_fn, '
'regenerate_access_token_fn ]\n'
'config.logs.logs = []\n'
'config.token_name = "token_DEMO"\n'
'await '
'config.run(factory_fn_ls=factory_fn_ls, '
'debug_api = False)\n'
'\n'
'pd.DataFrame(config.logs.to_json())'},
{'cell_type': 'markdown',
'id': '93bdc6e5-aa58-43eb-aebe-cf5f9883d627',
'metadata': {'tags': []},
'source': '# SAMPLE IMPLEMENTATION'},
{'cell_type': 'code',
'execution_count': 89,
'id': '68a934ef-7545-40c6-8322-21941a2f66be',
'metadata': {'trusted': True},
'outputs': [{'data': {'text/html': '<div>\n'
'<style scoped>\n'
' .dataframe '
'tbody tr '
'th:only-of-type '
'{\n'
' '
'vertical-align: '
'middle;\n'
' }\n'
'\n'
' .dataframe '
'tbody tr th {\n'
' '
'vertical-align: '
'top;\n'
' }\n'
'\n'
' .dataframe '
'thead th {\n'
' '
'text-align: '
'right;\n'
' }\n'
'</style>\n'
'<table border="1" '
'class="dataframe">\n'
' <thead>\n'
' <tr '
'style="text-align: '
'right;">\n'
' <th></th>\n'
' '
'<th>execution</th>\n'
' '
'<th>function_name</th>\n'
' '
'<th>stage</th>\n'
' '
'<th>id</th>\n'
' '
'<th>is_success</th>\n'
' '
'<th>message</th>\n'
' '
'<th>response</th>\n'
' </tr>\n'
' </thead>\n'
' <tbody>\n'
' <tr>\n'
' <th>0</th>\n'
' <td>0</td>\n'
' '
'<td>upsert_user_fn</td>\n'
' '
'<td>upsert_user</td>\n'
' '
'<td>test_automate@sony.com</td>\n'
' '
'<td>True</td>\n'
' <td>user '
'1853825438 '
'upserted</td>\n'
' '
"<td>DomoUser(id='1853825438', "
"display_name='Test "
'U...</td>\n'
' </tr>\n'
' <tr>\n'
' <th>1</th>\n'
' <td>1</td>\n'
' '
'<td>generate_password_fn</td>\n'
' '
'<td>generate_password</td>\n'
' '
'<td>test_automate@sony.com</td>\n'
' '
'<td>True</td>\n'
' '
'<td>password_generated</td>\n'
' '
'<td>foam_affix_cider_envy_2024!@#</td>\n'
' </tr>\n'
' <tr>\n'
' <th>2</th>\n'
' <td>2</td>\n'
' '
'<td>user_reset_password_fn</td>\n'
' '
'<td>get_user_by_id</td>\n'
' '
'<td>test_automate@sony.com</td>\n'
' '
'<td>True</td>\n'
' <td>user '
'1853825438 '
'retrieved</td>\n'
' '
"<td>DomoUser(id='1853825438', "
"display_name='Test "
'U...</td>\n'
' </tr>\n'
' <tr>\n'
' <th>3</th>\n'
' <td>2</td>\n'
' '
'<td>user_reset_password_fn</td>\n'
' '
'<td>reset_password</td>\n'
' '
'<td>test_automate@sony.com</td>\n'
' '
'<td>True</td>\n'
' '
'<td>password '
'reset to '
'foam_affix_cider_envy_2024!@#</td>\n'
' '
"<td>DomoUser(id='1853825438', "
"display_name='Test "
'U...</td>\n'
' </tr>\n'
' <tr>\n'
' <th>4</th>\n'
' <td>3</td>\n'
' '
'<td>regenerate_access_token_fn</td>\n'
' '
'<td>get_by_id</td>\n'
' '
'<td>test_automate@sony.com</td>\n'
' '
'<td>True</td>\n'
' '
'<td>retrieve '
'1853825438</td>\n'
' '
'<td>DomoAccessToken(id=186897, '
"name='token_DEMO', "
'...</td>\n'
' </tr>\n'
' <tr>\n'
' <th>5</th>\n'
' <td>3</td>\n'
' '
'<td>regenerate_access_token_fn</td>\n'
' <td>get '
'access_tokens</td>\n'
' '
'<td>test_automate@sony.com</td>\n'
' '
'<td>True</td>\n'
' <td>all '
'access_tokens '
'retrieved</td>\n'
' '
'<td>DomoAccessToken(id=186897, '
"name='token_DEMO', "
'...</td>\n'
' </tr>\n'
' <tr>\n'
' <th>6</th>\n'
' <td>3</td>\n'
' '
'<td>regenerate_access_token_fn</td>\n'
' '
'<td>regenerate '
'access_token</td>\n'
' '
'<td>test_automate@sony.com</td>\n'
' '
'<td>True</td>\n'
' '
'<td>regenerated '
'token - '
'82dbf02cf5cb181d252d42e16a...</td>\n'
' '
'<td>DomoAccessToken(id=186897, '
"name='token_DEMO', "
'...</td>\n'
' </tr>\n'
' <tr>\n'
' <th>7</th>\n'
' <td>4</td>\n'
' '
'<td>upsert_user_fn</td>\n'
' '
'<td>upsert_user</td>\n'
' '
'<td>test_automate2@sony.com</td>\n'
' '
'<td>True</td>\n'
' <td>user '
'1228812242 '
'upserted</td>\n'
' '
"<td>DomoUser(id='1228812242', "
"display_name='Test "
'U...</td>\n'
' </tr>\n'
' <tr>\n'
' <th>8</th>\n'
' <td>5</td>\n'
' '
'<td>generate_password_fn</td>\n'
' '
'<td>generate_password</td>\n'
' '
'<td>test_automate2@sony.com</td>\n'
' '
'<td>True</td>\n'
' '
'<td>password_generated</td>\n'
' '
'<td>fling_aqua_curvy_elite_2024!@#</td>\n'
' </tr>\n'
' <tr>\n'
' <th>9</th>\n'
' <td>6</td>\n'
' '
'<td>user_reset_password_fn</td>\n'
' '
'<td>get_user_by_id</td>\n'
' '
'<td>test_automate2@sony.com</td>\n'
' '
'<td>True</td>\n'
' <td>user '
'1228812242 '
'retrieved</td>\n'
' '
"<td>DomoUser(id='1228812242', "
"display_name='Test "
'U...</td>\n'
' </tr>\n'
' <tr>\n'
' '
'<th>10</th>\n'
' <td>6</td>\n'
' '
'<td>user_reset_password_fn</td>\n'
' '
'<td>reset_password</td>\n'
' '
'<td>test_automate2@sony.com</td>\n'
' '
'<td>True</td>\n'
' '
'<td>password '
'reset to '
'fling_aqua_curvy_elite_2024!@#</td>\n'
' '
"<td>DomoUser(id='1228812242', "
"display_name='Test "
'U...</td>\n'
' </tr>\n'
' <tr>\n'
' '
'<th>11</th>\n'
' <td>7</td>\n'
' '
'<td>regenerate_access_token_fn</td>\n'
' '
'<td>get_by_id</td>\n'
' '
'<td>test_automate2@sony.com</td>\n'
' '
'<td>True</td>\n'
' '
'<td>retrieve '
'1228812242</td>\n'
' '
'<td>DomoAccessToken(id=186898, '
"name='token_DEMO', "
'...</td>\n'
' </tr>\n'
' <tr>\n'
' '
'<th>12</th>\n'
' <td>7</td>\n'
' '
'<td>regenerate_access_token_fn</td>\n'
' <td>get '
'access_tokens</td>\n'
' '
'<td>test_automate2@sony.com</td>\n'
' '
'<td>True</td>\n'
' <td>all '
'access_tokens '
'retrieved</td>\n'
' '
'<td>DomoAccessToken(id=186898, '
"name='token_DEMO', "
'...</td>\n'
' </tr>\n'
' <tr>\n'
' '
'<th>13</th>\n'
' <td>7</td>\n'
' '
'<td>regenerate_access_token_fn</td>\n'
' '
'<td>regenerate '
'access_token</td>\n'
' '
'<td>test_automate2@sony.com</td>\n'
' '
'<td>True</td>\n'
' '
'<td>regenerated '
'token - '
'9b81d27abb8c8bc87286a1253d...</td>\n'
' '
'<td>DomoAccessToken(id=186898, '
"name='token_DEMO', "
'...</td>\n'
' </tr>\n'
' </tbody>\n'
'</table>\n'
'</div>',
'text/plain': ' '
'execution '
'function_name '
'stage \\\n'
'0 '
'0 '
'upsert_user_fn '
'upsert_user \n'
'1 '
'1 '
'generate_password_fn '
'generate_password \n'
'2 '
'2 '
'user_reset_password_fn '
'get_user_by_id \n'
'3 '
'2 '
'user_reset_password_fn '
'reset_password \n'
'4 3 '
'regenerate_access_token_fn '
'get_by_id \n'
'5 3 '
'regenerate_access_token_fn '
'get '
'access_tokens \n'
'6 3 '
'regenerate_access_token_fn '
'regenerate '
'access_token \n'
'7 '
'4 '
'upsert_user_fn '
'upsert_user \n'
'8 '
'5 '
'generate_password_fn '
'generate_password \n'
'9 '
'6 '
'user_reset_password_fn '
'get_user_by_id \n'
'10 '
'6 '
'user_reset_password_fn '
'reset_password \n'
'11 7 '
'regenerate_access_token_fn '
'get_by_id \n'
'12 7 '
'regenerate_access_token_fn '
'get '
'access_tokens \n'
'13 7 '
'regenerate_access_token_fn '
'regenerate '
'access_token \n'
'\n'
' '
'id is_success '
'\\\n'
'0 '
'test_automate@sony.com '
'True \n'
'1 '
'test_automate@sony.com '
'True \n'
'2 '
'test_automate@sony.com '
'True \n'
'3 '
'test_automate@sony.com '
'True \n'
'4 '
'test_automate@sony.com '
'True \n'
'5 '
'test_automate@sony.com '
'True \n'
'6 '
'test_automate@sony.com '
'True \n'
'7 '
'test_automate2@sony.com '
'True \n'
'8 '
'test_automate2@sony.com '
'True \n'
'9 '
'test_automate2@sony.com '
'True \n'
'10 '
'test_automate2@sony.com '
'True \n'
'11 '
'test_automate2@sony.com '
'True \n'
'12 '
'test_automate2@sony.com '
'True \n'
'13 '
'test_automate2@sony.com '
'True \n'
'\n'
' '
'message \\\n'
'0 '
'user 1853825438 '
'upserted \n'
'1 '
'password_generated \n'
'2 '
'user 1853825438 '
'retrieved \n'
'3 password '
'reset to '
'foam_affix_cider_envy_2024!@# \n'
'4 '
'retrieve '
'1853825438 \n'
'5 '
'all '
'access_tokens '
'retrieved \n'
'6 regenerated '
'token - '
'82dbf02cf5cb181d252d42e16a... \n'
'7 '
'user 1228812242 '
'upserted \n'
'8 '
'password_generated \n'
'9 '
'user 1228812242 '
'retrieved \n'
'10 password '
'reset to '
'fling_aqua_curvy_elite_2024!@# \n'
'11 '
'retrieve '
'1228812242 \n'
'12 '
'all '
'access_tokens '
'retrieved \n'
'13 regenerated '
'token - '
'9b81d27abb8c8bc87286a1253d... \n'
'\n'
' '
'response \n'
'0 '
"DomoUser(id='1853825438', "
"display_name='Test "
'U... \n'
'1 '
'foam_affix_cider_envy_2024!@# \n'
'2 '
"DomoUser(id='1853825438', "
"display_name='Test "
'U... \n'
'3 '
"DomoUser(id='1853825438', "
"display_name='Test "
'U... \n'
'4 '
'DomoAccessToken(id=186897, '
"name='token_DEMO', "
'... \n'
'5 '
'DomoAccessToken(id=186897, '
"name='token_DEMO', "
'... \n'
'6 '
'DomoAccessToken(id=186897, '
"name='token_DEMO', "
'... \n'
'7 '
"DomoUser(id='1228812242', "
"display_name='Test "
'U... \n'
'8 '
'fling_aqua_curvy_elite_2024!@# \n'
'9 '
"DomoUser(id='1228812242', "
"display_name='Test "
'U... \n'
'10 '
"DomoUser(id='1228812242', "
"display_name='Test "
'U... \n'
'11 '
'DomoAccessToken(id=186898, '
"name='token_DEMO', "
'... \n'
'12 '
'DomoAccessToken(id=186898, '
"name='token_DEMO', "
'... \n'
'13 '
'DomoAccessToken(id=186898, '
"name='token_DEMO', "
'... '},
'execution_count': 89,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'users_to_create= [\n'
' { \'display_name\': f"Test User 1 - '
'updated {dt.datetime.now()}", \n'
" 'email' : "
'"test_automate@sony.com",\n'
" 'role_id': 2097317660\n"
' },\n'
' { \'display_name\': f"Test User 2 - '
'updated {dt.datetime.now()}", \n'
" 'email' : "
'"test_automate2@sony.com",\n'
" 'role_id': 2097317660}\n"
']\n'
'\n'
'logs = FactoryLogs()\n'
'\n'
'factory_fn_ls = [\n'
' upsert_user_fn, \n'
' generate_password_fn,\n'
' user_reset_password_fn,\n'
' '
'regenerate_access_token_fn \n'
' ]\n'
'\n'
'for user in users_to_create:\n'
' config = AssemblyConfig(\n'
' **user,\n'
' token_name = "token_DEMO",\n'
' auth = auth,\n'
' session = httpx.AsyncClient(),\n'
' factory_fn_ls = factory_fn_ls,\n'
' logs = logs\n'
' )\n'
' await config.run()\n'
'\n'
'pd.DataFrame(logs.to_json())'},
{'cell_type': 'code',
'execution_count': None,
'id': 'bc7a0442-4c96-4873-951e-9c8456ae9549',
'metadata': {'trusted': True},
'outputs': [],
'source': ''},
{'cell_type': 'code',
'execution_count': None,
'id': '9a8021f5-65bb-417e-bf83-d2875387c730',
'metadata': {'trusted': True},
'outputs': [],
'source': '# import domolibrary.classes.DomoRole as '
'dmr\n'
'\n'
'# async def sync_roles(auth : '
'dmda.DomoAuth,):\n'
'# domo_role = '
'dmr.Domo_Roles.upsert_role(\n'
'# auth = auth,\n'
'# name: str,\n'
'# description: str = None,\n'
'# grant_ls: [dmg.DomoGrant] = '
'None,\n'
'# debug_api: bool = False,\n'
'# debug_prn: bool = False,\n'
'# session: httpx.AsyncClient = '
'None,'},
{'cell_type': 'markdown',
'id': '6971d5a6-ddf3-4a68-b099-ebdc2124105d',
'metadata': {},
'source': '# OTHER STUFF'},
{'cell_type': 'code',
'execution_count': None,
'id': 'd3bb7ca0-bbcf-4954-aac6-f97006e9cb9e',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'import domolibrary.classes.DomoUser as '
'dmdu\n'
'\n'
'import httpx\n'
'\n'
'config_ds = {"display_name": "Test User", '
'"email" : "test_automate@sony.com"}\n'
'\n'
'@pr.process_function\n'
'async def sync_user(display_name,\n'
' email,\n'
' auth : dmda.DomoAuth,\n'
' logs,\n'
' process: '
'pr.ProcessResponse = None,\n'
' domo_role = None,\n'
' password = None,\n'
' debug_api: bool = '
'False,\n'
' session : '
'httpx.AsyncClient = None) -> '
'pr.ProcessResponse:\n'
' \n'
' #STAGE1 - DEFINE ROLE\n'
' message = pr.ProcessMessage(\n'
' stage_num = 1,\n'
" stage = 'define role',\n"
' message = f"supplied role: '
'{domo_role.id} - {domo_role.name}" if '
"domo_role else 'init')\n"
' \n'
' process.add_message(message)\n'
' \n'
' if not domo_role:\n'
' domo_role = await '
'DomoRoles.get_default_role(auth = '
'auth,debug_api = debug_api, session = '
'session)\n'
' message.message = f"default role: '
'{domo_role.id} - {domo_role.name}"\n'
' \n'
' message.is_success = True\n'
'\n'
' # STAGE2 - UPSERT USER\n'
' message = pr.ProcessMessage(\n'
' stage_num = 2,\n'
" stage = 'upsert user')\n"
' process.add_message(message)\n'
' \n'
' domo_user = None\n'
' try:\n'
' domo_user = await '
'dmdu.DomoUsers.upsert_user(\n'
' auth = auth,\n'
' email_address = email,\n'
' display_name = display_name,\n'
' session = session,\n'
' role_id = domo_role.id,\n'
' )\n'
' \n'
' message.is_success = True\n'
' message.message = f"upsert user '
'{domo_user.id}"\n'
' \n'
' except Exception as e:\n'
' message.message = e\n'
' message.is_success = False\n'
' process.is_success = False\n'
' return process\n'
'\n'
' process.response = domo_user\n'
' process.is_success = True\n'
' \n'
' # STAGE3 - OPTIONAL - RESET PASSWORD\n'
' message = pr.ProcessMessage(\n'
' stage_num = 3,\n'
" stage = 'reset_password'\n"
' )\n'
' process.add_message(message)\n'
' \n'
' if not password:\n'
' message.message = "set password '
'not requested"\n'
' message.is_success = True\n'
' return process\n'
' \n'
' domo_user.password = password\n'
' \n'
' try:\n'
' await '
'domo_user.reset_password(new_password = '
'password, \n'
' '
'debug_api = debug_api,\n'
' # '
'session = session\n'
' )\n'
' message.message= f"set password '
'{password}"\n'
' message.is_success = True\n'
' \n'
' except Exception as e:\n'
' message.message = e\n'
' message.is_success = False\n'
' process.is_success = False\n'
' \n'
' return process'},
{'cell_type': 'code',
'execution_count': None,
'id': 'cfc84694-a959-46e5-b28b-979488e0bbec',
'metadata': {'trusted': True},
'outputs': [],
'source': ''},
{'cell_type': 'markdown',
'id': '172b24de-d128-4dae-b442-551e36276cec',
'metadata': {},
'source': '# OTHER STUFF'},
{'cell_type': 'code',
'execution_count': None,
'id': 'a6c0b8d7-4506-44ca-a6b3-f06f665e4641',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'import pandas as pd \n'
'\n'
'logs = pr.ProcessLogs()\n'
'\n'
'res = await sync_user(display_name = '
"config_ds['display_name'],\n"
' email = '
"config_ds['email'],\n"
' auth = auth,\n'
' session = '
'httpx.AsyncClient(),\n'
' debug_api = None,\n'
' logs = logs,\n'
' )\n'
'\n'
'pd.DataFrame(res.to_json())'},
{'cell_type': 'code',
'execution_count': None,
'id': 'ae8b1828-bad6-4551-91ad-c202fea44b2d',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': '@pr.process_function\n'
'async def process_user(display_name, \n'
' email,\n'
' auth : '
'dmda.DomoAuth,\n'
' logs : '
'pr.ProcessLogs,\n'
' password = None,\n'
' '
'is_generate_password: bool = False\n'
' debug_api: bool = '
'False,\n'
' session '
':httpx.AsyncClient = None):\n'
' \n'
' process = '
'pr.ProcessResponse(function_name = '
"'process_user',\n"
' id = email)\n'
' logs.append(process)\n'
' \n'
' # STAGE1 - GENERATE PASSWORD\n'
' message = pr.ProcessMessage(\n'
" stage = 'generate_password',\n"
' stage_num = 1)\n'
' process.add_message(message)\n'
' \n'
' password = generate_password()\n'
' \n'
' message.message = password\n'
' message.is_success = True\n'
' \n'
' # STAGE 2 - SYNC USER\n'
' message = pr.ProcessMessage(\n'
" stage = 'sync_user',\n"
' stage_num = 2)\n'
' process.add_message(message)\n'
' \n'
' process_su = await sync_user(\n'
' display_name = display_name,\n'
' email = email,\n'
' auth = auth,\n'
' debug_api = debug_api,\n'
' session = session,\n'
' password = password,\n'
' logs = logs)\n'
' \n'
' domo_user = process_su.response\n'
' message.is_success = '
'process_su.is_success\n'
" message.message = f'sync_user { "
'"successful" if process_su.is_success else '
'"failed"}\'\n'
' \n'
' if not process_su.is_success:\n'
' raise pr.ProcessFunction_Error(\n'
' process = process,\n'
' message = '
'process_su.message[-1]\n'
' )\n'
' \n'
' process.is_success = True\n'
' process.response = domo_user\n'
' \n'
' return process'},
{'cell_type': 'code',
'execution_count': None,
'id': '62441e9b-bb74-47c1-874a-b4e18731b998',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'logs = pr.ProcessLogs()\n'
'\n'
'res = await process_user(\n'
' display_name = '
"config_ds['display_name'],\n"
" email = config_ds['email'],\n"
' auth = auth,\n'
' debug_api = False,\n'
' session = None, \n'
' logs = logs\n'
')\n'
'\n'
'pd.DataFrame(logs.to_json())'},
{'cell_type': 'code',
'execution_count': None,
'id': '60679e5d-13bd-4839-9f47-15497c11257b',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'async def request_api_token(domo_user):\n'
' pass'}],
'metadata': {'kernelspec': {'display_name': 'Python',
'language': 'python',
'name': 'python_3_9'},
'language_info': {'codemirror_mode': {'name': 'ipython',
'version': 3},
'file_extension': '.py',
'mimetype': 'text/x-python',
'name': 'python',
'nbconvert_exporter': 'python',
'pygments_lexer': 'ipython3',
'version': '3.9.13'}},
'nbformat': 4,
'nbformat_minor': 5},
'created': '2024-03-21T05:25:37.580000Z',
'format': 'json',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-21T05:25:37.580000Z',
'mimetype': None,
'name': 'assembly.ipynb',
'path': 'test_domolibrary/assembly.ipynb',
'size': 63771,
'type': 'notebook',
'writable': True},
{'content': {'cells': [{'cell_type': 'markdown',
'id': '70e93111-f9a5-461e-9067-5980c301adfe',
'metadata': {},
'source': '# 🚀 Workspace management, Working with '
'Accounts & Domo Integration\n'
'In this tutorial we will:\n'
'1. store authentication credentials '
'securely using Domo Account objects\n'
'2. learn to interact with Domo Account '
'objects in Jupyter\n'
'3. implement a workflow that issues '
'requests to Domo APIs authenticated using '
'username/password flow\n'
'4. store the results in a dataset\n'
'5. schedule the script as a dataflow'},
{'cell_type': 'markdown',
'id': 'f4475f04',
'metadata': {},
'source': '## 🚀 Handle sensitive credentials '
'appropriately\n'
'\n'
'Do not store sensitive credentials in '
'plain text on the internet!<br>\n'
'\n'
'### 🧪 Option 1: Use '
'[python-dotenv](https://pypi.org/project/python-dotenv/) '
'to store a local `.env` and then make sure '
'to `.gitignore` it\n'
'\n'
'⚠️ DomoJupyterWorkspaces makes it '
'difficult to see the .env file so you can '
'use env.txt Be aware that anyone with '
'access to your notebook can see the .txt '
'file.'},
{'cell_type': 'code',
'execution_count': None,
'id': 'e352eb34',
'metadata': {'trusted': True},
'outputs': [],
'source': '# %pip install python-dotenv'},
{'cell_type': 'code',
'execution_count': None,
'id': 'c7fe356a',
'metadata': {'trusted': True},
'outputs': [],
'source': 'from dotenv import load_dotenv\n'
'import os\n'
'\n'
"load_dotenv('env.txt', override= True)\n"
'\n'
"os.environ['DOMO_PASSWORD']"},
{'cell_type': 'markdown',
'id': 'f78e16c5',
'metadata': {},
'source': '### 🧪 Option 2: Use Domo Account objects '
'to store credentials\n'
'- ⚠️ secured fields can only be seen in '
'clear text in DomoJupyter and use the same '
'encryption platform as Domo connectors.\n'
'- ⚠️if you have accounts-v2 (account '
'sharing) enabled in your instance, any '
"user with whom you've shared the connector "
'can read your credentials\n'
'\n'
'### ▶️ create account an '
'"abstract_credentials_store" and '
'"access_token" account object with your '
'username and password (Data > Accounts).\n'
'1. create an '
'Abstract_Credentials_Store_Account named '
'`YourInitials_Absract`\n'
'- store your credentials as a properly '
'formatted json object\n'
' ```\n'
' {\n'
' "DOMO_USERNAME": '
'"<your_username>", \n'
' "DOMO_PASSWORD": "<your_password>",\n'
' "DOMO_INSTANCE": "<domo_instance>"\n'
' }\n'
' ```\n'
' \n'
' \n'
'2. create a Domo_Access_Token_Account '
'named `YourInitials_AccessToken`\n'
'3. edit this workspace and share the '
'accounts with this notebook\n'
'\n'
'\n'
'### ▶️ create an ouput dataset for your '
'JupyterWorkspace called '
'`YourInitials_MONIT_DomoAccount`.\n'},
{'cell_type': 'code',
'execution_count': None,
'id': '071d74d4-05c5-43f4-9219-5ba070c380e3',
'metadata': {'trusted': True},
'outputs': [],
'source': ''},
{'cell_type': 'markdown',
'id': 'c3df389b',
'metadata': {},
'source': '## 🚀 Read Account Objects in Jupyter '
'Workspaces\n'
'\n'
'### ▶️ write a function '
'`read_domo_jupyter_account` that reads in '
'the properties of an account \n'
'\n'
'- Implement function in '
'`functions/utils.py`\n'
'- function should receive one argument '
'`account_name` and return a dictionary '
'representing the account properties\n'
'\n'
'Notice that you can see secure fields in '
'plain text. \n'
'\n'
'```\n'
' {\n'
' "prop1": "value",\n'
' "prop2" : "value"\n'
' }\n'
' ```'},
{'cell_type': 'code',
'execution_count': 2,
'id': 'cb92ce97',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': '# from '
'solutions.read_domo_jupyter_account_v1 '
'import read_domo_jupyter_account\n'
'\n'
'import domojupyter as dj\n'
'\n'
'# FIX ME and move to functions/utils.py\n'
'def '
'read_domo_jupyter_account(account_name):\n'
' account_properties = '
'dj.get_account_property_keys(account_name)\n'
'\n'
' creds = {prop : '
'dj.get_account_property_value(account_name, '
'prop) for prop in account_properties} # '
'list comprehension\n'
' \n'
' return creds'},
{'cell_type': 'code',
'execution_count': 6,
'id': '6274fab3',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'data': {'text/plain': 'str'},
'execution_count': 6,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'from '
'solutions.read_domo_jupyter_account_v1 '
'import read_domo_jupyter_account\n'
'\n'
'ACCOUNT_NAME = "username_password_auth" \n'
'creds = '
'read_domo_jupyter_account(ACCOUNT_NAME)\n'
'\n'
"type(creds['credentials'])"},
{'cell_type': 'markdown',
'id': 'de0ab3da',
'metadata': {},
'source': '### 🧪 modify `read_domo_jupyter_account` '
'to provide custom formatting to the output '
'for `abstract_credentials_store` account '
'types\n'
'\n'
'🎓 you could have two functions, one for '
'handling any account type, and one '
'specifically for formatting '
'abstract_credentials_store accounts. But '
'no need to overengineer today :D\n'
'\n'
'1. Modify `read_domo_jupyter_account` to '
'receive parameter, `is_abstract : bool = '
'False`\n'
'2. add a conditional return to return \n'
'```\n'
'if not is_abstract_account`: return creds\n'
'```\n'
'3. use `json.load()` to convert the '
"`creds['credentials']` from a string into "
'a dictioary \n'
'4. return the result\n'
'\n'
'[solution](./solutions/read_domo_jupyter_account_v2.py)'},
{'cell_type': 'code',
'execution_count': 16,
'id': '75afdeae-6b53-49cb-9a17-832a501b23a2',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'import json\n'
'\n'
'def '
'read_domo_jupyter_account(account_name, '
'is_abstract: bool = False):\n'
' account_properties = '
'dj.get_account_property_keys(account_name)\n'
'\n'
' creds = {prop : '
'dj.get_account_property_value(account_name, '
'prop) for prop in account_properties} # '
'list comprehension\n'
' \n'
' if not is_abstract:\n'
' return creds\n'
' \n'
' \n'
' return '
"json.loads(creds['credentials'])"},
{'cell_type': 'code',
'execution_count': 18,
'id': 'd475373e-1d8a-443a-bea4-bcb4dfbab5c2',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'data': {'text/plain': "dict_keys(['DOMO_USERNAME', "
"'DOMO_PASSWORD', "
"'DOMO_INSTANCE'])"},
'execution_count': 18,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'ACCOUNT_NAME = "username_password_auth" \n'
'creds = '
'read_domo_jupyter_account(ACCOUNT_NAME, '
'is_abstract = True)\n'
'\n'
'creds.keys()'},
{'cell_type': 'markdown',
'id': '2336cd1f',
'metadata': {},
'source': '## ▶️ Put it all Together with a function '
"called 'main'\n"
'\n'
'create a function called `main()` that '
'encapsulates the entire script.\n'
'\n'
'Main should:\n'
'1. retrieve username and password from '
'domo account, `account_name` object using '
'`read_domo_jupyter_account`\n'
'2. get a session token using '
'`get_session_token`\n'
'3. return the results of `get_accounts`\n'},
{'cell_type': 'code',
'execution_count': 33,
'id': '47239381',
'metadata': {'trusted': True},
'outputs': [],
'source': 'from typing import List\n'
'\n'
'\n'
'from solutions.auth import '
'get_session_token\n'
'from solutions.accounts import '
'get_accounts\n'
'import pandas as pd\n'
'\n'
'import domojupyter as dj\n'
'\n'
'def main(account_name) -> List[dict]:\n'
' creds = '
'read_domo_jupyter_account(account_name, '
'is_abstract = True)\n'
' \n'
' domo_username = '
"creds['DOMO_USERNAME']\n"
' domo_password = '
"creds['DOMO_PASSWORD']\n"
' domo_instance = '
"creds['DOMO_INSTANCE']\n"
' \n'
' session_token = get_session_token( '
'domo_username = domo_username,\n'
' '
'domo_password = domo_password, '
'domo_instance = domo_instance)\n'
' \n'
' res = get_accounts(session_token = '
'session_token, domo_instance= '
'domo_instance)\n'
' \n'
' account_ls = res.response\n'
' \n'
' df = pd.DataFrame(account_ls)\n'
' \n'
" dj.write_dataframe(df, 'DomoStats - "
"Accounts')\n"
' \n'
' return df\n'},
{'cell_type': 'code',
'execution_count': None,
'id': '1ff49c87-3b1a-4395-b69c-d446a9d92045',
'metadata': {'trusted': True},
'outputs': [],
'source': ''},
{'cell_type': 'code',
'execution_count': None,
'id': '320dafdc-9b6d-44a7-9d7f-08c987b7b17a',
'metadata': {'trusted': True},
'outputs': [],
'source': ''},
{'cell_type': 'code',
'execution_count': 34,
'id': '8d7a5574',
'metadata': {'trusted': True},
'outputs': [{'name': 'stderr',
'output_type': 'stream',
'text': '/home/domo/.conda/lib/python3.9/site-packages/domojupyter/io.py:125: '
'FutureWarning: '
'Series.__getitem__ treating '
'keys as positions is '
'deprecated. In a future '
'version, integer keys will '
'always be treated as labels '
'(consistent with DataFrame '
'behavior). To access a value by '
'position, use `ser.iloc[pos]`\n'
" columns = [{'name': column, "
"'type': "
'_convert_type(df.dtypes[ind].name)} '
'for ind, column in '
'enumerate(df.columns)]\n'
'/home/domo/.conda/lib/python3.9/site-packages/domojupyter/io.py:125: '
'FutureWarning: '
'Series.__getitem__ treating '
'keys as positions is '
'deprecated. In a future '
'version, integer keys will '
'always be treated as labels '
'(consistent with DataFrame '
'behavior). To access a value by '
'position, use `ser.iloc[pos]`\n'
" columns = [{'name': column, "
"'type': "
'_convert_type(df.dtypes[ind].name)} '
'for ind, column in '
'enumerate(df.columns)]\n'
'/home/domo/.conda/lib/python3.9/site-packages/domojupyter/io.py:125: '
'FutureWarning: '
'Series.__getitem__ treating '
'keys as positions is '
'deprecated. In a future '
'version, integer keys will '
'always be treated as labels '
'(consistent with DataFrame '
'behavior). To access a value by '
'position, use `ser.iloc[pos]`\n'
" columns = [{'name': column, "
"'type': "
'_convert_type(df.dtypes[ind].name)} '
'for ind, column in '
'enumerate(df.columns)]\n'
'/home/domo/.conda/lib/python3.9/site-packages/domojupyter/io.py:125: '
'FutureWarning: '
'Series.__getitem__ treating '
'keys as positions is '
'deprecated. In a future '
'version, integer keys will '
'always be treated as labels '
'(consistent with DataFrame '
'behavior). To access a value by '
'position, use `ser.iloc[pos]`\n'
" columns = [{'name': column, "
"'type': "
'_convert_type(df.dtypes[ind].name)} '
'for ind, column in '
'enumerate(df.columns)]\n'
'/home/domo/.conda/lib/python3.9/site-packages/domojupyter/io.py:125: '
'FutureWarning: '
'Series.__getitem__ treating '
'keys as positions is '
'deprecated. In a future '
'version, integer keys will '
'always be treated as labels '
'(consistent with DataFrame '
'behavior). To access a value by '
'position, use `ser.iloc[pos]`\n'
" columns = [{'name': column, "
"'type': "
'_convert_type(df.dtypes[ind].name)} '
'for ind, column in '
'enumerate(df.columns)]\n'},
{'data': {'text/html': '<div>\n'
'<style scoped>\n'
' .dataframe '
'tbody tr '
'th:only-of-type '
'{\n'
' '
'vertical-align: '
'middle;\n'
' }\n'
'\n'
' .dataframe '
'tbody tr th {\n'
' '
'vertical-align: '
'top;\n'
' }\n'
'\n'
' .dataframe '
'thead th {\n'
' '
'text-align: '
'right;\n'
' }\n'
'</style>\n'
'<table border="1" '
'class="dataframe">\n'
' <thead>\n'
' <tr '
'style="text-align: '
'right;">\n'
' <th></th>\n'
' '
'<th>key</th>\n'
' '
'<th>name</th>\n'
' '
'<th>authenticationScheme</th>\n'
' '
'<th>unassociatedDataSourceCount</th>\n'
' '
'<th>accounts</th>\n'
' </tr>\n'
' </thead>\n'
' <tbody>\n'
' <tr>\n'
' <th>0</th>\n'
' '
'<td>abstract-credential-store</td>\n'
' '
'<td>Abstract '
'Credential '
'Store</td>\n'
' '
'<td>fields</td>\n'
' <td>0</td>\n'
" <td>[{'id': "
"71, 'name': "
"'domo_creds', "
"'userId': "
"'1...</td>\n"
' </tr>\n'
' <tr>\n'
' <th>1</th>\n'
' '
'<td>api</td>\n'
' '
'<td>API</td>\n'
' '
'<td>NaN</td>\n'
' <td>7</td>\n'
' '
'<td>[]</td>\n'
' </tr>\n'
' <tr>\n'
' <th>2</th>\n'
' '
'<td>dataset-copy</td>\n'
' <td>DataSet '
'Copy</td>\n'
' '
'<td>fields</td>\n'
' <td>0</td>\n'
" <td>[{'id': "
"1, 'name': "
"'DataSet Copy "
"Account', "
"'us...</td>\n"
' </tr>\n'
' <tr>\n'
' <th>3</th>\n'
' '
'<td>dataset-view</td>\n'
' <td>DataSet '
'View</td>\n'
' '
'<td>NaN</td>\n'
' <td>7</td>\n'
' '
'<td>[]</td>\n'
' </tr>\n'
' <tr>\n'
' <th>4</th>\n'
' '
'<td>domo-access-token</td>\n'
' <td>Domo '
'Access '
'Token</td>\n'
' '
'<td>fields</td>\n'
' <td>0</td>\n'
" <td>[{'id': "
"96, 'name': 'Domo "
'Access Token '
'Account...</td>\n'
' </tr>\n'
' <tr>\n'
' <th>5</th>\n'
' '
'<td>domo-csv</td>\n'
' <td>DataSet '
'Copy</td>\n'
' '
'<td>fields</td>\n'
' <td>0</td>\n'
" <td>[{'id': "
"27, 'name': "
"'DataSet Copy "
"Account', "
"'u...</td>\n"
' </tr>\n'
' <tr>\n'
' <th>6</th>\n'
' '
'<td>domo-jupyterdata</td>\n'
' <td>Jupyter '
'Data</td>\n'
' '
'<td>NaN</td>\n'
' '
'<td>11</td>\n'
' '
'<td>[]</td>\n'
' </tr>\n'
' <tr>\n'
' <th>7</th>\n'
' '
'<td>file-upload</td>\n'
' <td>File '
'Upload</td>\n'
' '
'<td>NaN</td>\n'
' <td>1</td>\n'
' '
'<td>[]</td>\n'
' </tr>\n'
' <tr>\n'
' <th>8</th>\n'
' '
'<td>google-spreadsheets</td>\n'
' <td>Google '
'Sheets</td>\n'
' '
'<td>oauth</td>\n'
' <td>0</td>\n'
" <td>[{'id': "
"45, 'name': "
"'onyxReporting@gmail.com',...</td>\n"
' </tr>\n'
' <tr>\n'
' <th>9</th>\n'
' '
'<td>json5</td>\n'
' '
'<td>JSON</td>\n'
' '
'<td>fields</td>\n'
' <td>0</td>\n'
" <td>[{'id': "
"91, 'name': 'JSON "
"Account', "
"'userId': "
'...</td>\n'
' </tr>\n'
' <tr>\n'
' '
'<th>10</th>\n'
' '
'<td>large-file-upload</td>\n'
' <td>Large '
'File Upload</td>\n'
' '
'<td>NaN</td>\n'
' <td>2</td>\n'
' '
'<td>[]</td>\n'
' </tr>\n'
' <tr>\n'
' '
'<th>11</th>\n'
' '
'<td>sample-data</td>\n'
' <td>Sample '
'Data</td>\n'
' '
'<td>NaN</td>\n'
' <td>6</td>\n'
' '
'<td>[]</td>\n'
' </tr>\n'
' <tr>\n'
' '
'<th>12</th>\n'
' '
'<td>webform</td>\n'
' <td>Domo '
'Webform</td>\n'
' '
'<td>NaN</td>\n'
' '
'<td>29</td>\n'
' '
'<td>[]</td>\n'
' </tr>\n'
' <tr>\n'
' '
'<th>13</th>\n'
' '
'<td>workbench-csv</td>\n'
' '
'<td>CSV</td>\n'
' '
'<td>NaN</td>\n'
' <td>1</td>\n'
' '
'<td>[]</td>\n'
' </tr>\n'
' </tbody>\n'
'</table>\n'
'</div>',
'text/plain': ' '
'key '
'name '
'authenticationScheme '
'\\\n'
'0 '
'abstract-credential-store '
'Abstract '
'Credential '
'Store '
'fields \n'
'1 '
'api '
'API '
'NaN \n'
'2 '
'dataset-copy '
'DataSet '
'Copy '
'fields \n'
'3 '
'dataset-view '
'DataSet '
'View '
'NaN \n'
'4 '
'domo-access-token '
'Domo Access '
'Token '
'fields \n'
'5 '
'domo-csv '
'DataSet '
'Copy '
'fields \n'
'6 '
'domo-jupyterdata '
'Jupyter '
'Data '
'NaN \n'
'7 '
'file-upload '
'File '
'Upload '
'NaN \n'
'8 '
'google-spreadsheets '
'Google '
'Sheets '
'oauth \n'
'9 '
'json5 '
'JSON '
'fields \n'
'10 '
'large-file-upload '
'Large File '
'Upload '
'NaN \n'
'11 '
'sample-data '
'Sample '
'Data '
'NaN \n'
'12 '
'webform '
'Domo '
'Webform '
'NaN \n'
'13 '
'workbench-csv '
'CSV '
'NaN \n'
'\n'
' '
'unassociatedDataSourceCount '
'\\\n'
'0 '
'0 \n'
'1 '
'7 \n'
'2 '
'0 \n'
'3 '
'7 \n'
'4 '
'0 \n'
'5 '
'0 \n'
'6 '
'11 \n'
'7 '
'1 \n'
'8 '
'0 \n'
'9 '
'0 \n'
'10 '
'2 \n'
'11 '
'6 \n'
'12 '
'29 \n'
'13 '
'1 \n'
'\n'
' '
'accounts \n'
"0 [{'id': 71, "
"'name': "
"'domo_creds', "
"'userId': "
"'1... \n"
'1 '
'[] \n'
"2 [{'id': 1, "
"'name': 'DataSet "
"Copy Account', "
"'us... \n"
'3 '
'[] \n'
"4 [{'id': 96, "
"'name': 'Domo "
'Access Token '
'Account... \n'
"5 [{'id': 27, "
"'name': 'DataSet "
"Copy Account', "
"'u... \n"
'6 '
'[] \n'
'7 '
'[] \n'
"8 [{'id': 45, "
"'name': "
"'onyxReporting@gmail.com',... \n"
"9 [{'id': 91, "
"'name': 'JSON "
"Account', "
"'userId': ... \n"
'10 '
'[] \n'
'11 '
'[] \n'
'12 '
'[] \n'
'13 '
'[] '},
'execution_count': 34,
'metadata': {},
'output_type': 'execute_result'}],
'source': "main('username_password_auth')"},
{'cell_type': 'markdown',
'id': 'ed296eeb',
'metadata': {},
'source': "## 🎓 What's the deal with main?\n"
'\n'
'All of our code so far consists of '
'individual functions are are each '
'test-able on their own.\n'
'\n'
'This vastly improves code legibility and '
'speaks to decoupling (making sure peices '
'of code can stand on their own because '
'they just perform one task with a very '
'short list of inputs).\n'
'\n'
"Main becomes an 'implementation' or a "
"'program' that we might repeat multiple "
'times, and the component parts (the .py '
'files) are peices we are recycling across '
'multiple implementations'},
{'cell_type': 'markdown',
'id': 'e72abbc5',
'metadata': {},
'source': '## ▶️ add an output to dataset step into '
'main()\n'
'\n'
'1. use `pandas` to convert our list of '
'results into a dataframe.\n'
'2. write the dataframe to the dataset '
'`YourInitials_MONIT_DomoAccount`'},
{'cell_type': 'code',
'execution_count': None,
'id': 'e008c326',
'metadata': {'trusted': True},
'outputs': [],
'source': '# %pip install pandas'},
{'cell_type': 'code',
'execution_count': None,
'id': '09157079',
'metadata': {'trusted': True},
'outputs': [],
'source': 'import pandas as pd\n'
'import domojupyter as dj\n'
'\n'
'df = pd.DataFrame(account_ls)\n'
'dj.write_dataframe(df, '
'"YourInitials_MONIT_DomoAccount")'},
{'cell_type': 'markdown',
'id': 'fd06ac5d',
'metadata': {},
'source': '## 🚀 Solution'},
{'cell_type': 'code',
'execution_count': None,
'id': 'c246e140',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'from typing import List, Union\n'
'\n'
'from solutions.utils import '
'read_domo_jupyter_account\n'
'from solutions.auth import '
'get_session_token\n'
'from solutions.accounts import '
'get_accounts\n'
'\n'
'\n'
'def main(account_name, is_dataframe: bool '
'= True) -> Union[List[dict], '
'pd.DataFrame]:\n'
' creds = '
'read_domo_jupyter_account(account_name)\n'
'\n'
' domo_username = '
"creds.get('DOMO_USERNAME')\n"
' domo_password = '
"creds.get('DOMO_PASSWORD')\n"
' domo_instance = '
"creds.get('DOMO_INSTANCE')\n"
'\n'
' session_token = '
'get_session_token(domo_username=domo_username, '
'domo_password=domo_password, )\n'
' res = get_accounts(domo_instance = '
'domo_instance , session_token= '
'session_token)\n'
'\n'
' account_ls = res.response\n'
' \n'
' if not is_dataframe:\n'
' return account_ls\n'
'\n'
' df = pd.DataFrame(account_ls)\n'
' dj.write_dataframe(df, '
'"YourInitials_MONIT_DomoAccount")\n'
'\n'
'main(\n'
' account_name = "account_name"\n'
')\n'
' '}],
'metadata': {'kernelspec': {'display_name': 'Python',
'language': 'python',
'name': 'python_3_9'},
'language_info': {'codemirror_mode': {'name': 'ipython',
'version': 3},
'file_extension': '.py',
'mimetype': 'text/x-python',
'name': 'python',
'nbconvert_exporter': 'python',
'pygments_lexer': 'ipython3',
'version': '3.9.13'}},
'nbformat': 4,
'nbformat_minor': 5},
'created': '2024-03-25T20:59:33.903000Z',
'format': 'json',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T20:59:33.903000Z',
'mimetype': None,
'name': 'Tut2 - Working with Objects and Domo Integration.ipynb',
'path': 'tutorial/domopalooza-24/Tut2 - Working with Objects and Domo '
'Integration.ipynb',
'size': 22890,
'type': 'notebook',
'writable': True},
{'content': {'cells': [{'cell_type': 'code',
'execution_count': 1,
'id': 'ae537a33-b670-4989-9309-11ab802ba0eb',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'import functions.utils as utils\n'
'import functions.auth as auth\n'
'import functions.errors as errors'},
{'cell_type': 'code',
'execution_count': 2,
'id': '21cf3e80-9d4b-42fb-ba00-aed5983eb0cd',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'creds = '
'utils.get_account_credentials("username_password_auth", '
'is_abstract_account=True)\n'
'assert creds\n'
'\n'
"domo_instance = creds['DOMO_INSTANCE']"},
{'cell_type': 'code',
'execution_count': 3,
'id': 'ec6cab69-d0cc-4848-aeb8-efcaf2f97414',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'session_token = '
'auth.get_full_auth(domo_username = '
"creds['DOMO_USERNAME'],\n"
' '
"domo_password = creds['DOMO_PASSWORD'],\n"
' '
"domo_instance = creds['DOMO_INSTANCE']\n"
' )\n'
'\n'
'assert session_token'},
{'cell_type': 'code',
'execution_count': 4,
'id': '845ba6de-4526-4e43-bec8-937ebfca8818',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'data': {'text/plain': "{'id': "
'1893952720,\n'
' '
"'invitorUserId': "
'587894148,\n'
" 'displayName': "
"'Jae Wilson1',\n"
" 'department': "
"'Business "
"Improvement',\n"
" 'userName': "
"'jae@onyxreporting.com',\n"
" 'emailAddress': "
"'jae@onyxreporting.com',\n"
" 'avatarKey': "
"'c605f478-0cd2-4451-9fd4-d82090b71e66',\n"
" 'accepted': "
'True,\n'
" 'userType': "
"'USER',\n"
" 'modified': "
'1708035568417,\n'
" 'created': "
'1588960518,\n'
" 'active': "
'True,\n'
" 'pending': "
'False,\n'
" 'anonymous': "
'False,\n'
" 'systemUser': "
'False}'},
'execution_count': 4,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'import requests\n'
'\n'
'# ultimately we will move this to auth.py, '
'but surfacing here since this is a new '
'function for us\n'
'\n'
'def who_am_i(domo_instance, '
'session_token):\n'
' """uses session_token and returns who '
'API request is authorized as"""\n'
' \n'
' headers = {"x-domo-authentication": '
'session_token}\n'
' url = '
'f"https://{domo_instance}.domo.com/api/content/v2/users/me"\n'
' \n'
" res = requests.request(method = 'GET', "
'url = url, headers = headers)\n'
' \n'
' data = res.json()\n'
' \n'
' if not res.ok:\n'
' raise '
'errors.DomoAPIRequest_Error(data)\n'
' return data\n'
'\n'
'who_am_i(domo_instance = domo_instance, '
'session_token = session_token)'},
{'cell_type': 'markdown',
'id': '4f7f7879-b98b-4fd1-9374-7145623aa8c6',
'metadata': {},
'source': '## utils'},
{'cell_type': 'code',
'execution_count': 5,
'id': '03bcd5e0-c798-46fe-991e-b2b3c51bf5ab',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'name': 'stdout',
'output_type': 'stream',
'text': '2024-02-28 02:50:32 is 5 days '
'in the future\n'}],
'source': 'import datetime as dt\n'
'import time\n'
'def generate_expiration_unixtimestamp(\n'
' duration_in_days: int = 30, debug_prn: '
'bool = False\n'
'):\n'
' """generate a unixtimestamp '
'`duration_in_days` into the future"""\n'
'\n'
' today = dt.datetime.today()\n'
' expiration_date = today + '
'dt.timedelta(days=duration_in_days)\n'
'\n'
' if debug_prn:\n'
' print(f"expiration_date is '
'{duration_in_days} from today '
'{expiration_date}")\n'
'\n'
' return '
'int(time.mktime(expiration_date.timetuple()) '
'* 1000)\n'
'\n'
'print(f"{dt.datetime.utcfromtimestamp(generate_expiration_unixtimestamp(5)/1000)} '
'is 5 days in the future")'},
{'cell_type': 'markdown',
'id': 'ca1619cb-6221-4829-999f-7ecdf777bea0',
'metadata': {},
'source': '# Access Token\n'},
{'cell_type': 'code',
'execution_count': 6,
'id': '6d652024-cbc5-4c98-82e0-4cefc7b700df',
'metadata': {'trusted': True},
'outputs': [{'name': 'stdout',
'output_type': 'stream',
'text': '🚀 generating token for 123 - '
'will expire on 2024-03-24 '
'02:50:32\n'},
{'data': {'text/plain': "{'name': 'test', "
"'ownerId': 123, "
"'expires': "
'1711248632000}'},
'execution_count': 6,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'import datetime as dt\n'
'\n'
'def '
'generate_request_accesstoken_body(token_name, '
'owner_id, duration_in_days: int = 30, '
'debug_prn: bool = False):\n'
' \n'
' expires_ts = '
'generate_expiration_unixtimestamp(duration_in_days)\n'
' \n'
' res = '
'{"name":token_name,"ownerId":owner_id,"expires":expires_ts}\n'
' \n'
' if debug_prn:\n'
' print(f"🚀 generating token for '
'{owner_id} - will expire on '
'{dt.datetime.utcfromtimestamp(expires_ts/1000)}")\n'
' \n'
' return res\n'
'\n'
'generate_request_accesstoken_body(token_name '
"= 'test', owner_id = 123, debug_prn = "
'True)'},
{'cell_type': 'code',
'execution_count': 12,
'id': 'fcb69565-549b-4b18-9d3b-f50380c3d6b5',
'metadata': {'trusted': True},
'outputs': [{'data': {'text/plain': "{'id': 186721,\n"
" 'name': "
"'tutorial',\n"
" 'ownerId': "
'1893952720,\n'
" 'ownerName': "
"'Jae Wilson1',\n"
" 'ownerEmail': "
"'jae@onyxreporting.com',\n"
" 'expires': "
'1711249039000,\n'
" 'token': "
"'51f7ee083ff2306230dbdb780ba71435b57c6f5ae498709f'}"},
'execution_count': 12,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'def request_access_token(\n'
' token_name : str,\n'
' session_token, \n'
' domo_instance,\n'
' duration_in_days : int= 30,\n'
' owner_id = None, # if no user_id '
'provided, will generate for authenticated '
'user\n'
' debug_prn:bool = False\n'
'):\n'
' \n'
' # update user_id based on who_am_i\n'
' res = who_am_i(domo_instance = '
'domo_instance, \n'
' session_token = '
'session_token)\n'
' \n'
" owner_id = owner_id or res['id']\n"
' \n'
' body = '
'generate_request_accesstoken_body(token_name,\n'
' '
'owner_id = owner_id,\n'
' '
'duration_in_days = duration_in_days,\n'
' '
'debug_prn = debug_prn)\n'
' \n'
' headers = {"x-domo-authentication": '
'session_token}\n'
' \n'
' url = '
"f'https://{domo_instance}.domo.com/api/data/v1/accesstokens'\n"
' \n'
' res = requests.request(method = '
"'POST', \n"
' url = url, \n'
' json = body,\n'
' headers = '
'headers)\n'
' \n'
' data = res.json()\n'
' \n'
' if not res.ok:\n'
' raise '
'errors.DomoAPIRequest_Error(data)\n'
' \n'
' return data\n'
'\n'
'access_token = '
'request_access_token(token_name = '
'"tutorial", \n'
' '
'session_token= session_token,\n'
' '
'domo_instance = domo_instance\n'
' )\n'
'access_token'},
{'cell_type': 'markdown',
'id': '16226601-8a1f-4ebd-accb-19c45523416d',
'metadata': {'tags': []},
'source': '## use an Abstract Account to store '
'credentials\n'
'\n'
'Remember, once we retrieve the token, '
"we'll never see it again in clear text\n"
'\n'
'How might we store it in an abstract '
'account object?\n'
'\n'
'Remember in tutorial 3 we generated a '
'DomoStats dataset. \n'
'1. retrieve the desired data\n'
'2. structure the data the way we want it\n'
'3. put it someplace\n'
'\n'
'At this point we have retrieved the data, '
'now we just need to understand how the '
'DomoAccounts api needs to receive the '
'access token for storage\n'
'\n'
'1. monitor network traffic to see what it '
'takes to store an abstract credential.\n'
'\n'
'Homework\n'
"We don't always want to create a new "
'account object, when we revoke and '
'generate a new access_token, we probably '
'just want to update the existing account '
'object. How might we.\n'
'\n'
'1. get_all_accounts (already done!)\n'
'2. retrieve "the correct" account object '
'(search by name)\n'
'3. update "the correct" account object'},
{'cell_type': 'code',
'execution_count': 20,
'id': '185b40cd-b431-40ce-a557-43739935f1ca',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'data': {'text/plain': "{'name': "
"'Abstract "
'Credential Store '
"Account',\n"
" 'displayName': "
"'test - updated "
"2024-02-23',\n"
' '
"'dataProviderType': "
"'abstract-credential-store',\n"
' '
"'configurations': "
"{'credentials': "
"'my creds go "
"here'}}"},
'execution_count': 20,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'import datetime as dt\n'
'import json\n'
'def '
'generate_abstract_credential_account_body( '
'account_name, credentials, is_timestamp: '
'bool = True):\n'
' \n'
' # the API expects credentials to be '
'type string, so conditionally convert dict '
'to string\n'
' if isinstance(credentials, dict):\n'
' credentials = '
'json.dumps(credentials)\n'
' \n'
' if is_timestamp:\n'
' account_name = f"{account_name} - '
'updated {dt.date.today()}"\n'
' return {"name":"Abstract Credential '
'Store Account",\n'
' "displayName": account_name,\n'
' '
'"dataProviderType":"abstract-credential-store",\n'
' '
'"configurations":{"credentials": '
'credentials}}\n'
'\n'
'generate_abstract_credential_account_body( '
'"test", "my creds go here", is_timestamp = '
'True)\n'},
{'cell_type': 'code',
'execution_count': 22,
'id': '35b54d23-5d84-4912-9380-9c582fee6c22',
'metadata': {'trusted': True},
'outputs': [{'data': {'text/plain': "{'id': 94,\n"
" 'userId': "
'1893952720,\n'
" 'name': "
"'Abstract "
'Credential Store '
"Account',\n"
" 'displayName': "
"'my_domo_community_access_token "
'- updated '
"2024-02-23',\n"
" 'type': "
"'data',\n"
" 'valid': "
'False,\n'
' '
"'dataProviderType': "
"'abstract-credential-store',\n"
' '
"'credentialsType': "
"'fields',\n"
" 'createdAt': "
'None,\n'
" 'createdBy': "
'1893952720,\n'
" 'modifiedAt': "
'None,\n'
" 'modifiedBy': "
'1893952720,\n'
' '
"'configurations': "
'{},\n'
" 'accountId': "
'94,\n'
' '
"'accountTemplateId': "
'None,\n'
' '
"'accountTemplateAuthorizationId': "
'None}'},
'execution_count': 22,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'import requests\n'
'def create_account(body, domo_instance, '
'session_token):\n'
' url = '
'f"https://{domo_instance}.domo.com/api/data/v1/accounts"\n'
' \n'
' headers = {"x-domo-authentication": '
'session_token}\n'
' \n'
' res = requests.request(method = '
"'POST', url = url, json = body, headers = "
'headers)\n'
' data = res.json()\n'
' \n'
' if not res.ok:\n'
' raise '
'errors.DomoAPIRequest_Error(data)\n'
' \n'
' return data\n'
'\n'
'create_account_body = '
'generate_abstract_credential_account_body(account_name '
'= "my_domo_community_access_token", '
'credentials = access_token)\n'
'\n'
'create_account(body = '
'create_account_body,\n'
' domo_instance = '
'domo_instance,\n'
' session_token = '
'session_token)'},
{'cell_type': 'code',
'execution_count': 23,
'id': '3d0665f6-e734-426e-a0c5-0dd2bd0678e5',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'data': {'text/plain': "{'id': 95,\n"
" 'userId': "
'1893952720,\n'
" 'name': "
"'my_domo_community_access_token "
'- updated '
'2024-02-23 '
"(2)',\n"
" 'displayName': "
"'my_domo_community_access_token "
'- updated '
'2024-02-23 '
"(2)',\n"
" 'type': "
"'data',\n"
" 'valid': "
'False,\n'
' '
"'dataProviderType': "
"'abstract-credential-store',\n"
' '
"'credentialsType': "
"'fields',\n"
" 'createdAt': "
'None,\n'
" 'createdBy': "
'1893952720,\n'
" 'modifiedAt': "
'None,\n'
" 'modifiedBy': "
'1893952720,\n'
' '
"'configurations': "
'{},\n'
" 'accountId': "
'95,\n'
' '
"'accountTemplateId': "
'None,\n'
' '
"'accountTemplateAuthorizationId': "
'None}'},
'execution_count': 23,
'metadata': {},
'output_type': 'execute_result'}],
'source': '\n'
'def main():\n'
' \n'
' creds = '
'utils.get_account_credentials("username_password_auth", '
'is_abstract_account=True)\n'
' domo_instance = '
"creds['DOMO_INSTANCE']\n"
' \n'
' session_token = '
'auth.get_full_auth(domo_username = '
"creds['DOMO_USERNAME'],\n"
' '
"domo_password = creds['DOMO_PASSWORD'],\n"
' '
"domo_instance = creds['DOMO_INSTANCE']\n"
' )\n'
' \n'
' access_token = '
'request_access_token(token_name = "b", \n'
' '
'session_token= session_token,\n'
' '
'domo_instance = domo_instance\n'
' )\n'
' \n'
' create_account_body = '
'generate_abstract_credential_account_body(account_name '
'= "my_domo_community_access_token", '
'credentials = access_token)\n'
'\n'
' return create_account(body = '
'create_account_body,\n'
' domo_instance = '
'domo_instance,\n'
' session_token = '
'session_token)\n'
'\n'
'main()'}],
'metadata': {'kernelspec': {'display_name': 'Python',
'language': 'python',
'name': 'python_3_9'},
'language_info': {'codemirror_mode': {'name': 'ipython',
'version': 3},
'file_extension': '.py',
'mimetype': 'text/x-python',
'name': 'python',
'nbconvert_exporter': 'python',
'pygments_lexer': 'ipython3',
'version': '3.9.13'}},
'nbformat': 4,
'nbformat_minor': 5},
'created': '2024-03-20T15:13:33.590000Z',
'format': 'json',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-20T15:13:33.590000Z',
'mimetype': None,
'name': 'Tut4 - Using Access Token Authentication and Updating Domo via '
'API.ipynb',
'path': 'test_domolibrary/Tut4 - Using Access Token Authentication and '
'Updating Domo via API.ipynb',
'size': 14982,
'type': 'notebook',
'writable': True},
{'content': '',
'created': '2025-03-10T20:17:07.175000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T20:17:07.175000Z',
'mimetype': 'text/plain',
'name': 'untitled',
'path': 'admin/song/untitled',
'size': 0,
'type': 'file',
'writable': True},
{'content': '',
'created': '2025-03-10T20:56:00.472000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T20:56:00.472000Z',
'mimetype': 'text/plain',
'name': 'untitled4',
'path': 'admin/song/untitled4',
'size': 0,
'type': 'file',
'writable': True},
{'content': 'import requests\n'
'from solutions.client import ResponseClass\n'
'\n'
'\n'
'def get_user_by_id(\n'
' domo_instance,\n'
' user_id: int,\n'
' session_token: str=None,\n'
' access_token:str = None, \n'
' headers: dict=None,\n'
' return_raw: bool = False,\n'
' debug_api: bool = False,\n'
'):\n'
' url = '
'f"https://{domo_instance}.domo.com/api/content/v2/users/{user_id}"\n'
'\n'
' headers = headers or {}\n'
'\n'
' if session_token:\n'
' headers.update({"x-domo-authentication": '
'session_token})\n'
' \n'
' if access_token:\n'
' headers.update({"x-domo-developer-token": '
'access_token})\n'
'\n'
' if debug_api:\n'
' print({"url": url, "headers": headers})\n'
' \n'
' res = requests.request(\n'
' url=url,\n'
' method="GET",\n'
' headers=headers,\n'
' )\n'
'\n'
' res = ResponseClass.from_request_response(res)\n'
'\n'
' if return_raw:\n'
' return res\n'
'\n'
' return res\n',
'created': '2024-03-25T12:58:36.889000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T12:58:36.889000Z',
'mimetype': 'text/x-python',
'name': 'users.py',
'path': 'tutorial/domopalooza-24/solutions/users.py',
'size': 833,
'type': 'file',
'writable': True},
{'content': 'import json\n'
'import domojupyter as dj\n'
'\n'
'\n'
'def read_domo_jupyter_account(account_name, is_abstract: bool = '
'False):\n'
'\n'
' account_properties = '
'dj.get_account_property_keys(account_name)\n'
'\n'
' creds = {\n'
' prop: dj.get_account_property_value(account_name, prop)\n'
' for prop in account_properties\n'
' }\n'
'\n'
' if not is_abstract:\n'
' return creds\n'
'\n'
' return json.loads(\n'
' creds["credentials"]\n'
' ) # converts credentials string into a dictionary\n',
'created': '2024-03-25T03:39:26.922000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T03:39:26.922000Z',
'mimetype': 'text/x-python',
'name': 'read_domo_jupyter_account_v2.py',
'path': 'tutorial/domopalooza-24/solutions/read_domo_jupyter_account_v2.py',
'size': 458,
'type': 'file',
'writable': True},
{'content': 'DOMO_PASSWORD = "thisissecure"\n',
'created': '2024-03-25T03:39:26.798000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T03:39:26.798000Z',
'mimetype': 'text/plain',
'name': 'env.txt',
'path': 'tutorial/domopalooza-24/env.txt',
'size': 31,
'type': 'file',
'writable': True},
{'content': 'hello world',
'created': '2025-03-10T20:28:31.157000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T20:28:31.157000Z',
'mimetype': 'text/plain',
'name': 'help6.txt',
'path': 'admin/song/help6.txt',
'size': 11,
'type': 'file',
'writable': True},
{'content': '',
'created': '2025-03-10T20:53:13.577000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T20:53:13.577000Z',
'mimetype': 'text/plain',
'name': 'untitled2',
'path': 'admin/song/untitled2',
'size': 0,
'type': 'file',
'writable': True},
{'content': 'import requests\n'
'from typing import List\n'
'\n'
'\n'
'def get_accounts(\n'
' domo_instance,\n'
' headers: dict = None,\n'
' session_token: str = None,\n'
' debug_api: bool = False, # to conditionally print request '
'parameters for debugging\n'
' return_raw: bool = False, # conditionally return the '
'Response class instead of just the sessionToken\n'
') -> List[dict]:\n'
'\n'
' headers = headers or {}\n'
'\n'
' if session_token:\n'
' headers.update({"x-domo-authentication": '
'session_token})\n'
'\n'
' url = '
'f"https://{domo_instance}.domo.com/api/data/v2/datasources/providers"\n'
'\n'
' if debug_api:\n'
' print({"headers": headers, "url": url})\n'
'\n'
' res = requests.request(method="GET", url=url, '
'headers=headers)\n'
'\n'
' if return_raw:\n'
' return res\n'
'\n'
' account_ls = res.json()\n'
'\n'
' return account_ls\n',
'created': '2024-03-25T03:39:26.897000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T03:39:26.897000Z',
'mimetype': 'text/x-python',
'name': 'get_accounts_v2.py',
'path': 'tutorial/domopalooza-24/solutions/get_accounts_v2.py',
'size': 771,
'type': 'file',
'writable': True},
{'content': 'import domojupyter as dj\n'
'\n'
'\n'
'def read_domo_jupyter_account(account_name):\n'
'\n'
' # each account config has different fields (properties)\n'
' account_properties = '
'dj.get_account_property_keys(account_name)\n'
'\n'
' creds = {\n'
' prop: dj.get_account_property_value(account_name, prop)\n'
' for prop in account_properties\n'
' } # in python this technique is called a "list '
'comprehension" its similar to a FOR loop\n'
'\n'
' return creds\n',
'created': '2024-03-25T12:36:12.724000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T12:36:12.724000Z',
'mimetype': 'text/x-python',
'name': 'read_domo_jupyter_account_v1.py',
'path': 'tutorial/domopalooza-24/solutions/read_domo_jupyter_account_v1.py',
'size': 430,
'type': 'file',
'writable': True},
{'content': '',
'created': '2025-03-10T21:43:12.468000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T21:43:12.468000Z',
'mimetype': 'text/plain',
'name': 'untitled13',
'path': 'admin/song/untitled13',
'size': 0,
'type': 'file',
'writable': True},
{'content': 'import requests\n'
'\n'
'from solutions.client import DomoAPIRequest_Error, '
'ResponseClass\n'
'\n'
'\n'
'class AuthError(DomoAPIRequest_Error):\n'
' def __init__(self, function_name, message):\n'
' super().__init__(function_name, message)\n'
'\n'
'\n'
'def get_session_token(\n'
' domo_instance: str, domo_username: str, domo_password: str, '
'return_raw: bool = False\n'
') -> ResponseClass:\n'
' """use username and password to generate an access token"""\n'
'\n'
' url = '
'f"https://{domo_instance}.domo.com/api/content/v2/authentication"\n'
'\n'
' body = {\n'
' "method": "password",\n'
' "emailAddress": domo_username,\n'
' "password": domo_password,\n'
' }\n'
'\n'
' res = requests.request(method="POST", url=url, json=body)\n'
'\n'
' # create standardardized response class\n'
' res = ResponseClass.from_request_response(res=res)\n'
'\n'
' if return_raw:\n'
' return res\n'
'\n'
' # test for API errrors\n'
' if not res.is_success:\n'
' raise AuthError(get_session_token.__name__, '
'res.response)\n'
'\n'
' session_token = res.response.get("sessionToken")\n'
'\n'
" # test for 'logic errors'\n"
' if not session_token:\n'
' raise AuthError(\n'
' get_session_token.__name__, "unable to retrieve a '
'session token"\n'
' )\n'
'\n'
' return session_token\n',
'created': '2024-03-25T03:39:26.870000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T03:39:26.870000Z',
'mimetype': 'text/x-python',
'name': 'auth.py',
'path': 'tutorial/domopalooza-24/solutions/auth.py',
'size': 1191,
'type': 'file',
'writable': True},
{'content': {'cells': [],
'metadata': {'language_info': {'name': 'python'}},
'nbformat': 4,
'nbformat_minor': 2},
'created': '2024-03-25T03:39:26.827000Z',
'format': 'json',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T03:39:26.827000Z',
'mimetype': None,
'name': 'monit_accounts.ipynb',
'path': 'tutorial/domopalooza-24/implementations/monit_accounts.ipynb',
'size': 119,
'type': 'notebook',
'writable': True},
{'content': '',
'created': '2024-03-25T03:39:26.817000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T03:39:26.817000Z',
'mimetype': 'text/x-python',
'name': '__init__.py',
'path': 'tutorial/domopalooza-24/implementations/__init__.py',
'size': 0,
'type': 'file',
'writable': True},
{'content': {'cells': [{'cell_type': 'markdown',
'id': '70e93111-f9a5-461e-9067-5980c301adfe',
'metadata': {},
'source': '# Tut4 - Automation. Using Access Token '
'Authentication and Updating Domo via API\n'
'\n'
'- In this tutorial we will modify all our '
'code to use access_token authentication.\n'
'- We will learn to create, search for, '
'retrieve and delete access_tokens via API\n'
'- We will create Account objects in Domo\n'
'\n'
'## 🎓 What is Automation or Integration?\n'
'\n'
'> "I want to generate and store my '
'access_token in Domo Accounts"\n'
'\n'
'Writing Integrations = decomposing a '
'multiple step process into smaller '
'pieces.\n'
'\n'
'1. Use the UI to write down how you might '
'approach this task by hand.\n'
'2. Each mouse-click often corresponds to '
'an API request. Stub out some functions to '
"capture the activities you're taking\n"
'3. Monitor network traffic to confirm '
'assumptions.\n'
'\n'
'### Possible Solution\n'
'Break into teams.\n'
'\n'
'## ⭐ Team 1. Design a workflow that can '
'regenerate or create an access_token given '
'a user_id and token_name\n'
'\n'
'## ⭐ Team 2. Design a workflow that can '
'create or update a Domo Account '
'(access_token and abstract credentials '
'store).\n'
'\n'
'- note updating the account is two steps, '
'updating metadata vs. updating the actual '
'configuration\n'
'\n'
'## Team 3. Modify format_domostats_account '
'to include config information from '
'accounts (that share the same name) with '
'the jupyter workspace\n'
'\n'
'- in our code we will match on account '
'name. what are the risks?\n'
'\n'
'\n'
'## ⭐ Team 4. MOST DIFFICULT - Design a '
'process to automatically share existing '
'accounts with the DomoJupyter workspace '
'then \n'
'\n'
'use DomoJupyter routes as a reference\n'
'https://github.com/jaewilson07/domolibrary/blob/main/domolibrary/routes/jupyter.py\n'
'https://github.com/jaewilson07/domolibrary/blob/main/nbs/routes/jupyter.ipynb\n'},
{'cell_type': 'markdown',
'id': '014d46a8',
'metadata': {},
'source': '### Utils\n'},
{'cell_type': 'code',
'execution_count': None,
'id': '71ac38b2',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'import datetime as dt\n'
'\n'
'\n'
'def '
'convert_domo_utc_to_datetime(timestamp):\n'
' return '
'dt.datetime.fromtimestamp(timestamp / '
'1000, dt.timezone.utc)'},
{'cell_type': 'code',
'execution_count': None,
'id': 'f1271caf',
'metadata': {'trusted': True},
'outputs': [],
'source': '# Domo returns token expiration date in '
'unix time\n'
'\n'
'convert_domo_utc_to_datetime(1904914053000)'},
{'cell_type': 'code',
'execution_count': None,
'id': 'beb47e8b',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'import time\n'
'\n'
'\n'
'def '
'generate_domo_expiration_unixtimestamp(\n'
' duration_in_days: int = 15, debug_prn: '
'bool = False\n'
'):\n'
' """# the expiration date of the access '
'token is calculated based off of x days '
'into the future which must then be '
'converted into a unix timestamp"""\n'
'\n'
' today = dt.datetime.today()\n'
' expiration_date = today + '
'dt.timedelta(days=duration_in_days)\n'
'\n'
' if debug_prn:\n'
' print(f"expiration_date is '
'{duration_in_days} from today '
'{expiration_date}")\n'
'\n'
' return '
'int(time.mktime(expiration_date.timetuple()) '
'* 1000)'},
{'cell_type': 'code',
'execution_count': None,
'id': 'a64533c6',
'metadata': {'trusted': True},
'outputs': [],
'source': '# the expiration date of the access token '
'is calculated based off of x days into the '
'future which must then be converted into a '
'unix timestamp\n'
'\n'
'generate_domo_expiration_unixtimestamp(duration_in_days=15)'},
{'cell_type': 'markdown',
'id': '3b55c719-3ee5-4983-9308-89bccef91eb4',
'metadata': {},
'source': '## Auth\n'
'\n'
'In this project, we use `access_token` '
'(retrieved from an "access_token" account '
'shared with DomoJupyter) to authenticate '
'API requests. \n'
'\n'
'Note that access_token auth can store '
'everything except the Domo Instance.'},
{'cell_type': 'code',
'execution_count': 41,
'id': '26dd17ea-19b9-469d-bc73-433c491039bb',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'from solutions.utils import '
'read_domo_jupyter_account\n'
'\n'
"account_name = 'username_password_auth'\n"
'\n'
'creds = '
'read_domo_jupyter_account(account_name, \n'
' '
'is_abstract = True)\n'
'\n'
'domo_username = '
"creds.get('DOMO_USERNAME')\n"
'domo_password = '
"creds.get('DOMO_PASSWORD')\n"
'domo_instance = '
"creds.get('DOMO_INSTANCE')\n"
'\n'
'session_token = '
'get_session_token(domo_username = '
'domo_username, \n'
' '
'domo_password = domo_password,\n'
' '
'domo_instance = domo_instance\n'
' )'},
{'cell_type': 'markdown',
'id': 'deaba2c9-fa1a-4b1f-8050-e7d4e971c597',
'metadata': {'tags': []},
'source': '## Solution Code starts here'},
{'cell_type': 'markdown',
'id': '406f9690',
'metadata': {},
'source': '### Access Tokens\n'},
{'cell_type': 'code',
'execution_count': 30,
'id': 'da7ed383',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': '# from solutions.access_tokens import '
'get_all_access_tokens\n'
'\n'
'import requests\n'
'from solutions.client import '
'ResponseClass\n'
'from solutions.utils import '
'convert_domo_utc_to_datetime\n'
'\n'
'\n'
'def get_all_access_tokens(\n'
' domo_instance,\n'
' session_token=None,\n'
' access_token = None,\n'
' headers=None,\n'
' return_raw: bool = False,\n'
' debug_api: bool = False,\n'
'):\n'
'\n'
' url = '
'f"https://{domo_instance}.domo.com/api/data/v1/accesstokens"\n'
'\n'
' headers = headers or {}\n'
'\n'
' if session_token:\n'
' '
'headers.update({"x-domo-authentication": '
'session_token})\n'
' \n'
' if access_token:\n'
' '
'headers.update({"x-domo-developer-token": '
'access_token})\n'
'\n'
' if debug_api:\n'
' print({"url": url, "headers": '
'headers})\n'
'\n'
' res = requests.request(\n'
' url=url,\n'
' method="GET",\n'
' headers=headers,\n'
' )\n'
'\n'
' res = '
'ResponseClass.from_request_response(res)\n'
'\n'
' if return_raw:\n'
' return res\n'
'\n'
' [\n'
' token.update({"expires": '
'convert_domo_utc_to_datetime(token["expires"])})\n'
' for token in res.response\n'
' ]\n'
'\n'
' return res'},
{'cell_type': 'code',
'execution_count': 52,
'id': '7f2f2423-fa9e-4491-817b-da67a8eadae3',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'data': {'text/html': '<div>\n'
'<style scoped>\n'
' .dataframe '
'tbody tr '
'th:only-of-type '
'{\n'
' '
'vertical-align: '
'middle;\n'
' }\n'
'\n'
' .dataframe '
'tbody tr th {\n'
' '
'vertical-align: '
'top;\n'
' }\n'
'\n'
' .dataframe '
'thead th {\n'
' '
'text-align: '
'right;\n'
' }\n'
'</style>\n'
'<table border="1" '
'class="dataframe">\n'
' <thead>\n'
' <tr '
'style="text-align: '
'right;">\n'
' <th></th>\n'
' '
'<th>id</th>\n'
' '
'<th>name</th>\n'
' '
'<th>ownerId</th>\n'
' '
'<th>ownerName</th>\n'
' '
'<th>ownerEmail</th>\n'
' '
'<th>expires</th>\n'
' '
'<th>owner_name</th>\n'
' </tr>\n'
' </thead>\n'
' <tbody>\n'
' <tr>\n'
' <th>0</th>\n'
' '
'<td>156180</td>\n'
' '
'<td>Governance</td>\n'
' '
'<td>587894148</td>\n'
' '
'<td>None</td>\n'
' '
'<td>None</td>\n'
' '
'<td>2030-05-13 '
'14:47:33+00:00</td>\n'
' <td>Bryan '
'Van Kampen</td>\n'
' </tr>\n'
' <tr>\n'
' <th>1</th>\n'
' '
'<td>159191</td>\n'
' <td>Java '
'CLI</td>\n'
' '
'<td>1345408759</td>\n'
' '
'<td>None</td>\n'
' '
'<td>None</td>\n'
' '
'<td>2030-07-26 '
'20:11:21+00:00</td>\n'
' <td>Alexis '
'Lorenz '
'(DataMaven)</td>\n'
' </tr>\n'
' <tr>\n'
' <th>2</th>\n'
' '
'<td>163868</td>\n'
' '
'<td>Governance</td>\n'
' '
'<td>1345408759</td>\n'
' '
'<td>None</td>\n'
' '
'<td>None</td>\n'
' '
'<td>2030-11-04 '
'21:06:00+00:00</td>\n'
' <td>Alexis '
'Lorenz '
'(DataMaven)</td>\n'
' </tr>\n'
' <tr>\n'
' <th>3</th>\n'
' '
'<td>168840</td>\n'
' <td>Dataset '
'Copy</td>\n'
' '
'<td>1345408759</td>\n'
' '
'<td>None</td>\n'
' '
'<td>None</td>\n'
' '
'<td>2031-02-20 '
'18:55:14+00:00</td>\n'
' <td>Alexis '
'Lorenz '
'(DataMaven)</td>\n'
' </tr>\n'
' <tr>\n'
' <th>4</th>\n'
' '
'<td>182879</td>\n'
' <td>S3 '
'Export</td>\n'
' '
'<td>68216396</td>\n'
' '
'<td>None</td>\n'
' '
'<td>None</td>\n'
' '
'<td>2022-10-08 '
'02:51:55+00:00</td>\n'
' <td>Elliott '
'Leonard</td>\n'
' </tr>\n'
' </tbody>\n'
'</table>\n'
'</div>',
'text/plain': ' '
'id '
'name ownerId '
'ownerName '
'ownerEmail \\\n'
'0 156180 '
'Governance '
'587894148 '
'None '
'None \n'
'1 159191 '
'Java CLI '
'1345408759 '
'None '
'None \n'
'2 163868 '
'Governance '
'1345408759 '
'None '
'None \n'
'3 168840 '
'Dataset Copy '
'1345408759 '
'None '
'None \n'
'4 182879 S3 '
'Export '
'68216396 '
'None '
'None \n'
'\n'
' '
'expires '
'owner_name \n'
'0 2030-05-13 '
'14:47:33+00:00 '
'Bryan Van '
'Kampen \n'
'1 2030-07-26 '
'20:11:21+00:00 '
'Alexis Lorenz '
'(DataMaven) \n'
'2 2030-11-04 '
'21:06:00+00:00 '
'Alexis Lorenz '
'(DataMaven) \n'
'3 2031-02-20 '
'18:55:14+00:00 '
'Alexis Lorenz '
'(DataMaven) \n'
'4 2022-10-08 '
'02:51:55+00:00 '
'Elliott '
'Leonard '},
'execution_count': 52,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'from solutions.utils import '
'read_domo_jupyter_account\n'
'from solutions.auth import '
'get_session_token\n'
'from solutions.users import '
'get_user_by_id\n'
'\n'
'import pandas as pd\n'
'\n'
'def format_access_token(access_token_obj, '
'session_token, domo_instance):\n'
" user_id = access_token_obj['ownerId']\n"
' \n'
' res = get_user_by_id(session_token = '
'session_token, domo_instance = '
'domo_instance, user_id = user_id)\n'
' user_obj = res.response\n'
' \n'
' access_token_obj.update({"owner_name" '
": user_obj['displayName']})\n"
' return access_token_obj\n'
' \n'
'\n'
'def main(account_name):\n'
' creds = '
'read_domo_jupyter_account(account_name, \n'
' '
'is_abstract = True)\n'
'\n'
' domo_username = '
"creds.get('DOMO_USERNAME')\n"
' domo_password = '
"creds.get('DOMO_PASSWORD')\n"
' domo_instance = '
"creds.get('DOMO_INSTANCE')\n"
' \n'
' session_token = '
'get_session_token(domo_username = '
'domo_username, \n'
' '
'domo_password = domo_password,\n'
' '
'domo_instance = domo_instance\n'
' )\n'
' res = '
'get_all_access_tokens(session_token = '
'session_token, domo_instance = '
'domo_instance)\n'
' \n'
' access_tokens_ls = res.response\n'
' \n'
' [format_access_token(access_token_obj '
'= access_token_obj,\n'
' domo_instance = '
'domo_instance,\n'
' session_token = '
'session_token) for access_token_obj in '
'access_tokens_ls]\n'
' \n'
' return pd.DataFrame(access_tokens_ls)\n'
' \n'
' # return access_tokens_ls\n'
'\n'
'access_tokens_ls = '
"main('username_password_auth')\n"
'access_tokens_ls[0:5]'},
{'cell_type': 'code',
'execution_count': 50,
'id': 'd9949356-19f3-4dcc-9cd1-0576c10cc848',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': '# format_access_token(access_token_obj = '
'access_tokens_ls[0], session_token = '
'session_token , domo_instance = '
'domo_instance)'},
{'cell_type': 'code',
'execution_count': None,
'id': 'c2db7a7a-c20f-47fe-9327-3a8f66f5294b',
'metadata': {'trusted': True},
'outputs': [],
'source': ''},
{'cell_type': 'code',
'execution_count': 53,
'id': '410eded4',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'data': {'text/plain': "{'id': 187011,\n"
" 'name': "
"'dp24',\n"
" 'ownerId': "
'85654293,\n'
" 'ownerName': "
'None,\n'
" 'ownerEmail': "
'None,\n'
" 'expires': "
'1712537476000}'},
'execution_count': 53,
'metadata': {},
'output_type': 'execute_result'}],
'source': '\n'
'# note - because this has "functionality" '
'beyond the base API\n'
'# you might argue that could be '
'implemented as a class method of a '
'"class_function" \n'
'# as described in the Extra Credit portion '
'of Tutorial 1.\n'
'\n'
'def '
'search_tokens_by_user_id_and_token_name(\n'
' domo_instance, \n'
' user_id,\n'
' token_name,\n'
' session_token = None,\n'
' access_token = None,\n'
'):\n'
' res = get_all_access_tokens(\n'
' session_token=session_token,\n'
' access_token = access_token,\n'
' domo_instance=domo_instance,\n'
' return_raw=True,\n'
' debug_api=False,\n'
' )\n'
'\n'
' all_tokens = res.response\n'
'\n'
' return next(\n'
' (\n'
' token\n'
' for token in all_tokens\n'
' if token["name"] == token_name '
'and token["ownerId"] == user_id\n'
' ),\n'
' None,\n'
' )\n'
'\n'
'\n'
'test_token = '
'search_tokens_by_user_id_and_token_name(\n'
' access_token =access_token,\n'
' domo_instance=domo_instance,\n'
' user_id=85654293,\n'
' token_name="dp24",\n'
')\n'
'\n'
'test_token'},
{'cell_type': 'code',
'execution_count': None,
'id': 'b131b65f',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'import pandas as pd\n'
'\n'
'res = get_all_access_tokens(\n'
' # session_token=test_session_token,\n'
' access_token = access_token,\n'
' domo_instance=domo_instance,\n'
' return_raw=True,\n'
' debug_api=False,\n'
')\n'
'test_access_tokens = res.response\n'
'test_access_tokens[0:5]\n'
'# pd.DataFrame(test_access_tokens)[0:5]'},
{'cell_type': 'markdown',
'id': '114b2c05',
'metadata': {},
'source': '# Users\n'},
{'cell_type': 'code',
'execution_count': None,
'id': '75da1f6b',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'from solutions.users import '
'get_user_by_id\n'
'\n'
'def get_user_by_id(\n'
' domo_instance,\n'
' user_id: int,\n'
' session_token=None,\n'
' access_token = None,\n'
' headers=None,\n'
' return_raw: bool = False,\n'
' debug_api: bool = False,\n'
'):\n'
' url = '
'f"https://{domo_instance}.domo.com/api/content/v2/users/{user_id}"\n'
'\n'
' headers = headers or {}\n'
'\n'
' if session_token:\n'
' '
'headers.update({"x-domo-authentication": '
'session_token})\n'
' \n'
' if access_token:\n'
' '
'headers.update({"x-domo-developer-token": '
'access_token})\n'
'\n'
' if debug_api:\n'
' print({"url": url, "headers": '
'headers})\n'
' \n'
' res = requests.request(\n'
' url=url,\n'
' method="GET",\n'
' headers=headers,\n'
' )\n'
'\n'
' res = '
'ResponseClass.from_request_response(res)\n'
'\n'
' if return_raw:\n'
' return res\n'
'\n'
' return res'},
{'cell_type': 'code',
'execution_count': None,
'id': '0c5b7ea7',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'get_user_by_id(\n'
' domo_instance=domo_instance,\n'
' access_token=access_token,\n'
' user_id=85654293,\n'
' debug_api=False,\n'
')'},
{'cell_type': 'code',
'execution_count': None,
'id': '8c264466',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'from solutions.access_tokens import '
'generate_access_token\n'
'\n'
'from pprint import pprint\n'
'\n'
'\n'
'def generate_access_token(\n'
' domo_instance,\n'
' token_name: str,\n'
' user_id,\n'
' duration_in_days: 15,\n'
' session_token=None,\n'
' access_token = None,\n'
' headers=None,\n'
' return_raw: bool = False,\n'
' debug_api: bool = False,\n'
'):\n'
' url = '
'f"https://{domo_instance}.domo.com/api/data/v1/accesstokens"\n'
'\n'
' expiration_timestamp = '
'generate_domo_expiration_unixtimestamp(\n'
' duration_in_days=duration_in_days\n'
' )\n'
'\n'
' body = {"name": token_name, "ownerId": '
'user_id, "expires": expiration_timestamp}\n'
'\n'
' headers = headers or {}\n'
'\n'
' if session_token:\n'
' '
'headers.update({"x-domo-authentication": '
'session_token})\n'
' \n'
' if access_token:\n'
' '
'headers.update({"x-domo-developer-token": '
'access_token})\n'
'\n'
' if debug_api:\n'
' print({"url": url, "headers": '
'headers, "body" : body})\n'
' \n'
' res = requests.request(method="post", '
'url=url, json=body, headers=headers)\n'
'\n'
' res = '
'ResponseClass.from_request_response(res)\n'
' if return_raw:\n'
' return res\n'
'\n'
' return res'},
{'cell_type': 'code',
'execution_count': None,
'id': '38fb068a',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'generate_access_token(\n'
' domo_instance=domo_instance,\n'
' access_token=access_token,\n'
' token_name="dp24",\n'
' duration_in_days=15,\n'
' user_id=85654293,\n'
' debug_api=False,\n'
')'},
{'cell_type': 'code',
'execution_count': 56,
'id': 'a4b9898c',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'from solutions.access_tokens import '
'revoke_access_token\n'
'\n'
'def revoke_access_token(\n'
' domo_instance,\n'
' access_token_id,\n'
' access_token = None,\n'
' session_token=None,\n'
' headers=None,\n'
' return_raw: bool = False,\n'
' debug_api: bool = False,\n'
'):\n'
'\n'
' url = '
'f"https://{domo_instance}.domo.com/api/data/v1/accesstokens/{access_token_id}"\n'
'\n'
' headers = headers or {}\n'
'\n'
' if session_token:\n'
' '
'headers.update({"x-domo-authentication": '
'session_token})\n'
' \n'
' if access_token:\n'
' '
'headers.update({"x-domo-developer-token": '
'access_token})\n'
'\n'
' if debug_api:\n'
' print({"url": url, "headers": '
'headers})\n'
' res = '
'requests.request(method="DELETE", url=url, '
'headers=headers)\n'
'\n'
' res = '
'ResponseClass.from_request_response(res)\n'
' if return_raw:\n'
' return res\n'
'\n'
' res.response = f"access token '
'{access_token_id} deleted"\n'
' return res\n'
'\n'
'\n'
'## CUSTOM WORKFLOW FOR TESTING CODE\n'
"# so that we don't generate a ton of the "
'same access token\n'
'# create access token\n'
'# find access token\n'
'# immediately delete it\n'
'\n'
'generate_access_token(\n'
' domo_instance=domo_instance,\n'
' access_token=access_token,\n'
' token_name="we want lunch",\n'
' duration_in_days=15,\n'
' user_id=85654293,\n'
' debug_api=False,\n'
')\n'
'\n'
'test_token = '
'search_tokens_by_user_id_and_token_name(\n'
' access_token=access_token,\n'
' domo_instance=domo_instance,\n'
' user_id=85654293,\n'
' token_name="we want lunch",\n'
')\n'
'\n'
'if not test_token:\n'
' raise Exception("no token")\n'
'\n'},
{'cell_type': 'code',
'execution_count': 57,
'id': '099daea4-374d-4cde-802b-7bd7d085dd64',
'metadata': {'tags': [], 'trusted': True},
'outputs': [{'data': {'text/plain': 'ResponseClass(status=200, '
'is_success=True, '
"response='access "
'token 187033 '
"deleted')"},
'execution_count': 57,
'metadata': {},
'output_type': 'execute_result'}],
'source': 'res =revoke_access_token(domo_instance = '
'domo_instance,\n'
' '
'access_token=access_token,\n'
' '
"access_token_id=test_token['id'],\n"
' return_raw=False,\n'
' debug_api=False)\n'
'\n'
'res'},
{'cell_type': 'markdown',
'id': 'c8208feb',
'metadata': {},
'source': '### Domo Accounts\n'},
{'cell_type': 'code',
'execution_count': None,
'id': '5758a03b',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'from solutions.accounts import '
'get_accounts\n'
'\n'
'def get_accounts(domo_instance, \n'
' session_token = None,\n'
' access_token = None,\n'
' headers : dict = None,\n'
' debug_api: bool = False,\n'
' return_raw: bool = '
'False):\n'
'\n'
' url = '
'f"https://{domo_instance}.domo.com/api/data/v1/accounts"\n'
'\n'
' headers = headers or {}\n'
'\n'
' if session_token:\n'
' '
'headers.update({"x-domo-authentication": '
'session_token})\n'
' \n'
' if access_token:\n'
' '
'headers.update({"x-domo-developer-token": '
'access_token})\n'
'\n'
' if debug_api:\n'
' print({"url": url, "headers": '
'headers})\n'
' \n'
' res = requests.request(method="GET", '
'url=url, headers=headers)\n'
'\n'
' res = '
'ResponseClass.from_request_response(res)\n'
'\n'
' return res'},
{'cell_type': 'code',
'execution_count': None,
'id': 'd22041e0',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'res = get_accounts(\n'
' domo_instance=domo_instance,\n'
' access_token=access_token\n'
')\n'
'pd.DataFrame(res.response[0:5])'},
{'cell_type': 'code',
'execution_count': None,
'id': '185b40cd-b431-40ce-a557-43739935f1ca',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'from solutions.accounts import '
'generate_account__abstract_credential_store_body\n'
'import datetime as dt\n'
'import json\n'
'\n'
'\n'
'def '
'generate_account__abstract_credential_store_body(\n'
' account_name, credentials, '
'is_timestamp: bool = True\n'
'):\n'
'\n'
' # the API expects credentials to be '
'type string, so conditionally convert dict '
'to string\n'
' if isinstance(credentials, dict):\n'
' credentials = '
'json.dumps(credentials)\n'
'\n'
' if is_timestamp:\n'
' account_name = f"{account_name} - '
'updated {dt.date.today()}"\n'
' return {\n'
' "name": "Abstract Credential Store '
'Account",\n'
' "displayName": account_name,\n'
' "dataProviderType": '
'"abstract-credential-store",\n'
' "configurations": {"credentials": '
'credentials},\n'
' }\n'
'\n'
'\n'
'generate_account__abstract_credential_store_body(\n'
' "test", "my creds go here", '
'is_timestamp=True\n'
')'},
{'cell_type': 'code',
'execution_count': None,
'id': 'b6b867a6',
'metadata': {'trusted': True},
'outputs': [],
'source': 'from solutions.accounts import '
'generate_account__access_token_body\n'
'\n'
'def generate_account__access_token_body(\n'
' account_name, access_token=None, '
'username=None, password=None\n'
'):\n'
' return {\n'
' "name": "Domo Access Token '
'Account",\n'
' "displayName": account_name,\n'
' "dataProviderType": '
'"domo-access-token",\n'
' "configurations": {\n'
' "domoAccessToken": '
'{access_token},\n'
' "username": {username},\n'
' "password": {password},\n'
' },\n'
' }\n'
'\n'
'\n'
'generate_account__access_token_body(\n'
' account_name="jw_dp24", '
'access_token="123", '
'username="jae@test.com", password=123\n'
')'},
{'cell_type': 'code',
'execution_count': None,
'id': '35b54d23-5d84-4912-9380-9c582fee6c22',
'metadata': {'trusted': True},
'outputs': [],
'source': 'from solutions.accounts import '
'create_account \n'
'\n'
'import requests\n'
'\n'
'\n'
'def create_account(body,\n'
' domo_instance,\n'
' headers = None,\n'
' session_token = None,\n'
' access_token = None,\n'
' debug_api: bool = '
'False):\n'
' \n'
' url = '
'f"https://{domo_instance}.domo.com/api/data/v1/accounts"\n'
'\n'
' headers = headers or {}\n'
'\n'
' if session_token:\n'
' '
'headers.update({"x-domo-authentication": '
'session_token})\n'
' \n'
' if access_token:\n'
' '
'headers.update({"x-domo-developer-token": '
'access_token})\n'
'\n'
' if debug_api:\n'
' print({"url": url, "headers": '
'headers})\n'
'\n'
' res = requests.request(method="POST", '
'url=url, json=body, headers=headers)\n'
'\n'
' res = '
'ResponseClass.from_request_response(res)\n'
'\n'
' if not res.is_success:\n'
' raise '
'DomoAPIRequest_Error(create_account.__name__, '
'res)\n'
'\n'
' return res\n'
'\n'
'\n'
'create_account_body = '
'generate_account__abstract_credential_store_body(\n'
' '
'account_name="my_domo_community_access_token", '
'credentials=test_token\n'
')\n'
'\n'
'create_account(\n'
' body=create_account_body,\n'
' domo_instance=domo_instance,\n'
' access_token=access_token,\n'
')'},
{'cell_type': 'code',
'execution_count': None,
'id': 'dbdf6a63',
'metadata': {'trusted': True},
'outputs': [],
'source': 'from solutions.accounts import '
'get_account_by_id\n'
'\n'
'def get_account_by_id(\n'
' domo_instance,\n'
' account_id,\n'
' headers = None,\n'
' session_token=None,\n'
' access_token=None,\n'
' return_raw: bool = False,\n'
' debug_api: bool = False,\n'
'):\n'
' url = '
'f"https://{domo_instance}.domo.com/api/data/v1/accounts/{account_id}?unmask=true"\n'
'\n'
' headers = headers or {}\n'
'\n'
' if session_token:\n'
' '
'headers.update({"x-domo-authentication": '
'session_token})\n'
' \n'
' if access_token:\n'
' '
'headers.update({"x-domo-developer-token": '
'access_token})\n'
'\n'
' if debug_api:\n'
' print({"url": url, "headers": '
'headers})\n'
'\n'
' res = requests.request(method="GET", '
'url=url, headers=headers)\n'
'\n'
' res = '
'ResponseClass.from_request_response(res)\n'
'\n'
' if return_raw:\n'
' return res\n'
'\n'
' return res'},
{'cell_type': 'code',
'execution_count': None,
'id': '3bc4073a',
'metadata': {'trusted': True},
'outputs': [],
'source': 'get_account_by_id(\n'
' domo_instance=DOMO_INSTANCE,\n'
' account_id=102,\n'
' session_token=test_session_token,\n'
' debug_api=True,\n'
')'},
{'cell_type': 'code',
'execution_count': None,
'id': '2f44a399',
'metadata': {'trusted': True},
'outputs': [],
'source': 'from solutions.accounts import '
'update_account_config\n'
'\n'
'def update_account_config(\n'
' domo_instance,\n'
' dataprovider_type,\n'
' account_id,\n'
' body: dict, # only receives '
'configuration portion of the account '
'definition\n'
' headers: dict = None,\n'
' session_token: str = None,\n'
' access_token: str = None,\n'
' debug_api: bool = False,\n'
' return_raw: bool = False,\n'
'):\n'
' url = '
'f"https://{domo_instance}.domo.com/api/data/v1/providers/{dataprovider_type}/account/{account_id}"\n'
'\n'
' headers = headers or {}\n'
'\n'
' if session_token:\n'
' '
'headers.update({"x-domo-authentication": '
'session_token})\n'
' \n'
' if access_token:\n'
' '
'headers.update({"x-domo-developer-token": '
'access_token})\n'
'\n'
' if debug_api:\n'
' print({"url": url, "headers": '
'headers})\n'
' res = requests.request(method="PUT", '
'json=body, url=url, headers=headers)\n'
'\n'
' res = '
'ResponseClass.from_request_response(res)\n'
'\n'
' if return_raw:\n'
' return res\n'
'\n'
' return res'},
{'cell_type': 'code',
'execution_count': None,
'id': 'a5b4beac',
'metadata': {'trusted': True},
'outputs': [],
'source': 'create_account_body = '
'generate_account__abstract_credential_store_body(\n'
' '
'account_name=f"my_domo_community_access_token '
'- {dt.datetime.now()}",\n'
' credentials=test_token,\n'
')\n'
'\n'
'# NOTE\n'
'config = '
'create_account_body["configurations"]\n'
'\n'
'update_account_config(\n'
' domo_instance=domo_instance,\n'
' account_id=102,\n'
' '
'dataprovider_type="abstract-credential-store",\n'
' body=config,\n'
' access_token=access_token,\n'
' debug_api=True,\n'
')'},
{'cell_type': 'code',
'execution_count': None,
'id': 'f76ab098',
'metadata': {'trusted': True},
'outputs': [],
'source': 'from solutions.accounts import '
'update_account_name\n'
'\n'
'# notice that we pass a string to requests '
'instead of a json object!!\n'
'\n'
'def update_account_name(\n'
' domo_instance: str,\n'
' account_id: int,\n'
' account_name: str,\n'
' session_token=None,\n'
' access_token= None,\n'
' headers: dict = None,\n'
' debug_api: bool = False,\n'
' return_raw: bool = False,\n'
'):\n'
' url = '
'f"https://{domo_instance}.domo.com/api/data/v1/accounts/{account_id}/name"\n'
'\n'
' headers = headers or {}\n'
'\n'
' if session_token:\n'
' '
'headers.update({"x-domo-authentication": '
'session_token})\n'
' \n'
' if access_token:\n'
' '
'headers.update({"x-domo-developer-token": '
'access_token})\n'
'\n'
' if debug_api:\n'
' print({"url": url, "headers": '
'headers, "body": account_name})\n'
'\n'
' res = requests.request(method="PUT", '
'data=account_name, url=url, '
'headers=headers)\n'
'\n'
' res = '
'ResponseClass.from_request_response(res)\n'
'\n'
' if return_raw:\n'
' return res\n'
'\n'
' return res'},
{'cell_type': 'code',
'execution_count': None,
'id': 'd97a143e',
'metadata': {'tags': [], 'trusted': True},
'outputs': [],
'source': 'update_account_name(\n'
' account_id=102,\n'
' account_name=f"dp24 - update '
'{dt.datetime.now()}",\n'
' domo_instance=domo_instance,\n'
' access_token=access_token,\n'
' debug_api=True,\n'
')'}],
'metadata': {'kernelspec': {'display_name': 'Python',
'language': 'python',
'name': 'python_3_9'},
'language_info': {'codemirror_mode': {'name': 'ipython',
'version': 3},
'file_extension': '.py',
'mimetype': 'text/x-python',
'name': 'python',
'nbconvert_exporter': 'python',
'pygments_lexer': 'ipython3',
'version': '3.9.13'}},
'nbformat': 4,
'nbformat_minor': 5},
'created': '2024-03-25T21:42:31.544000Z',
'format': 'json',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T21:42:31.544000Z',
'mimetype': None,
'name': 'Tut4 - Using Access Token Authentication and Updating Domo via '
'API.ipynb',
'path': 'tutorial/domopalooza-24/Tut4 - Using Access Token Authentication '
'and Updating Domo via API.ipynb',
'size': 33989,
'type': 'notebook',
'writable': True},
{'content': '',
'created': '2025-03-10T21:34:45.832000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T21:34:45.832000Z',
'mimetype': 'text/plain',
'name': 'untitled11',
'path': 'admin/song/untitled11',
'size': 0,
'type': 'file',
'writable': True},
{'content': '',
'created': '2025-03-10T21:05:52.203000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T21:05:52.203000Z',
'mimetype': 'text/plain',
'name': 'untitled6',
'path': 'admin/song/untitled6',
'size': 0,
'type': 'file',
'writable': True},
{'content': '',
'created': '2024-03-25T03:39:26.842000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T03:39:26.842000Z',
'mimetype': 'text/x-python',
'name': '__init__.py',
'path': 'tutorial/domopalooza-24/solutions/__init__.py',
'size': 0,
'type': 'file',
'writable': True},
{'content': 'import requests\n'
'from solutions.client import DomoAPIRequest_Error, '
'ResponseClass\n'
'\n'
'import json\n'
'import datetime as dt\n'
'\n'
'from pprint import pprint\n'
'\n'
'\n'
'class Account_Error(DomoAPIRequest_Error):\n'
' def __init__(self, function_name, message):\n'
' super().__init__(function_name, message)\n'
'\n'
'\n'
'def get_accounts(\n'
' domo_instance,\n'
' headers: dict = None,\n'
' session_token: str = None,\n'
' access_token : str = None,\n'
' debug_api: bool = False,\n'
' return_raw: bool = False,\n'
') -> ResponseClass:\n'
'\n'
' url = '
'f"https://{domo_instance}.domo.com/api/data/v2/datasources/providers"\n'
' \n'
' headers = headers or {}\n'
'\n'
' if session_token:\n'
' headers.update({"x-domo-authentication": '
'session_token})\n'
' \n'
' if access_token:\n'
' headers.update({"x-domo-developer-token": '
'access_token})\n'
'\n'
' if debug_api:\n'
' print({"url": url, "headers": headers})\n'
'\n'
' res = requests.request(method="GET", url=url, '
'headers=headers)\n'
'\n'
' # create standardardized response class\n'
' res = ResponseClass.from_request_response(res=res)\n'
'\n'
' if return_raw:\n'
' return res\n'
'\n'
' # test for API errrors\n'
' if not res.is_success:\n'
' raise Account_Error(get_accounts.__name__, '
'res.response)\n'
'\n'
" # test for 'logic errors'\n"
' if len(res.response) == 0:\n'
' raise Account_Error(\n'
' get_accounts.__name__,\n'
' "no accounts returned, does this user have access to '
'accounts Domo > Data > Accounts",\n'
' )\n'
'\n'
' return res\n'
'\n'
'def get_account_by_id(\n'
' domo_instance,\n'
' account_id,\n'
' headers : dict=None,\n'
' session_token : str =None,\n'
' access_token: str = None,\n'
' return_raw: bool = False,\n'
' debug_api: bool = False,\n'
'):\n'
' url = '
'f"https://{domo_instance}.domo.com/api/data/v1/accounts/{account_id}?unmask=true"\n'
'\n'
' headers = headers or {}\n'
'\n'
' if session_token:\n'
' headers.update({"x-domo-authentication": '
'session_token})\n'
' \n'
' if access_token:\n'
' headers.update({"x-domo-developer-token": '
'access_token})\n'
'\n'
' if debug_api:\n'
' print({"url": url, "headers": headers})\n'
'\n'
' res = requests.request(method="GET", url=url, '
'headers=headers)\n'
'\n'
' res = ResponseClass.from_request_response(res)\n'
'\n'
' if return_raw:\n'
' return res\n'
'\n'
' return res\n'
'\n'
'\n'
'def generate_account__abstract_credential_store_body(\n'
' account_name, credentials, is_timestamp: bool = True\n'
'):\n'
'\n'
' # the API expects credentials to be type string, so '
'conditionally convert dict to string\n'
' if isinstance(credentials, dict):\n'
' credentials = json.dumps(credentials)\n'
'\n'
' if is_timestamp:\n'
' account_name = f"{account_name} - updated '
'{dt.date.today()}"\n'
' return {\n'
' "name": "Abstract Credential Store Account",\n'
' "displayName": account_name,\n'
' "dataProviderType": "abstract-credential-store",\n'
' "configurations": {"credentials": credentials},\n'
' }\n'
'\n'
'\n'
'def generate_account__access_token_body(\n'
' account_name, access_token=None, username=None, '
'password=None\n'
'):\n'
' return {\n'
' "name": "Domo Access Token Account",\n'
' "displayName": account_name,\n'
' "dataProviderType": "domo-access-token",\n'
' "configurations": {\n'
' "domoAccessToken": {access_token},\n'
' "username": {username},\n'
' "password": {password},\n'
' },\n'
' }\n'
'\n'
'\n'
'def create_account(body, \n'
' domo_instance, \n'
' headers = None,\n'
' session_token = None,\n'
' access_token = None,\n'
' debug_api: bool = False):\n'
' url = '
'f"https://{domo_instance}.domo.com/api/data/v1/accounts"\n'
'\n'
' headers = headers or {}\n'
'\n'
' if session_token:\n'
' headers.update({"x-domo-authentication": '
'session_token})\n'
' \n'
' if access_token:\n'
' headers.update({"x-domo-developer-token": '
'access_token})\n'
'\n'
' if debug_api:\n'
' print({"url": url, "headers": headers, "body": body})\n'
'\n'
' res = requests.request(method="POST", url=url, json=body, '
'headers=headers)\n'
'\n'
' res = ResponseClass.from_request_response(res)\n'
'\n'
' if not res.is_success:\n'
' raise DomoAPIRequest_Error(create_account.__name__, '
'res)\n'
'\n'
' return res\n'
'\n'
'\n'
'def update_account_name(\n'
' domo_instance: str,\n'
' account_id: int,\n'
' account_name: str,\n'
' session_token=None,\n'
' access_token = None,\n'
' headers: dict = None,\n'
' debug_api: bool = False,\n'
' return_raw: bool = False,\n'
'):\n'
' url = '
'f"https://{domo_instance}.domo.com/api/data/v1/accounts/{account_id}/name"\n'
'\n'
' headers = headers or {}\n'
'\n'
' if session_token:\n'
' headers.update({"x-domo-authentication": '
'session_token})\n'
' \n'
' if access_token:\n'
' headers.update({"x-domo-developer-token": '
'access_token})\n'
'\n'
' if debug_api:\n'
' pprint({"url": url, "headers": headers, "body": '
'account_name})\n'
'\n'
' res = requests.request(method="PUT", data=account_name, '
'url=url, headers=headers)\n'
'\n'
' res = ResponseClass.from_request_response(res)\n'
'\n'
' if return_raw:\n'
' return res\n'
'\n'
' return res\n'
'\n'
'\n'
'def update_account_config(\n'
' domo_instance,\n'
' dataprovider_type,\n'
' account_id,\n'
' body: dict, # only receives configuration portion of the '
'account definition\n'
' headers: dict = None,\n'
' session_token: str = None,\n'
' access_token : str = None,\n'
' debug_api: bool = False,\n'
' return_raw: bool = False,\n'
'):\n'
' url = '
'f"https://{domo_instance}.domo.com/api/data/v1/providers/{dataprovider_type}/account/{account_id}"\n'
'\n'
' headers = headers or {}\n'
'\n'
' if session_token:\n'
' headers.update({"x-domo-authentication": '
'session_token})\n'
' \n'
' if access_token:\n'
' headers.update({"x-domo-developer-token": '
'access_token})\n'
'\n'
' if debug_api:\n'
' pprint({"url": url, "headers": headers, "body": body})\n'
'\n'
' res = requests.request(method="PUT", json=body, url=url, '
'headers=headers)\n'
'\n'
' res = ResponseClass.from_request_response(res)\n'
'\n'
' if return_raw:\n'
' return res\n'
'\n'
' return res\n',
'created': '2024-03-25T13:12:42.987000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2024-03-25T13:12:42.987000Z',
'mimetype': 'text/x-python',
'name': 'accounts.py',
'path': 'tutorial/domopalooza-24/solutions/accounts.py',
'size': 5758,
'type': 'file',
'writable': True},
{'content': '',
'created': '2025-03-10T21:52:02.073000Z',
'format': 'text',
'hash': None,
'hash_algorithm': None,
'last_modified': '2025-03-10T21:52:02.073000Z',
'mimetype': 'text/plain',
'name': 'untitled15',
'path': 'admin/song/untitled15',
'size': 0,
'type': 'file',
'writable': True}]CLASS
DomoJupyter Content and Class
sample impelemntation of get_contet
import domolibrary.classes.DomoJupyter as dmjc
try:
domo_dj = await dmjc.DomoJupyterWorkspace.get_by_id(
auth=dj_auth, workspace_id=workspace_id
)
domo_dj_content = await domo_dj.get_content(
debug_api=False, return_raw=False, is_recursive=True
)
print(domo_dj_content[-1])
except dmde.DomoError as e:
print(e)DomoJupyter_Content(name='untitled15', folder='admin/song/', last_modified=datetime.datetime(2025, 3, 10, 21, 52, 2, 73000, tzinfo=tzlocal()), file_type='file', content='', default_export_folder='export')