DEV Community: Dhanush D

Balancing Imbalanced Datasets with SMOTE: A Baking Analogy

Dhanush D — Thu, 02 Oct 2025 11:08:01 +0000

Dealing with imbalanced datasets is one of the trickiest parts of machine learning. Imagine you’re building a classifier to detect credit card fraud: out of 10,000 transactions, maybe only 100 are fraudulent. If you simply train a model on this dataset, it could achieve 99% accuracy by predicting “not fraud” every single time while completely failing at the task you actually care about.

That’s where SMOTE (Synthetic Minority Oversampling Technique) comes in. Let’s explore this idea with something everyone loves: cake.

The Baking Analogy

Think of your machine learning project as baking a cake:

The recipe = your learning algorithm

The ingredients = your training data

The cake = your predictive model

Now, imagine you have way too many eggs (the majority class) and very little flour (the minority class). Clearly, your cake won’t turn out right.

Enter SMOTE: a magical kitchen gadget that can generate more flour. But instead of duplicating the exact flour you already have, it creates slightly new variations synthetic samples based on existing minority data. Suddenly, you have a better balance between eggs and flour, and your cake stands a chance of turning out perfect.

But Here’s the Catch

You also need to set aside some ingredients to make a cupcake—this represents your test set. The cupcake is meant to show you how the cake would taste in the real world.

Here’s the golden rule: never use SMOTE on the test set.

Why? Because that’s like pretending you have more diverse real-world data than you really do. If you enrich your cupcake ingredients with synthetic flour, you’ll get a misleading impression of how good your recipe actually is. The model might perform well on artificially boosted data but fail miserably when faced with real-world input.

Best Practice with Code
Step 1: Split your dataset first
Step 2: Apply SMOTE only on the training set
Step 3: Keep the test set untouched

Here’s how that looks in Python:

from sklearn.model_selection import train_test_split
from imblearn.over_sampling import SMOTE
from collections import Counter

# Example: X = features, y = labels
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y
)

print("Before SMOTE:", Counter(y_train))

# Apply SMOTE only on training set
sm = SMOTE(random_state=42)
X_train_res, y_train_res = sm.fit_resample(X_train, y_train)

print("After SMOTE:", Counter(y_train_res))
print("Test set distribution (untouched):", Counter(y_test))

Notice how only the training set gets resampled, while the test set remains in its original distribution.

Example in Practice

Fraud Detection: If you apply SMOTE before splitting, your test set might contain synthetic fraud cases. That means your model isn’t really being tested on real fraud patterns—it’s being tested on artificially generated ones. The result? Over-optimistic performance metrics.

Medical Diagnosis: Let’s say you’re predicting a rare disease. If you generate synthetic patients in your test set, you’re no longer testing how well your model handles actual rare cases. In a real hospital setting, this could lead to disastrous misdiagnoses.

Wrapping It Up

Machine learning is a lot like baking. It’s about balancing ingredients, adjusting recipes, and sometimes starting over from scratch. SMOTE is a fantastic tool, but only when used correctly. Apply it to your training data, not your test data, and your “cake” (model) will not only rise beautifully but also taste just right in the real world.

Happy baking—and happy modeling!

How to Prompt an LLM to Write Angular Code: Straight from the Experts

Dhanush D — Tue, 24 Jun 2025 12:24:08 +0000

Writing Angular code with an AI assistant is like pair programming with someone who knows everything, but only if you ask the right questions.

This guide will walk you through the best way to prompt LLMs for Angular apps and components, using expert approved TypeScript and Angular practices.

TypeScript and Angular Best Practices

So here’s a checklist of best practices one should expect the LLM to follow. Use these to inform the prompt and verify the output.

TypeScript Best Practices

Use strict type checking

The prompt should always assume the project uses strict: true in tsconfig.json.
Prefer type inference when obvious

Let TypeScript do the work where possible no need to clutter code with redundant types.
Avoid any; use unknown instead

any kills type safety. If you don’t know the type yet, ask for unknown + type guards.

Angular Best Practices

Components

Always use standalone components (No need of standalone: true; it’s implicit).
Use signals and computed() for state management.
Keep components small and single-responsibility.
Use input() and output() functions instead of decorators @input and @output.
Set changeDetection: ChangeDetectionStrategy.OnPush.
Prefer inline templates for small components.
Avoid ngClass and ngStyle use [class] and [style] bindings instead.
Prefer Reactive Forms over template driven ones.

Services

Design services with single responsibility.
Use providedIn: 'root' for singleton services.
Use the inject() function, not constructor injection.

State & Templates

Use signals for local state.
Use computed() for derived values.
Keep state pure and predictable.
In templates, avoid complex logic.
Use native control flow (@if, @for, @switch) over structural directives like *ngIf, *ngFor, *ngSwitch.
Use the async pipe for observables.

Assets & Routing

Use NgOptimizedImage for all static images.
Use lazy loading for all feature routes.

When Reviewing LLM Generated Code

LLMs can hallucinate or use outdated patterns. When reviewing the code, always check for:

✅ Use of signals over RxJS unless necessary
✅ computed() for derived state
✅ Proper use of inject() in services
✅ Inline templates for simple components
✅ Avoidance of *ngIf, *ngFor in favor of @if, @for
✅ No ngClass or ngStyle

Happy prompting

How do signals in Angular 20 simplify reactive programming for me

Dhanush D — Sun, 22 Jun 2025 12:37:05 +0000

Signals in Angular 20 fundamentally simplify reactive programming by offering a lightweight, synchronous, and intuitive way to manage state changes in the application. Here’s how they make my life as a developer easier:

1. No More Manual Subscriptions

Unlike RxJS Observables, which require to manually subscribe and unsubscribe to avoid memory leaks, signals automatically notify the templates and dependent code when their values change. This eliminates a common source of bugs and boilerplate code.

Example:

import { signal } from '@angular/core';

const count = signal(0);

count.set(1); // Update value
console.log(count()); // Read value: 1

I don’t need to manage subscriptions—Angular takes care of it for me.

2. Fine-Grained Reactivity

Signals ensure that only the parts of your application that depend on a particular piece of state (like a template or computed value) are updated when that state changes. This leads to better performance because unnecessary re-renders are minimized.

Example:

const x = signal(5);
const y = signal(3);
const z = computed(() => x() + y());

console.log(z()); // Output: 8
x.set(10);
console.log(z()); // Output: 13 (z updates automatically)

Here, z only updates when x or y changes, not for every unrelated state change.

3. Easy Integration with Templates

I can bind signals directly in my templates, and Angular ensures the UI stays in sync with the underlying data.

Example:

// In my component
count = signal(0);
increment() { this.count.update(v => v + 1); }

<p>Count: {{ count() }}</p>
<button (click)="increment()">Increment</button>

The template updates automatically when count changes.

4. Predictable and Debuggable State Management

Signals make it clear where state changes originate and how they propagate, which simplifies debugging and reasoning about my app’s behavior. I don’t have to track down complex chains of subscriptions or worry about side effects from unrelated state changes.

5. Reduced Boilerplate and Complexity

Signals require less code than traditional RxJS patterns, especially for local component state. I don’t need to set up Subjects, manage subscriptions, or deal with the mental overhead of async streams when I don’t need them.

In summary:
Signals in Angular 20 let's me write reactive code that’s easier to read, maintain, and debug. They automatically keep my UI in sync with the data, reduce boilerplate, and help me avoid common pitfalls associated with manual subscription management.

Streamlit Dashboard: Let's analyse how Virat Kohli performs!

Dhanush D — Thu, 19 Jun 2025 08:24:30 +0000

🏏 Player Analytics: An Interactive Dashboard for Cricket Lovers

Hi, I'm Dhanush Devadiga — a front-end developer and passionate analyst. But at the same time, I’m also a cricket enthusiast and a fan of Virat Kohli, arguably the best batsman in the world today.

So, I thought, why not combine my love for cricket and data? That’s how I built Player Analytics, an interactive dashboard to analyze player performance, provide insights, and even predict future outcomes.

