DEV Community: Marant7

Your First MCP Server in Python: Connect Custom Tools to Claude🚀

Marant7 — Sat, 05 Jul 2025 06:58:55 +0000

Did you know you can create your own tools for Claude Desktop without consuming your token quota? I'll show you how to build a Model Context Protocol (MCP) server in 5 minutes.

What is MCP? 🤔

Model Context Protocol is an open standard that allows AIs to access external tools. Think of it as creating "plugins" for your favorite AI.

Key benefits:

✅ Free: Doesn't consume AI tokens
✅ Reusable: Works with multiple clients (Claude, Windsurf, etc.)
✅ Extensible: Connect APIs, databases, or any Python code

Quick Setup 🛠️

# 1. Create project
mkdir my-mcp-server && cd my-mcp-server
python -m venv venv

# 2. Activate environment
# Windows: .\venv\Scripts\Activate.ps1
# macOS/Linux: source venv/bin/activate

# 3. Install dependencies
pip install mcp fastmcp

The Code: 2 Tools in 30 Lines 🎯

#!/usr/bin/env python3
from mcp.server.fastmcp import FastMCP

mcp = FastMCP()

@mcp.tool()
def calculator(a: int, b: int) -> str:
    """Adds two numbers."""
    result = a + b
    return f"OK {a} + {b} = {result}"

@mcp.tool()
def generate_greeting(name: str, language: str = "english") -> str:
    """Generates greetings in different languages."""
    greetings = {
        "english": f"Hello {name}, have a great day!",
        "spanish": f"Hola {name}, que tengas un excelente dia!",
        "french": f"Bonjour {name}, passez une excellente journee!"
    }
    return greetings.get(language.lower(), greetings["english"])

if __name__ == "__main__":
    print("MCP Server started...")
    mcp.run()

Connect with Claude Desktop 🤖

Run the server:

   python server.py

Configure Claude Desktop: Edit %APPDATA%\Claude\claude_desktop_config.json:

   {
     "mcpServers": {
       "MY-SERVER": {
         "command": "C:\\path\\to\\your\\venv\\Scripts\\python.exe",
         "args": ["C:\\path\\to\\your\\server.py"],
         "cwd": "C:\\path\\to\\your\\project"
       }
     }
   }

Test it!
- "Add 15 and 27" → Uses calculator
- "Greet Ana in Spanish" → Uses generate_greeting

Key Concepts 📚

Tools vs Prompts

Tools (@mcp.tool()): Execute code, return data
Prompts (@mcp.prompt()): Generate text templates

When to use each?

Tool: Calculate, query APIs, process data
Prompt: Generate emails, documents, templates

Real-World Use Cases 🎯

# Connect with external API
@mcp.tool()
async def get_weather(city: str) -> dict:
    """Gets current weather."""
    # Your logic here
    pass

# Query database
@mcp.tool()
def find_customer(id: int) -> dict:
    """Finds a customer in the database."""
    # Your logic here
    pass

Common Troubleshooting 🔧

UTF-8 Error: Avoid emojis in prints or configure encoding.
Won't connect: Verify absolute paths in configuration.
Tools don't appear: Restart Claude Desktop after changes.

What's Next? 🚀

With MCP you can:

Connect your AI to any API
Automate work-specific tasks
Create reusable tools for your team

The future of AI is extensible. What tool will you create first?

Liked it? 💖 and tell me what MCP tools you're planning to build.

Full code: https://github.com/Marant7/mcp-python.git

MCP #AI

Observability Practices with Python, Prometheus, and Grafana

Marant7 — Fri, 04 Jul 2025 16:03:42 +0000

Observability Practices with a Real-World Example

Observability is essential for understanding how our applications behave in production. It involves collecting metrics, logs, and traces to detect issues, analyze trends, and optimize performance. Good observability allows teams to quickly identify bottlenecks, react to incidents, and maintain reliable systems.

What is Observability?

Observability is the ability to measure the internal state of a system by examining its outputs. In modern software, this means having visibility into metrics (quantitative measurements), logs (detailed event records), and traces (end-to-end request flows).

Real-World Example: Python, Prometheus, and Grafana

Let's look at a practical example. We build a simple Python API with Flask that exposes two key metrics using Prometheus:

http_requests_total: the number of HTTP requests received.
http_request_latency_seconds: the average latency of those requests.

The script also simulates traffic automatically, so there is always data available for monitoring.

We use Docker to run Prometheus and Grafana. Prometheus scrapes the metrics from our API, and Grafana visualizes them in real time. This setup is very similar to what you would use in a production environment.

Diagram

Example Code

from flask import Flask, jsonify
from prometheus_client import Counter, Summary, generate_latest, CONTENT_TYPE_LATEST
import time, random, threading, requests

app = Flask(__name__)
REQUEST_COUNT = Counter('http_requests_total', 'Total HTTP requests', ['method', 'endpoint'])
REQUEST_LATENCY = Summary('http_request_latency_seconds', 'HTTP request latency', ['endpoint'])

@app.route('/api')
def api():
    start = time.time()
    time.sleep(random.uniform(0.1, 0.8))
    REQUEST_COUNT.labels(method='GET', endpoint='/api').inc()
    REQUEST_LATENCY.labels(endpoint='/api').observe(time.time() - start)
    return jsonify({'message': 'Hello, observability!'})

@app.route('/metrics')
def metrics():
    return generate_latest(), 200, {'Content-Type': CONTENT_TYPE_LATEST}

def generate_traffic():
    while True:
        try:
            requests.get('http://localhost:8000/api')
        except Exception:
            pass
        time.sleep(random.uniform(0.5, 2))

if __name__ == '__main__':
    threading.Thread(target=generate_traffic, daemon=True).start()
    app.run(host='0.0.0.0', port=8000)

Prometheus Configuration (prometheus.yml)

global:
  scrape_interval: 5s
scrape_configs:
  - job_name: 'python-app'
    static_configs:
      - targets: ['host.docker.internal:8000']

Docker Compose Example

docker-compose.yml:
version: '3.8'
services:
  prometheus:
    image: prom/prometheus:latest
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
    ports:
      - '9090:9090'
  grafana:
    image: grafana/grafana:latest
    ports:
      - '3000:3000'
    depends_on:
      - prometheus

