smoothglue_django_map 0.0.5__tar.gz

smoothglue_django_map-0.0.5/LICENSE

@@ -0,0 +1,11 @@
+Copyright 2020–2025, BrainGu LLC. All rights reserved.
+
+This software is part of SmoothGlue™, a proprietary product developed by BrainGu LLC.
+
+This software is proprietary and confidential. It may not be copied, modified, distributed,
+or used in any form except under a valid commercial license agreement with BrainGu.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EXPRESS OR IMPLIED,
+INCLUDING BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
+
+To inquire about licensing, contact: legal@braingu.com

smoothglue_django_map-0.0.5/PKG-INFO

@@ -0,0 +1,104 @@
+Metadata-Version: 2.3
+Name: smoothglue_django_map
+Version: 0.0.5
+Summary: A Django app to do anything with Django.
+License: Proprietary
+Keywords: Interoperability,API Integration,Edge Computing,Application Framework,Data-Driven Development,Map
+Author: SmoothGlue
+Maintainer: BrainGu
+Maintainer-email: smoothglue@braingu.com
+Requires-Python: >= 3.12
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: django (>=3.2)
+Requires-Dist: smoothglue-django-core (>=1.5.3,<2.0.0)
+Project-URL: Homepage, https://braingu.com/solutions/smoothglue/
+Description-Content-Type: text/markdown
+
+# SmoothGlue Django Map App
+
+This Django app provides backend api to support front end Map features such as Map Imagery Layers, CZML / GeoJSON python helper classes (coming soon), etc.
+
+## Development
+
+### Set Up Virtual Environment and Install Required Packages
+
+This project uses [Poetry](https://python-poetry.org/) for dependency management and packaging.
+
+1. Install Poetry if you haven't already.
+2. Run `poetry install` to create a virtual environment and install dependencies.
+
+### Running Management Commands With Your App
+
+- **smoothglue/map/tests/boot_django.py** to set up a Django environment using Django’s settings.configure() and django.setup() to allow interacting with your app outside of a project.
+
+  - The settings.configure() call inside this file takes a list of arguments that are equivalent to the variables defined in a settings.py file. Anything you would need in your settings.py to make your app run gets passed into settings.configure().
+  - This file is used by the test runner and other scripts to bootstrap the environment.
+
+- **djangoshell.py** to spawn a Django shell that’s aware of your app
+- **loaddata.py "some argument"** load fixture data into your app's database and test out
+- **run_test.sh** to run all tests for your app (executes `smoothglue/map/tests/loadtests.py`)
+- **makemigrations.py** to create a migration file
+- **migrate.py** to perform table migrations
+
+## Using App Package (Locally)
+
+The steps for using your package locally are:
+
+### Build Your App
+
+Run `poetry build` inside the main level of this repo. This creates a directory called `dist` and builds your new package into source and binary formats (e.g., **smoothglue_django_map-<version>.tar.gz** and **smoothglue_django_map-<version>-py3-none-any.whl**).
+
+### Install App Inside a Django Project
+
+1. Before installing the package, make sure that there is a virtual environment set up inside of the Django project you want to install your app into.
+
+2. Then use pip or poetry to install the package:
+
+   ```bash
+   # Using pip
+   pip install [path to your newly packaged file]
+
+   # Using Poetry
+   poetry add [path to your newly packaged file]
+   ```
+
+3. Update the `settings.py` file inside that Django project to point to the new app name:
+
+   ```python
+   INSTALLED_APPS = [
+     "smoothglue.map",
+     ...,
+   ]
+   ```
+
+4. Update the `urls.py` file inside that Django project to point to the new app name: :
+
+   ```python
+   urlpatterns = [
+     path("", include("smoothglue.map.urls")),
+     ...,
+   ]
+   ```
+
+5. Run the development server to confirm the project continues to work.
+
+   [GIF COMING SOON]
+
+## Install App From Gitlab PyPI Package (Official Use)
+
+1. Before installing the package, make sure that there is a virtual environment set up inside of the Django project you want to install the app into.
+
+2. Use pip and the following command inside the Django project:
+   ```python
+   pip install <app_name> --index-url https://__token__:<your_personal_token>@code.dsop.structsure.io/api/v4/projects/<project_id>/packages/pypi/simple
+   ```
+
+## Other File Descriptions
+
+- MANIFEST.in - Tells the build process which non common files and folders that should be packaged
+- pyproject.toml - Package and project metadata / configuration
+- tox.ini - Used to configure different types of packages,
+

smoothglue_django_map-0.0.5/README.md

@@ -0,0 +1,84 @@
+# SmoothGlue Django Map App
+
+This Django app provides backend api to support front end Map features such as Map Imagery Layers, CZML / GeoJSON python helper classes (coming soon), etc.
+
+## Development
+
+### Set Up Virtual Environment and Install Required Packages
+
+This project uses [Poetry](https://python-poetry.org/) for dependency management and packaging.
+
+1. Install Poetry if you haven't already.
+2. Run `poetry install` to create a virtual environment and install dependencies.
+
+### Running Management Commands With Your App
+
+- **smoothglue/map/tests/boot_django.py** to set up a Django environment using Django’s settings.configure() and django.setup() to allow interacting with your app outside of a project.
+
+  - The settings.configure() call inside this file takes a list of arguments that are equivalent to the variables defined in a settings.py file. Anything you would need in your settings.py to make your app run gets passed into settings.configure().
+  - This file is used by the test runner and other scripts to bootstrap the environment.
+
+- **djangoshell.py** to spawn a Django shell that’s aware of your app
+- **loaddata.py "some argument"** load fixture data into your app's database and test out
+- **run_test.sh** to run all tests for your app (executes `smoothglue/map/tests/loadtests.py`)
+- **makemigrations.py** to create a migration file
+- **migrate.py** to perform table migrations
+
+## Using App Package (Locally)
+
+The steps for using your package locally are:
+
+### Build Your App
+
+Run `poetry build` inside the main level of this repo. This creates a directory called `dist` and builds your new package into source and binary formats (e.g., **smoothglue_django_map-<version>.tar.gz** and **smoothglue_django_map-<version>-py3-none-any.whl**).
+
+### Install App Inside a Django Project
+
+1. Before installing the package, make sure that there is a virtual environment set up inside of the Django project you want to install your app into.
+
+2. Then use pip or poetry to install the package:
+
+   ```bash
+   # Using pip
+   pip install [path to your newly packaged file]
+
+   # Using Poetry
+   poetry add [path to your newly packaged file]
+   ```
+
+3. Update the `settings.py` file inside that Django project to point to the new app name:
+
+   ```python
+   INSTALLED_APPS = [
+     "smoothglue.map",
+     ...,
+   ]
+   ```
+
+4. Update the `urls.py` file inside that Django project to point to the new app name: :
+
+   ```python
+   urlpatterns = [
+     path("", include("smoothglue.map.urls")),
+     ...,
+   ]
+   ```
+
+5. Run the development server to confirm the project continues to work.
+
+   [GIF COMING SOON]
+
+## Install App From Gitlab PyPI Package (Official Use)
+
+1. Before installing the package, make sure that there is a virtual environment set up inside of the Django project you want to install the app into.
+
+2. Use pip and the following command inside the Django project:
+   ```python
+   pip install <app_name> --index-url https://__token__:<your_personal_token>@code.dsop.structsure.io/api/v4/projects/<project_id>/packages/pypi/simple
+   ```
+
+## Other File Descriptions
+
+- MANIFEST.in - Tells the build process which non common files and folders that should be packaged
+- pyproject.toml - Package and project metadata / configuration
+- tox.ini - Used to configure different types of packages,

smoothglue_django_map-0.0.5/pyproject.toml

@@ -0,0 +1,108 @@
+[tool.poetry]
+name = "smoothglue_django_map"
+version = "0.0.6"
+description = "Enhance your development with SmoothGlue™, Map component for providing backend related map APIs."
+authors = ["BrainGu <smoothglue@braingu.com>"]
+maintainers = ["BrainGu <smoothglue@braingu.com>"]
+license = "Proprietary"
+readme = "README.md"
+homepage = "https://braingu.com/solutions/smoothglue/"
+keywords = [
+    "Interoperability",
+    "API Integration",
+    "Edge Computing",
+    "Application Framework",
+    "Data-Driven Development",
+    "Map"
+]
+packages = [
+    { include = "smoothglue" },
+    { include = "smoothglue/map" },
+    { include = "smoothglue/map/serializers" },
+    { include = "smoothglue/map/migrations" },
+]
+
+[tool.poetry.dependencies]
+python = "^3.12"
+
+[tool.poetry.group.dev.dependencies]
+pre-commit = "^3.7.1"
+black = "^24.4.2"
+isort = "^5.13.2"
+
+pylint = "^3.2.5"
+pylint-plugin-utils = "^0.8.2"
+pylint-django = "^2.5.5"
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[project]
+name = "smoothglue_django_map"
+version = "0.0.5"
+dependencies = [
+    "django>=3.2",
+    "smoothglue-django-core (>=1.5.3,<2.0.0)",
+]
+description = "A Django app to do anything with Django."
+readme = "README.md"
+requires-python = ">= 3.12"
+authors = [
+    {name = "SmoothGlue"},
+]
+
+[tool.setuptools]
+packages = ["smoothglue.map", "smoothglue.map.serializers", "smoothglue.map.migrations", "smoothglue.map.fixtures"]
+
+[project.urls]
+Homepage = "https://braingu.com/solutions/smoothglue/"
+
+
+[tool.black]
+exclude = '''
+/(
+    | venv
+    | migrations
+)/
+'''
+
+[tool.pylint.main]
+recursive = true
+fail-under = 10
+max-attributes = 15
+ignore-paths = [
+    "^.*migrations\\/.*$",
+    "^.*venv\\/.*$"
+]
+no-docstring-rgx = "(?:^_|^[Tt]est.+|Mock.+)"
+load-plugins = ["pylint_django"]
+
+[tool.pylint."messages control"]
+disable = [
+    "missing-module-docstring",
+    "E5110",
+]
+
+[tool.isort]
+profile = "black"
+
+[tool.pylint.design]
+exclude-too-few-public-methods = ["abc.ABC"]
+
+[tool.coverage.run]
+include = [
+    "smoothglue/*",
+]
+
+[tool.coverage.report]
+exclude_also = [
+    "class DefaultUploadProcessor",
+    "class DefaultValidator",
+    "class TestValidator",
+    "class TestPostProcessor",
+    # ignore abstract base classes
+    "class .+\\((?:abc\\.)?ABC\\)",
+    # ignore storage provider initalizers
+    "def init_minio_client",
+    "def init_s3_client"
+]

smoothglue_django_map-0.0.5/smoothglue/map/admin.py

@@ -0,0 +1,17 @@
+from django.contrib import admin
+
+from smoothglue.core.admin import DataAdmin
+from smoothglue.map.models import ImageryLayer
+
+
+class ImageryLayerAdmin(DataAdmin):
+    list_display = (
+        "name",
+        "provider_type",
+        "is_active",
+    )
+    list_editable = ("is_active",)
+    list_filter = ("provider_type",)
+
+
+admin.site.register(ImageryLayer, ImageryLayerAdmin)

smoothglue_django_map-0.0.5/smoothglue/map/apps.py

@@ -0,0 +1,7 @@
+from django.apps import AppConfig
+
+
+class MapConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "smoothglue.map"
+    verbose_name = "SmoothGlue Map"

smoothglue_django_map-0.0.5/smoothglue/map/fixtures/imagerylayer.json

@@ -0,0 +1,82 @@
+[
+    {
+        "model": "map.imagerylayer",
+        "pk": "021904c4-68f0-4207-8bee-9efed7ec56fe",
+        "fields": {
+            "name": "World Physical Map",
+            "url": "https://services.arcgisonline.com/arcgis/rest/services/World_Physical_Map/MapServer",
+            "provider_type": "AG",
+            "sort_order": 8
+        }
+    },
+    {
+        "model": "map.imagerylayer",
+        "pk": "319836c0-2812-4454-8e26-137f4e80f8de",
+        "fields": {
+            "name": "NatGeo World Map",
+            "url": "https://services.arcgisonline.com/arcgis/rest/services/NatGeo_World_Map/MapServer",
+            "provider_type": "AG",
+            "sort_order": 7
+        }
+    },
+    {
+        "model": "map.imagerylayer",
+        "pk": "421d599f-9898-4cac-bcb0-48c9d123a57f",
+        "fields": {
+            "name": "FAA Sectional",
+            "url": "https://tfsgis.tfs.tamu.edu/arcgis/rest/services/Aviation/FAA_Sectional_Charts/MapServer",
+            "provider_type": "AG",
+            "sort_order": 6
+        }
+    },
+    {
+        "model": "map.imagerylayer",
+        "pk": "4835b616-f678-442c-a9ba-5b96eecdf405",
+        "fields": {
+            "name": "World Shaded Relief",
+            "url": "https://services.arcgisonline.com/arcgis/rest/services/World_Shaded_Relief/MapServer",
+            "provider_type": "AG",
+            "sort_order": 5
+        }
+    },
+    {
+        "model": "map.imagerylayer",
+        "pk": "6667aa56-34b4-43fe-ab33-7da3d038ed6e",
+        "fields": {
+            "name": "World Street Map",
+            "url": "https://services.arcgisonline.com/arcgis/rest/services/World_Street_Map/MapServer",
+            "provider_type": "AG",
+            "sort_order": 4
+        }
+    },
+    {
+        "model": "map.imagerylayer",
+        "pk": "89fcdb03-eed9-4b23-a3e7-5fb1ec6ca56d",
+        "fields": {
+            "name": "World Topo Maps",
+            "url": "https://services.arcgisonline.com/arcgis/rest/services/World_Topo_Map/MapServer",
+            "provider_type": "AG",
+            "sort_order": 3
+        }
+    },
+    {
+        "model": "map.imagerylayer",
+        "pk": "e4611332-23d9-4a08-96db-b7860ebc4d00",
+        "fields": {
+            "name": "World Terrain Base",
+            "url": "https://services.arcgisonline.com/arcgis/rest/services/World_Terrain_Base/MapServer",
+            "provider_type": "NO",
+            "sort_order": 2
+        }
+    },
+    {
+        "model": "map.imagerylayer",
+        "pk": "e6227ca5-9e8a-4793-9e63-d8ffa6e858b7",
+        "fields": {
+            "name": "World Imagery",
+            "url": "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer",
+            "provider_type": "AG",
+            "sort_order": 1
+        }
+    }
+]

smoothglue_django_map-0.0.5/smoothglue/map/migrations/0001_initial.py

@@ -0,0 +1,51 @@
+# Generated by Django 4.2.13 on 2024-06-18 00:51
+
+import uuid
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    initial = True
+
+    dependencies = []
+
+    operations = [
+        migrations.CreateModel(
+            name="ImageryLayer",
+            fields=[
+                (
+                    "id",
+                    models.UUIDField(
+                        default=uuid.uuid4,
+                        editable=False,
+                        primary_key=True,
+                        serialize=False,
+                        unique=True,
+                    ),
+                ),
+                ("name", models.CharField(blank=True, max_length=64, unique=True)),
+                ("url", models.CharField(blank=True, max_length=512)),
+                (
+                    "provider_type",
+                    models.CharField(
+                        choices=[
+                            ("NO", "None"),
+                            ("AG", "ArcGis Map Server"),
+                            ("TL", "Tile Map Service"),
+                            ("BG", "Bing Map Imagery"),
+                            ("GG", "Google Earth Enterprise"),
+                            ("OS", "Open Street Map"),
+                            ("WM", "Web Map Tile Service"),
+                            ("UT", "Url Template Imagery"),
+                            ("GO", "Geo Server"),
+                        ],
+                        default="NO",
+                        max_length=2,
+                    ),
+                ),
+                ("sort_order", models.IntegerField(blank=True, null=True)),
+                ("is_active", models.BooleanField(default=True)),
+            ],
+        ),
+    ]

smoothglue_django_map-0.0.5/smoothglue/map/models.py

@@ -0,0 +1,32 @@
+import uuid
+
+from django.db import models
+
+
+class ImageryLayer(models.Model):
+    class MapImageryProviderType(models.TextChoices):
+        NONE = "NO", "None"
+        ARCGIS = "AG", "ArcGis Map Server"
+        TILE = "TL", "Tile Map Service"
+        BING = "BG", "Bing Map Imagery"
+        GOOGLE = "GG", "Google Earth Enterprise"
+        OPEN = "OS", "Open Street Map"
+        WEBMAP = "WM", "Web Map Tile Service"
+        URL = "UT", "Url Template Imagery"
+        GEO = "GO", "Geo Server"
+
+    id = models.UUIDField(
+        primary_key=True, unique=True, default=uuid.uuid4, editable=False
+    )
+    name = models.CharField(max_length=64, unique=True, blank=True, null=False)
+    url = models.CharField(max_length=512, blank=True, null=False)
+    provider_type = models.CharField(
+        max_length=2,
+        choices=MapImageryProviderType.choices,
+        default=MapImageryProviderType.NONE,
+    )
+    sort_order = models.IntegerField(blank=True, null=True)
+    is_active = models.BooleanField(default=True)
+
+    def __str__(self) -> str:
+        return f"{self.name} - {self.provider_type}"

smoothglue_django_map-0.0.5/smoothglue/map/serializers/imagery_layer.py

@@ -0,0 +1,15 @@
+from rest_framework import serializers
+
+from smoothglue.core.serializers.dynamic import DynamicModelSerializer
+from smoothglue.map.models import ImageryLayer
+
+
+class ImageryLayerSerializer(DynamicModelSerializer):
+
+    provider_type = serializers.CharField(
+        source="get_provider_type_display", read_only=True
+    )
+
+    class Meta:
+        model = ImageryLayer
+        fields = ["id", "name", "url", "provider_type", "sort_order", "is_active"]

smoothglue_django_map-0.0.5/smoothglue/map/tests/boot_django.py

@@ -0,0 +1,34 @@
+# boot_django.py
+#
+# This file sets up and configures Django. It's used by scripts that need to
+# execute as if running in a Django server.
+import os
+
+import django
+from django.conf import settings
+
+BASE_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), "smoothglue/map"))
+
+
+def boot_django():
+    # The settings.configure() call takes a list of args that are equivalent to variables
+    # defined in a settings.py file.
+    # Anything you would need in your settings.py to make your app run gets passed here
+    settings.configure(
+        BASE_DIR=BASE_DIR,
+        DEBUG=True,
+        DATABASES={
+            "default": {
+                "ENGINE": "django.db.backends.sqlite3",
+                "NAME": os.path.join(BASE_DIR, "db.sqlite3"),
+            }
+        },
+        INSTALLED_APPS=[
+            "django.contrib.contenttypes",
+            "django.contrib.auth",
+            "smoothglue.map",
+        ],
+        TIME_ZONE="UTC",
+        USE_TZ=True,
+    )
+    django.setup()

