%%writefile hot_reload_example.py

def greet(name="World"):
    """Greets the given name."""
    return f"Hello, {name}! This is version 1."

def calculate_sum(a, b):
    """Calculates the sum of two numbers."""
    return a + b

class MyUtility:
    def __init__(self, value):
        self.value = value

    def get_info(self):
        return f"Utility v1: Value is {self.value}"

import hot_reload_example
import importlib

print("Initial greeting:", hot_reload_example.greet("Alice"))
print("Initial sum:", hot_reload_example.calculate_sum(5, 3))

utility_instance = hot_reload_example.MyUtility(10)
print("Initial utility info:", utility_instance.get_info())

%%writefile hot_reload_example.py

def greet(name="World"):
    """Greets the given name with a different message."""
    return f"Good evening, {name}! This is version 2 and it's awesome!"

def calculate_sum(a, b):
    """Calculates the sum of two numbers and adds a bonus."""
    return a + b + 10 # Adding a bonus!

class MyUtility:
    def __init__(self, value):
        self.value = value

    def get_info(self):
        return f"Utility v2: Updated value is {self.value * 2}" # Changed logic

# Reload the module
importlib.reload(hot_reload_example)

print("\nAfter hot reload:")
print("New greeting:", hot_reload_example.greet("Bob"))
print("New sum:", hot_reload_example.calculate_sum(5, 3))

# Observe the existing instance vs. new instance behavior
print("\nExisting utility instance info (before reload):", utility_instance.get_info())

new_utility_instance = hot_reload_example.MyUtility(10)
print("New utility instance info (after reload):", new_utility_instance.get_info())

print("\nNotice how the `greet` function and `calculate_sum` function immediately reflect the changes because they are called directly from the reloaded module reference. However, the existing `utility_instance` maintains its original definition, while `new_utility_instance` uses the reloaded class definition.")

import numpy as np
import matplotlib.pyplot as plt
import importlib
import sys
import os
import importlib.util # Import importlib.util for cache_from_source

module_filename = 'dynamic_module.py'
module_name = 'dynamic_module'

# Clean up any existing module and ensure current directory is in sys.path
if os.path.exists(module_filename):
    os.remove(module_filename)

# Remove potential .pyc file at the beginning too using importlib.util
pyc_filename_at_start = importlib.util.cache_from_source(module_filename)
if os.path.exists(pyc_filename_at_start):
    os.remove(pyc_filename_at_start)

if module_name in sys.modules:
    del sys.modules[module_name]

# Ensure the current directory is in sys.path for module discovery
if os.getcwd() not in sys.path:
    sys.path.insert(0, os.getcwd())

output_values = []
num_reloads = 5
base_value = 10

for i in range(num_reloads):
    new_multiplier = i + 1  # 1, 2, 3, 4, 5

    # Write the new version of the module
    file_content = f"def get_dynamic_value(base_value):\n    return base_value * {new_multiplier}\n"

    with open(module_filename, 'w') as f:
        f.write(file_content)
        f.flush()
        os.fsync(f.fileno())  # Force write to disk

    # --- NEW ADDITION: Remove .pyc file before re-importing ---
    # Use importlib.util.cache_from_source to get the .pyc filename
    pyc_filename = importlib.util.cache_from_source(module_filename)
    if os.path.exists(pyc_filename):
        os.remove(pyc_filename)
    # -----------------------------------------------------------

    # Force a fresh import of the module each time to ensure changes are picked up
    if module_name in sys.modules:
        del sys.modules[module_name] # Remove from cache to force re-import
    importlib.invalidate_caches() # Invalidate caches to ensure Python looks at the filesystem
    dynamic_module = importlib.import_module(module_name)

    # Call the function
    current_value = dynamic_module.get_dynamic_value(base_value)
    output_values.append(current_value)
    print(f"--- Iteration {i+1} ---")
    print(f"Multiplier: {new_multiplier}, Function returned: {current_value} (expected: {base_value * new_multiplier})")

# Plot the results
plt.figure(figsize=(10, 6))
plt.plot(range(1, num_reloads + 1), output_values, marker='o', linestyle='-', color='skyblue', linewidth=2, markersize=8)
plt.title('Function Output Evolution Across Hot Reloads', fontsize=14)
plt.xlabel('Reload Iteration', fontsize=12)
plt.ylabel('Function Output Value', fontsize=12)
plt.grid(True, linestyle='--', alpha=0.7)
plt.xticks(range(1, num_reloads + 1))
plt.ylim(0, base_value * num_reloads + 5) # Adjust ylim to better fit the expected output
plt.show()