Grafana Queries

Total requests: sum(rate(http_requests_total[1m]))
Average latency: rate(http_request_latency_seconds_sum[1m]) / rate(http_request_latency_seconds_count[1m])

Prometheus

It collects, stores, and queries metrics (such as CPU usage, memory, network traffic, etc.).

Dashboard Example

You can create a dashboard in Grafana to visualize these metrics in real time. This allows you to monitor your API's health, spot trends, and set up alerts for anomalies.

Why is this important?

With these metrics, you can:

Detect performance issues (e.g., high latency)
Monitor traffic patterns
Set up alerts for abnormal behavior
Make data-driven decisions to improve your application

How to Try It Yourself

Clone the repository and install dependencies:

   pip install flask prometheus_client requests

Run the Python script to start the API and metrics endpoint.
Use Docker Compose to start Prometheus and Grafana.
In Grafana, add Prometheus as a data source and create dashboards with queries like:
- sum(rate(http_requests_total[1m]))
- rate(http_request_latency_seconds_sum[1m]) / rate(http_request_latency_seconds_count[1m])

Conclusion

Observability is not just about collecting data, but about making your systems transparent and manageable. With tools like Prometheus and Grafana, and a few lines of code, you can gain valuable insights into your applications and ensure their reliability.

Link : https://github.com/Marant7/demo-observabilty-practice

Software Design Principles: A Practical Approach with Python

Marant7 — Sun, 27 Apr 2025 22:14:12 +0000

Software design is fundamental in building robust, scalable, and maintainable applications. There are several principles that guide how we structure code to ensure it's efficient and sustainable over time. In this article, we will explore some of the most important software design principles and apply them in a real-world example using Python.

Software Design Principles

1. Single Responsibility Principle (SRP)

This principle states that a class or module should have one and only one reason to change, meaning it should have a single responsibility. If a class has multiple responsibilities, it becomes harder to maintain and understand.

Example in Python:
Imagine a class that handles both business logic and data persistence. According to SRP, we should split these responsibilities into separate classes.

# Class to handle business logic
class Order:
    def __init__(self, items, total_amount):
        self.items = items
        self.total_amount = total_amount

    def calculate_total(self):
        return sum(item['price'] for item in self.items)


# Class to handle data persistence
class OrderPersistence:
    def save_order(self, order):
        # Imagine saving the order to a database
        print(f"Order for {len(order.items)} items saved with total of ${order.total_amount}")

Here, we’ve separated the responsibilities of business logic (total calculation) and data persistence into two distinct classes.

2. Open/Closed Principle (OCP)

This principle suggests that code should be open for extension but closed for modification. This means that we should be able to add new functionality without modifying the existing code.

Example in Python: Suppose we want to calculate the total of an order with different payment methods (credit card, PayPal, etc.). We use inheritance to extend functionality without modifying the base classes.

# Base class for total calculation
class PaymentMethod:
    def calculate_total(self, order):
        raise NotImplementedError


# Class for calculating with credit card
class CreditCardPayment(PaymentMethod):
    def calculate_total(self, order):
        return order.total_amount * 1.02  # Apply 2% commission


# Class for calculating with PayPal
class PayPalPayment(PaymentMethod):
    def calculate_total(self, order):
        return order.total_amount * 1.05  # Apply 5% commission

3.Liskov Substitution Principle (LSP)

This principle states that derived classes must be substitutable for their base classes without altering the correct behavior of the program. That is, if class B is a subclass of A, we should be able to use an object of B where an object of A is expected without breaking functionality.

Example in Python: Continuing from the previous example, subclasses of PaymentMethod should be able to be used wherever a PaymentMethod is expected without issues.

def process_payment(payment_method, order):
    total = payment_method.calculate_total(order)
    print(f"Total after payment processing: ${total}")

order = Order([{"price": 20}, {"price": 35}], 55)
payment_method = CreditCardPayment()
process_payment(payment_method, order)  # Works correctly with any subclass of PaymentMethod

This code works seamlessly with both CreditCardPayment and PayPalPayment, adhering to the LSP principle.

4. Interface Segregation Principle (ISP)

The interface segregation principle tells us that we should not force classes to implement interfaces they do not use. Instead of having one large interface, we should have several smaller ones, each covering a cohesive set of operations.

Example in Python: Instead of creating a generic class that has all payment methods, we can separate interfaces for each type of payment.

class CreditCardPaymentProcessor:
    def process_credit_card(self, card_number, amount):
        print(f"Processing credit card payment of ${amount} using card {card_number}")


class PayPalPaymentProcessor:
    def process_paypal(self, account_email, amount):
        print(f"Processing PayPal payment of ${amount} for account {account_email}")

This way, the classes implement only the interfaces necessary for the type of payment they process.

5. Dependency Inversion Principle (DIP)

The dependency inversion principle states that high-level classes should not depend on low-level classes, but on abstractions. Moreover, abstractions should not depend on details, but details should depend on abstractions.

Example in Python: To apply this principle, we can introduce an abstraction for payment processing rather than directly depending on classes like CreditCardPayment or PayPalPayment.

# Abstract payment processor interface
class PaymentProcessor:
    def process(self, order):
        raise NotImplementedError


# Credit card implementation
class CreditCardProcessor(PaymentProcessor):
    def process(self, order):
        print(f"Processing credit card payment of ${order.total_amount}")


# Class that handles the order
class OrderService:
    def __init__(self, payment_processor: PaymentProcessor):
        self.payment_processor = payment_processor

    def process_order(self, order):
        print("Processing order...")
        self.payment_processor.process(order)

In this example, OrderService doesn’t depend on a concrete payment implementation, but rather on the PaymentProcessor abstraction. This allows us to change the payment method without modifying the OrderService class.

Conclusion

Software design is a crucial discipline for developing clean, scalable, and maintainable applications. By following principles such as SRP, OCP, LSP, ISP, and DIP, we can write more modular, flexible, and robust code. Through practical examples in Python, we’ve illustrated how to apply these principles in real-world projects.

