psat-server-web 0.4.2__tar.gz → 0.5.0__tar.gz

psat_server_web-0.5.0/PKG-INFO

@@ -0,0 +1,131 @@
+Metadata-Version: 2.1
+Name: psat-server-web
+Version: 0.5.0
+Summary: Pan-STARRS and ATLAS web interface.
+Home-page: https://github.com/genghisken/psat-server-web
+Author: genghisken
+Author-email: ken.w.smith@gmail.com
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Topic :: Utilities
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: mysqlclient
+Requires-Dist: django<4.2
+Requires-Dist: django_tables2
+Requires-Dist: djangorestframework
+Requires-Dist: mod-wsgi
+Requires-Dist: pyyaml
+Requires-Dist: docopt
+Requires-Dist: python-dotenv
+Requires-Dist: gkhtm
+Requires-Dist: gkutils>=0.3.2
+Requires-Dist: requests
+Requires-Dist: lasair
+Requires-Dist: dustmaps
+
+# psat-server-web
+Python 3 web interface for the Pan-STARRS and ATLAS surveys.
+
+To install:
+
+pip install psat-server-web
+
+Once installed, don't forget to add the "data" symlinks in the:
+
+site-packages/psat\_server\_web/atlas/media/images
+site-packages/psat\_server\_web/ps1/media/images
+
+directories which point to the location of the image stamps.
+
+--- 
+
+# Local development version 
+
+A localised development instance can be run with docker compose. You will need a 
+`.env` file in your repository root to define some environment variables, 
+looking something like:
+
+``` .env
+# Django settings
+SECRET_KEY={YOUR_SECRET_KEY_HERE}
+DJANGO_ALLOWED_HOSTS=localhost 127.0.0.1 [::1]
+
+# MySQL/MariaDB settings
+MYSQL_ROOT_USER=root
+MYSQL_ROOT_PASSWORD=root
+MYSQL_DATABASE=atlas
+MYSQL_USER=atlas
+MYSQL_PASSWORD=atlas
+MYSQL_PORT=3306
+MYSQL_TEST_DATABASE=atlas_test
+MYSQL_TEST_PORT=3306
+MYSQL_TEST_USER=root
+MYSQL_TEST_PASSWORD=root
+
+DJANGO_MYSQL_DBUSER=atlas
+DJANGO_LASAIR_TOKEN=
+
+```
+
+Several of the values are omitted but aren't necessary to run a development 
+environment. Also ruch simple passwords should not be used in production, but this should get you something running locally. Hopefully it's then as simple as running the following:
+
+``` bash
+docker compose up
+```
+
+Which will start 4 services, comprised of:
+- `db` - A MariaDB instance. By default served at `localhost:3036` 
+- `atlas-web` - A mod-wsgi instance to serve the django front end. By default 
+served at `localhost:8086` and requires `db` to be running.
+- `adminer` - A web interface for interacting with the db. By default served 
+at `localhost:8080` and requires `db` to be running.
+- `tests` - A single-use run of the unit tests using django's `manage.py test`. 
+Requires `db` to be running.
+
+Each of these services can be run independently with 
+
+``` bash
+docker compose up {service_name}
+```
+
+So if, for example, you wanted to run the tests you could execute 
+`docker compose up tests` and it would – after starting `db` if it is not 
+already running – perform a single run of the unit tests. 
+
+## A dummy database
+
+There are a few things you will likely need to do to get a fully working version 
+of the web-server so as to make your local version useful, namely: 
+1. Get a dummy database dump .sql file from one of the developers and place it into `data/init.sql`
+2. [Optional] Get an image dump and place it into `data/db_data/`
+3. Fix a mild issue with the database model (see next section)
+
+If you are having problems with any of this, contact one of the developers.
+
+### Issue with `TcsGravityEventAnnotations.map_iteration`
+
+If you are getting an error along the lines of 
+
+```
+atlas-web-1  | ERRORS:
+atlas-web-1  | atlas.TcsGravityEventAnnotations.map_iteration: (fields.E311) 'TcsGravityAlerts.map_iteration' must be unique because it is referenced by a foreign key.
+atlas-web-1  | 	HINT: Add unique=True to this field or add a UniqueConstraint (without condition) in the model Meta.constraints.
+```
+
+Then you may need to make an adjustment to the models, specifically by 
+uncommenting the line declaring `TcsGravityAlerts.map_iteration` which adds a 
+unique `kwarg`, and commenting the line without the unique `kwarg`, should solve 
+the problem. Specifically, the lines should look like 
+```
+# map_iteration = models.CharField(max_length=100, blank=True, null=True)
+map_iteration = models.CharField(max_length=100, blank=True, null=True, unique=True)
+``` 
+This is within the `TcsGravityAlerts(models.Model)` class. Again, please speak 
+to one of the developers if this is unclear. 
+

