Exploring the Climate Resilience Data Platform: A Survey of Its Assets

import json
from damn_tool.ls import list_assets

result = list_assets(orchestrator='dagster', configs_dir="../.damn/")
data = json.loads(result)

organized_data = {}
for item in data["ls"]:
    product, key = item.split("/", 1)
    if product not in organized_data:
        organized_data[product] = []
    organized_data[product].append(key)

for product, keys in organized_data.items():
    print(f"{product}:")
    for key in keys:
        print(f" - {key}")

analytics:
 - int__media_articles
 - int__social_network_conversations
 - int__social_network_posts
 - int__social_network_user_profiles
 - media_articles_fct
 - social_network_conversations_dim
 - social_network_posts_fct
 - social_network_user_profiles_dim
 - stg__conversation_classifications
 - stg__conversation_event_summaries
 - stg__nytimes_articles
 - stg__post_narrative_associations
 - stg__user_geolocations
 - stg__x_conversation_posts
 - stg__x_conversations
media:
 - nytimes_articles
narratives:
 - conversation_classifications
 - conversation_event_summary
 - post_narrative_associations
social_networks:
 - user_geolocations
 - x_conversation_posts
 - x_conversations

import json
from damn_tool.show import show_asset

result = show_asset('media/nytimes_articles', orchestrator='dagster', data_warehouse='bigquery', configs_dir="../.damn/")
data = json.loads(result)

# Extract and print the desired attributes
asset_details = data["show"]
orchestrator_details = asset_details["From orchestrator"]
warehouse_details = asset_details["From data warehouse"]

# Combine attributes into a single string
output = (
    f"- Description: {orchestrator_details['description']}\n"
    f"- Compute kind: {orchestrator_details['computeKind']}\n"
    f"- Is partitioned: {orchestrator_details['isPartitioned']}\n"
    f"- Table type: {warehouse_details['table_type']}\n"
    f"- Table schema: {warehouse_details['table_schema']}\n"
    f"- Created: {warehouse_details['created']}"
)

# Print the final string
print(output)

- Description: Media feed for New York Times
- Compute kind: python
- Is partitioned: True
- Table type: BASE TABLE
- Table schema: media
- Created: 2024-12-12T18:44:11.473000+00:00

import json
from damn_tool.metrics import asset_metrics

result = asset_metrics('media/nytimes_articles', orchestrator='dagster', data_warehouse='bigquery', configs_dir="../.damn/")
data = json.loads(result)

# Extract relevant metrics
orchestrator_metrics = data["metrics"]["From orchestrator"]
dw_metrics = data["metrics"]["From data warehouse"]

# Combine metrics into a single string
output = (
    f"- Row count: {dw_metrics['row_count']}\n"
    f"- Size: {dw_metrics['bytes']}\n"
    f"- Last run id: {orchestrator_metrics['run_id']}\n"
    f"- Last run status: {orchestrator_metrics['status']}\n"
    f"- Last start time: {orchestrator_metrics['start_time']}\n"
    f"- Last end time: {orchestrator_metrics['end_time']}\n"
    f"- Number of partitions: {orchestrator_metrics['num_partitions']}\n"
    f"- Number of partitions materialized: {orchestrator_metrics['num_materialized']}\n"
    f"- Number of failed partitions: {orchestrator_metrics['num_failed']}"
)

# Print the final string
print(output)

- Row count: 894
- Size: 649.96 KB
- Last run id: e6cf5f89-f14d-4623-9496-82b52efe79d1
- Last run status: SUCCESS
- Last start time: 2024-12-24 10:01:45
- Last end time: 2024-12-24 10:01:54
- Number of partitions: 2275
- Number of partitions materialized: 291
- Number of failed partitions: 0

import pyarrow.feather as feather
from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

query = """
    select *
    from `phonic-biplane-420020.media.nytimes_articles`
    order by published_ts desc
    limit 5"""

# Make an API request.
query_job = client.query(query)

# Wait for the job to complete.
articles_df = query_job.result().to_dataframe()

# Write the DataFrame to a Feather file
feather_file = "data/articles.feather"
feather.write_feather(articles_df, feather_file)

# Pass the file path to the global namespace
globals()['articles_feather'] = feather_file

library(arrow)

# Read the Feather file
feather_file <- reticulate::py$articles_feather

