ludo-technologies/python-best-practices/coding-standards

try:
    config = parse_config(path)
except ConfigParseError as exc:
    raise StartupError(f"Invalid configuration: {path}") from exc
def main() -> int:
    try:
        start_application()
    except StartupError:
        logger.exception("Application startup failed")
        return 1  # explicit non-success outcome at the process boundary
    return 0
if __name__ == "__main__":
    raise SystemExit(main())

# List comprehension (not loops)
result = [x * 2 for x in items]
# Generator for large data
total = sum(x * x for x in range(1_000_000))
# dict.get() with default
value = config.get("key", default_value)
# Set for fast lookup
valid_ids: set[int] = {1, 2, 3}
if item_id in valid_ids: ...
# join for strings
result = ",".join(values)

# Concurrent execution
results = await asyncio.gather(task1(), task2(), task3())
# Resource management
async with aiohttp.ClientSession() as session:
    async with session.get(url) as response:
        data = await response.json()
# Concurrency limit
semaphore = asyncio.Semaphore(10)
async with semaphore:
    await do_work()

# Dependency injection (not module-level singletons)
class Service:
    def __init__(self, repository: Repository) -> None:
        self.repository = repository
# Composition root builds the graph once
def create_app(settings: Settings) -> Service:
    return Service(repository=PostgresRepository(settings.dsn))
# Open/Closed: extend via new types, not edits
class JsonFormat:
    def export(self, invoice: Invoice) -> str: ...
# Interface Segregation: small Protocols
class Workable(Protocol):
    def work(self) -> None: ...
# Early return
def process(data: Data | None) -> Result:
    if data is None:
        return Result.empty()
    # main logic here

def create_user(email: str, name: str) -> User:
    """Create a user account.
    Args:
        email: Unique email address for the account.
        name: Display name for the user.
    Returns:
        The created user.
    """
    return user_repository.create(email=email, name=name)

from pydantic import BaseModel, EmailStr, Field
class CreateUserRequest(BaseModel):
    email: EmailStr
    age: int = Field(ge=0, le=150)

# Dataclass
@dataclass
class User:
    name: str
    email: str
# Protocol for interfaces
class Repository(Protocol):
    def get(self, id: str) -> Entity: ...
# Property
@property
def full_name(self) -> str:
    return f"{self.first} {self.last}"