# Modele

class `articles.models.``Article`(id, created, modified, title, category, is_active, short_text, long_text, image, image_list, author, system_id, position)
  exception `DoesNotExist`
    `__module__` = 'articles.models'
    `__reduce__`()
    `__setstate__`(args)
  exception `MultipleObjectsReturned`
    `__module__` = 'articles.models'
    `__reduce__`()
    `__setstate__`(args)
  `__module__` = 'articles.models'
  `__str__`()

    Return str(self).

  `author`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `category`

    Accessor to the related object on the forward side of a many-to-one or one-to-one (via ForwardOneToOneDescriptor subclass) relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    `child.parent` is a `ForwardManyToOneDescriptor` instance.

  `category_id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `get_next_by_created`(**morekwargs)
  `get_next_by_modified`(**morekwargs)
  `get_previous_by_created`(**morekwargs)
  `get_previous_by_modified`(**morekwargs)
  `get_system_id_display`(**morekwargs)
  `id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `image`

    Just like the FileDescriptor, but for ImageFields. The only difference is assigning the width/height to the width_field/height_field, if appropriate.

  `image_list`

    Just like the FileDescriptor, but for ImageFields. The only difference is assigning the width/height to the width_field/height_field, if appropriate.

  `is_active`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `long_text`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `next`()
  `objects` = <django.db.models.manager.ManagerFromArticleQuerySet object>
  `position`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `previous`()
  `short_text`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `slug`()
  `system_id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `tasks`

    Accessor to the related objects manager on the forward and reverse sides of a many-to-many relation.

    In the example:

        class Pizza(Model):
            toppings = ManyToManyField(Topping, related_name='pizzas')

    `pizza.toppings` and `topping.pizzas` are `ManyToManyDescriptor` instances.

    Most of the implementation is delegated to a dynamically defined manager class built by `create_forward_many_to_many_manager()` defined below.

  `title`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

class `articles.models.``ArticleCategory`(id, name)
  exception `DoesNotExist`
    `__module__` = 'articles.models'
    `__reduce__`()
    `__setstate__`(args)
  exception `MultipleObjectsReturned`
    `__module__` = 'articles.models'
    `__reduce__`()
    `__setstate__`(args)
  `__module__` = 'articles.models'
  `__str__`()

    Return str(self).

  `article_set`

    Accessor to the related objects manager on the reverse side of a many-to-one relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    `parent.children` is a `ReverseManyToOneDescriptor` instance.

    Most of the implementation is delegated to a dynamically defined manager class built by `create_forward_many_to_many_manager()` defined below.

  `id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `name`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `objects` = <django.db.models.manager.Manager object>

class `articles.models.``ArticleQuerySet`(model=None, query=None, using=None, hints=None)
  `__module__` = 'articles.models'
  `active`()
  `random_from_category`(article, max_quant)

class `articles.models.``StaticVideo`(id, system_id, text, yt_video)
  exception `DoesNotExist`
    `__module__` = 'articles.models'
    `__reduce__`()
    `__setstate__`(args)
  exception `MultipleObjectsReturned`
    `__module__` = 'articles.models'
    `__reduce__`()
    `__setstate__`(args)
  `__module__` = 'articles.models'
  `__str__`()

    Return str(self).

  `get_system_id_display`(**morekwargs)
  `id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `objects` = <django.db.models.manager.Manager object>
  `system_id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `text`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `yt_video`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