# Clean up
if os.path.exists(module_filename):
    os.remove(module_filename)
# Remove the final .pyc file as well (re-calculate in case loop didn't run or pyc_filename wasn't updated)
pyc_filename_final_cleanup = importlib.util.cache_from_source(module_filename)
if os.path.exists(pyc_filename_final_cleanup):
    os.remove(pyc_filename_final_cleanup)

import numpy as np
import matplotlib.pyplot as plt
import importlib
import os
import sys
import importlib.util

module_filename = 'calculator_module.py'
module_name = 'calculator_module'

# --- Initial Cleanup (important to ensure a clean start for the demonstration) ---
if os.path.exists(module_filename):
    os.remove(module_filename)
pyc_filename_start = importlib.util.cache_from_source(module_filename)
if os.path.exists(pyc_filename_start):
    os.remove(pyc_filename_start)
if module_name in sys.modules:
    del sys.modules[module_name]
importlib.invalidate_caches() # Clear caches
# -----------------------------------------------------------------------------------

# 1. Write Initial Module Content
initial_calculator_content = [
    "class Calculator:",
    "    def __init__(self, factor):",
    "        self.factor = factor",
    "    def multiply(self, num):",
    "        return num * self.factor # Initial logic"
]
with open(module_filename, 'w') as f:
    f.write('\n'.join(initial_calculator_content))
    f.flush()
    os.fsync(f.fileno())

# Remove any .pyc created during write, force fresh import
pyc_filename_initial_load = importlib.util.cache_from_source(module_filename)
if os.path.exists(pyc_filename_initial_load):
    os.remove(pyc_filename_initial_load)
importlib.invalidate_caches()

# Import the initial module and capture the original class reference
initial_calculator_module = importlib.import_module(module_name)
OriginalCalculatorClass = initial_calculator_module.Calculator # Store reference to the original class

# 2. Create an instance from the initial module (using the captured class)
calc_v1 = OriginalCalculatorClass(2)
initial_result = calc_v1.multiply(10) # Expected: 2 * 10 = 20

# 3. Modify the Module File (overwrite with new logic)
modified_calculator_content = [
    "class Calculator:",
    "    def __init__(self, factor):",
    "        self.factor = factor",
    "    def multiply(self, num):",
    "        return num * self.factor + 5 # Modified logic: add 5"
]
with open(module_filename, 'w') as f:
    f.write('\n'.join(modified_calculator_content))
    f.flush()
    os.fsync(f.fileno())

# 4. Perform Hot Reload (or re-import to get the new module definition)
# Ensure .pyc is removed and module is cleared from sys.modules
pyc_filename_after_modify = importlib.util.cache_from_source(module_filename)
if os.path.exists(pyc_filename_after_modify):
    os.remove(pyc_filename_after_modify)
if module_name in sys.modules:
    del sys.modules[module_name] # Remove from cache to force re-import
importlib.invalidate_caches()

# Import the module again, this will now load the modified content
reloaded_calculator_module = importlib.import_module(module_name)

# 5. Observe behavior
# calc_v1 still refers to OriginalCalculatorClass, so its method should be unchanged
result_existing_instance = calc_v1.multiply(10) # Expected: 2 * 10 = 20

# Create a new instance from the reloaded module's class
calc_v2 = reloaded_calculator_module.Calculator(2)
result_new_instance = calc_v2.multiply(10) # Expected: 2 * 10 + 5 = 25

# Data for plotting
labels = ['Initial Call', 'Existing Instance After Reload', 'New Instance After Reload']
results = [initial_result, result_existing_instance, result_new_instance]
colors = ['lightcoral', 'lightgreen', 'skyblue']

plt.figure(figsize=(10, 6))
plt.bar(labels, results, color=colors)
plt.title('Calculator Class Method Behavior After Hot Reload')
plt.ylabel('Result of multiply(10)')
plt.ylim(ymin=0, ymax=max(results) + 5) # Adjust ylim dynamically to fit all values
for i, v in enumerate(results):
    plt.text(i, v + 0.5, str(v), ha='center', va='bottom')
plt.grid(axis='y', linestyle='--', alpha=0.7)
plt.show()

# Clean up the dummy module file and its .pyc
if os.path.exists(module_filename):
    os.remove(module_filename)
pyc_filename_final_cleanup = importlib.util.cache_from_source(module_filename)
if os.path.exists(pyc_filename_final_cleanup):
    os.remove(pyc_filename_final_cleanup)