# Read the Feather file
articles_df <- read_feather(feather_file)

# Display the table
kable(
    articles_df,
    format = "html",
    escape = TRUE   
)

import json
from damn_tool.show import show_asset

result = show_asset('social_networks/x_conversations', orchestrator='dagster', data_warehouse='bigquery', configs_dir="../.damn/")
data = json.loads(result)

# Extract and print the desired attributes
asset_details = data["show"]
orchestrator_details = asset_details["From orchestrator"]
warehouse_details = asset_details["From data warehouse"]

# Combine attributes into a single string
output = (
    f"- Description: {orchestrator_details['description']}\n"
    f"- Compute kind: {orchestrator_details['computeKind']}\n"
    f"- Is partitioned: {orchestrator_details['isPartitioned']}\n"
    f"- Table type: {warehouse_details['table_type']}\n"
    f"- Table schema: {warehouse_details['table_schema']}\n"
    f"- Created: {warehouse_details['created']}"
)

# Print the final string
print(output)

- Description: X conversations that mention this partition's article
- Compute kind: python
- Is partitioned: True
- Table type: BASE TABLE
- Table schema: social_networks
- Created: 2024-12-12T18:44:47.015000+00:00

import json
from damn_tool.metrics import asset_metrics

result = asset_metrics('social_networks/x_conversations', orchestrator='dagster', data_warehouse='bigquery', configs_dir="../.damn/")
data = json.loads(result)

# Extract relevant metrics
orchestrator_metrics = data["metrics"]["From orchestrator"]
dw_metrics = data["metrics"]["From data warehouse"]

# Combine metrics into a single string
output = (
    f"- Row count: {dw_metrics['row_count']}\n"
    f"- Size: {dw_metrics['bytes']}\n"
    f"- Last run id: {orchestrator_metrics['run_id']}\n"
    f"- Last run status: {orchestrator_metrics['status']}\n"
    f"- Last start time: {orchestrator_metrics['start_time']}\n"
    f"- Last end time: {orchestrator_metrics['end_time']}\n"
    f"- Number of partitions: {orchestrator_metrics['num_partitions']}\n"
    f"- Number of partitions materialized: {orchestrator_metrics['num_materialized']}\n"
    f"- Number of failed partitions: {orchestrator_metrics['num_failed']}"
)

# Print the final string
print(output)

- Row count: 8203
- Size: 5.51 MB
- Last run id: 84dd166d-a39c-4574-9b3d-f578b2cb9de3
- Last run status: SUCCESS
- Last start time: 2024-12-24 10:11:44
- Last end time: 2024-12-24 10:11:51
- Number of partitions: 2275
- Number of partitions materialized: 291
- Number of failed partitions: 0

from google.cloud import bigquery
import pyarrow.feather as feather

# Construct a BigQuery client object.
client = bigquery.Client()

query = """
    select * except (tweet_public_metrics, author_public_metrics)
    from `social_networks.x_conversations`
    limit 5"""

# Make an API request.
query_job = client.query(query)

# Wait for the job to complete.
conversations_df = query_job.result().to_dataframe()

# Write the DataFrame to a Feather file
feather_file = "data/x_conversations.feather"
feather.write_feather(conversations_df, feather_file)

# Pass the file path to the global namespace
globals()['x_conversations_feather'] = feather_file

library(arrow)
library(dplyr)

# Read the Feather file
feather_file <- reticulate::py$x_conversations_feather

# Read the Feather file
conversations_df <- read_feather(feather_file)
conversations_df <- conversations_df %>%
  mutate(
    TWEET_TEXT = substr(TWEET_TEXT, 1, 50)
  )

# Display the table
kable(
    conversations_df,
    format = "html",    # Ensures better rendering in Quarto
    escape = TRUE   
)

import json
from damn_tool.show import show_asset

result = show_asset('social_networks/x_conversation_posts', orchestrator='dagster', data_warehouse='bigquery', configs_dir="../.damn/")
data = json.loads(result)

# Extract and print the desired attributes
asset_details = data["show"]
orchestrator_details = asset_details["From orchestrator"]
warehouse_details = asset_details["From data warehouse"]

# Combine attributes into a single string
output = (
    f"- Description: {orchestrator_details['description']}\n"
    f"- Compute kind: {orchestrator_details['computeKind']}\n"
    f"- Is partitioned: {orchestrator_details['isPartitioned']}\n"
    f"- Table type: {warehouse_details['table_type']}\n"
    f"- Table schema: {warehouse_details['table_schema']}\n"
    f"- Created: {warehouse_details['created']}"
)