class `exercises.models.``Exercise`(id, title, text, is_active, yt_video)
  exception `DoesNotExist`
    `__module__` = 'exercises.models'
    `__reduce__`()
    `__setstate__`(args)
  exception `MultipleObjectsReturned`
    `__module__` = 'exercises.models'
    `__reduce__`()
    `__setstate__`(args)
  `__module__` = 'exercises.models'
  `__str__`()

    Return str(self).

  `apprentices`

    Accessor to the related objects manager on the forward and reverse sides of a many-to-many relation.

    In the example:

        class Pizza(Model):
            toppings = ManyToManyField(Topping, related_name='pizzas')

    `pizza.toppings` and `topping.pizzas` are `ManyToManyDescriptor` instances.

    Most of the implementation is delegated to a dynamically defined manager class built by `create_forward_many_to_many_manager()` defined below.

  `exercise_task_positions`

    Accessor to the related objects manager on the reverse side of a many-to-one relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    `parent.children` is a `ReverseManyToOneDescriptor` instance.

    Most of the implementation is delegated to a dynamically defined manager class built by `create_forward_many_to_many_manager()` defined below.

  `id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `is_active`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `objects` = <exercises.models.ExerciseManager object>
  `slug`()
  `tasks`

    Accessor to the related objects manager on the forward and reverse sides of a many-to-many relation.

    In the example:

        class Pizza(Model):
            toppings = ManyToManyField(Topping, related_name='pizzas')

    `pizza.toppings` and `topping.pizzas` are `ManyToManyDescriptor` instances.

    Most of the implementation is delegated to a dynamically defined manager class built by `create_forward_many_to_many_manager()` defined below.

  `text`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `title`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `yt_video`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

class `exercises.models.``ExerciseManager`
  `__module__` = 'exercises.models'
  `__slotnames__` = []

class `exercises.models.``ExerciseQuerySet`(model=None, query=None, using=None, hints=None)
  `__module__` = 'exercises.models'
  `active`()
  `annotated_with_done_by_apprentice`(apprentice)
  `annotated_with_done_by_apprentice_count`(apprentice)
  `from_path`(path)
  `from_path_count`(path)
  `from_task`(task)
  `from_task_count`(task)

class `marks.models.``MarkCriteria`(id, name, group, position)
  exception `DoesNotExist`
    `__module__` = 'marks.models'
    `__reduce__`()
    `__setstate__`(args)
  exception `MultipleObjectsReturned`
    `__module__` = 'marks.models'
    `__reduce__`()
    `__setstate__`(args)
  `__module__` = 'marks.models'
  `__str__`()

    Return str(self).

  `group`

    Accessor to the related object on the forward side of a many-to-one or one-to-one (via ForwardOneToOneDescriptor subclass) relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    `child.parent` is a `ForwardManyToOneDescriptor` instance.

  `group_id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `name`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `objects` = <django.db.models.manager.Manager object>
  `position`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `task_mark_criteria`

    Accessor to the related objects manager on the reverse side of a many-to-one relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    `parent.children` is a `ReverseManyToOneDescriptor` instance.

    Most of the implementation is delegated to a dynamically defined manager class built by `create_forward_many_to_many_manager()` defined below.

  `tasks`

    Accessor to the related objects manager on the forward and reverse sides of a many-to-many relation.

    In the example:

        class Pizza(Model):
            toppings = ManyToManyField(Topping, related_name='pizzas')

    `pizza.toppings` and `topping.pizzas` are `ManyToManyDescriptor` instances.

    Most of the implementation is delegated to a dynamically defined manager class built by `create_forward_many_to_many_manager()` defined below.

class `marks.models.``MarkCriteriaGroup`(id, name, position)
  exception `DoesNotExist`
    `__module__` = 'marks.models'
    `__reduce__`()
    `__setstate__`(args)
  exception `MultipleObjectsReturned`
    `__module__` = 'marks.models'
    `__reduce__`()
    `__setstate__`(args)
  `__module__` = 'marks.models'
  `__str__`()

    Return str(self).

  `id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `marks`

    Accessor to the related objects manager on the reverse side of a many-to-one relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    `parent.children` is a `ReverseManyToOneDescriptor` instance.

    Most of the implementation is delegated to a dynamically defined manager class built by `create_forward_many_to_many_manager()` defined below.

  `name`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `objects` = <django.db.models.manager.Manager object>
  `position`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

class `tasks.models.``ApprenticeTaskAnswer`(id, created, modified, task, apprentice, custom_title, video_1, video_2, notification)
  exception `DoesNotExist`
    `__module__` = 'tasks.models'
    `__reduce__`()
    `__setstate__`(args)
  exception `MultipleObjectsReturned`
    `__module__` = 'tasks.models'
    `__reduce__`()
    `__setstate__`(args)
  `__module__` = 'tasks.models'
  `__str__`()

    Return str(self).

  `apprentice`

    Accessor to the related object on the forward side of a many-to-one or one-to-one (via ForwardOneToOneDescriptor subclass) relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    `child.parent` is a `ForwardManyToOneDescriptor` instance.

  `apprentice_id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `custom_title`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `get_next_by_created`(**morekwargs)
  `get_next_by_modified`(**morekwargs)
  `get_previous_by_created`(**morekwargs)
  `get_previous_by_modified`(**morekwargs)
  `get_status`()
  `get_task_process`()
  `id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `notification`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `objects` = <tasks.models.ApprenticeTaskAnswerManager object>
  `save`(**kwargs)

    Saves the current instance. Override this in a subclass if you want to control the saving process.

    The «force_insert» and «force_update» parameters can be used to insist that the „save” must be an SQL insert or update (or equivalent for non-SQL backends), respectively. Normally, they should not be set.

  `slug`()
  `task`

    Accessor to the related object on the forward side of a many-to-one or one-to-one (via ForwardOneToOneDescriptor subclass) relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    `child.parent` is a `ForwardManyToOneDescriptor` instance.

  `task_id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `video_1`

    Accessor to the related object on the forward side of a one-to-one relation.

    In the example:

        class Restaurant(Model):
            place = OneToOneField(Place, related_name='restaurant')

    `restaurant.place` is a `ForwardOneToOneDescriptor` instance.

  `video_1_id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `video_2`

    Accessor to the related object on the forward side of a one-to-one relation.

    In the example:

        class Restaurant(Model):
            place = OneToOneField(Place, related_name='restaurant')

    `restaurant.place` is a `ForwardOneToOneDescriptor` instance.

  `video_2_id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

class `tasks.models.``ApprenticeTaskAnswerManager`
  `__module__` = 'tasks.models'
  `__slotnames__` = []
  `from_path`(path)
  `others`(apprentice)
  `own`(apprentice)
  `random_from_task_answer`(task_answer, max_quant)