psat_server_web-0.5.0/README.md

@@ -0,0 +1,101 @@
+# psat-server-web
+Python 3 web interface for the Pan-STARRS and ATLAS surveys.
+
+To install:
+
+pip install psat-server-web
+
+Once installed, don't forget to add the "data" symlinks in the:
+
+site-packages/psat\_server\_web/atlas/media/images
+site-packages/psat\_server\_web/ps1/media/images
+
+directories which point to the location of the image stamps.
+
+--- 
+
+# Local development version 
+
+A localised development instance can be run with docker compose. You will need a 
+`.env` file in your repository root to define some environment variables, 
+looking something like:
+
+``` .env
+# Django settings
+SECRET_KEY={YOUR_SECRET_KEY_HERE}
+DJANGO_ALLOWED_HOSTS=localhost 127.0.0.1 [::1]
+
+# MySQL/MariaDB settings
+MYSQL_ROOT_USER=root
+MYSQL_ROOT_PASSWORD=root
+MYSQL_DATABASE=atlas
+MYSQL_USER=atlas
+MYSQL_PASSWORD=atlas
+MYSQL_PORT=3306
+MYSQL_TEST_DATABASE=atlas_test
+MYSQL_TEST_PORT=3306
+MYSQL_TEST_USER=root
+MYSQL_TEST_PASSWORD=root
+
+DJANGO_MYSQL_DBUSER=atlas
+DJANGO_LASAIR_TOKEN=
+
+```
+
+Several of the values are omitted but aren't necessary to run a development 
+environment. Also ruch simple passwords should not be used in production, but this should get you something running locally. Hopefully it's then as simple as running the following:
+
+``` bash
+docker compose up
+```
+
+Which will start 4 services, comprised of:
+- `db` - A MariaDB instance. By default served at `localhost:3036` 
+- `atlas-web` - A mod-wsgi instance to serve the django front end. By default 
+served at `localhost:8086` and requires `db` to be running.
+- `adminer` - A web interface for interacting with the db. By default served 
+at `localhost:8080` and requires `db` to be running.
+- `tests` - A single-use run of the unit tests using django's `manage.py test`. 
+Requires `db` to be running.
+
+Each of these services can be run independently with 
+
+``` bash
+docker compose up {service_name}
+```
+
+So if, for example, you wanted to run the tests you could execute 
+`docker compose up tests` and it would – after starting `db` if it is not 
+already running – perform a single run of the unit tests. 
+
+## A dummy database
+
+There are a few things you will likely need to do to get a fully working version 
+of the web-server so as to make your local version useful, namely: 
+1. Get a dummy database dump .sql file from one of the developers and place it into `data/init.sql`
+2. [Optional] Get an image dump and place it into `data/db_data/`
+3. Fix a mild issue with the database model (see next section)
+
+If you are having problems with any of this, contact one of the developers.
+
+### Issue with `TcsGravityEventAnnotations.map_iteration`
+
+If you are getting an error along the lines of 
+
+```
+atlas-web-1  | ERRORS:
+atlas-web-1  | atlas.TcsGravityEventAnnotations.map_iteration: (fields.E311) 'TcsGravityAlerts.map_iteration' must be unique because it is referenced by a foreign key.
+atlas-web-1  | 	HINT: Add unique=True to this field or add a UniqueConstraint (without condition) in the model Meta.constraints.
+```
+
+Then you may need to make an adjustment to the models, specifically by 
+uncommenting the line declaring `TcsGravityAlerts.map_iteration` which adds a 
+unique `kwarg`, and commenting the line without the unique `kwarg`, should solve 
+the problem. Specifically, the lines should look like 
+```
+# map_iteration = models.CharField(max_length=100, blank=True, null=True)
+map_iteration = models.CharField(max_length=100, blank=True, null=True, unique=True)
+``` 
+This is within the `TcsGravityAlerts(models.Model)` class. Again, please speak 
+to one of the developers if this is unclear. 
+

psat_server_web-0.5.0/psat_server_web/__version__.py

@@ -0,0 +1 @@
+__version__ = '0.5.0'

psat_server_web-0.5.0/psat_server_web/atlas/accounts/admin.py