GitHub repo: https://github.com/dhanushd1998/streamlit-cricket-performance-dashboard.git
Live Demo: https://dhanushd1998-cricket-performance-dashboard-main-ejl7hp.streamlit.app/
Data Set on Kaggle: https://www.kaggle.com/code/dhanush1998/virat-kohli-performance-dashboard-analytics
youTube: https://lnkd.in/gBy-rdXq

🎨 UI & Design Highlights

Page Title: Set to “Player Analytics” for easy tab identification.
Favicon: A cricket themed logo serves as a visual identifier.
Layout: Wide mode enabled for better screen utilization.
Theme: Customized using config.toml to reflect India’s blue jersey and a dark mode aesthetic.
Sidebar: Starts collapsed by default and is reserved strictly for navigation via radio buttons.

📊 Understanding the Dashboard

On initial load, the Cricket Performance Dashboard is visible. If you’re not a cricket follower, here’s some context:

Cricket has three primary formats:

ODI (One Day Internationals) – the most popular
Test Matches – the longest format
T20 (Twenty20) – the shortest and most fast-paced

Virat Kohli is a three-format player, so his data spans across all these formats.

🔁 Dynamic Tabs & Metrics

The dashboard allows users to:

Switch between formats (ODI, Test, T20) using tabs.
Automatically update plots and metrics according to the selected format.

Key Metrics Displayed:

Total Runs
Matches Played
Average Strike Rate
Best Score
Number of Hundreds (100s)
Number of Fifties (50s)

👤 About Tab

This page gives a short introduction of the cricketer being analyzed — essential to establish context for the user.

🔮 Score Predictor

This page showcases cascading filter criteria to introduce predictive analytics.

How it works:

Select Match Type, Opposition, and Ground.
Based on historical data, the model predicts a potential score.

The filter values are dependent:

For example, choosing ODI and England shows Indian or English grounds.
Choosing T20 and Ireland filters the ground to Malahide in Ireland.

📋 Interactive Data Table

Features include:

Filtering by match type
Sorting by date (newest/oldest)
Filtering by opposition
Year range selection using a slider
Download filtered data as CSV

🧪 Example:

Filter for all T20 matches against England and Australia between 2010–2020 — and easily download the results.

📈 Visualizations

1. Area Plot — Runs Scored vs Year

Configuration hidden inside a Streamlit expander for a cleaner UI.
Allows selection of a year range to analyze performance trends.

2. Spider Plot — Matches by Country

Visualize the number of matches played against top N countries.
Default is top 6 countries.
Helps identify dominant matchups.

3. Bar Plot — Top 5 Scoring Grounds

Test: Highest runs at Adelaide
ODI: Highest runs at Mirpur

4. Vertical Bar Plot — Runs by Batting Position

T20: Highest runs at No. 3 position
Test: Highest at No. 4
Helps understand role evolution and effectiveness by position.

5. Line Chart — Total Runs Over Time

Select a year range to view trends.
From 2010–2020: Notable 56.68% dip (possibly due to COVID-19).
From 2008–2010: Positive upward trend.

🧠 Why Cricket Analytics Matters

In a billion-dollar sport where every run counts, data-driven insights are crucial. This dashboard transforms raw match data into actionable intelligence.

Cricketlytics (Cricket + Analytics) is on the rise — used by analysts, broadcasters, coaches, and fans alike.

⚠️ Current Drawbacks

Data is preloaded from a static CSV
No real-time data or API integration
Lacks light/dark mode switching
Best viewed on desktop, not optimized for mobile yet

🚀 Future Enhancements

API Integration for live stats
Advanced AI Models for score predictions
Add more visualizations (wagon wheels, dismissals, partnerships)
Player Comparison Tool
Mobile responsiveness / Progressive Web App (PWA)
Light/Dark mode toggle
Integration with platforms like Paddy Power or BoyleSports for monetization

🏁 Final Thoughts

This project represents the fusion of data, design, and cricket fandom. Whether you’re an analyst, developer, or just a cricket fan — this dashboard has something insightful for you.

“In cricket, your bat talks louder than words. But now, so can your data.”

Feel free to explore the dashboard, offer feedback, or suggest collaborations!

📌 Built using Python, Streamlit, Pandas, and Plotly — powered by a love for cricket and clean UI.

Read this Hands-on article on Data Visualization

Dhanush D — Wed, 16 Apr 2025 17:08:08 +0000

Dhanush D

Apr 11 '25

Art of Story telling with Data Visualization

#python #kaggle #matplot #datascience

Comments 2

16 min read

Art of Story telling with Data Visualization

Dhanush D — Fri, 11 Apr 2025 11:51:17 +0000

🔍Exploratory Data Analysis and Data Visualization with Python

Streaming services have become a crucial part of our entertainment routine. In this blog, we’ll walk through an Exploratory Data Analysis (EDA)and Data Visualization of Amazon Prime Video content using Python. This includes data cleaning, visualization, and insight extraction. Let’s dive in! 💻📊

First thing's first

Clone the repository using the Repo link provided and install the required libraries as provided in the requirements.txt file.
Link to the Github Repository: Amazon-prime

⚙️ Setting Up the Environment

We begin by importing the essential Python libraries for data analysis and visualization.

import numpy as np
import pandas as pd
import plotly.graph_objs as go
import matplotlib.colors
import warnings
warnings.filterwarnings("ignore")
import matplotlib.pyplot as plt
import seaborn as sns
import plotly as py
from datetime import datetime
import datetime as dt

📥 Loading and Understanding the Data

Let's load the dataset and get an initial understanding of its structure.

amazon_csv = pd.read_csv('Amazon_prime_titles.csv')
amazon_csv.shape

📊 Exploratory Data Analysis

np.random.seed(0) #seed for reproducibility
amazon_csv.sample(5)

Yes, it looks like there's some missing values.
Lets do some Initial data exploration and data cleaning

🧼 Checking Missing Data

# Operator to find null/ missing values
print('Percentage of null values in the given data set:')
for col in amazon_csv.columns:
  null_count = amazon_csv[col].isna().sum()/len(amazon_csv)*100
  if null_count > 0:
    print(f'{col}  : {round(null_count,2)}%')

Loops through the columns and finds the percentage of null values

✅ Validating Columns

# Define valid values
valid_types = {"Movie", "TV Show"}

# Find invalid values
invalid_types = amazon_csv[~amazon_csv['type'].isin(valid_types)]

# Check if any invalid values exist
if invalid_types.empty:
    print("Valid values")
else:
    print("\nInvalid 'type' values:")
    print(invalid_types['type'].unique())

Above code checks if the type column has any invalid values other than "TV Show" and "Movies"

# Check if there are any invalid ratings (less than 0 or greater than 10)
if ((amazon_csv['rating'] < 0.0) | (amazon_csv['rating'] > 10.0)).any():
    print("Invalid")
else:
    print("Valid range")

🎨 Amazon Prime Color Palette

Using Sea born lets visualize the data set. Let's use Amazon Prime color palette for all the visualizations.

# Amazon Prime Video brand colors
sns.palplot(['#00A8E1', '#232F3E', '#FFFFFF', '#B4B4B4'])

plt.title("Amazon Prime Brand Palette", loc='left',  fontweight="bold",  fontsize=16, color='#4a4a4a', y=1.2)
plt.show()

📈 Summary Statistics

# summary statistics
print("\nSummary Statistics:\n", amazon_csv.describe())

The above code gives us the summary statistics of the data set.

📉 Histograms and Box Plots

# new column 'duration_numeric'
amazon_csv['duration_numeric'] = amazon_csv['duration'].str.extract(r'(\d+)').astype(float)

#seaborn style and color palette
sns.set(style="whitegrid", rc={"font.family": "serif"})
palette = ['#00A8E1', '#232F3E', '#FFFFFF', '#B4B4B4']

#subplots for histograms
fig, axes = plt.subplots(1, 3, figsize=(18, 5))
fig.suptitle("Exploratory Data Analysis by plotting the Histogram and Box Plots", fontsize=16, fontweight='bold', family='serif')

