Homework 5.1

.bash_history

@@ -0,0 +1,5 @@
+streamlit run app.py
+streamlit run app.py
+streamlit run app.py
+streamlit run app.py
+streamlit run app.py

.cache/Microsoft/DeveloperTools/deviceid

@@ -0,0 +1 @@
+a5c936e7-e0c1-4067-98d1-c3fa3de57425

.config/code-server/config.yaml

@@ -0,0 +1,4 @@
+bind-addr: 127.0.0.1:8080
+auth: password
+password: 903bae018fa9e47b8195dac4
+cert: false

.local/share/code-server/CachedProfilesData/__default__profile__/extensions.user.cache

@@ -0,0 +1 @@
+{"input":{"location":{"$mid":1,"fsPath":"/home/coder/.local/share/code-server/extensions/extensions.json","external":"file:///home/coder/.local/share/code-server/extensions/extensions.json","path":"/home/coder/.local/share/code-server/extensions/extensions.json","scheme":"file"},"mtime":1731806263514,"profile":true,"profileScanOptions":{"bailOutWhenFileNotFound":true},"type":1,"excludeObsolete":true,"validate":true,"productVersion":"1.91.1","productDate":"2024-07-15T18:41:47.410Z","productCommit":"1962f48b7f71772dc2c060dbaa5a6b4c0792a549","devMode":false,"language":"en","translations":{}},"result":[]}

.local/share/code-server/User/History/450b0aa/0rFy.py

@@ -0,0 +1,75 @@
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load the dataset
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Convert 'Original Issue Date' to datetime and dropping rows with missing data
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Count the number of licenses for each License Type and get top 10
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+top_10_license_types = license_type_counts.head(10)
+st.header("1. Top 10 License Types by Frequency")
+
+# Bar chart for the top 10 license types
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+st.altair_chart(bar_chart, use_container_width=True)
+
+# Write-Up for first plot
+st.markdown("""
+This bar chart highlights the top 10 most frequent license types in the dataset. The x-axis represents the count of each license type, while the y-axis shows the name of the license type. 
+The bars are color-coded to differentiate between the license types. This makes it easy for users to visually distinguish between each category. The chart is sorted in descending order of the license count.
+
+I started by creating a bar chart for all license types, but the chart was difficult to read because many types had very low frequency, making the visualization cluttered. 
+To improve this, I focused on the top 10 most frequent license types, which allowed for a clearer and more insightful view of the most prevalent licenses in the dataset. 
+Since some license names were long, I made sure that the full text is visible when you hover on the bar chart.""")
+
+# Convert 'Expiration Date' to datetime and extract the year
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("4. Trend of Licenses Expiring Over Time")
+
+# Create trend line (line chart) with circle marks at data points
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine line and points
+final_chart = line_chart + points
+
+st.altair_chart(final_chart, use_container_width=True)
+
+# Markdown Write-Up for the trend line chart
+st.markdown("""
+This line chart shows the trend of licenses expiring over time, highlighting variations in license expirations. The x-axis represents the expiration year, while the y-axis shows the number of licenses expiring.
+The line shows the overall trend, with circles marking individual data points for better visibility. Tooltips provide more details when hovering.
+
+I chose a trend line because it clearly shows how the number of licenses expiring changes over time. 
+By plotting the data in this way, I can easily spot patterns or spikes in expiration rates. 
+The trend line gives a quick overview of the overall trend, while the circles on the data points highlight key years with significant changes.
+If I had more time, I would break down the expiration data further by month or quarter to detect more granular patterns.
+""")

.local/share/code-server/User/History/450b0aa/2sco.py

@@ -0,0 +1,73 @@
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load the dataset
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Convert 'Original Issue Date' to datetime and dropping rows with missing data
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Count the number of licenses for each License Type and get top 10
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+top_10_license_types = license_type_counts.head(10)
+st.header("1. Top 10 License Types by Frequency")
+
+# Bar chart for the top 10 license types
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+st.altair_chart(bar_chart, use_container_width=True)
+
+# Write-Up for first plot
+st.markdown("""
+This bar chart highlights the top 10 most frequent license types in the dataset, allowing us to easily identify which types of licenses are the most prevalent.
+
+**Design Choices**: The x-axis represents the count of each license type, while the y-axis shows the name of the license type. The bars are color-coded to differentiate between the license types, and tooltips are included for better interaction. The chart is sorted in descending order of the license count.
+
+**Improvements**: If I had more time, I would add more granular details about the licenses or break down the data further by state or city for more localized insights.
+""")
+
+# Convert 'Expiration Date' to datetime and extract the year
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("4. Trend of Licenses Expiring Over Time")
+
+# Create trend line (line chart) with circle marks at data points
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine line and points
+final_chart = line_chart + points
+
+st.altair_chart(final_chart, use_container_width=True)
+
+# Markdown Write-Up for the trend line chart
+st.markdown("""
+**Highlights**: This line chart shows the trend of licenses expiring over time, highlighting seasonal or yearly variations in license expirations.
+
+**Design Choices**: The x-axis represents the expiration year, while the y-axis shows the number of licenses expiring. The line shows the overall trend, with circles marking individual data points for better visibility. Tooltips provide more details when hovering.
+
+**Improvements**: If I had more time, I would break down the expiration data further by month or quarter to detect more granular patterns.
+""")

.local/share/code-server/User/History/450b0aa/2wHf.py

@@ -0,0 +1,74 @@
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load the dataset
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Convert 'Original Issue Date' to datetime and dropping rows with missing data
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Count the number of licenses for each License Type and get top 10
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+top_10_license_types = license_type_counts.head(10)
+st.header("1. Top 10 License Types by Frequency")
+
+# Create bar chart for the top 10 license types
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+
+st.altair_chart(bar_chart, use_container_width=True)
+
+# Markdown Write-Up for the bar chart
+st.markdown("""
+**Highlights**: This bar chart highlights the top 10 most frequent license types in the dataset, allowing us to easily identify which types of licenses are the most prevalent.
+
+**Design Choices**: The x-axis represents the count of each license type, while the y-axis shows the name of the license type. The bars are color-coded to differentiate between the license types, and tooltips are included for better interaction. The chart is sorted in descending order of the license count.
+
+**Improvements**: If I had more time, I would add more granular details about the licenses or break down the data further by state or city for more localized insights.
+""")
+
+# Convert 'Expiration Date' to datetime and extract the year
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("4. Trend of Licenses Expiring Over Time")
+
+# Create trend line (line chart) with circle marks at data points
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine line and points
+final_chart = line_chart + points
+
+st.altair_chart(final_chart, use_container_width=True)
+
+# Markdown Write-Up for the trend line chart
+st.markdown("""
+**Highlights**: This line chart shows the trend of licenses expiring over time, highlighting seasonal or yearly variations in license expirations.
+
+**Design Choices**: The x-axis represents the expiration year, while the y-axis shows the number of licenses expiring. The line shows the overall trend, with circles marking individual data points for better visibility. Tooltips provide more details when hovering.
+
+**Improvements**: If I had more time, I would break down the expiration data further by month or quarter to detect more granular patterns.
+""")

.local/share/code-server/User/History/450b0aa/4TtO.py

@@ -0,0 +1,73 @@
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load the dataset
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Convert 'Original Issue Date' to datetime and dropping rows with missing data
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Count the number of licenses for each License Type and get top 10
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+top_10_license_types = license_type_counts.head(10)
+st.header("1. Top 10 License Types by Frequency")
+
+# Bar chart for the top 10 license types
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+st.altair_chart(bar_chart, use_container_width=True)
+
+# Write-Up for first plot
+st.markdown("""
+This bar chart highlights the top 10 most frequent license types in the dataset. allowing us to easily identify which types of licenses are the most prevalent.
+
+**Design Choices**: The x-axis represents the count of each license type, while the y-axis shows the name of the license type. The bars are color-coded to differentiate between the license types, and tooltips are included for better interaction. The chart is sorted in descending order of the license count.
+
+**Improvements**: If I had more time, I would add more granular details about the licenses or break down the data further by state or city for more localized insights.
+""")
+
+# Convert 'Expiration Date' to datetime and extract the year
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("4. Trend of Licenses Expiring Over Time")
+
+# Create trend line (line chart) with circle marks at data points
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine line and points
+final_chart = line_chart + points
+
+st.altair_chart(final_chart, use_container_width=True)
+
+# Markdown Write-Up for the trend line chart
+st.markdown("""
+**Highlights**: This line chart shows the trend of licenses expiring over time, highlighting seasonal or yearly variations in license expirations.
+
+**Design Choices**: The x-axis represents the expiration year, while the y-axis shows the number of licenses expiring. The line shows the overall trend, with circles marking individual data points for better visibility. Tooltips provide more details when hovering.
+
+**Improvements**: If I had more time, I would break down the expiration data further by month or quarter to detect more granular patterns.
+""")

.local/share/code-server/User/History/450b0aa/53Ql.py

@@ -0,0 +1,75 @@
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load the dataset
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Convert 'Original Issue Date' to datetime and dropping rows with missing data
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Count the number of licenses for each License Type and get top 10
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+top_10_license_types = license_type_counts.head(10)
+st.header("1. Top 10 License Types by Frequency")
+
+# Bar chart for the top 10 license types
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+st.altair_chart(bar_chart, use_container_width=True)
+
+# Write-Up for first plot
+st.markdown("""
+This bar chart highlights the top 10 most frequent license types in the dataset. The x-axis represents the count of each license type, while the y-axis shows the name of the license type. 
+The bars are color-coded to differentiate between the license types. This makes it easy for users to visually distinguish between each category. The chart is sorted in descending order of the license count.
+
+I started by creating a bar chart for all license types, but the chart was difficult to read because many types had very low frequency. 
+To improve this, I focused on the top 10 most frequent license types. 
+Some license names were long, so I made sure that full text is visible when you hover on the bars. 
+If I had more time, I would like to find a way to make the column names more readable on the y-axis and include all license types without making the visualization too cluttered""")
+
+# Convert 'Expiration Date' to datetime and extract the year
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("2. Trend of Licenses Expiring Over Time")
+
+# Create trend line (line chart) with circle marks at data points
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine line and points
+final_chart = line_chart + points
+
+st.altair_chart(final_chart, use_container_width=True)
+
+# Markdown Write-Up for the trend line chart
+st.markdown("""
+This line chart shows the trend of licenses expiring over time, highlighting variations in license expirations. The x-axis represents the expiration year, while the y-axis shows the number of licenses expiring.
+The line shows the overall trend, with circles marking individual data points for better visibility. Tooltips provide more details when hovering.
+
+I chose a trend line because it clearly shows how the number of licenses expiring changes over time. 
+By plotting the data in this way, I can easily spot patterns or spikes in expiration rates. 
+The trend line gives a quick overview of the overall trend, while the circles on the data points highlight key years with significant changes.
+If I had more time, I would break down the expiration data further by month or quarter to detect more granular patterns and find a way to make it all of it more organized""")

.local/share/code-server/User/History/450b0aa/53ry.py

@@ -0,0 +1,75 @@
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load the dataset
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Convert 'Original Issue Date' to datetime and dropping rows with missing data
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Count the number of licenses for each License Type and get top 10
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+top_10_license_types = license_type_counts.head(10)
+st.header("1. Top 10 License Types by Frequency")
+
+# Bar chart for the top 10 license types
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+st.altair_chart(bar_chart, use_container_width=True)
+
+# Write-Up for first plot
+st.markdown("""
+This bar chart highlights the top 10 most frequent license types in the dataset. The x-axis represents the count of each license type, while the y-axis shows the name of the license type. 
+The bars are color-coded to differentiate between the license types. This makes it easy for users to visually distinguish between each category. The chart is sorted in descending order of the license count.
+
+I started by creating a bar chart for all license types, but the chart was difficult to read because many types had very low frequency. 
+To improve this, I focused on the top 10 most frequent license types, which allowed for a clearer and more insightful view of the most prevalent licenses in the dataset. 
+Since some license names were long, I made sure that the full text is visible when you hover on the bar chart. 
+If I had more time, I would like to find a way to make the column names more readable on the y-axis and include all license types without making the visualization too cluttered""")
+
+# Convert 'Expiration Date' to datetime and extract the year
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("2. Trend of Licenses Expiring Over Time")
+
+# Create trend line (line chart) with circle marks at data points
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine line and points
+final_chart = line_chart + points
+
+st.altair_chart(final_chart, use_container_width=True)
+
+# Markdown Write-Up for the trend line chart
+st.markdown("""
+This line chart shows the trend of licenses expiring over time, highlighting variations in license expirations. The x-axis represents the expiration year, while the y-axis shows the number of licenses expiring.
+The line shows the overall trend, with circles marking individual data points for better visibility. Tooltips provide more details when hovering.
+
+I chose a trend line because it clearly shows how the number of licenses expiring changes over time. 
+By plotting the data in this way, I can easily spot patterns or spikes in expiration rates. 
+The trend line gives a quick overview of the overall trend, while the circles on the data points highlight key years with significant changes.
+If I had more time, I would break down the expiration data further by month or quarter to detect more granular patterns and find a way to make it all of it more organized""")

.local/share/code-server/User/History/450b0aa/8qMH.py

@@ -0,0 +1,74 @@
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load the dataset
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Convert 'Original Issue Date' to datetime and dropping rows with missing data
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Count the number of licenses for each License Type and get top 10
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+top_10_license_types = license_type_counts.head(10)
+st.header("1. Top 10 License Types by Frequency")
+
+# Bar chart for the top 10 license types
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+st.altair_chart(bar_chart, use_container_width=True)
+
+# Write-Up for first plot
+st.markdown("""
+This bar chart highlights the top 10 most frequent license types in the dataset. The x-axis represents the count of each license type, while the y-axis shows the name of the license type. 
+The bars are color-coded to differentiate between the license types. This makes it easy for users to visually distinguish between each category. The chart is sorted in descending order of the license count.
+
+I started by creating a bar chart for all license types, but the chart was difficult to read because many types had very low frequency, making the visualization cluttered. 
+To improve this, I focused on the top 10 most frequent license types, which allowed for a clearer and more insightful view of the most prevalent licenses in the dataset. 
+Since some license names were long, I made sure that the full text is visible when you hover on the bar chart.""")
+
+# Convert 'Expiration Date' to datetime and extract the year
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("4. Trend of Licenses Expiring Over Time")
+
+# Create trend line (line chart) with circle marks at data points
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine line and points
+final_chart = line_chart + points
+
+st.altair_chart(final_chart, use_container_width=True)
+
+# Markdown Write-Up for the trend line chart
+st.markdown("""
+This line chart shows the trend of licenses expiring over time, highlighting variations in license expirations. The x-axis represents the expiration year, while the y-axis shows the number of licenses expiring.
+The line shows the overall trend, with circles marking individual data points for better visibility. Tooltips provide more details when hovering.
+
+I chose a trend line because it clearly shows how the number of licenses expiring changes over time. 
+By plotting the data in this way, I can easily spot patterns or spikes in expiration rates. 
+The trend line gives a quick overview of the overall trend, while the circles on the data points highlight key years with significant changes.
+If I had more time, I would break down the expiration data further by month or quarter to detect more granular patterns and find a way to make it all of it more organized""")

.local/share/code-server/User/History/450b0aa/8wPI.py

