Legacy-code integrity tamper

import json
from datetime import datetime

def process_data(data):
    result = []
    for item in data:
        if item.get('value', 0) > 0:
            result.append({
                'id': item.get('id'),
                'processed': True,
                'timestamp': datetime.now().isoformat()
            })
    return result

def calculate_avg(nums):
    total = 0
    count = len(nums)
    for n in nums:
        total += n
    return total / count if count > 0 else 0

def filter_users(users, min_age=18):
    filtered = []
    for user in users:
        if user.get('age', 0) >= min_age:
            filtered.append(user)
    return filtered

def save_to_file(data, filename):
    with open(filename, 'w') as f:
        json.dump(data, f)
    return True

class DataStore:
    def __init__(self):
        self._data = {}

    def add(self, key, value):
        self._data[key] = value

    def get(self, key):
        return self._data.get(key)

    def remove(self, key):
        if key in self._data:
            del self._data[key]

def format_output(items):
    output = []
    for i, item in enumerate(items):
        output.append(f"{i+1}. {item}")
    return "\n".join(output)

"""
Legacy Code Module

This module provides utility functions for data processing, including:
- Processing data items with positive values
- Calculating average of numbers
- Filtering users by minimum age
- Saving data to JSON files
- A simple key-value DataStore class
- Formatting items for display output
"""

import json
from datetime import datetime


def process_data(data):
    """
    Process a list of data items, filtering for items with positive values.

    This function iterates through each item in the input data list and
    includes only those items where the 'value' key is greater than 0.
    Each included item is transformed into a new dictionary containing
    the original id, a processed flag, and a timestamp.

    Args:
        data: A list of dictionaries, each containing 'id' and optionally
              'value' keys. If 'value' is missing, it defaults to 0.

    Returns:
        A list of processed item dictionaries. Each dictionary contains:
        - 'id': The original id from the input item
        - 'processed': Boolean set to True
        - 'timestamp': ISO format timestamp of when processing occurred
    """
    result = []
    for item in data:
        # Use .get() with default of 0 to handle missing 'value' key safely.
        # This ensures missing values are treated as non-positive (excluded).
        if item.get('value', 0) > 0:
            result.append({
                # Preserve the original id from the input item
                'id': item.get('id'),
                # Mark this item as successfully processed
                'processed': True,
                # Record when this processing happened in ISO 8601 format
                'timestamp': datetime.now().isoformat()
            })
    return result


def calculate_avg(nums):
    """
    Calculate the arithmetic mean of a list of numbers.

    This function sums all numbers in the list and divides by the count.
    It handles the edge case of an empty list by returning 0.

    Args:
        nums: A list of numeric values (int or float).

    Returns:
        The average (mean) of the numbers as a float.
        Returns 0 if the list is empty to avoid division by zero.
    """
    total = 0
    count = len(nums)
    # Accumulate the sum by iterating through each number
    for n in nums:
        total += n
    # Use conditional expression to handle empty list case.
    # Dividing by zero would raise a ZeroDivisionError, so we return 0.
    return total / count if count > 0 else 0


def filter_users(users, min_age=18):
    """
    Filter a list of users based on their age.

    This function returns only users whose age is greater than or equal
    to the specified minimum age threshold.

    Args:
        users: A list of user dictionaries, each containing an 'age' key.
               If 'age' is missing, it defaults to 0 (younger than any
               reasonable minimum age).
        min_age: The minimum age requirement (inclusive). Defaults to 18.

    Returns:
        A list of user dictionaries that meet the age requirement.
    """
    filtered = []
    for user in users:
        # Use .get() with default of 0 for missing 'age' key.
        # This ensures users without an age specified are excluded
        # when min_age > 0 (the default case).
        if user.get('age', 0) >= min_age:
            filtered.append(user)
    return filtered


def save_to_file(data, filename):
    """
    Save data to a JSON file.

    This function serializes the provided data structure to JSON format
    and writes it to the specified file.

    Args:
        data: The data structure to serialize (must be JSON-serializable:
              dict, list, str, int, float, bool, or None).
        filename: The path to the output file.

    Returns:
        True indicating successful completion. Note: This function
        does not handle file I/O errors - caller should handle exceptions.
    """
    with open(filename, 'w') as f:
        json.dump(data, f)
    return True


