Merge branch '2025-anti'

Author: egges

2025/anti/abstraction.py

@@ -0,0 +1,98 @@
+import json
+from dataclasses import dataclass
+from typing import Callable, Protocol
+
+
+@dataclass
+class Report:
+    title: str
+    content: str
+
+    def to_csv(self) -> str:
+        return f"{self.title}, {self.content}\n"
+
+    def to_json(self) -> str:
+        return json.dumps(
+            {
+                "title": self.title,
+                "content": self.content,
+            },
+            indent=4,
+        )
+
+
+@dataclass
+class Budget:
+    title: str
+    amount: float
+
+    def to_csv(self) -> str:
+        return f"{self.title}, {self.amount}\n"
+
+    def to_json(self) -> str:
+        return json.dumps(
+            {
+                "title": self.title,
+                "amount": self.amount,
+            },
+            indent=4,
+        )
+
+
+type ExportFn = Callable[[str, Exportable], None]
+
+
+class Exportable(Protocol):
+    def to_csv(self) -> str: ...
+
+    def to_json(self) -> str: ...
+
+
+def export_to_csv(filename: str, data: Exportable) -> None:
+    print("Exporting to CSV...")
+    with open(filename, "w") as f:
+        f.write(data.to_csv())
+    print("Done.")
+
+
+def export_to_json(filename: str, data: Exportable) -> None:
+    print("Exporting to JSON...")
+    with open(filename, "w") as f:
+        json.dump(data.to_json(), f)
+    print("Done.")
+
+
+EXPORTERS = {
+    "csv": export_to_csv,
+    "json": export_to_json,
+}
+
+
+def get_exporter(format: str) -> ExportFn:
+    """Factory function to get the appropriate exporter function based on format string."""
+    if format in EXPORTERS:
+        return EXPORTERS[format]
+    else:
+        raise ValueError(f"Unsupported export format: {format}")
+
+
+def main() -> None:
+    report = Report(
+        title="Quarterly Earnings",
+        content="Here are the earnings for the last quarter...",
+    )
+
+    export_fn = get_exporter("json")
+    export_fn("report.json", report)
+
+    budget = Budget(
+        title="Annual Budget",
+        amount=1000000.00,
+    )
+
+    export_fn = get_exporter("json")
+    export_fn("budget.json", budget)
+
+
+if __name__ == "__main__":
+    main()

2025/anti/config.json

@@ -0,0 +1,5 @@
+{
+    "learning_rate": 0.01,
+    "batch_size": 32,
+    "epochs": 10
+}

2025/anti/data_processing.py

@@ -0,0 +1,24 @@
+import pandas as pd
+
+
+def fill_missing_values(df: pd.DataFrame) -> pd.DataFrame:
+    """Fill missing numeric values with the median of each column."""
+    return df.fillna(df.median(numeric_only=True))
+
+
+def normalize_columns(df: pd.DataFrame, columns: list[str]) -> pd.DataFrame:
+    """Min-max normalize specified columns in the DataFrame."""
+    df = df.copy()
+    for col in columns:
+        min_val = df[col].min()
+        max_val = df[col].max()
+        if min_val == max_val:
+            df[col] = 0.0  # avoid division by zero
+        else:
+            df[col] = (df[col] - min_val) / (max_val - min_val)
+    return df
+
+
+def encode_categorical(df: pd.DataFrame, columns: list[str]) -> pd.DataFrame:
+    """Convert categorical columns into one-hot encoded columns."""
+    return pd.get_dummies(df, columns=columns, drop_first=True)

2025/anti/decorator_inject_after.py

@@ -0,0 +1,17 @@
+import json
+from typing import Any
+
+
+def load_config(file_name: str) -> dict[str, Any]:
+    """Load configuration from the specified file."""
+    with open(file_name, "r") as f:
+        return json.load(f)
+
+
+def main() -> None:
+    config = load_config("config.json")
+    print(f"Training with config: {config}")
+
+
+if __name__ == "__main__":
+    main()

