Pyright

import pyright

import pyright.cli
import pyright.langserver
import pyright.errors
import pyright.node
import pyright.utils
import pyright.types

from pyright import errors
from pyright.cli import run, main, entrypoint
from pyright.langserver import run, main, entrypoint
from pyright.node import run, version, latest
from pyright.types import Target, check_target
from pyright.utils import get_cache_dir, env_to_bool

# Via console script (most common)
# After installation, pyright is available as a command:
# $ pyright --help
# $ pyright src/

# Programmatic usage
from pyright.cli import run, main

# Run pyright with arguments (returns CompletedProcess)
result = run('--version')
print(result.stdout)

# Run pyright and get exit code
exit_code = main(['src/', '--outputjson'])

from pyright.langserver import run as langserver_run, main as langserver_main

# Run pyright language server
result = langserver_run('--stdio')

# Run with exit code
exit_code = langserver_main('--stdio')

def run(*args: str, **kwargs: Any) -> Union[subprocess.CompletedProcess[bytes], subprocess.CompletedProcess[str]]:
    """
    Execute pyright with given arguments.
    
    Parameters:
    - *args: Command line arguments to pass to pyright
    - **kwargs: Additional subprocess arguments (stdout, stderr, etc.)
    
    Returns:
    subprocess.CompletedProcess: Result of pyright execution
    """

def main(args: List[str], **kwargs: Any) -> int:
    """
    Main entry point for pyright CLI returning exit code.
    
    Parameters:
    - args: List of command line arguments
    - **kwargs: Additional subprocess arguments
    
    Returns:
    int: Exit code (0 for success, non-zero for errors)
    """

def entrypoint() -> NoReturn:
    """
    Console script entry point for pyright command.
    
    Calls main() with sys.argv[1:] and exits with the result.
    """

def run(*args: str, **kwargs: Any) -> subprocess.CompletedProcess[bytes] | subprocess.CompletedProcess[str]:
    """
    Execute pyright language server with arguments.
    
    Parameters:
    - *args: Language server arguments (typically --stdio)
    - **kwargs: Additional subprocess arguments
    
    Returns:
    subprocess.CompletedProcess: Result of language server execution
    """

def main(*args: str, **kwargs: Any) -> int:
    """
    Main entry point for language server returning exit code.
    
    Parameters:
    - *args: Language server arguments
    - **kwargs: Additional subprocess arguments
    
    Returns:
    int: Exit code
    """

def entrypoint() -> NoReturn:
    """
    Console script entry point for pyright language server.
    
    Calls main() with sys.argv[1:] and exits with the result.
    """

def run(target: Target, *args: str, **kwargs: Any) -> Union[subprocess.CompletedProcess[bytes], subprocess.CompletedProcess[str]]:
    """
    Execute node or npm commands using resolved binary strategy.
    
    Parameters:
    - target: Either 'node' or 'npm'
    - *args: Command line arguments to pass to the binary
    - **kwargs: Additional subprocess arguments
    
    Returns:
    subprocess.CompletedProcess: Result of command execution
    
    Raises:
    - BinaryNotFound: If required binary cannot be found
    - VersionCheckFailed: If version validation fails
    """

def version(target: Target) -> Tuple[int, ...]:
    """
    Get version information for node or npm binary.
    
    Parameters:
    - target: Either 'node' or 'npm'
    
    Returns:
    Tuple[int, ...]: Version tuple (e.g., (18, 17, 0))
    
    Raises:
    - VersionCheckFailed: If version cannot be determined
    """

def latest(package: str) -> str:
    """
    Get latest version of an npm package.
    
    Parameters:
    - package: NPM package name
    
    Returns:
    str: Latest version string
    
    Raises:
    - VersionCheckFailed: If version check fails
    """

def get_env_variables() -> Dict[str, Any]:
    """
    Get environment variables for Node.js execution.
    
    Returns:
    Dict[str, Any]: Environment variables dict
    """

def get_pkg_version(pkg: Path) -> str | None:
    """
    Parse package.json file and return version property.
    
    Parameters:
    - pkg: Path to package.json file
    
    Returns:
    str | None: Version string or None if cannot be resolved
    """

def get_cache_dir() -> Path:
    """
    Get user cache directory path.
    
    Returns:
    Path: Cache directory path (respects XDG_CACHE_HOME, defaults to ~/.cache)
    """