@@ -0,0 +1,73 @@
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load the dataset
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Convert 'Original Issue Date' to datetime and dropping rows with missing data
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Count the number of licenses for each License Type and get top 10
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+top_10_license_types = license_type_counts.head(10)
+st.header("1. Top 10 License Types by Frequency")
+
+# Bar chart for the top 10 license types
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+st.altair_chart(bar_chart, use_container_width=True)
+
+# Write-Up for first plot
+st.markdown("""
+This bar chart highlights the top 10 most frequent license types in the dataset. The x-axis represents the count of each license type, while the y-axis shows the name of the license type. 
+The bars are color-coded to differentiate between the license types. This makes it easy for users to visually distinguish between each category. The chart is sorted in descending order of the license count.
+
+I started by creating a bar chart for all license types, but the chart was difficult to read because many types had very low frequency, making the visualization cluttered. 
+To improve this, I focused on the top 10 most frequent license types, which allowed for a clearer and more insightful view of the most prevalent licenses in the dataset. 
+Since some license names were long, I made sure that the full text is visible when you hover on the bar chart.""")
+
+# Convert 'Expiration Date' to datetime and extract the year
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("4. Trend of Licenses Expiring Over Time")
+
+# Create trend line (line chart) with circle marks at data points
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine line and points
+final_chart = line_chart + points
+
+st.altair_chart(final_chart, use_container_width=True)
+
+# Markdown Write-Up for the trend line chart
+st.markdown("""
+This line chart shows the trend of licenses expiring over time, highlighting seasonal or yearly variations in license expirations.
+
+**Design Choices**: The x-axis represents the expiration year, while the y-axis shows the number of licenses expiring. The line shows the overall trend, with circles marking individual data points for better visibility. Tooltips provide more details when hovering.
+
+**Improvements**: If I had more time, I would break down the expiration data further by month or quarter to detect more granular patterns.
+""")

.local/share/code-server/User/History/450b0aa/AIA9.py

@@ -0,0 +1,208 @@
+# put streamlit code here as needed
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+#import the data
+#url = "https://raw.githubusercontent.com/UIUC-iSchool-DataViz/is445_data/main/ufo-scrubbed-geocoded-time-standardized-00.csv"
+#df = pd.read_csv(url)
+#df.sum().isnull()
+
+
+
+# #Fill the missing data with Unknown
+# df['County'].fillna('Not available', inplace=True)
+# df['Rep Full Name'].fillna('Not available', inplace=True)
+# df['Year Constructed'].fillna(df['Year Constructed'].median(), inplace=True)
+# df['Senator Full Name'].fillna('Unknown', inplace=True)
+# df['Usage Description 2'].fillna(df['Usage Description 2'].mode()[0], inplace=True)
+# df['Usage Description 3'].fillna(df['Usage Description 3'].mode()[0], inplace=True)
+# df['Address'].fillna('Not available', inplace=True)
+# df['Congressional Full Name'].fillna('Unknown', inplace=True)
+
+# #Page Title
+# st.markdown("<h1 style='text-align: center;'>Homework 5.1</h1>", unsafe_allow_html=True)
+
+# st.subheader("Analyzing the Building Inventory Dataset")
+# #Visualization 1
+# st.markdown("<h4 style='text-decoration: underline;'>Visualization 1</h4>", unsafe_allow_html=True)
+
+# df_filtered = df.dropna(subset=['Bldg Status', 'Year Constructed'])
+# df_filtered['Year Constructed'] = pd.to_numeric(df_filtered['Year Constructed'], errors='coerce')
+# df_filtered = df_filtered[(df_filtered['Year Constructed'] >= 1600) & (df_filtered['Year Constructed'] <= 2100)]
+
+
+# line_chart = alt.Chart(df_filtered).mark_line(point=True).encode(
+#     x=alt.X('Year Constructed:Q', title='Year Constructed'),
+#     y=alt.Y('count()', title='Number of Buildings'),
+#     color=alt.Color('Bldg Status:N', title='Building Status'),
+#     tooltip=['Year Constructed', 'count()', 'Bldg Status']
+# ).properties(
+#     width=700,
+#     height=400,
+#     title="Trend of Building Construction by Status"
+# )
+# st.altair_chart(line_chart, use_container_width=True)
+# st.write("""
+# This line chart highlights the trend in the number of buildings constructed over time, 
+# categorized by their building status (e.g., whether they are currently in use or not). 
+# The x-axis represents the 'Year Constructed' and the y-axis represents the count of buildings. 
+# The color encoding separates the buildings by their 'Bldg Status' 
+# I used a line plot with points to clearly indicate the number of buildings per year, 
+# which helps in identifying trends and peaks. Another reason is that line chart is ideal for 
+# visualizing time-series data. The colors are chosen to differentiate the building statuses 
+# effectively. 
+
+# If I had more time, I would consider adding labels to the data points for clarity and 
+# perhaps break down the data further by usage description or location for a more detailed analysis.
+# Probably adding hover effects could display additional information, such as the exact count of 
+# buildings and their status, when hovering over each data point. This would allow users to gain 
+# deeper insights without cluttering the chart. I would also include filtering options so users 
+# could select specific building statuses or even a range of years to focus on, which would make
+# the analysis more targeted. 
+# """)
+
+
+# # Visualization 2
+# st.markdown("<h4 style='text-decoration: underline;'>Visualization 2</h4>", unsafe_allow_html=True)
+# county_agency_data = df.dropna(subset=['County', 'Agency Name'])
+# county_agency_count = county_agency_data.groupby('County')['Agency Name'].nunique().reset_index()
+# county_agency_count.rename(columns={'Agency Name': 'Unique Agencies'}, inplace=True)
+
+# county_agency_chart = alt.Chart(county_agency_count).mark_bar().encode(
+#     x=alt.X('County:N', sort='-y', title="County"),
+#     y=alt.Y('Unique Agencies:Q', title="Number of Agencies"),
+#     color=alt.Color('Unique Agencies:Q', scale=alt.Scale(scheme='viridis')),
+#     tooltip=['County:N', 'Unique Agencies:Q']
+# ).properties(
+#     width=700,
+#     height=400,
+#     title="Unique Agencies in Each County"
+# )
+# st.altair_chart(county_agency_chart, use_container_width=True)
+
+# st.write("""
+# This bar chart highlights the number of unique agencies operating in each county. 
+# The x-axis represents the 'County' and the y-axis represents the 'Number of Unique Agencies' 
+# I used a bar chart as it allows for easy comparison between counties based on the number of
+# agencies, and sorting the counties by agency count makes it easier to identify areas with 
+# more agencies. The color scale uses a 'viridis' color scheme, to show how the number of agencies
+# differs accross counties. 
+
+# If I had more time, I would consider adding interactivity, like a filter for 'Building Status', so that users can
+# focus on specific statuses, such as buildings that are still in progress or abandoned for each county. 
+# I would also implement a slider for 'Year Constructed' to allow users to focus on specific time periods, 
+# enabling them to analyze trends and compare the distribution of agencies by different time periods. 
+# I would also consider adding a search function so that users can look for specific counties 
+# or agency types.
+# """)
+# Load State GeoJSON for Map (example if supported)
+# Visualization: Licenses by State
+
+
+# Load Dataset
+@st.cache
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Handle Missing Values for Visualizations
+# 1. Remove rows with missing `Original Issue Date`
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Title
+st.title("Licenses Dataset Visualizations")
+st.markdown("This app presents three visualizations of the licenses dataset.")
+
+# Visualization 1: Bar Chart (Distribution of Licenses by Type)
+st.header("1. Distribution of Licenses by Type")
+license_count = df['License Type'].value_counts().reset_index()
+license_count.columns = ['License Type', 'Count']
+
+bar_chart = alt.Chart(license_count).mark_bar().encode(
+    x=alt.X('Count:Q', title='Number of Licenses'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type'),
+    color=alt.Color('License Type:N', legend=None)
+).properties(title="Number of Licenses by Type")
+
+st.altair_chart(bar_chart, use_container_width=True)
+
+st.markdown("""
+**Highlights**: This bar chart shows the distribution of licenses by type.
+**Design Choices**: A horizontal bar chart is used for better readability of license types.
+""")
+
+# Visualization 2: Line Chart (Trend of Licenses Over Time)
+st.header("2. Trend of Licenses Over Time")
+time_data = df_time.groupby(df_time['Original Issue Date'].dt.year).size().reset_index(name='Count')
+time_data.columns = ['Year', 'Count']
+
+line_chart = alt.Chart(time_data).mark_line(point=True).encode(
+    x=alt.X('Year:O', title='Year'),
+    y=alt.Y('Count:Q', title='Number of Licenses'),
+    color=alt.value('blue')
+).properties(title="Trend of Licenses Issued Over Years")
+
+st.altair_chart(line_chart, use_container_width=True)
+
+st.markdown("""
+**Highlights**: This line chart shows the trend of license issuances over time.
+**Design Choices**: Points are added to highlight specific data points, and the color blue is chosen for simplicity.
+""")
+
+
+# Count the number of licenses for each License Type and sort by count
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+
+# Get the top 10 License Types
+top_10_license_types = license_type_counts.head(10)
+
+# Create the bar chart
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+).properties(
+    title='Top 10 License Types by Frequency'
+)
+
+# Show the chart in the Streamlit app
+st.altair_chart(bar_chart, use_container_width=True)
+
+
+# Convert the Expiration Date to datetime (if not already)
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+
+# Extract the year from Expiration Date
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+
+# Create the trend line (line chart) with interactive data points (circle marks)
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']  # Tooltip for interactivity
+).properties(
+    title='Trend Line for Licenses Expiring Over Time'
+)
+
+# Add circle marks at data points
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine the line and point marks
+final_chart = line_chart + points
+
+# Show the chart in the Streamlit app
+st.altair_chart(final_chart, use_container_width=True)
+

.local/share/code-server/User/History/450b0aa/BA55.py

@@ -0,0 +1,73 @@
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load the dataset
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Convert 'Original Issue Date' to datetime and dropping rows with missing data
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Count the number of licenses for each License Type and get top 10
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+top_10_license_types = license_type_counts.head(10)
+st.header("1. Top 10 License Types by Frequency")
+
+# Bar chart for the top 10 license types
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+st.altair_chart(bar_chart, use_container_width=True)
+
+# Write-Up for first plot
+st.markdown("""
+**Highlights**: This bar chart highlights the top 10 most frequent license types in the dataset, allowing us to easily identify which types of licenses are the most prevalent.
+
+**Design Choices**: The x-axis represents the count of each license type, while the y-axis shows the name of the license type. The bars are color-coded to differentiate between the license types, and tooltips are included for better interaction. The chart is sorted in descending order of the license count.
+
+**Improvements**: If I had more time, I would add more granular details about the licenses or break down the data further by state or city for more localized insights.
+""")
+
+# Convert 'Expiration Date' to datetime and extract the year
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("4. Trend of Licenses Expiring Over Time")
+
+# Create trend line (line chart) with circle marks at data points
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine line and points
+final_chart = line_chart + points
+
+st.altair_chart(final_chart, use_container_width=True)
+
+# Markdown Write-Up for the trend line chart
+st.markdown("""
+**Highlights**: This line chart shows the trend of licenses expiring over time, highlighting seasonal or yearly variations in license expirations.
+
+**Design Choices**: The x-axis represents the expiration year, while the y-axis shows the number of licenses expiring. The line shows the overall trend, with circles marking individual data points for better visibility. Tooltips provide more details when hovering.
+
+**Improvements**: If I had more time, I would break down the expiration data further by month or quarter to detect more granular patterns.
+""")

.local/share/code-server/User/History/450b0aa/BvGZ.py

@@ -0,0 +1,260 @@
+# put streamlit code here as needed
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+#import the data
+#url = "https://raw.githubusercontent.com/UIUC-iSchool-DataViz/is445_data/main/ufo-scrubbed-geocoded-time-standardized-00.csv"
+#df = pd.read_csv(url)
+#df.sum().isnull()
+
+
+
+# #Fill the missing data with Unknown
+# df['County'].fillna('Not available', inplace=True)
+# df['Rep Full Name'].fillna('Not available', inplace=True)
+# df['Year Constructed'].fillna(df['Year Constructed'].median(), inplace=True)
+# df['Senator Full Name'].fillna('Unknown', inplace=True)
+# df['Usage Description 2'].fillna(df['Usage Description 2'].mode()[0], inplace=True)
+# df['Usage Description 3'].fillna(df['Usage Description 3'].mode()[0], inplace=True)
+# df['Address'].fillna('Not available', inplace=True)
+# df['Congressional Full Name'].fillna('Unknown', inplace=True)
+
+# #Page Title
+# st.markdown("<h1 style='text-align: center;'>Homework 5.1</h1>", unsafe_allow_html=True)
+
+# st.subheader("Analyzing the Building Inventory Dataset")
+# #Visualization 1
+# st.markdown("<h4 style='text-decoration: underline;'>Visualization 1</h4>", unsafe_allow_html=True)
+
+# df_filtered = df.dropna(subset=['Bldg Status', 'Year Constructed'])
+# df_filtered['Year Constructed'] = pd.to_numeric(df_filtered['Year Constructed'], errors='coerce')
+# df_filtered = df_filtered[(df_filtered['Year Constructed'] >= 1600) & (df_filtered['Year Constructed'] <= 2100)]
+
+
+# line_chart = alt.Chart(df_filtered).mark_line(point=True).encode(
+#     x=alt.X('Year Constructed:Q', title='Year Constructed'),
+#     y=alt.Y('count()', title='Number of Buildings'),
+#     color=alt.Color('Bldg Status:N', title='Building Status'),
+#     tooltip=['Year Constructed', 'count()', 'Bldg Status']
+# ).properties(
+#     width=700,
+#     height=400,
+#     title="Trend of Building Construction by Status"
+# )
+# st.altair_chart(line_chart, use_container_width=True)
+# st.write("""
+# This line chart highlights the trend in the number of buildings constructed over time, 
+# categorized by their building status (e.g., whether they are currently in use or not). 
+# The x-axis represents the 'Year Constructed' and the y-axis represents the count of buildings. 
+# The color encoding separates the buildings by their 'Bldg Status' 
+# I used a line plot with points to clearly indicate the number of buildings per year, 
+# which helps in identifying trends and peaks. Another reason is that line chart is ideal for 
+# visualizing time-series data. The colors are chosen to differentiate the building statuses 
+# effectively. 
+
+# If I had more time, I would consider adding labels to the data points for clarity and 
+# perhaps break down the data further by usage description or location for a more detailed analysis.
+# Probably adding hover effects could display additional information, such as the exact count of 
+# buildings and their status, when hovering over each data point. This would allow users to gain 
+# deeper insights without cluttering the chart. I would also include filtering options so users 
+# could select specific building statuses or even a range of years to focus on, which would make
+# the analysis more targeted. 
+# """)
+
+
+# # Visualization 2
+# st.markdown("<h4 style='text-decoration: underline;'>Visualization 2</h4>", unsafe_allow_html=True)
+# county_agency_data = df.dropna(subset=['County', 'Agency Name'])
+# county_agency_count = county_agency_data.groupby('County')['Agency Name'].nunique().reset_index()
+# county_agency_count.rename(columns={'Agency Name': 'Unique Agencies'}, inplace=True)
+
+# county_agency_chart = alt.Chart(county_agency_count).mark_bar().encode(
+#     x=alt.X('County:N', sort='-y', title="County"),
+#     y=alt.Y('Unique Agencies:Q', title="Number of Agencies"),
+#     color=alt.Color('Unique Agencies:Q', scale=alt.Scale(scheme='viridis')),
+#     tooltip=['County:N', 'Unique Agencies:Q']
+# ).properties(
+#     width=700,
+#     height=400,
+#     title="Unique Agencies in Each County"
+# )
+# st.altair_chart(county_agency_chart, use_container_width=True)
+
+# st.write("""
+# This bar chart highlights the number of unique agencies operating in each county. 
+# The x-axis represents the 'County' and the y-axis represents the 'Number of Unique Agencies' 
+# I used a bar chart as it allows for easy comparison between counties based on the number of
+# agencies, and sorting the counties by agency count makes it easier to identify areas with 
+# more agencies. The color scale uses a 'viridis' color scheme, to show how the number of agencies
+# differs accross counties. 
+
+# If I had more time, I would consider adding interactivity, like a filter for 'Building Status', so that users can
+# focus on specific statuses, such as buildings that are still in progress or abandoned for each county. 
+# I would also implement a slider for 'Year Constructed' to allow users to focus on specific time periods, 
+# enabling them to analyze trends and compare the distribution of agencies by different time periods. 
+# I would also consider adding a search function so that users can look for specific counties 
+# or agency types.
+# """)
+# Load State GeoJSON for Map (example if supported)
+# Visualization: Licenses by State
+
+
+# Load Dataset
+@st.cache
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Handle Missing Values for Visualizations
+# 1. Remove rows with missing `Original Issue Date`
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Title
+st.title("Licenses Dataset Visualizations")
+st.markdown("This app presents three visualizations of the licenses dataset.")
+
+# Visualization 1: Bar Chart (Distribution of Licenses by Type)
+st.header("1. Distribution of Licenses by Type")
+license_count = df['License Type'].value_counts().reset_index()
+license_count.columns = ['License Type', 'Count']
+
+bar_chart = alt.Chart(license_count).mark_bar().encode(
+    x=alt.X('Count:Q', title='Number of Licenses'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type'),
+    color=alt.Color('License Type:N', legend=None)
+).properties(title="Number of Licenses by Type")
+
+st.altair_chart(bar_chart, use_container_width=True)
+
+st.markdown("""
+**Highlights**: This bar chart shows the distribution of licenses by type.
+**Design Choices**: A horizontal bar chart is used for better readability of license types.
+""")
+
+# Visualization 2: Line Chart (Trend of Licenses Over Time)
+st.header("2. Trend of Licenses Over Time")
+time_data = df_time.groupby(df_time['Original Issue Date'].dt.year).size().reset_index(name='Count')
+time_data.columns = ['Year', 'Count']
+
+line_chart = alt.Chart(time_data).mark_line(point=True).encode(
+    x=alt.X('Year:O', title='Year'),
+    y=alt.Y('Count:Q', title='Number of Licenses'),
+    color=alt.value('blue')
+).properties(title="Trend of Licenses Issued Over Years")
+
+st.altair_chart(line_chart, use_container_width=True)
+
+st.markdown("""
+**Highlights**: This line chart shows the trend of license issuances over time.
+**Design Choices**: Points are added to highlight specific data points, and the color blue is chosen for simplicity.
+""")
+
+
+# Count the number of licenses for each License Type and sort by count
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+
+# Get the top 10 License Types
+top_10_license_types = license_type_counts.head(10)
+
+# Create the bar chart
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+).properties(
+    title='Top 10 License Types by Frequency'
+)
+
+# Show the chart in the Streamlit app
+st.altair_chart(bar_chart, use_container_width=True)
+
+# Convert the Expiration Date to datetime (if not already)
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+
+# Extract the month and year from Expiration Date
+df['Expiration Year'] = df['Expiration Date'].dt.year
+df['Expiration Month'] = df['Expiration Date'].dt.month
+
+# Group by year and month and count the number of licenses expiring
+expiration_counts = df.groupby(['Expiration Year', 'Expiration Month']).size().reset_index(name='License Count')
+
+# Convert the Expiration Date to datetime (if not already)
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+
+# Extract the year from Expiration Date
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+
+# Create the trend line (line chart)
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+).properties(
+    title='Trend Line for License Expirations Over Time'
+)
+
+# Show the chart in the Streamlit app
+st.altair_chart(line_chart, use_container_width=True)
+# Convert the Expiration Date to datetime (if not already)
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+
+# Extract the year from Expiration Date
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+
+# Create the trend line (line chart)
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+).properties(
+    title='Trend Line for Licenses Expiring Over Time'
+)
+
+# Show the chart in the Streamlit app
+st.altair_chart(line_chart, use_container_width=True)
+
+
+
+# Convert the Expiration Date to datetime (if not already)
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+
+# Extract the year from Expiration Date
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+
+# Create the trend line (line chart) with interactive data points (circle marks)
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']  # Tooltip for interactivity
+).properties(
+    title='Trend Line for Licenses Expiring Over Time'
+).interactive()  # Make the chart interactive
+
+# Add circle marks at data points
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine the line and point marks
+final_chart = line_chart + points
+
+# Show the chart in the Streamlit app
+st.altair_chart(final_chart, use_container_width=True)
+