class `tasks.models.``ApprenticeTaskAnswerQuerySet`(model=None, query=None, using=None, hints=None)
  `__module__` = 'tasks.models'
  `by_apprentice`(apprentice)
  `completed`()

class `tasks.models.``ApprenticeTaskMarkCriteriaApprenticeVideo`(id, created, modified, apprentice, apprentice_video, task_mark_criteria)
  exception `DoesNotExist`
    `__module__` = 'tasks.models'
    `__reduce__`()
    `__setstate__`(args)
  exception `MultipleObjectsReturned`
    `__module__` = 'tasks.models'
    `__reduce__`()
    `__setstate__`(args)
  `__module__` = 'tasks.models'
  `__str__`()

    Return str(self).

  `apprentice`

    Accessor to the related object on the forward side of a many-to-one or one-to-one (via ForwardOneToOneDescriptor subclass) relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    `child.parent` is a `ForwardManyToOneDescriptor` instance.

  `apprentice_id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `apprentice_video`

    Accessor to the related object on the forward side of a many-to-one or one-to-one (via ForwardOneToOneDescriptor subclass) relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    `child.parent` is a `ForwardManyToOneDescriptor` instance.

  `apprentice_video_id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `get_next_by_created`(**morekwargs)
  `get_next_by_modified`(**morekwargs)
  `get_previous_by_created`(**morekwargs)
  `get_previous_by_modified`(**morekwargs)
  `id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `objects` = <django.db.models.manager.Manager object>
  `task_mark_criteria`

    Accessor to the related object on the forward side of a many-to-one or one-to-one (via ForwardOneToOneDescriptor subclass) relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    `child.parent` is a `ForwardManyToOneDescriptor` instance.

  `task_mark_criteria_id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

class `tasks.models.``ApprenticeVideo`(id, created, modified, yt_video, reflection)
  exception `DoesNotExist`
    `__module__` = 'tasks.models'
    `__reduce__`()
    `__setstate__`(args)
  exception `MultipleObjectsReturned`
    `__module__` = 'tasks.models'
    `__reduce__`()
    `__setstate__`(args)
  `__module__` = 'tasks.models'
  `__str__`()

    Return str(self).

  `apprentice_scores`

    Accessor to the related objects manager on the reverse side of a many-to-one relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    `parent.children` is a `ReverseManyToOneDescriptor` instance.

    Most of the implementation is delegated to a dynamically defined manager class built by `create_forward_many_to_many_manager()` defined below.

  `apprentices`

    Accessor to the related objects manager on the forward and reverse sides of a many-to-many relation.

    In the example:

        class Pizza(Model):
            toppings = ManyToManyField(Topping, related_name='pizzas')

    `pizza.toppings` and `topping.pizzas` are `ManyToManyDescriptor` instances.

    Most of the implementation is delegated to a dynamically defined manager class built by `create_forward_many_to_many_manager()` defined below.

  `get_likes`()
  `get_next_by_created`(**morekwargs)
  `get_next_by_modified`(**morekwargs)
  `get_previous_by_created`(**morekwargs)
  `get_previous_by_modified`(**morekwargs)
  `id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `mentor_scores`

    Accessor to the related objects manager on the reverse side of a many-to-one relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    `parent.children` is a `ReverseManyToOneDescriptor` instance.

    Most of the implementation is delegated to a dynamically defined manager class built by `create_forward_many_to_many_manager()` defined below.

  `mentor_text_score`

    Accessor to the related object on the reverse side of a one-to-one relation.

    In the example:

        class Restaurant(Model):
            place = OneToOneField(Place, related_name='restaurant')

    `place.restaurant` is a `ReverseOneToOneDescriptor` instance.

  `objects` = <django.db.models.manager.Manager object>
  `reflection`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `task_answer_as_1`

    Accessor to the related object on the reverse side of a one-to-one relation.

    In the example:

        class Restaurant(Model):
            place = OneToOneField(Place, related_name='restaurant')

    `place.restaurant` is a `ReverseOneToOneDescriptor` instance.

  `task_answer_as_2`

    Accessor to the related object on the reverse side of a one-to-one relation.

    In the example:

        class Restaurant(Model):
            place = OneToOneField(Place, related_name='restaurant')

    `place.restaurant` is a `ReverseOneToOneDescriptor` instance.

  `yt_video`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

class `tasks.models.``ExerciseTaskPosition`(id, exercise, task, position)
  exception `DoesNotExist`
    `__module__` = 'tasks.models'
    `__reduce__`()
    `__setstate__`(args)
  exception `MultipleObjectsReturned`
    `__module__` = 'tasks.models'
    `__reduce__`()
    `__setstate__`(args)
  `__module__` = 'tasks.models'
  `__str__`()

    Return str(self).

  `exercise`

    Accessor to the related object on the forward side of a many-to-one or one-to-one (via ForwardOneToOneDescriptor subclass) relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    `child.parent` is a `ForwardManyToOneDescriptor` instance.

  `exercise_id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `next`()
  `objects` = <tasks.models.ExerciseTaskPositionManager object>
  `position`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `previous`()
  `task`

    Accessor to the related object on the forward side of a many-to-one or one-to-one (via ForwardOneToOneDescriptor subclass) relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    `child.parent` is a `ForwardManyToOneDescriptor` instance.

  `task_id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

class `tasks.models.``ExerciseTaskPositionManager`
  `__module__` = 'tasks.models'
  `__slotnames__` = []
  `active`()
  `annotated_with_done_by_apprentice`(apprentice)

class `tasks.models.``MentorApprenticeVideoOpinion`(id, created, modified, mentor, apprentice_video, opinion)
  exception `DoesNotExist`
    `__module__` = 'tasks.models'
    `__reduce__`()
    `__setstate__`(args)
  exception `MultipleObjectsReturned`
    `__module__` = 'tasks.models'
    `__reduce__`()
    `__setstate__`(args)
  `__module__` = 'tasks.models'
  `__str__`()

    Return str(self).

  `apprentice_video`

    Accessor to the related object on the forward side of a one-to-one relation.

    In the example:

        class Restaurant(Model):
            place = OneToOneField(Place, related_name='restaurant')

    `restaurant.place` is a `ForwardOneToOneDescriptor` instance.

  `apprentice_video_id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `get_next_by_created`(**morekwargs)
  `get_next_by_modified`(**morekwargs)
  `get_previous_by_created`(**morekwargs)
  `get_previous_by_modified`(**morekwargs)
  `id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `mentor`

    Accessor to the related object on the forward side of a many-to-one or one-to-one (via ForwardOneToOneDescriptor subclass) relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    `child.parent` is a `ForwardManyToOneDescriptor` instance.

  `mentor_id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `objects` = <django.db.models.manager.Manager object>
  `opinion`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