def get_env_dir() -> Path:
    """
    Get nodeenv directory path.
    
    Returns:
    Path: Directory containing nodeenv installation
    """

def get_bin_dir(*, env_dir: Path) -> Path:
    """
    Get binary directory for given environment directory.
    
    Parameters:
    - env_dir: Environment directory path
    
    Returns:
    Path: Binary directory (Scripts on Windows, bin on Unix)
    """

def env_to_bool(key: str, *, default: bool = False) -> bool:
    """
    Convert environment variable to boolean.
    
    Parameters:
    - key: Environment variable name
    - default: Default value if not set
    
    Returns:
    bool: Boolean value (recognizes '1', 't', 'on', 'true' as True)
    """

def maybe_decode(data: Union[str, bytes]) -> str:
    """
    Decode bytes to string if needed.
    
    Parameters:
    - data: String or bytes data
    
    Returns:
    str: Decoded string
    """

def get_latest_version() -> Optional[str]:
    """
    Get latest pyright-python version from PyPI.
    
    Returns:
    Optional[str]: Latest version string or None if unavailable
    """

def check_target(value: Any) -> None:
    """
    Validate that a value is a valid Target type.
    
    Parameters:
    - value: Value to validate
    
    Raises:
    - TypeError: If value is not 'node' or 'npm'
    """

class PyrightError(Exception):
    """Base exception for pyright-related errors."""
    message: str

class NodeError(PyrightError):
    """Node.js related errors."""
    pass

class BinaryNotFound(NodeError):
    """Raised when expected Node.js binary is not found."""
    path: Path
    target: Target

class VersionCheckFailed(NodeError):
    """Raised when version checking fails."""
    pass

Target = Literal['node', 'npm']

class GlobalStrategy(NamedTuple):
    """Strategy using global Node.js installation."""
    type: Literal['global']
    path: Path

class NodeJSWheelStrategy(NamedTuple):
    """Strategy using nodejs-wheel package."""
    type: Literal['nodejs_wheel']

class NodeenvStrategy(NamedTuple):
    """Strategy using nodeenv installation."""
    type: Literal['nodeenv'] 
    path: Path

Strategy = Union[GlobalStrategy, NodeJSWheelStrategy, NodeenvStrategy]

ENV_DIR: Path  # Environment directory path
BINARIES_DIR: Path  # Binary directory path
USE_GLOBAL_NODE: bool  # Whether to use global Node.js (default: True)
USE_NODEJS_WHEEL: bool  # Whether to use nodejs-wheel package (default: True) 
NODE_VERSION: Optional[str]  # User-specified Node.js version
VERSION_RE: Pattern  # Regular expression for version matching
PYPI_API_URL: str  # PyPI JSON API URL for version checking

# Package metadata constants (available from main pyright module)
__version__: str  # Package version (e.g., "1.1.405")
__pyright_version__: str  # Wrapped pyright version (e.g., "1.1.405")
__title__: str  # Package title
__author__: str  # Package author  
__license__: str  # Package license
__copyright__: str  # Copyright information

repos:
  - repo: https://github.com/RobertCraigie/pyright-python
    rev: v1.1.405
    hooks:
    - id: pyright

# Basic installation
pip install pyright

# Recommended: with nodejs-wheel for reliable Node.js binaries  
pip install pyright[nodejs]

# Development installation
pip install pyright[dev]

# All extras
pip install pyright[all]

from pyright.cli import run

# Check specific files
result = run('src/main.py', 'src/utils.py')
if result.returncode == 0:
    print("Type checking passed!")
else:
    print("Type checking failed")

# Check entire directory with JSON output
result = run('src/', '--outputjson')

from pyright.langserver import run as langserver_run

# Start language server with stdio communication
result = langserver_run('--stdio')

from pyright.node import version, latest

# Check Node.js version
node_version = version('node')
print(f"Node.js version: {'.'.join(map(str, node_version))}")

# Get latest pyright version
latest_pyright = latest('pyright')
print(f"Latest pyright: {latest_pyright}")

from pyright.cli import run
from pyright.errors import PyrightError, BinaryNotFound

try:
    result = run('--version')
    print(result.stdout.decode())
except BinaryNotFound as e:
    print(f"Node.js binary not found at {e.path}")
except PyrightError as e:
    print(f"Pyright error: {e.message}")