@@ -0,0 +1,34 @@
+"""
+Customise admin interface for Group model to include GroupProfile, so default 
+expiry time for tokens can be set. 
+"""
+import logging
+
+from django.contrib import admin
+from django.contrib.auth.models import Group
+from django.forms.models import ModelForm
+from .models import GroupProfile
+
+
+logger = logging.getLogger(__name__)
+
+class AlwaysChangedModelForm(ModelForm):
+    def has_changed(self):
+        """ Should return True if data differs from initial. 
+        By always returning true even unchanged inlines will get validated and saved.
+        We need this because the GroupProfile needs to be created even if the default 
+        values haven't been changed. 
+        """
+        return True
+
+class GroupProfileInline(admin.StackedInline):
+    model = GroupProfile
+    can_delete = False
+    extra = 1
+    form = AlwaysChangedModelForm
+
+class GroupAdmin(admin.ModelAdmin):
+    inlines = (GroupProfileInline,)
+
+admin.site.unregister(Group)
+admin.site.register(Group, GroupAdmin)

psat_server_web-0.5.0/psat_server_web/atlas/accounts/signals.py

@@ -0,0 +1,27 @@
+import logging
+
+from django.db.models import signals 
+from django.dispatch import receiver
+from django.contrib.auth.models import Group
+
+logger = logging.getLogger(__name__)
+
+@receiver(signals.post_save, sender=Group)
+def create_group_profile(sender, instance, created, **kwargs):
+    # NOTE (2024-11-12 JL): This function is no longer needed as we have instead 
+    # solved the problem of duplicate GroupProfile creation by using the 
+    # AlwaysChangedModelForm in the admin interface, but I'm leaving this here 
+    # as a reference for future use of signals and logging.
+    logger.debug('create_group_profile called')
+    logger.debug('instance: %s', instance)
+    logger.debug('created: %s', created)
+    
+    # Disconnect the signal so we don't get into a loop
+    signals.post_save.disconnect(create_group_profile, sender=Group)
+    
+    if created:
+        logger.debug('In created block')
+        
+    # Reconnect the signal once we're done
+    signals.post_save.connect(create_group_profile, sender=Group)
+    logger.debug('create_group_profile finished')

{psat_server_web-0.4.2 → psat_server_web-0.5.0}/psat_server_web/atlas/atlas/settings.py

@@ -25,9 +25,9 @@ SITE_ID = 1
 SECRET_KEY = os.environ.get('DJANGO_SECRET_KEY')
 
 # SECURITY WARNING: don't run with debug turned on in production!
-DEBUG = True
+DEBUG = os.environ.get('DJANGO_DEBUG', 'False') == 'True'
 
-TEMPLATE_DEBUG = True
+TEMPLATE_DEBUG = os.environ.get('DJANGO_DEBUG', 'False') == 'True'
 
 # 2021-08-21 KWS Need to set this to None, otherwise default is 1000.
 DATA_UPLOAD_MAX_NUMBER_FIELDS = None
@@ -57,14 +57,17 @@ LOGOUT_URL = 'logout'
 
 DATABASES = {
     'default': {
-        'ENGINE': 'django.db.backends.mysql',
+        'ENGINE': os.environ.get('DJANGO_DB_ENGINE', 'django.db.backends.mysql'),
         'NAME': os.environ.get('DJANGO_MYSQL_DBNAME'),
         'USER': os.environ.get('DJANGO_MYSQL_DBUSER'),
         'PASSWORD': os.environ.get('DJANGO_MYSQL_DBPASS'),
         'HOST': os.environ.get('DJANGO_MYSQL_DBHOST'),
         'PORT': int(os.environ.get('DJANGO_MYSQL_DBPORT')),
         'TEST': {
-            'NAME': os.environ.get('DJANGO_MYSQL_TESTDBNAME'),
+            'NAME': os.environ.get('DJANGO_MYSQL_TEST_DBNAME'),
+            'PORT': os.environ.get('DJANGO_MYSQL_TEST_DBPORT'),
+            'USER': os.environ.get('DJANGO_MYSQL_TEST_DBUSER'),
+            'PASSWORD': os.environ.get('DJANGO_MYSQL_TEST_DBPASS'),
         }
     }
 }
@@ -84,6 +87,49 @@ DAEMONS = {
 }
 
 