class `tasks.models.``MentorTaskMarkCriteriaApprenticeVideoValue`(id, created, modified, mentor, apprentice_video, task_mark_criteria, value)
  exception `DoesNotExist`
    `__module__` = 'tasks.models'
    `__reduce__`()
    `__setstate__`(args)
  exception `MultipleObjectsReturned`
    `__module__` = 'tasks.models'
    `__reduce__`()
    `__setstate__`(args)
  `__module__` = 'tasks.models'
  `__str__`()

    Return str(self).

  `apprentice_video`

    Accessor to the related object on the forward side of a many-to-one or one-to-one (via ForwardOneToOneDescriptor subclass) relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    `child.parent` is a `ForwardManyToOneDescriptor` instance.

  `apprentice_video_id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `get_next_by_created`(**morekwargs)
  `get_next_by_modified`(**morekwargs)
  `get_previous_by_created`(**morekwargs)
  `get_previous_by_modified`(**morekwargs)
  `id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `mentor`

    Accessor to the related object on the forward side of a many-to-one or one-to-one (via ForwardOneToOneDescriptor subclass) relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    `child.parent` is a `ForwardManyToOneDescriptor` instance.

  `mentor_id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `objects` = <tasks.models.MentorTaskMarkCriteriaApprenticeVideoValueManager object>
  `task_mark_criteria`

    Accessor to the related object on the forward side of a many-to-one or one-to-one (via ForwardOneToOneDescriptor subclass) relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    `child.parent` is a `ForwardManyToOneDescriptor` instance.

  `task_mark_criteria_id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `value`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

class `tasks.models.``MentorTaskMarkCriteriaApprenticeVideoValueManager`
  `__module__` = 'tasks.models'
  `__slotnames__` = []

class `tasks.models.``MentorTaskMarkCriteriaApprenticeVideoValueQuerySet`(model=None, query=None, using=None, hints=None)
  `__module__` = 'tasks.models'
  `average`()
  `group_averages`()

