> ## Documentation Index > Fetch the complete documentation index at: https://site.aspect.build/llms.txt > Use this file to discover all available pages before exploring further. # TcpStream `function` **TcpStream.close** 
        
          def TcpStream.close() -> None
Close the stream. A TLS stream tells its peer first. Closing twice is harmless; any other use after closing fails. A stream that is dropped closes by itself. `function` **TcpStream.flush** 
        
          def TcpStream.flush() -> None
Send whatever is buffered. A TLS stream buffers the records it encrypts; a plain socket has nothing to flush. `function` **TcpStream.local\_addr** 
        
          def TcpStream.local\_addr() -> str
This end's address, as `"ip:port"`. `function` **TcpStream.peer\_addr** 
        
          def TcpStream.peer\_addr() -> str
The peer's address, as `"ip:port"`. `function` **TcpStream.read** 
        
          def TcpStream.read(
          n: int,
          /
          ) -> bytes
Read at most `n` bytes, and at most 64 KiB: whatever arrives first, at least one byte unless the peer has closed its end, where it returns `b""`. Call it again for more. `function` **TcpStream.read\_exact** 
        
          def TcpStream.read\_exact(
          n: int,
          /
          ) -> bytes
Read exactly `n` bytes. A peer that closes first fails it with `kind == "unexpected_eof"`. `function` **TcpStream.read\_to\_end** 
        
          def TcpStream.read\_to\_end() -> bytes
Read until the peer closes its end. `function` **TcpStream.read\_to\_string** 
        
          def TcpStream.read\_to\_string() -> str
Read until the peer closes its end, as text. Bytes that are not UTF-8 fail it with `kind == "invalid_data"`. `function` **TcpStream.set\_nodelay** 
        
          def TcpStream.set\_nodelay(
          on: bool,
          /
          ) -> None
Turn Nagle's algorithm off (`True`) so small writes go out at once, or back on (`False`). `function` **TcpStream.set\_read\_timeout** 
        
          def TcpStream.set\_read\_timeout(
          timeout\_ms: None | int,
          /
          ) -> None
Fail any later read that waits longer than `timeout_ms` with `kind == "timed_out"`. `None` waits as long as the OS does. `function` **TcpStream.set\_write\_timeout** 
        
          def TcpStream.set\_write\_timeout(
          timeout\_ms: None | int,
          /
          ) -> None
Fail any later write that waits longer than `timeout_ms` with `kind == "timed_out"`. `None` waits as long as the OS does. `function` **TcpStream.shutdown** 
        
          def TcpStream.shutdown(
          how: str,
          /
          ) -> None
Shut down the `"read"` half, the `"write"` half, or `"both"`. After shutting down writes, the peer reads the end of the stream: the way to tell a peer that waits for it that the request is complete. A TLS stream tells its peer first, so the end is not mistaken for a cut. `function` **TcpStream.try\_flush** 
        
          def TcpStream.try\_flush() -> (None | std.io.Error, None)
`flush`, returning an `(err, None)` pair instead of raising a `std.io.Error`. `function` **TcpStream.try\_local\_addr** 
        
          def TcpStream.try\_local\_addr() -> (None | std.io.Error, None | str)
`local_addr`, returning an `(err, str)` pair instead of raising a `std.io.Error`. `function` **TcpStream.try\_peer\_addr** 
        
          def TcpStream.try\_peer\_addr() -> (None | std.io.Error, None | str)
`peer_addr`, returning an `(err, str)` pair instead of raising a `std.io.Error`. `function` **TcpStream.try\_read** 
        
          def TcpStream.try\_read(
          n: int,
          /
          ) -> (None | std.io.Error, None | bytes)
`read`, returning an `(err, bytes)` pair instead of raising a `std.io.Error`. `function` **TcpStream.try\_read\_exact** 
        
          def TcpStream.try\_read\_exact(
          n: int,
          /
          ) -> (None | std.io.Error, None | bytes)
`read_exact`, returning an `(err, bytes)` pair instead of raising a `std.io.Error`. `function` **TcpStream.try\_read\_to\_end** 
        
          def TcpStream.try\_read\_to\_end() -> (None | std.io.Error, None | bytes)
`read_to_end`, returning an `(err, bytes)` pair instead of raising a `std.io.Error`. `function` **TcpStream.try\_read\_to\_string** 
        
          def TcpStream.try\_read\_to\_string() -> (None | std.io.Error, None | str)
`read_to_string`, returning an `(err, str)` pair instead of raising a `std.io.Error`. `function` **TcpStream.try\_set\_nodelay** 
        
          def TcpStream.try\_set\_nodelay(
          on: bool,
          /
          ) -> (None | std.io.Error, None)
`set_nodelay`, returning an `(err, None)` pair instead of raising a `std.io.Error`. `function` **TcpStream.try\_set\_read\_timeout** 
        
          def TcpStream.try\_set\_read\_timeout(
          timeout\_ms: None | int,
          /
          ) -> (None | std.io.Error, None)
`set_read_timeout`, returning an `(err, None)` pair instead of raising a `std.io.Error`. `function` **TcpStream.try\_set\_write\_timeout** 
        
          def TcpStream.try\_set\_write\_timeout(
          timeout\_ms: None | int,
          /
          ) -> (None | std.io.Error, None)
`set_write_timeout`, returning an `(err, None)` pair instead of raising a `std.io.Error`. `function` **TcpStream.try\_shutdown** 
        
          def TcpStream.try\_shutdown(
          how: str,
          /
          ) -> (None | std.io.Error, None)
`shutdown`, returning an `(err, None)` pair instead of raising a `std.io.Error`. `function` **TcpStream.try\_write** 
        
          def TcpStream.try\_write(
          data: bytes | str,
          /
          ) -> (None | std.io.Error, None | int)
`write`, returning an `(err, int)` pair instead of raising a `std.io.Error`. `function` **TcpStream.try\_write\_all** 
        
          def TcpStream.try\_write\_all(
          data: bytes | str,
          /
          ) -> (None | std.io.Error, None)
`write_all`, returning an `(err, None)` pair instead of raising a `std.io.Error`. `function` **TcpStream.write** 
        
          def TcpStream.write(
          data: bytes | str,
          /
          ) -> int
Write some of `data` and return how many bytes were written, which can be fewer than `len(data)`. Use `write_all` to write all of it. `function` **TcpStream.write\_all** 
        
          def TcpStream.write\_all(
          data: bytes | str,
          /
          ) -> None
Write all of `data`, a string or bytes.