# aesthetics
for ax in axes:
    ax.spines["top"].set_visible(False)
    ax.spines["right"].set_visible(False)
    ax.spines["left"].set_visible(False)
    ax.spines["bottom"].set_visible(False)

# Histogram for Release Year
sns.histplot(amazon_csv['release_year'], bins=30, kde=True, ax=axes[0], color=palette[0])
axes[0].set_title("Distribution of Release Years")
axes[0].set_xlabel("Year")

# Histogram for Rating
sns.histplot(amazon_csv['rating'].dropna(), bins=30, kde=True, ax=axes[1], color=palette[1])
axes[1].set_title("Distribution of Ratings")
axes[1].set_xlabel("Rating")

# Histogram for Duration
sns.histplot(amazon_csv['duration_numeric'].dropna(), bins=30, kde=True, ax=axes[2], color=palette[3])
axes[2].set_title("Distribution of Duration (Minutes)")
axes[2].set_xlabel("Duration (Minutes)")

plt.tight_layout()
plt.show()

# box plots
fig, axes = plt.subplots(1, 3, figsize=(18, 5))
for ax in axes:
    ax.spines["top"].set_visible(False)
    ax.spines["right"].set_visible(False)
    ax.spines["left"].set_visible(False)
    ax.spines["bottom"].set_visible(False)

sns.boxplot(y=amazon_csv['release_year'], ax=axes[0], color=palette[0])
axes[0].set_title("Box Plot of Release Years")

sns.boxplot(y=amazon_csv['rating'], ax=axes[1], color=palette[1])
axes[1].set_title("Box Plot of Ratings")

sns.boxplot(y=amazon_csv['duration_numeric'], ax=axes[2], color=palette[3])
axes[2].set_title("Box Plot of Duration (Minutes)")
plt.tight_layout()
plt.show()

Histogram: Displays the frequency distribution of content duration. Rating values has a bell shaped spread of data with values from 0 to 10, with a peak 7.0. Release year is skewed towards year towards 2005 and beyond. Shows that spread is more towards newer contents.
Boxplots: Show the distribution of ratings and release years, highlighting outliers. The duration box plot shows a time duration of 600 minutes, which could be outlier or a lengthy movie.

⚠️ Insights on Missing Values

It's tracked that values are missing in 5 columns Director, Cast, Country , Date_added and rating.

Date added columns has the highest missing counts
Missing values in Ratings are the lowest
Fair share of missing values in director, followed by cast, country and age_group column.

🧹 Data Cleaning

🌍 Handling Missing Country Data

I will replace NULL values in the 'country' column with the MODE value.

Let's deal with the missing Data

For the given dataset, with N = 7786, my approach for data cleaning will be:

I will replace NULL values in the 'country' column with the MODE value.

Why: Since the 'country' column is categorical, replacing missing values with the most common country (the mode) seems like a good choice. Because I’m keeping the most frequent value, which makes sense for the analysis.

🗑️ Dropping Columns and Rows

I will drop the row in the 'Cast' column if it has NULL values.

Why: The 'Cast' column is crucial for understanding the movie’s popularity. It’s better to drop that row so it doesn't mess up the analysis.

I will drop the whole 'Date Added' column since it might not provide any significant insight, especially since there are so many NULL values.

Why: 'Date Added' has too many NULL values, and it’s probably not useful for the analysis.

🎭 Handling Missing Cast and Director Data

I will keep the 'Director' as it is.

Why: The 'Director' column seems important, and there doesn't seem to be much missing data here. So, it’s best to leave it untouched because it might provide important information for understanding the movie.

I will drop the whole 'Date Added' column since it might not provide any significant insight, especially since there are so many NULL values.

#Drop the column date_added
amazon_csv.drop(columns=['date_added'], inplace=True)

# Replace missing values in 'country' with its mode (most frequent value)
amazon_csv['country'].fillna(amazon_csv['country'].mode()[0], inplace=True)

# Replace missing values in 'director' and 'cast' with "Not available"
amazon_csv[['director', 'cast']] = amazon_csv[['director', 'cast']].fillna("Not available")

# Drop rows where 'age group' or 'rating' are missing
amazon_csv.dropna(subset=['age_group', 'rating'], inplace=True)

# Reset index after dropping rows
amazon_csv.reset_index(drop=True, inplace=True)

📽️ Data Visualization

🕰️ Amazon Prime Timeline

Lets create a time line, to show the progress of Amazon Prime over the years. Timeline plotting code inspired from Subin An's notebook


# Set figure & Axes
fig, ax = plt.subplots(figsize=(15, 4), constrained_layout=True)
ax.set_ylim(-2, 1.75)
ax.set_xlim(0, 10)


# Timeline : line
ax.axhline(0, xmin=0.1, xmax=0.68, c='#B4B4B4', zorder=1)
# these values go on the numbers below
tl_dates = [
    "1994\nFounded",
    "2006\nIntroduced Prime",
    "2015\n100M Users",
    "2024\nPrime membership hits 250M"
]

tl_x = [1, 2.6, 4.3,6.8]
## these go on the numbers
tl_sub_x = [2.3,3.5,4.1,5.1,5.8]

tl_sub_times = [
    "2005","2010","2014","2016","2020"
]
# these values go on Stemplot : vertical line
tl_text = [
    "Amazon Prime Launched","First Amazon Original","Amazon adds streaming benefits", "India Launch (My birthplace)", "Prime Video Goes Global"]

# Timeline : Date Points
ax.scatter(tl_x, np.zeros(len(tl_x)), s=120, c='#4a4a4a', zorder=2)
ax.scatter(tl_x, np.zeros(len(tl_x)), s=30, c='#fafafa', zorder=3)
# Timeline : Time Points
ax.scatter(tl_sub_x, np.zeros(len(tl_sub_x)), s=50, c='#4a4a4a',zorder=4)

# Date Text
for x, date in zip(tl_x, tl_dates):
    ax.text(x, -0.55, date, ha='center',
             fontweight='bold',
            color='#4a4a4a',fontfamily='serif',fontsize=12)

# Stemplot : vertical line
levels = np.zeros(len(tl_sub_x))
levels[::2] = 0.3
levels[1::2] = -0.3

markerline, stemline, baseline = ax.stem(tl_sub_x, levels)
plt.setp(baseline, zorder=0)
plt.setp(markerline, marker=',', color='#4a4a4a')
plt.setp(stemline, color='#232F3E')


# Remove the Spine around the plot
for spine in ["left", "top", "right", "bottom"]:
    ax.spines[spine].set_visible(False)

# Ticks
ax.set_xticks([])
ax.set_yticks([])

# Title
ax.set_title("Amazon through the years", fontweight="bold",  fontsize=16,fontfamily='serif', color='#4a4a4a')
ax.text(2.4,1.57,"From Fast Shipping to Global Streaming - Popular streaming service for movies and TV shows.",  fontsize=12, fontfamily='serif',color='#4a4a4a')

# Text
for idx, x, time, txt in zip(range(1, len(tl_sub_x)+1), tl_sub_x, tl_sub_times, tl_text):
    ax.text(x, 1.3*(idx%2)-0.5, time, ha='center',
             fontweight='bold',
            color='#4a4a4a' if idx!=len(tl_sub_x)-1 else '#00A8E1', fontfamily='serif',fontsize=11)

    ax.text(x, 1.3*(idx%2)-0.6, txt, va='top', ha='center',fontfamily='serif',
        color='#4a4a4a' if idx!=len(tl_sub_x)-1 else '#00A8E1')
plt.show()

🌐 Country-Wise Content Analysis

Helper code for better display of country names , also since a few movies have more than one Country I am seggeregating. Also Group country and get the total count and sort in descending order.

amazon_csv['count'] = 1
# Extract the first country from the 'country' column
amazon_csv['first_country'] = amazon_csv['country'].apply(lambda x: x.split(",")[0])

