🇺🇸English

Python Pro Specialist

Purpose

Provides expert Python development expertise specializing in Python 3.11+ features, type annotations, and async programming patterns. Builds high-performance applications with FastAPI, leveraging modern Python syntax and comprehensive type safety across complex systems.

When to Use

• Building Python applications with modern features (3.11+)
• Implementing async/await patterns with asyncio
• Developing FastAPI REST APIs
• Creating type-safe Python code with comprehensive annotations
• Optimizing Python performance and scalability
• Working with advanced Python patterns and idioms

Quick Start

Invoke this skill when:

• Building new Python 3.11+ applications
• Implementing async APIs with FastAPI
• Need comprehensive type annotations and mypy compliance
• Performance optimization for I/O-bound applications
• Advanced patterns (generics, protocols, pattern matching)

Do NOT invoke when:

• Simple scripts without type safety requirements
• Legacy Python 2.x or early 3.x code (use general-purpose)
• Data science/ML model training (use ml-engineer or data-scientist)
• Django-specific patterns (use django-developer)

Core Capabilities

Python 3.11+ Modern Features

• Pattern Matching : Structural pattern matching with match/case statements
• Exception Groups : Exception handling with exception groups and except*
• Union Types : Modern union syntax with | instead of Union
• Self Types : Using typing.Self for proper method return types
• Literal Types : Compile-time literal types for configuration
• TypedDict : Enhanced TypedDict with total=False and inheritance
• ParamSpec : Parameter specification for callable types

Advanced Type Annotations

• Generics : Complex generic classes, functions, and protocols
• Protocols : Structural subtyping and duck typing with typing.Protocol
• TypeVar : Type variables with bounds and constraints
• NewType : Type-safe wrappers for primitive types
• Final : Immutable variables and method overriding prevention
• Overload : Function overload decorators for multiple signatures

Async Programming Expertise

• Asyncio : Deep understanding of asyncio event loop and coroutines
• Concurrency Patterns : Async context managers, generators, comprehensions
• AsyncIO Libraries : aiohttp, asyncpg, asyncpg-pool for high-performance I/O
• FastAPI : Building async REST APIs with automatic documentation
• Background Tasks : Async background processing and task queues
• WebSockets : Real-time communication with async websockets

Decision Framework

When to Use Async

Type Annotation Strategy

New Code
│
├─ Public API (functions, classes)?
│  └─ Full type annotations required
│
├─ Internal helpers?
│  └─ Type annotations recommended
│
├─ Third-party library integration?
│  └─ Use type stubs or # type: ignore
│
└─ Complex generics needed?
   └─ Use TypeVar, Protocol, ParamSpec

Core Patterns

Pattern Matching with Type Guards

from typing import Any

def process_data(data: dict[str, Any]) -> str:
    match data:
        case {"type": "user", "id": user_id, **rest}:
            return f"Processing user {user_id} with {rest}"
        
        case {"type": "order", "items": items, "total": total} if total > 1000:
            return f"High-value order with {len(items)} items"
        
        case {"status": status} if status in ("pending", "processing"):
            return f"Order status: {status}"
        
        case _:
            return "Unknown data structure"

Async Context Manager

from typing import Optional, Type
from types import TracebackType
import asyncpg

class DatabaseConnection:
    def __init__(self, connection_string: str) -> None:
        self.connection_string = connection_string
        self.connection: Optional[asyncpg.Connection] = None
    
    async def __aenter__(self) -> 'DatabaseConnection':
        self.connection = await asyncpg.connect(self.connection_string)
        return self
    
    async def __aexit__(
        self, 
        exc_type: Optional[Type[BaseException]], 
        exc_val: Optional[BaseException], 
        exc_tb: Optional[TracebackType]
    ) -> None:
        if self.connection:
            await self.connection.close()
    
    async def execute(self, query: str, *args) -> Optional[asyncpg.Record]:
        if not self.connection:
            raise RuntimeError("Connection not established")
        return await self.connection.fetchrow(query, *args)

Generic Data Processing Pipeline

from typing import TypeVar, Generic, Protocol
from abc import ABC, abstractmethod

T = TypeVar('T')
U = TypeVar('U')

class Processor(Protocol[T, U]):
    async def process(self, item: T) -> U: ...

class Pipeline(Generic[T, U]):
    def __init__(self, processors: list[Processor]) -> None:
        self.processors = processors
    
    async def execute(self, data: T) -> U:
        result = data
        for processor in self.processors:
            result = await processor.process(result)
        return result

Best Practices Quick Reference

Code Quality

• Type Annotations : Add comprehensive type annotations to all public APIs
• PEP 8 Compliance : Follow style guidelines with black and isort
• Error Handling : Implement proper exception handling with custom exceptions
• Documentation : Use docstrings with type hints for all functions and classes
• Testing : Maintain high test coverage with unit, integration, and E2E tests

Async Programming

• Async Context Managers : Use async with for resource management
• Exception Handling : Handle async exceptions properly with try/except
• Concurrency Limits : Limit concurrent operations with semaphores
• Timeout Handling : Implement timeouts for async operations
• Resource Cleanup : Ensure proper cleanup in async functions

Performance

• Profiling : Profile before optimizing to identify bottlenecks
• Caching : Implement appropriate caching strategies
• Connection Pooling : Use connection pools for database access
• Lazy Loading : Implement lazy loading where appropriate

Development Workflow

Project Setup

• Uses poetry or pip-tools for dependency management
• Implements pyproject.toml with modern Python packaging
• Configures pre-commit hooks with black, isort, and mypy
• Uses pytest with pytest-asyncio for comprehensive testing

Type Checking

• Implements strict mypy configuration
• Uses pyright for enhanced IDE type checking
• Leverages type stubs for external libraries
• Uses mypy plugins for Django, SQLAlchemy, and other frameworks

Integration Patterns

python-pro ↔ fastapi/django

• Handoff : Python pro designs types/models → Framework implements endpoints
• Collaboration : Shared Pydantic models, type-safe APIs

python-pro ↔ database-administrator

• Handoff : Python pro uses ORM → DBA optimizes queries
• Collaboration : Index strategies, query performance

python-pro ↔ devops-engineer

• Handoff : Python pro writes app → DevOps deploys
• Collaboration : Dockerfile, requirements.txt, health checks

python-pro ↔ ml-engineer

• Handoff : Python pro builds API → ML engineer integrates models
• Collaboration : FastAPI + model serving (TensorFlow Serving, TorchServe)

Additional Resources

• Detailed Technical Reference : See REFERENCE.md

  • Repository pattern with async SQLAlchemy
  • Background tasks with Celery + FastAPI
  • Advanced Pydantic validation patterns

• Code Examples & Patterns: See EXAMPLES.md

  • Anti-patterns (ignoring type hints, blocking async)
  • FastAPI endpoint examples
  • Testing patterns with pytest-asyncio

Weekly Installs

68

Repository

404kidwiz/claud…e-skills

GitHub Stars

42

First Seen

Jan 23, 2026

Security Audits

Gen Agent Trust HubPassSocketPassSnykPass

Installed on

opencode56

claude-code51

codex51

gemini-cli50

cursor47

github-copilot45