# Print the final string
print(output)

- Description: Posts within X conversations
- Compute kind: python
- Is partitioned: True
- Table type: BASE TABLE
- Table schema: social_networks
- Created: 2024-12-12T18:44:28.374000+00:00

import json
from damn_tool.metrics import asset_metrics

result = asset_metrics('social_networks/x_conversation_posts', orchestrator='dagster', data_warehouse='bigquery', configs_dir="../.damn/")
data = json.loads(result)

# Extract relevant metrics
orchestrator_metrics = data["metrics"]["From orchestrator"]
dw_metrics = data["metrics"]["From data warehouse"]

# Combine metrics into a single string
output = (
    f"- Row count: {dw_metrics['row_count']}\n"
    f"- Size: {dw_metrics['bytes']}\n"
    f"- Last run id: {orchestrator_metrics['run_id']}\n"
    f"- Last run status: {orchestrator_metrics['status']}\n"
    f"- Last start time: {orchestrator_metrics['start_time']}\n"
    f"- Last end time: {orchestrator_metrics['end_time']}\n"
    f"- Number of partitions: {orchestrator_metrics['num_partitions']}\n"
    f"- Number of partitions materialized: {orchestrator_metrics['num_materialized']}\n"
    f"- Number of failed partitions: {orchestrator_metrics['num_failed']}"
)

# Print the final string
print(output)

- Row count: 4415
- Size: 2.38 MB
- Last run id: 63a9fe77-8ed3-4c77-b59c-b74efe609713
- Last run status: SUCCESS
- Last start time: 2024-12-24 10:21:45
- Last end time: 2024-12-24 10:21:57
- Number of partitions: 758
- Number of partitions materialized: 100
- Number of failed partitions: 0

from google.cloud import bigquery
import pyarrow.feather as feather

# Construct a BigQuery client object.
client = bigquery.Client()

query = """
    select * except (article_url, tweet_public_metrics, author_public_metrics)
    from `social_networks.x_conversation_posts`
    limit 5"""

# Make an API request.
query_job = client.query(query)

# Wait for the job to complete.
conversation_posts_df = query_job.result().to_dataframe()

# Write the DataFrame to a Feather file
feather_file = "data/x_conversation_posts.feather"
feather.write_feather(conversation_posts_df, feather_file)

# Pass the file path to the global namespace
globals()['x_conversation_posts_feather'] = feather_file

library(arrow)
library(dplyr)

# Read the Feather file
feather_file <- reticulate::py$x_conversation_posts_feather

# Read the Feather file
conversation_posts_df <- read_feather(feather_file)
conversation_posts_df <- conversation_posts_df %>%
  mutate(
    TWEET_TEXT = substr(TWEET_TEXT, 1, 50)
  )

# Display the table
kable(
    conversation_posts_df,
    format = "html",    # Ensures better rendering in Quarto
    escape = TRUE   
)

import json
from damn_tool.show import show_asset

result = show_asset('social_networks/user_geolocations', orchestrator='dagster', data_warehouse='bigquery', configs_dir="../.damn/")
data = json.loads(result)

# Extract and print the desired attributes
asset_details = data["show"]
orchestrator_details = asset_details["From orchestrator"]
warehouse_details = asset_details["From data warehouse"]

# Combine attributes into a single string
output = (
    f"- Description: {orchestrator_details['description']}\n"
    f"- Compute kind: {orchestrator_details['computeKind']}\n"
    f"- Is partitioned: {orchestrator_details['isPartitioned']}\n"
    f"- Table type: {warehouse_details['table_type']}\n"
    f"- Table schema: {warehouse_details['table_schema']}\n"
    f"- Created: {warehouse_details['created']}"
)

# Print the final string
print(output)

- Description: Geolocation of social network user's profile location
- Compute kind: python
- Is partitioned: True
- Table type: BASE TABLE
- Table schema: social_networks
- Created: 2024-12-12T18:46:22.036000+00:00

import json
from damn_tool.metrics import asset_metrics

result = asset_metrics('social_networks/user_geolocations', orchestrator='dagster', data_warehouse='bigquery', configs_dir="../.damn/")
data = json.loads(result)

