Алгоритмы и структуры данных

Base.metadata.create_all(bind=engine)

load_dotenv()

DATABASE_URL = f"postgresql://{os.getenv('DB_USER')}:{os.getenv('DB_PASSWORD')}@{os.getenv('DB_HOST')}:{os.getenv('DB_PORT')}/{os.getenv('DB_NAME')}"

engine = create_engine(DATABASE_URL)

#Генератор сессий для Depends
def get_db():
    db = sessionlocal()
    try:
        yield db
    finally:
        db.close()
Base.metadata.create_all(bind=engine)

sessionlocal = sessionmaker(bind=engine)

DATABASE_CONN = create_async_engine(f"postgresql+asyncpg://{os.getenv('DB_USER')}:{os.getenv('DB_PASSWORD')}@{os.getenv('DB_HOST')}:{os.getenv('DB_PORT')}/{os.getenv('DB_NAME')}") #Создаем базу данных при помощи ассинхрона

#Асинхронная сессия
async_session = sessionmaker(async_engine, class_=AsyncSession, expire_on_commit=False)

@asynccontextmanager
async def lifespan(app: FastAPI):
    async with DATABASE_CONN.begin() as conn:
        await conn.run_sync(Base.metadata.create_all)
    yield
    await DATABASE_CONN.dispose()

python
@asynccontextmanager
async def lifespan(app: FastAPI):
    yield

alembic upgrade head

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right       
        
    def sumOfLeftLeaves(self, root, data=None, is_left=False):
        if data is None:
            data = []
            
        if not root:
            return []
        
        if root.left is None and root.right is None and is_left:
            data.append(root.val)
            
        if root.left is not None:
            l = self.sumOfLeftLeaves(root.left, data, True)
            
        if root.right is not None:
            r = self.sumOfLeftLeaves(root.right, data, False)
        
        return sum(data)

root = TreeNode(3)
root.left = TreeNode(9)
root.right = TreeNode(20)
root.right.right = TreeNode(7)
root.right.left = TreeNode(15)
print(root.sumOfLeftLeafs(root))

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right       
    
    def pathSum(self, root, targetSum, data=None):
        if data is None:
            data = []
            
        if not root:
            return 0
            
        
        cnt = 0
        ans = []
        
        data.append(root.val)
        
        for i in data[::-1]:
            ans.append(i)
            if sum(ans) == targetSum:
                cnt += 1
        
            
        if root.left is not None:
            cnt += self.pathSum(root.left, targetSum, data)
            
            
        if root.right is not None:
            cnt += self.pathSum(root.right, targetSum, data)
        data.pop()   
        
        return cnt

root = TreeNode(10)
root.left = TreeNode(5)
root.right = TreeNode(-3)
root.right.right = TreeNode(11)
root.left.right = TreeNode(2)    
root.left.right.right = TreeNode(1)  
root.left.left = TreeNode(3)
root.left.left.left = TreeNode(3)
print(root.pathSum(root, 8))

from collections import deque
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right       
    
    def levelOrder(self, root):
        if not root:
            return []
        
        res = []
        queue = deque([root])
        
        while queue:
            vals = []
            for _ in range(len(queue)):
            
                node = queue.popleft()
                vals.append(node.val)
            
                if node.left:
                    queue.append(node.left)
            
                if node.right:
                    queue.append(node.right)      
        
            res.append(vals)
        return res            
              