+DJANGO_LOG_LEVEL = os.environ.get('DJANGO_LOG_LEVEL', 'WARNING')
+LOGGING = {
+    "version": 1,  # the dictConfig format version
+    "disable_existing_loggers": False,  # retain the default loggers
+    "formatters": {
+        "verbose": {
+            "format": "{name} {levelname} {asctime} {module} {message}",
+            "style": "{",
+        },
+        "simple": {
+            "format": "{levelname} {message}",
+            "style": "{",
+        },
+    },
+
+    "handlers": {
+        # The different log handlers are defined here. We have a file logger and 
+        # a stderr logger - which reroutes to the error_log file managed by wsgi.  
+        "file": {
+            "class": "logging.FileHandler",
+            "filename": "django-default.log",
+            "level": DJANGO_LOG_LEVEL,
+            "formatter": "verbose",
+        },
+        "stderr": {
+            "class": "logging.StreamHandler",
+            "level": DJANGO_LOG_LEVEL,
+            "formatter": "verbose",
+            "stream": "ext://sys.stderr",
+        }
+    },
+    # Implement the stderr logger as the default logger.
+    "loggers": {
+        "": {
+            "handlers": ["stderr"],
+            "level": DJANGO_LOG_LEVEL,
+            "propagate": True,
+        },
+    }
+
+}
+
+
 LANGUAGE_CODE = 'en-gb'
 
 TIME_ZONE = 'UTC'
@@ -187,4 +233,4 @@ INSTALLED_APPS = [
 ]
 
 # Token expiry time in days, default 1 day (24*60*60 seconds)
-TOKEN_EXPIRY = int(os.environ.get("API_TOKEN_EXPIRY") or 86400) # seconds
+TOKEN_EXPIRY = int(os.environ.get("API_TOKEN_EXPIRY") or 86400) # seconds

psat_server_web-0.5.0/psat_server_web/atlas/tests/atlasapi/test_authentication.py

@@ -0,0 +1,111 @@
+# tests/test_authentication.py
+from django.test import TestCase
+from django.contrib.auth.models import User, Group
+from django.utils.timezone import now, timedelta
+from django.conf import settings
+from rest_framework.authtoken.models import Token
+from rest_framework.exceptions import AuthenticationFailed
+
+from atlasapi.authentication import ExpiringTokenAuthentication
+from accounts.models import GroupProfile
+
+
+class TokenAuthenticationTests(TestCase):
+
+    def setUp(self):
+        # Create groups
+        self.week_group = Group.objects.create(name="Weekly Expiring")
+        self.year_group = Group.objects.create(name="Yearly Expiring")
+        self.never_expiring_group = Group.objects.create(name="Never Expiring")
+        self.no_profile_group = Group.objects.create(name="No Profile")
+
+        # Add expiration times to group profiles
+        # No profile for self.no_profile_group
+        GroupProfile.objects.create(group=self.week_group, token_expiration_time=timedelta(weeks=1))
+        GroupProfile.objects.create(group=self.year_group, token_expiration_time=timedelta(days=365))
+        GroupProfile.objects.create(group=self.never_expiring_group, token_expiration_time=timedelta(days=10000))
+
+        # Create users and assign them to groups
+        self.no_group_user = User.objects.create_user(username="no_group_user", password="password")
+        self.no_profile_user = User.objects.create_user(username="no_profile_user", password="password")
+        self.week_user = User.objects.create_user(username="week_user", password="password")
+        self.year_user = User.objects.create_user(username="year_user", password="password")
+        self.never_expiring_user = User.objects.create_user(username="never_expiring_user", password="password")
+
+        # Assign users to groups
+        # No group for self.no_group_user
+        self.no_profile_user.groups.add(self.no_profile_group)
+        self.week_user.groups.add(self.week_group)
+        self.year_user.groups.add(self.year_group)
+        self.never_expiring_user.groups.add(self.never_expiring_group)
+
+        # Create tokens for each user
+        self.no_group_token = Token.objects.create(user=self.no_group_user)
+        self.no_profile_token = Token.objects.create(user=self.no_profile_user)
+        self.week_token = Token.objects.create(user=self.week_user)
+        self.year_token = Token.objects.create(user=self.year_user)
+        self.never_expiring_token = Token.objects.create(user=self.never_expiring_user)
+
+        # Setup token authentication
+        self.auth = ExpiringTokenAuthentication()
+        
+    def test_no_group(self):
+        # Test: user with no group profile should have default token expiration
+        self.assertEqual(self.auth.authenticate_credentials(self.no_group_token.key), 
+                         (self.no_group_user, self.no_group_token))
+        
+        self.no_group_token.created = now() - timedelta(days=settings.TOKEN_EXPIRY + 1)
+        self.no_group_token.save()
+        with self.assertRaises(AuthenticationFailed) as cm:
+            self.auth.authenticate_credentials(self.no_group_token.key)
+        self.assertEqual(str(cm.exception), 'Token has expired.')
+        
+    def test_no_profile(self):
+        # Test: user with no group profile should have default token expiration
+        with self.assertRaises(AuthenticationFailed) as cm:
+            self.auth.authenticate_credentials(self.no_profile_token.key)
+        self.assertEqual(str(cm.exception), 'Could not authenticate: Group has no profile. Please contact administrator.')
+
+    def test_weekly_token_expiration(self):
+        # Test: weekly expiring token should be valid if within one week
+        self.assertEqual(
+            self.auth.authenticate_credentials(self.week_token.key), 
+            (self.week_user, self.week_token)
+        )
+
+        # Test: weekly token should expire after one week
+        self.week_token.created = now() - timedelta(weeks=2)
+        self.week_token.save()
+        with self.assertRaises(AuthenticationFailed) as cm:
+            self.auth.authenticate_credentials(self.week_token.key)
+        self.assertEqual(str(cm.exception), 'Token has expired.')
+
+    def test_yearly_token_expiration(self):
+        # Test: yearly expiring token should be valid if within one year
+        self.assertEqual(
+            self.auth.authenticate_credentials(self.year_token.key), 
+            (self.year_user, self.year_token)
+        )
+
+        # Test: yearly token should expire after one year
+        self.year_token.created = now() - timedelta(days=400)
+        self.year_token.save()
+        with self.assertRaises(AuthenticationFailed) as cm:
+            self.auth.authenticate_credentials(self.year_token.key)
+        self.assertEqual(str(cm.exception), 'Token has expired.')
+
+    def test_never_expiring_token(self):
+        # Test: never-expiring token should always be valid
+        self.assertEqual(
+            self.auth.authenticate_credentials(self.never_expiring_token.key), 
+            (self.never_expiring_user, self.never_expiring_token)
+        )
+
+        # Even if we artificially backdate the token, it should still be valid
+        self.never_expiring_token.created = now() - timedelta(days=9999)
+        self.never_expiring_token.save()
+        self.assertEqual(
+            self.auth.authenticate_credentials(self.never_expiring_token.key), 
+            (self.never_expiring_user, self.never_expiring_token)
+        )
+

