DEV Community: Akarsh Jaiswal

Automate Scheduled Jobs in Python Using the schedule Library: A Cron Alternative

Akarsh Jaiswal — Mon, 29 Sep 2025 18:23:07 +0000

If you’re used to setting up cron jobs on Linux to automate tasks, but want a simple, Python-native way to schedule jobs, the schedule library is an excellent alternative. It allows you to run Python functions periodically without relying on system-level cron.

In this post, I’ll show you how to:

Install and use the schedule library
Write Python scripts that run tasks on a schedule
Keep your jobs running continuously
Understand when to use schedule instead of cron

What Is the `schedule` Library?

schedule is a lightweight Python package designed to run jobs periodically inside your Python program. Unlike cron, which is managed by your OS, schedule lets you embed scheduling logic directly in Python.

This makes it ideal for cross-platform automation and when you want to keep everything in Python.

Installation

Install it easily with pip:

pip install schedule

Basic Usage Example

Here’s a simple example that prints the current time every minute:

import schedule
import time
from datetime import datetime

def job():
    print(f"Task running at {datetime.now()}")

# Schedule the job every minute
schedule.every(1).minutes.do(job)

print("Scheduler started. Press Ctrl+C to exit.")

while True:
    schedule.run_pending()
    time.sleep(1)

This script:

Defines a job function to run on schedule
Schedules it every minute
Enters an infinite loop that checks and runs due jobs

Scheduling Variations

schedule supports many common patterns:

schedule.every().day.at("14:00").do(job)     # Every day at 2 PM
schedule.every().hour.do(job)                 # Every hour
schedule.every().monday.do(job)                # Every Monday
schedule.every(10).seconds.do(job)            # Every 10 seconds
schedule.every(5).to(10).minutes.do(job)      # Every 5 to 10 minutes (random)

Keeping Your Scheduled Jobs Running

Since schedule runs within your Python script, you need to ensure the script stays alive:

Run inside a terminal multiplexer like screen or tmux
Use Linux tools like systemd or supervisord to manage the script
Run as a background process with nohup or &
Dockerize your script with restart policies for resilience

Why Use `schedule` Over Cron?

Cross-platform: Works on Linux, macOS, Windows without changes
Python-native: Write schedules in Python rather than shell scripts
Dynamic: Modify schedules programmatically at runtime
Single process: Manage multiple jobs from one Python app

Limitations Compared to Cron

The Python script must be continuously running for tasks to execute
Lacks built-in logging, notifications, or advanced cron features
Not suitable for system-level task scheduling where OS guarantees execution

When Should You Use `schedule`?

When you want to keep all logic inside Python
For cross-platform automation without OS dependencies
When you want simple scheduling integrated with your Python app

For mission-critical or system-level tasks, traditional cron combined with Python scripts is still recommended.

Helpful links:

Finding the K Shortest Paths Using Yen's Algorithm in Python

Akarsh Jaiswal — Mon, 29 Sep 2025 18:13:46 +0000

When you need more than just the single shortest path—say, the top 3 shortest routes between two locations—Dijkstra alone isn't enough. That's where Yen's algorithm comes in. It builds on Dijkstra’s algorithm to find multiple shortest paths in a weighted graph.

In this post, we'll:

Explain Yen’s K Shortest Paths algorithm
Implement it using networkx and Dijkstra
Run an example to get multiple optimal routes

No external packages beyond networkx required.

What is Yen’s Algorithm?

Yen’s algorithm finds the K shortest loopless paths between a source and target node in a weighted graph. It:

Starts with the shortest path (via Dijkstra)
Iteratively finds deviations ("spur paths") from previous paths
Ensures no cycles and avoids previously used subpaths
Returns a list of the top k paths ranked by total weight

This is helpful in routing, logistics, or network failover systems where alternate optimal paths are needed.

Prerequisites

Install networkx if you don’t already have it:

pip install networkx

Full Implementation of Yen’s Algorithm in Python

Here’s a complete implementation using networkx. This assumes a directed graph with positive edge weights.

import heapq
import networkx as nx

def dijkstra_path_length(graph, source, target):
    try:
        return nx.dijkstra_path_length(graph, source, target, weight='weight')
    except nx.NetworkXNoPath:
        return float('inf')

