from pydantic import BaseModel  # Third-party: Class import OK
from pathlib import Path        # Stdlib: Class import OK
import sound_effects.utils      # App: Module import
from myproject import config    # App: Module import

from myproject.utils import heavy_function  # App: Avoid direct function import if circular dep risk

undefined

undefined

try:
    result = risky_operation()
except ValueError as e:
    logging.error(f"Invalid value: {e}")
    raise

try:
    result = risky_operation()
except:  # Too broad, hides bugs
    pass

def fetch_data(url: str, timeout: int = 30) -> dict[str, Any]:
    """Fetch data from URL."""
    ...

def process_items(items: list[str]) -> None:
    """Process a list of items."""
    ...

def foo(a: int, b: list[int] | None = None) -> None:
    if b is None:
        b = []

def foo(a: int, b: list[int] = []) -> None:  # Mutable default - WRONG!
    b.append(a)

if not users:  # Preferred
if not some_dict:
if value:

if len(users) == 0:  # Verbose
if users == []:
if value == True:  # Never compare to True/False explicitly

result = [x for x in data if x > 0]
squares = (x**2 for x in range(10))

undefined

undefined

sorted(data, key=lambda x: x.timestamp)

def get_timestamp(item):
    return item.timestamp

sorted(data, key=get_timestamp)

undefined

undefined

def fetch_smalltable_rows(
    table_handle: smalltable.Table,
    keys: Sequence[bytes | str],
    require_all_keys: bool = False,
) -> Mapping[bytes, tuple[str, ...]]:
    """Fetches rows from a Smalltable.

    Retrieves rows pertaining to the given keys from the Table instance
    represented by table_handle. String keys will be UTF-8 encoded.

    Args:
        table_handle: An open smalltable.Table instance.
        keys: A sequence of strings representing the key of each table
            row to fetch. String keys will be UTF-8 encoded.
        require_all_keys: If True, raise ValueError if any key is missing.

    Returns:
        A dict mapping keys to the corresponding table row data
        fetched. Each row is represented as a tuple of strings.

    Raises:
        IOError: An error occurred accessing the smalltable.
        ValueError: A key is missing and require_all_keys is True.
    """
    ...

class SampleClass:
    """Summary of class here.

    Longer class information...
    Longer class information...

    Attributes:
        likes_spam: A boolean indicating if we like SPAM or not.
        eggs: An integer count of the eggs we have laid.
    """

    def __init__(self, likes_spam: bool = False):
        """Initializes the instance based on spam preference.

        Args:
            likes_spam: Defines if instance exhibits this preference.
        """
        self.likes_spam = likes_spam
        self.eggs = 0

undefined

undefined

x = f"name: {name}; score: {score}"

x = "name: %s; score: %d" % (name, score)
x = "name: {}; score: {}".format(name, score)

x = "name: " + name + "; score: " + str(score)  # Avoid + for formatting

logger.info("Request from {} resulted in {}", ip_address, status_code)

data = Path("file.txt").read_text()
Path("output.txt").write_text("content")

with open("image.png", "rb") as f:
    data = f.read()

if foo:
    bar()

if foo: bar()  # Avoid

def main():
    ...

if __name__ == "__main__":
    main()

class MyClass:
    def method(self) -> "MyClass":
        return self

from typing import TypeAlias

ConnectionOptions: TypeAlias = dict[str, str]
Address: TypeAlias = tuple[str, int]
Server: TypeAlias = tuple[Address, ConnectionOptions]

from typing import TypeVar

_T = TypeVar("_T")  # Good: private, unconstrained
AddableType = TypeVar("AddableType", int, float, str)  # Good: descriptive

def get_names(employee_ids: list[int]) -> dict[int, str]:
    ...

def get_names(employee_ids: list) -> dict:  # Missing type parameters
    ...

from collections.abc import Mapping, Sequence
from typing import Any, Union

undefined

def handle_response(response: dict) -> str:
    match response:
        case {"status": "ok", "data": data}:
            return f"Success: {data}"
        case {"status": "error", "message": msg}:
            return f"Error: {msg}"
        case {"status": status}:
            return f"Unknown status: {status}"
        case _:
            return "Invalid response"

def process(value: int | str | list) -> str:
    match value:
        case int(n) if n > 0:
            return f"Positive int: {n}"
        case int(n):
            return f"Non-positive int: {n}"
        case str(s):
            return f"String: {s}"
        case [first, *rest]:
            return f"List starting with {first}"

from dataclasses import dataclass

@dataclass(slots=True)
class Point:
    x: float
    y: float

@dataclass(slots=True, frozen=True)
class ImmutableConfig:
    host: str
    port: int
    timeout: float = 30.0

from __future__ import annotations

class Node:
    def __init__(self, children: list[Node]) -> None:  # No quotes needed
        self.children = children

    def add_child(self, child: Node) -> None:
        self.children.append(child)

try:
    async with asyncio.TaskGroup() as tg:
        tg.create_task(task1())
        tg.create_task(task2())
except* ValueError as eg:
    for exc in eg.exceptions:
        logger.error("ValueError: {}", exc)
except* TypeError as eg:
    for exc in eg.exceptions:
        logger.error("TypeError: {}", exc)

class Square:
    def __init__(self, side: float):
        self._side = side
    
    @property
    def area(self) -> float:
        return self._side ** 2

x = "yes" if condition else "no"

from contextlib import contextmanager

@contextmanager
def managed_resource(*args, **kwargs):
    resource = acquire_resource(*args, **kwargs)
    try:
        yield resource
    finally:
        release_resource(resource)

dict = 'something'  # noqa: A001

undefined

Import from modules directly:
```python

undefined