Coder Legion - Recent posts tagged python-3

Building a survey-based ML pipeline to find out what's really holding SEE and +2 graduates back

Sat, 08 Aug 2026 12:00:31 +0000

Building a survey-based ML pipeline to find out what's really holding SEE and +2 graduates back
The question I couldn't stop thinking about
Every year, hundreds of thousands of students in Nepal finish their SEE or +2 exams and hit the same fork in the road: keep studying, start building skills, or jump into the job market — usually with very little structured guidance. I'd heard the anecdotes a hundred times: "graduates feel unprepared," "the education system doesn't teach real skills," "there's no mentorship." But I hadn't seen actual data behind any of it.

So I built some.

This post walks through a full data science project — survey design, cleaning, exploratory analysis, a custom scoring model, and machine learning — that tries to answer three questions:

What skills are SEE/+2 graduates actually building, and how?

What's really blocking them from feeling career-ready?

What factors predict that readiness — effort, background, or something else?

Getting the data
I designed a 23-question Google Form covering demographics, current activity, skill-building habits (what, why, where, how many hours/week), four Likert-scale questions on career clarity/confidence/awareness, top challenges, career interests, and views on Nepal's education system. It went out primarily through an Instagram channel and pulled in 171 raw responses, cleaned down to 167 after dropping non-consenting and blank submissions.

Worth being upfront about this from the start: Instagram distribution means the sample skews toward urban, digitally active students, disproportionately from Bagmati province. This isn't a nationally representative sample — and every result below should be read with that in mind.

Cleaning: the unglamorous 80%
Google Forms exports are messy by default — full question text as column headers, multi-select checkboxes crammed into single semicolon-separated strings, free-text "Other" answers full of near-duplicates ("not learning", "Not Learning", "no where" all meaning the same thing).

The cleaning pipeline:

Renamed all 23 columns to short, code-friendly names

Converted bucketed answers (age ranges, GPA bands, weekly hours) into numeric midpoints for correlation/modeling, while keeping the original labels for display

Exploded 4 multi-select questions into 34 individual binary columns, folding rare free-text answers into a single Other bucket instead of creating one noisy column per typo

Dropped rows with no consent or with all four core Likert answers blank

That left a clean 167×66 dataset, ready for analysis.

What the data actually shows
Who responded: the sample skews toward Bagmati (37%) and the 19–21 age group, split fairly evenly by gender, with Management and Science as the dominant academic streams.

What they're learning: Programming/Coding (41 respondents) and Data Analyst/Data Science (40) lead, followed by Public Speaking/Communication (35), AI/ML (33), and Graphic Design (31). But 22% of respondents aren't learning any new skill at all — a real gap worth flagging.

Top skills chart
Why and where they learn: "To get a job" and "personal interest" dominate the motivation side. On the source side, YouTube and free content are by far the most common learning channel — institutes, mentors, and paid courses are comparatively underused, despite (as the modeling below shows) being associated with higher readiness.

What's blocking them: financial problems are the single most common challenge (54% of respondents), followed by lack of guidance/mentorship and lack of networking. Poor internet access and family pressure are comparatively minor. This isn't uniform across provinces either — less-connected provinces like Karnali and Sudurpaschim lean more toward financial/infrastructure barriers, while Bagmati's challenge profile leans more toward networking and mentorship gaps.

Top challenges chart
Building a Career Readiness Score
There's no pre-existing "readiness" label in survey data like this — it has to be constructed. I built a transparent, weighted 0–100 score from seven normalized signals:

weights = {
'clarity': 0.20, 'market': 0.15, 'edu': 0.10, 'conf': 0.20,
'hours': 0.15, 'breadth': 0.10, 'challenge_inv': 0.10,
}

Career clarity and confidence get the highest weight since they most directly represent "feeling ready"; active effort (hours invested, skill breadth) and challenge burden are supporting signals. I kept the weights explicit rather than hidden — this is the one place in the whole pipeline that's a judgment call rather than purely mechanical, and it deserves to be visible.

The result: an average score of 50.5/100, with most students landing in the "Medium" band — engaged, but not confidently prepared.

Readiness score distribution
Does GPA or effort predict readiness? Not really.
Here's where it got interesting. I trained two models — Linear Regression as an interpretable baseline, and a Random Forest for non-linear patterns — to predict the readiness score using only context features (demographics, learning habits, career interest). I deliberately excluded the Likert questions that built the score itself, to avoid circular prediction.

Model R² MAE RMSE
Linear Regression -0.26 15.31 19.54
Random Forest 0.12 13.15 16.36
Random Forest beat Linear Regression on every metric — readiness depends on non-linear combinations of context, not a simple additive relationship. That said, an R² of 0.12 is modest, and with only 167 rows and no attitudinal predictors allowed, this model is exploratory and directional, not a precision instrument.

What mattered most, according to feature importance:

Feature importance chart
GPA, whether a student thinks the education system is adequate, and their learning channel (institute or paid course vs. informal self-study) came out as the strongest predictors — ahead of age, gender, or province. Three of the top four predictors are about structural/environmental context, not personal effort. That lines up with the EDA finding that hours invested alone doesn't reliably predict how ready someone feels — how and where someone learns seems to matter more.

So what actually helps?
Putting it together, a few things stood out enough to act on:

Mentorship and networking gaps matter more than skill access. Career-guidance programs should target these specifically rather than assuming more course content is the fix.

Structured learning channels correlate with higher readiness than free YouTube content alone — worth encouraging alongside (not instead of) free resources.

Financial barriers are the single biggest reported challenge. Scholarships and subsidized training pathways would likely move the needle more than another course catalog.

The education-support gap is real. Of the four Likert measures, students rated their formal education as least helpful in preparing them for a career — a disconnect worth deeper, qualitative follow-up.

Limitations, stated plainly
Convenience sample via a single Instagram channel — urban/Bagmati skew, not nationally representative.