def yen_k_shortest_paths(graph, source, target, k):
    if source == target:
        return [[source]]

    paths = []
    potential_paths = []

    # First shortest path using Dijkstra
    try:
        first_path = nx.dijkstra_path(graph, source, target, weight='weight')
        paths.append(first_path)
    except nx.NetworkXNoPath:
        return []

    for i in range(1, k):
        for j in range(len(paths[-1]) - 1):
            spur_node = paths[-1][j]
            root_path = paths[-1][:j + 1]

            g_copy = graph.copy()

            # Remove edges that would recreate previously found paths
            for path in paths:
                if path[:j + 1] == root_path and len(path) > j + 1:
                    g_copy.remove_edge(path[j], path[j + 1])

            # Remove nodes in root path except spur_node
            for node in root_path[:-1]:
                g_copy.remove_node(node)

            try:
                spur_path = nx.dijkstra_path(g_copy, spur_node, target, weight='weight')
                total_path = root_path[:-1] + spur_path
                total_weight = sum(
                    graph[u][v]['weight'] for u, v in zip(total_path, total_path[1:])
                )
                heapq.heappush(potential_paths, (total_weight, total_path))
            except nx.NetworkXNoPath:
                continue

        if potential_paths:
            _, new_path = heapq.heappop(potential_paths)
            paths.append(new_path)
        else:
            break

    return paths

Example Usage

G = nx.DiGraph()
G.add_weighted_edges_from([
    ('A', 'B', 1),
    ('A', 'C', 5),
    ('B', 'C', 1),
    ('B', 'D', 2),
    ('C', 'D', 1),
    ('D', 'E', 3),
    ('C', 'E', 5),
])

k_paths = yen_k_shortest_paths(G, 'A', 'E', k=3)

for idx, path in enumerate(k_paths):
    cost = sum(G[u][v]['weight'] for u, v in zip(path, path[1:]))
    print(f"{idx + 1}: Path = {path}, Cost = {cost}")

Output:

1: Path = ['A', 'B', 'C', 'D', 'E'], Cost = 7
2: Path = ['A', 'B', 'D', 'E'], Cost = 6
3: Path = ['A', 'C', 'D', 'E'], Cost = 9

Performance Note

networkx is fine for small to mid-sized graphs.
For very large graphs, you might want to use igraph or implement a more efficient priority queue system.

When Should You Use Yen’s Algorithm?

Use it when:

You need multiple options for routing
You want to offer fallbacks (e.g., in navigation systems)
Your problem requires loopless, shortest, and alternative paths

Don’t use it for cyclic paths or in graphs with negative weights—it assumes non-negative weighted edges.

Final Thoughts

Yen’s algorithm is a great way to go beyond "just the shortest path" in a network. While libraries like networkx don't offer it out-of-the-box, it's easy to implement yourself using Dijkstra as the base. Whether you're building logistics tools, recommendation engines, or network analysis apps, having access to the K best paths opens up new possibilities.

Comparing Dijkstra's Algorithm in iGraph vs networkX: Which One Should You Use?

Akarsh Jaiswal — Mon, 29 Sep 2025 18:10:42 +0000

When working with graphs in Python, two of the most popular libraries are igraph and networkx. Both offer a range of features for network analysis, including shortest path algorithms like Dijkstra's. But which one should you choose? This post walks through a hands-on comparison using Dijkstra’s algorithm, with insights on performance, ease of use, and real-world suitability.

Libraries Overview

networkx is a pure Python library known for its simplicity and ease of use. It’s ideal for small to medium-sized graphs and educational purposes.

igraph is written in C and optimized for performance. It’s great for large-scale networks where speed and memory efficiency matter.

Let’s compare how both libraries handle Dijkstra’s algorithm.

Installation

First, install both libraries:

pip install networkx
pip install igraph

If you're using igraph for the first time, make sure you get the Python bindings, not just the C core.

pip install python-igraph

Example: Finding Shortest Path with Dijkstra

Let’s define a simple directed graph with weighted edges and compute the shortest path from node A to node D.

Using networkx

import networkx as nx

G = nx.DiGraph()
G.add_weighted_edges_from([
    ('A', 'B', 1),
    ('B', 'C', 2),
    ('A', 'C', 4),
    ('C', 'D', 1)
])

path = nx.dijkstra_path(G, source='A', target='D')
length = nx.dijkstra_path_length(G, source='A', target='D')

print("Shortest path:", path)
print("Total distance:", length)

Output:

Shortest path: ['A', 'B', 'C', 'D']
Total distance: 4

Using igraph

from igraph import Graph

edges = [('A', 'B'), ('B', 'C'), ('A', 'C'), ('C', 'D')]
weights = [1, 2, 4, 1]

# Convert node names to indices
vertices = ['A', 'B', 'C', 'D']
vertex_map = {name: idx for idx, name in enumerate(vertices)}