.local/share/code-server/User/History/450b0aa/C2VD.py

@@ -0,0 +1,73 @@
+# put streamlit code here as needed
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load Dataset
+@st.cache
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+
+
+
+# Count the number of licenses for each License Type and sort by count
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+
+# Get the top 10 License Types
+top_10_license_types = license_type_counts.head(10)
+st.header("3. Top 10 License Types by Frequency")
+# Create the bar chart
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+
+
+# Show the chart in the Streamlit app
+st.altair_chart(bar_chart, use_container_width=True)
+
+st.markdown("""
+**Highlights**: This line chart shows .
+**Design Choices**: Points are added to highlight.
+""")
+
+# Convert the Expiration Date to datetime (if not already)
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+
+# Extract the year from Expiration Date
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("4. Trend of Licenses Expiring Over Time")
+# Create the trend line (line chart) with interactive data points (circle marks)
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']  # Tooltip for interactivity
+)
+
+
+# Add circle marks at data points
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine the line and point marks
+final_chart = line_chart + points
+
+# Show the chart in the Streamlit app
+st.altair_chart(final_chart, use_container_width=True)
+

.local/share/code-server/User/History/450b0aa/Dqul.py

@@ -0,0 +1,73 @@
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load the dataset
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Convert 'Original Issue Date' to datetime and dropping rows with missing data
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Count the number of licenses for each License Type and get top 10
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+top_10_license_types = license_type_counts.head(10)
+st.header("1. Top 10 License Types by Frequency")
+
+# Bar chart for the top 10 license types
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+st.altair_chart(bar_chart, use_container_width=True)
+
+# Write-Up for the bar chart
+st.markdown("""
+**Highlights**: This bar chart highlights the top 10 most frequent license types in the dataset, allowing us to easily identify which types of licenses are the most prevalent.
+
+**Design Choices**: The x-axis represents the count of each license type, while the y-axis shows the name of the license type. The bars are color-coded to differentiate between the license types, and tooltips are included for better interaction. The chart is sorted in descending order of the license count.
+
+**Improvements**: If I had more time, I would add more granular details about the licenses or break down the data further by state or city for more localized insights.
+""")
+
+# Convert 'Expiration Date' to datetime and extract the year
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("4. Trend of Licenses Expiring Over Time")
+
+# Create trend line (line chart) with circle marks at data points
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine line and points
+final_chart = line_chart + points
+
+st.altair_chart(final_chart, use_container_width=True)
+
+# Markdown Write-Up for the trend line chart
+st.markdown("""
+**Highlights**: This line chart shows the trend of licenses expiring over time, highlighting seasonal or yearly variations in license expirations.
+
+**Design Choices**: The x-axis represents the expiration year, while the y-axis shows the number of licenses expiring. The line shows the overall trend, with circles marking individual data points for better visibility. Tooltips provide more details when hovering.
+
+**Improvements**: If I had more time, I would break down the expiration data further by month or quarter to detect more granular patterns.
+""")

.local/share/code-server/User/History/450b0aa/GB0z.py

@@ -0,0 +1,75 @@
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load the dataset
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Convert 'Original Issue Date' to datetime and dropping rows with missing data
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Count the number of licenses for each License Type and get top 10
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+top_10_license_types = license_type_counts.head(10)
+st.header("1. Top 10 License Types by Frequency")
+
+# Bar chart for the top 10 license types
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+st.altair_chart(bar_chart, use_container_width=True)
+
+# Write-Up for first plot
+st.markdown("""
+This bar chart highlights the top 10 most frequent license types in the dataset. The x-axis represents the count of each license type, while the y-axis shows the name of the license type. 
+The bars are color-coded to differentiate between the license types. This makes it easy for users to visually distinguish between each category. The chart is sorted in descending order of the license count.
+
+I started by creating a bar chart for all license types, but the chart was difficult to read because many types had very low frequency, making the visualization cluttered. 
+To improve this, I focused on the top 10 most frequent license types, which allowed for a clearer and more insightful view of the most prevalent licenses in the dataset. 
+Since some license names were long, I made sure that the full text is visible when you hover on the bar chart. 
+If I had more time, I would like to find a way to make the column names more readable and include all license types without making the visualization too cluttered""")
+
+# Convert 'Expiration Date' to datetime and extract the year
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("2. Trend of Licenses Expiring Over Time")
+
+# Create trend line (line chart) with circle marks at data points
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine line and points
+final_chart = line_chart + points
+
+st.altair_chart(final_chart, use_container_width=True)
+
+# Markdown Write-Up for the trend line chart
+st.markdown("""
+This line chart shows the trend of licenses expiring over time, highlighting variations in license expirations. The x-axis represents the expiration year, while the y-axis shows the number of licenses expiring.
+The line shows the overall trend, with circles marking individual data points for better visibility. Tooltips provide more details when hovering.
+
+I chose a trend line because it clearly shows how the number of licenses expiring changes over time. 
+By plotting the data in this way, I can easily spot patterns or spikes in expiration rates. 
+The trend line gives a quick overview of the overall trend, while the circles on the data points highlight key years with significant changes.
+If I had more time, I would break down the expiration data further by month or quarter to detect more granular patterns and find a way to make it all of it more organized""")

.local/share/code-server/User/History/450b0aa/HxIz.py

@@ -0,0 +1,107 @@
+# put streamlit code here as needed
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load Dataset
+@st.cache
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Title
+st.title("Licenses Dataset Visualizations")
+st.markdown("This app presents three visualizations of the licenses dataset.")
+
+# Visualization 1: Bar Chart (Distribution of Licenses by Type)
+st.header("1. Distribution of Licenses by Type")
+license_count = df['License Type'].value_counts().reset_index()
+license_count.columns = ['License Type', 'Count']
+
+bar_chart = alt.Chart(license_count).mark_bar().encode(
+    x=alt.X('Count:Q', title='Number of Licenses'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type'),
+    color=alt.Color('License Type:N', legend=None)
+).properties(title="Number of Licenses by Type")
+
+st.altair_chart(bar_chart, use_container_width=True)
+
+st.markdown("""
+**Highlights**: This bar chart shows the distribution of licenses by type.
+**Design Choices**: A horizontal bar chart is used for better readability of license types.
+""")
+
+# Visualization 2: Line Chart (Trend of Licenses Over Time)
+st.header("2. Trend of Licenses Over Time")
+time_data = df_time.groupby(df_time['Original Issue Date'].dt.year).size().reset_index(name='Count')
+time_data.columns = ['Year', 'Count']
+
+line_chart = alt.Chart(time_data).mark_line(point=True).encode(
+    x=alt.X('Year:O', title='Year'),
+    y=alt.Y('Count:Q', title='Number of Licenses'),
+    color=alt.value('blue')
+).properties(title="Trend of Licenses Issued Over Years")
+
+st.altair_chart(line_chart, use_container_width=True)
+
+st.markdown("""
+**Highlights**: This line chart shows the trend of license issuances over time.
+**Design Choices**: Points are added to highlight specific data points, and the color blue is chosen for simplicity.
+""")
+
+
+# Count the number of licenses for each License Type and sort by count
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+
+# Get the top 10 License Types
+top_10_license_types = license_type_counts.head(10)
+st.header("3. Top 10 License Types by Frequency")
+# Create the bar chart
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+
+
+# Show the chart in the Streamlit app
+st.altair_chart(bar_chart, use_container_width=True)
+
+
+# Convert the Expiration Date to datetime (if not already)
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+
+# Extract the year from Expiration Date
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header(". Top 10 License Types by Frequency")
+# Create the trend line (line chart) with interactive data points (circle marks)
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']  # Tooltip for interactivity
+)
+
+
+# Add circle marks at data points
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine the line and point marks
+final_chart = line_chart + points
+
+# Show the chart in the Streamlit app
+st.altair_chart(final_chart, use_container_width=True)
+

.local/share/code-server/User/History/450b0aa/I3Tc.py

@@ -0,0 +1,108 @@
+# put streamlit code here as needed
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load Dataset
+@st.cache
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Title
+st.title("Licenses Dataset Visualizations")
+st.markdown("This app presents three visualizations of the licenses dataset.")
+
+# Visualization 1: Bar Chart (Distribution of Licenses by Type)
+st.header("1. Distribution of Licenses by Type")
+license_count = df['License Type'].value_counts().reset_index()
+license_count.columns = ['License Type', 'Count']
+
+bar_chart = alt.Chart(license_count).mark_bar().encode(
+    x=alt.X('Count:Q', title='Number of Licenses'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type'),
+    color=alt.Color('License Type:N', legend=None)
+).properties(title="Number of Licenses by Type")
+
+st.altair_chart(bar_chart, use_container_width=True)
+
+st.markdown("""
+**Highlights**: This bar chart shows the distribution of licenses by type.
+**Design Choices**: A horizontal bar chart is used for better readability of license types.
+""")
+
+# Visualization 2: Line Chart (Trend of Licenses Over Time)
+st.header("2. Trend of Licenses Over Time")
+time_data = df_time.groupby(df_time['Original Issue Date'].dt.year).size().reset_index(name='Count')
+time_data.columns = ['Year', 'Count']
+
+line_chart = alt.Chart(time_data).mark_line(point=True).encode(
+    x=alt.X('Year:O', title='Year'),
+    y=alt.Y('Count:Q', title='Number of Licenses'),
+    color=alt.value('blue')
+).properties(title="Trend of Licenses Issued Over Years")
+
+st.altair_chart(line_chart, use_container_width=True)
+
+st.markdown("""
+**Highlights**: This line chart shows the trend of license issuances over time.
+**Design Choices**: Points are added to highlight specific data points, and the color blue is chosen for simplicity.
+""")
+
+
+# Count the number of licenses for each License Type and sort by count
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+
+# Get the top 10 License Types
+top_10_license_types = license_type_counts.head(10)
+
+# Create the bar chart
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+).properties(
+    title='Top 10 License Types by Frequency'
+)
+
+# Show the chart in the Streamlit app
+st.altair_chart(bar_chart, use_container_width=True)
+
+
+# Convert the Expiration Date to datetime (if not already)
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+
+# Extract the year from Expiration Date
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+
+# Create the trend line (line chart) with interactive data points (circle marks)
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']  # Tooltip for interactivity
+)
+)
+
+# Add circle marks at data points
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine the line and point marks
+final_chart = line_chart + points
+
+# Show the chart in the Streamlit app
+st.altair_chart(final_chart, use_container_width=True)
+

.local/share/code-server/User/History/450b0aa/Km75.py

@@ -0,0 +1,75 @@
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load the dataset
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Convert 'Original Issue Date' to datetime and dropping rows with missing data
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Count the number of licenses for each License Type and get top 10
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+top_10_license_types = license_type_counts.head(10)
+st.header("1. Top 10 License Types by Frequency")
+
+# Bar chart for the top 10 license types
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+st.altair_chart(bar_chart, use_container_width=True)
+
+# Write-Up for first plot
+st.markdown("""
+This bar chart highlights the top 10 most frequent license types in the dataset. The x-axis represents the count of each license type, while the y-axis shows the name of the license type. 
+The bars are color-coded to differentiate between the license types. This makes it easy for users to visually distinguish between each category. The chart is sorted in descending order of the license count.
+
+I started by creating a bar chart for all license types, but the chart was difficult to read because many types had very low frequency. 
+To improve this, I focused on the top 10 most frequent license types. 
+Some license names were long, so I made sure that full text is visible when you hover on the bars. 
+If I had more time, I would like to find a way to make the column names more readable on the y-axis and include all license types without making the visualization too cluttered""")
+
+#Secon
+# Converting 'Expiration Date' to datetime 
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("2. Trend of Licenses Expiring Over Time")
+
+# Trend line
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine line and points
+final_chart = line_chart + points
+
+st.altair_chart(final_chart, use_container_width=True)
+
+# Write-Up for second plot
+st.markdown("""
+This line chart shows the trend of licenses expiring over time, highlighting variations in license expirations. The x-axis represents the expiration year, while the y-axis shows the number of licenses expiring.
+The line shows the overall trend, with circles marking individual data points for better visibility. Tooltips provide more details when hovering.
+
+I chose a trend line because it clearly shows how the number of licenses expiring changes over time. 
+By plotting the data in this way, I can easily spot patterns or spikes in expiration rates. 
+The trend line gives a quick overview of the overall trend, while the circles on the data points highlight key years with significant changes.
+If I had more time, I would break down the expiration data further by month or quarter to detect more granular patterns and find a way to make it all of it more organized""")

