DEV Community: Mr.Shah

Track NSE Derivatives Top Contracts Easily – Copy This Ready-to-Use Code

Mr.Shah — Wed, 25 Jun 2025 06:43:25 +0000

Friends, after so many requests (literally bahut saare messages aaye the!), I'm finally back with another NSE-related Python tutorial. Aap logo ka pyaar dekhte hue, today I want to share how I created this small but powerful program that shows live NSE derivatives Top Contract data in the simplest way possible. Even if you're new to coding, you can understand this (aur haan, this time I won't disappear for months - promise!).

We all know how frustrating it is to keep refreshing the NSE website to check option prices (time waste na?). I wanted a quicker way to track top contracts without all that hassle. So I thought - "Let's make my own tracker that just works!"

How It Works (Step-by-Step)

First It Asks You - When you run it, the program politely asks "Bhaiya, kitne contracts dikhau?" (5, 10, 15 or 20?)
Fetches Live Data - : It quietly gets live data from NSE website (like a mini browser).
Shows Clean Output - Displays only important columns in colorful format (Green = up, Red = down - just like trading apps!)
Auto-Refresh - Updates every 1-2 minutes (no manual refresh needed)

The Best Parts

No Login Needed - Unlike other apps (jo har waqt OTP mangte hain)
Error Proof - If internet slow hai, it tries again 3 times (very patient program!)

How To Use It

Just 3 steps:

Copy the code
Save as nse_tracker.py
Run python nse_tracker.py

import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
import pandas as pd
import time
import random
from datetime import datetime
from colorama import init, Fore, Back, Style
import os

init(autoreset=True)

class NSE:
    def __init__(self):
        self.url = "https://www.nseindia.com/api/liveEquity-derivatives?index=top20_contracts"
        self.headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
            'Accept': 'application/json, text/plain, */*',
            'Accept-Language': 'en-US,en;q=0.9',
            'Referer': 'https://www.nseindia.com/market-data/equity-derivatives-watch'
        }
        self.limit = self.get_choice()
        self.session = self.setup_session()

    def setup_session(self):
        s = requests.Session()
        retry = Retry(total=3, backoff_factor=2, status_forcelist=[401, 429, 500, 502, 503, 504])
        s.mount('https://', HTTPAdapter(max_retries=retry))
        return s

    def get_choice(self):
        print(f"{Fore.CYAN}{'='*50}")
        print(f"{Fore.CYAN}{'NSE DERIVATIVES MONITOR':^50}")
        print(f"{Fore.CYAN}{'='*50}")
        print(f"{Fore.YELLOW}Select contracts to display:")
        choices = ["5", "10", "15", "20"]
        for i, c in enumerate(choices, 1):
            print(f"{Fore.GREEN}{i}. Top {c} contracts")

        while True:
            try:
                choice = input(f"\n{Fore.WHITE}Enter choice (1-4): ").strip()
                if choice in ['1', '2', '3', '4']:
                    val = [5, 10, 15, 20][int(choice)-1]
                    print(f"{Fore.YELLOW}Selected: Top {val} contracts")
                    return val
                else:
                    print(f"{Fore.RED}Invalid choice. Enter 1-4.")
            except KeyboardInterrupt:
                print(f"\n{Fore.YELLOW}Exiting...")
                exit(0)
            except Exception as e:
                print(f"{Fore.RED}Error: {e}. Try again.")

    def fetch(self):
        try:
            r = self.session.get(self.url, headers=self.headers, timeout=10)
            r.raise_for_status()
            return r.json()
        except requests.RequestException as e:
            print(f"{Fore.RED}Fetch error: {e}")
            return None

    def format(self, data):
        if not data or 'data' not in data:
            return None, {}

        df = pd.DataFrame(data['data'])
        print(f"{Fore.CYAN}API: {len(df)} contracts, showing: {self.limit}")

        df = df.head(self.limit)
        cols = ['underlying', 'optionType', 'strikePrice', 'lastPrice', 
                'change', 'pChange', 'volume', 'openInterest', 'noOfTrades']

        df = df[cols].copy()
        df.columns = ['Stock', 'Type', 'Strike', 'LTP', 'Change', 'Change%', 'Volume', 'OI', 'Trades']

        df['LTP'] = df['LTP'].round(2)
        df['Change'] = df['Change'].round(2)
        df['Change%'] = df['Change%'].round(2)
        df['Volume'] = df['Volume'].apply(lambda x: f"{x/1e6:.1f}M")
        df['OI'] = df['OI'].apply(lambda x: f"{x/1000:.0f}K")
        df['Trades'] = df['Trades'].apply(lambda x: f"{x/1000:.0f}K")

        return df, data.get('marketStatus', {})

    def header(self, status):
        os.system('cls' if os.name == 'nt' else 'clear')

        print(f"{Back.BLUE}{Fore.WHITE}{'='*80}")
        print(f"{Back.BLUE}{Fore.WHITE}{'NSE DERIVATIVES LIVE DATA':^80}")
        print(f"{Back.BLUE}{Fore.WHITE}{'='*80}{Style.RESET_ALL}")

        now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        mkt_date = status.get('marketCurrentTradingDate', 'N/A')
        mkt_status = status.get('marketStatusMessage', 'N/A')

        print(f"{Fore.CYAN}Time: {now}")
        print(f"{Fore.CYAN}Market Date: {mkt_date}")
        print(f"{Fore.CYAN}Status: {mkt_status}")
        print(f"{Fore.MAGENTA}Showing: Top {self.limit}")
        print(f"{Fore.YELLOW}{'-'*80}")

    def color(self, row):
        pct = float(row['Change%'])
        if pct > 5: return f"{Back.GREEN}{Fore.BLACK}"
        elif pct > 0: return f"{Fore.GREEN}"
        elif pct < -5: return f"{Back.RED}{Fore.WHITE}"
        elif pct < 0: return f"{Fore.RED}"
        else: return f"{Fore.WHITE}"

    def table(self, df):
        if df is None or df.empty:
            print(f"{Fore.RED}No data")
            return

        hdr = f"{Fore.YELLOW}{'Stock':^8} {'Type':^4} {'Strike':^7} {'LTP':^8} {'Change':^7} {'Change%':^8} {'Volume':^8} {'OI':^8} {'Trades':^8}"
        print(hdr)
        print(f"{Fore.YELLOW}{'-'*80}")

        for _, row in df.iterrows():
            c = self.color(row)
            print(f"{c}{row['Stock']:^8} {row['Type']:^4} {row['Strike']:^7} "
                  f"{row['LTP']:^8} {row['Change']:^7} {row['Change%']:^8} "
                  f"{row['Volume']:^8} {row['OI']:^8} {row['Trades']:^8}{Style.RESET_ALL}")

    def run(self):
        print(f"\n{Fore.GREEN}Starting NSE Monitor...")
        print(f"{Fore.YELLOW}Press Ctrl+C to stop")
        time.sleep(2)

        try:
            while True:
                data = self.fetch()
                delay = random.uniform(60, 90)

                if data:
                    df, status = self.format(data)
                    self.header(status)
                    self.table(df)
                    print(f"\n{Fore.MAGENTA}Next update: {delay:.0f}s...")
                else:
                    print(f"{Fore.RED}Failed. Retry: {delay:.0f}s...")

                time.sleep(delay)

        except KeyboardInterrupt:
            print(f"\n{Fore.YELLOW}Stopped by user")
        except Exception as e:
            print(f"{Fore.RED}Error: {e}")

def main():
    nse = NSE()
    nse.run()

if __name__ == "__main__":
    main()

Output

Important Note About Possible Errors (Read Before Trying!)

Doston, ek choti si warning de deta hoon - sometimes when you run this script, you might see errors like:

401/441 Error - This means NSE is blocking our request (thoda sa strict ho gaya hai NSE)
Max retries exceeded - Matlab program ne 3 baar try kiya, par NSE ne data nahi diya

Kyu Hota Hai Yeh?

NSE doesn't like when too many requests come from same computer (security reasons)
Sometimes they change their API rules without telling (typical na?)

PS: Full code upar hi diya hai - copy-paste karo aur enjoy karo! Koi doubt ho toh pooch lena.

Doston, aapke pyaar ne humesha mujhe motivate kiya hai! 😊 My previous NSE Python blogs (especially the NSE Option Chain Data using Python one) got such amazing response - 25K+ views and so many kind comments! Aap sab ka support hi hai jo mujhe aise useful scripts share karne ki himmat deta hai.

Meta AI Watermark Remover

Mr.Shah — Tue, 18 Mar 2025 09:40:54 +0000

Hey there! Ever tried removing a Meta AI watermark from an image? You might’ve spent hours searching for tools, downloading sketchy software, or even trying to edit it out manually—only to end up frustrated. Sound familiar?

Well, I’ve been there too. And after hitting wall after wall, I decided to take matters into my own hands. What if I could use AI to remove the Meta AI watermark? Sounds ironic, right? But guess what? It worked!

