Congressman, we do not do anything that is beyond any industry norms

import asyncio

def register(...):
 ....
 asyncio.create_task(
   send_email, ...)
 ...
 return...

# Accepting CSV file and processing it in the background
from fastapi import FastAPI, File, UploadFile, BackgroundTasks
import asyncio

app = FastAPI()

process_status = {} # use database in production

async def process_id_generator():
    ...

async def process_csv(process_id: int, file: UploadFile):
    # Do some processing
    await asyncio.sleep(5)
    process_status[process_id] = "success"
    return


@app.post("/upload")
async def upload_file(file: UploadFile = File(...)):
    asyncio.create_task(process_csv(file))
    return {"status": "processing"}

# this uses fastapi background task scheduler to process
@app.post("/upload-fast-bg")
async def upload_file_fast_bg(file: UploadFile = File(...) , background_tasks: BackgroundTasks):
    process_id = await process_id_generator()
    background_tasks.add_task(process_csv, process_id, file)
    return {"status": "pending", "process_id": process_id}

@app.post("process-status/{process_id}")
async def process_status(process_id: int):
    return {"status": process_status.get(process_id, "not found")}

import socket
import struct

def dns_resolver(domain_name):
    # DNS server (Google's Public DNS)
    dns_server = '8.8.8.8'
    dns_port = 53

    # Create a UDP socket
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

    # Pack the DNS query
    query = build_dns_query(domain_name)
    
    # Send the DNS query to the DNS server
    sock.sendto(query, (dns_server, dns_port))

    # Receive the DNS response
    response, _ = sock.recvfrom(1024)
    print('response', response, _)

    # Parse the DNS response
    ip_address = parse_dns_response(response)

    return ip_address

def build_dns_query(domain_name):
    # DNS header
    header = struct.pack('!HBBHHHH', 0, 1, 0, 1, 0, 0, 0)

    # DNS question section
    question = b''
    for part in domain_name.split('.'):
        question += struct.pack('!B', len(part))
        question += part.encode('utf-8')
    question += b'\x00'  # End of domain name
    question += struct.pack('!H', 1)  # Query type A (IPv4)
    question += struct.pack('!H', 1)  # Class IN (Internet)
    return header + question

def parse_dns_response(response):
    # Parse the response to extract the IP address
    ip_address = '.'.join(str(byte) for byte in response[-4:])
    return ip_address

# Example usage
domain_name = 'blog.chapimenge.com'
ip_address = dns_resolver(domain_name)
print(f'The IP address of {domain_name} is {ip_address}')