.local/share/code-server/User/History/450b0aa/O3TC.py

@@ -0,0 +1,260 @@
+# put streamlit code here as needed
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+#import the data
+#url = "https://raw.githubusercontent.com/UIUC-iSchool-DataViz/is445_data/main/ufo-scrubbed-geocoded-time-standardized-00.csv"
+#df = pd.read_csv(url)
+#df.sum().isnull()
+
+
+
+# #Fill the missing data with Unknown
+# df['County'].fillna('Not available', inplace=True)
+# df['Rep Full Name'].fillna('Not available', inplace=True)
+# df['Year Constructed'].fillna(df['Year Constructed'].median(), inplace=True)
+# df['Senator Full Name'].fillna('Unknown', inplace=True)
+# df['Usage Description 2'].fillna(df['Usage Description 2'].mode()[0], inplace=True)
+# df['Usage Description 3'].fillna(df['Usage Description 3'].mode()[0], inplace=True)
+# df['Address'].fillna('Not available', inplace=True)
+# df['Congressional Full Name'].fillna('Unknown', inplace=True)
+
+# #Page Title
+# st.markdown("<h1 style='text-align: center;'>Homework 5.1</h1>", unsafe_allow_html=True)
+
+# st.subheader("Analyzing the Building Inventory Dataset")
+# #Visualization 1
+# st.markdown("<h4 style='text-decoration: underline;'>Visualization 1</h4>", unsafe_allow_html=True)
+
+# df_filtered = df.dropna(subset=['Bldg Status', 'Year Constructed'])
+# df_filtered['Year Constructed'] = pd.to_numeric(df_filtered['Year Constructed'], errors='coerce')
+# df_filtered = df_filtered[(df_filtered['Year Constructed'] >= 1600) & (df_filtered['Year Constructed'] <= 2100)]
+
+
+# line_chart = alt.Chart(df_filtered).mark_line(point=True).encode(
+#     x=alt.X('Year Constructed:Q', title='Year Constructed'),
+#     y=alt.Y('count()', title='Number of Buildings'),
+#     color=alt.Color('Bldg Status:N', title='Building Status'),
+#     tooltip=['Year Constructed', 'count()', 'Bldg Status']
+# ).properties(
+#     width=700,
+#     height=400,
+#     title="Trend of Building Construction by Status"
+# )
+# st.altair_chart(line_chart, use_container_width=True)
+# st.write("""
+# This line chart highlights the trend in the number of buildings constructed over time, 
+# categorized by their building status (e.g., whether they are currently in use or not). 
+# The x-axis represents the 'Year Constructed' and the y-axis represents the count of buildings. 
+# The color encoding separates the buildings by their 'Bldg Status' 
+# I used a line plot with points to clearly indicate the number of buildings per year, 
+# which helps in identifying trends and peaks. Another reason is that line chart is ideal for 
+# visualizing time-series data. The colors are chosen to differentiate the building statuses 
+# effectively. 
+
+# If I had more time, I would consider adding labels to the data points for clarity and 
+# perhaps break down the data further by usage description or location for a more detailed analysis.
+# Probably adding hover effects could display additional information, such as the exact count of 
+# buildings and their status, when hovering over each data point. This would allow users to gain 
+# deeper insights without cluttering the chart. I would also include filtering options so users 
+# could select specific building statuses or even a range of years to focus on, which would make
+# the analysis more targeted. 
+# """)
+
+
+# # Visualization 2
+# st.markdown("<h4 style='text-decoration: underline;'>Visualization 2</h4>", unsafe_allow_html=True)
+# county_agency_data = df.dropna(subset=['County', 'Agency Name'])
+# county_agency_count = county_agency_data.groupby('County')['Agency Name'].nunique().reset_index()
+# county_agency_count.rename(columns={'Agency Name': 'Unique Agencies'}, inplace=True)
+
+# county_agency_chart = alt.Chart(county_agency_count).mark_bar().encode(
+#     x=alt.X('County:N', sort='-y', title="County"),
+#     y=alt.Y('Unique Agencies:Q', title="Number of Agencies"),
+#     color=alt.Color('Unique Agencies:Q', scale=alt.Scale(scheme='viridis')),
+#     tooltip=['County:N', 'Unique Agencies:Q']
+# ).properties(
+#     width=700,
+#     height=400,
+#     title="Unique Agencies in Each County"
+# )
+# st.altair_chart(county_agency_chart, use_container_width=True)
+
+# st.write("""
+# This bar chart highlights the number of unique agencies operating in each county. 
+# The x-axis represents the 'County' and the y-axis represents the 'Number of Unique Agencies' 
+# I used a bar chart as it allows for easy comparison between counties based on the number of
+# agencies, and sorting the counties by agency count makes it easier to identify areas with 
+# more agencies. The color scale uses a 'viridis' color scheme, to show how the number of agencies
+# differs accross counties. 
+
+# If I had more time, I would consider adding interactivity, like a filter for 'Building Status', so that users can
+# focus on specific statuses, such as buildings that are still in progress or abandoned for each county. 
+# I would also implement a slider for 'Year Constructed' to allow users to focus on specific time periods, 
+# enabling them to analyze trends and compare the distribution of agencies by different time periods. 
+# I would also consider adding a search function so that users can look for specific counties 
+# or agency types.
+# """)
+# Load State GeoJSON for Map (example if supported)
+# Visualization: Licenses by State
+
+
+# Load Dataset
+@st.cache
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Handle Missing Values for Visualizations
+# 1. Remove rows with missing `Original Issue Date`
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Title
+st.title("Licenses Dataset Visualizations")
+st.markdown("This app presents three visualizations of the licenses dataset.")
+
+# Visualization 1: Bar Chart (Distribution of Licenses by Type)
+st.header("1. Distribution of Licenses by Type")
+license_count = df['License Type'].value_counts().reset_index()
+license_count.columns = ['License Type', 'Count']
+
+bar_chart = alt.Chart(license_count).mark_bar().encode(
+    x=alt.X('Count:Q', title='Number of Licenses'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type'),
+    color=alt.Color('License Type:N', legend=None)
+).properties(title="Number of Licenses by Type")
+
+st.altair_chart(bar_chart, use_container_width=True)
+
+st.markdown("""
+**Highlights**: This bar chart shows the distribution of licenses by type.
+**Design Choices**: A horizontal bar chart is used for better readability of license types.
+""")
+
+# Visualization 2: Line Chart (Trend of Licenses Over Time)
+st.header("2. Trend of Licenses Over Time")
+time_data = df_time.groupby(df_time['Original Issue Date'].dt.year).size().reset_index(name='Count')
+time_data.columns = ['Year', 'Count']
+
+line_chart = alt.Chart(time_data).mark_line(point=True).encode(
+    x=alt.X('Year:O', title='Year'),
+    y=alt.Y('Count:Q', title='Number of Licenses'),
+    color=alt.value('blue')
+).properties(title="Trend of Licenses Issued Over Years")
+
+st.altair_chart(line_chart, use_container_width=True)
+
+st.markdown("""
+**Highlights**: This line chart shows the trend of license issuances over time.
+**Design Choices**: Points are added to highlight specific data points, and the color blue is chosen for simplicity.
+""")
+
+
+# Count the number of licenses for each License Type and sort by count
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+
+# Get the top 10 License Types
+top_10_license_types = license_type_counts.head(10)
+
+# Create the bar chart
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+).properties(
+    title='Top 10 License Types by Frequency'
+)
+
+# Show the chart in the Streamlit app
+st.altair_chart(bar_chart, use_container_width=True)
+
+# Convert the Expiration Date to datetime (if not already)
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+
+# Extract the month and year from Expiration Date
+df['Expiration Year'] = df['Expiration Date'].dt.year
+df['Expiration Month'] = df['Expiration Date'].dt.month
+
+# Group by year and month and count the number of licenses expiring
+expiration_counts = df.groupby(['Expiration Year', 'Expiration Month']).size().reset_index(name='License Count')
+
+# Convert the Expiration Date to datetime (if not already)
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+
+# Extract the year from Expiration Date
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+
+# Create the trend line (line chart)
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+).properties(
+    title='Trend Line for License Expirations Over Time'
+)
+
+# Show the chart in the Streamlit app
+st.altair_chart(line_chart, use_container_width=True)
+# Convert the Expiration Date to datetime (if not already)
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+
+# Extract the year from Expiration Date
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+
+# Create the trend line (line chart)
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+).properties(
+    title='Trend Line for Licenses Expiring Over Time'
+)
+
+# Show the chart in the Streamlit app
+st.altair_chart(line_chart, use_container_width=True)
+
+
+
+# Convert the Expiration Date to datetime (if not already)
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+
+# Extract the year from Expiration Date
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+
+# Create the trend line (line chart) with interactive data points (circle marks)
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']  # Tooltip for interactivity
+).properties(
+    title='Trend Line for Licenses Expiring Over Time'
+).interactive()  # Make the chart interactive
+
+# Add circle marks at data points
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=100).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine the line and point marks
+final_chart = line_chart + points
+
+# Show the chart in the Streamlit app
+st.altair_chart(final_chart, use_container_width=True)
+

.local/share/code-server/User/History/450b0aa/P3er.py

@@ -0,0 +1,107 @@
+# put streamlit code here as needed
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load Dataset
+@st.cache
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Title
+st.title("Licenses Dataset Visualizations")
+st.markdown("This app presents three visualizations of the licenses dataset.")
+
+# Visualization 1: Bar Chart (Distribution of Licenses by Type)
+st.header("1. Distribution of Licenses by Type")
+license_count = df['License Type'].value_counts().reset_index()
+license_count.columns = ['License Type', 'Count']
+
+bar_chart = alt.Chart(license_count).mark_bar().encode(
+    x=alt.X('Count:Q', title='Number of Licenses'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type'),
+    color=alt.Color('License Type:N', legend=None)
+).properties(title="Number of Licenses by Type")
+
+st.altair_chart(bar_chart, use_container_width=True)
+
+st.markdown("""
+**Highlights**: This bar chart shows the distribution of licenses by type.
+**Design Choices**: A horizontal bar chart is used for better readability of license types.
+""")
+
+# Visualization 2: Line Chart (Trend of Licenses Over Time)
+st.header("2. Trend of Licenses Over Time")
+time_data = df_time.groupby(df_time['Original Issue Date'].dt.year).size().reset_index(name='Count')
+time_data.columns = ['Year', 'Count']
+
+line_chart = alt.Chart(time_data).mark_line(point=True).encode(
+    x=alt.X('Year:O', title='Year'),
+    y=alt.Y('Count:Q', title='Number of Licenses'),
+    color=alt.value('blue')
+).properties(title="Trend of Licenses Issued Over Years")
+
+st.altair_chart(line_chart, use_container_width=True)
+
+st.markdown("""
+**Highlights**: This line chart shows the trend of license issuances over time.
+**Design Choices**: Points are added to highlight specific data points, and the color blue is chosen for simplicity.
+""")
+
+
+# Count the number of licenses for each License Type and sort by count
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+
+# Get the top 10 License Types
+top_10_license_types = license_type_counts.head(10)
+st.header("3. Top 10 License Types by Frequency")
+# Create the bar chart
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+
+
+# Show the chart in the Streamlit app
+st.altair_chart(bar_chart, use_container_width=True)
+
+
+# Convert the Expiration Date to datetime (if not already)
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+
+# Extract the year from Expiration Date
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+
+# Create the trend line (line chart) with interactive data points (circle marks)
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']  # Tooltip for interactivity
+)
+
+
+# Add circle marks at data points
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine the line and point marks
+final_chart = line_chart + points
+
+# Show the chart in the Streamlit app
+st.altair_chart(final_chart, use_container_width=True)
+

.local/share/code-server/User/History/450b0aa/Q5uV.py

@@ -0,0 +1,75 @@
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load the dataset
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Convert 'Original Issue Date' to datetime and dropping rows with missing data
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Count the number of licenses for each License Type and get top 10
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+top_10_license_types = license_type_counts.head(10)
+st.header("1. Top 10 License Types by Frequency")
+
+# Bar chart for the top 10 license types
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+st.altair_chart(bar_chart, use_container_width=True)
+
+# Write-Up for first plot
+st.markdown("""
+This bar chart highlights the top 10 most frequent license types in the dataset. The x-axis represents the count of each license type, while the y-axis shows the name of the license type. 
+The bars are color-coded to differentiate between the license types. This makes it easy for users to visually distinguish between each category. The chart is sorted in descending order of the license count.
+
+I started by creating a bar chart for all license types, but the chart was difficult to read because many types had very low frequency, making the visualization cluttered. 
+To improve this, I focused on the top 10 most frequent license types, which allowed for a clearer and more insightful view of the most prevalent licenses in the dataset. 
+Since some license names were long, I made sure that the full text is visible when you hover on the bar chart.""")
+
+# Convert 'Expiration Date' to datetime and extract the year
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("4. Trend of Licenses Expiring Over Time")
+
+# Create trend line (line chart) with circle marks at data points
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine line and points
+final_chart = line_chart + points
+
+st.altair_chart(final_chart, use_container_width=True)
+
+# Markdown Write-Up for the trend line chart
+st.markdown("""
+This line chart shows the trend of licenses expiring over time, highlighting variations in license expirations. The x-axis represents the expiration year, while the y-axis shows the number of licenses expiring.
+The line shows the overall trend, with circles marking individual data points for better visibility. Tooltips provide more details when hovering.
+
+I chose a trend line because it clearly shows how the number of licenses expiring changes over time. 
+By plotting the data in this way, I can easily spot patterns or spikes in expiration rates. 
+The trend line gives a quick overview of the overall trend, while the circles on the data points highlight key years with significant changes.
+If I had more time, I would like to break down the expiration data further by month or quarter to detect more granular patterns and find a may to make it less cluttered.
+""")

.local/share/code-server/User/History/450b0aa/QeUw.py

@@ -0,0 +1,69 @@
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load the dataset
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Convert 'Original Issue Date' to datetime and dropping rows with missing data
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Count the number of licenses for each License Type and get top 10
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+top_10_license_types = license_type_counts.head(10)
+st.header("1. Top 10 License Types by Frequency")
+
+# Bar chart for the top 10 license types
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+st.altair_chart(bar_chart, use_container_width=True)
+
+# Write-Up for first plot
+st.markdown("""
+This bar chart highlights the top 10 most frequent license types in the dataset. 
+I started by creating a bar chart for all license types, but the chart was difficult to read because many types had very low frequency, making the visualization cluttered and less informative. To improve this, I focused on the top 10 most frequent license types, which allowed for a clearer and more insightful view of the most prevalent licenses in the dataset. Since some license names were long, I made them hoverable to ensure that the full text is visible when interacting with the chart.""")
+
+# Convert 'Expiration Date' to datetime and extract the year
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("4. Trend of Licenses Expiring Over Time")
+
+# Create trend line (line chart) with circle marks at data points
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine line and points
+final_chart = line_chart + points
+
+st.altair_chart(final_chart, use_container_width=True)
+
+# Markdown Write-Up for the trend line chart
+st.markdown("""
+**Highlights**: This line chart shows the trend of licenses expiring over time, highlighting seasonal or yearly variations in license expirations.
+
+**Design Choices**: The x-axis represents the expiration year, while the y-axis shows the number of licenses expiring. The line shows the overall trend, with circles marking individual data points for better visibility. Tooltips provide more details when hovering.
+
+**Improvements**: If I had more time, I would break down the expiration data further by month or quarter to detect more granular patterns.
+""")

