Types, functions, and modules

name = "Rahish"           # str   - text
score = 0.92              # float - decimal number
count = 3                 # int   - whole number
ready = True              # bool  - True or False
answer = None             # None  - "no value yet"

print(type(name).__name__, type(score).__name__, type(count).__name__)
print(type(ready).__name__, type(answer).__name__)

print(7 / 2, 7 // 2, 7 % 2, 2 ** 10)
print(0.1 + 0.2)
print(round(0.1 + 0.2, 2))

model = "gpt-4o-mini"
temperature = 0.2
max_tokens = 1500

prompt = f"Model: {model} | temp={temperature:.1f} | tokens={max_tokens:,}"
print(prompt)

context = "Paris is the capital of France."
question = "What is the capital of France?"

prompt = f"""Answer using only the context.

Context: {context}
Question: {question}
Answer:"""
print(prompt)

text = "  RAG Retrieves Context  "
print(text.strip().lower())                    # trim + lowercase
print("a,b,c".split(","))                      # split into a list
print(" | ".join(["rag", "agents", "evals"]))  # join a list into one string
print("chunk_001.txt".startswith("chunk"), "notes.md".endswith(".txt"))
print("Hello AI"[0:5], "Hello AI"[-2:])        # slicing

for value in [0, 0.0, "", [], {}, None, "0", [0]]:
    print(repr(value), bool(value))

print(int("42") + 1, float("0.75") * 2, str(3) + "3", bool(""))

try:
    int("abc")
except ValueError as e:
    print("ValueError:", e)

score = 0.74

if score >= 0.8:
    label = "relevant"
elif score >= 0.5:
    label = "maybe"
else:
    label = "irrelevant"

print(label)

docs = ["intro to rag", "", "vector databases", "evals"]

for doc in docs:
    if not doc:
        continue          # skip empty strings, go to the next item
    print(doc.title())

for i in range(3):        # 0, 1, 2
    print("attempt", i + 1)

attempt = 0
succeeded = False

while attempt < 5:
    attempt += 1
    if attempt == 3:          # pretend the third call works
        succeeded = True
        break

print(f"succeeded={succeeded} after {attempt} attempts")

def normalize(text):
    """Lowercase text and collapse repeated whitespace."""
    return " ".join(text.lower().split())

print(normalize("  Hello   RAG  "))

def build_prompt(question, context="", style="concise"):
    prompt = f"Answer in a {style} way.\n"
    if context:
        prompt += f"Context: {context}\n"
    return prompt + f"Question: {question}"

print(build_prompt("What is RAG?"))
print("---")
print(build_prompt("What is RAG?", style="detailed", context="RAG = retrieval + generation"))

def text_stats(text):
    words = text.split()
    return len(words), len(text)

word_count, char_count = text_stats("embeddings map text to vectors")
print(word_count, char_count)

def call_model(prompt, *stop_words, **options):
    print("prompt:", prompt)
    print("stop:", stop_words)
    print("options:", options)

call_model("Hi", "###", "END", temperature=0.3, max_tokens=50)

def chunk_words(text: str, size: int = 50) -> list[str]:
    """Split text into chunks of at most `size` words."""
    words = text.split()
    return [" ".join(words[i:i + size]) for i in range(0, len(words), size)]


def find_doc(doc_id: str, docs: dict[str, str]) -> str | None:
    """Return the document text, or None if the id is unknown."""
    return docs.get(doc_id)


print(chunk_words("one two three four five", size=2))
print(find_doc("a", {"a": "alpha"}), find_doc("z", {"a": "alpha"}))

def add_message(text, history=[]):      # BUG: shared list
    history.append(text)
    return history

print(add_message("hi"))
print(add_message("again"))              # remembers the previous call!


def add_message_fixed(text, history=None):
    if history is None:
        history = []                     # fresh list on every call
    history.append(text)
    return history

print(add_message_fixed("hi"))
print(add_message_fixed("again"))

DEFAULT_MODEL = "gpt-4o-mini"      # module-level constant

def describe(model=None):
    chosen = model or DEFAULT_MODEL   # 'chosen' is local
    return f"using {chosen}"

print(describe())
print(describe("llama-3.1-8b"))

results = [
    {"id": "a", "score": 0.62},
    {"id": "b", "score": 0.91},
    {"id": "c", "score": 0.78},
]

ranked = sorted(results, key=lambda r: r["score"], reverse=True)
print([r["id"] for r in ranked])

def parse_score(raw: str) -> float:
    try:
        value = float(raw)
    except ValueError:
        print(f"could not parse {raw!r}, defaulting to 0.0")
        return 0.0
    if not 0.0 <= value <= 1.0:
        raise ValueError(f"score must be between 0 and 1, got {value}")
    return value

print(parse_score("0.83"))
print(parse_score("high"))

try:
    parse_score("7")
except ValueError as err:
    print("rejected:", err)

"""Reusable text helpers for AI pipelines."""

def normalize(text: str) -> str:
    return " ".join(text.lower().split())


def estimate_tokens(text: str) -> int:
    """Rough rule of thumb: about 4 characters per token for English."""
    return max(1, len(text) // 4)


if __name__ == "__main__":
    # Runs only with `python text_utils.py`, not on import.
    print(estimate_tokens("Retrieval augmented generation"))

from text_utils import normalize, estimate_tokens

doc = "  Agents   PLAN, act, and   observe.  "
clean = normalize(doc)
print(clean)
print("≈ tokens:", estimate_tokens(clean))

def format_context(chunks: list[str], max_chunks: int = 3) -> str:
    if not chunks:
        raise ValueError("need at least one context chunk")
    selected = chunks[:max_chunks]
    return "\n".join(f"[{i}] {c.strip()}" for i, c in enumerate(selected, start=1))


def rag_prompt(question: str, chunks: list[str]) -> str:
    return (
        "Answer the question using only the numbered context. "
        "Cite sources like [1].\n\n"
        f"{format_context(chunks)}\n\n"
        f"Question: {question.strip()}"
    )


print(rag_prompt(" What does RAG reduce? ", [
    "RAG grounds answers in retrieved documents.",
    "Grounding reduces hallucinations.",
]))