Attributes#
| Attribute | Type | Description |
|---|---|---|
fd | int |
Functions#
__init__#
__init__(fd, *, append) -> None| Parameter | Type | Description |
|---|---|---|
fd | int | |
append | bool |
def __init__(self, fd: int, *, append: bool) -> None:
self._fd = fd
self._append = append
self._position = 0stat#
stat() -> Effect[FileInfo, PlatformError]Returns Effect[FileInfo, PlatformError]
def stat(self) -> Effect[FileInfo, PlatformError]:
return run("stat", self._fd, lambda: file_info(os.fstat(self._fd)))seek#
seek(offset, whence='start') -> Effect[int, PlatformError]| Parameter | Type | Description |
|---|---|---|
offset | int | |
whence | SeekMode = 'start' |
Returns Effect[int, PlatformError]
def seek(self, offset: int, whence: SeekMode = "start") -> Effect[int, PlatformError]:
def go() -> Effect[int, PlatformError]:
position = offset if whence == "start" else self._position + offset
if position < 0:
return fail(
bad_argument(
module="FileSystem",
method="seek",
description="Cannot seek before the start of the file",
)
)
self._position = position
return succeed(position)
return suspend(go)sync#
sync() -> Effect[None, PlatformError]Returns Effect[None, PlatformError]
def sync(self) -> Effect[None, PlatformError]:
return run("sync", self._fd, lambda: os.fsync(self._fd))read#
read(buffer, *, position=None) -> Effect[int, PlatformError]| Parameter | Type | Description |
|---|---|---|
buffer | bytearray | memoryview | |
position | int | None = None |
Returns Effect[int, PlatformError]
def read(
self, buffer: bytearray | memoryview, *, position: int | None = None
) -> Effect[int, PlatformError]:
def go() -> Effect[int, PlatformError]:
explicit = position
if explicit is not None:
if explicit < 0:
return _before_start("read")
return run("read", self._fd, lambda: _read_into(self._fd, buffer, explicit))
start = self._position
return run("read", self._fd, lambda: _read_into(self._fd, buffer, start)).map(
lambda count: self._advance(start, count)
)
return suspend(go)read_alloc#
read_alloc(size, *, position=None) -> Effect[bytes | None, PlatformError]| Parameter | Type | Description |
|---|---|---|
size | int | |
position | int | None = None |
Returns Effect[bytes | None, PlatformError]
def read_alloc(
self, size: int, *, position: int | None = None
) -> Effect[bytes | None, PlatformError]:
def go() -> Effect[bytes | None, PlatformError]:
if size < 0:
return fail(
bad_argument(
module="FileSystem",
method="read_alloc",
description="size must be a non-negative integer",
)
)
if position is not None and position < 0:
return _before_start("read_alloc")
start = self._position if position is None else position
def got(data: bytes) -> bytes | None:
if not data:
return None
if position is None:
self._position = start + len(data)
return data
return run("read_alloc", self._fd, lambda: _pread(self._fd, size, start)).map(got)
return suspend(go)truncate#
truncate(length=0) -> Effect[None, PlatformError]| Parameter | Type | Description |
|---|---|---|
length | int = 0 |
Returns Effect[None, PlatformError]
def truncate(self, length: int = 0) -> Effect[None, PlatformError]:
def clamp(_: None) -> None:
if not self._append and self._position > length:
self._position = length
return run("truncate", self._fd, lambda: os.ftruncate(self._fd, length)).map(clamp)write#
write(data) -> Effect[int, PlatformError]| Parameter | Type | Description |
|---|---|---|
data | bytes |
Returns Effect[int, PlatformError]
def write(self, data: bytes) -> Effect[int, PlatformError]:
return suspend(lambda: self._write_once("write", data))write_all#
write_all(data) -> Effect[None, PlatformError]| Parameter | Type | Description |
|---|---|---|
data | bytes |
Returns Effect[None, PlatformError]
def write_all(self, data: bytes) -> Effect[None, PlatformError]:
if not data:
return void
return suspend(
lambda: self._write_once("write_all", data).flat_map(
lambda written: self._rest(data, written)
)
)