# Shorten country names
amazon_csv['first_country'].replace({'United States': 'USA','United Kingdom': 'UK','South Korea': 'S. Korea'}, inplace=True)

# Group by country and get total count
df_country = amazon_csv.groupby('first_country')['count'].sum().sort_values(ascending=False)

Let's use Plotly's choropleth map to show country wise release of Movies/ TV shows on Amazon Prime.
Load a new CSV for ISO Code of countries, as choropleth takes one of these as the input for plotting.
Merge this with the Amazon CSV to map it with the choropleth.

# Load the ISO code CSV data
iso_df = pd.read_csv('country_iso_codes.csv')


# Merge the country counts with the ISO codes
merged_df = pd.merge(countriess, iso_df, left_index=True, right_on='Country')


# Define Amazon Prime themed color scale for specific ranges for better visibility
custom_colorscale = [
    (0.0, '#00A8E1'),  # Highest values (Prime Blue)
    (0.1, '#0073CF'),  # 700-800 range (Deep Blue)
    (0.2, '#005BB5'),  # 600-700 range (Darker Blue)
    (0.3, '#004494'),  # 500-600 range (Navy Blue)
    (0.4, '#002E73'),  # 400-500 range (Deep Navy)
    (0.5, '#001A52'),  # 300-400 range (Dark Indigo)
    (0.6, '#232F3E'),  # 100-300 range (Amazon Dark Blue)
    (1.0, '#0F1111')   # 1-100 range (Almost Black)
]


# Create the choropleth map
fig = go.Figure(data=go.Choropleth(
    locations=merged_df['ISO Code'],  # Country ISO codes
    z=merged_df['count'],  # Data values
    text=merged_df['Country'],  # Hover text
    colorscale=custom_colorscale,
    marker_line_color='darkgray',
    marker_line_width=0.6,
    colorbar_title='Count',
))

# Update layout
fig.update_layout(
    title={
        'text': "TV Shows / Movies origin country available on Amazon Prime",
        'x': 0.5,
        'xanchor': 'center',
        'yanchor': 'top',
        'font': dict(
            size=30,
            family='serif',
            weight='bold'
        ),
        'pad': dict(t=20)
    },
    geo=dict(
        showframe=False,
        showcoastlines=True,
        projection_type='equirectangular'
    )
)

# Show the figure
fig.show()

We can clearly see that Majority of the content on Amazon Prime is produced in USA & then followed by India, UK, South Korea, France, Australia. This could be because of Hollywood and Bollywood which are major producers of Movies and TV Shows. Also, because of K Drama and K Pop, South Korea also holds a strong hold. But also could be a result of Population in the respective countries which increases the production of contents.

🍿Movie vs TV Show Ratio

Let's plot the share of ratio between Movies and TV Shows on Amazon Prime

# Find the ratio of type
x=amazon_csv.groupby(['type'])['type'].count()
y=len(amazon_csv)
r=((x/y)).round(2)

mf_ratio = pd.DataFrame(r).T
print(mf_ratio)

Above code finds the ratio of Movies to TV Shows for the next step in visualizing.



#calclated 'mf_ratio'
mf_ratio = pd.DataFrame({'Movie': [0.8], 'TV Show': [0.2]})

fig, ax = plt.subplots(figsize=(6, 1.5))

#  single horizontal stacked bar
ax.barh(0, mf_ratio['Movie'], color='#00A8E1', alpha=0.9)
ax.barh(0, mf_ratio['TV Show'], left=mf_ratio['Movie'], color='#232F3E', alpha=0.9)

# Remove axes details
ax.set_xlim(0, 1)
ax.set_xticks([])
ax.set_yticks([])
ax.spines[['top', 'left', 'right', 'bottom']].set_visible(False)

# Annotations for Movie & TV Show
ax.annotate("80%", xy=(mf_ratio['Movie'][0] / 2, 0), va='center', ha='center',  color='white', fontsize=20, fontweight='bold', fontfamily='serif')
ax.annotate("20%", xy=(mf_ratio['Movie'][0] + mf_ratio['TV Show'][0] / 2, 0), va='center', ha='center', fontsize=20, color='white', fontweight='bold', fontfamily='serif')
fig.text(1.1, 1, 'Insight', fontsize=15, fontweight='bold', fontfamily='serif')

fig.text(1.1, 0.40, '''
The graph shows that the content available
in Amazon Prime is majorly Movies with (80%)
and TV Shows  only add upto (20%).This could
be a result because of the country distribution which
we saw on the previous plot. Or Maybe because
TV Shows are something which are new to the trend than movies.
'''
         , fontsize=8, fontweight='light', fontfamily='serif')
# Creates a vertical line to seperate the insight
import matplotlib.lines as lines
l1 = lines.Line2D([1, 1], [0, 1], transform=fig.transFigure, figure=fig,color='black',lw=0.2)
fig.lines.extend([l1])

# Title
fig.text(0.125, 1.1, 'Movie & TV Show Distribution', fontsize=14, fontweight='bold', fontfamily='serif')

fig.text(0.64,0.9,"Movie", fontweight="bold", fontfamily='serif', fontsize=15, color='#00A8E1')
fig.text(0.77,0.9,"|", fontweight="bold", fontfamily='serif', fontsize=15, color='black')
fig.text(0.8,0.9,"TV Show", fontweight="bold", fontfamily='serif', fontsize=15, color='#221f1f')

plt.show()

The graph shows that the content available in Amazon Prime is majorly Movies with (80%) and TV Shows only add upto (20%).This could be a result because of the country distribution which we saw on the previous plot. Or Maybe because TV Shows are something which are new to the trend than movies.

🎬 Top Directors on Amazon Prime

Now lets analyze the Directors column and find Top 6 of them all.


# Filter out 'Not Available' values before counting occurrences
filtered_directors = amazon_csv[amazon_csv['director'] != "Not available"]

# Count the number of titles per director
director_counts = filtered_directors['director'].value_counts()

# Select top 10 directors
top_directors = director_counts[:6]

# Define bar colors
colors = ['#232F3E'] * 10  # Default light color
colors[:3] = ['#00A8E1'] * 3  # Highlight top 3 directors

# Create figure and axis for the bar chart
fig, ax = plt.subplots(figsize=(12, 6))

# Plot the bar chart
ax.bar(top_directors.index, top_directors.values, width=0.5, color=colors, edgecolor='darkgray', linewidth=0.6)

# Get the maximum value for dynamic annotation positioning
max_value = top_directors.max()

# Add value labels above the bars
for i, director in enumerate(top_directors.index):
    ax.annotate(f"{top_directors[director]} Content",
                xy=(i, top_directors[director] + max_value * 0.05),  # 5% above the bar
                ha='center', va='bottom', fontweight='light', fontfamily='serif')

# Remove top, left, and right borders
for side in ['top', 'left', 'right']:
    ax.spines[side].set_visible(False)

# Set x-axis labels
ax.set_xticks(range(len(top_directors.index)))  # Correct tick positioning
ax.set_xticklabels(top_directors.index, fontfamily='serif', rotation=0, ha='center')
ax.set_yticklabels('', fontfamily='serif', rotation=0, ha='center')


# Add horizontal grid lines for better readability
ax.grid(axis='y', linestyle='-', alpha=0.4)
ax.set_axisbelow(True)  # Place grid lines behind bars

# Add a thick bottom border
plt.axhline(y=0, color='black', linewidth=1.3, alpha=0.7)
fig.text(0.95, 0.75, 'Insight', fontsize=15, fontweight='bold', fontfamily='serif')

fig.text(0.95, 0.45, '''
I have chosen only Top 6 for better visualization
because majority of the directors have single
figure content under their name.
Director, Mark Knight has the highest
content of Movies/ TV show with 104 counts
that is hosted on Amazon Prime. Followed
by Cannis Holder (60), Moonbug E(36).

Its interesting although India , South Korea are one of the top
producers, the directors dont hold a Monopoly.
'''
         , fontsize=8.5, fontweight='light', fontfamily='serif')