# Extract relevant metrics
orchestrator_metrics = data["metrics"]["From orchestrator"]
dw_metrics = data["metrics"]["From data warehouse"]

# Combine metrics into a single string
output = (
    f"- Row count: {dw_metrics['row_count']}\n"
    f"- Size: {dw_metrics['bytes']}\n"
    f"- Last run id: {orchestrator_metrics['run_id']}\n"
    f"- Last run status: {orchestrator_metrics['status']}\n"
    f"- Last start time: {orchestrator_metrics['start_time']}\n"
    f"- Last end time: {orchestrator_metrics['end_time']}\n"
    f"- Number of partitions: {orchestrator_metrics['num_partitions']}\n"
    f"- Number of partitions materialized: {orchestrator_metrics['num_materialized']}\n"
    f"- Number of failed partitions: {orchestrator_metrics['num_failed']}"
)

# Print the final string
print(output)

- Row count: 4853
- Size: 523.74 KB
- Last run id: 63a9fe77-8ed3-4c77-b59c-b74efe609713
- Last run status: SUCCESS
- Last start time: 2024-12-24 10:22:06
- Last end time: 2024-12-24 10:22:21
- Number of partitions: 758
- Number of partitions materialized: 74
- Number of failed partitions: 0

from google.cloud import bigquery
import pyarrow.feather as feather

# Construct a BigQuery client object.
client = bigquery.Client()

query = """
    select * from `social_networks.user_geolocations`
    order by geolocation_ts desc
    limit 5"""

# Make an API request.
query_job = client.query(query)

# Wait for the job to complete.
user_geolocations_df = query_job.result().to_dataframe()

# Write the DataFrame to a Feather file
feather_file = "data/user_geolocations.feather"
feather.write_feather(user_geolocations_df, feather_file)

# Pass the file path to the global namespace
globals()['user_geolocations_feather'] = feather_file

library(arrow)

# Read the Feather file
feather_file <- reticulate::py$user_geolocations_feather

# Read the Feather file
user_geolocations_df <- read_feather(feather_file)

# Display the table
kable(
    user_geolocations_df,
    format = "html",    # Ensures better rendering in Quarto
    escape = TRUE   
)

import json
from damn_tool.show import show_asset

result = show_asset('narratives/conversation_classifications', orchestrator='dagster', data_warehouse='bigquery', configs_dir="../.damn/")
data = json.loads(result)

# Extract and print the desired attributes
asset_details = data["show"]
orchestrator_details = asset_details["From orchestrator"]
warehouse_details = asset_details["From data warehouse"]

# Combine attributes into a single string
output = (
    f"- Description: {orchestrator_details['description']}\n"
    f"- Compute kind: {orchestrator_details['computeKind']}\n"
    f"- Is partitioned: {orchestrator_details['isPartitioned']}\n"
    f"- Table type: {warehouse_details['table_type']}\n"
    f"- Table schema: {warehouse_details['table_schema']}\n"
    f"- Created: {warehouse_details['created']}"
)

# Print the final string
print(output)

- Description: Classification of conversations as climate-related or not
- Compute kind: LangChain
- Is partitioned: True
- Table type: BASE TABLE
- Table schema: narratives
- Created: 2024-12-12T18:45:28.708000+00:00

import json
from damn_tool.metrics import asset_metrics

result = asset_metrics('narratives/conversation_classifications', orchestrator='dagster', data_warehouse='bigquery', configs_dir="../.damn/")
data = json.loads(result)

# Extract relevant metrics
orchestrator_metrics = data["metrics"]["From orchestrator"]
dw_metrics = data["metrics"]["From data warehouse"]

# Combine metrics into a single string
output = (
    f"- Row count: {dw_metrics['row_count']}\n"
    f"- Size: {dw_metrics['bytes']}\n"
    f"- Last run id: {orchestrator_metrics['run_id']}\n"
    f"- Last run status: {orchestrator_metrics['status']}\n"
    f"- Last start time: {orchestrator_metrics['start_time']}\n"
    f"- Last end time: {orchestrator_metrics['end_time']}\n"
    f"- Number of partitions: {orchestrator_metrics['num_partitions']}\n"
    f"- Number of partitions materialized: {orchestrator_metrics['num_materialized']}\n"
    f"- Number of failed partitions: {orchestrator_metrics['num_failed']}"
)

