:py:mod:`dissect.target.helpers.targetd`
========================================

.. py:module:: dissect.target.helpers.targetd


Module Contents
---------------

Classes
~~~~~~~

.. autoapisummary::

   dissect.target.helpers.targetd.TargetdStream
   dissect.target.helpers.targetd.ProxyLoader
   dissect.target.helpers.targetd.CommandProxy




.. py:class:: TargetdStream(size: Optional[int] = None, align: int = STREAM_BUFFER_SIZE)


   Bases: :py:obj:`dissect.util.stream.AlignedStream`

   Basic buffered stream that provides easy aligned reads.

   Must be subclassed for various stream implementations. Subclasses can implement:
       - _read(offset, length)
       - _seek(pos, whence=io.SEEK_SET)

   The offset and length for _read are guaranteed to be aligned. The only time
   that overriding _seek would make sense is if there's no known size of your stream,
   but still want to provide SEEK_END functionality.

   Most subclasses of AlignedStream take one or more file-like objects as source.
   Operations on these subclasses, like reading, will modify the source file-like object as a side effect.

   :param size: The size of the stream. This is used in read and seek operations. None if unknown.
   :param align: The alignment size. Read operations are aligned on this boundary. Also determines buffer size.


.. py:class:: ProxyLoader(path: pathlib.Path, **kwargs)


   Bases: :py:obj:`dissect.target.loader.Loader`

   A base class for loading a specific path and coupling it to a :class:`Target <dissect.target.target.Target>`.

   Implementors of this class are responsible for mapping any type of source data
   to a :class:`Target <dissect.target.target.Target>`.
   Whether that's to map all VMDK files from a VMX or mapping the contents of a zip file to a virtual filesystem,
   if it's something that can be translated to a "disk", "volume" or "filesystem", you can write a loader that
   maps it into a target.

   You can do anything you want to manipulate the :class:`Target <dissect.target.target.Target>` object
   in your ``map`` function, but generally you do one of the following:

   * open a :class:`Container <dissect.target.container.Container>` and add it to ``target.disks``.
   * open a :class:`Volume <dissect.target.volume.Volume>` and add it to ``target.volumes``.
   * open a :class:`VirtualFilesystem <dissect.target.filesystem.VirtualFilesystem>`,    add your files into it and add it to ``target.filesystems``.

   You don't need to manually parse volumes or filesystems in your loader, just add the highest level object you have
   (e.g. a :class:`Container <dissect.target.container.Container>` of a VMDK file) to the target.
   However, sometimes you need to get creative.
   Take a look at the :class:`ITunesLoader <dissect.target.loaders.itunes.ITunesLoader>` and
   :class:`TarLoader <dissect.target.loaders.tar.TarLoader>` for some creative examples.

   :param path: The target path to load.


.. py:exception:: TargetdInvalidStateError(message=None, cause=None, extra=None)


   Bases: :py:obj:`dissect.target.exceptions.FatalError`

   An error occurred that cannot be resolved.


.. py:class:: CommandProxy(loader: dissect.target.loader.Loader, func: Callable, namespace: Optional[str] = None)


   .. py:method:: __getattr__(func: Union[Callable, str]) -> CommandProxy


   .. py:method:: command() -> Callable


   .. py:method:: __call__(*args, **kwargs) -> Any


   .. py:method:: __repr__() -> str

      Return repr(self).