class `tasks.models.``Path`(id, name, is_path_blocking, image, position)
  exception `DoesNotExist`
    `__module__` = 'tasks.models'
    `__reduce__`()
    `__setstate__`(args)
  exception `MultipleObjectsReturned`
    `__module__` = 'tasks.models'
    `__reduce__`()
    `__setstate__`(args)
  `__module__` = 'tasks.models'
  `__str__`()

    Return str(self).

  `id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `image`

    Just like the FileDescriptor, but for ImageFields. The only difference is assigning the width/height to the width_field/height_field, if appropriate.

  `is_path_blocking`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `name`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `objects` = <tasks.models.PathManager object>
  `position`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `slug`()
  `tasks`

    Accessor to the related objects manager on the reverse side of a many-to-one relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    `parent.children` is a `ReverseManyToOneDescriptor` instance.

    Most of the implementation is delegated to a dynamically defined manager class built by `create_forward_many_to_many_manager()` defined below.

class `tasks.models.``PathManager`
  `__module__` = 'tasks.models'
  `__slotnames__` = []
  `active`()

class `tasks.models.``Task`(id, path, is_active, title, subtitle, header, image, yt_video, description, instruction, position)
  exception `DoesNotExist`
    `__module__` = 'tasks.models'
    `__reduce__`()
    `__setstate__`(args)
  exception `MultipleObjectsReturned`
    `__module__` = 'tasks.models'
    `__reduce__`()
    `__setstate__`(args)
  `__module__` = 'tasks.models'
  `__str__`()

    Return str(self).

  `all_exercises_count`()
  `all_exercises_done`(apprentice)
  `answers`

    Accessor to the related objects manager on the reverse side of a many-to-one relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    `parent.children` is a `ReverseManyToOneDescriptor` instance.

    Most of the implementation is delegated to a dynamically defined manager class built by `create_forward_many_to_many_manager()` defined below.

  `articles`

    Accessor to the related objects manager on the forward and reverse sides of a many-to-many relation.

    In the example:

        class Pizza(Model):
            toppings = ManyToManyField(Topping, related_name='pizzas')

    `pizza.toppings` and `topping.pizzas` are `ManyToManyDescriptor` instances.

    Most of the implementation is delegated to a dynamically defined manager class built by `create_forward_many_to_many_manager()` defined below.

  `description`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `done_exercises_count`(apprentice)
  `exercise_task_positions`

    Accessor to the related objects manager on the reverse side of a many-to-one relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    `parent.children` is a `ReverseManyToOneDescriptor` instance.

    Most of the implementation is delegated to a dynamically defined manager class built by `create_forward_many_to_many_manager()` defined below.

  `exercises`

    Accessor to the related objects manager on the forward and reverse sides of a many-to-many relation.

    In the example:

        class Pizza(Model):
            toppings = ManyToManyField(Topping, related_name='pizzas')

    `pizza.toppings` and `topping.pizzas` are `ManyToManyDescriptor` instances.

    Most of the implementation is delegated to a dynamically defined manager class built by `create_forward_many_to_many_manager()` defined below.

  `get_in_path_position`()
  `header`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `image`

    Just like the FileDescriptor, but for ImageFields. The only difference is assigning the width/height to the width_field/height_field, if appropriate.

  `instruction`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `is_active`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `mark_criteria`

    Accessor to the related objects manager on the forward and reverse sides of a many-to-many relation.

    In the example:

        class Pizza(Model):
            toppings = ManyToManyField(Topping, related_name='pizzas')

    `pizza.toppings` and `topping.pizzas` are `ManyToManyDescriptor` instances.

    Most of the implementation is delegated to a dynamically defined manager class built by `create_forward_many_to_many_manager()` defined below.

  `objects` = <tasks.models.TaskManager object>
  `path`

    Accessor to the related object on the forward side of a many-to-one or one-to-one (via ForwardOneToOneDescriptor subclass) relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    `child.parent` is a `ForwardManyToOneDescriptor` instance.

  `path_id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `position`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `slug`()
  `subtitle`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `task_mark_criteria`

    Accessor to the related objects manager on the reverse side of a many-to-one relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    `parent.children` is a `ReverseManyToOneDescriptor` instance.

    Most of the implementation is delegated to a dynamically defined manager class built by `create_forward_many_to_many_manager()` defined below.

  `title`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `yt_video`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

class `tasks.models.``TaskManager`
  `__module__` = 'tasks.models'
  `__slotnames__` = []