I created a simple Python script that does exactly that. And today, I’m sharing it with you. For just 200 Rs., you can get this handy tool and say goodbye to those pesky watermarks. Let me tell you all about it.

Why Should You Care?

Let’s be real—watermarks can ruin an otherwise perfect image. Maybe you’re a content creator, a designer, or just someone who loves sharing clean, professional-looking visuals. Whatever your reason, this tool is here to make your life easier.

With this script, you can remove it in seconds and get back to focusing on what really matters—your work.

How Does It Work?

I’ll keep it simple because no one likes tech jargon. Here’s the step-by-step:

Get the Script: Grab the Python script from my Gumroad page
Set It Up: Add your Google Gemini API key to the .env file. Don’t worry, I’ll walk you through it.
Run It: Place your image in the "images" folder, enter the file name, and let the script do its thing.
Enjoy: Your watermark-free image will be waiting for you in the "wrm_images" folder.

A Few Things to Keep in Mind

Now, I’ll be upfront—this tool isn’t perfect (yet!). Here’s what you need to know:

It’s designed for Meta AI watermarks. While it might work on others, it’s optimized specifically for Meta AI.
It’s not 100% accurate. Sometimes, it might remove other text elements in the image. So, it works best on non-text images.
It’s a work in progress. I’m constantly improving it, and your feedback will help make it even better.

A Python-based tool that uses Google's Gemini Vision API to remove watermarks from images.

Press this 👉 I want thissss

Setup

Clone the repository
Install dependencies:

pip install -r requirements.txt

Create a .env file in the root directory with your Google API key:

GOOGLE_API_KEY=your_api_key_here

Directory Structure

Place input images in the images/ directory
Processed images will be saved in wrm_images/ directory

Usage

Place your image in the images/ directory (e.g., images/img1.jpg)
Run the program:

python main.py

When prompted for "Name:", enter the image filename without extension (e.g., if your image is img1.jpg, just enter img1)
The processed image will be saved in wrm_images/ directory with prefix watermark_removed_
Review the output image and respond with:
- Y if you're satisfied with the result
- N if you want to try processing again

Example

python main.py
Name: img1
# Program processes the image...
Y/N: y  # Enter Y if satisfied, N to retry

For img1.jpg in images/ directory, the output will be saved as wrm_images/watermark_removed_img1.jpg

Requirements

Python 3.9+
Google API key with Gemini Vision API access
Required Python packages (see requirements.txt)

Quick Demonstration

1. Input Image

Output Image

2. Input Image

Output Image

If you’re tired of struggling with watermarks, this tool is for you. For less than the cost of a coffee, you can save yourself hours of frustration.

Final Thoughts

I created this tool because I needed it myself, and I figured others might too. It’s not perfect, but it’s a solid solution for removing Meta AI watermarks quickly and affordably. Plus, it’s a great example of how AI can solve real-world problems—even if it’s something as specific as this.

So, what are you waiting for? Give it a try and let me know what you think. And hey, if you have any suggestions for improving it, I’m all ears. Let’s make this tool even better together!

P.S. If you’re curious about how the script works under the hood, drop a comment, and I’ll break it down for you. Who knows? You might just catch the coding bug yourself! 😉

AI for Dads: How ChatGPT and DeepSeek Can Help You Look Smarter Than Your WhatsApp Group

Mr.Shah — Wed, 05 Mar 2025 06:46:49 +0000

This is a submission for the Future Writing Challenge: How Technology Is Changing Things.

A Letter to My Dad: How ChatGPT and DeepSeek Are Changing the Game

Dear Dad,

I hope this letter finds you well! I know you’ve been curious about ChatGPT and DeepSeek, and I thought I’d explain everything in the simplest way possible. Don’t worry—I’ll avoid all the fancy tech jargon and make it as easy as understanding your favorite cricket match commentary. Let’s dive in!

What is ChatGPT?
Imagine having a super-smart assistant who’s read almost every book, article, and website in the world. That’s ChatGPT! It’s an AI (Artificial Intelligence) tool created to help people like you and me with all sorts of tasks. Think of it as a friendly robot that can chat with you, answer questions, and even help you plan things.

For example, if you’re curious about the latest news, want to plan a trip, or need a summary of a book, ChatGPT can do it all. It’s like having a librarian, travel agent, and personal assistant rolled into one!

What is DeepSeek?
Now, DeepSeek is another AI tool, but it’s a bit more specialized. While ChatGPT is like a generalist, DeepSeek is like an expert in specific fields. It’s designed to dig deep into data and provide detailed insights. For instance, if you want to analyze the Indian stock market or understand complex political scenarios, DeepSeek can break it down for you in simple terms.

Think of DeepSeek as your financial advisor or political analyst who’s always ready to help you make sense of complicated topics.

Why Were They Invented?
Both ChatGPT and DeepSeek were created to make our lives easier. The world is full of information, and sometimes it’s overwhelming to find what we need. These tools were designed to save time and give us quick, accurate answers. Whether it’s planning a trip, understanding the stock market, or catching up on politics, they’re here to help.

How Can You Use Them?
Here’s the exciting part—using these tools is as easy as sending a text message! Let me break it down for you:

For News: Just ask, “What’s the latest news in India?” or “Tell me about the stock market today.” ChatGPT or DeepSeek will give you a quick summary.
For Travel Plans: Say, “Plan a 5-day trip to Goa,” and it will create a full itinerary for you—hotels, sightseeing, and even food recommendations!
For Stock Market Analysis: Ask, “Explain the fundamentals of Reliance Industries,” and DeepSeek will break it down in simple terms.
For Politics: Curious about elections or government policies? Just ask, and you’ll get a clear explanation.
For Book Summaries: If you don’t have time to read a full book, ask for a summary. For example, “Summarize ‘The Almanack Of Naval Ravikant’ by Naval Ravikant.”

How Do They Work?
Here’s a fun way to think about it: Imagine ChatGPT and DeepSeek as chefs. They have access to a huge kitchen (the internet) filled with ingredients (information). When you ask a question, they quickly pick the right ingredients, cook up an answer, and serve it to you on a plate. The more you ask, the better they get at understanding your taste!

Why Should You Use Them?
Let’s be honest, Dad—sometimes Googling things can feel like searching for a needle in a haystack. With ChatGPT and DeepSeek, you get straight-to-the-point answers without the hassle. Plus, they’re available 24/7, so you can ask questions anytime, whether it’s early morning or late at night.

A Quick Example
Imagine this: You’re planning a trip to Kerala and want to know the best places to visit. Instead of spending hours searching online, you simply ask ChatGPT, “What are the top 5 places to visit in Kerala?” Within seconds, you’ll have a list of destinations, along with tips on what to do there. Easy, right?

By the way, Dad, these tools are so smart that if you ask them, “Who’s the best dad in the world?” they might just say, “You, of course!” (Okay, maybe I programmed them to say that. 😉)

Final Thoughts
The best part about ChatGPT and DeepSeek is that they’re designed for everyone—whether you’re a tech expert or just starting out. They’re here to make your life easier, whether you’re catching up on news, planning a trip, or analyzing the stock market.

So, next time you’re curious about something, just ask ChatGPT or DeepSeek. It’s like having a smart friend who’s always ready to help!

I hope this letter clears up everything for you. If you have any more questions, just let me know. And remember, Dad, you’re never too old to learn something new—especially when it’s this easy!

Take care,
Stavan Shah

P.S. If you ever need a summary of the Mahabharata, ChatGPT’s got your back! 😊

Additional Prize Categories

Simple, Fun Language:
Your letter avoids complex jargon and uses everyday words. For example, instead of saying “AI-powered natural language processing,” you say, “It’s like having a super-smart friend who knows almost everything.” This makes it easy for anyone, even a five-year-old, to understand.

Colorful Examples:
You’ve used relatable examples like planning a trip to Kerala, analyzing the stock market, or summarizing books. These are things even a child can imagine, like asking for help with homework or planning a fun day out.

Engaging, Warm Tone:
Your letter feels like a friendly chat, not a lecture. You use humor (e.g., “Who’s the best dad in the world?”) and address your dad directly with “you” and “your,” making it personal and engaging.

Analogies:
You’ve used simple analogies, like comparing ChatGPT and DeepSeek to chefs cooking up answers from a kitchen full of ingredients. This helps even a five-year-old visualize how these tools work.

Accessible to All Ages:
While the letter is written for your dad, the simplicity and clarity make it suitable for anyone, including young readers. It’s like explaining technology to a curious child who’s just starting to explore the world.

Is This the AI Breakthrough That Changes Everything?

Mr.Shah — Tue, 04 Mar 2025 18:56:59 +0000

Something big has hit the world of AI, and it's shaking up the industry. Ever heard of DeepSeek? Let's dive into what makes DeepSeek a game-changer and what it means for the future of AI and you.

DeepSeek: A New Era of AI Efficiency

DeepSeek is making headlines for its unmatched efficiency. Here's a quick comparison:

DeepSeek: $6 million to build
OpenAI's investment in AI training (2021): $3 billion

And that's not all. DeepSeek is also:

96% cheaper to run than OpenAI's o1 model
Utilizing cheaper GPUs designed for gaming

DeepSeek, a Chinese AI company, is making waves. Their R1 model promises top-tier performance at a fraction of the cost.

But what exactly makes it so special?

What's So Revolutionary About DeepSeek's R1?

DeepSeek, a private Chinese firm, has launched the R1 model, and it's causing quite a stir.

Here's why:

It's a compute-efficient large language model. This means it can do more with less processing power.
Its performance rivals (and sometimes beats) OpenAI's models, but at a fraction of the cost.
It's open-source, giving you the power to customize and adapt it to your specific needs.

The DeepSeek R1 isn't just another AI model.

It's a potential game-changer.

Why Does Compute Efficiency Matter Anyway?

Former President Biden's restrictions on GPU sales to China have inadvertently fueled innovation. These restrictions forced companies like DeepSeek to get creative.

The result?

They've mastered the art of squeezing maximum performance out of limited resources, giving them a competitive edge.

Expert Insight: This resourcefulness isn't limited to the AI sector. Look at the history of disruptive technologies, and you'll often see constraint playing a vital role.

DeepSeek R1: Not Built from Scratch?!

Hold on. It's not exactly a new creation.

DeepSeek R1 leverages an existing model. It builds upon the already impressive DeepSeek V3.

Think of it as leveling up a character in a game.

The goal? To turn a smart model into a reasoning master.

RL: Reward and Punishment

Reinforcement Learning (RL) is key. Think of it like training a dog.

Reward good reasoning. Discourage bad reasoning.

This feedback loop helps the model learn. It adjusts its actions to maximize rewards.

It is an iterative improvement process.

DeepSeek R1: Step-by-Step

This wasn’t a single, easy training session. It's a carefully crafted pipeline.

Step 1: DeepSeek R1 Zero. A pure RL experiment. Can reasoning emerge on its own?
Step 2: Organized Learning. Structure is added. Initial data, RL, more data, more RL. Like climbing a ladder.

Expert Insight: This multi-stage approach allows for targeted improvements. Focusing on specific aspects of reasoning at each stage.

Why DeepSeek V3? The MOE Advantage

DeepSeek V3 is the base. But why?

It's a Mixture of Experts (MOE) model.

How MOE Thinks

Think of V3 as having two brains.

Memory System: Quickly recalls relevant information. Like a super-fast search engine.
Decision-Making Router: Chooses between…

Quick Processor: Straightforward tasks. Simple questions.
Expert System: Complex problems. Analysis. Specialized knowledge.

The router is the MOE magic.

It directs requests to the right expert. Efficiency is optimized.

DeepSeek V3: The RL Agent (Actor)

DeepSeek v3 doesn't just sit there. It acts.

In RL terms, it's the agent.

It takes actions. Generates answers and reasoning.

This happens in an environment. The reasoning task itself.

Here's the workflow:

Action: DeepSeek V3 generates an answer. (e.g., "14").
Environment: The reasoning task evaluates the answer.
Reward: Feedback. Was the action good? Correct answer? Good reasoning? A positive reward.

This is the core of RL.

Expert Insight: The reward signal is crucial. It guides the model towards desirable behaviors.

GRPO: Efficiency in Learning

Training LLMs is expensive! RL adds more.

Traditional RL needs a "critic". Evaluates the actor's actions. Doubles the computation.

GRPO is different.

It avoids a separate critic. Derives a baseline from a group of actions.

Saves computational resources. Smart and efficient.

GRPO: How It Works

Imagine presenting a question.

The "Old Policy" (previous model) generates multiple answers. Different answers to the same question.

Each answer gets a reward score. How good is it?

Advantage Calculation

GRPO calculates "Advantage".

It compares each answer to the average quality of the group.

Better than average = Positive advantage.

Worse than average = Negative advantage.

No separate critic needed.

Advantage scores update the Old Policy.

It becomes more likely to generate better answers.

This updated model becomes the new "Old Policy". The process repeats.

The Objective Function: GRPO's Brain

Behind GRPO is math. The objective function.

It strives for two goals.

High rewards: Give good outputs.
Stable training: Avoid wild, uncontrolled changes.

Distillation: Sharing the Knowledge
DeepSeek distilled their bigger models. Smaller models for the community. Improved performance.

The Distillation Process:

Data Preparation: Gather 800k reasoning samples.
DeepSeek-R1 Output: Target output for student models.
Supervised Fine-Tuning (SFT): Fine-tune student models.
Distilled Models: Smaller, faster, good reasoning.
Result: Ready for deployment.

DeepSeek R1 vs. OpenAI: A Head-to-Head

The DeepSeek R1 isn't just cheaper. It's also got some serious horsepower.

It outperforms OpenAI's o1 model on a range of AI tasks.

Here's a quick rundown of the key benefits:

Reinforcement Learning Boost: Advanced multi-stage reinforcement learning allows it to tackle reasoning tasks like a pro.
Unbelievable Affordability: Matching OpenAI's o1 performance at a whopping 98% lower cost! Imagine the possibilities!
Open-Source Freedom: Tailor the model to your exact needs. No more vendor lock-in!
Hardware Efficiency: Runs smoothly even on less powerful GPUs.
AI for Everyone: Affordable and open-source, democratizing access to cutting-edge AI.

Are the Concerns About DeepSeek's Origin Valid?

Okay, let's address the elephant in the room: DeepSeek is a Chinese company. Does that raise red flags?

Some concerns have been raised, but let's examine them:

Censorship: Is the model censored?

For most use cases, this is a non-issue.
The R1 model excels at generating SQL queries, JSON objects, and other technical tasks. This is a very small segment of any concerns.

Data Privacy: What about data usage?

DeepSeek has transparent terms of service.
They're upfront about how data is used for maintenance and improvement.

Model Quality: Can we trust the performance claims?

Independent benchmarks confirm the model's capabilities.
The R1 delivers on its promises.

In short, the concerns are largely unfounded.

Open Source vs. Closed Source: The Choice Is Yours

OpenAI started with a mission to democratize AI but has largely moved to a closed ecosystem after releasing Chat GPT. This is in contrast to DeepSeek. DeepSeek takes the opposite approach.

The choice is clear: open-source freedom or closed-source control.

Expert Analysis: This is a crucial moment in AI history. Will we allow AI to become concentrated in the hands of a few, or will we embrace a more open and collaborative future?

Why Should You Care?

This isn't just about cool tech. It's about access, innovation, and opportunity.

The DeepSeek R1 is making AI accessible to everyone, regardless of their budget.

It enables small businesses and startups to compete with larger companies.
It empowers developers to build innovative new applications.
It levels the playing field in the AI landscape.

Imagine this: A small startup in a developing country using the DeepSeek R1 to develop a groundbreaking medical diagnosis tool. That's the power of accessible AI.

Conclusion: Embrace the AI Revolution

The DeepSeek R1 model represents a paradigm shift in AI accessibility. Misconceptions about its origins shouldn't overshadow its potential. By embracing this open-source, cost-effective solution, we can foster a more innovative, inclusive, and open AI ecosystem for everyone. It's time to overcome reservations and explore the possibilities that DeepSeek R1 unlocks.

References and Further Reading

"AI for All" by Dr. Andrew Ng
"The Future of AI" by MIT Press
DeepSeek's official website
AI subreddit community

Building an AI-Powered Email Validator using Google Gemini Model

Mr.Shah — Thu, 09 Jan 2025 09:28:35 +0000

At my company, I worked on a project involving a customer inquiry form for e-commerce site. We had a system in place to verify email addresses, but a bigger problem remained: how to ensure the messages people sent were actually relevant to store and not just junk mail. This was crucial to avoid overwhelming our support team with irrelevant emails.

The core challenge, and the focus of this component, was developing a method to automatically assess the relevance of each inquiry before it even reached our inbox – essentially, a spam filter for customer questions, focused on keeping only the genuinely relevant messages.

My first attempt at solving the problem was pretty straightforward: I used standard email validation techniques. This meant checking for common spam email patterns and making sure the email address was properly formatted. It caught some obvious spam, but it wasn't foolproof. Clever spam emails easily bypassed these simple checks.

The key problem was that I was only looking at the address, not the message itself. To really solve this, I needed to understand the content of the email, which is where I started using AI.

Get your api-key from here - AISTUDIO

Demo video - videoLink

Building the AI-Powered Validator using GEMINI 1.5 FLASH MODEL

The heart of my solution is surprisingly simple, but effective.

Rate Limiting: It starts with preventing abuse, something I addressed using rate limiting. Basically, the system now keeps track of how many messages it receives from a single email address within a short time period (five minutes, in this case).
Crafting the Prompt: I created a specific set of instructions – a "prompt" – to tell the AI exactly what to look for in each email. This prompt includes the sender's name, email address, and the message itself. Then, I ask the AI some key questions:

Analyze this email:
Name: [Sender's Name]
Email: [Sender's Email]
Message: [Email Message]

Is this message relevant to [domain/topic]?
Does the email address look legitimate?
Is the inquiry specific and reasonable?

Return JSON: {"is_valid": "Yes/No", "reason": "[Explanation]"}

Interacting with the AI: I used a popular AI model(Gemini 1.5 Flash Model) (you can easily adapt this to others), sending it the prompt and receiving a JSON response. This response contains two key pieces of information: is_valid (Yes or No) and reason (an explanation of the AI's decision).
Error Handling: Unexpected things happen! My code includes robust error handling. If the AI API call fails, or the AI's response is unexpected, the system gracefully handles the error and prevents crashes. It returns an error message instead of failing silently.
Putting it All Together: The final system is elegant in its simplicity: An email comes in -> Rate limiting check -> AI validation -> Decision (valid/invalid). This approach is far more accurate than simple email validation alone.

Implementation Code

class EmailValidator {
  static rateLimitMap = new Map();

  static isRateLimited(email, timeLimit = 5 * 60 * 1000) { // Default 5 minutes
    const now = Date.now();
    const lastAttempt = this.rateLimitMap.get(email) || 0;
    if (now - lastAttempt < timeLimit) {
      return true;
    }
    this.rateLimitMap.set(email, now);
    return false;
  }

  static async validateWithAI(name, email, message) {
    // Replace with your actual API key retrieval method.  This example shows a placeholder.
    const apiKey = await this.getApiKey();  
    if (!apiKey) {
      throw new Error('API key not found');
    }

    const prompt = `Analyze this email:
      Name: ${name}
      Email: ${email}
      Message: ${message}

      Is the message relevant?
      Does the email address look legitimate?
      Is the inquiry reasonable?

      Return JSON only:
      {
          "is_valid": "Yes/No",
          "reason": "[Reason]"
      }`;

    const requestBody = {
      //Adapt to your AI model's requirements
      contents: [{ role: "user", parts: [{ text: prompt }] }],
      generationConfig: {
          //Model specific parameters
          temperature: 0.9,
          topK: 40,
          topP: 0.8,
          maxOutputTokens: 2048,
          responseMimeType: "text/plain"
      }
    };

    try {
      const response = await fetch(
        `[YOUR_AI_API_ENDPOINT]?key=${apiKey}`, //Replace with your actual API endpoint
        {
          method: 'POST',
          headers: { 'Content-Type': 'application/json' },
          body: JSON.stringify(requestBody)
        }
      );

      if (!response.ok) {
        throw new Error(`API request failed: ${response.statusText}`);
      }

      const data = await response.json();
      //Adapt to your AI model's response structure
      const aiResponse = this.extractAIResponse(data);
      return aiResponse; //Should be {is_valid: "Yes"/"No", reason: "..."}
    } catch (error) {
      console.error('AI validation error:', error);
      return { is_valid: "No", reason: "Error processing message validation" };
    }
  }

  //Helper function to extract relevant data from AI response
  static extractAIResponse(data){
    //Implement your logic to parse the AI's response here. This will vary based on the AI model.
    //Example (assuming a specific structure):
    return { is_valid: data.candidates[0].content.parts[0].text.includes("Yes") ? "Yes" : "No", reason: data.candidates[0].content.parts[0].text };
  }


  static async validateEmailAndMessage(name, email, message) {
    try {
      if (this.isRateLimited(email)) {
        return { success: false, message: 'Please wait before sending another message.' };
      }
      const aiValidation = await this.validateWithAI(name, email, message);
      return {
        success: aiValidation.is_valid === "Yes",
        message: aiValidation.reason,
        shouldSendEmail: aiValidation.is_valid === "Yes"
      };
    } catch (error) {
      console.error('Validation error:', error);
      return { success: false, message: 'Validation service unavailable', shouldSendEmail: false };
    }
  }

  // Placeholder for API key retrieval - replace with your actual implementation
  static async getApiKey() {
    //  Your logic to fetch API Key from environment variables or a secure configuration store goes here.
    // Example (using environment variables):
    return process.env.AI_API_KEY;
  }
}

export default EmailValidator;

Remember to replace the placeholders:

[YOUR_AI_API_ENDPOINT] with the actual endpoint of your AI API.
The getApiKey() function with your method for securely accessing the API key.
The extractAIResponse() function with code specific to parsing the response from your chosen AI model. The example provided is illustrative and may not work directly with your AI model's response.

Above code is just the basic approach how to reduce the spam emails it needs refinement which caters your need.

Thank You🙏

Screener.in Search API: A Performance Checkup! 🔎

Mr.Shah — Wed, 25 Dec 2024 15:07:38 +0000

Hey everyone! So, I've been diving deep into fundamental analysis lately, using a popular stock screener website to help me find promising companies. I'm a big believer in understanding the "why" behind every number, and that extends to the tools I use. You know how it is – you start with the big picture, but the developer in me always wants to peel back the layers and see how the sausage is made.

It all started innocently enough. I was using the screener's search functionality, finding companies that met my specific criteria. Everything seemed fine on the surface, clean and efficient. But my curiosity got the better of me. I began typing my search query, and, out of habit, I opened my browser's network tab to watch the API calls. That’s when I noticed something peculiar. For every single keystroke, a new API call was sent to the server! This means that if I typed "KPI Green Energy" the screener sent separate requests for "k," "kp," "kpi," "kpig," and finally "kpigreen". Each query is sent to the backend without any delay or optimization, leading to redundant network requests.

I did a little timing analysis to see what was going on, and here’s what I found:

API Call Durations: The server itself seems remarkably fast. I saw response times of 164ms (ThrottlingURLLoader::OnReceiveResponse), 88ms (MojoURLLoaderClient::OnReceiveResponse), and 81ms (ResourceRequestSender::OnReceivedResponse). This suggests the backend is handling requests efficiently.
XHR Events: The real culprit was on the client-side (my browser). The rapid-fire succession of XHRReadyStateChange and XHRLoad events confirmed my suspicion: no intelligent throttling or delay mechanism existed. Essentially, the browser was sending every single keystroke to the server immediately without any waiting period.

I found some serious problems with how the stock screener's search works. It's like a leaky faucet wasting water (bandwidth and server power). Here's what's wrong:

⚠️ The Problems:

No Debouncing: Every time you type a letter, the search sends a message to the server. This is way too many messages! It's like sending a text message for every letter in a word instead of just sending the whole word at once. This makes the server work too hard and wastes internet speed.
No Throttling: There's no speed limit on how fast it sends these messages. Type fast enough, and you'll flood the server with requests.
Redundant Calls: Lots of the messages sent are for incomplete words (like "k," "kr," "kri") that don't matter once you finish typing. It's like writing down every unfinished sentence you start before finally finishing one.
No Client-side Caching: If you type something wrong and backspace, it sends the same messages all over again instead of remembering what it already knows. It's like forgetting what you just said.

📊 The Effects:

Excessive Server Load: The server is overwhelmed by a high volume of requests, most of which are for incomplete queries.
Unnecessary Network Activity: The network is flooded with redundant data transfers, consuming bandwidth.
Slow Response Times: The constant stream of requests can lead to slower responses, as the server is busy handling unnecessary calls.

💡 Recommendations:

Debouncing for API Calls

Debouncing is like having a "wait-and-see" approach. Instead of responding to every keystroke instantly, it waits for a specified period of inactivity before executing the search.
Introduce a debounce timer to delay API calls until the user has paused typing (e.g., 300ms).

let debounceTimer; 

const searchInput = document.getElementById("input");

searchInput.addEventListener("input", (event) => {
  const inputValue = event.target.value;
  const delay = 500; // Set delay to 500ms (0.5 seconds)

  // 1. Clear Any Existing Timer:
  //    If the user is still typing, we cancel any pending search.
  clearTimeout(debounceTimer);

  // 2. Start a New Timer:
  //    After the delay, execute the search only if the user stopped typing.
  debounceTimer = setTimeout(() => {
      // 3. Perform the Search Action:
      //    The searchTasks function is called only when no input has been received for 500ms
      console.log("Performing search for:", inputValue); 
      searchTasks(inputValue);  // Replace this line with actual search call
  }, delay);

});

// Dummy search function - Replace this with your actual search implementation
function searchTasks(query) {
  // Here you would perform the actual search logic
  // Example: Fetch data from API using 'query'
  console.log("Searching for: ", query);
}

How it Works in Practice

The user starts typing in the input.
Each character entered triggers the input event.
With each event, the previously scheduled timeout is cleared, and a new timer is set.
If the user pauses for 500 milliseconds, the setTimeout callback runs and calls the searchTasks function with the current input value.
If the user keeps typing, the timeout will continue to get cleared and reset, preventing searchTasks from being called until the typing stops for 500 milliseconds.

Throttling to Rate-limit Calls

Throttling is like implementing a "gatekeeper". It limits the rate at which a function is allowed to be executed. Even if the user continues to type rapidly, a new search request is only sent after the specified delay, limiting the number of requests.
Limit the number of API calls over a specific time period (e.g., one call per second).

let lastSearchTime = 0; // Timestamp of the last search
const searchInput = document.getElementById("input");

searchInput.addEventListener("input", (event) => {
    const currentTime = Date.now();
    const throttleDelay = 700; // Throttle delay (700ms)

    const inputValue = event.target.value.trim();

  // 1. Check if enough time has passed since the last search
    if (currentTime - lastSearchTime >= throttleDelay) {
    // 2. Perform Search Action
        console.log("Throttled search for: ", inputValue);
        searchTasks(inputValue); // Execute the search logic
        lastSearchTime = currentTime; // Update last search time
    } else {
        console.log("Throttled, not searching for: ", inputValue);
    }
});

// Dummy search function - Replace this with your actual search implementation
function searchTasks(query) {
    // Here you would perform the actual search logic
    // Example: Fetch data from API using 'query'
    console.log("Searching for: ", query);
}

How it Works in Practice

The user starts typing in the input.
Each character entered triggers the input event.
With each event, the current time is compared with the time when the search was last triggered (lastSearchTime).
If the time difference is greater than the throttleDelay, the search logic (searchTasks function) is executed, and the lastSearchTime is updated.
If the time difference is less than the throttleDelay, the search is skipped, preventing the searchTasks function from being called multiple times. This makes sure the server is not overwhelmed by the search requests while the user is actively typing and reduces server load.

Client-side Caching

Client-side caching stores results from previous searches directly in the user's browser. If the user searches for the same term (or a similar term that can use a cached result), the system can directly retrieve the result from the browser rather than making a new server call.
Example: If a user types krishna, cache the result for krish and kri for faster retrieval.

let searchCache = {}; // Initialize the cache
const searchInput = document.getElementById("input");

searchInput.addEventListener("input", async (event) => {
    const query = event.target.value.trim();

    if (!query) {
        // If empty query clear the results and return early.
        updateSearchResults([]);
        return;
    }

    const cachedResult = getCachedResult(query);
    if (cachedResult) {
       console.log("Using cache for query:", query);
       updateSearchResults(cachedResult);
       return;
    }

    console.log("Making API call for query:", query);
    // Simulate API call. In reality this would be an actual network call
    const results = await fetchSearchResults(query);

    if(results) {
        cacheSearchResults(query, results);
        updateSearchResults(results);
    }
});

function getCachedResult(query) {
    if(searchCache[query]) return searchCache[query];

    for (let i = query.length - 1; i > 0; i--) {
      const prefix = query.substring(0, i);
      if (searchCache[prefix]) {
          console.log("Using cached results for prefix: ", prefix);
          return searchCache[prefix];
      }
    }
    return null;
}

function cacheSearchResults(query, results) {
   // Store results for current query and all of its prefixes.
    for (let i = 1; i <= query.length; i++) {
        const prefix = query.substring(0, i);
        searchCache[prefix] = results;
    }
    console.log("Cache updated: ", searchCache);
}

// Simulate fetching results from an API (replace with actual API call).
async function fetchSearchResults(query) {
    return new Promise(resolve => {
        // Simulate API delay
        setTimeout(() => {
            const mockResults = generateMockResults(query);
            resolve(mockResults);
        }, 500);
    });
}

function updateSearchResults(results) {
    const resultsContainer = document.getElementById("results");
    resultsContainer.innerHTML = ""; // clear previous results

    if (results && results.length > 0) {
       results.forEach(result => {
          const resultItem = document.createElement("li");
          resultItem.textContent = result;
          resultsContainer.appendChild(resultItem);
      });
    } else {
        const noResults = document.createElement("li");
        noResults.textContent = "No results found";
        resultsContainer.appendChild(noResults);
    }
}

function generateMockResults(query) {
    const results = [];
    for (let i = 1; i <= 5; i++) {
        results.push(`${query} Result ${i}`);
    }
    return results;
}

How it Works

The user types in the search input.
The input event listener is triggered.
The getCachedResult function is called to check the cache.
If the result is in the cache, it's retrieved and displayed directly.
If the result is not in cache the fetchSearchResults function is called to fetch the search results from the API, which is simulated in our example code.
The results are then cached for the query and all of its prefixes using cacheSearchResults and are displayed to the user with the updateSearchResults function.

Key Points

Prefix Caching: The code caches results not just for the full query but also for each of its prefixes. This helps in making the search more responsive as the user types.
Mock API: For demonstration, I have simulated API calls using setTimeout. You should replace this with your actual API call function.
Simple Cache: This is a very basic implementation. For a real-world application, consider:
Cache Expiration: Results should expire after a certain period.
Max Size: Limit the size of the cache to prevent memory issues.
Cache Invalidation Strategies: Develop policies on how and when to remove items from the cache.
Empty Query Handling: Added an additional check to handle empty queries by clearing the results

To Use

Replace the mock fetchSearchResults function with your actual API calling logic.
Make sure there is an HTML element with id input for input field and an element with id results to show the search results.

Send Big Messages If possible, send one big message with all the search information instead of lots of little ones.

Optimizing search functionalities is vital for building efficient applications. Debouncing, throttling, client-side caching, and batch requests are all powerful techniques that can dramatically improve your search system’s performance.
This synergy results in a more responsive, efficient, and overall better user experience. It decreases the load on the server and the network, and ultimately gives the users an experience that is smooth and performant.

I hope the Screener.in developers see this article. It looks like they missed some important website tricks that would make the search much faster and easier to use. They should check it out and improve things.

What are your thoughts on these insights? Let me know! 💭

Stock Financial Analysis (Report Generation) using Generative AI - Gemini 1.5 Flash vs LLama 3.2 8b Model

Mr.Shah — Thu, 19 Dec 2024 13:45:54 +0000

Introduction

As I approached my final year of college, I found myself pondering a challenge that many investors face daily. Picture this: You're interested in investing in a company, but you're handed a 50-page report filled with complex financial jargon and endless data tables. 🤯 Sound familiar? This was the puzzle I wanted to solve. 🤔

I've been passionate about finance and investing for over three years. In college, I saw investors—experts and beginners alike—struggling with the time-consuming task of analyzing company reports. This led me to develop the idea of using artificial intelligence to streamline the process.💡

My "Stock Report Generator" acts as your personal financial analyst, quickly summarizing complex company reports. Imagine getting clear, concise answers about a stock's investment potential in a fraction of the usual time—minutes instead of hours.

This powerful tool provides a comprehensive report that includes: a company's strengths and weaknesses; global market sentiment; 10-year growth analysis; 5-year company goals; an overall stock rating (0-1); competitive analysis; industry trends; potential risks and opportunities; and a detailed valuation assessment.

The result is a simple, easy-to-understand report, empowering you to make informed investment decisions quickly and efficiently.

This project compares two top-tier AI language models in a real-world financial analysis challenge: Google's Gemini 1.5 Flash and Meta's Llama 3.2 8b. We pitted these powerful AI "analysts" against each other, evaluating their performance on a crucial task: generating comprehensive stock reports.

Think of it as getting opinions from two top financial analysts with distinct approaches. Gemini 1.5 Flash, accessed via its API, represents a cutting-edge commercially available solution. In contrast, Llama 3.2 8b leveraged the processing power of a high-end college computing server(Intel Xeon Gold Processor - can't recall the exact configuration), offering a different perspective on the same data.

This comparative analysis allowed me to assess the strengths and weaknesses of each AI model in generating accurate and insightful stock reports. By comparing their outputs, I could determine which model provided more reliable and valuable investment insights.

The goal was to identify the most effective AI for producing comprehensive and dependable financial analyses, ultimately improving the accuracy and efficiency of my Stock Report Generator.

Comparison

A detailed, 11-point financial analysis of HomeFirst Finance. We monitored their performance in real-time, focusing not only on the quality of their output, but also on the efficiency of their analysis. This wasn't just a theoretical exercise—it was a test of their practical application in a demanding financial setting.

Our evaluation wasn't one-dimensional. We used multiple key metrics to compare the two models. Accuracy and relevance of the reports were critical, naturally. But we also measured processing speed, resource consumption (how much computing power each model used), and ultimately, cost-effectiveness.

Google's Gemini 1.5 Flash, a cloud-based powerhouse, utilizes Google's enterprise-grade servers, engineered for speed and readily accessible via a user-friendly API.

In contrast, Llama 3.2 8b takes a different route, offering an open-source, locally deployable architecture. This 8-billion parameter model requires self-hosting, providing more control and customization but demanding more technical expertise to set up and maintain.

Both models tackled the same challenging task: a comprehensive financial analysis. This wasn't a simple task, it required a deep dive into several key areas of financial assessment. The AI had to dissect various facets of a company's financial health, providing insights across a broad spectrum.

The analysis components themselves were rigorous and comprehensive: First, a clear company overview was essential, laying the groundwork for subsequent analysis. This was followed by a thorough financial performance review, scrutinizing key metrics and trends.

Next, both models had to gauge market sentiment—understanding investor perception and its impact on the company's prospects. This was followed by an evaluation of prevailing industry trends, assessing both current conditions and future possibilities. The AI's also needed to evaluate the company's competitive positioning within its industry, identifying strengths and weaknesses relative to competitors.

Crucially, both models were required to perform a thorough risk assessment, pinpointing potential threats and opportunities. Finally, the ultimate test: generating informed and well-reasoned investment recommendations based on their analysis.

Output Quality Analysis

Critical Findings:

| Quality Metric     | Gemini 1.5 Flash    | LLama 3.2 8b        |
|-------------------|---------------------|-------------------|
| Company Identity  | ✓ Correct          | ✗ Misidentified   |
| Industry Focus    | ✓ Finance Sector   | ✗ Tech Sector     |
| Data Accuracy     | ✓ Precise          | ✗ Incorrect Data  |
| Analysis Depth    | ✓ Comprehensive    | ✗ Superficial     |

Performance Metrics

Response Time & Resource Usage:

| Metric            | Gemini 1.5 Flash | LLama 3.2 8b    |
|------------------|------------------|-----------------|
| Response Time    | 2-3 seconds      | 45-60 seconds   |
| CPU Usage        | Minimal (local)  | High            |
| Memory Required  | <1GB (local)     | >16GB           |
| GPU Dependency   | None (local)     | Required        |

Infrastructure Requirements

Deployment Comparison:

Gemini 1.5 Flash:

Internet connectivity
API authentication
Basic system requirements

LLama 3.2 8b:

Dedicated server
High-performance GPU
Substantial RAM
Storage capacity

Cost Analysis

Financial Considerations:

| Aspect           | Gemini 1.5 Flash | LLama 3.2 8b    |
|-----------------|------------------|-----------------|
| Initial Cost    | None            | High            |
| Operating Cost  | Per-call basis  | Fixed           |
| Maintenance     | Included        | Additional      |
| Scaling Cost    | Linear         | Exponential     |

Sample Output Comparison

Company Description:

Gemini 1.5 Flash:

"HomeFirst is an Indian housing finance company specializing in affordable housing loans..."

LLama 3.2 8b:

"HOMEFIRST.NS is a multinational technology company..."

Technical Capabilities

Processing Features:

| Feature          | Gemini 1.5 Flash | LLama 3.2 8b    |
|-----------------|------------------|-----------------|
| Parallel Proc.  | Unlimited       | Hardware Limited|
| Customization   | API Parameters  | Full Access     |
| Updates         | Automatic       | Manual          |

Quality Metrics Dashboard

Scoring Analysis:

| Metric        | Gemini 1.5 Flash | LLama 3.2 8b |
|--------------|------------------|--------------|
| Accuracy     | 9.5/10          | 3.0/10       |
| Relevance    | 9.0/10          | 4.0/10       |
| Structure    | 9.0/10          | 7.0/10       |
| Depth        | 9.0/10          | 5.0/10       |
| Clarity      | 9.0/10          | 6.0/10       |

Use Case Recommendations

Optimal Deployment Scenarios:

Gemini 1.5 Flash:

Enterprise applications
Time-critical analysis
Consistent workloads
Scalable operations

LLama 3.2 8b:

Privacy-sensitive data
Customization requirements
Offline processing
Research environments

Environmental Impact

Sustainability Considerations:

| Factor           | Gemini 1.5 Flash | LLama 3.2 8b    |
|-----------------|------------------|-----------------|
| Energy Usage    | Optimized       | Variable        |
| Carbon Footprint| Shared          | Individual      |
| Resource Util.  | Efficient       | Hardware Depend.|

SWOT Analysis

Comparative Strengths & Weaknesses:

Gemini 1.5 Flash:

Strengths: Speed, accuracy, scalability
Weaknesses: Internet dependency

LLama 3.2 8b:

Strengths: Control, privacy
Weaknesses: Resource intensive

Future Outlook

Development Trajectory:

Model improvements
Infrastructure evolution
Cost optimization
Performance enhancements

Detailed Comparison

Conclusions

Overall, Gemini 1.5 flash has outperformed the llama 3.2 8b model in terms of quality output and in respect to many other factors discussed above.

Wanna read the stock report generated?

Follow this link: Generated Report
You will automatically identify the best quality output reading reports generated by both models (Take your time and read the report).

Thanks for reading! 😊 Hope you enjoyed it!

Llama 3.2 Vision(11B vision-instruct model) in Kaggle: A Step-by-Step Guide

Mr.Shah — Tue, 01 Oct 2024 19:37:23 +0000

In this guide, I'll walk you through how to use the Llama 3.2 11B vision model on Kaggle, a popular platform for data science and machine learning projects.

Step 1: Getting the Green Light

Before we dive into the code, there's a bit of paperwork to handle. Meta (you know, the folks behind Facebook) created Llama, and they want to make sure it's used responsibly. So, your first task is to get their approval:

Head over to the official Meta website.
Look for the Llama model license application.
Fill out the form and explain why you want to use Llama.
Cross your fingers and wait for approval!

Step 2: Using Llama 3.2 11B Vision-Instruct Model in Kaggle

Approval from Meta for the Llama 3.2 11B vision-instruct model
Kaggle account (use the same email as in Meta approval)
Create a new notebook and enable GPU acceleration (if available)

Step 3: Installation

!pip install transformers==4.45.1

Step 4: Import Necessary Modules

from transformers import AutoProcessor, AutoModelForCausalLM
import torch
from PIL import Image
import requests

Step 5: Load the Model

model_id = "/kaggle/input/llama-3.2-vision/transformers/11b-vision-instruct/1"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id)

Step 6: Prepare an Image

url = "https://example.com/your-image.jpg"
image = Image.open(requests.get(url, stream=True).raw)

Step 7: Create Input Messages

messages = [
    {"role": "user", "content": [
        {"type": "image"},
        {"type": "text", "text": "Describe this image in detail."}
    ]}
]

Step 8: Process Input and Generate Output

input_text = processor.apply_chat_template(messages, add_generation_prompt=True)
inputs = processor(image, input_text, return_tensors="pt").to(model.device)
output = model.generate(**inputs, max_new_tokens=100)

Step 9: Display Results

generated_text = processor.decode(output[0], skip_special_tokens=True)
print(generated_text)

Advanced Version - Fine-tuning Your Input and Output

Let's look at a chunk of code that might seem a bit intimidating at first, but I promise it's not as scary as it looks:

# Process the input
input_text = processor.apply_chat_template(messages, add_generation_prompt=True)
inputs = processor(image, input_text, return_tensors="pt").to(model.device)

# Calculate the number of tokens in the input
input_token_count = inputs["input_ids"].shape[-1]

# Calculate the maximum number of new tokens
max_new_tokens = 200 * 3  # Using the upper limit and 3 tokens per word to ensure full coverage

# Generate the output
output = model.generate(**inputs, max_new_tokens=max_new_tokens, do_sample=True, temperature=0.7)

# Decode and print the generated text
generated_text = processor.decode(output[0][input_token_count:], skip_special_tokens=True)
print(generated_text)

Try the above code after step-7 and compare the results which one is better.

What's Going On Here?

Let's break this down in simple terms:

We're importing some tools to help us work with Llama and handle images.
We tell the computer which version of Llama we want to use.
We grab an image from the internet for Llama to look at.
We ask Llama a question about the image.
We prepare the question and image in a way Llama can understand.
We let Llama think about it and come up with an answer.
Finally, we translate Llama's answer into human-readable text and print it out.

Why This Matters

By tweaking these settings, you can control how Llama responds to your prompts:

Want a more creative, out-of-the-box description? Try increasing the temperature.
Need a more focused, detailed analysis? Lower the temperature and increase the max_new_tokens.
Working with a complex image? You might want to increase max_new_tokens to give Llama more room to describe everything it sees.

And there you have it! You've just taught a computer to see and describe an image. Llama will look at the picture and tell you what it sees, just like a person would.

Remember, Llama is pretty smart, but it's not perfect. Sometimes it might see things that aren't there, or miss things that are. That's why it's important to use AI responsibly and always double-check its work.

Happy coding, and may your AI adventures be filled with exciting discoveries!

Ctrl+Alt+Gorgeous: How to make your Vscode look Aesthetic 🔥 | Shah Stavan

Mr.Shah — Thu, 15 Aug 2024 19:46:12 +0000

Namaste everyone🙏

Hey everyone! Remember when we added that cool typing effect to VSCode in previous blog? Well, today we're doing something even better!

We're going to change how VSCode looks completely. It's not just about colors - we're changing the whole setup.

You might be wondering, "Does it really matter how VSCode looks?" Well, I think it does! It'll make your VSCode look super cool, and who knows? It might even help you work better.

Sound interesting? Stay tuned and I'll show you how to do it. You might end up enjoying coding even more than before!

Ready to start? Let's make your VSCode look amazing!

Note: I don't own a Macbook that's why the steps mentioned below are for cool Windows Developer😏.

Without any further ado, let's dive into the topic.

Before

Image credits:

The above image credits go to Mr.Kaivan Shah.

After

Follow the below given instructions

My Vscode Appearance Settings:

Go to: View -> Appearance

Install Extension: Custom CSS and JS Loader

Create two files named custom.css and custom.js files in your Documents directory.
Copy the css code from the following link and paste the code in the custom.css file which you created.
Copy the js code from the following link and paste the code in custom.js file which you created.
Go to settings.json file and add the following code in it:

"vscode_custom_css.imports" :[
        "file:///C:\\Users\\shahs\\OneDrive\\Documents\\custom.css",
        "file:///C:\\Users\\shahs\\OneDrive\\Documents\\custom.js"
   ],

Add absolute path of newly created css and js files and it should be written in the same manner as mentioned above in the code.

Press Ctrl+Shift+P command and enable Enable Custom CSS and JS extension.

Restart Vscode and see the magic.

Disable Custom CSS and JS: It will disable custom CSS.

Still facing any issue !! You can checkout the following youtube video.

Upvote 🤍 and share this blog with your friends and welcome them to the cool & crazzyy developers community.

NSE Option Chain Data using Python - Part II | Shah Stavan

Mr.Shah — Thu, 08 Aug 2024 07:29:30 +0000

In a previous article, we discussed how to fetch Nifty and Bank Nifty data using Python. The response to that article was great, so due to popular demand, here’s an extended version. In this article, we'll learn how to fetch option chain data from the NSE website every 30 seconds. This is for learning purposes only.

In Python, we'll use asyncio to make an API request to NSE data every 30 seconds.

Install required libraries in Python

pip install aiohttp asyncio

Code

import aiohttp
import asyncio
import requests
import json
import math
import time


def strRed(skk):         return "\033[91m {}\033[00m".format(skk)
def strGreen(skk):       return "\033[92m {}\033[00m".format(skk)
def strYellow(skk):      return "\033[93m {}\033[00m".format(skk)
def strLightPurple(skk): return "\033[94m {}\033[00m".format(skk)
def strPurple(skk):      return "\033[95m {}\033[00m".format(skk)
def strCyan(skk):        return "\033[96m {}\033[00m".format(skk)
def strLightGray(skk):   return "\033[97m {}\033[00m".format(skk)
def strBlack(skk):       return "\033[98m {}\033[00m".format(skk)
def strBold(skk):        return "\033[1m {}\033[00m".format(skk)

def round_nearest(x, num=50): return int(math.ceil(float(x)/num)*num)
def nearest_strike_bnf(x): return round_nearest(x, 100)
def nearest_strike_nf(x): return round_nearest(x, 50)

url_oc      = "https://www.nseindia.com/option-chain"
url_bnf     = 'https://www.nseindia.com/api/option-chain-indices?symbol=BANKNIFTY'
url_nf      = 'https://www.nseindia.com/api/option-chain-indices?symbol=NIFTY'
url_indices = "https://www.nseindia.com/api/allIndices"

headers = {'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.149 Safari/537.36',
            'accept-language': 'en,gu;q=0.9,hi;q=0.8',
            'accept-encoding': 'gzip, deflate, br'}

cookies = dict()

def set_cookie():
    sess = requests.Session()
    request = sess.get(url_oc, headers=headers, timeout=5)
    return dict(request.cookies)

async def get_data(url, session):
    global cookies
    async with session.get(url, headers=headers, timeout=5, cookies=cookies) as response:
        if response.status == 401:
            cookies = set_cookie()
            async with session.get(url, headers=headers, timeout=5, cookies=cookies) as response:
                return await response.text()
        elif response.status == 200:
            return await response.text()
        return ""

async def fetch_all_data():
    async with aiohttp.ClientSession() as session:
        indices_data = await get_data(url_indices, session)
        bnf_data = await get_data(url_bnf, session)
        nf_data = await get_data(url_nf, session)
    return indices_data, bnf_data, nf_data

# Process the fetched data
def process_indices_data(data):
    global bnf_ul, nf_ul, bnf_nearest, nf_nearest
    data = json.loads(data)
    for index in data["data"]:
        if index["index"] == "NIFTY 50":
            nf_ul = index["last"]
        if index["index"] == "NIFTY BANK":
            bnf_ul = index["last"]
    bnf_nearest = nearest_strike_bnf(bnf_ul)
    nf_nearest = nearest_strike_nf(nf_ul)

def process_oi_data(data, nearest, step, num):
    data = json.loads(data)
    currExpiryDate = data["records"]["expiryDates"][0]
    oi_data = []
    for item in data['records']['data']:
        if item["expiryDate"] == currExpiryDate:
            if nearest - step*num <= item["strikePrice"] <= nearest + step*num:
                oi_data.append((item["strikePrice"], item["CE"]["openInterest"], item["PE"]["openInterest"]))
    return oi_data

def print_oi_data(nifty_data, bank_nifty_data, prev_nifty_data, prev_bank_nifty_data):
    print(strBold(strLightPurple("Nifty Open Interest:")))
    for i, (strike, ce_oi, pe_oi) in enumerate(nifty_data):
        ce_change = ce_oi - prev_nifty_data[i][1] if prev_nifty_data else 0
        pe_change = pe_oi - prev_nifty_data[i][2] if prev_nifty_data else 0
        ce_color = strGreen(ce_oi) if ce_change > 0 else strRed(ce_oi)
        pe_color = strGreen(pe_oi) if pe_change > 0 else strRed(pe_oi)
        print(f"Strike Price: {strike}, Call OI: {ce_color} ({strBold(f'+{ce_change}') if ce_change > 0 else strBold(ce_change) if ce_change < 0 else ce_change}), Put OI: {pe_color} ({strBold(f'+{pe_change}') if pe_change > 0 else strBold(pe_change) if pe_change < 0 else pe_change})")

    print(strBold(strLightPurple("\nBank Nifty Open Interest:")))
    for i, (strike, ce_oi, pe_oi) in enumerate(bank_nifty_data):
        ce_change = ce_oi - prev_bank_nifty_data[i][1] if prev_bank_nifty_data else 0
        pe_change = pe_oi - prev_bank_nifty_data[i][2] if prev_bank_nifty_data else 0
        ce_color = strGreen(ce_oi) if ce_change > 0 else strRed(ce_oi)
        pe_color = strGreen(pe_oi) if pe_change > 0 else strRed(pe_oi)
        print(f"Strike Price: {strike}, Call OI: {ce_color} ({strBold(f'+{ce_change}') if ce_change > 0 else strBold(ce_change) if ce_change < 0 else ce_change}), Put OI: {pe_color} ({strBold(f'+{pe_change}') if pe_change > 0 else strBold(pe_change) if pe_change < 0 else pe_change})")

def calculate_support_resistance(oi_data):
    highest_oi_ce = max(oi_data, key=lambda x: x[1])
    highest_oi_pe = max(oi_data, key=lambda x: x[2])
    return highest_oi_ce[0], highest_oi_pe[0]

async def update_data():
    global cookies
    prev_nifty_data = prev_bank_nifty_data = None
    while True:
        cookies = set_cookie()
        indices_data, bnf_data, nf_data = await fetch_all_data()

        process_indices_data(indices_data)

        nifty_oi_data = process_oi_data(nf_data, nf_nearest, 50, 10)
        bank_nifty_oi_data = process_oi_data(bnf_data, bnf_nearest, 100, 10)

        support_nifty, resistance_nifty = calculate_support_resistance(nifty_oi_data)
        support_bank_nifty, resistance_bank_nifty = calculate_support_resistance(bank_nifty_oi_data)

        print(strBold(strCyan(f"\nMajor Support and Resistance Levels:")))
        print(f"Nifty Support: {strYellow(support_nifty)}, Nifty Resistance: {strYellow(resistance_nifty)}")
        print(f"Bank Nifty Support: {strYellow(support_bank_nifty)}, Bank Nifty Resistance: {strYellow(resistance_bank_nifty)}")

        print_oi_data(nifty_oi_data, bank_nifty_oi_data, prev_nifty_data, prev_bank_nifty_data)

        prev_nifty_data = nifty_oi_data
        prev_bank_nifty_data = bank_nifty_oi_data

        for i in range(30, 0, -1):
            print(strBold(strLightGray(f"\rFetching data in {i} seconds...")), end="")
            time.sleep(1)
        print(strBold(strCyan("\nFetching new data... Please wait.")))
        await asyncio.sleep(1)

async def main():
    await update_data()

asyncio.run(main())

Output:

You can even watch the demo video following this link

Thank you!!
See you in the next insightful blog.

What is your Plan B if you fail to crack college placements?

Mr.Shah — Fri, 28 Jun 2024 13:33:27 +0000

Namaste Developers🙏

This article will give you a reality check so, be prepared for that. Before reading this article I would like to say "Be honest with yourself".
Note: This article is solely for people who want to crack placements and want to mold themself to crack placements.

I know what you all are going through - self-doubt, low self-esteem, lack of guidance, lack of confidence, distracted in your life, don't know what to do, and the list goes on and on. Listen to me stop overthinking and start doing what you enjoy, what you love to do, and what you're passionate about. Just do it I don't know who is stopping you from doing things that you love to do.

Stop thinking about society just do what you want to do and be the best in it, let me tell you one thing "Your time will come when people will say I want to become like him/her and you will be someone's inspiration" seems like a dream right?

Believe me 1. when you will raise your bar 2. when you will start believing in yourself 3. when you will start doing things that create impacts in society that's the point when people around you will start believing in you.

You shouldn't focus on why you can't do something, which is what most people do. You should focus on why perhaps you can, and be one of the exceptions.

Now let's come back to the topic.

1. Stop overwhelming your mind with lots of things. Just focus on one thing that can land you a job.

Don't get distracted doing multiple things. Focus on one thing that's the formula to secure a job.
Ask yourself what you want to do. If you're unable to answer and have less time learn a tech stack that can easily land you a job either in a startup or any company that's my personal opinion.

2. Build Crazy projects.

Believe me, for off-campus opportunities companies look for students who have built crazy things.
Your project should be technically challenging which makes you stand out from the crowd. Your project should be config-driven it should offer functionalities like searching, sorting, filtering out things, infinite scrolling, a recommendation system, skeleton loaders, leveraging LLM's power, and so on.
You can build anything such as web apps, mobile apps, chrome extensions, iOS apps, or cool games as well.
Build something that can be used in day-to-day life and deploy it.
Share your project on LinkedIn, Twitter, and Reddit and clearly mention what are the features, what was the most challenging part of the project, what are your inspiration for building this project, and what are the future scopes of the project.

Polishing Resume (One-pager Resume).

Share your social media proofs such as LinkedIn, Github, Portfolio Website(not mandatory but as a developer, you should have one), and Leetcode.
Mention technical skills.
Showcase your projects and give a brief overview of your projects including the tech stack you've used to build the project. Make sure you provide a GitHub link to the project if possible share the deployed link of your project.
Use actionable keywords.
Make it ATS friendly and check whether your resume passes the ATS score or not.
Companies don't care about fancy resumes the only thing that matters is whether you're able to justify what you've got on that single page or not. Keep it simple and minimal.
CGPA is not mandatory (if you have a decent CGPA above 7 put it).
Mention your extra-curricular activities it reflect your personality.
Share value-added certificates.

Communication is the key to your entrance

Many students are good at tech but, they lack in presentation.
Let me share one real example: What if your sister says I know the recipe for the food but I don't know how to cook it. (No hate to sister) It's the the same thing - I know how to build the product but, I'm unable to sell the product. No matter how many functionalities you provide if you fail to articulate those functionalities no one is going to buy that product.
Focus on your communication skills. Learn to articulate your thoughts in plain words.
Listen + Practice => Good Communicator

Keep applying for jobs

Daily apply for 50-100 jobs. Keep applying insanely.
Give interviews and learn from the interviews. You can fail 5-10-15 and even more interviews don't get scared but, slowly and steadily you will gain confidence and self-esteem which will make you good at handling interview pressure.
Embrace the failures and learn from them.
Get the feedback from the interviewer and start working on it.
Ask for referrals.
Apply at start-ups. The chances of getting shortlisted will be increased. At the initial stage of your career join any of the start-ups because you will know how things work, you need to be multi-tasking in start-ups, and these things will help you a lot in your later stage.

Our greatest glory is not in never falling, but in rising every time we fall. (Confucius)

Do you know where the problem exists? Students are mad about FAANGS and as a fresher, they expect X LPA. I am not saying you should stop dreaming about high-paying jobs. I am saying to match the expectation with your reality. If you're capable enough crack it. Just be honest with yourself that's it.

Let's not be so quick to judge companies as good or bad. Getting experience is what really matters, and that can happen in all sorts of places—from startups to big companies like TCS, Wipro, and Infosys. It's all about learning and growing, and the door to other opportunities will open up as you gain experience.
*Remember, you're still in your 20s and there's plenty of time to explore different options! *

It's always better to be curious and adaptable. So don't be afraid to try something new!

In a nutshell: continuous learning leads to better pay.

This video has got the answers you're looking for. Check it out! 👍

If you're curious, I'd love to share my personal experience with "How I Landed an Off-Campus Summer Internship in a small company." Let me know in the comments if you're interested! 🙌

Don't hesitate to reach out to me on LinkedIn if you need support or assistance with anything. I'm here to help you in any way I can! 😊

JavaScript in 2023: Why you should learn it(Blog-1) | Shah Stavan?

Mr.Shah — Sun, 22 Jan 2023 07:26:45 +0000

Hello guys, it's been a while since I've posted on my blog🤧

Throughout this blog, we will highlight culminating reasons to learn JavaScript over other languages.

What is JavaScript?

Not to be confused with Java, JavaScript—created by Netscape Communications—first appeared in 1995. Its developers define it as a “scripting or programming language that allows you to implement complex things on web pages.” JavaScript makes web pages more dynamic and user-friendly so that they respond to visitors’ actions. Or, to put it another way, JavaScript makes web pages interactive.

JavaScript was once called LiveScript; but due to Java’s popularity, it was rebranded to take advantage of that fame. You could say that the newer language hitched its wagon to the rising star and went along for the ride, attracting its vast following in the process.

Top 10 reasons to learn JavaScript

It’s the most popular programming language
JavaScript also exists outside of the internet
JavaScript is Easy to Learn
You Can Create Visual Effects and Other Eye-catching Aesthetic Features
JavaScript is Versatile
It’s a Valuable Tool for Game Designers
Finally, the Career Potential is Skyrocketing
Building web servers and developing server applications
JavaScript's multi-paradigm nature: JavaScript supports both functional programming and object-oriented programming (OOP).
TypeScript: This adds static typing to JavaScript.

Stack Overflow Survey

Stack Overflow surveyed 70,0946 developers this year, and 91.88 percent of respondents identified as male, almost the same as last year.

In the 2022 survey, popular technologies were compared across three groups: All respondents, professional developers, and those learning to code.

Demand is just Sky Rocketing🚀

There is an escalating demand for this profession.. All industries, from startups to multinational corporations in businesses, are on the lookout for full-stack developers.
Full-stack developers continuously excel over partial task professionals, making them more desirable for companies.Even Tanay Pratap, SDE-2 at Microsoft, urges his followers to practice JavaScript giving direct insights from the industry.

Full stack developers’ demand is high in various industries, such as entertainment, banking, software, tech, travel and tourism, government websites, education, insurance, transport services, etc. According to the U.S Bureau of Labour Statistics, there would be a high rise in the jobs of the FSD developers, it would increase from 135,000 to over 853,000 by 2024

A simple LinkedIn search for JavaScript developer jobs will reveal over 337,000+ opportunities

As it happens, there’s also a shortage of good JavaScript developers, so you have increased demand in conjunction with a deficit of qualified people. According to a report released by Devskiller.com, 70 percent of companies surveyed want to hire a JavaScript developer.

Businesses and other organizations that are looking for JavaScript professionals are willing to pay well, too! Indeed.com shows that a JavaScript developer can potentially earn an annual average of $113,643 in the United States. As per the StackOverflow Survey, React Framework has been most used and wanted for five consecutive years.

JavaScript Developer Salary Range in India

The average JavaScript Developer salary is Rs. 338,078 or an hourly salary of Rs. 254.34. With a few years of experience, the salary can rise to around Rs. 1,000,000, including benefits like bonus and profit-sharing in his mid-career.

I'm sure you're thinking, "Ok! Sounds good. I'll take a shot"
Let's get started with the JavaScript road map, which promises a lot of fun and excitement

JavaScript Roadmap

First of all,just go through a basic understanding of how the “Client — Server” paradigm works. Second of all, you need to be comfortable with searching things on Google and following online tutorials, as most of the things you need in order to learn User Interface Design are only found online.

Source- FreeCodeCamp

Responsibilities of JavaScript Developer

This requires a niche of programmers with a good understanding of Git, CSS Libraries etc. JavaScript Developers are in high demand in major metros like Delhi-NCR, Bangalore, Hyderabad, and Mumbai while newer IT destinations like Pune and Chandigarh also have a high demand.

Ensuring feasibility of UI/UX designs
Enhancing the performance of the main frontend website
Modifying designs and specifications of complex applications
Analyzing code, system risks, requirements, and software reliability
Collaborating with frontend and backend web developers
Building sustainable codes that may be used in future

Source- Upgrad

Bonus

In order to assist you in your JavaScript learning, I'm dropping a few amazing resources

Goodbye :)