# Remove tick marks
ax.tick_params(axis='both', which='major', labelsize=12, length=0)
fig.text(0.65,0.75,"Top 3", fontweight="bold", fontfamily='serif', fontsize=15, color='#00A8E1')
fig.text(0.71,0.75,"|", fontweight="bold", fontfamily='serif', fontsize=15, color='black')
fig.text(0.73,0.75,"Rest 3", fontweight="bold", fontfamily='serif', fontsize=15, color='#221f1f')
# Title styling
plt.title('Top 6 Directors on Amazon Prime', fontsize=16, fontweight='bold', fontfamily='serif')

# Display the plot
plt.show()

Director, Mark Knight has the highest content of Movies/ TV show with 104 counts that is hosted on Amazon Prime. Followed by Cannis Holder (60), Moonbug E(36).
Its interesting although India , South Korea are one of the top
producers, the directors dont hold a Monopoly.

⏳ Chronological availability of Movies & TV Shows

# To create a layout with length and width defined
fig, ax = plt.subplots(figsize=(12, 6))
color = ["#00A8E1", "#221f1f"]

# Annotation
for i, mtv in enumerate(amazon_csv['type'].value_counts().index):
    mtv_rel = amazon_csv[amazon_csv['type']==mtv]['release_year'].value_counts().sort_index()
    ax.plot(mtv_rel.index, mtv_rel, color=color[i], label=mtv)
    ax.fill_between(mtv_rel.index, 0, mtv_rel, color=color[i], alpha=0.9)

ax.yaxis.tick_right()
# Creates a horizontal line below in x axis
ax.axhline(y = 0, color = 'black', linewidth = 1.3, alpha = .7)
# Limits for the y axis ticks
ax.set_ylim(0, 1000)
#To remove the box around
for s in ['top', 'right','bottom','left']:
    ax.spines[s].set_visible(False)

ax.grid(False)
plt.xticks(fontfamily='serif')
plt.yticks(fontfamily='serif')
# Insights
fig.text(0.30, 0.85, 'Chronological availability of Movies & TV Shows', fontsize=16, fontweight='bold', fontfamily='serif')
fig.text(0.13, 0.75, 'Insight', fontsize=15, fontweight='bold', fontfamily='serif')
fig.text(0.13, 0.55,
'''It shows that majority of the content on Amazon Prime
is new. We can see a steep curve in the range of 2000-2020.
Definitely this will give us an insight of the age group
of the consumers.
Could this mean contents are mainly focused on youth or teens?
'''

, fontsize=8.5, fontweight='light', fontfamily='serif')
# Legends
fig.text(0.13,0.2,"Movie", fontweight="bold", fontfamily='serif', fontsize=15, color='#00A8E1')
fig.text(0.19,0.2,"|", fontweight="bold", fontfamily='serif', fontsize=15, color='black')
fig.text(0.2,0.2,"TV Show", fontweight="bold", fontfamily='serif', fontsize=15, color='#221f1f')
# removes the ticks
ax.tick_params(axis=u'both', which=u'both',length=0)
# Display the grapgh
plt.show()

It shows that majority of the content on Amazon Prime is new. We can see a steep curve in the range of 2000-2020. Definitely this will give us an insight of the age group of the consumers. Could this mean contents are mainly focused on youth or teens?

Plot a Heatmap .

# Get the unique countries
unique_countries = set()
# Get the first country if multiple are listed
for entry in amazon_csv['country'].dropna():
    first_country = entry.split(', ')[0]
    unique_countries.add(first_country)

# Filter the dataset
amazon_csv['first_country'] = amazon_csv['country'].apply(lambda x: x.split(', ')[0] if isinstance(x, str) else x)

# Get the top 10 countries
top_countries = amazon_csv['first_country'].value_counts().head(10).index
# Creating a dictionary for clubbing
ratings_ages = {
    'TV-Y': 'Kids', 'TV-G': 'Kids', 'G': 'Kids', 'ALL': 'Kids', 'ALL_AGES': 'Kids',
    'TV-Y7': 'Older Kids', '7+': 'Older Kids', 'TV-PG': 'Older Kids', 'PG': 'Older Kids',
    'PG-13': 'Teens', 'TV-14': 'Teens', '13+': 'Teens', '16+': 'Teens', '16': 'Teens', 'AGES_16_': 'Teens',
    '18+': 'Adults', 'R': 'Adults', 'TV-MA': 'Adults', 'NC-17': 'Adults', 'NR': 'Adults', 'TV-NR': 'Adults',
    'UNRATED': 'Adults', 'AGES_18_': 'Adults', 'NOT_RATE': 'Adults'
}

# Create 'target_age_group' column *before* filtering
amazon_csv['target_age_group'] = amazon_csv['age_group'].map(ratings_ages)

# Filter data for only the top 10 countries
filtered_data = amazon_csv[amazon_csv['first_country'].isin(top_countries)]
filtered_data['first_country'].replace({'United States': 'USA',
                                     'United Kingdom': 'UK',
                                     'South Korea': 'S. Korea'}, inplace=True)
# Create a pivot table with counts of each age group per country
heatmap_data = filtered_data.pivot_table(index='target_age_group', columns='first_country', aggfunc='size', fill_value=0)

# Convert counts to percentages
heatmap_data_percentage = heatmap_data.div(heatmap_data.sum(axis=0), axis=1) * 100

# custom colormap for Amazon
cmap = matplotlib.colors.LinearSegmentedColormap.from_list("", ['#FFFFFF', '#B4B4B4', '#00A8E1'])

# Plot the heatmap
plt.figure(figsize=(12, 6))
sns.heatmap(heatmap_data_percentage, cmap=cmap, annot=True, fmt='.1f', linewidths=2.5, square=True,
            cbar=False, vmax=60, vmin=5, annot_kws={"fontsize": 12, "fontfamily": 'serif', "fontweight": 'bold', "color": 'black'})

# Annotations
for t in plt.gca().texts:
    t.set_text(t.get_text() + "%")
    t.set_fontsize(10)

# Title and labels
plt.title("Target Age Group Distribution by Country (%)", fontsize=16, fontweight='bold', fontfamily='serif', pad=20, color='#232F3E')
plt.xlabel("", fontsize=10, labelpad=10, fontfamily='serif', color='#232F3E')
plt.ylabel("", fontsize=10, labelpad=10, fontfamily='serif', color='#232F3E')

plt.xticks(fontsize=10, fontfamily='serif')
plt.yticks(fontsize=10, fontfamily='serif')

# Add  labels
plt.text(10.5, 0.2, "Insight", fontweight="bold", fontfamily='serif', fontsize=16)
plt.text(10.5, 0.9, '''Yes, we can see that Most of the countries
 target Teens and Adults for their viewer engagement.
 Italy targets 70% of younger viewers.
  ''', fontfamily='serif', fontsize=8.5)

# Show plot
plt.show()

Yes, we can see that Most of the countries target Teens and Adults for their viewer engagement.
Italy targets 70% of younger viewers.

Could the number of seasons of a TV Show has any relation with the rating? Usually TV Shows tend to increase their seasons if its a success or has a good engagegement.

amazon_csv['num_seasons'] = amazon_csv['duration'].str.extract(r'(\d+) Season[s]?')

From duration checks if the value has 'season' in it to confirm its TV Shows.

###Correlation between Number of Seasons Vs Ratings.

correlation = amazon_csv['num_seasons'].corr(amazon_csv['rating'])
print(f"Correlation Coefficient: {correlation}")

Correlation Coefficient is found between Number of Seasons in a TV Show and Rating value of it. To check for statistical signicance.


# Make it numeric to extract the number of seasons
amazon_csv['num_seasons'] = pd.to_numeric(amazon_csv['num_seasons'], errors='coerce')

# Create the regplot / Scatter plot
plt.figure(figsize=(12, 6))
sns.regplot(x=amazon_csv['num_seasons'], y=amazon_csv['rating'], scatter_kws={"s": 3, "color": "#232F3E"}, line_kws={"color": "#00A8E1", "linewidth": 2})