psat_server_web-0.5.0/psat_server_web/atlas/tests/atlasapi/test_failure.py

@@ -0,0 +1,8 @@
+import unittest
+
+from django.test import TestCase
+
+class TestFailure(TestCase):
+    @unittest.skip("Skipping this test")
+    def test_failure(self):
+        assert False

{psat_server_web-0.4.2/psat_server_web/atlas/tests → psat_server_web-0.5.0/psat_server_web/atlas/tests/atlasapi}/test_permissions.py

@@ -15,14 +15,16 @@ class TestPermissionsAuthenticated(TestCase):
         self.client.credentials(HTTP_AUTHORIZATION='Token ' + self.token.key)
 
     def test_permissions(self):
-        response = self.client.get(reverse('api:objects'))
+        endpoint = "/api/vrascores/"
+        response = self.client.get(endpoint)
         self.assertEqual(response.status_code, status.HTTP_200_OK)
 
-        response = self.client.post(reverse('api:objects'))
+        response = self.client.post(endpoint)
         self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
 
         self.user.is_staff = True
         self.user.save()
 
-        response = self.client.post(reverse('api:objects'))
-        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
+        response = self.client.post(endpoint)
+        # This will now fail with a 400 because we've not provided the payload
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)

{psat_server_web-0.4.2 → psat_server_web-0.5.0}/psat_server_web/schema/tcs_gravity_alerts.sql

@@ -1,6 +1,6 @@
 -- 2023-06-15 KWS Added an "interesting" column - human override of alert significance
 
