Skip to main content

Reusable django-app for outdoor and indoor mapping

Project description

CI build status Dependency monitoring downloads code style: black

Reusable django-app for storing GIS and indoor coordinates of objects.

Indoor coordinates Map coordinates Mobile coordinates


Compatibility Table

django-loci Python version
0.2 2.7 or >=3.4
0.3 - 0.4 >=3.6
0.5 >=3.7

Install stable version from pypi

Install from pypi:

pip install django-loci

Install development version

First of all, install the dependencies of GeoDjango:

Install tarball:

pip install

Alternatively you can install via pip using git:

pip install -e git+git://

If you want to contribute, install your cloned fork:

git clone<your_fork>/django-loci.git
cd django_loci
python develop

Setup (integrate in an existing django project)

First of all, set up your database engine to one of the spatial databases suppported by GeoDjango.

Add django_loci and its dependencies to INSTALLED_APPS in the following order:

    # ...
    # ...

Configure CHANNEL_LAYERS according to your needs, a sample configuration can be:

ASGI_APPLICATION = "django_loci.channels.routing.channel_routing"
    "default": {
        "BACKEND": "channels.layers.InMemoryChannelLayer",

Now run migrations:

./ migrate


Common issues and solutions when installing GeoDjango.

Unable to load the SpatiaLite library extension

If you get the following exception:

django.core.exceptions.ImproperlyConfigured: Unable to load the SpatiaLite library extension

You need to specify the SPATIALITE_LIBRARY_PATH in your as explained in the django documentation regarding how to install and configure spatialte.

Issues with other geospatial libraries

Please refer to the geodjango documentation on troubleshooting issues related to geospatial libraries.



type: str

The django file storage class used for uploading floorplan images.

The filestorage can be changed to a different one as long as it has an upload_to class method which will be passed to FloorPlan.image.upload_to.

To understand the details of this statement, take a look at the code of


type: str
default: ArcGIS

Service used for geocoding and reverse geocoding.

Supported geolocation services:

  • ArcGIS
  • Nominatim
  • GoogleV3 (Google Maps v3)


type: int
default: 1

Amount of seconds between geocoding retry API calls when geocoding requests fail.


type: int
default: 3

Amount of retry API calls when geocoding requests fail.


type: str
default: None

API key if required (eg: Google Maps).

System Checks


Use to check if geocoding is working as expected or not.

Run this checks with:

./ check --deploy --tag geocoding

Extending django-loci

django-loci provides a set of models and admin classes which can be imported, extended and reused by third party apps.

To extend django-loci, you MUST NOT add it to settings.INSTALLED_APPS, but you must create your own app (which goes into settings.INSTALLED_APPS), import the base classes of django-loci and add your customizations.

Extending models

This example provides an example of how to extend the base models of django-loci by adding a relation to another django model named Organization.

# of your app
from django.db import models
from django_loci.base.models import (AbstractFloorPlan,

# the model ``organizations.Organization`` is omitted for brevity
# if you are curious to see a real implementation, check out django-organizations

class OrganizationMixin(models.Model):
    organization = models.ForeignKey('organizations.Organization')

    class Meta:
        abstract = True

class Location(OrganizationMixin, AbstractLocation):
    class Meta(AbstractLocation.Meta):
        abstract = False

    def clean(self):
        # your own validation logic here...

class FloorPlan(OrganizationMixin, AbstractFloorPlan):
    location = models.ForeignKey(Location)

    class Meta(AbstractFloorPlan.Meta):
        abstract = False

    def clean(self):
        # your own validation logic here...

class ObjectLocation(OrganizationMixin, AbstractObjectLocation):
    location = models.ForeignKey(Location, models.PROTECT,
                                 blank=True, null=True)
    floorplan = models.ForeignKey(FloorPlan, models.PROTECT,
                                  blank=True, null=True)

    class Meta(AbstractObjectLocation.Meta):
        abstract = False

    def clean(self):
        # your own validation logic here...

Extending the admin

Following the previous Organization example, you can avoid duplicating the admin code by importing the base admin classes and registering your models with them.

But first you have to change a few settings in your, these are needed in order to load the admin templates and static files of django-loci even if it’s not listed in settings.INSTALLED_APPS.

Add django.forms to INSTALLED_APPS, now it should look like the following:

    # ...
    #      ↓
    'django.forms', # <-- add this
    #      ↑
    # ...


    # ...

EXTENDED_APPS = ('django_loci',)

Add openwisp_utils.staticfiles.DependencyFinder to STATICFILES_FINDERS:


Add openwisp_utils.loaders.DependencyLoader to TEMPLATES:

        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [],
        'OPTIONS': {
            'loaders': [
                # add the following line
            'context_processors': [

Last step, add FORM_RENDERER:

FORM_RENDERER = 'django.forms.renderers.TemplatesSetting'

Then you can go ahead and create your file following the example below:

# of your app
from django.contrib import admin

from django_loci.base.admin import (AbstractFloorPlanAdmin, AbstractFloorPlanForm,
                                    AbstractFloorPlanInline, AbstractLocationAdmin,
                                    AbstractLocationForm, AbstractObjectLocationForm,
from django_loci.models import FloorPlan, Location, ObjectLocation

class FloorPlanForm(AbstractFloorPlanForm):
    class Meta(AbstractFloorPlanForm.Meta):
        model = FloorPlan

class FloorPlanAdmin(AbstractFloorPlanAdmin):
    form = FloorPlanForm

class LocationForm(AbstractLocationForm):
    class Meta(AbstractLocationForm.Meta):
        model = Location

class FloorPlanInline(AbstractFloorPlanInline):
    form = FloorPlanForm
    model = FloorPlan

class LocationAdmin(AbstractLocationAdmin):
    form = LocationForm
    inlines = [FloorPlanInline]

class ObjectLocationForm(AbstractObjectLocationForm):
    class Meta(AbstractObjectLocationForm.Meta):
        model = ObjectLocation

class ObjectLocationInline(AbstractObjectLocationInline):
    model = ObjectLocation
    form = ObjectLocationForm, FloorPlanAdmin), LocationAdmin)

Extending channel consumers

Extend the channel consumer of django-loci in this way:

from django_loci.channels.base import BaseLocationBroadcast
from ..models import Location  # your own location model

class LocationBroadcast(BaseLocationBroadcast):
    model = Location

Extending AppConfig

You may want to reuse the AppConfig class of django-loci too:

from django_loci.apps import LociConfig

class MyConfig(LociConfig):
    name = 'myapp'
    verbose_name = _('My custom app')

    def __setmodels__(self):
        from .models import Location
        self.location_model = Location

Installing for development

Install sqlite:

sudo apt-get install sqlite3 libsqlite3-dev libsqlite3-mod-spatialite gdal-bin

Install your forked repo:

git clone git://<your_fork>/django-loci
cd django-loci/
python develop

Install test requirements:

pip install -r requirements-test.txt

Create database:

cd tests/
./ migrate
./ createsuperuser

Launch development server and SMTP debugging server:

./ runserver

You can access the admin interface at

Run tests with:

# pytests is used to test django-channels
./ && pytest


  1. Announce your intentions in the OpenWISP Mailing List
  2. Fork this repo and install it
  3. Follow PEP8, Style Guide for Python Code
  4. Write code
  5. Write tests for your code
  6. Ensure all tests pass
  7. Ensure test coverage does not decrease
  8. Document your changes
  9. Send pull request





Project details

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

django-loci-1.0.1.tar.gz (42.0 kB view hashes)

Uploaded source

Built Distribution

django_loci-1.0.1-py2.py3-none-any.whl (47.6 kB view hashes)

Uploaded py2 py3

Supported by

AWS AWS Cloud computing Datadog Datadog Monitoring Facebook / Instagram Facebook / Instagram PSF Sponsor Fastly Fastly CDN Google Google Object Storage and Download Analytics Huawei Huawei PSF Sponsor Microsoft Microsoft PSF Sponsor NVIDIA NVIDIA PSF Sponsor Pingdom Pingdom Monitoring Salesforce Salesforce PSF Sponsor Sentry Sentry Error logging StatusPage StatusPage Status page