smoothglue_django_map-0.0.5/smoothglue/map/tests/loadtests.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python
+
+import sys
+from unittest import TestSuite
+
+from smoothglue.map.tests.boot_django import boot_django
+
+boot_django()
+
+default_labels = ["smoothglue/map/tests"]
+
+
+def get_suite(labels=default_labels):
+    from django.test.runner import DiscoverRunner
+
+    runner = DiscoverRunner(verbosity=1)
+    failures = runner.run_tests(labels)
+    if failures:
+        sys.exit(failures)
+
+    # In case this is called from setuptools, return a test suite
+    return TestSuite()
+
+
+if __name__ == "__main__":
+    labels = default_labels
+    if len(sys.argv[1:]) > 0:
+        labels = sys.argv[1:]
+
+    get_suite(labels)

smoothglue_django_map-0.0.5/smoothglue/map/tests/test_coordinate_utils.py

@@ -0,0 +1,12 @@
+from django.test import TestCase
+
+from smoothglue.map.utils.coordinate_utils import get_decimal_degrees_from_dms_string
+
+
+class TestCoordinateUtilsSerializer(TestCase):
+
+    def test_serializer_valid(self):
+
+        coordinate_str = "373420.50N1272218.92E"
+        result = get_decimal_degrees_from_dms_string(coordinate_str)
+        self.assertEqual(result, [127.37192222222221, 37.572361111111114])