Career clarity/confidence/awareness are self-reported and subjective.

n=167 is small for machine learning — treat the model as directional, not predictive.

Cross-sectional data (single point in time) — can't establish causality or track change over time.

Closing thoughts
This was as much an exercise in disciplined data cleaning and honest reporting as it was in modeling. The most useful output wasn't the R² score — it was being able to say, with actual evidence, that the story students tell about "the system doesn't prepare us" is more specific than it sounds: it's not a uniform failure, it's a mentorship and networking gap layered on top of financial constraints, and where someone learns matters more than how many hours they put in.

The full notebook, cleaned dataset, report, and presentation are on GitHub — link below. If you work in EdTech, career guidance, or Nepali education policy, I'd genuinely like to hear what you think.

Tools: Python (pandas, scikit-learn, matplotlib, seaborn) in Jupyter, Google Forms for data collection.

Fixed "Indexerror: single positional indexer is out-of-bounds"

Wed, 11 Mar 2026 21:25:33 +0000

The "IndexError: single positional indexer is out-of-bounds" is a common error encountered while working with pandas DataFrames in Python. It occurs when attempting to access elements using invalid row or column indices. In this article, we will explore the main causes of this error and provide practical solutions to fix it. Let's dive in!

What is "IndexError: single positional indexer is out-of-bounds" error?

This is a specific type of IndexError that occurs when working with pandas DataFrames. It arises when attempting to access DataFrame elements using invalid integer-based indexers or using non-existent row or column indices. This error indicates that the index being used to access the DataFrame is either out of the valid range or does not exist in the DataFrame.

How is this error different from other IndexError errors?

While "IndexError: single positional indexer is out-of-bounds" is a subtype of the generic IndexError, it has unique characteristics. Unlike other IndexError errors, which may occur when working with lists, arrays, or sequences, this error is specific to pandas DataFrames. It typically arises when using incorrect indexing methods like iloc or iat with non-existent or out-of-bounds indices.

What causes the error in Python?

This error is specific to DataFrame indexing methods, such as iloc, iat, loc and at. Let's explore several common scenarios that trigger this error and understand the root causes behind each one.

DataFrame Indexing Functions:

iloc: Used for integer-based indexing, allowing us to access DataFrame elements using numeric row and column indices.
iat: A faster version of iloc for scalar (single element) access, where we can provide numeric row and column indices to retrieve a single cell's value.
loc: Used for label-based indexing, allowing us to access DataFrame elements using row and column labels (index names) instead of numeric indices.
at: A faster version of loc for scalar access, where we can provide row and column labels to retrieve a single cell's value.

Also, for every scenario in this article, we will use the small data set below to demonstrate our examples:

Notice that this DataFrame has 3 columns and 4 rows.

Scenario 1: Invalid Row Index

In this scenario, the error occurs when trying to access a row in the DataFrame using an invalid row index. For instance, we attempt to access the 5th row in the data set using iloc:

import pandas as pd

# The data set is stored in data
data = {'Name': ['John', 'Jane', 'Mike', 'Alice'],
        'Age': [25, 30, 22, 28],
        'City': ['New York', 'San Francisco', 'Chicago', 'Los Angeles']}

df = pd.DataFrame(data)

# Invalid row index access
print(df.iloc[4])  # Attempting to access the 5th row

This occurs because the DataFrame only has four rows with valid indices 0 to 3, and attempting to access the 5th row (index 4) leads to the "IndexError".

Note Python indexes are zero-based, so the index of the first column is 0 and the index of the last column is -1. And it's totally fine to use negative indexes for accessing the data, as long as they are integers.

Scenario 2: Invalid Column Index

The same error arises when trying to access a column in the DataFrame using an invalid column index. This time we attempt to access the 4th column (index 3) in a DataFrame with three columns:

import pandas as pd

data = {'Name': ['John', 'Jane', 'Mike', 'Alice'],
        'Age': [25, 30, 22, 28],
        'City': ['New York', 'San Francisco', 'Chicago', 'Los Angeles']}

df = pd.DataFrame(data)

# Invalid column index access
print(df.iloc[:, 3])  # Attempting to access the 4th column

Again, this occurs because the DataFrame has only three columns with valid indices 0 to 2, and we are attempting to access the 4th column (index 3).

How to fix this problem?

Knowing the causes of the error is the first step to solving it. After that, you can follow these steps to resolve the issue:

Step 1: Verify DataFrame's Number of Rows and Columns

Before accessing elements using iloc, ensure you know the number of rows in your DataFrame. You can use the shape attribute to obtain the dimensions of the DataFrame.

# Get the number of rows and columns in DataFrame
num_rows = df.shape[0]
num_columns = df.shape[1]
print("Number of rows: ", num_rows, "\nNumber of columns: ", num_columns)

Step 2: Ensure the Index is Within Bounds

You should make sure to verify that the index falls within the valid range (0 to num - 1). Use conditional statements to check the index before accessing the row or column.

num_rows = df.shape[0]
row_index = 4  # The row index to access

if row_index >= 0 and row_index < num_rows:
    print(df.iloc[row_index])
else:
    print("Invalid row index. Index should be between 0 and", num_rows - 1)

Step 3: Avoid Hardcoding Indices

Instead of hardcoding row indices, use loop constructs or iterators to iterate over the DataFrame rows. This prevents the need to access specific rows by index.

# Loop all rows
for index, row in df.iterrows():
    print("Row", index, ":", row)

Step 4: Handle Potential Exceptions

To avoid the "IndexError" altogether, consider using exception handling when working with user-provided or uncertain data. Use try-except blocks to catch and handle potential exceptions.

try:
    print(df.iloc[5]) # Attempting to access the 6th row
except IndexError:
    print("Invalid row index. Please ensure the index is within the valid range.")

Some tips to avoid this error

Use CSV Reading with Error Handling

