django-data-observer 0.0.1__tar.gz

django_data_observer-0.0.1/.github/workflows/publish.yml

@@ -0,0 +1,51 @@
+name: Publish to PyPI
+
+on:
+  push
+
+jobs:
+  build:
+    name: Build distribution  
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        persist-credentials: false
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.x"
+    - name: Install pypa/build
+      run: >-
+        python3 -m
+        pip install
+        build
+        --user
+    - name: Build a binary wheel and a source tarball
+      run: python3 -m build
+    - name: Store the distribution packages
+      uses: actions/upload-artifact@v4
+      with:
+        name: python-package-distributions
+        path: dist/
+
+  publish-to-pypi:
+    name: >-
+      Publish Python   distribution   to PyPI
+    if: startsWith(github.ref, 'refs/tags/')
+    needs:
+    - build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/project/django-data-observer/
+    permissions:
+      id-token: write
+    steps:
+    - name: Download all the dists
+      uses: actions/download-artifact@v4
+      with:
+        name: python-package-distributions
+        path: dist/
+    - name: Publish distribution   to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1

django_data_observer-0.0.1/.gitignore

@@ -0,0 +1,79 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+*.pyo
+build/
+dist/
+wheels/
+*.egg-info
+*.egg
+.eggs/
+MANIFEST
+
+# Virtual environments
+.venv
+venv/
+env/
+ENV/
+.env
+
+# Environment variables
+.env.local
+.env.*.local
+
+# Distribution / packaging
+*.tar.gz
+*.whl
+
+# Testing
+.tox/
+.nox/
+.coverage
+.coverage.*
+coverage.xml
+htmlcov/
+.pytest_cache/
+.hypothesis/
+
+# Type checking
+.mypy_cache/
+.dmypy.json
+.pytype/
+.pyre/
+
+# Linting / formatting
+.ruff_cache/
+
+# Django
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+media/
+staticfiles/
+static/
+
+# Django migrations (optional — remove if you want to track migrations)
+# */migrations/*.py
+# !*/migrations/__init__.py
+
+# Celery
+celerybeat-schedule
+celerybeat.pid
+
+# IDE / editors
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# Jupyter Notebooks
+.ipynb_checkpoints/
+*.ipynb
+
+# uv / pip
+pip-log.txt
+pip-delete-this-directory.txt
+.uv/

django_data_observer-0.0.1/.python-version

@@ -0,0 +1 @@
+3.13

django_data_observer-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Saranya Balasubramanian
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

django_data_observer-0.0.1/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.5
+Name: django-data-observer
+Version: 0.0.1
+Summary: Data observer package for Django projects
+Project-URL: Homepage, https://github.com/gythaogg/django-data-linter
+Author-email: Saranya Balasubramanian <saranya.balasubramanian@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: data observer
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.13
+Requires-Dist: tqdm>=4.68.3
+Description-Content-Type: text/markdown
+
+# django-data-observer
+
+## Aim
+A data observer package for Django projects.
+
+## Sample project
+
+The APIS dependencies are only needed to run the demonstration project. Install them
+with the `sample-project` dependency group:
+
+```bash
+uv sync --group sample-project
+```
+
+A more generic django project to come as well, eventually.

django_data_observer-0.0.1/README.md

@@ -0,0 +1,15 @@
+# django-data-observer
+
+## Aim
+A data observer package for Django projects.
+
+## Sample project
+
+The APIS dependencies are only needed to run the demonstration project. Install them
+with the `sample-project` dependency group:
+
+```bash
+uv sync --group sample-project
+```
+
+A more generic django project to come as well, eventually.

django_data_observer-0.0.1/manage.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python
+import os
+import sys
+
+def main():
+    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'sample_project_apis.settings')
+    try:
+        from django.core.management import execute_from_command_line
+    except ImportError as exc:
+        raise ImportError(
+            "Couldn't import Django. Are you sure it's installed and available on your PYTHONPATH environment variable? Did you forget to activate a virtual environment?"
+        ) from exc
+    execute_from_command_line(sys.argv)
+
+if __name__ == '__main__':
+    main()

django_data_observer-0.0.1/pyproject.toml

@@ -0,0 +1,31 @@
+[project]
+name = "django-data-observer"
+version = "0.0.1"
+description = "Data observer package for Django projects"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+keywords = ["data observer"]
+urls = { "Homepage" = "https://github.com/gythaogg/django-data-linter" }
+authors = [
+    { name = "Saranya Balasubramanian", email = "saranya.balasubramanian@gmail.com" }
+]
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.13"
+dependencies = [
+    "tqdm>=4.68.3",
+]
+
+[dependency-groups]
+sample-project = [
+    "apis-acdhch-default-settings==2.24.1",
+    "apis-core-rdf==0.71.1",
+]
+
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

django_data_observer-0.0.1/sample_project_apis/migrations/0001_initial.py