class `tasks.models.``TaskMarkCriteria`(id, task, mark_criteria)
  exception `DoesNotExist`
    `__module__` = 'tasks.models'
    `__reduce__`()
    `__setstate__`(args)
  exception `MultipleObjectsReturned`
    `__module__` = 'tasks.models'
    `__reduce__`()
    `__setstate__`(args)
  `__module__` = 'tasks.models'
  `__str__`()

    Return str(self).

  `apprentice_scores`

    Accessor to the related objects manager on the reverse side of a many-to-one relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    `parent.children` is a `ReverseManyToOneDescriptor` instance.

    Most of the implementation is delegated to a dynamically defined manager class built by `create_forward_many_to_many_manager()` defined below.

  `id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `mark_criteria`

    Accessor to the related object on the forward side of a many-to-one or one-to-one (via ForwardOneToOneDescriptor subclass) relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    `child.parent` is a `ForwardManyToOneDescriptor` instance.

  `mark_criteria_id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `mentor_scores`

    Accessor to the related objects manager on the reverse side of a many-to-one relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    `parent.children` is a `ReverseManyToOneDescriptor` instance.

    Most of the implementation is delegated to a dynamically defined manager class built by `create_forward_many_to_many_manager()` defined below.

  `objects` = <tasks.models.TaskMarkCriteriaManager object>
  `task`

    Accessor to the related object on the forward side of a many-to-one or one-to-one (via ForwardOneToOneDescriptor subclass) relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    `child.parent` is a `ForwardManyToOneDescriptor` instance.

  `task_id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

class `tasks.models.``TaskMarkCriteriaManager`
  `__module__` = 'tasks.models'
  `__slotnames__` = []
  `from_apprentice_video_with_likes`(apprentice_video)

class `tasks.models.``TaskQuerySet`(model=None, query=None, using=None, hints=None)
  `__module__` = 'tasks.models'
  `active`()

class `users.models.``Apprentice`(id, password, last_login, is_superuser, username, first_name, last_name, email, is_staff, is_active, date_joined, user_ptr, activation_key, intro_videos)
  exception `DoesNotExist`
    `__module__` = 'users.models'
    `__reduce__`()
    `__setstate__`(args)
  exception `MultipleObjectsReturned`
    `__module__` = 'users.models'
    `__reduce__`()
    `__setstate__`(args)
  `USERNAME_FIELD` = 'email'
  `__module__` = 'users.models'
  `__str__`()

    Return str(self).

  `activation_key`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `answers`

    Accessor to the related objects manager on the reverse side of a many-to-one relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    `parent.children` is a `ReverseManyToOneDescriptor` instance.

    Most of the implementation is delegated to a dynamically defined manager class built by `create_forward_many_to_many_manager()` defined below.

  `apprentice_scores`

    Accessor to the related objects manager on the reverse side of a many-to-one relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    `parent.children` is a `ReverseManyToOneDescriptor` instance.

    Most of the implementation is delegated to a dynamically defined manager class built by `create_forward_many_to_many_manager()` defined below.

  `exercise_set`

    Accessor to the related objects manager on the forward and reverse sides of a many-to-many relation.

    In the example:

        class Pizza(Model):
            toppings = ManyToManyField(Topping, related_name='pizzas')

    `pizza.toppings` and `topping.pizzas` are `ManyToManyDescriptor` instances.

    Most of the implementation is delegated to a dynamically defined manager class built by `create_forward_many_to_many_manager()` defined below.

  `generate_activation_key`()
  `intro_videos`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `liked_apprentice_videos`

    Accessor to the related objects manager on the forward and reverse sides of a many-to-many relation.

    In the example:

        class Pizza(Model):
            toppings = ManyToManyField(Topping, related_name='pizzas')

    `pizza.toppings` and `topping.pizzas` are `ManyToManyDescriptor` instances.

    Most of the implementation is delegated to a dynamically defined manager class built by `create_forward_many_to_many_manager()` defined below.

  `save`(*args, **kwargs)

    Saves the current instance. Override this in a subclass if you want to control the saving process.

    The «force_insert» and «force_update» parameters can be used to insist that the „save” must be an SQL insert or update (or equivalent for non-SQL backends), respectively. Normally, they should not be set.

  `user_ptr`

    Accessor to the related object on the forward side of a one-to-one relation.

    In the example:

        class Restaurant(Model):
            place = OneToOneField(Place, related_name='restaurant')

    `restaurant.place` is a `ForwardOneToOneDescriptor` instance.

  `user_ptr_id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