Adopting these principles not only improves the quality of our code but also facilitates teamwork and the evolution of applications over time. If you want to create high-quality software, incorporating these principles into your daily development practices is essential.

Link Repository : https://github.com/Marant7/desingprinciples

Data Mapper Pattern in Enterprise Application Architecture

Marant7 — Sun, 27 Apr 2025 20:08:30 +0000

Introduction

In the book "Patterns of Enterprise Application Architecture", Martin Fowler introduces the Data Mapper pattern, a crucial technique for applications that require a clean separation between business logic and data persistence.

While other patterns (like Active Record) mix business logic and database operations into a single object, Data Mapper enforces a clear separation.

What is the Data Mapper Pattern?

The Data Mapper pattern:

Maps domain objects to database structures and vice versa.
Keeps business objects unaware of how their data is stored or retrieved.
Enables better scaling for large enterprise applications.

Benefits:

High separation of concerns.
Easier unit testing of business logic.
Simplifies switching database technologies (e.g., from SQLite to PostgreSQL).

Real-world Example in Python

Without DataMapper

import sqlite3

class Product:
    def __init__(self, id, name, price):
        self.id = id
        self.name = name
        self.price = price
        self.connection = sqlite3.connect("database.db") 
    def save(self):

        cursor = self.connection.cursor()
        cursor.execute('''INSERT INTO products (id, name, price) VALUES (?, ?, ?)''',
                       (self.id, self.name, self.price))
        self.connection.commit()

    @classmethod
    def find(cls, product_id):

        connection = sqlite3.connect("database.db")  
        cursor = connection.cursor()
        cursor.execute('''SELECT * FROM products WHERE id = ?''', (product_id,))
        row = cursor.fetchone()
        if row:
            return Product(row[0], row[1], row[2])
        return None

    @classmethod
    def list_all(cls):

        connection = sqlite3.connect("database.db")
        cursor = connection.cursor()
        cursor.execute('''SELECT * FROM products''')
        rows = cursor.fetchall()
        return [Product(row[0], row[1], row[2]) for row in rows]

Imagine we want to manage a collection of products for a store. We'll use:

A domain model Product.
A mapper class ProductMapper.
A simple SQLite database for persistence.

1. Domain Model (`domain/product.py`)

class Product:
    def __init__(self, product_id: int, name: str, price: float):
        self.product_id = product_id
        self.name = name
        self.price = price

    def __repr__(self):
        return f"Product(id={self.product_id}, name='{self.name}', price={self.price})"

2. Data Mapper (`mappers/product_mapper.py`)

import sqlite3
from app.domain.product import Product

