semvec/pypi-packages huggingface dataset:
django-super-inlines 0.2.2
Adds useful features to inlines, such as the ability to nest them.
License: BSD

Django-super-inlines
====================

For now, it only adds nested inlines (see `Django#9025 <https://code.djangoproject.com/ticket/9025>`_).
But I also plan to add other features I developed for my own projects.

**There is no unit tests for the moment, so use at your own risks.**

**It would be extremely useful if someone took time to write Selenium tests.**


Usage
-----

It’s only compatible with Django 1.7.2 to 1.7.8 (I tested) and probably 1.8.
Don’t even try with previous versions, django-super-inlines relies on changes
that happened between 1.6 and 1.7.2.

For design reasons, you can’t nest inlines inside tabular inlines,
only inside stacked inlines.

1. `pip install django-super-inlines`
2. Add ``'super_inlines',`` to ``INSTALLED_APPS``
   **before** ``'django.contrib.admin',``
3. If you use django-grappelli, add ``'super_inlines.grappelli_integration',``
   to ``INSTALLED_APPS`` **before** ``'grappelli',`` and ``'super_inlines',``
4. Inherit from ``SuperModelAdmin`` instead of ``ModelAdmin``,
   ``SuperInlineModelAdmin`` instead of ``InlineModelAdmin``, and use the class
   attribute ``inlines`` in inlines as you do in model admins

Example usage:

.. code-block:: python

    from django.contrib.admin import TabularInline, StackedInline, site
    from super_inlines.admin import SuperInlineModelAdmin, SuperModelAdmin

    from .models import *


    class RoomInlineAdmin(SuperInlineModelAdmin, TabularInline):
        model = Room


    class HouseInlineAdmin(SuperInlineModelAdmin, StackedInline):
        model = House
        inlines = (RoomInlineAdmin,)


    class OwnerAdmin(SuperModelAdmin):
        inlines = (HouseInlineAdmin,)


    site.register(Owner, OwnerAdmin)
robo-pid 0.2.6
PID Controller For Mobile Robotic Regulators
License: BSD
Keywords: PID,controllers,regulators,discrete time systems,mobile robotics,robotics

**robo-pid** 

A Python PID Controller For Mobile Robotics

**RoboPID** is PID controller designed to handle the combined kinematic 
and dynamic complexity of mobile robotics. The controller implements timestep
integration and can be used in discretized time regulators.


**RoboPID** has proven to be a tested, reliable PID controller that can
regulate the dynamic balance and rapid response required for differential drive
linear and lateral wheeled motion control. It has been used, for example with mobile
robotic systems for LVC (Linear Velocity Control) for regulating wheel velocities, 
LVDR (Lateral Velocity Differential Regulator) for keeping the wheel velocities in sync for 
differential drive mobile robots when traversing a straight line path and 
ADVR (Angular Differential Velocity Regulator) for tracking a heading angle using typical
motion control input signals (v,w) for linear velocities and angular orientation rotational rates.


The PID controller supports 2 modes of operation: **Integrative** and **Iterative**

In **Integrative Mode**, the timestep integrations are calculated inside the controller
and the output from the PID controller for the current timestep is used directly or with 
modifications and sent to the device or process plant as the current input signal without
further iterative integration.

In **Iterative Mode**, the PID timestep integrations are manually calculated and updated
outside the controller in the algorithm that calls the PID controller for the output of
the PID at the current timestep.


Installation: 

$ **pip** install robo-pid

For documentation see https://robo-pid.readthedocs.io/en/latest/