# Set title and labels
plt.title("Number of Seasons vs Rating", fontsize=16, fontweight='bold', family='serif')
plt.xlabel("Number of Seasons", fontsize=12, fontweight='normal', family='serif')
plt.ylabel("Rating", fontsize=12, fontweight='normal', family='serif')

# Grid customization
plt.grid(True, axis='both', linestyle='-', alpha=0.4)

# Make the background color white for a cleaner look
plt.gca().set_facecolor('white')
plt.text(22, 15.5, 'Insight', fontsize=16, fontweight='bold', fontfamily='serif')
plt.text(22, 13,
'''There is a strong correlation of 0.67 to show
 that rating might have tempted the Directors to
 increase the number of seasons.
'''

, fontsize=8.5, fontweight='light', fontfamily='serif')
# Customize the ticks
plt.xticks(fontsize=8, family='serif')
plt.yticks(fontsize=8, family='serif')

# Remove the borders (spines)
for spine in plt.gca().spines.values():
    spine.set_visible(False)

# Display the plot
plt.tight_layout()
plt.show()

There is a strong correlation of 0.67 to show that rating might have tempted the Directors to increase the number of seasons. But correlation doesnt imply causation so we cant predict AND confirm the analysis.

Exploratory Data Analysis (EDA) of Amazon Prime Titles

Word count: 391

This analysis explores Amazon Prime’s content library using data from 9,667 titles, including movies and TV shows. The dataset contains attributes like title, type, release year, rating, and genre. The objective is to clean the data, handle missing values, and uncover trends in content distribution.

Data Cleaning and Preprocessing

Missing values were found in multiple columns:

"date_added" (98.4%) – Dropped due to excessive missing data.
"country" (10.3%) – Filled with mode value.
"director" (21.54%) and "cast" (12.75%) – Replaced with "Unknown."
"rating" (2.93%) – Filled with mode value.

Checks ensured "type" only had "Movie" and "TV Show" values, and all ratings were valid.

Content Distribution and Trends

Movies vs TV Shows: The dataset contains 7,814 movies (80%) and 1,854 TV shows (20%).
Release Year Trends: Content production increased after 2000, with a sharp rise post-2015.
Newer Content Preference: 50% of content is from 2016 or later.

Genre and Audience Analysis

Popular Categories: "Drama," "Comedy," and "Suspense" dominate the dataset.
Ratings Breakdown: PG, R, and TV-MA are common ratings, showing a mix of family-friendly and mature content.
Country-wise Production:
- USA leads content production.
- India, UK, South Korea, and France follow.
- Hollywood, Bollywood, and K-Dramas contribute significantly.

Duration and Rating Analysis

Movies: Average duration is 90 minutes.
TV Shows: Ratings correlate strongly (0.67) with the number of seasons, suggesting successful shows get extended seasons.
Highest Rated Content: Median rating is 6.3, with a maximum of 9.8.

Key Findings and Business Insights

Content Type: Majorly populated with Movies than TV Shows
Content Age: Significant rise in content chronology distrubtion after 2010, majorly being newer releases.
Regional Availability: USA dominates, but India and South Korea also have strong presence maybe due to Hollywood, Bollywood and KDrama.
Directors: Mark Knight (104 titles) leads, followed by Cannis Holder (60) and Moonbug E (36). Notably, no monopoly among Indian and Korean directors even with higher content origin.
Statistical Insights: Correlation between rating and number of TV show seasons suggests audience engagement influences newer releases.

Conclusion

Amazon Prime’s content is heavily movie-focused. The platform’s diverse genre majorly targets Adult viewers but mix both family and mature audiences. These insights can help optimize content curation and engagement strategies.

[Boost]

Dhanush D — Sun, 26 Jan 2025 12:10:34 +0000

New Angular 19 feature - ngComponentOutlet componentInstance

Connie Leung ・ Jan 26

#angular

Get Done ✅ : A step-by-step guide in building a Django To Do List

Dhanush D — Sun, 05 Jan 2025 14:45:51 +0000

Introduction

Managing tasks effectively is crucial in our busy lives, and a to-do list application can be an excellent tool for staying organized. This blog post walks you through the development of a to-do list application using Django, a powerful and versatile web framework in Python. The project, titled django-todoList, is designed to help users create, manage, and track their daily tasks seamlessly.

Prerequisites

Before we begin, ensure that you have the following:

Python installed (preferably version 3.8 or above).
Django installed. If not, you can install it using the following command.

pip install django

A basic understanding of how Django works and familiarity with Python and HTML.

Step 1: Setting Up the Project

1.1 Create a Django Project

First, create a new Django project using the command:

django-admin startproject mysite

Navigate into your project folder:

cd mysite

1.2 Create a Django App

Next, create an app within the project. We’ll call it todoList:

python manage.py startapp todoList

Step 2: Define Models

In Django, models are used to define the structure of your data. For the GetDone To-Do app, we need a model to represent a Task.

Navigate to todoList/models.py and define the Task model:

from django.db import models
from django.contrib.auth.models import User

class Task(models.Model):
    title = models.CharField(max_length=200)
    description = models.TextField()
    complete = models.BooleanField(default=False)
    created = models.DateTimeField(auto_now_add=True)
    deadline = models.DateTimeField(null=True, blank=True)
    user = models.ForeignKey(User, on_delete=models.CASCADE)

    def __str__(self):
        return self.title

This model includes fields like title, description, deadline, and complete to store details of each task. We also associate each task with a user via the user foreign key.

2.1 Migrate the Database

Once the model is ready, run the migrations to create the table for this model in the database:

python manage.py makemigrations
python manage.py migrate

Step 3: Create Forms

We need forms to handle user input for creating and updating tasks. In todoList/forms.py, create the TaskForm:

from django import forms
from .models import Task

class TaskForm(forms.ModelForm):
    class Meta:
        model = Task
        fields = ['title', 'description', 'deadline', 'complete']
        widgets = {
            'title': forms.TextInput(attrs={'placeholder': 'Enter task title'}),
            'description': forms.Textarea(attrs={'placeholder': 'Enter task description', 'rows': 4}),
            'deadline': forms.DateTimeInput(attrs={'type': 'datetime-local'}),
            'complete': forms.CheckboxInput(),
        }

    def clean_title(self):
        title = self.cleaned_data.get('title')
        if not title:
            raise forms.ValidationError('Title is required')
        return title

    def clean_description(self):
        description = self.cleaned_data.get('description')
        if not description:
            raise forms.ValidationError('Description is required')
        return description

    def clean_deadline(self):
        deadline = self.cleaned_data.get('deadline')
        if not deadline:
            raise forms.ValidationError('Deadline is required')
        return deadline

The TaskForm uses Django’s ModelForm to automatically create form fields for the Task model.

Step 4: Define Views

Next, we need to create views to handle user requests, such as creating tasks, updating them, and listing them.

In todoList/views.py, define the views:

from django.shortcuts import render, redirect
from django.views.generic import ListView, CreateView, UpdateView, DeleteView
from django.contrib.auth.views import LoginView
from django.contrib.auth.mixins import LoginRequiredMixin
from django.contrib.auth.forms import UserCreationForm
from django.urls import reverse_lazy
from .models import Task
from .forms import TaskForm
from django.contrib import messages
from django.utils import timezone


# Task List View
class TodoListView(LoginRequiredMixin, ListView):
    model = Task
    context_object_name = 'tasks'
    template_name = 'task_list.html'

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        user_tasks = Task.objects.filter(user=self.request.user)
        context['tasks'] = Task.objects.filter(user=self.request.user)
        context['incomplete_tasks_count'] = user_tasks.filter(complete=False).count()  # Count incomplete tasks
        context['now'] = timezone.now()
        return context

# Task Create View
class TaskCreate(LoginRequiredMixin, CreateView):
    model = Task
    form_class = TaskForm
    template_name = 'todoList/task_create.html'
    success_url = reverse_lazy('todoList')

    def form_valid(self, form):
        form.instance.user = self.request.user
        messages.success(self.request, 'Task created successfully!')
        return super(TaskCreate, self).form_valid(form)