class ProductMapper:
    def __init__(self, connection: sqlite3.Connection):
        self.connection = connection
        self._create_table()

    def _create_table(self):
        cursor = self.connection.cursor()
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS products (
                product_id INTEGER PRIMARY KEY,
                name TEXT NOT NULL,
                price REAL NOT NULL
            )
        ''')
        self.connection.commit()

    def insert(self, product: Product):
        cursor = self.connection.cursor()
        cursor.execute('''
            INSERT INTO products (product_id, name, price) VALUES (?, ?, ?)
        ''', (product.product_id, product.name, product.price))
        self.connection.commit()

    def find(self, product_id: int) -> Product:
        cursor = self.connection.cursor()
        cursor.execute('SELECT product_id, name, price FROM products WHERE product_id = ?', (product_id,))
        row = cursor.fetchone()
        if row:
            return Product(*row)
        return None

    def list_all(self):
        cursor = self.connection.cursor()
        cursor.execute('SELECT product_id, name, price FROM products')
        rows = cursor.fetchall()
        return [Product(*row) for row in rows]

3.Using the Mapper (`main.py`)

import sqlite3
from app.domain.product import Product
from app.mappers.product_mapper import ProductMapper

def main():
    connection = sqlite3.connect(":memory:")  # In-memory database for testing
    mapper = ProductMapper(connection)

    # Inserting products
    mapper.insert(Product(1, "Laptop", 999.99))
    mapper.insert(Product(2, "Smartphone", 499.50))

    # Listing products
    products = mapper.list_all()
    for product in products:
        print(product)

    # Finding a product
    product = mapper.find(1)
    print(f"Found product: {product}")

if __name__ == "__main__":
    main()

4. Testing with Python (`tests/test_product_mapper.py`)

import unittest
import sqlite3
from app.domain.product import Product
from app.mappers.product_mapper import ProductMapper

class TestProductMapper(unittest.TestCase):
    def setUp(self):
        self.connection = sqlite3.connect(":memory:")
        self.mapper = ProductMapper(self.connection)

    def test_insert_and_find(self):
        product = Product(1, "Tablet", 299.99)
        self.mapper.insert(product)
        found = self.mapper.find(1)
        self.assertIsNotNone(found)
        self.assertEqual(found.name, "Tablet")

    def test_list_all(self):
        self.mapper.insert(Product(1, "Tablet", 299.99))
        self.mapper.insert(Product(2, "Monitor", 199.99))
        products = self.mapper.list_all()
        self.assertEqual(len(products), 2)

if __name__ == "__main__":
    unittest.main()

Conclusion

The Data Mapper pattern is an excellent choice for applications that prioritize business logic independence from database concerns.
By separating responsibilities, it enables easier evolution of the system, integration of caching layers, database migrations, and safe refactoring without impacting business logic.

Adopting patterns like Data Mapper will help you build cleaner, more robust, and scalable enterprise software.

link repository: https://github.com/Marant7/datamapperpython.git

Creating an Interactive Dashboard and Reports with Streamlit

Marant7 — Fri, 25 Apr 2025 17:38:33 +0000

Creating an Interactive Dashboard and Reports with Streamlit

Data visualization is essential for understanding patterns, making informed decisions, and sharing insights with others. With tools like Streamlit, it’s possible to quickly create interactive dashboards and generate reports, without needing advanced web development skills. In this article, we'll explore how to build an interactive dashboard that shows multiple visualizations and generates dynamic reports.

Why Use Streamlit for Dashboards and Reports?

Streamlit is an open-source tool designed to quickly create interactive web applications with just a few lines of Python code. It’s ideal for building visual dashboards and generating reports with minimal effort. Some of the benefits of using Streamlit include:

Fast prototyping: Dashboards can be built in minutes.
Interactivity: Allows adding interactive elements like sliders, dropdown menus, charts, and more.
Easy sharing: Applications can be deployed on platforms like Streamlit Cloud, making it easy to share results with others.

Practical Example: Online Store Sales Dashboard

In this example, we will create an interactive dashboard that shows sales data for an online store and generates a dynamic sales report. The application will include various visualizations like bar and line charts, and users will be able to select a date range to filter the data.

Step 1: Install Streamlit and Other Dependencies

If you don’t have Streamlit installed yet, you can do so with the following command:

pip install streamlit pandas matplotlib

Step 2: Write the Dashboard and Report Code

Here is the code to create an interactive Streamlit app that shows sales data for an online store and generates a report dynamically:

import streamlit as st
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# Dashboard title
st.title("Online Store Sales Dashboard")

# Simulating some sales data
np.random.seed(0)
dates = pd.date_range(start='2023-01-01', periods=100, freq='D')
sales = np.random.randint(10, 100, size=100)
products = np.random.choice(['Product A', 'Product B', 'Product C'], size=100)

# Create DataFrame
df = pd.DataFrame({'Date': dates, 'Sales': sales, 'Product': products})

# Show the first few rows of the data
st.write("Sales Data:", df.head())

# Date filter
start_date = st.date_input('Start Date', df['Date'].min())
end_date = st.date_input('End Date', df['Date'].max())

# Filter data based on selected date range
filtered_df = df[(df['Date'] >= pd.to_datetime(start_date)) & (df['Date'] <= pd.to_datetime(end_date))]

# Show filtered data summary
st.write(f"Filtered data from {start_date} to {end_date}", filtered_df)

# Generate Charts

# Sales by Date chart
fig, ax = plt.subplots()
ax.plot(filtered_df['Date'], filtered_df['Sales'], label='Daily Sales', color='blue')
ax.set_title('Daily Sales')
ax.set_xlabel('Date')
ax.set_ylabel('Sales')
st.pyplot(fig)

# Sales by Product chart
sales_by_product = filtered_df.groupby('Product')['Sales'].sum()
fig2, ax2 = plt.subplots()
ax2.bar(sales_by_product.index, sales_by_product.values, color='green')
ax2.set_title('Sales by Product')
ax2.set_xlabel('Product')
ax2.set_ylabel('Sales')
st.pyplot(fig2)

# Generate Sales Report
st.subheader("Sales Report")

# Show sales summary
total_sales = filtered_df['Sales'].sum()
avg_sales = filtered_df['Sales'].mean()
best_selling_product = sales_by_product.idxmax()

# Display the report
st.write(f"Total Sales: {total_sales}")
st.write(f"Average Sales: {avg_sales:.2f}")
st.write(f"Best Selling Product: {best_selling_product}")

# Button to download the report as text
if st.button("Generate Text Report"):
    report = f"""
    Sales Report:
        Total Sales: {total_sales}
        Average Sales: {avg_sales:.2f}
        Best Selling Product: {best_selling_product}
    """
    st.text(report)

Explanation of the Code

Simulating Sales Data: In this example, we generate a DataFrame with simulated sales data using NumPy. This DataFrame contains columns for Date, Sales, and Product.
Date Filter: We use st.date_input() to allow the user to select a date range. The data is filtered based on the selected start and end dates.

Visualizations:

Daily Sales Chart: A line chart created with Matplotlib that shows sales over time.
Sales by Product Chart: A bar chart that displays total sales per product.

Sales Report:

We calculate total sales, average sales, and the best-selling product in the selected date range.
The "Generate Text Report" button displays the dynamic report in text format in the interface.

Step 3: Deploy the Dashboard on Streamlit Cloud

Once the code is written and tested locally, you can deploy your app to Streamlit Cloud to make it accessible from anywhere.

Upload the File to GitHub: Save your file, for example, app.py, in a GitHub repository.
Connect to Streamlit Cloud: Go to Streamlit Cloud and connect your GitHub account. Streamlit Cloud will allow you to link your repository and deploy the app.
Deploy the App: After linking the repository, Streamlit Cloud will automatically detect the app.py file and deploy the app.
Access the URL: Once deployed, Streamlit will provide a unique URL where you can access your dashboard and interactive report.

Conclusion

With Streamlit, you can create interactive dashboards and generate dynamic reports without much effort. In this example, we built an app that allows users to analyze sales data for an online store, view interactive charts, and generate a sales report based on selected date ranges.

This kind of tool is highly useful in business scenarios where data needs to be analyzed and shared quickly and effectively.

link repository: https://github.com/Marant7/streamlitpython.git
link deploy: https://apppython-nbtphi4eroakapphxggf2aj.streamlit.app/

Comprehensive Analysis of Testing Management Tools: A Practical Guide

Marant7 — Sun, 08 Dec 2024 08:11:59 +0000

Introduction

In today's software development ecosystem, test automation and efficient test management are fundamental pillars for ensuring code quality. This article provides an in-depth analysis of the main testing management tools, complemented with practical examples and real use cases.

1. GitHub Actions:

GitHub Actions is an automation tool integrated directly into GitHub. It allows you to automate development workflows, including testing, deployment, and other CI/CD tasks.

Main Features

Automated Events: Responds to events like push, pull_request, release, etc.
Runners: Availability of GitHub-hosted or self-hosted runners
Matrix Builds: Testing across multiple versions/operating systems
Secrets and Variables: Secure credentials management
Dependencies Cache: Execution time optimization

Detailed Example

name: Complete Tests

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main, develop ]

jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        node-version: [16.x, 18.x, 20.x]

    steps:
    - uses: actions/checkout@v3

    - name: Setup Node.js ${{ matrix.node-version }}
      uses: actions/setup-node@v3
      with:
        node-version: ${{ matrix.node-version }}
        cache: 'npm'

    - name: Install dependencies
      run: |
        npm ci
        npm install -g codecov

    - name: Run unit tests
      run: npm test -- --coverage

    - name: Upload coverage to Codecov
      uses: codecov/codecov-action@v3

    - name: Integration tests
      run: npm run test:integration

    - name: E2E tests
      run: npm run test:e2e

Advantages and Disadvantages

2. GitLab CI/CD

GitLab CI/CD is an integrated solution within the GitLab ecosystem that provides a complete continuous integration and deployment pipeline.

Key Features

Pipeline As Code: Configuration in .gitlab-ci.yml
Auto DevOps: Automatic CI/CD configuration
Container Registry: Integrated container registry
Environments: Development environment management
Review Apps: Automatic deployments for review

Practical Example

image: node:20

stages:
  - test
  - coverage
  - deploy

cache:
  paths:
    - node_modules/

unit_tests:
  stage: test
  script:
    - npm install
    - npm run test:unit
  artifacts:
    reports:
      junit: junit.xml

integration_tests:
  stage: test
  script:
    - npm run test:integration

coverage:
  stage: coverage
  script:
    - npm run test:coverage
  coverage: '/Lines\s*:\s*([0-9.]+)%/'
  artifacts:
    reports:
      coverage_report:
        coverage_format: cobertura
        path: coverage/cobertura-coverage.xml

deploy_staging:
  stage: deploy
  script:
    - npm run build
    - npm run deploy:staging
  environment:
    name: staging
  only:
    - develop

Advantages and Disadvantages

3. Jenkins

Jenkins is one of the oldest and most respected tools in the CI/CD world. It's highly customizable and supports virtually any type of automation.

Main Features

Pipeline as Code: Jenkinsfile in Groovy
Extensive Plugins: Thousands of plugins available
Distributed Builds: Support for distributed builds
Robust Security: Granular access control
Flexible Automation: Supports any language/platform

Jenkinsfile Example

pipeline {
    agent any

    tools {
        nodejs 'Node 20'
    }

    stages {
        stage('Preparation') {
            steps {
                git 'https://github.com/user/repo.git'
                sh 'npm install'
            }
        }

        stage('Testing') {
            parallel {
                stage('Unit') {
                    steps {
                        sh 'npm run test:unit'
                    }
                }
                stage('Integration') {
                    steps {
                        sh 'npm run test:integration'
                    }
                }
            }
        }

        stage('Coverage') {
            steps {
                sh 'npm run test:coverage'
                publishCoverage(
                    adapters: [coberturaAdapter('coverage/cobertura-coverage.xml')]
                )
            }
        }

        stage('Quality') {
            steps {
                sh 'npm run lint'
                sh 'npm run sonar'
            }
        }
    }

    post {
        always {
            junit '**/test-results.xml'
            cleanWs()
        }
    }
}

4. CircleCI

CircleCI is a cloud-native CI/CD platform that excels in parallel testing and configuration simplicity. It offers powerful features for modern development workflows and seamless cloud integration.

Main Features

Orbs: Reusable configuration packages
Docker Layer Caching: Speed up build times
SSH Debugging: Live build debugging
Resource Classes: Customizable compute resources
Test Splitting: Intelligent test parallelization

Practical Example

version: 2.1

orbs:
  node: circleci/node@5.0.0
  codecov: codecov/codecov@3.0.0

jobs:
  build-and-test:
    docker:
      - image: cimg/node:20.0
    steps:
      - checkout
      - node/install-packages
      - run:
          name: Run Tests
          command: npm run test
      - codecov/upload

  integration:
    docker:
      - image: cimg/node:20.0
    steps:
      - checkout
      - node/install-packages
      - run:
          name: Integration Tests
          command: npm run test:integration

workflows:
  version: 2
  build-test-deploy:
    jobs:
      - build-and-test
      - integration:
          requires:
            - build-and-test

Advantages and Disadvantages

5. Travis CI

Travis CI is one of the pioneers in cloud-based CI/CD services. It's particularly well-known for its simplicity and excellent support for open-source projects.

Main Features

Build Matrix: Multi-version testing
Auto-deployment: Built-in deployment options
Caching: Dependency caching
Environment Variables: Secure variable management
Multi-OS Support: Linux, macOS, and Windows

Example Configuration

language: node_js
node_js:
  - 16
  - 18
  - 20

cache:
  directories:
    - node_modules

before_install:
  - npm install -g codecov

install:
  - npm ci

script:
  - npm run lint
  - npm run test
  - npm run build

jobs:
  include:
    - stage: test
      script: npm run test:unit
    - stage: integration
      script: npm run test:integration
    - stage: coverage
      script:
        - npm run test:coverage
        - codecov

deploy:
  provider: heroku
  api_key:
    secure: "YOUR-ENCRYPTED-API-KEY"
  on:
    branch: main

notifications:
  email:
    on_success: never
    on_failure: always

Advantages and Disadvantages

Comparison Table of All Tools

Selection Guide

Real Implementation Example

You can find a complete working example of these concepts in my repository:

https://github.com/Marant7/repository_github_actions

This implementation includes:

Basic Testing Suite

Calculator class with arithmetic operations
Input validators
User management service

Comprehensive Test Coverage

Unit tests for all components
Integration tests
Coverage reports

GitHub Actions Pipeline

Automated testing on push
Version 20.x Node.js testing
Coverage requirements enforcement

API Testing Frameworks

Marant7 — Sat, 23 Nov 2024 23:32:23 +0000

In modern software development, API testing is crucial for ensuring the reliability and quality of web services. Let's explore some of the most popular frameworks with practical code examples.

Rest-Assured: RESTful API Testing in Java

Rest-Assured stands out for its fluent and expressive syntax, ideal for REST API testing in Java.

@Test
public void testGetUsers() {
    given()
        .header("Content-Type", "application/json")
    .when()
        .get("https://api.example.com/users")
    .then()
        .statusCode(200)
        .body("users.size()", greaterThan(0))
        .body("users[0].name", notNullValue());
}

@Test
public void testCreateUser() {
    User user = new User("John", "john@email.com");

    given()
        .body(user)
        .contentType(ContentType.JSON)
    .when()
        .post("https://api.example.com/users")
    .then()
        .statusCode(201)
        .body("id", notNullValue())
        .body("name", equalTo("John"));
}

Postman: Codeless Testing

Postman allows creating automated tests using JavaScript in its graphical interface:

// Test to verify successful response and data structure
pm.test("Status code is 200", function () {
    pm.response.to.have.status(200);
});

pm.test("Response contains correct data", function () {
    var jsonData = pm.response.json();

    pm.expect(jsonData).to.have.property('users');
    pm.expect(jsonData.users).to.be.an('array');
    pm.expect(jsonData.users[0]).to.have.property('id');
    pm.expect(jsonData.users[0]).to.have.property('name');
});

// Test to validate JSON schema
var schema = {
    "type": "object",
    "properties": {
        "id": { "type": "number" },
        "name": { "type": "string" },
        "email": { "type": "string" }
    },
    "required": ["id", "name", "email"]
};

pm.test("Schema is valid", function() {
    var jsonData = pm.response.json();
    pm.expect(tv4.validate(jsonData, schema)).to.be.true;
});

Karate DSL: Simplified BDD Testing

Karate DSL allows writing tests in Gherkin format without requiring step definitions:

Feature: User API Tests

Background:
    * url 'https://api.example.com'
    * header Accept = 'application/json'

Scenario: Get list of users
    Given path 'users'
    When method get
    Then status 200
    And match response == '#array'
    And match each response contains { id: '#number', name: '#string' }

Scenario: Create new user
    Given path 'users'
    And request { name: 'Anna', email: 'anna@email.com' }
    When method post
    Then status 201
    And match response contains { id: '#number', name: 'Anna' }

PyRestTest: YAML Testing

PyRestTest allows defining tests in YAML files, making them more readable:

- config:
    - testset: "User API Tests"
    - base_url: "https://api.example.com"

- test:
    - name: "Get users"
    - url: "/users"
    - method: "GET"
    - headers: {'Content-Type': 'application/json'}
    - validators:
        - compare: {header: "status_code", comparator: "eq", expected: 200}
        - json_schema: {schema: {type: "array"}}

- test:
    - name: "Create user"
    - url: "/users"
    - method: "POST"
    - body: '{"name": "Charles", "email": "charles@email.com"}'
    - headers: {'Content-Type': 'application/json'}
    - validators:
        - compare: {header: "status_code", comparator: "eq", expected: 201}
        - compare: {jsonpath_mini: "name", comparator: "eq", expected: "Charles"}

JMeter: Performance and Functional Testing

While JMeter is known for load testing, it can also perform functional API testing:

<?xml version="1.0" encoding="UTF-8"?>
<jmeterTestPlan version="1.2">
  <hashTree>
    <HTTPSamplerProxy>
      <stringProp name="HTTPSampler.domain">api.example.com</stringProp>
      <stringProp name="HTTPSampler.path">/users</stringProp>
      <stringProp name="HTTPSampler.method">GET</stringProp>
      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>

      <HeaderManager>
        <collectionProp name="HeaderManager.headers">
          <elementProp name="">
            <stringProp name="Header.name">Content-Type</stringProp>
            <stringProp name="Header.value">application/json</stringProp>
          </elementProp>
        </collectionProp>
      </HeaderManager>

      <JSONPathAssertion>
        <stringProp name="JSON_PATH">$[0].id</stringProp>
        <stringProp name="EXPECTED_VALUE">1</stringProp>
        <boolProp name="JSONVALIDATION">true</boolProp>
      </JSONPathAssertion>
    </HTTPSamplerProxy>
  </hashTree>
</jmeterTestPlan>

Conclusions and Best Practices

Each framework has its particular strengths:

Rest-Assured: Excellent for Java teams needing TestNG/JUnit integration
Postman: Ideal for quick testing and teams with less programming experience
Karate DSL: Perfect for teams using BDD methodology
PyRestTest: Good option for simple tests with YAML configuration
JMeter: Optimal when combining functional and performance testing

Recommendations:

Test Independence: Each test should be able to run in isolation
Test Data: Use specific test data, not production data
Complete Assertions: Verify not just status codes, but also response structure and content
Documentation: Keep examples and documentation up to date
Continuous Integration: Incorporate tests into the CI/CD pipeline

Applying SAST Tools to Any Application

Marant7 — Thu, 03 Oct 2024 06:27:53 +0000

Applying CodeQL to Your Application
CodeQL is a powerful static analysis tool developed by GitHub, used for finding security vulnerabilities in code by turning it into a queryable database. This flexibility allows developers to write custom queries to identify vulnerabilities specific to their application.

Why CodeQL?
Customizable Queries: CodeQL allows you to create or modify queries to detect specific patterns or vulnerabilities in your codebase.
Integration with GitHub Actions: It’s easily integrated into CI/CD pipelines, allowing for continuous security testing as part of the development process.
Broad Language Support: CodeQL supports various languages, including JavaScript, Python, Go, C++, and Java, making it versatile for different types of projects.
CodeQL Workflow
Here’s a basic workflow for applying CodeQL to your application:

Set Up CodeQL in Your Project If you are using GitHub, you can enable CodeQL analysis through GitHub Actions. Navigate to the Security tab in your repository and choose "Set up CodeQL". GitHub will create a .github/workflows/codeql-analysis.yml file in your repository.
Configure the CodeQL Workflow In the codeql-analysis.yml, you can configure which languages CodeQL should analyze. For example:

jobs:
  analyze:
    strategy:
      matrix:
        language: [ 'javascript', 'python' ] # Add the languages you're using

Set the repository paths and branches for scanning. By default, CodeQL runs on pull requests and pushes to the main branch.
. Run the Analysis
Once the workflow is set up, CodeQL will automatically run on each pull request or push event.
During the CI/CD process, it converts your code into a queryable database and runs a set of predefined queries to detect vulnerabilities like SQL injection, buffer overflows, or unsafe data handling.

Review the Results After the scan, CodeQL generates a report with vulnerabilities found. You can access this in the Security tab of your repository on GitHub. Each finding includes details about the vulnerability, its location in the code, and recommended fixes.
Custom Queries (Optional) If you want to write custom rules for specific vulnerabilities, you can create a .ql query file. These custom queries can target unique business logic vulnerabilities or coding patterns. For example, a custom query to find unsafe string concatenation for SQL commands:

import javascript
from FunctionCall f
where f.getMethod().getName() = "concat" and f.getArgument(0).getType() = "SQLQuery"
select f, "Unsafe SQL concatenation found"

Continuous Monitoring CodeQL continues scanning each new code change as part of your CI/CD pipeline, ensuring that no new vulnerabilities are introduced. Conclusion By integrating CodeQL into your development pipeline, you can proactively catch security issues and enforce security best practices. With its customizable queries, CodeQL offers a powerful way to tailor security scanning to the specific needs of your project, ensuring robust code security throughout the development process.

Applying the Data Mapper Pattern in a Real-World Application

Marant7 — Sat, 21 Sep 2024 10:40:25 +0000

Introduction
The Patterns of Enterprise Application Architecture (PEAA), as described by Martin Fowler, provides a set of reusable solutions to common problems in enterprise software development. One of these patterns is the Data Mapper, which is widely used for separating the domain logic from the database access logic. This article will present a real-world example applying the Data Mapper pattern, highlighting its benefits and the problems it solves.

Overview of the Data Mapper Pattern
The Data Mapper pattern is used to map objects in an application's domain model to records in a database. It provides a layer of separation, ensuring that the domain objects do not need to know about the database structure or the way data is stored. This separation makes the codebase more maintainable and testable, allowing the domain logic to evolve independently from the database.

Real-World Example: Implementing a Data Mapper in a Customer Management System
Let's consider a simple Customer Management System where we have to manage customers' data using a relational database. Instead of tightly coupling the Customer object with database operations, we will use a Data Mapper to handle the conversion between the database rows and the domain objects.

Step 1: Define the Domain Model
First, we define a Customer class that represents our domain model:

public class Customer
{
public int Id { get; private set; }
public string FirstName { get; private set; }
public string LastName { get; private set; }
public string Email { get; private set; }

public Customer(int id, string firstName, string lastName, string email)
{
    Id = id;
    FirstName = firstName;
    LastName = lastName;
    Email = email;
}

public void UpdateEmail(string newEmail)
{
    Email = newEmail;
}
}

The Customer class encapsulates all the business logic and data related to a customer.

Step 2: Create the Data Mapper
The Data Mapper class, CustomerDataMapper, is responsible for handling the database interactions and mapping them to the Customer object.

using System.Data.SqlClient;

public class CustomerDataMapper
{
private readonly string _connectionString;

public CustomerDataMapper(string connectionString)
{
    _connectionString = connectionString;
}

public Customer FindById(int id)
{
    using (var connection = new SqlConnection(_connectionString))
    {
        connection.Open();
        var command = new SqlCommand("SELECT Id, FirstName, LastName, Email FROM Customers WHERE Id = @Id", connection);
        command.Parameters.AddWithValue("@Id", id);

        using (var reader = command.ExecuteReader())
        {
            if (reader.Read())
            {
                return new Customer(
                    (int)reader["Id"],
                    reader["FirstName"].ToString(),
                    reader["LastName"].ToString(),
                    reader["Email"].ToString()
                );
            }
        }
    }

    return null;
}

public void Insert(Customer customer)
{
    using (var connection = new SqlConnection(_connectionString))
    {
        connection.Open();
        var command = new SqlCommand(
            "INSERT INTO Customers (FirstName, LastName, Email) VALUES (@FirstName, @LastName, @Email); SELECT SCOPE_IDENTITY();",
            connection);

        command.Parameters.AddWithValue("@FirstName", customer.FirstName);
        command.Parameters.AddWithValue("@LastName", customer.LastName);
        command.Parameters.AddWithValue("@Email", customer.Email);

        var id = Convert.ToInt32(command.ExecuteScalar());
        typeof(Customer).GetProperty("Id").SetValue(customer, id, null);
    }
}

public void Update(Customer customer)
{
    using (var connection = new SqlConnection(_connectionString))
    {
        connection.Open();
        var command = new SqlCommand(
            "UPDATE Customers SET FirstName = @FirstName, LastName = @LastName, Email = @Email WHERE Id = @Id",
            connection);

        command.Parameters.AddWithValue("@Id", customer.Id);
        command.Parameters.AddWithValue("@FirstName", customer.FirstName);
        command.Parameters.AddWithValue("@LastName", customer.LastName);
        command.Parameters.AddWithValue("@Email", customer.Email);

        command.ExecuteNonQuery();
    }
}
}

In this example, the CustomerDataMapper is responsible for converting database rows into Customer objects (FindById method) and converting Customer objects into rows (Insert and Update methods).

Step 3: Utilizing the Data Mapper in Business Logic
Now that we have the Customer and CustomerDataMapper classes, the application can utilize the Data Mapper pattern to handle database interactions cleanly.

public class CustomerService
{
private readonly CustomerDataMapper _customerDataMapper;

public CustomerService(string connectionString)
{
    _customerDataMapper = new CustomerDataMapper(connectionString);
}

public Customer GetCustomerById(int id)
{
    return _customerDataMapper.FindById(id);
}

public void RegisterNewCustomer(string firstName, string lastName, string email)
{
    var customer = new Customer(0, firstName, lastName, email);
    _customerDataMapper.Insert(customer);
}

public void UpdateCustomerEmail(int customerId, string newEmail)
{
    var customer = _customerDataMapper.FindById(customerId);
    if (customer != null)
    {
        customer.UpdateEmail(newEmail);
        _customerDataMapper.Update(customer);
    }
}
}

Benefits of Using the Data Mapper Pattern
Separation of Concerns: The domain model (Customer) is independent of database concerns, allowing cleaner and more maintainable code.
Testability: Since the database access is handled by a separate class, the domain model can be easily unit-tested without needing a database connection.
Scalability: Changes in the database schema do not affect the domain model directly, making it easier to adapt to evolving requirements.
Conclusion
The Data Mapper pattern is an effective solution for decoupling domain logic from database access, resulting in more maintainable, testable, and scalable code. It is particularly useful in applications where the domain logic is complex and needs to be kept separate from infrastructure concerns.

Deploy a Java application using Spring Boot on Google Cloud

Marant7 — Thu, 04 Jul 2024 23:15:33 +0000

Google Cloud offers many other features that you can configure, such as databases, storage, monitoring, and more.

Use Google App Engine, which is a serverless platform that makes it easy to deploy and automatically scale applications. Next, I'll show you how to do it.

Step 1: Set up your environment

Install Google Cloud SDK: If you don't have it installed yet, follow the instructions here.
Initialize Google Cloud SDK: Set up your Google Cloud environment by running:

gcloud init

Install the App Engine plugin:

gcloud components install app-engine-java

Step 2: Create a Spring Boot Application

Create a Spring Boot project:

o Project: Maven Project
o Language: Java
o Spring Boot: 2.5.x
o Project Metadata: Enter the name of your group, artifact, and other details.
o Dependencies: Add Spring Web.

Then, build the project and download the ZIP file. Unzip the file on your machine.

Create the Spring Boot application: Open your project in your favorite IDE
Create a simple controller: In the directory

src/main/java/com/example/demo (adjust according to your structure), create a file called HelloController.java with the following content:

package com.example.demo;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

@GetMapping("/")
public String hello() {
    return "Hello, World!";
}

}

Make sure the application runs: Run your application with the mvn spring-boot:run command and verify that you can access http://localhost:8080 and see the "Hello, World!" message

Step 3: Prepare your app for App Engine

Create the app.yaml file: In the root directory of your project, create a file called app.yaml with the following content: runtime: java11 instance_class: F1

This file tells App Engine to use the Java 11 runtime.

Package your application: Build your application to generate the executable JAR file. Use the Java 11 runtime environment.

mvn clean package

Step 4: Deploy the app to Google App Engine

1.Deploy the application:

gcloud app deploy target/demo-0.0.1-SNAPSHOT.jar

Follow the instructions and confirm the deployment when prompted.

2.Abrir la aplicación:

gcloud app browse

Tu aplicación Spring Boot ahora debería estar desplegada en Google App Engine. Puedes actualizar el código y redeployar usando el mismo comando gcloud app deploy.

Api Architecture Styles using GraphQL

Marant7 — Wed, 12 Jun 2024 23:22:06 +0000

Applications need data to function, these are in a database within a server
They have a client which is the view and a server where the data logic is.
both communicate through an API, the best known is REST

Graphql allow queries to be made on the client side, not on the server side, it is like doing sql on the frontend.

It can be integrated with multiple Backend programming languages such as Javascript (Nodejs), Python, etc.

1.On the client it is a SQL-type query language.
2.The server is an execution environment, it processes the query.

THIS IS EXAMPLE

Understanding how programming works using Functors, Monads, and Promises

Marant7 — Thu, 18 Apr 2024 22:08:32 +0000

1.FUNCTORS

Functors are data structures that can be mapped over with a function. This means you can apply a function to the values inside a functor, producing a new functor with the transformed values.

2.Promises

Promises are a fundamental concept in asynchronous programming in JavaScript. They represent the eventual completion (or failure) of an asynchronous operation and allow handling its result asynchronously. A promise can be in one of three states: pending, fulfilled, or rejected. When a promise is fulfilled, it means the asynchronous operation has successfully completed, and you can access the result using .then(). If it's rejected, it means an error occurred, and you can handle it using .catch(). Promises are chainable, which means you can use .then() to chain asynchronous operations one after another, facilitating sequential execution in an asynchronous environment.

3.Monads
Monads are structures in functional programming that facilitate handling side effects and function composition. They have two main operations: unit, which wraps a value in a monad, and bind, which allows chaining operations while handling the monadic context. Monads provide a way to encapsulate values with side effects or values that can be null, avoiding common issues such as null or undefined.

DEV Community: Marant7

Your First MCP Server in Python: Connect Custom Tools to Claude🚀

What is MCP? 🤔

Quick Setup 🛠️

The Code: 2 Tools in 30 Lines 🎯

Connect with Claude Desktop 🤖

Key Concepts 📚

Tools vs Prompts

When to use each?

Real-World Use Cases 🎯

Common Troubleshooting 🔧

What's Next? 🚀

MCP #AI

Observability Practices with Python, Prometheus, and Grafana

Observability Practices with a Real-World Example

What is Observability?

Real-World Example: Python, Prometheus, and Grafana

Diagram

Example Code

Prometheus Configuration (prometheus.yml)

Docker Compose Example

Grafana Queries

Prometheus

Dashboard Example

Why is this important?

How to Try It Yourself

Conclusion

Link : https://github.com/Marant7/demo-observabilty-practice

Software Design Principles: A Practical Approach with Python

Software Design Principles

1. Single Responsibility Principle (SRP)

2. Open/Closed Principle (OCP)

3.Liskov Substitution Principle (LSP)

4. Interface Segregation Principle (ISP)

5. Dependency Inversion Principle (DIP)

Conclusion

Data Mapper Pattern in Enterprise Application Architecture

Introduction

What is the Data Mapper Pattern?

Benefits:

Real-world Example in Python

Without DataMapper

1. Domain Model (domain/product.py)

2. Data Mapper (mappers/product_mapper.py)

3.Using the Mapper (main.py)

4. Testing with Python (tests/test_product_mapper.py)

Conclusion

Creating an Interactive Dashboard and Reports with Streamlit

Creating an Interactive Dashboard and Reports with Streamlit

Why Use Streamlit for Dashboards and Reports?

Practical Example: Online Store Sales Dashboard

Step 1: Install Streamlit and Other Dependencies

Step 2: Write the Dashboard and Report Code

Explanation of the Code

Visualizations:

Sales Report:

Step 3: Deploy the Dashboard on Streamlit Cloud

Conclusion

Comprehensive Analysis of Testing Management Tools: A Practical Guide

API Testing Frameworks

Applying SAST Tools to Any Application

Applying the Data Mapper Pattern in a Real-World Application

Deploy a Java application using Spring Boot on Google Cloud

Api Architecture Styles using GraphQL

Understanding how programming works using Functors, Monads, and Promises

1. Domain Model (`domain/product.py`)

2. Data Mapper (`mappers/product_mapper.py`)

3.Using the Mapper (`main.py`)

4. Testing with Python (`tests/test_product_mapper.py`)