When reading data from CSV files, use Python's built-in file handling and error handling mechanisms to check if the file is empty or does not exist before attempting to create a DataFrame.

import pandas as pd

file_path = 'data.csv'
try:
    with open(file_path) as f:
        first_line = f.readline()
        if not first_line:
            print("File is empty!")
        else:
            df = pd.read_csv(file_path)
except FileNotFoundError:
    print("File not found!")

Consider alternatives to DataFrames

While pandas DataFrames are a powerful tool for data manipulation and analysis, there are instances where you might prefer alternatives to avoid potential errors like "IndexError: single positional indexer is out-of-bounds."

Use Dictionaries or NamedTuples

If you need labeled data and a DataFrame is not necessary, consider using dictionaries or collections.namedtuple. These data structures can provide similar functionality without the overhead of a DataFrame.

# Use dictionaries
data = [{'Name': 'John', 'Age': 25, 'City': 'New York'},
        {'Name': 'Jane', 'Age': 30, 'City': 'San Francisco'},
        {'Name': 'Mike', 'Age': 22, 'City': 'Chicago'},
        {'Name': 'Alice', 'Age': 28, 'City': 'Los Angeles'}]
        
# Use NamedTuples
from collections import namedtuple

Person = namedtuple('Person', ['Name', 'Age', 'City'])
data = [Person('John', 25, 'New York'),
        Person('Jane', 30, 'San Francisco'),
        Person('Mike', 22, 'Chicago'),
        Person('Alice', 28, 'Los Angeles')]

For Simple Lists

For simple operations on lists or arrays, use native Python lists or NumPy arrays. DataFrame overhead might not be necessary, and it reduces the risk of DataFrame-related errors.

# Use native Python lists
data = [1, 2, 3, 4, 5]
mean_value = sum(data) / len(data)

# Or NumPy arrays
import numpy as np

data = np.array([1, 2, 3, 4, 5])
mean_value = np.mean(data)

Conclusion

The "IndexError: single positional indexer is out-of-bounds" error is a specific type of IndexError that occurs when accessing elements in pandas DataFrames using invalid indices. This error can arise due to various scenarios, such as invalid row or column indices with iloc, iat, loc, and at. By understanding these scenarios and the functions' behavior, we can effectively troubleshoot and resolve the errors. To avoid encountering this error, it is essential to verify DataFrame dimensions, use valid indices and labels, and handle potential exceptions gracefully. Additionally, employing loop constructs for safer row access and being cautious when reading data from CSV files can prevent DataFrame-related issues. Implementing these best practices ensures smoother data manipulation and analysis with pandas, enhancing the overall reliability and efficiency of our Python programs.

That's it for today. Have fun coding!

Which method can be used to add a group of elements to a set?

Wed, 14 Jan 2026 11:54:37 +0000

Introduction

Adding a group of elements to a set in Python is a common task encountered in programming when dealing with collections of unique elements. This problem arises when there's a need to incorporate multiple items into an existing set efficiently. Sets in Python ensure uniqueness, meaning duplicate elements are automatically filtered out. However, adding a group of elements to a set requires special attention to maintain this uniqueness while achieving the desired functionality. Fortunately, Python offers various methods to address this challenge, providing flexibility and efficiency in managing sets. By understanding these methods, programmers can effectively manipulate sets to accommodate new elements while preserving their distinctiveness.

What is a Set?

In Python, sets are a fundamental data structure used for storing collections of unique elements. Unlike lists or tuples, sets do not allow duplicate values, ensuring that each element within the set is unique. Sets are unordered, meaning that the elements are not stored in any particular order, and they are mutable, allowing for dynamic changes to the set's contents.
Sets in Python are like containers that holds a collection of unique items.
Imagine you have an empty bag where you can only keep unique items; that's essentially what a set is.
Each item in a set is distinct, and the order doesn't matter. If you try to put a duplicate item, it simply won't go in.
Sets in Python are denoted by curly braces {} enclosing a comma-separated list of elements, or by using the set() constructor.

Let's look at a small example to understand what a set is,

EXAMPLE

CODE

  # Unique Elements
     fruits_1 = {'mango', 'apple', 'orange', 'kiwi'}
     print("Set of Fruits-1 : ", fruits_1)

     # Even if I repeat elements, it will consider that element to be unique only
     fruits_2 = {'mango', 'apple', 'orange', 'kiwi','orange'}
     print("Set of Fruits-2: ", fruits_2)

OUTPUT

Adding a group of elements to a set

Using update() method
Using | Operator
Using Set Union Method - union()
Using Set Comprehension
Using Set Constructor

These methods offer flexibility in adding a single element or a group of elements to a set in Python-3.

CODE

# Define a set
my_set = {1, 2, 3}

# Define a list of elements to add
to_add_elements = [4, 5, 6]

Method - 1

Using `'update()'` method

This method directly adds multiple elements to a set in Python-3.
It takes an iterable (such as a list, tuple, or set) as input and modifies the set by adding all elements from the iterable.
Example: my_set.update(elements_to_add).

CODE

# Method 1: Using update() method
my_set.update(to_add_elements)
print("my_set", my_set)

OUTPUT

Tip: Use `update()` method when you want to directly add multiple elements to a set.

Method - 2

Using `'|'` Operator

The set union operator (|) performs a union operation between two sets, adding elements from both sets to create a new set.
It combines the existing set with another set created from an iterable using the set() constructor.
Example: my_set |= set(elements_to_add).

CODE

# Method 2: Using '|' operator
my_set |= set(to_add_elements)
print("my_set : ", my_set)

OUTPUT

Method - 3

Using Set Union Method - `'union()'`

The union() method returns a new set containing all the elements from the existing set and an iterable.
It doesn't modify the original set but creates a new set with the
combined elements.
Example: my_set = my_set.union(elements_to_add)

CODE

# Method 3: Using union() method
my_set = my_set.union(to_add_elements)
print("my_set : ", my_set)