# Task Update View
class TaskUpdate(LoginRequiredMixin, UpdateView):
    model = Task
    form_class = TaskForm
    template_name = 'todoList/task_update.html'
    success_url = reverse_lazy('todoList')
    def form_valid(self, form):
        messages.success(self.request, 'Task updated successfully!')
        return super(TaskUpdate, self).form_valid(form)

# Task Delete View
class TaskDelete(LoginRequiredMixin, DeleteView):
    model = Task
    context_object_name = 'task'
    template_name = 'todoList/task_delete.html'
    success_url = reverse_lazy('todoList')
    def dispatch(self, request, *args, **kwargs):
        response = super().dispatch(request, *args, **kwargs)
        if response.status_code == 302:
            messages.success(self.request, 'Task deleted successfully!')
        return response

# User Registration View
class RegisterView(CreateView):
    form_class = UserCreationForm
    template_name = 'todoList/register.html'
    success_url = reverse_lazy('todoList')

    def form_valid(self, form):
        response = super().form_valid(form)
        # Log the user in after successful registration
        from django.contrib.auth import login
        login(self.request, self.object)
        messages.success(self.request, 'Registration successful! Welcome!')
        return response


# Login View
class CustomLoginView(LoginView):
    template_name = 'todoList/login.html'
    fields = '__all__'
    redirect_authenticated_user = True

    def get_success_url(self):
        messages.success(self.request, 'You have logged in successfully!')
        return reverse_lazy('todoList')

-TodoListView: Lists all tasks for the logged-in user.
-TaskCreate: Handles task creation.
-TaskUpdate: Allows users to update a task.
-TaskDelete: Provides a confirmation page for deleting a task.
T-he LoginRequiredMixin ensures that only logged-in users can access these views.

Step 5: Configure URLs

In todoList/urls.py, map URLs to their respective views:

from django.urls import path
from .views import TodoListView, TaskCreate, TaskUpdate, TaskDelete, RegisterView

urlpatterns = [
    path('', TodoListView.as_view(), name='todoList'),
    path('create/', TaskCreate.as_view(), name='create_task'),
    path('edit/<int:pk>/', TaskUpdate.as_view(), name='edit_task'),
    path('delete/<int:pk>/', TaskDelete.as_view(), name='delete_task'),
]

These URL patterns will map each view to a specific URL. For example, the task list is displayed at the root URL of the app, and users can create, edit, or delete tasks by visiting specific URLs.

Step 6: Create Templates

Create the following HTML templates to render the views:

6.1 base.html

The base template provides a consistent layout for all pages:

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{% block title %}Task Manager{% endblock %}</title>

    <!-- Load Static files -->
    {% load static %}

    <!-- Bootstrap CSS -->
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css" rel="stylesheet">
    <link rel="preconnect" href="https://fonts.googleapis.com">
    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
    <link
        href="https://fonts.googleapis.com/css2?family=Lato:ital,wght@0,100;0,300;0,400;0,700;0,900;1,100;1,300;1,400;1,700;1,900&display=swap"
        rel="stylesheet">

    <!-- Custom CSS -->
    <link rel="stylesheet" href="{% static 'css/styles.css' %}">
</head>

<body class="container p-4">

    <!-- Display messages -->
    <div class="toast-container position-relative top-0 end-0 p-3 ml-6">
        {% if messages %}
        {% for message in messages %}
        <div class="toast" role="alert" aria-live="assertive" aria-atomic="true">
            <div class="toast-body">
                {{ message }}
            </div>
        </div>
        {% endfor %}
        {% endif %}

    </div>

    <main>
        <h1 class=""> Get Done <span class="done-icon">✔</span></h1>
        {% block content %}{% endblock %}

    </main>

    <!-- Bootstrap JS and Popper.js -->
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/js/bootstrap.bundle.min.js"></script>

    <!-- Toast display on page load -->
    <script>
        window.onload = function () {
            let toastElements = document.querySelectorAll('.toast');
            toastElements.forEach(toastElement => {
                var toast = new bootstrap.Toast(toastElement);
                toast.show();
            });
        };
    </script>
</body>

</html>

6.2 login.html

This template is for logging in of the user:

{% extends 'base.html' %}
{% block title %}Login{% endblock %}
{% block content %}
<div class="card p-4">
<h2 class="mb-4">Sign in</h2>
<form method="post">
    {% csrf_token %}
    {{ form.as_p }}
    <button class="btn btn-primary" type="submit">Login</button>
</form>
<p class="mt-3">Don't have an account? <a href="{% url 'register' %}">Sign up</a></p>
</div>
{% endblock %}

6.3 register.html

This template is for new user registration :

{% extends 'base.html' %}
{% block title %}Register{% endblock %}
{% block content %}
<div class="card p-4">
<h2 class="mb-4">Sign up</h2>
<form method="post">
    {% csrf_token %}
    {{ form.as_p }}
    <button class="btn btn-primary" type="submit">Sign Up</button>
</form>
<p class="mt-3">Already have an account? <a href="{% url 'login' %}">Sign In</a></p>
</div>
{% endblock %}

6.4 task_create.html

This template handle task creation. They contain forms to input task details.:

{% extends 'base.html' %}
{% block title %}Create Task{% endblock %}
{% block content %}

<h2 class="mb-4">Create Task</h2>
<form method="post" class="card p-4">
    {% csrf_token %}
    {{ form.as_p }}
    <button class="btn btn-success" type="submit">Save</button>
    <a href="{% url 'todoList' %}" class="btn btn-secondary mt-1">Cancel</a>
</form>

{% endblock %}

6.5 task_delete.html

This template is for deleting a particular task:

{% extends 'base.html' %}
{% block title %}Delete Task{% endblock %}
{% block content %}
<h2 class="mb-4">Delete Task</h2>
<p class="delete-text">Are you sure you want to delete this task: "{{task.title}}" ?</p>
<form method="post" class="d-inline">
    {% csrf_token %}
    <button class="btn btn-danger" type="submit">Confirm</button>
</form>
<a href="{% url 'todoList' %}" class="btn btn-secondary mt-1">Cancel</a>
{% endblock %}

6.6 task_list.html

This template lists all tasks for the logged-in user:

{% extends 'base.html' %}
{% block title %}Your Tasks{% endblock %}
{% block content %}
<div class="logout-section"><a href="{% url 'logout' %}" class="btn btn-secondary mt-1"
        title="Do you want to sign out?">Sign out</a></div>
<div class="header">
    <div class="mb-2 username">
        <h3 class="superusers">Hello, {{ request.user.username }}</h3>
    </div>
    <a href="{% url 'create_task' %}" title="Add a new task">
        <div class="add-icon">
            +
        </div>
</div></a>
<h5 class="count-container">You have <span class="task-count">{{ incomplete_tasks_count }}</span> incomplete tasks.</h5>

{% if tasks %}
<ul class="list-group">
    {% for task in tasks %}
    <li class="list-group-item d-flex justify-content-between align-items-center">
        <a href="{% url 'edit_task' task.id %}" class="text-decoration-none" title="Open the task">
            <span style="text-decoration: {% if task.complete %}line-through{% endif %};">
                <div class="title">{{ task.title }}</div>
            </span>
            <div class="mb-0 description">{{ task.description }}</div>
            <div class="deadline">
                Deadline: {{ task.deadline|date:"M d, Y h:i A" }}
                {% if task.deadline < now %}
                <span class="text-danger ms-2" title="Deadline is past!">❗</span>
                {% endif %}
            </div>
        </a>
        <span>
            <a href="{% url 'delete_task' task.id %}" class="text-danger ms-3" title="Delete the task">❌️</a>
        </span>
    </li>
    {% endfor %}
</ul>
{% else %}
<p>No pending tasks.</p>
{% endif %}
{% endblock %}

6.7 task_update.html