.local/share/code-server/User/History/450b0aa/RWSp.py

@@ -0,0 +1,73 @@
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load the dataset
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Convert 'Original Issue Date' to datetime and dropping rows with missing data
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Count the number of licenses for each License Type and get top 10
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+top_10_license_types = license_type_counts.head(10)
+st.header("1. Top 10 License Types by Frequency")
+
+# Bar chart for the top 10 license types
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+st.altair_chart(bar_chart, use_container_width=True)
+
+# Write-Up for first plot
+st.markdown("""
+This bar chart highlights the top 10 most frequent license types in the dataset. The x-axis represents the count of each license type, while the y-axis shows the name of the license type. 
+ The chart is sorted in descending order of the license count.
+
+I started by creating a bar chart for all license types, but the chart was difficult to read because many types had very low frequency, making the visualization cluttered. 
+To improve this, I focused on the top 10 most frequent license types, which allowed for a clearer and more insightful view of the most prevalent licenses in the dataset. 
+Since some license names were long, I made sure that the full text is visible when you hover on the bar chart.""")
+
+# Convert 'Expiration Date' to datetime and extract the year
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("4. Trend of Licenses Expiring Over Time")
+
+# Create trend line (line chart) with circle marks at data points
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine line and points
+final_chart = line_chart + points
+
+st.altair_chart(final_chart, use_container_width=True)
+
+# Markdown Write-Up for the trend line chart
+st.markdown("""
+**Highlights**: This line chart shows the trend of licenses expiring over time, highlighting seasonal or yearly variations in license expirations.
+
+**Design Choices**: The x-axis represents the expiration year, while the y-axis shows the number of licenses expiring. The line shows the overall trend, with circles marking individual data points for better visibility. Tooltips provide more details when hovering.
+
+**Improvements**: If I had more time, I would break down the expiration data further by month or quarter to detect more granular patterns.
+""")

.local/share/code-server/User/History/450b0aa/RuPD.py

@@ -0,0 +1,74 @@
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load the dataset
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Convert 'Original Issue Date' to datetime and dropping rows with missing data
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Count the number of licenses for each License Type and get top 10
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+top_10_license_types = license_type_counts.head(10)
+st.header("1. Top 10 License Types by Frequency")
+
+# Bar chart for the top 10 license types
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+
+st.altair_chart(bar_chart, use_container_width=True)
+
+# Markdown Write-Up for the bar chart
+st.markdown("""
+**Highlights**: This bar chart highlights the top 10 most frequent license types in the dataset, allowing us to easily identify which types of licenses are the most prevalent.
+
+**Design Choices**: The x-axis represents the count of each license type, while the y-axis shows the name of the license type. The bars are color-coded to differentiate between the license types, and tooltips are included for better interaction. The chart is sorted in descending order of the license count.
+
+**Improvements**: If I had more time, I would add more granular details about the licenses or break down the data further by state or city for more localized insights.
+""")
+
+# Convert 'Expiration Date' to datetime and extract the year
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("4. Trend of Licenses Expiring Over Time")
+
+# Create trend line (line chart) with circle marks at data points
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine line and points
+final_chart = line_chart + points
+
+st.altair_chart(final_chart, use_container_width=True)
+
+# Markdown Write-Up for the trend line chart
+st.markdown("""
+**Highlights**: This line chart shows the trend of licenses expiring over time, highlighting seasonal or yearly variations in license expirations.
+
+**Design Choices**: The x-axis represents the expiration year, while the y-axis shows the number of licenses expiring. The line shows the overall trend, with circles marking individual data points for better visibility. Tooltips provide more details when hovering.
+
+**Improvements**: If I had more time, I would break down the expiration data further by month or quarter to detect more granular patterns.
+""")

.local/share/code-server/User/History/450b0aa/TdSt.py

@@ -0,0 +1,109 @@
+# put streamlit code here as needed
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load Dataset
+@st.cache
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Title
+st.title("Licenses Dataset Visualizations")
+st.markdown("This app presents three visualizations of the licenses dataset.")
+
+# Visualization 1: Bar Chart (Distribution of Licenses by Type)
+st.header("1. Distribution of Licenses by Type")
+license_count = df['License Type'].value_counts().reset_index()
+license_count.columns = ['License Type', 'Count']
+
+bar_chart = alt.Chart(license_count).mark_bar().encode(
+    x=alt.X('Count:Q', title='Number of Licenses'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type'),
+    color=alt.Color('License Type:N', legend=None)
+).properties(title="Number of Licenses by Type")
+
+st.altair_chart(bar_chart, use_container_width=True)
+
+st.markdown("""
+**Highlights**: This bar chart shows the distribution of licenses by type.
+**Design Choices**: A horizontal bar chart is used for better readability of license types.
+""")
+
+# Visualization 2: Line Chart (Trend of Licenses Over Time)
+st.header("2. Trend of Licenses Over Time")
+time_data = df_time.groupby(df_time['Original Issue Date'].dt.year).size().reset_index(name='Count')
+time_data.columns = ['Year', 'Count']
+
+line_chart = alt.Chart(time_data).mark_line(point=True).encode(
+    x=alt.X('Year:O', title='Year'),
+    y=alt.Y('Count:Q', title='Number of Licenses'),
+    color=alt.value('blue')
+).properties(title="Trend of Licenses Issued Over Years")
+
+st.altair_chart(line_chart, use_container_width=True)
+
+st.markdown("""
+**Highlights**: This line chart shows the trend of license issuances over time.
+**Design Choices**: Points are added to highlight specific data points, and the color blue is chosen for simplicity.
+""")
+
+
+# Count the number of licenses for each License Type and sort by count
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+
+# Get the top 10 License Types
+top_10_license_types = license_type_counts.head(10)
+
+# Create the bar chart
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+).properties(
+    title='Top 10 License Types by Frequency'
+)
+
+# Show the chart in the Streamlit app
+st.altair_chart(bar_chart, use_container_width=True)
+
+
+# Convert the Expiration Date to datetime (if not already)
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+
+# Extract the year from Expiration Date
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+
+# Create the trend line (line chart) with interactive data points (circle marks)
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']  # Tooltip for interactivity
+).properties(
+    title='Trend Line for Licenses Expiring Over Time'
+)
+
+# Add circle marks at data points
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine the line and point marks
+final_chart = line_chart + points
+
+# Show the chart in the Streamlit app
+st.altair_chart(final_chart, use_container_width=True)
+

.local/share/code-server/User/History/450b0aa/Vrxk.py

@@ -0,0 +1,74 @@
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load the dataset
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Convert 'Original Issue Date' to datetime and dropping rows with missing data
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Count the number of licenses for each License Type and get top 10
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+top_10_license_types = license_type_counts.head(10)
+st.header("1. Top 10 License Types by Frequency")
+
+# Bar chart for the top 10 license types
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+st.altair_chart(bar_chart, use_container_width=True)
+
+# Write-Up for first plot
+st.markdown("""
+This bar chart highlights the top 10 most frequent license types in the dataset. The x-axis represents the count of each license type, while the y-axis shows the name of the license type. 
+The bars are color-coded to differentiate between the license types. This makes it easy for users to visually distinguish between each category. The chart is sorted in descending order of the license count.
+
+I started by creating a bar chart for all license types, but the chart was difficult to read because many types had very low frequency, making the visualization cluttered. 
+To improve this, I focused on the top 10 most frequent license types, which allowed for a clearer and more insightful view of the most prevalent licenses in the dataset. 
+Since some license names were long, I made sure that the full text is visible when you hover on the bar chart.""")
+
+# Convert 'Expiration Date' to datetime and extract the year
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("2. Trend of Licenses Expiring Over Time")
+
+# Create trend line (line chart) with circle marks at data points
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine line and points
+final_chart = line_chart + points
+
+st.altair_chart(final_chart, use_container_width=True)
+
+# Markdown Write-Up for the trend line chart
+st.markdown("""
+This line chart shows the trend of licenses expiring over time, highlighting variations in license expirations. The x-axis represents the expiration year, while the y-axis shows the number of licenses expiring.
+The line shows the overall trend, with circles marking individual data points for better visibility. Tooltips provide more details when hovering.
+
+I chose a trend line because it clearly shows how the number of licenses expiring changes over time. 
+By plotting the data in this way, I can easily spot patterns or spikes in expiration rates. 
+The trend line gives a quick overview of the overall trend, while the circles on the data points highlight key years with significant changes.
+If I had more time, I would break down the expiration data further by month or quarter to detect more granular patterns and find a way to make it all of it more organized""")

.local/share/code-server/User/History/450b0aa/W0T9.py

@@ -0,0 +1,73 @@
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load the dataset
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Convert 'Original Issue Date' to datetime and dropping rows with missing data
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Count the number of licenses for each License Type and get top 10
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+top_10_license_types = license_type_counts.head(10)
+st.header("1. Top 10 License Types by Frequency")
+
+# Bar chart for the top 10 license types
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+st.altair_chart(bar_chart, use_container_width=True)
+
+# Write-Up for first plot
+st.markdown("""
+This bar chart highlights the top 10 most frequent license types in the dataset. The x-axis represents the count of each license type, while the y-axis shows the name of the license type. 
+The bars are color-coded to differentiate between the license types. This makes it easy for users to visually distinguish between each category. The chart is sorted in descending order of the license count.
+
+I started by creating a bar chart for all license types, but the chart was difficult to read because many types had very low frequency, making the visualization cluttered. 
+To improve this, I focused on the top 10 most frequent license types, which allowed for a clearer and more insightful view of the most prevalent licenses in the dataset. 
+Since some license names were long, I made sure that the full text is visible when you hover on the bar chart.""")
+
+# Convert 'Expiration Date' to datetime and extract the year
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("4. Trend of Licenses Expiring Over Time")
+
+# Create trend line (line chart) with circle marks at data points
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine line and points
+final_chart = line_chart + points
+
+st.altair_chart(final_chart, use_container_width=True)
+
+# Markdown Write-Up for the trend line chart
+st.markdown("""
+**Highlights**: This line chart shows the trend of licenses expiring over time, highlighting seasonal or yearly variations in license expirations.
+
+**Design Choices**: The x-axis represents the expiration year, while the y-axis shows the number of licenses expiring. The line shows the overall trend, with circles marking individual data points for better visibility. Tooltips provide more details when hovering.
+
+**Improvements**: If I had more time, I would break down the expiration data further by month or quarter to detect more granular patterns.
+""")

.local/share/code-server/User/History/450b0aa/WCDW.py

@@ -0,0 +1,73 @@
+# put streamlit code here as needed
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load Dataset
+
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+
+
+
+# Count the number of licenses for each License Type and sort by count
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+
+# Get the top 10 License Types
+top_10_license_types = license_type_counts.head(10)
+st.header("3. Top 10 License Types by Frequency")
+# Create the bar chart
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+
+
+# Show the chart in the Streamlit app
+st.altair_chart(bar_chart, use_container_width=True)
+
+st.markdown("""
+**Highlights**: This line chart shows .
+**Design Choices**: Points are added to highlight.
+""")
+
+# Convert the Expiration Date to datetime (if not already)
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+
+# Extract the year from Expiration Date
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("4. Trend of Licenses Expiring Over Time")
+# Create the trend line (line chart) with interactive data points (circle marks)
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']  # Tooltip for interactivity
+)
+
+
+# Add circle marks at data points
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine the line and point marks
+final_chart = line_chart + points
+
+# Show the chart in the Streamlit app
+st.altair_chart(final_chart, use_container_width=True)
+

.local/share/code-server/User/History/450b0aa/WLXq.py

@@ -0,0 +1,70 @@
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load the dataset
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Convert 'Original Issue Date' to datetime and dropping rows with missing data
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Count the number of licenses for each License Type and get top 10
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+top_10_license_types = license_type_counts.head(10)
+st.header("1. Top 10 License Types by Frequency")
+
+# Bar chart for the top 10 license types
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+st.altair_chart(bar_chart, use_container_width=True)
+
+# Write-Up for first plot
+st.markdown("""
+This bar chart highlights the top 10 most frequent license types in the dataset. 
+I started by creating a bar chart for all license types, but the chart was difficult to read because many types had very low frequency, making the visualization cluttered. 
+To improve this, I focused on the top 10 most frequent license types, which allowed for a clearer and more insightful view of the most prevalent licenses in the dataset. Since some license names were long, I made them hoverable to ensure that the full text is visible when interacting with the chart.""")
+
+# Convert 'Expiration Date' to datetime and extract the year
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("4. Trend of Licenses Expiring Over Time")
+
+# Create trend line (line chart) with circle marks at data points
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine line and points
+final_chart = line_chart + points
+
+st.altair_chart(final_chart, use_container_width=True)
+
+# Markdown Write-Up for the trend line chart
+st.markdown("""
+**Highlights**: This line chart shows the trend of licenses expiring over time, highlighting seasonal or yearly variations in license expirations.
+
+**Design Choices**: The x-axis represents the expiration year, while the y-axis shows the number of licenses expiring. The line shows the overall trend, with circles marking individual data points for better visibility. Tooltips provide more details when hovering.
+
+**Improvements**: If I had more time, I would break down the expiration data further by month or quarter to detect more granular patterns.
+""")

.local/share/code-server/User/History/450b0aa/YJb8.py

@@ -0,0 +1,73 @@
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load the dataset
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Convert 'Original Issue Date' to datetime and dropping rows with missing data
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Count the number of licenses for each License Type and get top 10
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+top_10_license_types = license_type_counts.head(10)
+st.header("1. Top 10 License Types by Frequency")
+
+# Bar chart for the top 10 license types
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+st.altair_chart(bar_chart, use_container_width=True)
+
+# Write-Up for first plot
+st.markdown("""
+This bar chart highlights the top 10 most frequent license types in the dataset. The x-axis represents the count of each license type, while the y-axis shows the name of the license type. 
+The bars are color-coded to differentiate between the license types. The chart is sorted in descending order of the license count.
+
+I started by creating a bar chart for all license types, but the chart was difficult to read because many types had very low frequency, making the visualization cluttered. 
+To improve this, I focused on the top 10 most frequent license types, which allowed for a clearer and more insightful view of the most prevalent licenses in the dataset. 
+Since some license names were long, I made sure that the full text is visible when you hover on the bar chart.""")
+
+# Convert 'Expiration Date' to datetime and extract the year
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("4. Trend of Licenses Expiring Over Time")
+
+# Create trend line (line chart) with circle marks at data points
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine line and points
+final_chart = line_chart + points
+
+st.altair_chart(final_chart, use_container_width=True)
+
+# Markdown Write-Up for the trend line chart
+st.markdown("""
+**Highlights**: This line chart shows the trend of licenses expiring over time, highlighting seasonal or yearly variations in license expirations.
+
+**Design Choices**: The x-axis represents the expiration year, while the y-axis shows the number of licenses expiring. The line shows the overall trend, with circles marking individual data points for better visibility. Tooltips provide more details when hovering.
+
+**Improvements**: If I had more time, I would break down the expiration data further by month or quarter to detect more granular patterns.
+""")

.local/share/code-server/User/History/450b0aa/YSbm.py

