import sys
import types

# Создаём фейковый модуль
fake = types.SimpleNamespace()
fake.get_data = lambda: "подмена работает"

# Подменяем импорт
sys.modules['external_service'] = fake

# Теперь даже import будет работать
import external_service
print(external_service.get_data())  # → "подмена работает"

import asyncio
import time
from collections import OrderedDict
from typing import Any, Optional
import threading

class AsyncTTLCache:
    def __init__(self, maxsize: int = 1024, ttl: int = 60):
        self._cache = OrderedDict()
        self._maxsize = maxsize
        self._ttl = ttl
        self._lock = threading.Lock()
        self._cleanup_task = asyncio.create_task(self._cleanup_expired())

    async def get(self, key: str) -> Optional[Any]:
        with self._lock:
            if key not in self._cache:
                return None
            value, expiry = self._cache[key]
            if time.time() > expiry:
                del self._cache[key]
                return None
            # Move to end to mark as recently used
            self._cache.move_to_end(key)
            return value

    async def set(self, key: str, value: Any) -> None:
        with self._lock:
            if key in self._cache:
                self._cache.move_to_end(key)
            self._cache[key] = (value, time.time() + self._ttl)
            if len(self._cache) > self._maxsize:
                self._cache.popitem(last=False)

    async def invalidate(self, key: str) -> None:
        with self._lock:
            if key in self._cache:
                del self._cache[key]

    async def _cleanup_expired(self) -> None:
        while True:
            await asyncio.sleep(self._ttl)
            with self._lock:
                now = time.time()
                expired_keys = [
                    k for k, (_, expiry) in self._cache.items()
                    if expiry <= now
                ]
                for k in expired_keys:
                    del self._cache[k]

    def __del__(self):
        self._cleanup_task.cancel()


# Пример использования
async def main():
    cache = AsyncTTLCache(ttl=2)
    
    await cache.set("a", 1)
    print(await cache.get("a"))  # 1
    
    await asyncio.sleep(3)
    print(await cache.get("a"))  # None
    
    await cache.set("b", 2)
    await cache.invalidate("b")
    print(await cache.get("b"))  # None

asyncio.run(main())

import functools
import logging

def log(level=logging.INFO):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            logging.log(level, f"Вызов {func.__name__} с args={args}, kwargs={kwargs}")
            return func(*args, **kwargs)
        return wrapper
    return decorator

@log(logging.DEBUG)
def compute(x, y):
    return x + y

pip install gremllm

from gremllm import Gremllm

counter = Gremllm('counter')
counter.value = 5
counter.increment()
print(counter.value)               # → 6?
print(counter.to_roman_numerals())  # → VI?

import importlib

# Обёртка для ленивого импорта
def lazy_import(name):
    return importlib.util.LazyLoader(importlib.import_module(name))

# Использование
np = lazy_import('numpy')
# numpy ещё не загружен

# Теперь загрузится:
print(np.array([1, 2, 3]))

def append_to_list(value, my_list=[]):
    my_list.append(value)
    return my_list

print(append_to_list(1))
print(append_to_list(2))
print(append_to_list(3))

[1]
[2]
[3]

python 
[1]
[1, 2]
[1, 2, 3]

def append_to_list(value, my_list=None):
    if my_list is None:
        my_list = []
    my_list.append(value)
    return my_list

[1]
[2]
[3]