These templates handle task updates. They contain forms to input task details.

{% extends 'base.html' %}
{% block title %}Update Task{% endblock %}
{% block content %}
<h2 class="mb-4">Update Task</h2>
<form method="post" class="card p-4">
    {% csrf_token %}
    {{ form.as_p }}
    <button class="btn btn-success" type="submit">Save</button>
    <a href="{% url 'todoList' %}" class="btn btn-secondary mt-1">Cancel</a>
</form>
{% endblock %}

Step 7: Add CSS for styling

a {
    text-decoration: none;
}

h1 {
    text-align: center;
    margin-bottom: 40px;
    color: #333;
    align-items: center;
    justify-content: center;
    font-weight: bold;
}

h2 {
    text-align: start;
    margin-bottom: 10px;
    color: #333;
    align-items: center;
    justify-content: center;
}

.header {
    display: flex;
    justify-content: space-between;
    align-items: center;
    margin: 0 10px;
}

body {
    font-family: "Lato", serif;
    margin: 0;
    padding: 0;
    background-color: #f8f9fa;
}

.container {
    max-width: 750px;
    margin: 20px auto;
    background: #ffffff;
    padding: 20px;
    border-radius: 8px;
    box-shadow: 0 0 10px rgba(0, 0, 0, 0.3);
}

input[type=text],
input[type=password],
textarea {
    border: 1px solid #6c757d;
}

form label {
    display: block !important;
    margin-bottom: 5px;
}

.done-icon {
    font-size: 38px;
    color: green;
    margin-left: 10px;
}

.card {
    border-radius: 8px;
    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
}

button {
    border-radius: 5px;
}

.count-container {
    margin-left: 16px;
}

.superusers {
    color: #333;
    display: inline-block;
    overflow: hidden;
    white-space: nowrap;
    border-right: 1px solid #333;
    width: 0;
    animation: typing 2s steps(30) 1s forwards, blink 0.75s step-end infinite;
}

.username {
    width: 370px;
}

/* Typing & Cursor blink animation effect */
@keyframes typing {
    from {
        width: 0;
    }

    to {
        width: 100%;
    }
}

@keyframes blink {
    50% {
        border-color: transparent;
    }
}

.delete-text {
    font-size:16px;
}
.add-icon {
    display: flex;
    justify-content: center;
    align-items: center;
    background-color: #007bff;
    color: white;
    width: 40px;
    height: 40px;
    border-radius: 50%;
    font-size: 24px;
    font-weight: bold;
    box-shadow: 0 2px 5px rgba(0, 0, 0, 0.2);
    transition: background-color 0.3s;
}

.add-icon a {
    text-decoration: none;
    color: white;
}

.add-icon:hover {
    background-color: #0056b3;
}

.logout-section {

    position: absolute;
    margin-top: -88px;
}

.task {
    padding: 10px;
    border-bottom: 1px solid #e9ecef;
    display: flex;
    justify-content: space-between;
    align-items: center;
}

.task-count {
    font-style: italic;
    color: blue;
    font-weight: bold;
}

.task:last-child {
    border-bottom: none;
}

.title {
    font-size: 22px;
    font-weight: bold;
    color: #007bff;
}

.title:hover {
    color: #0056b3;
    font-size: 24px;
}

.description {
    margin: 5px 0;
    font-size: 16px;
    color: #6c757d;
}

.deadline {
    font-size: 14px;
    color: #adb5bd;
}

.tooltip {
    position: relative;
    cursor: pointer;
}

.tooltip::after {
    content: attr(data-tooltip);
    position: absolute;
    bottom: 100%;
    /* Position above the icon */
    left: 50%;
    transform: translateX(-50%);
    background-color: #333;
    color: #fff;
    padding: 5px;
    border-radius: 4px;
    white-space: nowrap;
    font-size: 12px;
    opacity: 0;
    pointer-events: none;
    transition: opacity 0.2s;
}

.tooltip:hover::after {
    opacity: 1;
}

Step 8: Add User Authentication

In views.py, you can use Django’s built-in user authentication views to handle user registration and login. For example, you can use UserCreationForm to allow users to sign up:

class RegisterView(CreateView):
    form_class = UserCreationForm
    template_name = 'registration/signup.html'
    success_url = reverse_lazy('login')

Step 8: Run the Server

Once everything is set up, you can run the server:

python manage.py runserver

Visit http://127.0.0.1:8000/todoList to see your To-Do List app in action!

Understanding settings.py and urls.py in the mysite Folder

settings.py

The settings.py file is a crucial part of every Django project. It contains the configuration settings for your project, such as database settings, installed apps, middleware, static files configuration, and more. This file controls the behavior of your project and allows Django to connect the dots between various components.

Here's a brief overview of key settings in settings.py for your GetDone To-Do List app:

Key Sections in settings.py:

Installed Apps: In the INSTALLED_APPS list, you register all the apps used in your project. For instance:

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'todoList',  # Our custom app
]

STATIC_URL = '/static/'


STATICFILES_DIRS = [
    BASE_DIR / "todoList/static",
]

Here, we’ve added todoList, which is the app that manages the tasks, alongside the default apps provided by Django for user authentication, admin panel, and static files.

urls.py

In Django, the urls.py file handles the routing of HTTP requests to views. It is where you map URL patterns (such as /tasks/, /login/) to corresponding views that will handle them.

In the mysite/urls.py, you usually include URLs for the whole project and link them to the app-level urls.py file.

Here’s what urls.py looks like in your GetDone app:

Key Sections in urls.py:

Project-Level urls.py (mysite/urls.py): The urls.py file in the mysite folder is the main router for your entire Django project. It includes the URLs for the admin panel, authentication, and links to your app's specific URLs. Here’s an example:

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('accounts/', include('django.contrib.auth.urls')),  # For login/logout
    path('', include('todoList.urls')),  # Include the todoList app URLs
]

path('admin/', admin.site.urls): This line includes the Django admin panel.
path('accounts/', include('django.contrib.auth.urls')): This includes built-in authentication URLs for login, logout, and password management.
path('', include('todoList.urls')): This includes the app-specific URLs (defined in todoList/urls.py), so users can navigate through tasks and other features.
App-Level urls.py (todoList/urls.py): This file maps specific URLs to views within the todoList app. It contains paths for viewing tasks, creating tasks, and other task-related actions. For example:

from django.urls import path
from .views import TodoListView, TaskCreate, TaskUpdate, TaskDelete

urlpatterns = [
    path('', TodoListView.as_view(), name='todoList'),
    path('create/', TaskCreate.as_view(), name='create_task'),
    path('edit/<int:pk>/', TaskUpdate.as_view(), name='edit_task'),
    path('delete/<int:pk>/', TaskDelete.as_view(), name='delete_task'),
]

TodoListView.as_view(): This view lists all tasks for the logged-in user.
TaskCreate.as_view(): This view handles the task creation form.
TaskUpdate.as_view(): This view handles the task update form.
TaskDelete.as_view(): This view handles the task deletion confirmation page.

Communication Between Files

Django’s architecture allows for smooth communication between the different files and components:

URLs and Views:

The urls.py maps URLs to views, such as task creation or list viewing. Views are defined in views.py.

Models and Views:

Views interact with models (defined in models.py) to retrieve and manipulate data (tasks). For example, in TodoListView, the view fetches tasks associated with the logged-in user using Task.objects.filter(user=self.request.user).

Forms and Views:

Forms (like TaskForm in forms.py) handle user input and interact with models to validate and save the data.

Templates:

Templates render the final output in HTML, displaying data passed from views and handling user input through forms.

Conclusion

With these steps, you’ve built a fully functional To-Do list app using Django. You’ve implemented user authentication, task management (create, edit, delete), and learned how Django’s MVC (MTV) architecture facilitates the smooth communication between models, views, templates, and URLs. This guide serves as a solid foundation for building more complex Django applications in the future.

Full code of the application is available to clone at

git clone https://github.com/dhanushd1998/django-todoList.git
cd django-todoList

Happy coding! 🚀