@@ -0,0 +1,75 @@
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load the dataset
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Convert 'Original Issue Date' to datetime and dropping rows with missing data
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Count the number of licenses for each License Type and get top 10
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+top_10_license_types = license_type_counts.head(10)
+st.header("1. Top 10 License Types by Frequency")
+
+# Bar chart for the top 10 license types
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+st.altair_chart(bar_chart, use_container_width=True)
+
+# Write-Up for first plot
+st.markdown("""
+This bar chart highlights the top 10 most frequent license types in the dataset. The x-axis represents the count of each license type, while the y-axis shows the name of the license type. 
+The bars are color-coded to differentiate between the license types. This makes it easy for users to visually distinguish between each category. The chart is sorted in descending order of the license count.
+
+I started by creating a bar chart for all license types, but the chart was difficult to read because many types had very low frequency. 
+To improve this, I focused on the top 10 most frequent license types, allowing for a clearer and more insightful visualization. 
+Since some license names were long, I made sure that the full text is visible when you hover on the bar chart. 
+If I had more time, I would like to find a way to make the column names more readable on the y-axis and include all license types without making the visualization too cluttered""")
+
+# Convert 'Expiration Date' to datetime and extract the year
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("2. Trend of Licenses Expiring Over Time")
+
+# Create trend line (line chart) with circle marks at data points
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine line and points
+final_chart = line_chart + points
+
+st.altair_chart(final_chart, use_container_width=True)
+
+# Markdown Write-Up for the trend line chart
+st.markdown("""
+This line chart shows the trend of licenses expiring over time, highlighting variations in license expirations. The x-axis represents the expiration year, while the y-axis shows the number of licenses expiring.
+The line shows the overall trend, with circles marking individual data points for better visibility. Tooltips provide more details when hovering.
+
+I chose a trend line because it clearly shows how the number of licenses expiring changes over time. 
+By plotting the data in this way, I can easily spot patterns or spikes in expiration rates. 
+The trend line gives a quick overview of the overall trend, while the circles on the data points highlight key years with significant changes.
+If I had more time, I would break down the expiration data further by month or quarter to detect more granular patterns and find a way to make it all of it more organized""")

.local/share/code-server/User/History/450b0aa/cWhv.py

@@ -0,0 +1,208 @@
+# put streamlit code here as needed
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+#import the data
+#url = "https://raw.githubusercontent.com/UIUC-iSchool-DataViz/is445_data/main/ufo-scrubbed-geocoded-time-standardized-00.csv"
+#df = pd.read_csv(url)
+#df.sum().isnull()
+
+
+
+# #Fill the missing data with Unknown
+# df['County'].fillna('Not available', inplace=True)
+# df['Rep Full Name'].fillna('Not available', inplace=True)
+# df['Year Constructed'].fillna(df['Year Constructed'].median(), inplace=True)
+# df['Senator Full Name'].fillna('Unknown', inplace=True)
+# df['Usage Description 2'].fillna(df['Usage Description 2'].mode()[0], inplace=True)
+# df['Usage Description 3'].fillna(df['Usage Description 3'].mode()[0], inplace=True)
+# df['Address'].fillna('Not available', inplace=True)
+# df['Congressional Full Name'].fillna('Unknown', inplace=True)
+
+# #Page Title
+# st.markdown("<h1 style='text-align: center;'>Homework 5.1</h1>", unsafe_allow_html=True)
+
+# st.subheader("Analyzing the Building Inventory Dataset")
+# #Visualization 1
+# st.markdown("<h4 style='text-decoration: underline;'>Visualization 1</h4>", unsafe_allow_html=True)
+
+# df_filtered = df.dropna(subset=['Bldg Status', 'Year Constructed'])
+# df_filtered['Year Constructed'] = pd.to_numeric(df_filtered['Year Constructed'], errors='coerce')
+# df_filtered = df_filtered[(df_filtered['Year Constructed'] >= 1600) & (df_filtered['Year Constructed'] <= 2100)]
+
+
+# line_chart = alt.Chart(df_filtered).mark_line(point=True).encode(
+#     x=alt.X('Year Constructed:Q', title='Year Constructed'),
+#     y=alt.Y('count()', title='Number of Buildings'),
+#     color=alt.Color('Bldg Status:N', title='Building Status'),
+#     tooltip=['Year Constructed', 'count()', 'Bldg Status']
+# ).properties(
+#     width=700,
+#     height=400,
+#     title="Trend of Building Construction by Status"
+# )
+# st.altair_chart(line_chart, use_container_width=True)
+# st.write("""
+# This line chart highlights the trend in the number of buildings constructed over time, 
+# categorized by their building status (e.g., whether they are currently in use or not). 
+# The x-axis represents the 'Year Constructed' and the y-axis represents the count of buildings. 
+# The color encoding separates the buildings by their 'Bldg Status' 
+# I used a line plot with points to clearly indicate the number of buildings per year, 
+# which helps in identifying trends and peaks. Another reason is that line chart is ideal for 
+# visualizing time-series data. The colors are chosen to differentiate the building statuses 
+# effectively. 
+
+# If I had more time, I would consider adding labels to the data points for clarity and 
+# perhaps break down the data further by usage description or location for a more detailed analysis.
+# Probably adding hover effects could display additional information, such as the exact count of 
+# buildings and their status, when hovering over each data point. This would allow users to gain 
+# deeper insights without cluttering the chart. I would also include filtering options so users 
+# could select specific building statuses or even a range of years to focus on, which would make
+# the analysis more targeted. 
+# """)
+
+
+# # Visualization 2
+# st.markdown("<h4 style='text-decoration: underline;'>Visualization 2</h4>", unsafe_allow_html=True)
+# county_agency_data = df.dropna(subset=['County', 'Agency Name'])
+# county_agency_count = county_agency_data.groupby('County')['Agency Name'].nunique().reset_index()
+# county_agency_count.rename(columns={'Agency Name': 'Unique Agencies'}, inplace=True)
+
+# county_agency_chart = alt.Chart(county_agency_count).mark_bar().encode(
+#     x=alt.X('County:N', sort='-y', title="County"),
+#     y=alt.Y('Unique Agencies:Q', title="Number of Agencies"),
+#     color=alt.Color('Unique Agencies:Q', scale=alt.Scale(scheme='viridis')),
+#     tooltip=['County:N', 'Unique Agencies:Q']
+# ).properties(
+#     width=700,
+#     height=400,
+#     title="Unique Agencies in Each County"
+# )
+# st.altair_chart(county_agency_chart, use_container_width=True)
+
+# st.write("""
+# This bar chart highlights the number of unique agencies operating in each county. 
+# The x-axis represents the 'County' and the y-axis represents the 'Number of Unique Agencies' 
+# I used a bar chart as it allows for easy comparison between counties based on the number of
+# agencies, and sorting the counties by agency count makes it easier to identify areas with 
+# more agencies. The color scale uses a 'viridis' color scheme, to show how the number of agencies
+# differs accross counties. 
+
+# If I had more time, I would consider adding interactivity, like a filter for 'Building Status', so that users can
+# focus on specific statuses, such as buildings that are still in progress or abandoned for each county. 
+# I would also implement a slider for 'Year Constructed' to allow users to focus on specific time periods, 
+# enabling them to analyze trends and compare the distribution of agencies by different time periods. 
+# I would also consider adding a search function so that users can look for specific counties 
+# or agency types.
+# """)
+# Load State GeoJSON for Map (example if supported)
+# Visualization: Licenses by State
+
+
+# Load Dataset
+@st.cache
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Handle Missing Values for Visualizations
+# 1. Remove rows with missing `Original Issue Date`
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Title
+st.title("Licenses Dataset Visualizations")
+st.markdown("This app presents three visualizations of the licenses dataset.")
+
+# Visualization 1: Bar Chart (Distribution of Licenses by Type)
+st.header("1. Distribution of Licenses by Type")
+license_count = df['License Type'].value_counts().reset_index()
+license_count.columns = ['License Type', 'Count']
+
+bar_chart = alt.Chart(license_count).mark_bar().encode(
+    x=alt.X('Count:Q', title='Number of Licenses'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type'),
+    color=alt.Color('License Type:N', legend=None)
+).properties(title="Number of Licenses by Type")
+
+st.altair_chart(bar_chart, use_container_width=True)
+
+st.markdown("""
+**Highlights**: This bar chart shows the distribution of licenses by type.
+**Design Choices**: A horizontal bar chart is used for better readability of license types.
+""")
+
+# Visualization 2: Line Chart (Trend of Licenses Over Time)
+st.header("2. Trend of Licenses Over Time")
+time_data = df_time.groupby(df_time['Original Issue Date'].dt.year).size().reset_index(name='Count')
+time_data.columns = ['Year', 'Count']
+
+line_chart = alt.Chart(time_data).mark_line(point=True).encode(
+    x=alt.X('Year:O', title='Year'),
+    y=alt.Y('Count:Q', title='Number of Licenses'),
+    color=alt.value('blue')
+).properties(title="Trend of Licenses Issued Over Years")
+
+st.altair_chart(line_chart, use_container_width=True)
+
+st.markdown("""
+**Highlights**: This line chart shows the trend of license issuances over time.
+**Design Choices**: Points are added to highlight specific data points, and the color blue is chosen for simplicity.
+""")
+
+
+# Count the number of licenses for each License Type and sort by count
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+
+# Get the top 10 License Types
+top_10_license_types = license_type_counts.head(10)
+
+# Create the bar chart
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+).properties(
+    title='Top 10 License Types by Frequency'
+)
+
+# Show the chart in the Streamlit app
+st.altair_chart(bar_chart, use_container_width=True)
+
+
+# Convert the Expiration Date to datetime (if not already)
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+
+# Extract the year from Expiration Date
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+
+# Create the trend line (line chart) with interactive data points (circle marks)
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']  # Tooltip for interactivity
+).properties(
+    title='Trend Line for Licenses Expiring Over Time'
+).interactive()  # Make the chart interactive
+
+# Add circle marks at data points
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine the line and point marks
+final_chart = line_chart + points
+
+# Show the chart in the Streamlit app
+st.altair_chart(final_chart, use_container_width=True)
+

.local/share/code-server/User/History/450b0aa/e7iD.py

@@ -0,0 +1,73 @@
+# put streamlit code here as needed
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load Dataset
+@st.cache
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+
+
+
+# Count the number of licenses for each License Type and sort by count
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+
+# Get the top 10 License Types
+top_10_license_types = license_type_counts.head(10)
+st.header("3. Top 10 License Types by Frequency")
+# Create the bar chart
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+
+
+# Show the chart in the Streamlit app
+st.altair_chart(bar_chart, use_container_width=True)
+
+st.markdown("""
+**Highlights**: This line chart shows .
+**Design Choices**: Points are added to highlight.
+""")
+
+# Convert the Expiration Date to datetime (if not already)
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+
+# Extract the year from Expiration Date
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("4. Trend of Licenses Expiring Over Time")
+# Create the trend line (line chart) with interactive data points (circle marks)
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']  # Tooltip for interactivity
+)
+
+
+# Add circle marks at data points
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine the line and point marks
+final_chart = line_chart + points
+
+# Show the chart in the Streamlit app
+st.altair_chart(final_chart, use_container_width=True)
+

.local/share/code-server/User/History/450b0aa/entries.json

@@ -0,0 +1 @@
+{"version":1,"resource":"vscode-remote://us.prairielearn.com/home/coder/app.py","entries":[{"id":"s0Hs.py","timestamp":1732610271002},{"id":"O3TC.py","timestamp":1732610434817},{"id":"BvGZ.py","timestamp":1732610476290},{"id":"cWhv.py","timestamp":1732610582621},{"id":"AIA9.py","timestamp":1732610651134},{"id":"TdSt.py","timestamp":1732610735299},{"id":"I3Tc.py","timestamp":1732610806873},{"id":"iwOA.py","timestamp":1732610839592},{"id":"P3er.py","timestamp":1732610855923},{"id":"HxIz.py","timestamp":1732610881797},{"id":"fdvg.py","timestamp":1732610922722},{"id":"e7iD.py","timestamp":1732611034843},{"id":"WCDW.py","timestamp":1732611365984},{"id":"v1EL.py","timestamp":1732611436229},{"id":"gwPw.py","source":"undoRedo.source","timestamp":1732611467020},{"id":"C2VD.py","source":"undoRedo.source","timestamp":1732611484102},{"id":"vTno.py","timestamp":1732611509771},{"id":"jtCb.py","timestamp":1732611541992},{"id":"2wHf.py","timestamp":1732611585052},{"id":"RuPD.py","timestamp":1732611595384},{"id":"Dqul.py","timestamp":1732611615454},{"id":"BA55.py","timestamp":1732611631889},{"id":"2sco.py","timestamp":1732611708324},{"id":"4TtO.py","timestamp":1732611993598},{"id":"QeUw.py","timestamp":1732612015814},{"id":"WLXq.py","timestamp":1732612053461},{"id":"hisc.py","timestamp":1732612075256},{"id":"zuML.py","timestamp":1732612088958},{"id":"YJb8.py","timestamp":1732612185652},{"id":"ksQB.py","timestamp":1732612338428},{"id":"RWSp.py","source":"undoRedo.source","timestamp":1732612367906},{"id":"zPF4.py","timestamp":1732612468393},{"id":"W0T9.py","timestamp":1732612478852},{"id":"8wPI.py","timestamp":1732612490534},{"id":"vzqC.py","timestamp":1732612520566},{"id":"0rFy.py","timestamp":1732612794232},{"id":"gJ7Y.py","timestamp":1732612838289},{"id":"Q5uV.py","timestamp":1732612850712},{"id":"8qMH.py","timestamp":1732612947711},{"id":"Vrxk.py","timestamp":1732612978297},{"id":"GB0z.py","timestamp":1732613153833},{"id":"fjsF.py","timestamp":1732613170235},{"id":"53ry.py","timestamp":1732613225839},{"id":"YSbm.py","timestamp":1732613251281},{"id":"mE68.py","timestamp":1732613291160},{"id":"53Ql.py","timestamp":1732613323548},{"id":"rykv.py","timestamp":1732613389594},{"id":"qzJp.py","timestamp":1732613401918},{"id":"zoVr.py","timestamp":1732613418498},{"id":"Km75.py","timestamp":1732613439341}]}

.local/share/code-server/User/History/450b0aa/fdvg.py

@@ -0,0 +1,107 @@
+# put streamlit code here as needed
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load Dataset
+@st.cache
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Title
+st.title("Licenses Dataset Visualizations")
+st.markdown("This app presents three visualizations of the licenses dataset.")
+
+# Visualization 1: Bar Chart (Distribution of Licenses by Type)
+st.header("1. Distribution of Licenses by Type")
+license_count = df['License Type'].value_counts().reset_index()
+license_count.columns = ['License Type', 'Count']
+
+bar_chart = alt.Chart(license_count).mark_bar().encode(
+    x=alt.X('Count:Q', title='Number of Licenses'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type'),
+    color=alt.Color('License Type:N', legend=None)
+).properties(title="Number of Licenses by Type")
+
+st.altair_chart(bar_chart, use_container_width=True)
+
+st.markdown("""
+**Highlights**: This bar chart shows the distribution of licenses by type.
+**Design Choices**: A horizontal bar chart is used for better readability of license types.
+""")
+
+# Visualization 2: Line Chart (Trend of Licenses Over Time)
+st.header("2. Trend of Licenses Over Time")
+time_data = df_time.groupby(df_time['Original Issue Date'].dt.year).size().reset_index(name='Count')
+time_data.columns = ['Year', 'Count']
+
+line_chart = alt.Chart(time_data).mark_line(point=True).encode(
+    x=alt.X('Year:O', title='Year'),
+    y=alt.Y('Count:Q', title='Number of Licenses'),
+    color=alt.value('blue')
+).properties(title="Trend of Licenses Issued Over Years")
+
+st.altair_chart(line_chart, use_container_width=True)
+
+st.markdown("""
+**Highlights**: This line chart shows the trend of license issuances over time.
+**Design Choices**: Points are added to highlight specific data points, and the color blue is chosen for simplicity.
+""")
+
+
+# Count the number of licenses for each License Type and sort by count
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+
+# Get the top 10 License Types
+top_10_license_types = license_type_counts.head(10)
+st.header("3. Top 10 License Types by Frequency")
+# Create the bar chart
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+
+
+# Show the chart in the Streamlit app
+st.altair_chart(bar_chart, use_container_width=True)
+
+
+# Convert the Expiration Date to datetime (if not already)
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+
+# Extract the year from Expiration Date
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("4. Trend of Licenses Expiring Over Time")
+# Create the trend line (line chart) with interactive data points (circle marks)
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']  # Tooltip for interactivity
+)
+
+
+# Add circle marks at data points
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine the line and point marks
+final_chart = line_chart + points
+
+# Show the chart in the Streamlit app
+st.altair_chart(final_chart, use_container_width=True)
+