-DROP TABLE `tcs_gravity_alerts`;
+DROP TABLE IF EXISTS `tcs_gravity_alerts`;
 
 CREATE TABLE `tcs_gravity_alerts` (
   `id` int NOT NULL AUTO_INCREMENT,

psat_server_web-0.5.0/psat_server_web.egg-info/PKG-INFO

@@ -0,0 +1,131 @@
+Metadata-Version: 2.1
+Name: psat-server-web
+Version: 0.5.0
+Summary: Pan-STARRS and ATLAS web interface.
+Home-page: https://github.com/genghisken/psat-server-web
+Author: genghisken
+Author-email: ken.w.smith@gmail.com
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Topic :: Utilities
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: mysqlclient
+Requires-Dist: django<4.2
+Requires-Dist: django_tables2
+Requires-Dist: djangorestframework
+Requires-Dist: mod-wsgi
+Requires-Dist: pyyaml
+Requires-Dist: docopt
+Requires-Dist: python-dotenv
+Requires-Dist: gkhtm
+Requires-Dist: gkutils>=0.3.2
+Requires-Dist: requests
+Requires-Dist: lasair
+Requires-Dist: dustmaps
+
+# psat-server-web
+Python 3 web interface for the Pan-STARRS and ATLAS surveys.
+
+To install:
+
+pip install psat-server-web
+
+Once installed, don't forget to add the "data" symlinks in the:
+
+site-packages/psat\_server\_web/atlas/media/images
+site-packages/psat\_server\_web/ps1/media/images
+
+directories which point to the location of the image stamps.
+
+--- 
+
+# Local development version 
+
+A localised development instance can be run with docker compose. You will need a 
+`.env` file in your repository root to define some environment variables, 
+looking something like:
+
+``` .env
+# Django settings
+SECRET_KEY={YOUR_SECRET_KEY_HERE}
+DJANGO_ALLOWED_HOSTS=localhost 127.0.0.1 [::1]
+
+# MySQL/MariaDB settings
+MYSQL_ROOT_USER=root
+MYSQL_ROOT_PASSWORD=root
+MYSQL_DATABASE=atlas
+MYSQL_USER=atlas
+MYSQL_PASSWORD=atlas
+MYSQL_PORT=3306
+MYSQL_TEST_DATABASE=atlas_test
+MYSQL_TEST_PORT=3306
+MYSQL_TEST_USER=root
+MYSQL_TEST_PASSWORD=root
+
+DJANGO_MYSQL_DBUSER=atlas
+DJANGO_LASAIR_TOKEN=
+
+```
+
+Several of the values are omitted but aren't necessary to run a development 
+environment. Also ruch simple passwords should not be used in production, but this should get you something running locally. Hopefully it's then as simple as running the following:
+
+``` bash
+docker compose up
+```
+
+Which will start 4 services, comprised of:
+- `db` - A MariaDB instance. By default served at `localhost:3036` 
+- `atlas-web` - A mod-wsgi instance to serve the django front end. By default 
+served at `localhost:8086` and requires `db` to be running.
+- `adminer` - A web interface for interacting with the db. By default served 
+at `localhost:8080` and requires `db` to be running.
+- `tests` - A single-use run of the unit tests using django's `manage.py test`. 
+Requires `db` to be running.
+
+Each of these services can be run independently with 
+
+``` bash
+docker compose up {service_name}
+```
+
+So if, for example, you wanted to run the tests you could execute 
+`docker compose up tests` and it would – after starting `db` if it is not 
+already running – perform a single run of the unit tests. 
+
+## A dummy database
+
+There are a few things you will likely need to do to get a fully working version 
+of the web-server so as to make your local version useful, namely: 
+1. Get a dummy database dump .sql file from one of the developers and place it into `data/init.sql`
+2. [Optional] Get an image dump and place it into `data/db_data/`
+3. Fix a mild issue with the database model (see next section)
+
+If you are having problems with any of this, contact one of the developers.
+
+### Issue with `TcsGravityEventAnnotations.map_iteration`
+
+If you are getting an error along the lines of 
+
+```
+atlas-web-1  | ERRORS:
+atlas-web-1  | atlas.TcsGravityEventAnnotations.map_iteration: (fields.E311) 'TcsGravityAlerts.map_iteration' must be unique because it is referenced by a foreign key.
+atlas-web-1  | 	HINT: Add unique=True to this field or add a UniqueConstraint (without condition) in the model Meta.constraints.
+```
+
+Then you may need to make an adjustment to the models, specifically by 
+uncommenting the line declaring `TcsGravityAlerts.map_iteration` which adds a 
+unique `kwarg`, and commenting the line without the unique `kwarg`, should solve 
+the problem. Specifically, the lines should look like 
+```
+# map_iteration = models.CharField(max_length=100, blank=True, null=True)
+map_iteration = models.CharField(max_length=100, blank=True, null=True, unique=True)
+``` 
+This is within the `TcsGravityAlerts(models.Model)` class. Again, please speak 
+to one of the developers if this is unclear. 
+