# granite_storage.manager

class granite_storage.manager.SizeLimitedStream(stream: BinaryIO, max_size: int | None, chunk_size: int = 1048576)

  Bases: `BufferedIOBase`, `BinaryIO`

  __init__(stream: BinaryIO, max_size: int | None, chunk_size: int = 1048576)
  close() → None

    Flush and close the IO object.

    This method has no effect if the file is already closed.

  fileno() → int

    Return underlying file descriptor if one exists.

    Raise OSError if the IO object does not use a file descriptor.

  flush() → None

    Flush write buffers, if applicable.

    This is not implemented for read-only and non-blocking streams.

  isatty() → bool

    Return whether this is an ‘interactive’ stream.

    Return False if it can’t be determined.

  read(size: int | None = -1) → bytes

    Read and return up to n bytes.

    If the size argument is omitted, None, or negative, read and return all data until EOF.

    If the size argument is positive, and the underlying raw stream is not ‘interactive’, multiple raw reads may be issued to satisfy the byte count (unless EOF is reached first). However, for interactive raw streams (as well as sockets and pipes), at most one raw read will be issued, and a short result does not imply that EOF is imminent.

    Return an empty bytes object on EOF.

    Return None if the underlying raw stream was open in non-blocking mode and no data is available at the moment.

  readable() → bool

    Return whether object was opened for reading.

    If False, read() will raise OSError.

  readline(limit: int | None = -1) → bytes

    Read and return a line from the stream.

    If size is specified, at most size bytes will be read.

    The line terminator is always b’n’ for binary files; for text files, the newlines argument to open can be used to select the line terminator(s) recognized.

  readlines(hint: int = -1) → list[bytes]

    Return a list of lines from the stream.

    hint can be specified to control the number of lines read: no more lines will be read if the total size (in bytes/characters) of all lines so far exceeds hint.

  seek(offset: int, whence: int = 0) → int

    Change the stream position to the given byte offset.

    > offset

    >   The stream position, relative to ‘whence’.

    > whence

    >   The relative position to seek from.

    The offset is interpreted relative to the position indicated by whence. Values for whence are:

    - os.SEEK_SET or 0 – start of stream (the default); offset should be zero or positive

    - os.SEEK_CUR or 1 – current stream position; offset may be negative

    - os.SEEK_END or 2 – end of stream; offset is usually negative

    Return the new absolute position.

  seekable() → bool

    Return whether object supports random access.

    If False, seek(), tell() and truncate() will raise OSError. This method may need to do a test seek().

  tell() → int

    Return current stream position.

  truncate(size: int | None = None) → int

    Truncate file to size bytes.

    File pointer is left unchanged. Size defaults to the current IO position as reported by tell(). Return the new size.

  writable() → bool

    Return whether object was opened for writing.

    If False, write() will raise OSError.

  write(_SizeLimitedStream__s: Any) → int

    Write buffer b to the IO stream.

    Return the number of bytes written, which is always the length of b in bytes.

    Raise BlockingIOError if the buffer is full and the underlying raw stream cannot accept more data at the moment.

  writelines(lines: Iterable[Any]) → None

    Write a list of lines to stream.

    Line separators are not added, so it is usual for each of the lines provided to have a line separator at the end.

class granite_storage.manager.StorageManager(backends: dict[str, StorageBackend], policies: dict[str, StoragePolicy])

  Bases: `object`

  __init__(backends: dict[str, StorageBackend], policies: dict[str, StoragePolicy])
  delete(ref: StoredObjectRef) → None
  exists(ref: StoredObjectRef) → bool
  get(ref: StoredObjectRef) → bytes
  get_backend_for_policy(policy: StoragePolicy) → StorageBackend
  get_policy(storage_key: str) → StoragePolicy
  open(ref: StoredObjectRef) → BinaryIO
  put_bytes(*, storage_key: str, model_name: str, entity_id: Any, field_name: str, content: bytes, content_type: str | None = None, original_filename: str | None = None, extra: dict[str, Any] | None = None) → StoredObjectRef
  put_stream(*, storage_key: str, model_name: str, entity_id: Any, field_name: str, stream: BinaryIO, content_type: str | None = None, original_filename: str | None = None, extra: dict[str, Any] | None = None) → StoredObjectRef