# Memory Identity & CPython Integer Interning
a = 256
b = 256
print(a is b)  # True (Shares pre-allocated PyObject pointer)

c = 257
d = 257
print(c is d)  # False in REPL (Allocated as separate heap objects)

# Dynamic Type System: Strong Typing prevents implicit string-integer coercion
try:
    result = "Total: " + 42  # Throws TypeError! (Strong typing)
except TypeError as e:
    result = f"Total: {42}"  # Explicit string formatting

# High-Performance Collections: deque vs list for FIFO queues
from collections import deque
import time

# deque: O(1) appends and pops from both ends (Doubly-linked block buffer)
queue = deque(maxlen=10000)
queue.append("task_1")
queue.appendleft("priority_task_0")
task = queue.popleft()  # O(1) constant time! (list.pop(0) is O(N)!)

import functools
import time
from typing import Callable, Any

# Enterprise Timing & Retry Decorator with Metadata Preservation
def retry_with_backoff(retries: int = 3, backoff_factor: float = 0.5):
    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
        @functools.wraps(func)
        def wrapper(*args: Any, **kwargs: Any) -> Any:
            attempt = 0
            while attempt < retries:
                try:
                    return func(*args, **kwargs)
                except Exception as err:
                    attempt += 1
                    if attempt >= retries:
                        raise err
                    sleep_duration = backoff_factor * (2 ** (attempt - 1))
                    time.sleep(sleep_duration)
        return wrapper
    return decorator

import asyncio
import httpx

# High-Concurrency Structured TaskGroup Pipeline (Python 3.11+)
async def fetch_metric(client: httpx.AsyncClient, endpoint: str) -> dict:
    response = await client.get(endpoint, timeout=5.0)
    response.raise_for_status()
    return response.json()

async def main():
    async with httpx.AsyncClient() as client:
        # TaskGroup guarantees clean cancellation if any task fails!
        async with asyncio.TaskGroup() as tg:
            task1 = tg.create_task(fetch_metric(client, "https://api.helloaihub.com/metrics/cpu"))
            task2 = tg.create_task(fetch_metric(client, "https://api.helloaihub.com/metrics/mem"))
        
        # Both tasks completed successfully
        print("CPU:", task1.result())
        print("RAM:", task2.result())

asyncio.run(main())

# Type-Validated Field Descriptor Protocol
class PositiveIntegerField:
    def __set_name__(self, owner, name):
        self.private_name = f"_{name}"

    def __get__(self, instance, owner):
        if instance is None:
            return self
        return getattr(instance, self.private_name, 0)

    def __set__(self, instance, value):
        if not isinstance(value, int) or value < 0:
            raise ValueError(f"Value must be a non-negative integer, got {value}")
        setattr(instance, self.private_name, value)

class ClusterNode:
    cpu_cores = PositiveIntegerField()
    ram_gb = PositiveIntegerField()

node = ClusterNode()
node.cpu_cores = 64  # ✓ Valid
# node.ram_gb = -8   # ✗ Throws ValueError!