.local/share/code-server/User/History/450b0aa/fjsF.py

@@ -0,0 +1,75 @@
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load the dataset
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Convert 'Original Issue Date' to datetime and dropping rows with missing data
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Count the number of licenses for each License Type and get top 10
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+top_10_license_types = license_type_counts.head(10)
+st.header("1. Top 10 License Types by Frequency")
+
+# Bar chart for the top 10 license types
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+st.altair_chart(bar_chart, use_container_width=True)
+
+# Write-Up for first plot
+st.markdown("""
+This bar chart highlights the top 10 most frequent license types in the dataset. The x-axis represents the count of each license type, while the y-axis shows the name of the license type. 
+The bars are color-coded to differentiate between the license types. This makes it easy for users to visually distinguish between each category. The chart is sorted in descending order of the license count.
+
+I started by creating a bar chart for all license types, but the chart was difficult to read because many types had very low frequency, making the visualization cluttered. 
+To improve this, I focused on the top 10 most frequent license types, which allowed for a clearer and more insightful view of the most prevalent licenses in the dataset. 
+Since some license names were long, I made sure that the full text is visible when you hover on the bar chart. 
+If I had more time, I would like to find a way to make the column names more readable on the y-axis and include all license types without making the visualization too cluttered""")
+
+# Convert 'Expiration Date' to datetime and extract the year
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("2. Trend of Licenses Expiring Over Time")
+
+# Create trend line (line chart) with circle marks at data points
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine line and points
+final_chart = line_chart + points
+
+st.altair_chart(final_chart, use_container_width=True)
+
+# Markdown Write-Up for the trend line chart
+st.markdown("""
+This line chart shows the trend of licenses expiring over time, highlighting variations in license expirations. The x-axis represents the expiration year, while the y-axis shows the number of licenses expiring.
+The line shows the overall trend, with circles marking individual data points for better visibility. Tooltips provide more details when hovering.
+
+I chose a trend line because it clearly shows how the number of licenses expiring changes over time. 
+By plotting the data in this way, I can easily spot patterns or spikes in expiration rates. 
+The trend line gives a quick overview of the overall trend, while the circles on the data points highlight key years with significant changes.
+If I had more time, I would break down the expiration data further by month or quarter to detect more granular patterns and find a way to make it all of it more organized""")

.local/share/code-server/User/History/450b0aa/gJ7Y.py

@@ -0,0 +1,75 @@
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load the dataset
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Convert 'Original Issue Date' to datetime and dropping rows with missing data
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Count the number of licenses for each License Type and get top 10
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+top_10_license_types = license_type_counts.head(10)
+st.header("1. Top 10 License Types by Frequency")
+
+# Bar chart for the top 10 license types
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+st.altair_chart(bar_chart, use_container_width=True)
+
+# Write-Up for first plot
+st.markdown("""
+This bar chart highlights the top 10 most frequent license types in the dataset. The x-axis represents the count of each license type, while the y-axis shows the name of the license type. 
+The bars are color-coded to differentiate between the license types. This makes it easy for users to visually distinguish between each category. The chart is sorted in descending order of the license count.
+
+I started by creating a bar chart for all license types, but the chart was difficult to read because many types had very low frequency, making the visualization cluttered. 
+To improve this, I focused on the top 10 most frequent license types, which allowed for a clearer and more insightful view of the most prevalent licenses in the dataset. 
+Since some license names were long, I made sure that the full text is visible when you hover on the bar chart.""")
+
+# Convert 'Expiration Date' to datetime and extract the year
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("4. Trend of Licenses Expiring Over Time")
+
+# Create trend line (line chart) with circle marks at data points
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine line and points
+final_chart = line_chart + points
+
+st.altair_chart(final_chart, use_container_width=True)
+
+# Markdown Write-Up for the trend line chart
+st.markdown("""
+This line chart shows the trend of licenses expiring over time, highlighting variations in license expirations. The x-axis represents the expiration year, while the y-axis shows the number of licenses expiring.
+The line shows the overall trend, with circles marking individual data points for better visibility. Tooltips provide more details when hovering.
+
+I chose a trend line because it clearly shows how the number of licenses expiring changes over time. 
+By plotting the data in this way, I can easily spot patterns or spikes in expiration rates. 
+The trend line gives a quick overview of the overall trend, while the circles on the data points highlight key years with significant changes.
+If I had more time, I would like to break down the expiration data further by month or quarter to detect more granular patterns a
+""")

.local/share/code-server/User/History/450b0aa/gwPw.py

@@ -0,0 +1,72 @@
+# put streamlit code here as needed
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load Dataset
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+
+
+
+# Count the number of licenses for each License Type and sort by count
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+
+# Get the top 10 License Types
+top_10_license_types = license_type_counts.head(10)
+st.header("3. Top 10 License Types by Frequency")
+# Create the bar chart
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+
+
+# Show the chart in the Streamlit app
+st.altair_chart(bar_chart, use_container_width=True)
+
+st.markdown("""
+**Highlights**: This line chart shows .
+**Design Choices**: Points are added to highlight.
+""")
+
+# Convert the Expiration Date to datetime (if not already)
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+
+# Extract the year from Expiration Date
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("4. Trend of Licenses Expiring Over Time")
+# Create the trend line (line chart) with interactive data points (circle marks)
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']  # Tooltip for interactivity
+)
+
+
+# Add circle marks at data points
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine the line and point marks
+final_chart = line_chart + points
+
+# Show the chart in the Streamlit app
+st.altair_chart(final_chart, use_container_width=True)
+

.local/share/code-server/User/History/450b0aa/hisc.py

@@ -0,0 +1,71 @@
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load the dataset
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Convert 'Original Issue Date' to datetime and dropping rows with missing data
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Count the number of licenses for each License Type and get top 10
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+top_10_license_types = license_type_counts.head(10)
+st.header("1. Top 10 License Types by Frequency")
+
+# Bar chart for the top 10 license types
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+st.altair_chart(bar_chart, use_container_width=True)
+
+# Write-Up for first plot
+st.markdown("""
+This bar chart highlights the top 10 most frequent license types in the dataset. 
+I started by creating a bar chart for all license types, but the chart was difficult to read because many types had very low frequency, making the visualization cluttered. 
+To improve this, I focused on the top 10 most frequent license types, which allowed for a clearer and more insightful view of the most prevalent licenses in the dataset. 
+Since some license names were long, I made sure that the full text is visible when interacting with the chart.""")
+
+# Convert 'Expiration Date' to datetime and extract the year
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("4. Trend of Licenses Expiring Over Time")
+
+# Create trend line (line chart) with circle marks at data points
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine line and points
+final_chart = line_chart + points
+
+st.altair_chart(final_chart, use_container_width=True)
+
+# Markdown Write-Up for the trend line chart
+st.markdown("""
+**Highlights**: This line chart shows the trend of licenses expiring over time, highlighting seasonal or yearly variations in license expirations.
+
+**Design Choices**: The x-axis represents the expiration year, while the y-axis shows the number of licenses expiring. The line shows the overall trend, with circles marking individual data points for better visibility. Tooltips provide more details when hovering.
+
+**Improvements**: If I had more time, I would break down the expiration data further by month or quarter to detect more granular patterns.
+""")

.local/share/code-server/User/History/450b0aa/iwOA.py

@@ -0,0 +1,108 @@
+# put streamlit code here as needed
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load Dataset
+@st.cache
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Title
+st.title("Licenses Dataset Visualizations")
+st.markdown("This app presents three visualizations of the licenses dataset.")
+
+# Visualization 1: Bar Chart (Distribution of Licenses by Type)
+st.header("1. Distribution of Licenses by Type")
+license_count = df['License Type'].value_counts().reset_index()
+license_count.columns = ['License Type', 'Count']
+
+bar_chart = alt.Chart(license_count).mark_bar().encode(
+    x=alt.X('Count:Q', title='Number of Licenses'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type'),
+    color=alt.Color('License Type:N', legend=None)
+).properties(title="Number of Licenses by Type")
+
+st.altair_chart(bar_chart, use_container_width=True)
+
+st.markdown("""
+**Highlights**: This bar chart shows the distribution of licenses by type.
+**Design Choices**: A horizontal bar chart is used for better readability of license types.
+""")
+
+# Visualization 2: Line Chart (Trend of Licenses Over Time)
+st.header("2. Trend of Licenses Over Time")
+time_data = df_time.groupby(df_time['Original Issue Date'].dt.year).size().reset_index(name='Count')
+time_data.columns = ['Year', 'Count']
+
+line_chart = alt.Chart(time_data).mark_line(point=True).encode(
+    x=alt.X('Year:O', title='Year'),
+    y=alt.Y('Count:Q', title='Number of Licenses'),
+    color=alt.value('blue')
+).properties(title="Trend of Licenses Issued Over Years")
+
+st.altair_chart(line_chart, use_container_width=True)
+
+st.markdown("""
+**Highlights**: This line chart shows the trend of license issuances over time.
+**Design Choices**: Points are added to highlight specific data points, and the color blue is chosen for simplicity.
+""")
+
+
+# Count the number of licenses for each License Type and sort by count
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+
+# Get the top 10 License Types
+top_10_license_types = license_type_counts.head(10)
+st.header(". Trend of Licenses Over Time")
+# Create the bar chart
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+).properties(
+    title='Top 10 License Types by Frequency'
+)
+
+# Show the chart in the Streamlit app
+st.altair_chart(bar_chart, use_container_width=True)
+
+
+# Convert the Expiration Date to datetime (if not already)
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+
+# Extract the year from Expiration Date
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+
+# Create the trend line (line chart) with interactive data points (circle marks)
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']  # Tooltip for interactivity
+)
+
+
+# Add circle marks at data points
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine the line and point marks
+final_chart = line_chart + points
+
+# Show the chart in the Streamlit app
+st.altair_chart(final_chart, use_container_width=True)
+

.local/share/code-server/User/History/450b0aa/jtCb.py

@@ -0,0 +1,74 @@
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load the dataset
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Convert 'Original Issue Date' to datetime and dropping rows with missing data
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Count the number of licenses for each License Type and get top 10
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+top_10_license_types = license_type_counts.head(10)
+st.header("3. Top 10 License Types by Frequency")
+
+# Create bar chart for the top 10 license types
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+
+st.altair_chart(bar_chart, use_container_width=True)
+
+# Markdown Write-Up for the bar chart
+st.markdown("""
+**Highlights**: This bar chart highlights the top 10 most frequent license types in the dataset, allowing us to easily identify which types of licenses are the most prevalent.
+
+**Design Choices**: The x-axis represents the count of each license type, while the y-axis shows the name of the license type. The bars are color-coded to differentiate between the license types, and tooltips are included for better interaction. The chart is sorted in descending order of the license count.
+
+**Improvements**: If I had more time, I would add more granular details about the licenses or break down the data further by state or city for more localized insights.
+""")
+
+# Convert 'Expiration Date' to datetime and extract the year
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("4. Trend of Licenses Expiring Over Time")
+
+# Create trend line (line chart) with circle marks at data points
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine line and points
+final_chart = line_chart + points
+
+st.altair_chart(final_chart, use_container_width=True)
+
+# Markdown Write-Up for the trend line chart
+st.markdown("""
+**Highlights**: This line chart shows the trend of licenses expiring over time, highlighting seasonal or yearly variations in license expirations.
+
+**Design Choices**: The x-axis represents the expiration year, while the y-axis shows the number of licenses expiring. The line shows the overall trend, with circles marking individual data points for better visibility. Tooltips provide more details when hovering.
+
+**Improvements**: If I had more time, I would break down the expiration data further by month or quarter to detect more granular patterns.
+""")

.local/share/code-server/User/History/450b0aa/ksQB.py

@@ -0,0 +1,73 @@
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load the dataset
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Convert 'Original Issue Date' to datetime and dropping rows with missing data
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Count the number of licenses for each License Type and get top 10
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+top_10_license_types = license_type_counts.head(10)
+st.header("1. Top 10 License Types by Frequency")
+
+# Bar chart for the top 10 license types
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+st.altair_chart(bar_chart, use_container_width=True)
+
+# Write-Up for first plot
+st.markdown("""
+This bar chart highlights the top 10 most frequent license types in the dataset. The x-axis represents the count of each license type, while the y-axis shows the name of the license type. 
+ The chart is sorted in descending order of the license count.
+
+I started by creating a bar chart for all license types, but the chart was difficult to read because many types had very low frequency, making the visualization cluttered. 
+To improve this, I focused on the top 10 most frequent license types, which allowed for a clearer and more insightful view of the most prevalent licenses in the dataset. 
+Since some license names were long, I made sure that the full text is visible when you hover on the bar chart.""")
+
+# Convert 'Expiration Date' to datetime and extract the year
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("4. Trend of Licenses Expiring Over Time")
+
+# Create trend line (line chart) with circle marks at data points
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine line and points
+final_chart = line_chart + points
+
+st.altair_chart(final_chart, use_container_width=True)
+
+# Markdown Write-Up for the trend line chart
+st.markdown("""
+**Highlights**: This line chart shows the trend of licenses expiring over time, highlighting seasonal or yearly variations in license expirations.
+
+**Design Choices**: The x-axis represents the expiration year, while the y-axis shows the number of licenses expiring. The line shows the overall trend, with circles marking individual data points for better visibility. Tooltips provide more details when hovering.
+
+**Improvements**: If I had more time, I would break down the expiration data further by month or quarter to detect more granular patterns.
+""")

.local/share/code-server/User/History/450b0aa/mE68.py

@@ -0,0 +1,75 @@
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load the dataset
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Convert 'Original Issue Date' to datetime and dropping rows with missing data
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Count the number of licenses for each License Type and get top 10
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+top_10_license_types = license_type_counts.head(10)
+st.header("1. Top 10 License Types by Frequency")
+
+# Bar chart for the top 10 license types
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+st.altair_chart(bar_chart, use_container_width=True)
+
+# Write-Up for first plot
+st.markdown("""
+This bar chart highlights the top 10 most frequent license types in the dataset. The x-axis represents the count of each license type, while the y-axis shows the name of the license type. 
+The bars are color-coded to differentiate between the license types. This makes it easy for users to visually distinguish between each category. The chart is sorted in descending order of the license count.
+
+I started by creating a bar chart for all license types, but the chart was difficult to read because many types had very low frequency. 
+To improve this, I focused on the top 10 most frequent license types. 
+Some license names were long, I made sure that the full text is visible when you hover on the bar chart. 
+If I had more time, I would like to find a way to make the column names more readable on the y-axis and include all license types without making the visualization too cluttered""")
+
+# Convert 'Expiration Date' to datetime and extract the year
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("2. Trend of Licenses Expiring Over Time")
+
+# Create trend line (line chart) with circle marks at data points
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine line and points
+final_chart = line_chart + points
+
+st.altair_chart(final_chart, use_container_width=True)
+
+# Markdown Write-Up for the trend line chart
+st.markdown("""
+This line chart shows the trend of licenses expiring over time, highlighting variations in license expirations. The x-axis represents the expiration year, while the y-axis shows the number of licenses expiring.
+The line shows the overall trend, with circles marking individual data points for better visibility. Tooltips provide more details when hovering.
+
+I chose a trend line because it clearly shows how the number of licenses expiring changes over time. 
+By plotting the data in this way, I can easily spot patterns or spikes in expiration rates. 
+The trend line gives a quick overview of the overall trend, while the circles on the data points highlight key years with significant changes.
+If I had more time, I would break down the expiration data further by month or quarter to detect more granular patterns and find a way to make it all of it more organized""")