g = Graph(directed=True)
g.add_vertices(vertices)
g.add_edges([(vertex_map[u], vertex_map[v]) for u, v in edges])
g.es['weight'] = weights

shortest = g.get_shortest_paths(vertex_map['A'], to=vertex_map['D'], weights='weight', output='vpath')
distance = g.shortest_paths(vertex_map['A'], to=vertex_map['D'], weights='weight')[0][0]

# Convert indices back to names
path = [vertices[i] for i in shortest[0]]

print("Shortest path:", path)
print("Total distance:", distance)

Output:

Shortest path: ['A', 'B', 'C', 'D']
Total distance: 4.0

Comparison: networkx vs igraph

Feature	networkx	igraph
Language	Pure Python	C core with Python bindings
Speed	Slower on large graphs	Much faster on large graphs
Memory Usage	Higher	Lower
Ease of Use	Very beginner-friendly	Slightly steeper learning curve
Best Use Case	Small to medium graphs, prototyping	Large-scale graphs, performance-critical tasks
Shortest Path Output	Node names	Node indices (manual mapping needed)

When to Use Which?

Use networkx if you're working on academic projects, prototyping, or working with small to mid-sized graphs where clarity and flexibility matter more than speed.
Use igraph if you're dealing with large networks (e.g., social graphs, biological networks), and you need high performance and low memory usage.

Final Thoughts

Both libraries implement Dijkstra's algorithm effectively, but your choice should depend on the size of your graph and your performance needs. For quick scripts and readable code, go with networkx. If you're pushing the limits of graph size or speed, igraph is the better option.

Being familiar with both gives you the flexibility to switch depending on your project needs. Try both, benchmark with your own data, and choose what feels right for your workflow.

Helpful Links

How to Run Mistral Locally Using Ollama

Akarsh Jaiswal — Mon, 29 Sep 2025 18:05:58 +0000

If you’ve ever wanted to run powerful language models on your own machine without cloud costs or complex setups Ollama makes that incredibly easy. In this post, I'll walk you through running the Mistral model locally using Ollama, from installation to making API calls from Python.

Let’s get started.

What is Ollama?

Ollama is a lightweight tool that lets you run large language models locally with minimal effort. It handles downloading, starting, and serving models through a local API—no Docker setup or GPU required (though it can use one if available).

Step 1: Install Ollama

First, install Ollama on your system. It's available for macOS, Linux, and Windows (via WSL).

macOS (via Homebrew):

brew install ollama

Linux:

curl -fsSL https://ollama.com/install.sh | sh

Windows (via WSL):

Install WSL (if you haven’t already)
Run the Linux install command inside your WSL terminal

Once installed, you can start the Ollama server:

ollama serve

Step 2: Download the Mistral Model

Ollama supports various open-weight models. To download Mistral, simply run:

ollama pull mistral

This will download the Mistral 7B model and prepare it for use.

Step 3: Run Mistral in Your Terminal

To start using the model in an interactive chat format, run:

ollama run mistral

You’ll enter a prompt where you can chat with the model just like you would with any LLM:

> What are some fun weekend projects using Raspberry Pi?

Mistral will generate a local response in real-time.

Step 4: Access Mistral Programmatically via API

Ollama also runs a local HTTP API at http://localhost:11434. You can use this to integrate the model into any app or script.

Here’s a quick example in Python:

import requests

response = requests.post(
    'http://localhost:11434/api/generate',
    json={
        'model': 'mistral',
        'prompt': 'Explain how quantum computing works in simple terms.',
        'stream': False
    }
)

print(response.json()['response'])

Make sure ollama serve is running in the background when you make this request.

Optional: Customize Mistral with a Modelfile

You can also create a customized version of the model using a simple Modelfile. This allows you to define a default system prompt or other behaviors.

Example Modelfile:

FROM mistral
SYSTEM You are a concise and friendly assistant.

To create and run your custom model:

ollama create custom-mistral -f Modelfile
ollama run custom-mistral

This is useful if you want to fine-tune the tone or role of the assistant.

Final Thoughts

With Ollama, running high-performance models like Mistral locally is no longer just for AI researchers or devops wizards. You can get started in minutes, and it's ideal for:

Offline development
Privacy-sensitive tasks
Learning how LLMs work behind the scenes

If you're interested in experimenting with open-source LLMs, this setup is one of the easiest ways to dive in.

Useful Links

Agentic AI: The Next Leap Toward Autonomous Intelligence

Akarsh Jaiswal — Mon, 29 Sep 2025 18:00:48 +0000