# Print the final string
print(output)

- Row count: 8127
- Size: 280.32 KB
- Last run id: 0346fbc5-54f5-46a1-8e7a-18299ef93004
- Last run status: SUCCESS
- Last start time: 2024-12-24 07:46:36
- Last end time: 2024-12-24 07:47:09
- Number of partitions: 758
- Number of partitions materialized: 98
- Number of failed partitions: 0

from google.cloud import bigquery
import pyarrow.feather as feather

# Construct a BigQuery client object.
client = bigquery.Client()

query = """
    select * from `dev_narratives.conversation_classifications`
    order by partition_time desc
    limit 5"""

# Make an API request.
query_job = client.query(query)

# Wait for the job to complete.
conversation_classifications_df = query_job.result().to_dataframe()

# Write the DataFrame to a Feather file
feather_file = "data/conversation_classifications.feather"
feather.write_feather(conversation_classifications_df, feather_file)

# Pass the file path to the global namespace
globals()['conversation_classifications_feather'] = feather_file

library(arrow)

# Read the Feather file
feather_file <- reticulate::py$conversation_classifications_feather

# Read the Feather file
conversation_classifications_df <- read_feather(feather_file)

# Display the table
kable(
    conversation_classifications_df,
    format = "html",    # Ensures better rendering in Quarto
    escape = TRUE   
)

import json
from damn_tool.show import show_asset

result = show_asset('narratives/conversation_event_summary', orchestrator='dagster', data_warehouse='bigquery', configs_dir="../.damn/")
data = json.loads(result)

# Extract and print the desired attributes
asset_details = data["show"]
orchestrator_details = asset_details["From orchestrator"]
warehouse_details = asset_details["From data warehouse"]

# Combine attributes into a single string
output = (
    f"- Description: {orchestrator_details['description']}\n"
    f"- Compute kind: {orchestrator_details['computeKind']}\n"
    f"- Is partitioned: {orchestrator_details['isPartitioned']}\n"
    f"- Table type: {warehouse_details['table_type']}\n"
    f"- Table schema: {warehouse_details['table_schema']}\n"
    f"- Created: {warehouse_details['created']}"
)

# Print the final string
print(output)

- Description: Summary of the event discussed in a conversation
- Compute kind: LangChain
- Is partitioned: True
- Table type: BASE TABLE
- Table schema: narratives
- Created: 2024-12-12T18:45:46.163000+00:00

import json
from damn_tool.metrics import asset_metrics

result = asset_metrics('narratives/conversation_event_summary', orchestrator='dagster', data_warehouse='bigquery', configs_dir="../.damn/")
data = json.loads(result)

# Extract relevant metrics
orchestrator_metrics = data["metrics"]["From orchestrator"]
dw_metrics = data["metrics"]["From data warehouse"]

# Combine metrics into a single string
output = (
    f"- Row count: {dw_metrics['row_count']}\n"
    f"- Size: {dw_metrics['bytes']}\n"
    f"- Last run id: {orchestrator_metrics['run_id']}\n"
    f"- Last run status: {orchestrator_metrics['status']}\n"
    f"- Last start time: {orchestrator_metrics['start_time']}\n"
    f"- Last end time: {orchestrator_metrics['end_time']}\n"
    f"- Number of partitions: {orchestrator_metrics['num_partitions']}\n"
    f"- Number of partitions materialized: {orchestrator_metrics['num_materialized']}\n"
    f"- Number of failed partitions: {orchestrator_metrics['num_failed']}"
)

# Print the final string
print(output)

- Row count: 289
- Size: 348.86 KB
- Last run id: 0346fbc5-54f5-46a1-8e7a-18299ef93004
- Last run status: SUCCESS
- Last start time: 2024-12-24 07:46:37
- Last end time: 2024-12-24 07:47:59
- Number of partitions: 758
- Number of partitions materialized: 48
- Number of failed partitions: 0

from google.cloud import bigquery
import pyarrow.feather as feather

# Construct a BigQuery client object.
client = bigquery.Client()

query = """
    select * except (research_cycles)
    from `dev_narratives.conversation_event_summary`
    order by partition_time desc
    limit 5"""

# Make an API request.
query_job = client.query(query)

# Wait for the job to complete.
conversation_event_summaries_df = query_job.result().to_dataframe()

