GitHub

LiveFile

API reference for LiveFile.

Attributes

AttributeTypeDescription
fdint

Functions

__init__

__init__(fd, *, append) -> None
ParameterTypeDescription
fdint
appendbool
def __init__(self, fd: int, *, append: bool) -> None:
    self._fd = fd
    self._append = append
    self._position = 0

stat

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]
ParameterTypeDescription
offsetint
whenceSeekMode = '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]
ParameterTypeDescription
bufferbytearray | memoryview
positionint | 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]
ParameterTypeDescription
sizeint
positionint | 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]
ParameterTypeDescription
lengthint = 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]
ParameterTypeDescription
databytes

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]
ParameterTypeDescription
databytes

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)
        )
    )