class_docstr: Pattern for a mutable list-like object shareable via a shared
  memory block.  It differs from the built-in list type in that these
  lists can not change their overall length (i.e. no append, insert,
  etc.)
  
  Because values are packed into a memoryview as bytes, the struct
  packing format for any storable value must require no more than 8
  characters to describe its format.
code: def __init__(self, sequence=None, *, name=None):
      if sequence is not None:
          _formats = [
              self._types_mapping[type(item)]
              if not isinstance(item, (str, bytes))
              else self._types_mapping[type(item)]
              % (self._alignment * (len(item) // self._alignment + 1),)
              for item in sequence
          ]
          self._list_len = len(_formats)
          assert (
              sum(len(fmt) <= 8 for fmt in _formats) == self._list_len
          )
          self._allocated_bytes = tuple(
              self._alignment if fmt[-1] != "s" else int(fmt[:-1])
              for fmt in _formats
          )
          _recreation_codes = [
              self._extract_recreation_code(item) for item in sequence
          ]
          requested_size = struct.calcsize(
              "q"
              + self._format_size_metainfo
              + "".join(_formats)
              + self._format_packing_metainfo
              + self._format_back_transform_codes
          )
  
      else:
          requested_size = 8  # Some platforms require > 0.
  
      if name is not None and sequence is None:
          self.shm = SharedMemory(name)
      else:
          self.shm = SharedMemory(
              name, create=True, size=requested_size
          )
  
      if sequence is not None:
          _enc = _encoding
          struct.pack_into(
              "q" + self._format_size_metainfo,
              self.shm.buf,
              0,
              self._list_len,
              *(self._allocated_bytes),
          )
          struct.pack_into(
              "".join(_formats),
              self.shm.buf,
              self._offset_data_start,
              *(
                  v.encode(_enc) if isinstance(v, str) else v
                  for v in sequence
              ),
          )
          struct.pack_into(
              self._format_packing_metainfo,
              self.shm.buf,
              self._offset_packing_formats,
              *(v.encode(_enc) for v in _formats),
          )
          struct.pack_into(
              self._format_back_transform_codes,
              self.shm.buf,
              self._offset_back_transform_codes,
              *(_recreation_codes),
          )
  
      else:
          self._list_len = len(
              self
          )  # Obtains size from offset 0 in buffer.
          self._allocated_bytes = struct.unpack_from(
              self._format_size_metainfo, self.shm.buf, 1 * 8
          )
  
imports: from functools import partial
  import mmap
  import os
  import errno
  import struct
  import secrets
label_desc: Use image node_id 2 to create a new ShareableList object  with example: obj = ShareableList(sequence)