Production deployment patterns

import random
import time
from dataclasses import dataclass, field
from typing import List, Dict


@dataclass
class Application:
    name: str
    source_repo: str
    target_revision: str
    synced: bool = False
    health_status: str = "Healthy"
    history: List[Dict] = field(default_factory=list)

    def sync(se…

How to Build a Simple Data Helper Class in Python

A beginner-friendly DataHelper class that stores Python dataclass objects as JSON records to disk, with load, add, and save methods.

dataclass json file-io

import json
from dataclasses import dataclass, asdict
from pathlib import Path

@dataclass
class User:
    name: str
    age: int
    email: str

class DataHelper:
    def __init__(self, filepath: str = "data.json"):
        self.filepath = Path(filepath)
        self._data = self._load()
    
    def _load(self) -> l…

12 0 Open

monitoring dataclass simulation

How to Build a Synthetic Monitor Mock in Python

Simulates a synthetic monitoring system in Python that collects latency samples, averages them, and reports service status as UP or DEGRADED.

import random
import time
from dataclasses import dataclass, field
from statistics import mean


@dataclass
class SyntheticMonitor:
    service: str
    endpoint: str
    latency_ms: list[float] = field(default_factory=list)

    def check(self) -> float:
        latency = random.uniform(50.0, 250.0)
        self.late…

Production deployment patterns medium

How to Mock Kubernetes Services with a ClusterIP Registry in Python

Simulate Kubernetes service discovery by assigning ClusterIP addresses to dataclass-defined services, with JSON export for inspection or testing.

kubernetes clusterip mock

import json
from dataclasses import dataclass, asdict
from typing import Dict, Optional


@dataclass
class Service:
    name: str
    namespace: str
    cluster_ip: str
    selector: Dict[str, str]
    port: int
    target_port: Optional[int] = None


class ClusterIPServiceRegistry:
    _ip_counter = 0

    def __init…

ci-cd simulation dataclasses

How to Mock a CI Pipeline with Build, Test, and Deploy Stages in Python

Simulate a three-stage CI pipeline (build, test, deploy) in Python with random pass/fail logic, early exit on failure, and measured stage durations.

import time
import random
from dataclasses import dataclass


@dataclass
class StageResult:
    name: str
    status: str
    duration: float


def run_stage(name: str, success_chance: float = 0.9) -> StageResult:
    """Simulate a pipeline stage with random success/failure."""
    start = time.time()
    time.sleep(r…

14 0 Open

dockerfile multi-stage simulation

How to Mock a Dockerfile Multi-Stage Build in Python

Simulate a Dockerfile multi-stage build process in Python using dataclasses to validate stage ordering and file availability before you write the real Dockerfile.

from dataclasses import dataclass
from pathlib import Path


@dataclass
class BuildStage:
    name: str
    base_image: str
    files: list[str]
    commands: list[str]


def run_build(stage: BuildStage, context_dir: Path):
    print(f"=== Stage: {stage.name} (base: {stage.base_image}) ===")
    for file in stage.file…

14 0 Open

feature-flags rollout deterministic

How to Mock a Feature Flag Rollout Percentage in Python

Simulate a percentage-based feature flag rollout by hashing a user ID to deterministically enable features for a subset of users.

import random
from dataclasses import dataclass


@dataclass
class FeatureFlag:
    name: str
    rollout_percentage: int


def is_feature_enabled(feature_flag: FeatureFlag, user_id: str) -> bool:
    hashed_id = hash(user_id) % 100
    return hashed_id < feature_flag.rollout_percentage


if __name__ == "__main__":
  …

11 0 Open

github-actions dataclasses mock

How to Mock a GitHub Actions Workflow in Python

Build a dataclass-based model of a GitHub Actions workflow and simulate its execution to validate steps and outputs before deployment.

import json
from dataclasses import dataclass, asdict
from typing import List, Dict, Any


@dataclass
class Step:
    name: str
    run: str


@dataclass
class Job:
    name: str
    steps: List[Step]
    runs_on: str = "ubuntu-latest"


@dataclass
class Workflow:
    name: str
    jobs: List[Job]

    def to_github_a…

dataclasses immutable configuration

How to Replace Fields in an Immutable Dataclass in Python

Create a new copy of a frozen dataclass with selected fields changed, leaving the original unchanged.

from dataclasses import dataclass, replace


@dataclass(frozen=True)
class ServerConfig:
    name: str
    cpu: int = 2
    ram: int = 4096
    tags: tuple = ()


original = ServerConfig("web-01", cpu=4, tags=("env:prod",))
updated = replace(original, ram=8192, tags=("env:prod", "region:us-east"))

print("Original:", …

15 0 Open

rollback deployment dataclass

How to Roll Back to a Previous Image Tag in Python

A dataclass-based mock registry that tracks image tag history and rolls back to the previous tag, useful for deployment rollback logic.

"""Demonstrates a rollback pattern for a Docker-style image tag registry."""

from dataclasses import dataclass, field


@dataclass
class ImageRegistry:
    """A minimal mock registry tracking current tags per image."""

    tags: dict[str, list[str]] = field(default_factory=dict)

    def push(self, image: str, tag: …