Artificial intelligence is evolving—fast. What started as rule-based automation has grown into machine learning, and now we're entering a new phase: Agentic AI. These AI systems aren't just reactive—they're proactive. They make decisions, pursue goals, and act independently in dynamic environments.

Agentic AI isn’t just a technical upgrade; it’s a fundamental shift in how machines can work alongside us.

What Is Agentic AI?

Agentic AI refers to systems that go beyond following instructions. They have a level of autonomy that allows them to:

Operate independently
Set and pursue goals
Adapt to changing environments and feedback

This turns AI from a passive tool into an active collaborator—something that can take initiative and handle complex tasks without constant human direction.

Real-World Applications

Logistics: AI agents can reroute supply chains in real-time during disruptions without waiting for human intervention.

Finance: They can autonomously monitor markets and adjust investment strategies on the fly.

Healthcare: Agentic AI can track patient vitals, predict risks, and suggest interventions in real-time, improving patient outcomes.

Customer Support: Instead of relying on scripts, AI agents can handle and resolve complex customer issues end-to-end.

Why It Matters

Agentic AI offers practical benefits across industries:

Scalability: Handle more with fewer human resources.
Speed: Make real-time decisions when timing matters.
Efficiency: Reduce repetitive tasks and operational delays.

As AI becomes more proactive, it opens doors for innovation and growth, especially in environments where speed and adaptability are critical.

Challenges to Consider

Autonomy brings complexity. Some challenges include:

Accountability: Who is responsible when AI makes a mistake?
Ethical Use: How do we ensure fairness, transparency, and bias mitigation?
Oversight: Striking the right balance between independence and human control.

Designing with intention and safety in mind is critical for building trustworthy agentic systems.

What's Next?

Agentic AI isn’t about replacing people, it’s about augmenting human capability. It enables new forms of collaboration where AI can handle tasks that are too fast, too complex, or too repetitive for humans alone.

Organizations that begin exploring this space today will be better positioned for the intelligent, autonomous systems of tomorrow.

Build a Native Mobile App Using Angular

Akarsh Jaiswal — Mon, 30 Sep 2024 14:48:07 +0000

We will build a native mobile application using Angular and Capacitor.

What is Capacitor ?

Capacitor is an open-source platform created by the team behind Ionic. It allows developers to build cross-platform mobile apps using web technologies like HTML, CSS, and JavaScript12.

Capacitor works by wrapping your web application in a native container, enabling it to run as a native app on iOS, Android, and even as a Progressive Web App (PWA). It provides a bridge between the web code and native functionality, allowing you to access native device features such as the camera, geolocation, and file system through JavaScript13.

Here are some key features of Capacitor:

Cross-Platform: Build apps that run on iOS, Android, and the web with a single codebase.
Native Access: Use native APIs and plugins to access device features.
Modern Web Technologies: Leverage standard web technologies to build your app.
Extensible: Create custom plugins to extend the functionality of your app

Prerequisites

Ensure that Node.js, Angular CLI, Capacitor Setup are installed.

Step 1: Create a New Angular Application

To kick things off, let’s generate a new Angular project using the CLI. Run the following command:

ng new angular-mobile-app

This command will set up a fresh Angular application.

Once the setup is complete, navigate to your project folder and start the development server:

cd angular-mobile-app
ng serve

Now, open your web browser and visit http://localhost:4200 to check if your app is running correctly.

Step 2: Install Capacitor

With your web app ready, it’s time to add Capacitor to your project. Execute the following commands:

cd angular-mobile-app
npm install @capacitor/core
npm install @capacitor/cli

Step 3: Initialize the Capacitor Configuration

Next, initialize Capacitor to create the configuration file:

npx cap init

You will be prompted to answer some basic questions about your app; you can keep the default settings for now.

Make sure to modify the webDir path to dist/angular-mobile-app, as this is the default build path for Angular applications.

Step 4: Add iOS and Android Support

Now, let’s install the required packages for iOS and Android and create the native projects:

npm install @capacitor/ios @capacitor/android
npx cap add ios
npx cap add android

These commands will generate folders for both Android and iOS within your project.

Step 5: Build Your Application

Now, build your Angular app and synchronize it with the native platforms using the following commands:

ng build --prod
npx cap sync

The npx cap sync command will copy the build files into the respective iOS and Android projects.

Step 6: Open Your Mobile Projects

You can open your mobile projects in Android Studio or Xcode using these commands:

npx cap open ios
npx cap open android

Before running these commands, ensure your environment is properly configured.

Once you’ve opened the project in your preferred IDE, you can deploy your app to a connected device or an emulator. For example, if you're using Android Studio, select your target device (like a Pixel 4 emulator) and hit the run or debug button.