@@ -0,0 +1,343 @@
+# Generated by Django 6.1.2 on 2026-10-18 23:10
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ("apis_metainfo", "0017_delete_uri"),
+        ("relations", "0003_relation_relations_r_subj_content_type_and_more"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="Group",
+            fields=[
+                (
+                    "rootobject_ptr",
+                    models.OneToOneField(
+                        auto_created=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        parent_link=True,
+                        primary_key=True,
+                        serialize=False,
+                        to="apis_metainfo.rootobject",
+                    ),
+                ),
+                (
+                    "label",
+                    models.CharField(
+                        blank=True, default="", max_length=4096, verbose_name="label"
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "group",
+                "verbose_name_plural": "groups",
+                "ordering": ["label"],
+                "abstract": False,
+            },
+            bases=("apis_metainfo.rootobject", models.Model),
+        ),
+        migrations.CreateModel(
+            name="IsCousinOf",
+            fields=[
+                (
+                    "relation_ptr",
+                    models.OneToOneField(
+                        auto_created=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        parent_link=True,
+                        primary_key=True,
+                        serialize=False,
+                        to="relations.relation",
+                    ),
+                ),
+                (
+                    "certainty",
+                    models.CharField(
+                        choices=[
+                            ("certain", "Certain"),
+                            ("probable", "Probable"),
+                            ("uncertain", "Uncertain"),
+                        ],
+                        default="certain",
+                        max_length=10,
+                    ),
+                ),
+            ],
+            options={
+                "ordering": ["pk"],
+                "abstract": False,
+            },
+            bases=("relations.relation",),
+        ),
+        migrations.CreateModel(
+            name="IsParentOf",
+            fields=[
+                (
+                    "relation_ptr",
+                    models.OneToOneField(
+                        auto_created=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        parent_link=True,
+                        primary_key=True,
+                        serialize=False,
+                        to="relations.relation",
+                    ),
+                ),
+                (
+                    "certainty",
+                    models.CharField(
+                        choices=[
+                            ("certain", "Certain"),
+                            ("probable", "Probable"),
+                            ("uncertain", "Uncertain"),
+                        ],
+                        default="certain",
+                        max_length=10,
+                    ),
+                ),
+            ],
+            options={
+                "ordering": ["pk"],
+                "abstract": False,
+            },
+            bases=("relations.relation",),
+        ),
+        migrations.CreateModel(
+            name="IsPartOf",
+            fields=[
+                (
+                    "relation_ptr",
+                    models.OneToOneField(
+                        auto_created=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        parent_link=True,
+                        primary_key=True,
+                        serialize=False,
+                        to="relations.relation",
+                    ),
+                ),
+                (
+                    "certainty",
+                    models.CharField(
+                        choices=[
+                            ("certain", "Certain"),
+                            ("probable", "Probable"),
+                            ("uncertain", "Uncertain"),
+                        ],
+                        default="certain",
+                        max_length=10,
+                    ),
+                ),
+            ],
+            options={
+                "ordering": ["pk"],
+                "abstract": False,
+            },
+            bases=("relations.relation",),
+        ),
+        migrations.CreateModel(
+            name="IsSiblingOf",
+            fields=[
+                (
+                    "relation_ptr",
+                    models.OneToOneField(
+                        auto_created=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        parent_link=True,
+                        primary_key=True,
+                        serialize=False,
+                        to="relations.relation",
+                    ),
+                ),
+                (
+                    "certainty",
+                    models.CharField(
+                        choices=[
+                            ("certain", "Certain"),
+                            ("probable", "Probable"),
+                            ("uncertain", "Uncertain"),
+                        ],
+                        default="certain",
+                        max_length=10,
+                    ),
+                ),
+            ],
+            options={
+                "ordering": ["pk"],
+                "abstract": False,
+            },
+            bases=("relations.relation",),
+        ),
+        migrations.CreateModel(
+            name="LivesIn",
+            fields=[
+                (
+                    "relation_ptr",
+                    models.OneToOneField(
+                        auto_created=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        parent_link=True,
+                        primary_key=True,
+                        serialize=False,
+                        to="relations.relation",
+                    ),
+                ),
+                (
+                    "certainty",
+                    models.CharField(
+                        choices=[
+                            ("certain", "Certain"),
+                            ("probable", "Probable"),
+                            ("uncertain", "Uncertain"),
+                        ],
+                        default="certain",
+                        max_length=10,
+                    ),
+                ),
+            ],
+            options={
+                "ordering": ["pk"],
+                "abstract": False,
+            },
+            bases=("relations.relation",),
+        ),
+        migrations.CreateModel(
+            name="Place",
+            fields=[
+                (
+                    "rootobject_ptr",
+                    models.OneToOneField(
+                        auto_created=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        parent_link=True,
+                        primary_key=True,
+                        serialize=False,
+                        to="apis_metainfo.rootobject",
+                    ),
+                ),
+                (
+                    "label",
+                    models.CharField(
+                        blank=True, default="", max_length=4096, verbose_name="label"
+                    ),
+                ),
+                (
+                    "latitude",
+                    models.FloatField(blank=True, null=True, verbose_name="latitude"),
+                ),
+                (
+                    "longitude",
+                    models.FloatField(blank=True, null=True, verbose_name="longitude"),
+                ),
+                (
+                    "feature_code",
+                    models.CharField(
+                        blank=True,
+                        default="",
+                        help_text='<a href="https://www.geonames.org/export/codes.html" target="_blank">Geonames Feature Code List</a>',
+                        max_length=16,
+                        verbose_name="feature code",
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "place",
+                "verbose_name_plural": "places",
+                "ordering": ["label"],
+                "abstract": False,
+            },
+            bases=("apis_metainfo.rootobject", models.Model),
+        ),
+        migrations.CreateModel(
+            name="Profession",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("name", models.CharField(blank=True, default="", max_length=1024)),
+            ],
+            options={
+                "abstract": False,
+            },
+        ),
+        migrations.CreateModel(
+            name="Person",
+            fields=[
+                (
+                    "rootobject_ptr",
+                    models.OneToOneField(
+                        auto_created=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        parent_link=True,
+                        primary_key=True,
+                        serialize=False,
+                        to="apis_metainfo.rootobject",
+                    ),
+                ),
+                (
+                    "forename",
+                    models.CharField(
+                        blank=True, default="", max_length=4096, verbose_name="forename"
+                    ),
+                ),
+                (
+                    "surname",
+                    models.CharField(
+                        blank=True, default="", max_length=4096, verbose_name="surname"
+                    ),
+                ),
+                (
+                    "date_of_birth",
+                    models.DateField(
+                        blank=True, null=True, verbose_name="date of birth"
+                    ),
+                ),
+                (
+                    "date_of_death",
+                    models.DateField(
+                        blank=True, null=True, verbose_name="date of death"
+                    ),
+                ),
+                ("bio", models.TextField(blank=True)),
+                (
+                    "gender",
+                    models.CharField(
+                        choices=[
+                            ("male", "Male"),
+                            ("female", "Female"),
+                            ("other", "Other"),
+                            ("unknown", "Unknown"),
+                        ],
+                        default="unknown",
+                        max_length=20,
+                    ),
+                ),
+                (
+                    "profession",
+                    models.ManyToManyField(
+                        blank=True, to="sample_project_apis.profession"
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "person",
+                "verbose_name_plural": "persons",
+                "ordering": ["surname", "forename"],
+                "abstract": False,
+            },
+            bases=("apis_metainfo.rootobject", models.Model),
+        ),
+    ]

django_data_observer-0.0.1/sample_project_apis/models.py

@@ -0,0 +1,97 @@
+from django.db import models
+
+from apis_core.entities.abc import E21_Person, E53_Place, E74_Group
+from apis_core.apis_entities.models import AbstractEntity
+from apis_core.generic.abc import GenericModel
+from apis_core.relations.models import Relation
+
+
+class Profession(GenericModel, models.Model):
+    name = models.CharField(blank=True, default="", max_length=1024)
+
+    def __str__(self):
+        return self.name
+
+
+class Person(E21_Person, AbstractEntity):
+    profession = models.ManyToManyField(Profession, blank=True)
+    bio = models.TextField(blank=True)
+    gender = models.CharField(
+        max_length=20,
+        choices=[
+            ("male", "Male"),
+            ("female", "Female"),
+            ("other", "Other"),
+            ("unknown", "Unknown"),
+        ],
+        default="unknown",
+    )
+
+
+class Place(E53_Place, AbstractEntity):
+    pass
+
+
+class Group(E74_Group, AbstractEntity):
+    pass
+
+
+class RelationMixin(Relation):
+    certainty = models.CharField(
+        max_length=10,
+        choices=[
+            ("certain", "Certain"),
+            ("probable", "Probable"),
+            ("uncertain", "Uncertain"),
+        ],
+        default="certain",
+    )
+
+    class Meta:
+        abstract = True
+        ordering = ["pk"]
+
+
+class IsCousinOf(RelationMixin):
+    subj_model = Person
+    obj_model = Person
+
+    @classmethod
+    def reverse_name(self) -> str:
+        return "is cousin of"
+
+
+class IsPartOf(RelationMixin):
+    subj_model = Person
+    obj_model = Group
+
+    @classmethod
+    def reverse_name(self) -> str:
+        return "consists of"
+
+
+class IsSiblingOf(RelationMixin):
+    subj_model = Person
+    obj_model = Person
+
+    @classmethod
+    def reverse_name(self) -> str:
+        return "is sibling of"
+
+
+class LivesIn(RelationMixin):
+    subj_model = Person
+    obj_model = Place
+
+    @classmethod
+    def reverse_name(self) -> str:
+        return "has inhabitant"
+
+
+class IsParentOf(RelationMixin):
+    subj_model = Person
+    obj_model = Person
+
+    @classmethod
+    def reverse_name(self) -> str:
+        return "is child of"