smoothglue_django_map-0.0.5/smoothglue/map/tests/test_map_layers.py

@@ -0,0 +1,23 @@
+from django.test import TestCase
+
+from smoothglue.core.tests.utils import CommonSerializer
+from smoothglue.map.models import ImageryLayer
+from smoothglue.map.serializers.imagery_layer import ImageryLayerSerializer
+
+
+class TestImageryLayerJsonSerializer(TestCase):
+    def setUp(self):
+        self.image_layer_data = {
+            "name": "test",
+            "url": "http://braingu.com",
+            "provider_type": "ArcGisMapServerImageryProvider",
+        }
+
+        self.required_fields = []
+
+    def test_serializer_valid(self):
+        CommonSerializer(serializer=ImageryLayerSerializer).test_model_serializer_valid(
+            model=ImageryLayer,
+            required_fields=self.required_fields,
+            data=self.image_layer_data,
+        )

smoothglue_django_map-0.0.5/smoothglue/map/urls.py

@@ -0,0 +1,13 @@
+from django.urls import include, path
+from rest_framework import routers
+
+from smoothglue.map import views
+
+ROUTER = routers.DefaultRouter()
+
+ROUTER.register(
+    r"imagelayersviews", views.ImageryLayerViewset, basename="imagelayersviews"
+)
+
+
+urlpatterns = [path("", include(ROUTER.urls))]