class `users.models.``Mentor`(id, password, last_login, is_superuser, username, first_name, last_name, email, is_staff, is_active, date_joined, user_ptr)
  exception `DoesNotExist`
    `__module__` = 'users.models'
    `__reduce__`()
    `__setstate__`(args)
  exception `MultipleObjectsReturned`
    `__module__` = 'users.models'
    `__reduce__`()
    `__setstate__`(args)
  `__module__` = 'users.models'
  `__str__`()

    Return str(self).

  `mentor_scores`

    Accessor to the related objects manager on the reverse side of a many-to-one relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    `parent.children` is a `ReverseManyToOneDescriptor` instance.

    Most of the implementation is delegated to a dynamically defined manager class built by `create_forward_many_to_many_manager()` defined below.

  `mentor_text_score`

    Accessor to the related objects manager on the reverse side of a many-to-one relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    `parent.children` is a `ReverseManyToOneDescriptor` instance.

    Most of the implementation is delegated to a dynamically defined manager class built by `create_forward_many_to_many_manager()` defined below.

  `user_ptr`

    Accessor to the related object on the forward side of a one-to-one relation.

    In the example:

        class Restaurant(Model):
            place = OneToOneField(Place, related_name='restaurant')

    `restaurant.place` is a `ForwardOneToOneDescriptor` instance.

  `user_ptr_id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

# Widoki

class `articles.views.``ArticleDetailView`(**kwargs)

  Widok reprezentujący bazę wiedzy - podedynczy artykuł

  `__module__` = 'articles.views'
  `context_object_name` = 'selected_article'
  `dispatch`(request, *args, **kwargs)
  `get_context_data`(**kwargs)

    Insert the single object into the context dict.

  `get_queryset`()

    Return the QuerySet that will be used to look up the object.

    Note that this method is called by the default implementation of get_object and may not be called if get_object is overridden.

  `pk_url_kwarg` = 'article_id'
  `template_name` = 'articles/article.html'

class `articles.views.``ArticleListView`(**kwargs)

  Widok reprezentujący bazę wiedzy - listę artykułów

  `__module__` = 'articles.views'
  `context_object_name` = 'active_articles'
  `dispatch`(request, *args, **kwargs)
  `get_queryset`()

    Return the list of items for this view.

    The return value must be an iterable and may be an instance of QuerySet in which case QuerySet specific behavior will be enabled.

  `intro_popup_type` = 0
  `template_name` = 'articles/article_list.html'

class `exercises.views.``ExerciseDetailView`(**kwargs)

  Widok reprezentujący wybrane ćwiczenie

  `__module__` = 'exercises.views'
  `context_object_name` = 'selected_exercise_task_position'
  `dispatch`(request, *args, **kwargs)
  `get_context_data`(**kwargs)

    Insert the single object into the context dict.

  `get_queryset`()

    Return the QuerySet that will be used to look up the object.

    Note that this method is called by the default implementation of get_object and may not be called if get_object is overridden.

  `pk_url_kwarg` = 'exercise_task_position_id'
  `template_name` = 'exercises/exercise.html'

class `exercises.views.``NotificationContent`(title='', description='', button_txt='', button_control_css_class='', button_href='', button_extra_arg='', **kwargs)
  `__dict__` = mappingproxy({'__module__': 'exercises.views', '__init__': <function NotificationContent.__init__>, 'from_type': <classmethod object>, '__dict__': <attribute '__dict__' of 'NotificationContent' objects>, '__weakref__': <attribute '__weakref__' of 'NotificationContent' objects>, '__doc__': None})
  `__init__`(title='', description='', button_txt='', button_control_css_class='', button_href='', button_extra_arg='', **kwargs)

    Initialize self. See help(type(self)) for accurate signature.

  `__module__` = 'exercises.views'
  `__weakref__`

    list of weak references to the object (if defined)

  classmethod `from_type`(notification_type)

class `tasks.views.``ActivePathsContextMixin`

  Mixin uzupełniający context o dostępne ścieżki

  `__module__` = 'tasks.views'
  `get_context_data`(**kwargs)

class `tasks.views.``IntroPopupContextMixin`
  `__module__` = 'tasks.views'
  `get_context_data`(**kwargs)
  `intro_popup_type` = None

class `tasks.views.``PathDetailView`(**kwargs)

  Widok reprezentujący wybraną ścieżkę

  `__module__` = 'tasks.views'
  `context_object_name` = 'selected_path'
  `dispatch`(request, *args, **kwargs)
  `get_context_data`(**kwargs)

    Insert the single object into the context dict.

  `get_queryset`()

    Return the QuerySet that will be used to look up the object.

    Note that this method is called by the default implementation of get_object and may not be called if get_object is overridden.

  `pk_url_kwarg` = 'path_id'
  `template_name` = 'tasks/path.html'

class `tasks.views.``PathListView`(**kwargs)

  Widok reprezentujący moduł Ucz się. Umożliwiającą przejście do wybranej ścieżki

  `__module__` = 'tasks.views'
  `dispatch`(request, *args, **kwargs)
  `get_context_data`(**kwargs)
  `intro_popup_type` = 1
  `template_name` = 'tasks/path_list.html'

class `tasks.views.``TaskAnswerDetailView`(**kwargs)

  Widok reprezentujący odpowiedz do zadania, szczegoly z widoku moje filmy i oceniaj

  `__module__` = 'tasks.views'
  `context_object_name` = 'selected_task_answer'
  `dispatch`(request, *args, **kwargs)
  `get_context_data`(**kwargs)

    Insert the single object into the context dict.

  `get_queryset`()

    Return the QuerySet that will be used to look up the object.

    Note that this method is called by the default implementation of get_object and may not be called if get_object is overridden.

  `pk_url_kwarg` = 'task_answer_id'
  `template_name` = 'tasks/task_answer.html'

class `tasks.views.``TaskAnswerListView`(**kwargs)

  Widok reprezentujący listę odpowiedzi na zadania (moje filmy oraz oceniaj)

  `__module__` = 'tasks.views'
  `dispatch`(request, *args, **kwargs)
  `elements_quant` = 9
  `get_context_data`(**kwargs)
  `intro_popup_type` = 2
  `process_with_query_attributes`(queryset)
  `template_name` = 'tasks/task_answer_list.html'

class `tasks.views.``TaskAnswerSubmittingView`(**kwargs)

  Widok reprezentujący wybrane zadanie

  `__module__` = 'tasks.views'
  `context_object_name` = 'task_answer'
  `dispatch`(request, *args, **kwargs)
  `form_class`

    alias klasy `tasks.forms.ApprenticeTaskAnswerForm`

  `form_valid`(form)

    If the form is valid, redirect to the supplied URL.

  `get_context_data`(**kwargs)

    Insert the single object into the context dict.

  `get_queryset`()

    Return the QuerySet that will be used to look up the object.

    Note that this method is called by the default implementation of get_object and may not be called if get_object is overridden.

  `model`

    alias klasy `tasks.models.ApprenticeTaskAnswer`

  `pk_url_kwarg` = 'task_answer_id'
  `post`(request, *args, **kwargs)

    Handles POST requests, instantiating a form instance with the passed POST variables and then checked for validity.

  `template_name` = 'tasks/task.html'

class `tasks.views.``TaskDetailView`(**kwargs)

  Widok reprezentujący wybrane zadanie

  `__module__` = 'tasks.views'
  `context_object_name` = 'selected_task'
  `dispatch`(request, *args, **kwargs)
  `form_class`

    alias klasy `tasks.forms.ApprenticeTaskAnswerForm`

  `form_valid`(form)

    If the form is valid, redirect to the supplied URL.

  `get`(request, *args, **kwargs)

    Handles GET requests and instantiates a blank version of the form.

  `get_context_data`(**kwargs)

    Insert the single object into the context dict.

  `get_queryset`()

    Return the QuerySet that will be used to look up the object.

    Note that this method is called by the default implementation of get_object and may not be called if get_object is overridden.

  `pk_url_kwarg` = 'task_id'
  `template_name` = 'tasks/task.html'

class `tasks.views.``TaskNotificationsContentContextMixin`
  `__module__` = 'tasks.views'
  `get_context_data`(**kwargs)

class `users.views.``ActivationView`(**kwargs)

  Widok aktywacji po rejestracji użytkownika.

  `__module__` = 'users.views'
  `dispatch`(request, *args, **kwargs)
  `get`(request, *args, **kwargs)
  `login_button` = True
  `subtitle_error` = 'Twoje konto było już wcześniej aktywowane, lub link jest nieprawidłowy.'
  `subtitle_success` = 'Twoje konto zostalo aktywowane, możesz teraz zalogować się do portalu.'
  `success_url` = '/users/login/'
  `template_name` = 'users/generic.html'
  `title_error` = 'Wystąpił problem'
  `title_success` = 'Świetnie!'

class `users.views.``LoginView`(**kwargs)

  Widok logowania użytkownika.

  `__module__` = 'users.views'
  `dispatch`(request, *args, **kwargs)
  `form_class`

    alias klasy `users.forms.ApprenticeAuthenticationForm`

  `get_context_data`(**kwargs)

    Insert the form into the context dict.

  `subtitle` = 'Doskonal sztukę prezentacji pod okiem mentorów, otrzymuj cenne uwagi i opinie od społeczności.'
  `template_name` = 'users/login.html'
  `title` = 'Twoje miejsce gdzie możesz prezentować siebie'

class `users.views.``LogoutView`(**kwargs)

  Widok wylogowania użytkownika.

  `__module__` = 'users.views'
  `dispatch`(request, *args, **kwargs)
  `next_page` = 'users:login'

class `users.views.``PasswordChangeDoneView`(**kwargs)

  Widok zmiany hasła użytkownika - podsumowanie.

  `__module__` = 'users.views'
  `dispatch`(request, *args, **kwargs)
  `login_button` = True
  `subtitle` = 'Możesz teraz zalogować się do portalu'
  `template_name` = 'users/generic.html'
  `title` = 'Hasło zostało ponownie ustawione'

class `users.views.``PasswordChangeView`(**kwargs)

  Widok zmiany hasła użytkownika.

  `__module__` = 'users.views'
  `dispatch`(*args, **kwargs)
  `form_class`

    alias klasy `users.forms.ApprenticePasswordChangeForm`

  `subtitle` = 'Możesz teraz ustawić nowe hasło do portalu'
  `success_url` = '/users/change_password_done/'
  `template_name` = 'users/password_change.html'
  `title` = 'Podaj hasło'

class `users.views.``PasswordResetDoneView`(**kwargs)

  Widok resetowania hasła użytkownika - podsumowanie.

  `__module__` = 'users.views'
  `dispatch`(request, *args, **kwargs)
  `subtitle` = 'Na podany adres email został wysłany link umożliwiający zmianę hasła'
  `template_name` = 'users/generic.html'
  `title` = 'Email wysłany'

class `users.views.``PasswordResetView`(**kwargs)

  Widok resetowania hasła użytkownika.

  `__module__` = 'users.views'
  `dispatch`(*args, **kwargs)
  `form_class`

    alias klasy `users.forms.ApprenticePasswordResetForm`

  `subtitle` = 'Podaj adres email który jest przypisany do Twojego konta'
  `success_url` = '/users/reset_password_done/'
  `template_name` = 'users/password_reset.html'
  `title` = 'Ustaw nowe hasło'

class `users.views.``ProfileView`(**kwargs)

  Widok profilu użytkownika.

  `__module__` = 'users.views'
  `dispatch`(request, *args, **kwargs)
  `form_class`

    alias klasy `users.forms.ApprenticeUpdateForm`

  `form_valid`(form)

    If the form is valid, redirect to the supplied URL.

  `get_context_data`(**kwargs)

    Insert the form into the context dict.

  `get_form`(form_class=None)

    Returns an instance of the form to be used in this view.

  `success_url` = '/users/profile/'
  `template_name` = 'users/profile.html'

class `users.views.``RegisterView`(**kwargs)
  `__module__` = 'users.views'
  `dispatch`(request, *args, **kwargs)
  `form_class`

    alias klasy `users.forms.ApprenticeCreateForm`

  `form_valid`(form)

    If the form is valid, redirect to the supplied URL.

  `subtitle` = 'Doskonal sztukę prezentacji pod okiem mentorów, otrzymuj cenne uwagi i opinie od społeczności.'
  `success_url` = '/users/login/'
  `template_name` = 'users/register.html'
  `title` = 'Twoje miejsce gdzie możesz prezentować siebie'

class `users.views.``TitleSubtitleContextMixin`

  Mixin uzupełniający context o tytuł i podtytuł widoczny z lewej strony

  `__module__` = 'users.views'
  `get_context_data`(**kwargs)
  `login_button` = False
  `subtitle` = ''
  `title` = ''