Step 7: Launch Your App!

Finally, it’s time to run your application! Click the run button in your IDE, and watch your Angular app come to life as a mobile application.

By following these steps, you can efficiently convert your Angular application into a mobile app using Capacitor, allowing you to reach users on both iOS and Android platforms. Happy coding!

Converting HTML web pages into PDF

Akarsh Jaiswal — Sun, 26 May 2024 08:21:21 +0000

In this article, I will guide you through the straightforward process of converting HTML web pages into PDF documents using Puppeteer. This Node.js library provides a user-friendly API to control Chrome or Chromium over the DevTools Protocol.

Prerequisites

Before I start, ensure you have Node.js and npm installed on your machine. Node.js is a JavaScript runtime built on Chrome’s V8 JavaScript engine, and npm is the package manager for the Node.js platform. If not, you can download and install Node.js from the official website (https://nodejs.org/en/download), where the Node.js package manager is included in the Node.js distribution.

You can verify the installation by running the following commands in your terminal:

node --version
npm --version

Step 1: Initialize a new Node.js project

First, create a new directory for your project and navigate into it:

mkdir html-to-pdf-demo
cd html-to-pdf-demo

Then, initialize a new Node.js project by running:

npm init -y

This will create a new ‘package.json* file in your project directory.

Step 2: Install Puppeteer

Next, install Puppeteer by running:

npm install puppeteer

This will download a recent version of Chromium, a headless browser that Puppeteer controls.

Step 3: Write the script

Create a new index.js file in your project directory and open it in your text
editor. Then, paste the following code:

const puppeteer =
require('puppeteer');
async function printPDF() {

 const browser = await puppeteer.launch();
 const page = await browser.newPage();

 await page.goto (http://
 marvel2950.github.io, {waitUntil:
 'networkidle0'});

 const pdf = await
 page.pdf ({ format: 'A4' });

 await browser.close();

 return pdf;

}

printPDF().then (pdf => {
require('fs') .writeFileSync('output.pdf', pdf);
});

This script launches a new browser instance, opens a new page, navigates to http://marvel2950.github.io, and generates a PDF. The ‘{waitUntil: ‘networkidle0’}’ option ensures that the ‘page.goto’ function waits until there are no more than 0 network connections for at least 500 ms.

Step 4: Run the script

node index.js

And that’s it! This will create a new PDF document named ‘output.pdf’ in your project directory. This file is the result of the PDF generation process and contains the content of the HTML web page in a PDF format.

DEV Community: Akarsh Jaiswal

Automate Scheduled Jobs in Python Using the schedule Library: A Cron Alternative

What Is the schedule Library?

Installation

Basic Usage Example

Scheduling Variations

Keeping Your Scheduled Jobs Running

Why Use schedule Over Cron?

Limitations Compared to Cron

When Should You Use schedule?

Finding the K Shortest Paths Using Yen's Algorithm in Python

What is Yen’s Algorithm?

Prerequisites

Full Implementation of Yen’s Algorithm in Python

Example Usage

Output:

Performance Note

When Should You Use Yen’s Algorithm?

Final Thoughts

Comparing Dijkstra's Algorithm in iGraph vs networkX: Which One Should You Use?

Libraries Overview

Installation

Example: Finding Shortest Path with Dijkstra

Using networkx

Output:

Using igraph

Output:

Comparison: networkx vs igraph

When to Use Which?

Final Thoughts

Helpful Links

How to Run Mistral Locally Using Ollama

What is Ollama?

Step 1: Install Ollama

Step 2: Download the Mistral Model

Step 3: Run Mistral in Your Terminal

Step 4: Access Mistral Programmatically via API

Optional: Customize Mistral with a Modelfile

Final Thoughts

Useful Links

Agentic AI: The Next Leap Toward Autonomous Intelligence

What Is Agentic AI?

Real-World Applications

Why It Matters

Challenges to Consider

What's Next?

Build a Native Mobile App Using Angular

What is Capacitor ?

Prerequisites

Step 1: Create a New Angular Application

Step 2: Install Capacitor

Step 3: Initialize the Capacitor Configuration

Step 4: Add iOS and Android Support

Step 5: Build Your Application

Step 6: Open Your Mobile Projects

Step 7: Launch Your App!

Converting HTML web pages into PDF

Prerequisites

Step 1: Initialize a new Node.js project

Step 2: Install Puppeteer

Step 3: Write the script

Step 4: Run the script

What Is the `schedule` Library?

Why Use `schedule` Over Cron?

When Should You Use `schedule`?