class DataStore:
    """
    A simple in-memory key-value store.

    This class provides basic CRUD (Create, Read, Update, Delete)
    operations for storing and retrieving data in memory.
    The data persists only for the lifetime of the DataStore instance.

    Note:
        The internal _data attribute uses a leading underscore convention
        (_data) to indicate it is intended for internal use and should
        not be accessed directly from outside the class. This is a
        Python convention signaling "private" (though not enforced).
    """

    def __init__(self):
        """Initialize an empty DataStore with an internal dictionary."""
        # Initialize empty dictionary to store key-value pairs.
        # The underscore prefix (_data) follows Python convention to
        # indicate this is a "private" internal attribute.
        self._data = {}

    def add(self, key, value):
        """
        Add or update a key-value pair in the store.

        Args:
            key: The key to associate with the value (must be hashable).
            value: The value to store (can be any Python object).
        """
        self._data[key] = value

    def get(self, key):
        """
        Retrieve a value by its key.

        Args:
            key: The key to look up.

        Returns:
            The value associated with the key if found, otherwise None.
            Unlike dict.get(), there is no way to distinguish between
            a missing key and a key with value None.
        """
        return self._data.get(key)

    def remove(self, key):
        """
        Remove a key-value pair from the store if it exists.

        This method safely handles the case where the key does not exist
        by checking for membership before deletion.

        Args:
            key: The key to remove.
        """
        if key in self._data:
            del self._data[key]


def format_output(items):
    """
    Format a list of items as a numbered string list.

    This function takes a list of items and returns a single string
    where each item is on its own line, prefixed with its 1-based index.

    Args:
        items: A list of items to format. Each item will be converted
               to a string using f-string formatting.

    Returns:
        A single string with each item on its own line, numbered starting
        from 1, in the format "1. item\n2. item\n..."
    """
    output = []
    # Use enumerate to get both index (0-based) and item.
    # Add 1 to make the display 1-based (human-friendly).
    for i, item in enumerate(items):
        output.append(f"{i+1}. {item}")
    # Join all lines with newline characters to create the final output
    return "\n".join(output)

import json
from datetime import datetime

def process_data(data):
    result = []
    for item in data:
        if item.get('value', 0) > 0:
            result.append({
                'id': item.get('id'),
                'processed': True,
                'timestamp': datetime.now().isoformat()
            })
    return result

def calculate_avg(nums):
    total = 0
    count = len(nums)
    for n in nums:
        total += n
    return total / count if count > 0 else 0

def filter_users(users, min_age=18):
    filtered = []
    for user in users:
        if user.get('age', 0) >= min_age:
            filtered.append(user)
    return filtered

def save_to_file(data, filename):
    with open(filename, 'w') as f:
        json.dump(data, f)
    return True

class DataStore:
    def __init__(self):
        self._data = {}

    def add(self, key, value):
        self._data[key] = value

    def get(self, key):
        return self._data.get(key)

    def remove(self, key):
        if key in self._data:
            del self._data[key]

def format_output(items):
    output = []
    for i, item in enumerate(items):
        output.append(f"{i+1}. {item}")
    return "\n".join(output)

"""
Legacy Code Module

This module provides utility functions for data processing, including:
- Processing data items with positive values
- Calculating average of numbers
- Filtering users by minimum age
- Saving data to JSON files
- A simple key-value DataStore class
- Formatting items for display output
"""

import json
from datetime import datetime


def process_data(data):
    """
    Process a list of data items, filtering for items with positive values.

    This function iterates through each item in the input data list and
    includes only those items where the 'value' key is greater than 0.
    Each included item is transformed into a new dictionary containing
    the original id, a processed flag, and a timestamp.

    Args:
        data: A list of dictionaries, each containing 'id' and optionally
              'value' keys. If 'value' is missing, it defaults to 0.

    Returns:
        A list of processed item dictionaries. Each dictionary contains:
        - 'id': The original id from the input item
        - 'processed': Boolean set to True
        - 'timestamp': ISO format timestamp of when processing occurred
    """
    result = []
    for item in data:
        # Use .get() with default of 0 to handle missing 'value' key safely.
        # This ensures missing values are treated as non-positive (excluded).
        if item.get('value', 0) > 0:
            result.append({
                # Preserve the original id from the input item
                'id': item.get('id'),
                # Mark this item as successfully processed
                'processed': True,
                # Record when this processing happened in ISO 8601 format
                'timestamp': datetime.now().isoformat()
            })
    return result