OUTPUT

Method - 4

Using Set Comprehension

Set comprehension is a concise way to create sets in Python by iterating over an iterable.
It allows for adding elements from the iterable to the set while creating it.
Example: my_set = {element for element in my_set} | set(elements_to_add).

CODE

# Method 4: Using set comprehension
my_set = {element for element in my_set} | set(to_add_elements)
print("my_set : ", my_set)

OUTPUT

Tip: Employ set comprehension for a concise way to create sets by iterating over an iterable.

Method - 5

Using Set Constructor

The set() constructor creates a new set from an iterable, automatically removing any duplicate elements.
It can be combined with set operations like union to add elements from the iterable to the existing set.
Example: my_set = my_set.union(set(elements_to_add)).

CODE

# Method 5: Using set constructor
my_set = my_set.union(set(to_add_elements))
print("my_set : ", my_set)

OUTPUT

All the 5 Methods in One Go!

# Define a set
my_set = {1, 2, 3}

# Define a list of elements to add
elements_to_add = [4, 5, 6]

# Method 1: Using update() method
my_set.update(elements_to_add)

# Method 2: Using set union (| operator)
my_set |= set(elements_to_add)

# Method 3: Using union() method
my_set = my_set.union(elements_to_add)

# Method 4: Using set comprehension
my_set = {element for element in my_set} | set(elements_to_add)

# Method 5: Using set constructor
my_set = my_set.union(set(elements_to_add))

Note: Pay attention to the performance implications of each method, especially when dealing with large sets.

Best Practices

Here are some best practices to follow when adding elements to a set:

Choose the most appropriate method:

Depending on your specific use case and preference, choose the method that best suits your needs. Each method has its advantages, but some might be more efficient or readable depending on the context.
Use update() for simplicity:

When you want to add multiple elements to an existing set and modify it in place, update() is the simplest and most straightforward method. It directly modifies the original set without creating a new one.
Document your code:

Clearly document your code, especially if you're using less common methods or if the purpose of the code might not be immediately obvious. Documenting your code helps other developers understand your intentions and use your code effectively.
Test thoroughly:

Test your code with various inputs and edge cases to ensure it behaves as expected. Consider writing unit tests to automate testing and catch regressions.

Note: Ensure that the elements you're adding to the set are unique to maintain set's uniqueness property.

Caution: Be cautious when using set comprehension with large iterables, as it may lead to increased memory usage.

Summary

Sets in Python are collections of unique elements, akin to a bag where each item is distinct.
They are useful for tasks requiring uniqueness, like removing duplicates or finding unique elements.
Various methods exist to add a group of elements to a set, including update(), set union (| operator), union() method, set comprehension, and set constructor.

Conclusion

In simpler terms, when working with sets in Python, you have different methods for adding multiple items. You can choose the one that suits your needs best:

If you want a straightforward approach, you can use update().
For a more elegant solution, you can use | (the pipe symbol).
If you need more flexibility, union() is a good option.
If you prefer concise code, you can use set comprehension.
And if you need to build a set from other iterable types, you can use the set constructor.

Understanding these methods helps you manage sets effectively, ensuring that each item you add remains unique.

References

Python documentation:https://www.python.org/doc/

Building an Intelligent Contract Assistant with OpenAI Agents SDK

Tue, 10 Jun 2025 13:20:38 +0000

Building an Intelligent Contract Assistant with OpenAI Agents SDK

In this article, we explore how we leveraged the OpenAI Agents SDK to create a sophisticated contract management system that combines multiple AI agents working in harmony. Let's dive into the key architectural decisions and technical implementations that make this system powerful and efficient.

️ Multi-Agent Architecture

At the heart of our system lies a multi-agent collaboration pattern, orchestrated by a supervisor agent that intelligently routes requests to specialized sub-agents. This architecture enables us to handle complex contract-related tasks with precision and efficiency.

The Supervisor Agent

The supervisor agent serves as the frontline interface, managing the conversation flow and making intelligent routing decisions. It's equipped with:

Advanced intent classification capabilities
Knowledge of contract templates and guidelines
Ability to handle general queries directly
Smart routing to specialized sub-agents using the handoff mechanism

Specialized Sub-Agents

1. Contract Drafting Agent

This agent demonstrates the power of combining LLMs with structured workflows:

️ Uses function tools to implement a three-step process:
1. Contract type determination
2. Dynamic question generation based on contract type
3. Contract generation using GPT-4
Supports three contract types:
- Purchase Agreements
- Franchise Agreements
- Time and Materials Contracts
Leverages template files for consistent structure

2. Existing Contract Agent

Handles all aspects of contract management:

Contract status retrieval
Detailed contract information
❓ Query resolution for existing agreements

3. General Contract Assistant

Provides expert guidance on:

Contract type selection
❓ General contract-related queries
Best practices and guidelines

⚙️ Technical Implementation Highlights

1. Handoff Mechanism

We implemented the Agent Pattern of Routing using the handoff_description feature, enabling seamless transitions between agents while maintaining context.

2. ️ Function Tools Integration

The system extensively uses function tools to:

Determine contract types
❓ Generate relevant questions
Draft contracts using GPT-4
Retrieve contract details and status

3. ⚡ Streaming Outputs

Implemented real-time response streaming for:

Smooth conversation flow
⚡ Immediate feedback
Enhanced user experience

Usage

Try out with these sample prompts -

"I need help with a purchase agreement."
"Can you show me the status of contract #12345?"

Key Technologies

OpenAI Agents SDK for agent management OpenAI Agents SDK
GPT-4 for contract generation GPT-4
️ Function tools for structured operations Function tools
⚡ Streaming for real-time responses Streaming

This implementation demonstrates how modern AI technologies can be combined to create sophisticated, practical applications that solve real-world business problems.

View the implementation on GitHub

Captured below are the sample conversation screenshots -