# Write the DataFrame to a Feather file
feather_file = "data/conversation_event_summaries.feather"
feather.write_feather(conversation_event_summaries_df, feather_file)

# Pass the file path to the global namespace
globals()['conversation_event_summaries_feather'] = feather_file

library(arrow)
library(dplyr)

# Read the Feather file
feather_file <- reticulate::py$conversation_event_summaries_feather

# Read the Feather file
conversation_event_summaries_df <- read_feather(feather_file)
conversation_event_summaries_df <- conversation_event_summaries_df %>%
  mutate(
    EVENT_SUMMARY = substr(EVENT_SUMMARY, 1, 50)
  )

# Display the table
kable(
    conversation_event_summaries_df,
    format = "html",    # Ensures better rendering in Quarto
    escape = TRUE   
)

import json
from damn_tool.show import show_asset

result = show_asset('narratives/post_narrative_associations', orchestrator='dagster', data_warehouse='bigquery', configs_dir="../.damn/")
data = json.loads(result)

# Extract and print the desired attributes
asset_details = data["show"]
orchestrator_details = asset_details["From orchestrator"]
warehouse_details = asset_details["From data warehouse"]

# Combine attributes into a single string
output = (
    f"- Description: {orchestrator_details['description']}\n"
    f"- Compute kind: {orchestrator_details['computeKind']}\n"
    f"- Is partitioned: {orchestrator_details['isPartitioned']}\n"
    f"- Table type: {warehouse_details['table_type']}\n"
    f"- Table schema: {warehouse_details['table_schema']}\n"
    f"- Created: {warehouse_details['created']}"
)

# Print the final string
print(output)

- Description: Associations between social network posts and narrative types
- Compute kind: LangChain
- Is partitioned: True
- Table type: BASE TABLE
- Table schema: narratives
- Created: 2024-12-12T18:46:06.324000+00:00

import json
from damn_tool.metrics import asset_metrics

result = asset_metrics('narratives/post_narrative_associations', orchestrator='dagster', data_warehouse='bigquery', configs_dir="../.damn/")
data = json.loads(result)

# Extract relevant metrics
orchestrator_metrics = data["metrics"]["From orchestrator"]
dw_metrics = data["metrics"]["From data warehouse"]

# Combine metrics into a single string
output = (
    f"- Row count: {dw_metrics['row_count']}\n"
    f"- Size: {dw_metrics['bytes']}\n"
    f"- Last run id: {orchestrator_metrics['run_id']}\n"
    f"- Last run status: {orchestrator_metrics['status']}\n"
    f"- Last start time: {orchestrator_metrics['start_time']}\n"
    f"- Last end time: {orchestrator_metrics['end_time']}\n"
    f"- Number of partitions: {orchestrator_metrics['num_partitions']}\n"
    f"- Number of partitions materialized: {orchestrator_metrics['num_materialized']}\n"
    f"- Number of failed partitions: {orchestrator_metrics['num_failed']}"
)

# Print the final string
print(output)

- Row count: 688
- Size: 366.30 KB
- Last run id: 0346fbc5-54f5-46a1-8e7a-18299ef93004
- Last run status: SUCCESS
- Last start time: 2024-12-24 07:48:11
- Last end time: 2024-12-24 07:49:58
- Number of partitions: 758
- Number of partitions materialized: 65
- Number of failed partitions: 0

from google.cloud import bigquery
import pyarrow.feather as feather

# Construct a BigQuery client object.
client = bigquery.Client()

query = """
    select * from `dev_narratives.post_narrative_associations`
    where discourse_type != "N/A"
    order by partition_time desc
    limit 5"""

# Make an API request.
query_job = client.query(query)

# Wait for the job to complete.
post_narrative_associations_df = query_job.result().to_dataframe()

# Write the DataFrame to a Feather file
feather_file = "data/post_narrative_associations.feather"
feather.write_feather(post_narrative_associations_df, feather_file)

# Pass the file path to the global namespace
globals()['post_narrative_associations_feather'] = feather_file

library(arrow)

# Read the Feather file
feather_file <- reticulate::py$post_narrative_associations_feather

# Read the Feather file
post_narrative_associations_df <- read_feather(feather_file)

# Display the table
kable(
    post_narrative_associations_df,
    format = "html",    # Ensures better rendering in Quarto
    escape = TRUE   
)