root = TreeNode(3)
root.left = TreeNode(9)
root.right = TreeNode(20)
root.right.right = TreeNode(7)
root.right.left = TreeNode(15)
print(root.levelOrder(root))

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right       
    
    def binaryTreePaths(self, root, data=None, path=None):
        if path is None:
            path = []
            
        if data is None:
            data = []
        
        if not root:
            return []
        
        
        path.append(root.val) 
        
        if root.left is None and root.right is None:
            data.append("->".join(str(x) for x in path))
        path.pop()    
            
        
        if root.left is not None:
            path.append(root.val)
            l = self.binaryTreePaths(root.left, data, path)
            path.pop()
            
        if root.right is not None:
            path.append(root.val)
            r = self.binaryTreePaths(root.right, data, path)
            path.pop()
        
        return data
        
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.right = TreeNode(5)
print(root.binaryTreePath(root))

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right       
    
    def binaryTreePath(self, root, data=None, path=None):
        if path is None:
            path = ""
        
        if data is None:
            data = []
        
        if not root:
            return []
        
        
        path += str(root.val) + "->"    
        
        if root.left is None and root.right is None:
            data.append(path.rstrip("->"))
            
        
        if root.left is not None:
            l = self.binaryTreePath(root.left, data, path)
        
        if root.right is not None:
            r = self.binaryTreePath(root.right, data, path)
        
        return data
        
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.right = TreeNode(5)
print(root.binaryTreePath(root))

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right       
    
    def sumNumber(self, root, vals=None, curr_vals=None):
        
        if vals is None:
            vals = []
        
        if curr_vals is None:
            curr_vals = ""
            
        if not root:
            return []
        
        curr_vals += str(root.val)
        
        if root.left is None and root.right is None:
            vals.append(int(curr_vals))
               
        
        if root.left is not None:
            l = self.sumNumber(root.left, vals, curr_vals)               
            
        if root.right is not None:
            r = self.sumNumber(root.right, vals, curr_vals)
        
        return sum(vals)
        

root = TreeNode(4)       
root.left = TreeNode(9)
root.right = TreeNode(0)
root.left.left = TreeNode(5)
root.left.right = TreeNode(1)
print(root.sumNumber(root))

from celery import Celery

REDIS_URL="rediss://***************ray-168337.upstash.io:6379?ssl_cert_reqs=CERT_NONE"

@app.task()
def add_num(x, y):
    return x + y

@app.task(ignore_result=True)
def add_num(x, y):
    return x + y

@app.task(rate_limit='10/m')
def add(x, y):
    return x + y

@app.task(bind=True, max_retries=3, default_retry_delay=60)
def add(self, x, y):
    try:
        return x + y
    except SomeTemporaryException as exc:
        raise self.retry(exc=exc)

res = add_num.delay(5, 3)
print(res.get())

result = add.apply_async((4, 4), countdown=10)

from celery import signature

sig = signature('tasks.add', args=(2, 2), immutable=True)
sig.delay()

from celery import chain
# (4 + 4) -> (8 * 10)
res = chain(add.s(4, 4), multiply.s(10))()

from celery import group
# выполняет add(2, 2) и add(4, 4) параллельно
group_result = group(add.s(2, 2), add.s(4, 4))()

from celery import chord
# cначала выполняет add(2, 2) и add(4, 4) параллельно, затем результаты передаются в multiply()
result = chord([add.s(2, 2), add.s(4, 4)])(multiply.s(2))

from celery import Celery

REDIS_URL = ***************ray-168337.upstash.io:6379?ssl_cert_reqs=CERT_NONE"

app = Celery(
    'example',
    broker=REDIS_URL,
    backend=REDIS_URL
)

@app.task()
def add_num(x, y):
    return x + y

res = add_num.delay(5, 3)
print(res.get())

celery -A learn_redis worker --loglevel=info --pool=solo

python run_task_celery_redis.py

@app.middleware("http")
async def process_time(request: Request, call_nxt):
    #Время до выполнения CRUD операции
    start = time.perf_counter()
    
    #Передаем запрос дальше в соответствующий маршрут
    response = await call_nxt(request)
    
    #Вычисляем время
    time_ = time.perf_counter() - start
    
    #Добавляем время в заголовок ответа
    response.headers["Process-Time"] = str(time_)
    return response

import time

from typing import Annotated
from fastapi import FastAPI, Depends, Request
from basemodel import Tasks
from db_new import Base, Task
from routs_for_db import router
from secure import oauth2_scheme

app = FastAPI()
app.include_router(router)

@app.middleware("http")
async def process_time(request: Request, call_nxt):
    #Время до выполнения CRUD операции
    start = time.perf_counter()
    
    #Передаем запрос дальше в соответствующий маршрут
    response = await call_nxt(request)
    
    #Вычисляем время
    time_ = time.perf_counter() - start
    
    #Добавляем время в заголовок ответа
    response.headers["Process-Time"] = str(time_)
    return response

@app.get("/auth")
async def read_items(token: Annotated[str, Depends(oauth2_scheme)]):
    return {"token": token}

def main_func():
    return {"Добро пожаловать в приложение"}