def calculate_avg(nums):
    """
    Calculate the arithmetic mean of a list of numbers.

    This function sums all numbers in the list and divides by the count.
    It handles the edge case of an empty list by returning 0.

    Args:
        nums: A list of numeric values (int or float).

    Returns:
        The average (mean) of the numbers as a float.
        Returns 0 if the list is empty to avoid division by zero.
    """
    total = 0
    count = len(nums)
    # Accumulate the sum by iterating through each number
    for n in nums:
        total += n
    # Use conditional expression to handle empty list case.
    # Dividing by zero would raise a ZeroDivisionError, so we return 0.
    return total / count if count > 0 else 0


def filter_users(users, min_age=18):
    """
    Filter a list of users based on their age.

    This function returns only users whose age is greater than or equal
    to the specified minimum age threshold.

    Args:
        users: A list of user dictionaries, each containing an 'age' key.
               If 'age' is missing, it defaults to 0 (younger than any
               reasonable minimum age).
        min_age: The minimum age requirement (inclusive). Defaults to 18.

    Returns:
        A list of user dictionaries that meet the age requirement.
    """
    filtered = []
    for user in users:
        # Use .get() with default of 0 for missing 'age' key.
        # This ensures users without an age specified are excluded
        # when min_age > 0 (the default case).
        if user.get('age', 0) >= min_age:
            filtered.append(user)
    return filtered


def save_to_file(data, filename):
    """
    Save data to a JSON file.

    This function serializes the provided data structure to JSON format
    and writes it to the specified file.

    Args:
        data: The data structure to serialize (must be JSON-serializable:
              dict, list, str, int, float, bool, or None).
        filename: The path to the output file.

    Returns:
        True indicating successful completion. Note: This function
        does not handle file I/O errors - caller should handle exceptions.
    """
    with open(filename, 'w') as f:
        json.dump(data, f)
    return True


class DataStore:
    """
    A simple in-memory key-value store.

    This class provides basic CRUD (Create, Read, Update, Delete)
    operations for storing and retrieving data in memory.
    The data persists only for the lifetime of the DataStore instance.

    Note:
        The internal _data attribute uses a leading underscore convention
        (_data) to indicate it is intended for internal use and should
        not be accessed directly from outside the class. This is a
        Python convention signaling "private" (though not enforced).
    """

    def __init__(self):
        """Initialize an empty DataStore with an internal dictionary."""
        # Initialize empty dictionary to store key-value pairs.
        # The underscore prefix (_data) follows Python convention to
        # indicate this is a "private" internal attribute.
        self._data = {}

    def add(self, key, value):
        """
        Add or update a key-value pair in the store.

        Args:
            key: The key to associate with the value (must be hashable).
            value: The value to store (can be any Python object).
        """
        self._data[key] = value

    def get(self, key):
        """
        Retrieve a value by its key.

        Args:
            key: The key to look up.

        Returns:
            The value associated with the key if found, otherwise None.
            Unlike dict.get(), there is no way to distinguish between
            a missing key and a key with value None.
        """
        return self._data.get(key)

    def remove(self, key):
        """
        Remove a key-value pair from the store if it exists.

        This method safely handles the case where the key does not exist
        by checking for membership before deletion.

        Args:
            key: The key to remove.
        """
        if key in self._data:
            del self._data[key]


def format_output(items):
    """
    Format a list of items as a numbered string list.

    This function takes a list of items and returns a single string
    where each item is on its own line, prefixed with its 1-based index.

    Args:
        items: A list of items to format. Each item will be converted
               to a string using f-string formatting.

    Returns:
        A single string with each item on its own line, numbered starting
        from 1, in the format "1. item\n2. item\n..."
    """
    output = []
    # Use enumerate to get both index (0-based) and item.
    # Add 1 to make the display 1-based (human-friendly).
    for i, item in enumerate(items):
        output.append(f"{i+1}. {item}")
    # Join all lines with newline characters to create the final output
    return "\n".join(output)