2025/anti/decorator_inject_before.py

@@ -0,0 +1,30 @@
+import json
+from functools import wraps
+from typing import Any, Callable
+
+
+def load_config(file_name: str) -> dict[str, Any]:
+    """Load configuration from the specified file."""
+    with open(file_name, "r") as f:
+        return json.load(f)
+
+
+def inject_config(file_name: str) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        @wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            config: dict[str, Any] = load_config(file_name)
+            return func(config, *args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+@inject_config("config.json")
+def main(config: dict[str, Any]) -> None:
+    print(f"Training with config: {config}")
+
+
+if __name__ == "__main__":
+    main()

2025/anti/exception_control_flow_after.py

@@ -0,0 +1,39 @@
+import random
+import time
+
+
+# Simulated API call that randomly succeeds or times out
+def fetch_from_primary_api(city: str) -> dict[str, str]:
+    if simulate_timeout():
+        return {"status": "error", "message": "Primary API timed out."}
+    return {"status": "success", "data": f"Weather in {city} is sunny."}
+
+
+def fetch_from_backup_api(city: str) -> dict[str, str]:
+    if simulate_timeout():
+        return {"status": "error", "message": "Backup API timed out."}
+    return {"status": "success", "data": f"Backup: Weather in {city} is cloudy."}
+
+
+def simulate_timeout() -> bool:
+    time.sleep(0.2)  # network delay
+    return random.random() < 0.5
+
+
+# Good: using return values for expected control flow
+def get_weather_forecast(city: str) -> dict[str, str]:
+    result = fetch_from_primary_api(city)
+    if result["status"] == "error":
+        result = fetch_from_backup_api(city)
+    if result["status"] == "error":
+        return {"status": "error", "message": "Both APIs timed out."}
+    return result
+
+
+def main():
+    result = get_weather_forecast("New York")
+    print(result)
+
+
+if __name__ == "__main__":
+    main()

2025/anti/exception_control_flow_before.py

@@ -0,0 +1,40 @@
+import random
+import time
+
+
+# Simulated API call that randomly succeeds or times out
+def fetch_from_primary_api(city: str) -> dict[str, str]:
+    if simulate_timeout():
+        raise TimeoutError("Primary API timed out.")
+    return {"status": "success", "data": f"Weather in {city} is sunny."}
+
+
+def fetch_from_backup_api(city: str) -> dict[str, str]:
+    if simulate_timeout():
+        raise TimeoutError("Backup API timed out.")
+    return {"status": "success", "data": f"Backup: Weather in {city} is cloudy."}
+
+
+def simulate_timeout() -> bool:
+    time.sleep(0.2)  # network delay
+    return random.random() < 0.5
+
+
+# Bad: using exceptions for expected control flow
+def get_weather_forecast(city: str) -> dict[str, str]:
+    try:
+        return fetch_from_primary_api(city)
+    except TimeoutError:
+        try:
+            return fetch_from_backup_api(city)
+        except TimeoutError:
+            return {"status": "error", "message": "Both APIs timed out."}
+
+
+def main():
+    result = get_weather_forecast("New York")
+    print(result)
+
+
+if __name__ == "__main__":
+    main()

2025/anti/hardcoded_after.py

@@ -0,0 +1,81 @@
+import io
+import json
+import os
+import zipfile
+
+import lokalise
+import numpy as np
+import pandas as pd
+import requests
+import streamlit as st
+from dotenv import load_dotenv
+
+load_dotenv()
+LOKALISE_API_KEY = os.getenv("LOKALISE_API_KEY")
+LOKALISE_PROJECT_ID = os.getenv("LOKALISE_PROJECT_ID")
+LANGUAGE = "nl"
+
+
+class LokaliseTranslator:
+    def __init__(self, api_key: str, project_id: str, language: str) -> None:
+        self.client = lokalise.Client(api_key)
+        self.project_id = project_id
+        self.language = language
+        self.translations = self.get_translations()
+
+    def get_translations(self) -> dict[str, str]:
+        response = self.client.download_files(
+            self.project_id,
+            {"format": "json", "original_filenames": True, "replace_breaks": False},
+        )
+        translations_url = response["bundle_url"]
+
+        # Download and extract the ZIP file
+        zip_response = requests.get(translations_url)
+        zip_file = zipfile.ZipFile(io.BytesIO(zip_response.content))
+
+        # Find the JSON file corresponding to the selected language
+        json_filename = f"{self.language}/no_filename.json"
+        with zip_file.open(json_filename) as json_file:
+            return json.load(json_file)
+
+    def __call__(self, key: str) -> str:
+        return self.translations.get(key, key)
+
+
+translator = LokaliseTranslator(LOKALISE_API_KEY, LOKALISE_PROJECT_ID, LANGUAGE)
+
+st.title(translator("dashboard_title"))
+
+DATE_COLUMN = "date/time"
+DATA_URL = (
+    "https://s3-us-west-2.amazonaws.com/streamlit-demo-data/uber-raw-data-sep14.csv.gz"
+)
+
+
+@st.cache_data
+def load_data(nrows):
+    data = pd.read_csv(DATA_URL, nrows=nrows)
+    data.rename(lambda x: str(x).lower(), axis="columns", inplace=True)
+    data[DATE_COLUMN] = pd.to_datetime(data[DATE_COLUMN])
+    return data
+
+
+data_load_state = st.text(translator("loading_data"))
+data = load_data(10000)
+data_load_state.text(translator("done"))
+
+if st.checkbox(translator("show_raw_data")):
+    st.subheader(translator("raw_data"))
+    st.write(data)
+
+st.subheader(translator("nb_pickups_hour"))
+hist_values = np.histogram(data[DATE_COLUMN].dt.hour, bins=24, range=(0, 24))[0]
+st.bar_chart(hist_values)
+
+# Some number in the range 0-23
+hour_to_filter = st.slider("hour", 0, 23, 17)
+filtered_data = data[data[DATE_COLUMN].dt.hour == hour_to_filter]
+
+st.subheader(translator("map_all_pickups") % hour_to_filter)
+st.map(filtered_data)

2025/anti/hardcoded_before.py

@@ -0,0 +1,39 @@
+import numpy as np
+import pandas as pd
+import streamlit as st
+
+# Hardcoded constants
+DATE_COLUMN = "date/time"
+DATA_URL = (
+    "https://s3-us-west-2.amazonaws.com/streamlit-demo-data/uber-raw-data-sep14.csv.gz"
+)
+
+
+@st.cache_data
+def load_data(nrows: int) -> pd.DataFrame:
+    data = pd.read_csv(DATA_URL, nrows=nrows)
+    data.rename(lambda x: str(x).lower(), axis="columns", inplace=True)
+    data[DATE_COLUMN] = pd.to_datetime(data[DATE_COLUMN])
+    return data
+
+
+# 🧨 All UI strings are hardcoded — even small changes are tedious
+st.title("Uber pickups in NYC")
+
+data_load_state = st.text("Loading data...")
+data = load_data(10000)
+data_load_state.text("Loading complete!")
+
+if st.checkbox("Show raw data"):
+    st.subheader("Raw data")
+    st.write(data)
+
+st.subheader("Number of pickups by hour")
+hist_values = np.histogram(data[DATE_COLUMN].dt.hour, bins=24, range=(0, 24))[0]
+st.bar_chart(hist_values)
+
+hour_to_filter = st.slider("Hour", 0, 23, 17)
+filtered_data = data[data[DATE_COLUMN].dt.hour == hour_to_filter]
+
+st.subheader(f"Map of all pickups at {hour_to_filter}:00")
+st.map(filtered_data)