core.skeleton.utils
===================

.. py:module:: core.skeleton.utils


Classes
-------

.. autoapisummary::

   core.skeleton.utils.SkelList


Functions
---------

.. autoapisummary::

   core.skeleton.utils.skeletonByKind
   core.skeleton.utils.listKnownSkeletons
   core.skeleton.utils.iterAllSkelClasses
   core.skeleton.utils.remove_render_preparation_deep
   core.skeleton.utils.without_render_preparation
   core.skeleton.utils.is_skeletoninstance_of


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

.. py:function:: skeletonByKind(kindName)

   Returns the Skeleton-Class for the given kindName. That skeleton must exist, otherwise an exception is raised.
   :param kindName: The kindname to retreive the skeleton for
   :return: The skeleton-class for that kind


.. py:function:: listKnownSkeletons()

   :return: A list of all known kindnames (all kindnames for which a skeleton is defined)


.. py:function:: iterAllSkelClasses()

   :return: An iterator that yields each Skeleton-Class once. (Only top-level skeletons are returned, so no
       RefSkel classes will be included)


.. py:class:: SkelList(skel = None, *items)

   Bases: :py:obj:`list`, :py:obj:`Generic`\ [\ :py:obj:`core.skeleton.meta.Skeleton_Cls`\ ]


   A typed list of :class:`SkeletonInstance` objects with query metadata.

   Returned by ``Skel().all()...fetch()`` constructs.  The generic parameter
   mirrors the one on :class:`SkeletonInstance` so that the element type flows
   through without manual casts::

       result: SkelList[ProductSkel] = ProductSkel().all().fetch(10)
       for skel in result:
           # skel is SkeletonInstance[ProductSkel]
           print(skel["price"])

   Without the type parameter the class behaves exactly as before.

   :ivar baseSkel: The base skeleton instance used to construct this list.
   :ivar getCursor: Callable returning the datastore cursor for pagination.
   :ivar get_orders: Callable returning the active query ordering.
   :ivar renderPreparation: Render-preparation callback, set by renderers.
   :ivar customQueryInfo: Arbitrary extra metadata attached by query helpers.

   :param baseSkel: The baseclass for all entries in this list


   .. py:attribute:: __slots__
      :value: ('baseSkel', 'customQueryInfo', 'getCursor', 'get_orders', 'renderPreparation')



   .. py:attribute:: baseSkel
      :type:  SkeletonInstance[Skeleton_Cls] | dict


   .. py:attribute:: getCursor


   .. py:attribute:: get_orders


   .. py:attribute:: renderPreparation
      :value: None



   .. py:attribute:: customQueryInfo


.. py:function:: remove_render_preparation_deep(skel)

   Remove renderPreparation of nested skeletons

   _refSkelCache can have renderPreparation too.


.. py:function:: without_render_preparation(skel, full_clone = False)

   Return the SkeletonInstance without renderPreparation.

   This method is useful (and unfortunately necessary due to the ViUR design)
   if you call python methods from the jinja template that should work on the
   `SkeletonInstance.accessedValues` and not on the `SkeletonInstance.renderAccessedValues`.

   If the SkeletonInstance does not have renderPreparation, it will be returned as is.
   If renderPreparation is enabled, a new SkeletonInstance is created.
   However, unless `full_clone` is True, the SkeletonInstance will use the
   identical objects as the source skeleton. It just "removes" the
   "renderPreparation mode" and keep it for the source skel enabled.


.. py:function:: is_skeletoninstance_of(obj, skel_cls, *, accept_ref_skel = True)

   Checks whether an object is an SkeletonInstance that belongs to a specific Skeleton class.

   :param obj: The object to check.
   :param skel_cls: The skeleton class that will be checked against ``obj``.
   :param accept_ref_skel: If True, ``obj`` can also be just a RefSkelFor``skel_cls``.
       If False, no ``RefSkel`` is accepted.