smoothglue_django_map-0.0.5/smoothglue/map/utils/coordinate_utils.py

@@ -0,0 +1,70 @@
+import re
+
+
+def get_decimal_degrees_from_dms_string(dms_string):
+    """
+    Convert set data representing lat lon as a Degree Minute Second (DMS) value to Decimal Degrees
+    using formula: Decimal Degrees = degrees + (minutes/60) + (seconds/3600)
+
+    ACO coordinate set data comes in 2 varieties:
+    LATS (e.g. LATS:431026N1165028W) and LATM (e.g. LATM:4302N11553W)
+    Assumptions:
+        LATS format is Degrees Minutes Seconds and broken down as follows:
+        Index: 0  1  2  3  4  5  6  7
+        LATS:  43 10 26 N 116 50 28 W
+
+    """
+    index_dict = {
+        "lat_degree_index": 0,
+        "lat_minute_index": 1,
+        "lat_second_index": 2,
+        "lat_millisecond_index": 3,
+        "lat_direction_index": 4,
+        "lon_degree_index": 5,
+        "lon_minute_index": 6,
+        "lon_second_index": 7,
+        "lon_millisecond_index": 8,
+        "lon_direction_index": 9,
+    }
+
+    pattern = r"\s*(\d{2})+(\d{2})+(\d{2})+(\.\d{2})+([N|S])*(\d{3})+(\d{2})+(\d{2})+(\.\d{2})+([E|W])"
+
+    try:
+        lat_lon_set = re.findall(pattern, dms_string)[0]
+    except IndexError as exc:
+        raise ValueError(
+            f"There was an error parsing coordinate: {dms_string}."
+        ) from exc
+
+    lat_decimal = (
+        int(lat_lon_set[index_dict["lat_degree_index"]])
+        + int(lat_lon_set[index_dict["lat_minute_index"]]) / 60
+    )
+    lon_decimal = (
+        int(lat_lon_set[index_dict["lon_degree_index"]])
+        + int(lat_lon_set[index_dict["lon_minute_index"]]) / 60
+    )
+
+    lat_decimal += (
+        float(
+            lat_lon_set[index_dict["lat_second_index"]]
+            + lat_lon_set[index_dict["lat_millisecond_index"]]
+        )
+        / 3600
+    )
+    lon_decimal += (
+        float(
+            lat_lon_set[index_dict["lon_second_index"]]
+            + lat_lon_set[index_dict["lon_millisecond_index"]]
+        )
+        / 3600
+    )
+
+    if (
+        lat_lon_set[index_dict["lon_direction_index"]] == "S"
+        or lat_lon_set[index_dict["lon_direction_index"]] == "W"
+    ):
+        lon_decimal *= -1
+
+    # GeoJSON coordinates are in (lon, lat) format
+    return [lon_decimal, lat_decimal]

smoothglue_django_map-0.0.5/smoothglue/map/views.py

@@ -0,0 +1,11 @@
+from django_filters.rest_framework import DjangoFilterBackend
+
+from smoothglue.core.views import ListModelViewSet
+from smoothglue.map.models import ImageryLayer
+from smoothglue.map.serializers.imagery_layer import ImageryLayerSerializer
+
+
+class ImageryLayerViewset(ListModelViewSet):
+    filter_backends = [DjangoFilterBackend]
+    queryset = ImageryLayer.objects.filter(is_active=True).order_by("sort_order")
+    serializer_class = ImageryLayerSerializer