.local/share/code-server/User/History/450b0aa/qzJp.py

@@ -0,0 +1,75 @@
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load the dataset
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Convert 'Original Issue Date' to datetime and dropping rows with missing data
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Count the number of licenses for each License Type and get top 10
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+top_10_license_types = license_type_counts.head(10)
+st.header("1. Top 10 License Types by Frequency")
+
+# Bar chart for the top 10 license types
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+st.altair_chart(bar_chart, use_container_width=True)
+
+# Write-Up for first plot
+st.markdown("""
+This bar chart highlights the top 10 most frequent license types in the dataset. The x-axis represents the count of each license type, while the y-axis shows the name of the license type. 
+The bars are color-coded to differentiate between the license types. This makes it easy for users to visually distinguish between each category. The chart is sorted in descending order of the license count.
+
+I started by creating a bar chart for all license types, but the chart was difficult to read because many types had very low frequency. 
+To improve this, I focused on the top 10 most frequent license types. 
+Some license names were long, so I made sure that full text is visible when you hover on the bars. 
+If I had more time, I would like to find a way to make the column names more readable on the y-axis and include all license types without making the visualization too cluttered""")
+
+# Convert 'Expiration Date' to datetime and extract the year
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("2. Trend of Licenses Expiring Over Time")
+
+# Trend line
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine line and points
+final_chart = line_chart + points
+
+st.altair_chart(final_chart, use_container_width=True)
+
+# Write-Up for second plot
+st.markdown("""
+This line chart shows the trend of licenses expiring over time, highlighting variations in license expirations. The x-axis represents the expiration year, while the y-axis shows the number of licenses expiring.
+The line shows the overall trend, with circles marking individual data points for better visibility. Tooltips provide more details when hovering.
+
+I chose a trend line because it clearly shows how the number of licenses expiring changes over time. 
+By plotting the data in this way, I can easily spot patterns or spikes in expiration rates. 
+The trend line gives a quick overview of the overall trend, while the circles on the data points highlight key years with significant changes.
+If I had more time, I would break down the expiration data further by month or quarter to detect more granular patterns and find a way to make it all of it more organized""")

.local/share/code-server/User/History/450b0aa/rykv.py

@@ -0,0 +1,75 @@
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+# Load the dataset
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Convert 'Original Issue Date' to datetime and dropping rows with missing data
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Count the number of licenses for each License Type and get top 10
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+top_10_license_types = license_type_counts.head(10)
+st.header("1. Top 10 License Types by Frequency")
+
+# Bar chart for the top 10 license types
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+)
+st.altair_chart(bar_chart, use_container_width=True)
+
+# Write-Up for first plot
+st.markdown("""
+This bar chart highlights the top 10 most frequent license types in the dataset. The x-axis represents the count of each license type, while the y-axis shows the name of the license type. 
+The bars are color-coded to differentiate between the license types. This makes it easy for users to visually distinguish between each category. The chart is sorted in descending order of the license count.
+
+I started by creating a bar chart for all license types, but the chart was difficult to read because many types had very low frequency. 
+To improve this, I focused on the top 10 most frequent license types. 
+Some license names were long, so I made sure that full text is visible when you hover on the bars. 
+If I had more time, I would like to find a way to make the column names more readable on the y-axis and include all license types without making the visualization too cluttered""")
+
+# Convert 'Expiration Date' to datetime and extract the year
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+st.header("2. Trend of Licenses Expiring Over Time")
+
+# Create trend line (line chart) with circle marks at data points
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+points = alt.Chart(expiration_counts).mark_point(shape='circle', filled=True, size=50).encode(
+    x=alt.X('Expiration Year:O'),
+    y=alt.Y('License Count:Q'),
+    tooltip=['Expiration Year', 'License Count']
+)
+
+# Combine line and points
+final_chart = line_chart + points
+
+st.altair_chart(final_chart, use_container_width=True)
+
+# Write-Up for second plot
+st.markdown("""
+This line chart shows the trend of licenses expiring over time, highlighting variations in license expirations. The x-axis represents the expiration year, while the y-axis shows the number of licenses expiring.
+The line shows the overall trend, with circles marking individual data points for better visibility. Tooltips provide more details when hovering.
+
+I chose a trend line because it clearly shows how the number of licenses expiring changes over time. 
+By plotting the data in this way, I can easily spot patterns or spikes in expiration rates. 
+The trend line gives a quick overview of the overall trend, while the circles on the data points highlight key years with significant changes.
+If I had more time, I would break down the expiration data further by month or quarter to detect more granular patterns and find a way to make it all of it more organized""")

.local/share/code-server/User/History/450b0aa/s0Hs.py

@@ -0,0 +1,250 @@
+# put streamlit code here as needed
+import pandas as pd
+import altair as alt
+import streamlit as st
+
+#import the data
+#url = "https://raw.githubusercontent.com/UIUC-iSchool-DataViz/is445_data/main/ufo-scrubbed-geocoded-time-standardized-00.csv"
+#df = pd.read_csv(url)
+#df.sum().isnull()
+
+
+
+# #Fill the missing data with Unknown
+# df['County'].fillna('Not available', inplace=True)
+# df['Rep Full Name'].fillna('Not available', inplace=True)
+# df['Year Constructed'].fillna(df['Year Constructed'].median(), inplace=True)
+# df['Senator Full Name'].fillna('Unknown', inplace=True)
+# df['Usage Description 2'].fillna(df['Usage Description 2'].mode()[0], inplace=True)
+# df['Usage Description 3'].fillna(df['Usage Description 3'].mode()[0], inplace=True)
+# df['Address'].fillna('Not available', inplace=True)
+# df['Congressional Full Name'].fillna('Unknown', inplace=True)
+
+# #Page Title
+# st.markdown("<h1 style='text-align: center;'>Homework 5.1</h1>", unsafe_allow_html=True)
+
+# st.subheader("Analyzing the Building Inventory Dataset")
+# #Visualization 1
+# st.markdown("<h4 style='text-decoration: underline;'>Visualization 1</h4>", unsafe_allow_html=True)
+
+# df_filtered = df.dropna(subset=['Bldg Status', 'Year Constructed'])
+# df_filtered['Year Constructed'] = pd.to_numeric(df_filtered['Year Constructed'], errors='coerce')
+# df_filtered = df_filtered[(df_filtered['Year Constructed'] >= 1600) & (df_filtered['Year Constructed'] <= 2100)]
+
+
+# line_chart = alt.Chart(df_filtered).mark_line(point=True).encode(
+#     x=alt.X('Year Constructed:Q', title='Year Constructed'),
+#     y=alt.Y('count()', title='Number of Buildings'),
+#     color=alt.Color('Bldg Status:N', title='Building Status'),
+#     tooltip=['Year Constructed', 'count()', 'Bldg Status']
+# ).properties(
+#     width=700,
+#     height=400,
+#     title="Trend of Building Construction by Status"
+# )
+# st.altair_chart(line_chart, use_container_width=True)
+# st.write("""
+# This line chart highlights the trend in the number of buildings constructed over time, 
+# categorized by their building status (e.g., whether they are currently in use or not). 
+# The x-axis represents the 'Year Constructed' and the y-axis represents the count of buildings. 
+# The color encoding separates the buildings by their 'Bldg Status' 
+# I used a line plot with points to clearly indicate the number of buildings per year, 
+# which helps in identifying trends and peaks. Another reason is that line chart is ideal for 
+# visualizing time-series data. The colors are chosen to differentiate the building statuses 
+# effectively. 
+
+# If I had more time, I would consider adding labels to the data points for clarity and 
+# perhaps break down the data further by usage description or location for a more detailed analysis.
+# Probably adding hover effects could display additional information, such as the exact count of 
+# buildings and their status, when hovering over each data point. This would allow users to gain 
+# deeper insights without cluttering the chart. I would also include filtering options so users 
+# could select specific building statuses or even a range of years to focus on, which would make
+# the analysis more targeted. 
+# """)
+
+
+# # Visualization 2
+# st.markdown("<h4 style='text-decoration: underline;'>Visualization 2</h4>", unsafe_allow_html=True)
+# county_agency_data = df.dropna(subset=['County', 'Agency Name'])
+# county_agency_count = county_agency_data.groupby('County')['Agency Name'].nunique().reset_index()
+# county_agency_count.rename(columns={'Agency Name': 'Unique Agencies'}, inplace=True)
+
+# county_agency_chart = alt.Chart(county_agency_count).mark_bar().encode(
+#     x=alt.X('County:N', sort='-y', title="County"),
+#     y=alt.Y('Unique Agencies:Q', title="Number of Agencies"),
+#     color=alt.Color('Unique Agencies:Q', scale=alt.Scale(scheme='viridis')),
+#     tooltip=['County:N', 'Unique Agencies:Q']
+# ).properties(
+#     width=700,
+#     height=400,
+#     title="Unique Agencies in Each County"
+# )
+# st.altair_chart(county_agency_chart, use_container_width=True)
+
+# st.write("""
+# This bar chart highlights the number of unique agencies operating in each county. 
+# The x-axis represents the 'County' and the y-axis represents the 'Number of Unique Agencies' 
+# I used a bar chart as it allows for easy comparison between counties based on the number of
+# agencies, and sorting the counties by agency count makes it easier to identify areas with 
+# more agencies. The color scale uses a 'viridis' color scheme, to show how the number of agencies
+# differs accross counties. 
+
+# If I had more time, I would consider adding interactivity, like a filter for 'Building Status', so that users can
+# focus on specific statuses, such as buildings that are still in progress or abandoned for each county. 
+# I would also implement a slider for 'Year Constructed' to allow users to focus on specific time periods, 
+# enabling them to analyze trends and compare the distribution of agencies by different time periods. 
+# I would also consider adding a search function so that users can look for specific counties 
+# or agency types.
+# """)
+# Load State GeoJSON for Map (example if supported)
+# Visualization: Licenses by State
+
+
+# Load Dataset
+@st.cache
+def load_data():
+    url = "https://github.com/UIUC-iSchool-DataViz/is445_data/raw/main/licenses_fall2022.csv"
+    return pd.read_csv(url)
+
+df = load_data()
+
+# Handle Missing Values for Visualizations
+# 1. Remove rows with missing `Original Issue Date`
+df['Original Issue Date'] = pd.to_datetime(df['Original Issue Date'], errors='coerce')
+df_time = df.dropna(subset=['Original Issue Date'])
+
+# Title
+st.title("Licenses Dataset Visualizations")
+st.markdown("This app presents three visualizations of the licenses dataset.")
+
+# Visualization 1: Bar Chart (Distribution of Licenses by Type)
+st.header("1. Distribution of Licenses by Type")
+license_count = df['License Type'].value_counts().reset_index()
+license_count.columns = ['License Type', 'Count']
+
+bar_chart = alt.Chart(license_count).mark_bar().encode(
+    x=alt.X('Count:Q', title='Number of Licenses'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type'),
+    color=alt.Color('License Type:N', legend=None)
+).properties(title="Number of Licenses by Type")
+
+st.altair_chart(bar_chart, use_container_width=True)
+
+st.markdown("""
+**Highlights**: This bar chart shows the distribution of licenses by type.
+**Design Choices**: A horizontal bar chart is used for better readability of license types.
+""")
+
+# Visualization 2: Line Chart (Trend of Licenses Over Time)
+st.header("2. Trend of Licenses Over Time")
+time_data = df_time.groupby(df_time['Original Issue Date'].dt.year).size().reset_index(name='Count')
+time_data.columns = ['Year', 'Count']
+
+line_chart = alt.Chart(time_data).mark_line(point=True).encode(
+    x=alt.X('Year:O', title='Year'),
+    y=alt.Y('Count:Q', title='Number of Licenses'),
+    color=alt.value('blue')
+).properties(title="Trend of Licenses Issued Over Years")
+
+st.altair_chart(line_chart, use_container_width=True)
+
+st.markdown("""
+**Highlights**: This line chart shows the trend of license issuances over time.
+**Design Choices**: Points are added to highlight specific data points, and the color blue is chosen for simplicity.
+""")
+
+
+# Count the number of licenses for each License Type and sort by count
+license_type_counts = df['License Type'].value_counts().reset_index()
+license_type_counts.columns = ['License Type', 'Count']
+
+# Get the top 10 License Types
+top_10_license_types = license_type_counts.head(10)
+
+# Create the bar chart
+bar_chart = alt.Chart(top_10_license_types).mark_bar().encode(
+    x=alt.X('Count:Q', title='License Count'),
+    y=alt.Y('License Type:N', sort='-x', title='License Type', axis=alt.Axis(labelPadding=15)),
+    color=alt.Color('License Type:N', legend=None),
+    tooltip=['License Type', 'Count']
+).properties(
+    title='Top 10 License Types by Frequency'
+)
+
+# Show the chart in the Streamlit app
+st.altair_chart(bar_chart, use_container_width=True)
+
+# Convert the Expiration Date to datetime (if not already)
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+
+# Extract the month and year from Expiration Date
+df['Expiration Year'] = df['Expiration Date'].dt.year
+df['Expiration Month'] = df['Expiration Date'].dt.month
+
+# Group by year and month and count the number of licenses expiring
+expiration_counts = df.groupby(['Expiration Year', 'Expiration Month']).size().reset_index(name='License Count')
+
+# Convert the Expiration Date to datetime (if not already)
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+
+# Extract the year from Expiration Date
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+
+# Create the trend line (line chart)
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+).properties(
+    title='Trend Line for License Expirations Over Time'
+)
+
+# Show the chart in the Streamlit app
+st.altair_chart(line_chart, use_container_width=True)
+# Convert the Expiration Date to datetime (if not already)
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+
+# Extract the year from Expiration Date
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+
+# Create the trend line (line chart)
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']
+).properties(
+    title='Trend Line for Licenses Expiring Over Time'
+)
+
+# Show the chart in the Streamlit app
+st.altair_chart(line_chart, use_container_width=True)
+
+
+
+
+# Convert the Expiration Date to datetime (if not already)
+df['Expiration Date'] = pd.to_datetime(df['Expiration Date'], errors='coerce')
+
+# Extract the year from Expiration Date
+df['Expiration Year'] = df['Expiration Date'].dt.year
+
+# Group by Expiration Year and count the number of licenses expiring
+expiration_counts = df.groupby('Expiration Year').size().reset_index(name='License Count')
+
+# Create the trend line (line chart) with interactive data points
+line_chart = alt.Chart(expiration_counts).mark_line().encode(
+    x=alt.X('Expiration Year:O', title='Expiration Year'),
+    y=alt.Y('License Count:Q', title='Number of Licenses Expiring'),
+    tooltip=['Expiration Year', 'License Count']  # Tooltip for interactivity
+).properties(
+    title='Trend Line for Licenses Expiring Over Time'
+).interactive()  # Make the chart interactive
+
+# Show the chart in the Streamlit app
+st.altair_chart(line_chart, use_container_width=True)