AI অ্যাপের জন্য অ্যাডভান্সড Python

from dataclasses import dataclass

@dataclass
class Document:
    title: str
    text: str
    tags: list[str]

def search(docs: list[Document], word: str, limit: int = 3) -> list[str]:
    """যেসব ডকুমেন্টে `word` আছে তাদের শিরোনাম, সর্বোচ্চ `limit`টা।"""
    hits = [d.title for d in docs if word.lower() in d.text.lower()]
    return hits[:limit]

def first_tag(doc: Document) -> str | None:
    return doc.tags[0] if doc.tags else None

docs = [
    Document("Intro", "Python is a language for AI.", ["basics"]),
    Document("Pricing", "Plans start at 10 dollars.", []),
]
print(search(docs, "python"))
print(first_tag(docs[1]))

['Intro']
None

import json
from dataclasses import dataclass

@dataclass
class ReviewAnalysis:
    sentiment: str
    score: float
    topics: list[str]

ALLOWED = {"positive", "negative", "neutral"}

def parse_analysis(raw: str) -> ReviewAnalysis:
    """মডেলের JSON উত্তরকে যাচাই করা Python অবজেক্টে বদলায়, নইলে ValueError তোলে।"""
    data = json.loads(raw)
    if data.get("sentiment") not in ALLOWED:
        raise ValueError(f"unexpected sentiment: {data.get('sentiment')!r}")
    score = float(data["score"])
    if not 0 <= score <= 1:
        raise ValueError(f"score out of range: {score}")
    return ReviewAnalysis(data["sentiment"], score, list(data.get("topics", [])))

good = '{"sentiment": "negative", "score": 0.12, "topics": ["delivery", "packaging"]}'
print(parse_analysis(good))

for bad in ['{"sentiment": "angry", "score": 0.3}', '{"sentiment": "positive", "score": 7}', 'Sure! Here is the JSON']:
    try:
        parse_analysis(bad)
    except (ValueError, KeyError) as error:
        print("Rejected:", type(error).__name__, "-", error)

ReviewAnalysis(sentiment='negative', score=0.12, topics=['delivery', 'packaging'])
Rejected: ValueError - unexpected sentiment: 'angry'
Rejected: ValueError - score out of range: 7.0
Rejected: JSONDecodeError - Expecting value: line 1 column 1 (char 0)

import asyncio
import time

async def fake_api_call(question: str) -> str:
    await asyncio.sleep(1)          # নেটওয়ার্কের অপেক্ষার বদলে
    return f"answer to {question!r}"

async def main():
    questions = ["What is NumPy?", "What is pandas?", "What is an API?"]

    start = time.perf_counter()
    for q in questions:                                   # একটার পর একটা
        await fake_api_call(q)
    print(f"One by one: {time.perf_counter() - start:.0f} s")

    start = time.perf_counter()
    answers = await asyncio.gather(*(fake_api_call(q) for q in questions))   # সব একসাথে
    print(f"Together:   {time.perf_counter() - start:.0f} s")
    print(answers[0])

asyncio.run(main())

One by one: 3 s
Together:   1 s
answer to 'What is NumPy?'

import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI()
limit = asyncio.Semaphore(5)                 # একসাথে সর্বোচ্চ ৫টা রিকোয়েস্ট চলবে

async def summarise(text: str) -> str:
    async with limit:
        response = await client.responses.create(
            model="gpt-5.5", input=f"Summarise in five words: {text}"
        )
        return response.output_text

async def main():
    reviews = ["The delivery was late but the product is great.",
               "Terrible battery life, would not buy again.",
               "Exactly as described, very happy with it."]
    summaries = await asyncio.gather(*(summarise(r) for r in reviews))
    for s in summaries:
        print("-", s)

asyncio.run(main())

- Late delivery, great product.
- Poor battery, would not rebuy.
- Exactly as described, satisfied.

from openai import OpenAI

client = OpenAI()
stream = client.responses.create(
    model="gpt-5.5",
    input="Give me one tip for learning Python.",
    stream=True,
)
for event in stream:
    if event.type == "response.output_text.delta":
        print(event.delta, end="", flush=True)     # প্রতিটা টুকরো আসামাত্র দেখাও
print()

Write a little code every day, and read the error messages carefully.

import logging

logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s: %(message)s")
log = logging.getLogger("review-bot")

def classify(text: str) -> str:
    log.debug("classifying %d characters", len(text))      # INFO স্তরে লুকানো
    label = "negative" if "bad" in text.lower() else "positive"
    log.info("classified as %s", label)
    if len(text) < 5:
        log.warning("very short input: %r", text)
    return label

classify("Bad")
classify("A wonderful phone")

INFO review-bot: classified as negative
WARNING review-bot: very short input: 'Bad'
INFO review-bot: classified as positive