A multi-agent HR assistant that handles various HR-related queries and actions using OpenAI- Agents Framework

Sat, 24 May 2025 11:37:31 +0000

Building an AI-Powered HR Assistant with OpenAI Agents SDK

Introduction

In the era of digital transformation, automating HR queries and processes can significantly enhance employee experience and operational efficiency. In this project, I built an intelligent HR Assistant using the OpenAI Agents SDK that can handle a variety of HR-related queries, triage requests, and even trigger backend actions such as leave requests or complaint registration. The assistant features a conversational UI built with Gradio, making it accessible and user-friendly.

Key Features

Multi-Agent Architecture: Specialized agents handle different HR domains (leaves, benefits, policies, complaints).
Guardrails: Input guardrails ensure only HR-related queries are processed, improving safety and relevance.
Tool Integration: Backend functions (tools) are registered with agents, allowing the assistant to perform actions like creating leave requests or registering complaints.
Context Management: The assistant maintains conversation history, enabling context-aware, multi-turn conversations.
User Interface: A Gradio-based web UI provides a seamless chat experience.

Project Structure & Important Aspects

1. Agent Design

Each HR domain is managed by a dedicated agent:

Leaves Agent: Handles leave policies and requests.
Benefits Agent: Answers questions about employee benefits.
Policy Agent: Provides information on company policies.
Complaints Agent: Registers and tracks complaints.

A Triage Agent routes user queries to the appropriate specialist agent.

2. Guardrails

A guardrail agent checks if the user’s query is HR-related before passing it to the triage agent, ensuring the assistant stays on topic.

3. Tool Functions

Tools are Python functions registered with agents. For example:

@function_tool
def create_leave_request(employee_id: str, department: str, leave_type: str, start_date: str, end_date: str):
    return f"Leave request created for {employee_id} in {department} from {start_date} to {end_date} for {leave_type}."

Agents invoke these tools when appropriate, enabling real actions beyond just answering questions.

4. Context Management

The assistant maintains a persistent conversation history, which is included in each prompt to ensure context continuity across multiple turns. This is crucial for handling follow-up questions and multi-step workflows.

5. Gradio UI

A simple yet effective chat interface was built using Gradio, allowing users to interact with the HR assistant in real time.

Example Queries

“I need to take a leave next week.”
“What is the company’s life insurance policy?”
“How many sick leaves do I have left?”
“I want to register a complaint about my manager.”
“Tell me about the gym membership benefit.”

Demo

Video Demo

Try it Yourself

The full project is available on GitHub:
GitHub Repository

Demo Queries

Try these in the chat UI:

“Can I get parental leave?”
“How do I register a complaint?”
“What are the food coupon benefits?”
“Tell me about the weekend shift policy.”
“I want to apply for sick leave from tomorrow.”

Conclusion

This project demonstrates how the OpenAI Agents SDK can be leveraged to build robust, context-aware, and action-oriented assistants for enterprise use cases. With modular agents, tool integration, and a user-friendly UI, the HR Assistant is a step towards smarter, more efficient HR operations.

For more details and to contribute, visit the GitHub repository.

"Dive Deep, Code Smart—Master the Waves of DSA!"

Thu, 16 Jan 2025 17:07:17 +0000

Diving into the Pool of Data Structures and Algorithms: A Swimmer’s Guide to Problem-Solving

Welcome to the world of Data Structures and Algorithms (DSA), where every concept is like a swimming technique and every challenge is an opportunity to swim deeper. In this guide, we will explore the basic and advanced elements of DSA, helping you navigate this vast ocean of knowledge. Just like swimming, mastering DSA takes practice, patience, and the right approach.

The Shallow End: Foundations of Data Structures

Arrays: The Swimming Lanes

Arrays act like swimming lanes that offer direct access to any point. Each element has a defined index, allowing you to precisely navigate your data.

