+ ,j?-^RIHt^RIt^RIHtHt^RIHtHtRt !RR4t !R R 4t R# ] ] 3dRt L#i;i) ) annotationsN)BinaryIOOptional) PyPtyProcessPyPtyProcessOptionsTFcn]tRt^t$RtR]R&RRRllt]RRl4t] RR l4t R R lt R t R #)PtyProcessOptionszk Options for creating a PTY process. Controls behavior like whether input is echoed back to the terminal. r_innerc V^8dQhRRRR/#)echoboolreturnNone)formats"7lib/python3.14/site-packages/rattler/pty/pty_process.py __annotate__PtyProcessOptions.__annotate__s00T0T0c T\'g \R4h\V4VnR#)a Create options for a PTY process. Arguments: echo: Whether to echo input back to the terminal. Defaults to True. Examples -------- ```python >>> from rattler.pty import PtyProcessOptions >>> # Create with echo enabled (default) >>> opts = PtyProcessOptions() >>> opts.echo True >>> # Create with echo disabled >>> opts = PtyProcessOptions(echo=False) >>> opts.echo False >>> ``` 3PTY functionality is not available on this platformN)_PTY_AVAILABLE ImportErrorrr )selfr s&&r__init__PtyProcessOptions.__init__s!,~ST T)$/ rc V^8dQhRRRR/#)r py_pty_process_optionsrrr r)rs"rrr3sBUZkrc 4VPV4pWnV#)z.Construct from FFI PyPtyProcessOptions object.__new__r )clsroptss&& r_from_py_pty_process_options.PtyProcessOptions._from_py_pty_process_options2s{{3,  rcV^8dQhRR/#)r rrr)rs"rrr:s  d rc .VPP#)z-Whether input is echoed back to the terminal.)r r rs&rr PtyProcessOptions.echo9s{{rcV^8dQhRR/#r rstrr)rs"rrr>s66#6rc "RVP R2#)zPtyProcessOptions(echo=))r r)s&r__repr__PtyProcessOptions.__repr__>s( 155rr N)T) __name__ __module__ __qualname____firstlineno____doc____annotations__r classmethodr%propertyr r0__static_attributes__rrrr r sF 04   66rr c]tRt^Bt$RtR]R&R RRllt]RRl4t] R R l4t R R lt R Rlt RRlt ] RRl4t]PRRl4tR!RRlltRRltRRltRRltRRltRtR#)" PtyProcessa A pseudoterminal (PTY) process. This is the lower-level PTY API that gives you more control over the process. Use this when you need to: - Read/write to the PTY manually using file handles - Check process status - Control process termination with specific signals For interactive shell sessions, consider using `PtySession` instead, which provides higher-level conveniences like `send_line()` and `interact()`. rr Nc$V^8dQhRRRRRR/#)r commandz list[str]optionszOptional[PtyProcessOptions]rrr)rs"rrPtyProcess.__annotate__Rs("@"@ "@4O"@[_"@rc \'g \R4hVf\V4VnR#\WP4VnR#)a  Create a new PTY process with the given command. Arguments: command: A list of strings representing the command and its arguments. The first element is the executable, subsequent elements are arguments. options: Optional PtyProcessOptions to configure the PTY behavior. If not provided, defaults to echo=True. Raises: RuntimeError: If the PTY process could not be created. Examples -------- ```python >>> from rattler.pty import PtyProcess, PtyProcessOptions >>> # Create with default options (echo enabled) >>> process = PtyProcess(["bash"]) >>> # Create with custom options >>> opts = PtyProcessOptions(echo=False) >>> process = PtyProcess(["bash", "-l"], opts) >>> # Check process status >>> status = process.status() >>> print(status) StillAlive >>> ``` rN)rrrr )rr?r@s&&&rrPtyProcess.__init__Rs6:~ST T ?&w/DK&w?DKrc V^8dQhRRRR/#)r py_pty_processrrr=r)rs"rrrAws,:rc 4VPV4pWnV#)z'Construct from FFI PyPtyProcess object.r!)r#rEprocesss&& r_from_py_pty_processPtyProcess._from_py_pty_processvs++c"'rcV^8dQhRR/#)r rintr)rs"rrrA~s%%3%rc .VPP#)z Get the process ID (PID) of the child process. Returns: The PID as an integer. Examples -------- ```python >>> process = PtyProcess(["bash"]) >>> pid = process.child_pid >>> print(f"Process ID: {pid}") Process ID: 12345 >>> ``` )r child_pidr)s&rrMPtyProcess.child_pid}s${{$$$rcV^8dQhRR/#)r rz Optional[str]r)rs"rrrAs$$ $rc 6VPP4#)a Check the status of the child process (non-blocking). This runs waitpid() with WNOHANG, so it returns immediately. Note: If you previously called exit() or status() returned an exit status, subsequent calls may return None. Returns: A string representing the process status, or None if status cannot be determined. Possible values: - "StillAlive": Process is still running - "Exited(code)": Process exited with the given exit code - "Signaled(signal)": Process was terminated by a signal - "Stopped": Process was stopped Examples -------- ```python >>> import time >>> process = PtyProcess(["sleep", "10"]) >>> print(process.status()) StillAlive >>> time.sleep(11) >>> print(process.status()) Exited(0) >>> ``` )r statusr)s&rrQPtyProcess.statuss:{{!!##rcV^8dQhRR/#r,r)rs"rrrAs""c"rc 6VPP4#)a Exit the process gracefully by sending SIGTERM. This method blocks until the process has exited. If the process doesn't respond to SIGTERM, it will eventually be killed with SIGKILL if a kill_timeout was set (not currently exposed to Python). Returns: A string describing the exit status. Raises: RuntimeError: If the process could not be terminated. Examples -------- ```python >>> process = PtyProcess(["bash"]) >>> status = process.exit() >>> print(status) Exited(0) >>> ``` )r exitr)s&rrUPtyProcess.exits0{{!!rcV^8dQhRR/#)r rrr)rs"rrrAs111rc hVPP4p\P!VR^R7#)a Get a file handle for reading from and writing to the PTY. This returns a Python file-like object that can be used to read output from the process and write input to it. This is useful for non-interactive automation where you want to programmatically read the process output. Returns: A Python binary file object for reading/writing to the PTY. Raises: RuntimeError: If the file handle could not be created. Examples -------- ```python >>> process = PtyProcess(["bash"]) >>> file = process.get_file_handle() >>> # Write to the process >>> file.write(b"echo hello\n") >>> file.flush() >>> # Read output (this is a blocking operation) >>> output = file.read(100) >>> print(output) >>> ``` zr+b) buffering)r get_file_handleosfdopen)rfds& rrZPtyProcess.get_file_handles)8[[ ( ( *yyUa00rcV^8dQhRR/#)r rOptional[float]r)rs"rrrAs..o.rc 6VPP4#)ac Get the kill timeout in seconds. When calling exit() or async_exit(), if the process doesn't respond to SIGTERM within this timeout, it will be forcefully killed with SIGKILL. Returns: The timeout in seconds, or None if no timeout is set. Examples -------- ```python >>> process = PtyProcess(["bash"]) >>> print(process.kill_timeout) None >>> ``` )r get_kill_timeoutr)s&r kill_timeoutPtyProcess.kill_timeouts({{++--rc V^8dQhRRRR/#)r timeoutr`rrr)rs"rrrAs..O..rc <VPPV4R#)a Set the kill timeout in seconds. Arguments: timeout: Timeout in seconds, or None to disable timeout. Examples -------- ```python >>> process = PtyProcess(["bash"]) >>> process.kill_timeout = 5.0 # 5 second timeout >>> process.kill_timeout = None # Disable timeout >>> ``` N)r set_kill_timeout)rrfs&&rrcrds" $$W-rc V^8dQhRRRR/#)r sizerKrbytesr)rs"rrrAs22S2E2rc T"VPPV4GRjxL #L5i)aC Read from the PTY asynchronously. This is the async version of reading via get_file_handle(). It performs non-blocking I/O using tokio on the Rust side, bridged to Python's asyncio. Arguments: size: Maximum number of bytes to read. Defaults to 8192. Returns: Bytes read from the PTY. Raises: RuntimeError: If the read operation fails. Examples -------- ```python >>> import asyncio >>> async def main(): ... process = PtyProcess(["bash", "-c", "echo hello"]) ... data = await process.async_read(1024) ... print(data) >>> asyncio.run(main()) >>> ``` N)r async_read)rrjs&&rrmPtyProcess.async_reads"8[[++D1111 (&(c V^8dQhRRRR/#)r datarkrrKr)rs"rrrA0s33e33rc T"VPPV4GRjxL #L5i)a& Write to the PTY asynchronously. This is the async version of writing via get_file_handle(). It performs non-blocking I/O using tokio on the Rust side. Arguments: data: Bytes to write to the PTY. Returns: The number of bytes written. Raises: RuntimeError: If the write operation fails. Examples -------- ```python >>> import asyncio >>> async def main(): ... process = PtyProcess(["cat"]) ... n = await process.async_write(b"hello\n") ... print(f"Wrote {n} bytes") ... process.exit() >>> asyncio.run(main()) >>> ``` N)r async_write)rrqs&&rrsPtyProcess.async_write0s":[[,,T2222rocV^8dQhRR/#r,r)rs"rrrAOs..#.rc R"VPP4GRjxL #L5i)a Wait for the process to exit asynchronously. This is the async version of polling status() in a loop. It polls the process status periodically without blocking the async runtime. Returns: A string describing the exit status. Raises: RuntimeError: If waiting fails. Examples -------- ```python >>> import asyncio >>> async def main(): ... process = PtyProcess(["sleep", "1"]) ... status = await process.async_wait() ... print(status) >>> asyncio.run(main()) Exited(0) >>> ``` N)r async_waitr)s&rrwPtyProcess.async_waitOs 4[[++---- '%'cV^8dQhRR/#r,r)rs"rrrAks..#.rc R"VPP4GRjxL #L5i)a Exit the process gracefully asynchronously by sending SIGTERM. This is the async version of exit(). It sends SIGTERM and waits for the process to terminate without blocking the async runtime. Returns: A string describing the exit status. Raises: RuntimeError: If the process could not be terminated. Examples -------- ```python >>> import asyncio >>> async def main(): ... process = PtyProcess(["bash"]) ... status = await process.async_exit() ... print(status) >>> asyncio.run(main()) >>> ``` N)r async_exitr)s&rr|PtyProcess.async_exitks 2[[++----rycV^8dQhRR/#r,r)rs"rrrAs99#9rc "RVP R2#)zPtyProcess(child_pid=r/)rMr)s&rr0PtyProcess.__repr__s&t~~&6a88rr2)N)i )r3r4r5r6r7r8rr9rHr:rMrQrUrZrcsetterrmrsrwr|r0r;rrrr=r=Bs  "@H %%&$>"41>..*..$2<3>.8.699rr=) __future__rr[typingrrrattler.rattlerrrrrAttributeErrorr r=rrrrsN" %AN 0606fE9E9o ^$Ns 4 AA