Python for Kotlin developers.

fun greet(name: String, loud: Boolean = false): String {
    val message = "Hello, $name"
    return if (loud) message.uppercase() else message
}

val x: Int = 5
var y = 10.5   // inferred Double

def greet(name: str, loud: bool = False) -> str:
    message = f"Hello, {name}"
    return message.upper() if loud else message

x: int = 5
y = 10.5   # inferred float, but never enforced

val names = listOf("Rag", "Agent", "Tool")
val upper = names.map { it.uppercase() }
val long = names.filter { it.length > 4 }

val scores = mapOf("rag" to 9, "agent" to 8)
for ((k, v) in scores) println("$k -> $v")

names = ["Rag", "Agent", "Tool"]
upper = [n.upper() for n in names]        # list comprehension
long = [n for n in names if len(n) > 4]   # filter, inline

scores = {"rag": 9, "agent": 8}
for k, v in scores.items():
    print(f"{k} -> {v}")

data class ChatMessage(
    val role: String,
    val content: String,
    val tokens: Int = 0
)

val m = ChatMessage(role = "user", content = "hi")
val m2 = m.copy(content = "hello")
println(m)  // ChatMessage(role=user, content=hi, tokens=0)

from dataclasses import dataclass, replace

@dataclass
class ChatMessage:
    role: str
    content: str
    tokens: int = 0

m = ChatMessage(role="user", content="hi")
m2 = replace(m, content="hello")
print(m)  # ChatMessage(role='user', content='hi', tokens=0)

class Wallet(private var balance: Double) {
    fun deposit(amount: Double) {
        balance += amount
    }
    fun getBalance() = balance
}

class Wallet:
    def __init__(self, balance: float):
        self._balance = balance

    def deposit(self, amount: float) -> None:
        self._balance += amount

    def get_balance(self) -> float:
        return self._balance

fun findUser(id: String): User? = repo.get(id)

val user = findUser("42")
val name = user?.name ?: "unknown"

// compiler refuses this unless user is smart-cast or null-checked:
// println(user.name)

from typing import Optional

def find_user(id: str) -> Optional[User]:
    return repo.get(id)

user = find_user("42")
name = user.name if user is not None else "unknown"

# this compiles and runs fine until it doesn't:
# print(user.name)  # AttributeError if user is None

try {
    val result = callLlmApi(prompt)
    println(result)
} catch (e: IOException) {
    println("network error: ${e.message}")
} catch (e: Exception) {
    println("unexpected: ${e.message}")
} finally {
    closeClient()
}

try:
    result = call_llm_api(prompt)
    print(result)
except ConnectionError as e:
    print(f"network error: {e}")
except Exception as e:
    print(f"unexpected: {e}")
finally:
    close_client()

fun retry(times: Int, block: () -> String): String {
    repeat(times - 1) {
        try { return block() } catch (_: Exception) {}
    }
    return block()
}

val square: (Int) -> Int = { it * it }
val doubled = listOf(1, 2, 3).map { it * 2 }

def retry(times: int, block):
    for _ in range(times - 1):
        try:
            return block()
        except Exception:
            pass
    return block()

square = lambda x: x * x          # single-expression only
doubled = [x * 2 for x in [1, 2, 3]]

suspend fun fetchAnswer(prompt: String): String {
    delay(200)               // suspends, doesn't block
    return "answer for $prompt"
}

suspend fun fetchAll(prompts: List<String>): List<String> =
    coroutineScope {
        prompts.map { async { fetchAnswer(it) } }
                .awaitAll()
    }

fun main() = runBlocking {
    println(fetchAll(listOf("a", "b")))
}

import asyncio

async def fetch_answer(prompt: str) -> str:
    await asyncio.sleep(0.2)   # suspends, doesn't block
    return f"answer for {prompt}"

async def fetch_all(prompts: list[str]) -> list[str]:
    tasks = [fetch_answer(p) for p in prompts]
    return await asyncio.gather(*tasks)

if __name__ == "__main__":
    print(asyncio.run(fetch_all(["a", "b"])))

// build.gradle.kts
dependencies {
    implementation("com.squareup.retrofit2:retrofit:2.11.0")
}

// import
import com.squareup.retrofit2.Retrofit

# pyproject.toml
[project]
dependencies = ["openai>=1.0.0"]

# import
from llm.client import call_model
import openai

data class ChatMessage(
    val role: String,
    val content: String
)

class Conversation(private val history: MutableList<ChatMessage> = mutableListOf()) {

    fun addMessage(role: String, content: String) {
        history.add(ChatMessage(role, content))
    }

    fun lastUserMessage(): String? =
        history.lastOrNull { it.role == "user" }?.content

    fun totalChars(): Int =
        history.sumOf { it.content.length }
}

fun main() {
    val convo = Conversation()
    convo.addMessage("user", "Summarize my week")
    convo.addMessage("assistant", "Sure, one moment")
    println(convo.lastUserMessage() ?: "no user message yet")
    println(convo.totalChars())
}

from dataclasses import dataclass, field

@dataclass
class ChatMessage:
    role: str
    content: str

class Conversation:
    def __init__(self) -> None:
        self.history: list[ChatMessage] = []

    def add_message(self, role: str, content: str) -> None:
        self.history.append(ChatMessage(role, content))

    def last_user_message(self) -> str | None:
        for msg in reversed(self.history):
            if msg.role == "user":
                return msg.content
        return None

    def total_chars(self) -> int:
        return sum(len(m.content) for m in self.history)


if __name__ == "__main__":
    convo = Conversation()
    convo.add_message("user", "Summarize my week")
    convo.add_message("assistant", "Sure, one moment")
    print(convo.last_user_message() or "no user message yet")
    print(convo.total_chars())