cpp
int arr[5] = {10, 20, 30, 40, 50}; // Initializing an array
cout << arr[2]; // Accessing third element (Output: 30)
```

Linked Lists: The Relay Race

Linked Lists are like a relay race where each node points to the next, ensuring continuous movement of data.

cpp
struct Node {
    int data;
    Node* next;
};

Stacks: The Diving Board (LIFO)

Stacks are like diving boards, where the Last In, First Out (LIFO) principle governs the order of operations.

python
stack = []
stack.append(10) # Push an element
stack.append(20)
print(stack.pop()) # Pop the last inserted element (Output: 20)

Queues: The Diving Platform Line (FIFO)

Queues operate like a line at a diving platform, where the First In, First Out (FIFO) order dictates the flow of data.

python
from collections import deque
queue = deque([1, 2, 3])
queue.append(4) # Enqueue
print(queue.popleft()) # Dequeue (Output: 1)

The Deep End: Advanced Data Structures

Trees: The Towering Platforms

Binary Search Trees (BST) guide you through organized data, ensuring efficient depth searches.

python
class Node:
    def __init__(self, key):
        self.left = self.right = None
        self.key = key

Graphs: The Interconnected Pools

Graphs are like interconnected pools where each node can follow multiple paths.

python
graph = {
    'A': ['B', 'C'],
    'B': ['A', 'D', 'E'],
    'C': ['A', 'F'],
    'D': ['B'],
}

Heaps: The Underwater Safety Zones

Heaps allow for optimal retrieval of the highest or lowest value, much like safety zones at varying depths.

python
import heapq
heap = []
heapq.heappush(heap, 10)
heapq.heappush(heap, 5)
print(heapq.heappop(heap)) # Output: 5 (Min-Heap)

Hash Tables: The Underwater Lockers

Hash Tables are like underwater lockers that provide instant access to data through keys.

python
hash_table = {}
hash_table['name'] = 'Alice'
print(hash_table['name']) # Output: Alice

Mastering the Strokes: Algorithms

Sorting Algorithms

Bubble Sort: Slow paddling.
Merge Sort: Graceful strokes.

Quick Sort: Swift dives.

python
def quick_sort(arr):

  if len(arr) <= 1:
      return arr
  pivot = arr[len(arr) // 2]
  left = [x for x in arr if x < pivot]
  right = [x for x in arr if x > pivot]
  return quick_sort(left) + [pivot] + quick_sort(right)

Searching Algorithms

Linear Search: Exhaustive exploration.

Binary Search: Precise diving.

python
def binary_search(arr, target):

  low, high = 0, len(arr) - 1
  while low <= high:
      mid = (low + high) // 2
      if arr[mid] == target:
          return mid
      elif arr[mid] < target:
          low = mid + 1
      else:
          high = mid - 1
  return -1

Dynamic Programming (DP)

Dynamic Programming is akin to endurance swimming—breaking problems into subproblems and storing results.

python
def fibonacci(n, memo={}):
    if n in memo:
        return memo[n]
    if n <= 1:
        return n
    memo[n] = fibonacci(n-1, memo) + fibonacci(n-2, memo)
    return memo[n]

Greedy Algorithms

Greedy Algorithms are like swimmers choosing the shortest path to their goal.

python
def coin_change(coins, amount):
    coins.sort(reverse=True)
    count = 0
    for coin in coins:
        while amount >= coin:
            amount -= coin
            count += 1
    return count if amount == 0 else -1

Overcoming the Tides: Complexity Analysis

Understanding time and space complexity is crucial for smooth sailing in DSA:

O(1): Best-case efficiency (e.g., hash table lookups).
O(log n): Efficient algorithms (e.g., binary search).
O(n): Linear time (e.g., traversing an array).
O(n log n): Sorting algorithms (e.g., quicksort, mergesort).
O(n²) or more: Inefficient approaches (e.g., bubble sort).

The Ultimate Dive: Real-World Applications

DSA powers many real-world applications:

Google’s Search Algorithms
Uber’s Shortest Route Calculations
Social Media Friend Suggestions
Efficient Database Indexing

Conclusion: The Endless Ocean

Mastering DSA is like swimming through an ocean of opportunities. The more you practice, the deeper you dive into problem-solving and the better you become at navigating complex challenges. Whether you’re a beginner or an expert, DSA offers endless possibilities for growth. Dive in, explore, and become a master of the tides of problem-solving!

References:

Django TemplateDoesNotExist Solved

Sat, 01 Jun 2024 23:24:56 +0000

While working in Django, you might encounter the "TemplateDoesNotExist" error. This issue typically arises due to incorrect configuration of template settings or paths. Fortunately, you can easily solve this error by properly configuring your settings.py file to include the correct template directories. In this article, I will guide you through the steps to set up your template directories correctly, how to debug potential issues, and ensure your templates are correctly recognized by Django a Python framework, all presented straightforwardly and practically.

Configuring Django Template Settings

The settings file of Django (settings.py) determines where the framework should look for templates. In this sense, it is the first step towards the successful resolution of all errors related to templates, since making sure that it is correctly set up is the first step.

Template Directories

Ensure your TEMPLATES configuration in settings.py includes the correct path to your templates. For example:

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, 'templates')],
        'APP_DIRS': True,
        ...
    },
]

Explanation: Inside the TEMPLATES setting, the value of the DIRS option should be the absolute path to the directory of your templates. BASE_DIR is a variable that holds the path to your project directory combined with 'templates' to point Django to the correct location.

Common Scenarios and Solutions

Scenario 1: Template Misplacement

Problem: Your template is not in a directory recognized by Django.

Solution: Move your template into one of the directories identified by the DIRS option in the TEMPLATES setting, or make sure the directory of your template appears in the appropriate application's templates directory if APP_DIRS is set to True.

Scenario 2: Typographical Errors in Template Name

Problem: There is a typo in the template name used in your view.

Solution: Verify the template name in your view matches exactly with the filename in your templates directory, including case sensitivity.

Scenario 3: Incorrect App Structure

Problem: Django cannot find the template because the app structure does not conform to Django's expectations.

Solution: Ensure each app in your project contains a templates directory. Django looks for templates inside the templates directory of each installed app if APP_DIRS is True.

Demonstrating a Solution

Create a Django project and start an app with the command:

python manage.py startapp app

Create a templates folder in the app folder and inside that create a my_template.html. Your folder structure should look something like the following.

urls.py

from django.contrib import admin
from django.shortcuts import render
from django.urls import path

def sample_view(request):
    return render(request, "this_template_does_not_exist.html")

def my_view(request):
    return render(request, "app/my_template.html")

urlpatterns = [
    path("admin/", admin.site.urls),
    path("test/", sample_view, name="test"),
    path("view/", my_view, name="view"),
]

my_template.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Template</title>
</head>
<body>
    This template exists
</body>

Now start the server with

python manage.py runserver

Now when you go to http://localhost:8000/view you should be able to see the following output as the file exists and there are no typos involved.

But when you go to http://localhost:8000/test you should be able to see the following output as the file does not exist.

Caution: Confirm that `my_template.html` is placed in `/templates/` and that your `settings.py` correctly points to this directory as described earlier.

Best Practices to Avoid the "TemplateDoesNotExist" Issue

The TemplateDoesNotExist error is a common issue in Django that can halt your development process. However, it's also one of the easiest to prevent with the right practices. You can refer various Debugging Techniques in Python to know more about the type of error. Here are some tips to ensure you never run into this error again:

1. Verify Your TEMPLATES Configuration

The most common cause of this error is a misconfiguration in the TEMPLATES setting in your settings.py file. Double-check that you have correctly defined the DIRS list to include the paths to your templates. Use the os.path.join(BASE_DIR, 'templates') pattern to ensure that your paths are correctly constructed and platform-independent.

2. Adhere to Django's Project Structure

Django expects your project to follow a certain structure, with a specific place for templates. By default, Django looks for a templates directory in each app folder if APP_DIRS is set to True in your TEMPLATES configuration. Ensure you place your templates in the correct directories within your apps or in the global templates directory you specify in DIRS. You can also use a Virtual Environment to isolate the project.

3. Use Correct Template Naming and Referencing

Always verify that the template names and paths you use in your views match exactly with your template files, including case sensitivity, which can be an issue on some file systems. A common mistake is a simple typo in the template path or name, leading Django to report that it cannot find the template.

4. Understand Template Loading Mechanism

Familiarize yourself with how Django loads templates, especially when using multiple apps. Django will search through the apps listed in INSTALLED_APPS in the order they appear, looking for templates in each app's templates directory. Knowing this order can help you troubleshoot and understand which template is being loaded when you have templates with the same name in different apps.

5. Regularly Check for Deprecated or Moved Templates

When upgrading Django or third-party apps, templates might be deprecated or moved. Always check the release notes for any changes to template paths or names to ensure your project stays up-to-date and error-free.

6. Utilize Django's Template Debugging Tools

Make use of Django's built-in template debugging tools, such as setting DEBUG to True in your development settings to get detailed error pages that show you exactly where Django looked for your templates and where it failed to find them. This can be invaluable for quickly diagnosing and fixing path issues.

7. Consistent Use of Template Extensions

Be consistent in your use of template file extensions. Django does not enforce a specific extension for templates (.html is common but not required), but using different extensions inconsistently can lead to confusion and errors.

8. Automate Template Checks

Consider incorporating checks into your deployment pipeline that verify the existence of templates referenced in your views. This can be as simple as a script that scans your views for render calls and checks that the referenced templates exist in your project's template directories.

Conclusion

The "TemplateDoesNotExist" error in Django can be a stumbling block for developers. However, with a systematic approach to troubleshooting—verifying template locations, ensuring correct settings in settings.py, and checking for typos—you can resolve this issue efficiently. Understanding Django's templating system and how it locates templates is crucial for developing dynamic, error-free web applications.

Remember, the key to avoiding such errors lies in adhering to Django's project structure conventions and thoroughly checking your configuration settings. With these practices, you'll find working with Django templates to be a smooth and error-free experience.

Additional Resources

Django Official Documentation: Templates (https://docs.djangoproject.com/en/stable/topics/templates/)
Django Official Documentation: Settings (https://docs.djangoproject.com/en/stable/topics/settings/)

Python Exception Handling

Mon, 04 Mar 2024 22:54:04 +0000

While working on the Python code you come across a situation where your program is stopped by the compiler during the execution and something like an error is displayed on the terminal, exception handling was the solution at that time. Well, that is a common problem in every developer's life. In this tutorial I will talk about Python exceptions and different types of exceptions with examples, also why exception handling is important, and how Python manages these exceptions effectively. Let's get started.

Why Error Handling Matters?

Suppose you are using a food ordering application and suddenly the app crashes. You have no idea why the app stopped working. So, exception handling is essential as it prevents the app from future errors and handles them effectively. Exception handling helps you with the smooth execution of your programs and removes the risk of abnormal event occurrence if it's handled during the program development phase. If some errors are left unchecked then that will cause the application to crash, data loss, and worse, so that is the reason exception handling is a significant matter.

It prevents the software from crashing and stopping abruptly.
Make the user experience better by reducing the frustration and confusion with properly displaying the error message.
It ensures data safety and integrity and handles data reliability.
It also helps the developer to safeguard their application from hacker attacks.
It reduces the need for future cost increments for technical support and saves time beforehand.

How Python Manages Errors with Exception Handling?

During your programming life, you may encounter many types of errors, which can be a syntactical error, an error that comes upon run-time, or a logical error. We can resolve the syntax error simply because it will show the error on the compilation time run time error occurs it will not halt the program compilation but shows unexpected behavior during the execution time that deviates from the normal flow of the program.

Note: Remember, a syntax error is a common error that can be caught before execution but if it is not caught in some situation at compile time then there is one built-in exception as well.

Exception Handling Different Ways

Python manages the errors by writing the program that handles the exception. There are many ways for exception handling in Python. So, let's dive into it:

Try: When you see that a specific piece of code will cause the error, you put it inside the try block.
Except: If the code in the try block creates an error. Python will jump to the except block and execute it. So, right after the try block, we must write the except block.
Finally: After using the try and except block, you can use the finally block which always executes whether the exception occurs or not.
Else: Instead of using the finally block, you can also use the else block right after a try-and-except block. It will help you to make sure that no exception occurs in the program, as it will only run when there is no exception.
Raise: One more exception handling is done by using the raise keyword, you can use it without using try and except block and just raise an exception that would most probably pop up.

Tip: It is important to use except block when you are using a try block. Many except blocks can be used with one try block

Understanding Exceptions

Exceptions in Python

Exception is like a situation that halts the normal flow of the program and stops the program in between without any reason. Exceptions are not related to the syntax error in the program but a run time issue. It will help the program to run smoothly and improve the robustness of the program. In Python, an exception is like a capsule that encapsulates the error events related to the program's abnormal behavior. When the Python compiler encounters a situation that cannot be handled on its own, it raises the exception by signaling the developer to resolve it.

Exploring Different Types of Exceptions

As we know there are two types of exceptions in Python, each has its use case and can be used by the developer in certain situations. These are:

Built-in Exception: A built-in exception is a type that is already defined in Python. These exceptions normally encounter errors by many of you, so Python developed the module based on it, which is helpful and time-saving.
User-defined exception Sometimes a situation occurs where you cannot handle it by the available built-in exceptions, therefore Python allows you to make the custom exception to handle this type of problem and the programmer has to define the exception on its own with coding.

Examples of Common built-in Exceptions

Python has a vast range of built-in exceptions. Each exception has been used for specific error occurrences. Each has its use case. So, let's explore each one of them:

1: Value Error

This exception occurs when the function gets an argument with the correct datatype, but the value of that datatype is invalid.

#here we pass the string to int datatype that is an invalid value 
number = int("string")

Output

2: Type Error

This exception occurs when the operation is performed on an incorrect type.

#here we perform an addition operation on a string with an int datatype that is inappropriate
number = 7 + "7"

Output

3: Assert Error

This exception occurs when the assert expression fails. Its main purpose is to debug and check expressions.

#here assertion error occurs because the expression fails 
assert 5!=5

Output

4: Module Error

This exception occurs when you are trying to import the module, but Python cannot locate the module.

#here import cannot locate the specified module 
import module_Name

Output

5: Index Error

This exception occurs when you try to access the number from the list that is not added or out of range.

#here num_add variable tries to access the number at index 6 which is out of range 
number_list = [1,2,3,4,5] 
num_add = number_list[6]

Output

6: ZeroDivision Error

This exception normally occurs when you try to divide a number with the second operand as zero.

#here num variable stores the result by dividing the 10 by 0 
num  = 10/0

Output

7: Name Error

This exception occurs when you try to use a variable that is not defined locally and globally in the program

#here when the variable is undefined, and you are trying to use it 
num = 10 
num2 = num/num3 
print(num2)

Output

8: Syntax Error

This exception occurs when the incorrect syntax is not detected by the parse or interpreter before the code compilation.

#here syntax is incorrect 
num  10; 
num2 50; 
result 10 + 50

Output

9: FileNotFound Error

This exception occurs when you try to open the file but it fails because the compiler cannot find the specific file in your program folder. This exception is the subclass of the OSError exception.

#Try to manipulate the file that is not available and cannot be found at the provided path 
def read_content_from_file(file_path):
    with open(file_path, 'r') as file:
        content =  file.readlines()
    
file_path = "file.txt"
read_content_from_file(file_path)

Output

10: Indentation Error

This exception usually occurs when you use incorrect indentation.

#IndentationError: incorrect indent/space is used at the return line 
def add(): 
    num1 = 7 
    num2 = 25 
    result = num1 + num2 
        return result
    
cal = add()
print("Sum of two numbers", cal)

Output

Note: All exception types are objects because they are inherited from the exception base class.

FAQs Q: Can I create my exception?
A: Yes, you can define your custom-built exception class by inheriting it from the Exception base class. Q: Is error or exception handling different?
A: Yes, there are many types of error that you can catch before compiling the code but sometimes the error occurs where only exception handling is required. Q: Is it possible to execute the code regardless of checking error occurrence?
A: Yes, by using the finally block with the try and catch block you can execute the code that is written in the finally block because the finally block will execute whether the exception occurs or not.

Wrapping Up

In conclusion, we discussed the need for exception handling in the software development process before the program is released in the market or available for the user. As you know, exception handling is a powerful concept of programming language. It helps you as well as prepares you beforehand for future errors. Many built-in exceptions provided by Python cover most of your errors during the program development but you can also use the custom-based exception if you encounter a situation where no built-in exception is helpful, this problem is also resolved by the Python programming language. Now, I hope you will easily handle the exception in your code. Thank you for reading the guide. Happy Coding!

Coder Legion - Recent posts tagged python-3

Building a survey-based ML pipeline to find out what's really holding SEE and +2 graduates back

Fixed "Indexerror: single positional indexer is out-of-bounds"

What is "IndexError: single positional indexer is out-of-bounds" error?

How is this error different from other IndexError errors?

What causes the error in Python?

DataFrame Indexing Functions:

Scenario 1: Invalid Row Index

Scenario 2: Invalid Column Index

How to fix this problem?

Step 1: Verify DataFrame's Number of Rows and Columns

Step 2: Ensure the Index is Within Bounds

Step 3: Avoid Hardcoding Indices

Step 4: Handle Potential Exceptions

Some tips to avoid this error

Use CSV Reading with Error Handling

Consider alternatives to DataFrames

Use Dictionaries or NamedTuples

For Simple Lists

Conclusion

Which method can be used to add a group of elements to a set?

Introduction

What is a Set?

EXAMPLE

Adding a group of elements to a set

Method - 1

Using 'update()' method

Method - 2

Using '|' Operator

Method - 3

Using Set Union Method - 'union()'

Method - 4

Using Set Comprehension

Method - 5

Using Set Constructor

All the 5 Methods in One Go!

Best Practices

Choose the most appropriate method:

Use update() for simplicity:

Document your code:

Test thoroughly:

Summary

Conclusion

References

Building an Intelligent Contract Assistant with OpenAI Agents SDK

Building an Intelligent Contract Assistant with OpenAI Agents SDK

️ Multi-Agent Architecture

The Supervisor Agent

Specialized Sub-Agents

1. Contract Drafting Agent

2. Existing Contract Agent

3. General Contract Assistant

⚙️ Technical Implementation Highlights

1. Handoff Mechanism

2. ️ Function Tools Integration

3. ⚡ Streaming Outputs

Usage

Key Technologies

Captured below are the sample conversation screenshots -

A multi-agent HR assistant that handles various HR-related queries and actions using OpenAI- Agents Framework

Building an AI-Powered HR Assistant with OpenAI Agents SDK

Introduction

Key Features

Project Structure & Important Aspects

1. Agent Design

2. Guardrails

3. Tool Functions

4. Context Management

5. Gradio UI

Example Queries

Demo

Video Demo

Try it Yourself

Demo Queries

Conclusion

"Dive Deep, Code Smart—Master the Waves of DSA!"

Diving into the Pool of Data Structures and Algorithms: A Swimmer’s Guide to Problem-Solving

The Shallow End: Foundations of Data Structures

Arrays: The Swimming Lanes

Linked Lists: The Relay Race

Using `'update()'` method

Using `'|'` Operator

Using Set Union Method - `'union()'`