From 59f218c138a2d5e30ba7809d9ead3880e2552382 Mon Sep 17 00:00:00 2001
From: EvdH0 <i@iric.nl>
Date: Sat, 10 Jul 2021 15:38:28 +0200
Subject: [PATCH 01/13] The  variable is not is not recognized, so moved to the
 Docker .env file

---
 tests/.env                 | 3 +++
 tests/docker-compose.yml   | 3 +++
 tests/docker-entrypoint.sh | 2 ++
 tests/settings.py          | 3 ---
 4 files changed, 8 insertions(+), 3 deletions(-)
 create mode 100644 tests/.env

diff --git a/tests/.env b/tests/.env
new file mode 100644
index 0000000..47c372c
--- /dev/null
+++ b/tests/.env
@@ -0,0 +1,3 @@
+DJANGO_SUPERUSER_PASSWORD=1234
+DJANGO_SUPERUSER_EMAIL=example@example.com
+DJANGO_SUPERUSER_USERNAME=admin
diff --git a/tests/docker-compose.yml b/tests/docker-compose.yml
index f68422a..822fb2a 100644
--- a/tests/docker-compose.yml
+++ b/tests/docker-compose.yml
@@ -19,6 +19,9 @@ services:
     environment:
       - NEO4J_BOLT_URL=bolt://neo4j:foobar@neo4j_db:7687
       - DJANGO_SETTINGS_MODULE=settings
+      - DJANGO_SUPERUSER_PASSWORD
+      - DJANGO_SUPERUSER_EMAIL
+      - DJANGO_SUPERUSER_USERNAME
 
 
   neo4j_db:
diff --git a/tests/docker-entrypoint.sh b/tests/docker-entrypoint.sh
index 42c79e7..2b56b00 100755
--- a/tests/docker-entrypoint.sh
+++ b/tests/docker-entrypoint.sh
@@ -15,6 +15,8 @@ then
         --noinput \
         --username $DJANGO_SUPERUSER_USERNAME \
         --email $DJANGO_SUPERUSER_EMAIL
+else
+    echo "No superusername found"
 fi
 
 $@
diff --git a/tests/settings.py b/tests/settings.py
index fccb4f9..bb20632 100644
--- a/tests/settings.py
+++ b/tests/settings.py
@@ -73,6 +73,3 @@
 STATIC_ROOT = "./static/"
 STATIC_URL = '/static/'
 
-DJANGO_SUPERUSER_PASSWORD = "1234"
-DJANGO_SUPERUSER_EMAIL = "example@example.com"
-DJANGO_SUPERUSER_USERNAME = "admin"
\ No newline at end of file

From d8c063524a41b874b118ed2bb93907bc93debe2c Mon Sep 17 00:00:00 2001
From: Eric van der Helm <i@iric.nl>
Date: Fri, 23 Jul 2021 13:03:30 +0200
Subject: [PATCH 02/13] Prevent failing when superuser already exists

---
 tests/docker-entrypoint.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/docker-entrypoint.sh b/tests/docker-entrypoint.sh
index 2b56b00..d207de5 100755
--- a/tests/docker-entrypoint.sh
+++ b/tests/docker-entrypoint.sh
@@ -14,7 +14,7 @@ then
     python manage.py createsuperuser \
         --noinput \
         --username $DJANGO_SUPERUSER_USERNAME \
-        --email $DJANGO_SUPERUSER_EMAIL
+        --email $DJANGO_SUPERUSER_EMAIL || true
 else
     echo "No superusername found"
 fi

From 66d4a4f7ce83c873399b01fd5f2fc8d481bf2f64 Mon Sep 17 00:00:00 2001
From: EvdH0 <i@iric.nl>
Date: Wed, 29 Dec 2021 21:48:10 +0100
Subject: [PATCH 03/13] Implement Relationships and fix delete button in admin

---
 django_neomodel/__init__.py            | 309 ++++++++++++++++++++++---
 tests/someapp/admin.py                 |   8 +-
 tests/someapp/models.py                |  42 +++-
 tests/someapp/tests/test_model_form.py | 184 ++++++++++++++-
 4 files changed, 492 insertions(+), 51 deletions(-)

diff --git a/django_neomodel/__init__.py b/django_neomodel/__init__.py
index 3b63d05..d71cb6a 100644
--- a/django_neomodel/__init__.py
+++ b/django_neomodel/__init__.py
@@ -2,14 +2,22 @@
 
 from django.db.models import signals
 from django.db.models.fields import BLANK_CHOICE_DASH
+from django.db.models.base import ModelState
+from django.db.models import ManyToManyField
+
 from django.conf import settings
 from django.forms import fields as form_fields
+from django.forms import ModelMultipleChoiceField as form_ModelMultipleChoiceField 
 from django.db.models.options import Options
-from django.core.exceptions import ValidationError
+from django.core.exceptions import ValidationError 
 
-from neomodel import RequiredProperty, DeflateError, StructuredNode, UniqueIdProperty
+from neomodel import RequiredProperty, DeflateError, StructuredNode, UniqueIdProperty, AliasProperty, UniqueProperty 
 from neomodel.core import NodeMeta
 from neomodel.match import NodeSet
+from neomodel.cardinality import OneOrMore, One, ZeroOrOne, ZeroOrMore
+
+from importlib import import_module
+from types import SimpleNamespace
 
 
 __author__ = 'Robin Edwards'
@@ -32,22 +40,83 @@ def __get__(self, obj, type=None):
     return cpf(f)
 
 
+class NOT_PROVIDED:
+    pass
+
+
+class DjangoFormFieldMultipleChoice(form_fields.MultipleChoiceField):
+    """ Sublcass of Djangos MultipleChoiceField but without working validator """
+    def validate(self, value):
+        return True 
+
+
+class DjangoFormFieldTypedChoice(form_fields.TypedChoiceField):
+    """ Sublcass of Djangos TypedChoiceField but without working validator """
+    def validate(self, value):
+        return True
+
+
 @total_ordering
-class DjangoField(object):
+class DjangoBaseField(object):
+    """ Base field where Properties and Relations Field should subclass from """
+
+    is_relation = False
+    concrete = True
+    editable = True
+    creation_counter = 0
+    unique = False
+    primary_key = False
+    auto_created = False
+
+    # Then from class RelatedField(FieldCacheMixin, Field): see https://docs.djangoproject.com/en/2.0/_modules/django/db/models/fields/related/
+    # Field flags
+    one_to_many = None
+    one_to_one = None
+    many_to_many = None
+    many_to_one = None
+   
+    creation_counter = 0
+
+    def __init__(self):
+        self.creation_counter = DjangoBaseField.creation_counter
+        DjangoBaseField.creation_counter += 1
+
+    def __eq__(self, other):
+        # Needed for @total_ordering
+        if isinstance(other, DjangoBaseField):
+            return self.creation_counter == other.creation_counter
+        return NotImplemented
+
+    def __lt__(self, other):
+        # This is needed because bisect does not take a comparison function.
+        if isinstance(other, DjangoBaseField):
+            return self.creation_counter < other.creation_counter
+        return NotImplemented
+
+    def has_default(self):
+        return self._has_default
+
+    def to_python(self, value):
+        return value
+
+    def __hash__(self):
+        # The delete function in the Admin requires a hash
+        return hash(self.creation_counter)
+    
+
+class DjangoPropertyField(DjangoBaseField):
     """
     Fake Django model field object which wraps a neomodel Property
     """
     is_relation = False
     concrete = True
-    editable = True
-    creation_counter = 0
+    editable = True   
     unique = False
     primary_key = False
     auto_created = False
 
     def __init__(self, prop, name):
         self.prop = prop
-
         self.name = name
         self.remote_field = name
         self.attname = name
@@ -70,23 +139,7 @@ def __init__(self, prop, name):
         self.blank = not self.required
         self.choices = getattr(prop, 'choices', None)
 
-        self.creation_counter = DjangoField.creation_counter
-        DjangoField.creation_counter += 1
-
-    def __eq__(self, other):
-        # Needed for @total_ordering
-        if isinstance(other, DjangoField):
-            return self.creation_counter == other.creation_counter
-        return NotImplemented
-
-    def __lt__(self, other):
-        # This is needed because bisect does not take a comparison function.
-        if isinstance(other, DjangoField):
-            return self.creation_counter < other.creation_counter
-        return NotImplemented
-
-    def has_default(self):
-        return self._has_default
+        super().__init__()
 
     def save_form_data(self, instance, data):
         setattr(instance, self.name, data)
@@ -123,20 +176,15 @@ def formfield(self, **kwargs):
                     del kwargs[k]
 
         defaults.update(kwargs)
-
         return self.form_class(**defaults)
 
-    def to_python(self, value):
-        return value
-
     def get_choices(self, include_blank=True):
         blank_defined = False
         blank_choice = BLANK_CHOICE_DASH
         choices = list(self.choices) if self.choices else []
-
         if issubclass(type(self.choices), dict):
-            choices = list(enumerate(self.choices))
-
+            # Ensure list of tuples with proper key-value pairing
+            choices = [(k, v) for k, v in self.choices.items()] 
         for choice, __ in choices:
             if choice in ('', None):
                 blank_defined = True
@@ -147,6 +195,176 @@ def get_choices(self, include_blank=True):
         return first_choice + choices
 
 
+class DjangoRemoteField(object):
+    """ Fake RemoteField to let the Django Admin work """
+
+    def __init__(self, b):
+        # Fake this call https://github.com/django/django/blob/ac5cc6cf01463d90aa333d5f6f046c311019827b/django/contrib/admin/widgets.py#L278
+        self.model = b 
+        self.through = SimpleNamespace(_meta=SimpleNamespace(auto_created=True))
+
+    def get_related_field(self):
+        # Fake call https://github.com/django/django/blob/ac5cc6cf01463d90aa333d5f6f046c311019827b/django/contrib/admin/widgets.py#L282
+        # from the Django Admin
+        return SimpleNamespace(name=self.model.pk.target)
+
+
+class DjangoRelationField(DjangoBaseField):
+    """
+    Fake Django model field object which wraps a neomodel Relationship
+    """
+    one_to_many = False
+    one_to_one = False
+    many_to_one = False
+
+    many_to_many = True
+
+    @property
+    def __class__(self):
+        # Fake the class for 
+        # https://github.com/django/django/blob/ac5cc6cf01463d90aa333d5f6f046c311019827b/django/contrib/admin/options.py#L144
+        # so we can get the admin ManyToMany field widgets to work
+        return ManyToManyField
+
+    def __init__(self, prop, name):
+        self.prop = prop
+        self.choices = None 
+        
+        self.required = False
+        if prop.manager is OneOrMore or prop.manager is One:
+            self.required = True
+
+        self.blank = False 
+       
+        # See https://docs.djangoproject.com/en/2.0/_modules/django/db/models/fields/
+        # Need a way to signal that there is no default
+        self._has_default = NOT_PROVIDED
+
+        self.name = name
+        self.attname = name
+        self.verbose_name = name
+        self.help_text = getattr(prop, 'help_text', '')
+        
+        if prop.manager is ZeroOrOne: 
+            # This form_class has its validator set to True
+            self.form_class = DjangoFormFieldTypedChoice
+        else:
+            # This form_class has its validator set to True
+            self.form_class = DjangoFormFieldMultipleChoice 
+    
+        # Need to load the related model in so we can fetch
+        # all nodes.
+
+        a = import_module(self.prop.module_name)
+        b = getattr(a, self.prop._raw_class)
+        self._related_model = b 
+        
+        self.remote_field = DjangoRemoteField(b)
+
+        super().__init__()
+        
+    def value_from_object(self, instance):
+        instance_relation = getattr(instance, self.name)
+        node_ids_selected = []
+        for this_object in instance_relation.all():
+            node_ids_selected.append(this_object.pk)
+        return node_ids_selected
+   
+    def save_form_data(self, instance, data):
+        # instance is the current node which needs to get connected
+        # data is a list of ids/uids of the nodes-to-connect-to
+
+        instance_relation = getattr(instance, self.name)
+        # Need to define which nodes to disconnect from first!
+        all_possible_nodes = self._related_model.nodes.all()
+        
+        # Gather the pks from these nodes
+        list_of_ids = []
+        for this_node in all_possible_nodes:
+            list_of_ids.append(this_node.pk)
+        # So which nodes are not selected?
+        should_not_be_connected = set(list_of_ids) - set(data)
+       
+        # Need to save the instance before relations can be made
+        try:
+            instance.save()
+        except UniqueProperty as e:
+            raise ValidationError(e)  
+        # Cardinality needs to be observed, so use following order:
+        # if One: replace
+        # if OneOreMore: first connect, then disconnect
+        # if ZeroOrMore: doesn't matter
+        # if ZeroOrOne: First disconnect, then connect
+     
+        if self.prop.manager is ZeroOrMore or self.prop.manager is ZeroOrOne:
+            # Instead of checking the relationship exists, just disconnect 
+            # In the future when specific relationships are implemented, this
+            # should be updated
+            self._disconnect_node(should_not_be_connected, instance_relation)
+
+            # Now time to setup new connections
+            if data:  # In case we selected an empty unit, don't do anything 
+                self._connect_node(data, instance_relation)
+        
+        elif self.prop.manager is OneOrMore:
+            # First setup new connections
+            self._connect_node(data, instance_relation)
+            try:
+                instance.save()
+            except UniqueProperty as e:
+                raise ValidationError(e)  
+        
+            # Instead of checking the relationship exists, just disconnect 
+            self._disconnect_node(should_not_be_connected, instance_relation)
+        else:
+            # This would require replacing the current relation with a new one
+            raise NotImplementedError('Cardinality of One is not supported yet')
+
+    def _disconnect_node(self, should_not_be_connected, instance_relation):
+        """ Given a list pk's, remove the relationship """
+
+        # Internals used by save_form_data to 
+        for this_object in should_not_be_connected:
+            remover = self._related_model.nodes.get_or_none(pk=this_object)
+            instance_relation.disconnect(remover)
+
+    def _connect_node(self, data, instance_relation):
+        """ Given a list pk's, add the relationship """
+
+        # If ChoiceField, it is not a list
+        data = [data] if not isinstance(data, list) else data  
+        
+        for this_object in data:
+            # Retreive the node-to-connect-to
+            adder = self._related_model.nodes.get_or_none(pk=this_object)
+            # If the connection is there, leave it
+            if not adder:
+                raise ValidationError({self.name: ' not found'})
+
+            if not instance_relation.is_connected(adder):
+                instance_relation.connect(adder)
+   
+    def formfield(self, *args, **kwargs):
+        """Return a django.forms.Field instance for this field."""
+
+        node_options = []
+
+        if self.prop.manager is ZeroOrOne:
+            node_options = BLANK_CHOICE_DASH.copy()
+
+        for this_object in self._related_model.nodes.all():
+            node_options.append((this_object.pk, this_object.__str__))
+
+        defaults = {'required': self.required,
+                    'label': self.verbose_name,
+                    'help_text': self.help_text,
+                    **kwargs,
+                    }
+
+        defaults['choices'] = node_options
+        return self.form_class(**defaults)
+
+
 class Query:
     select_related = False
     order_by = ['pk']
@@ -158,7 +376,7 @@ class NeoNodeSet(NodeSet):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.model = self.source
-
+    
     def count(self):
         return len(self)
 
@@ -189,18 +407,39 @@ class DjangoNode(StructuredNode, metaclass=MetaClass):
     def _meta(self):
         if hasattr(self.Meta, 'unique_together'):
             raise NotImplementedError('unique_together property not supported by neomodel')
+        
+        # Need a ModelState for the admin to delete an object
+        self._state = ModelState() 
+        self._state.adding = False 
 
         opts = Options(self.Meta, app_label=self.Meta.app_label)
         opts.contribute_to_class(self, self.__name__)
 
+        # Again, otherwise delete from admin doesn't work, see: 
+        # https://github.com/django/django/blob/0e656c02fe945389246f0c08f51c6db4a0849bd2/django/db/models/deletion.py#L252 
+        opts.concrete_model = self 
+
         for key, prop in self.__all_properties__:
-            opts.add_field(DjangoField(prop, key), getattr(prop, 'private', False))
+            opts.add_field(DjangoPropertyField(prop, key), getattr(prop, 'private', False))
             if getattr(prop, "primary_key", False):
-                self.pk = prop
-                self.pk.auto_created = True
+                # a reference using self.pk = prop fails in some cases where
+                # django references the .pk attribute directly. ie in 
+                # https://github.com/django/django/blob/ac5cc6cf01463d90aa333d5f6f046c311019827b/django/contrib/admin/options.py#L860
+                # causes non-consistent behaviour because Django sometimes looks up the 
+                # attribute name via 'pk = cl.lookup_opts.pk.attname'.
+                # instead provide an AliasProperty to the property tagged
+                # as primary_key
+                self.pk = AliasProperty(to=key)
+        
+        for key, relation in self.__all_relationships__:
+            opts.add_field(DjangoRelationField(relation,key), getattr(prop, 'private', False))
 
         return opts
 
+    def __hash__(self):
+        # The delete function in the Admin requires a hash
+        return hash(self.pk)
+   
     def full_clean(self, exclude, validate_unique=False):
         """
         Validate node, on error raising ValidationErrors which can be handled by django forms
@@ -217,6 +456,8 @@ def full_clean(self, exclude, validate_unique=False):
             raise ValidationError({e.property_name: e.msg})
         except RequiredProperty as e:
             raise ValidationError({e.property_name: 'is required'})
+        except UniqueProperty as e:
+            raise ValidationError({e.property_name: e.msg})  
 
     def validate_unique(self, exclude):
         # get unique indexed properties
diff --git a/tests/someapp/admin.py b/tests/someapp/admin.py
index 6bcded4..01cf1c8 100644
--- a/tests/someapp/admin.py
+++ b/tests/someapp/admin.py
@@ -1,6 +1,7 @@
 from django.contrib import admin as dj_admin
 from django_neomodel import admin as neo_admin
-from .models import Library, Book, Shelf
+from .models import Library, Book, Shelf, Author
+
 
 
 class LibraryAdmin(dj_admin.ModelAdmin):
@@ -10,9 +11,14 @@ class LibraryAdmin(dj_admin.ModelAdmin):
     )
 dj_admin.site.register(Library, LibraryAdmin)
 
+class AuthorAdmin(dj_admin.ModelAdmin):
+    list_display = ("name",)
+neo_admin.register(Author, AuthorAdmin)
 
 class BookAdmin(dj_admin.ModelAdmin):
     list_display = ("title", "created")
+    filter_horizontal = ('authored_by',)
+    #fields = ('title', 'shelf')
 neo_admin.register(Book, BookAdmin)
 
 
diff --git a/tests/someapp/models.py b/tests/someapp/models.py
index 37eeef6..e4a0d1e 100644
--- a/tests/someapp/models.py
+++ b/tests/someapp/models.py
@@ -1,8 +1,9 @@
 from datetime import datetime
 
 from django.db import models
-from django_neomodel import DjangoNode
-from neomodel import StringProperty, DateTimeProperty, UniqueIdProperty
+from django_neomodel import DjangoNode 
+from neomodel import StringProperty, DateTimeProperty, UniqueIdProperty, RelationshipTo, RelationshipFrom, AliasProperty, StructuredRel
+from neomodel.cardinality import OneOrMore, ZeroOrOne
 
 
 class Library(models.Model):
@@ -12,10 +13,35 @@ class Meta:
         app_label = 'someapp'
 
 
+class BaseRel(StructuredRel):
+    """ A simple relationship that stores timestqmps as properties on the relationship """
+
+
+    created_at = DateTimeProperty(default_now=True)
+    updated_at = DateTimeProperty(default_now=True)
+    group_id = StringProperty()
+    
+    def pre_save(self):
+        self.updated_at = datetime.utcnow()
+    def post_save(self):
+        pass
+
+class Author(DjangoNode):
+    unique_id = UniqueIdProperty(primary_key=True)
+    name = StringProperty()
+    wrote = RelationshipTo('Book','WROTE',model=BaseRel)
+
+    class Meta:
+        app_label = "someapp"
+
+    def __str__(self):
+        return self.name
+
 class Book(DjangoNode):
     uid = UniqueIdProperty(primary_key=True)
-    title = StringProperty(unique_index=True)
+    title = StringProperty(unique_index=True, help_text="Catchy title of the book")
     format = StringProperty(required=True)  # check required field can be omitted on update
+    
     status = StringProperty(choices=(
             ('available', 'A'),
             ('on_loan', 'L'),
@@ -23,6 +49,13 @@ class Book(DjangoNode):
         ), default='available', coerce=str)
     created = DateTimeProperty(default=datetime.utcnow)
 
+    # A book can only be stored in one shelf, thus ZeroOrOne
+    shelf = RelationshipTo('Shelf', 'STORED_IN',cardinality=ZeroOrOne)  
+    
+    #A book can be written by multiple authors, so the default ZeroOrMore 
+    # applies. As example this relationship has a model with properties: BaseRel
+    authored_by = RelationshipFrom('Author','WROTE', model=BaseRel) 
+
     class Meta:
         app_label = "someapp"
 
@@ -33,9 +66,10 @@ def __str__(self):
 class Shelf(DjangoNode):
     uid = UniqueIdProperty(primary_key=True)
     name = StringProperty()
+    contains = RelationshipFrom('Book','STORED_IN')
 
     class Meta:
         app_label = "someapp"
 
     def __str__(self):
-        return self.name
\ No newline at end of file
+        return self.name
diff --git a/tests/someapp/tests/test_model_form.py b/tests/someapp/tests/test_model_form.py
index 5eb74e3..9c09f6f 100644
--- a/tests/someapp/tests/test_model_form.py
+++ b/tests/someapp/tests/test_model_form.py
@@ -2,8 +2,11 @@
 from django.forms.models import ModelForm
 import django
 django.setup()
-from tests.someapp.models import Book
+from tests.someapp.models import Book, Author, Shelf
 from django import forms
+from django.db.models.fields import BLANK_CHOICE_DASH
+
+from neomodel import db, clear_neo4j_database
 
 GEEKS_CHOICES =(('available', 'A'),
             ('on_loan', 'L'),
@@ -15,7 +18,7 @@ class BookForm(ModelForm):
 
     class Meta:
         model = Book
-        fields = ('title', 'status', 'format')
+        fields = ('title', 'status', 'format', 'authored_by', 'shelf')
 
 
 class UpdateBookStatusForm(ModelForm):
@@ -23,11 +26,15 @@ class UpdateBookStatusForm(ModelForm):
 
     class Meta:
         model = Book
-        fields = ('title', 'status')
+        fields = ('title', 'status', 'authored_by')
 
 
 class BookFormTest(DjangoTestCase):
 
+    def setUp(self):
+        pass 
+        # clear_neo4j_database(db)
+
     def test_define(self):
         self.assertTrue(issubclass(BookForm, ModelForm))
 
@@ -43,21 +50,21 @@ def test_can_save(self):
 
         self.assertTrue(bf.is_valid())
         bf.save(True)
-
+    
     def test_unique_is_checked(self):
         BookForm(data={'title': 'book1', 'format': 'P'}).save()
         bf = BookForm(data={'title': 'book1', 'format': 'P'})
         self.assertFalse(bf.is_valid())
-
+    
     def test_can_update(self):
         hp = Book(title='Harrry', format='P').save()
-        bf = BookForm(data={'title': 'Harry Potter', 'status': 'damaged', 'format': 'P'}, instance=hp)
+        bf = BookForm(data={'title': 'Harry Potter the New One', 'status': 'damaged', 'format': 'P'}, instance=hp)
         self.assertTrue(bf.is_valid())
         bf.save(True)
 
     def test_can_update_subclass(self):
         hp = Book(title='potterr', format='P').save()
-        bf = UpdateBookStatusForm(data={'title': 'Hary Potter', 'format': 'P'}, instance=hp)
+        bf = UpdateBookStatusForm(data={'title': 'Hary Potter', 'format': 'P','status':'damaged'}, instance=hp)
         self.assertTrue(bf.is_valid())
         bf.save(True)
 
@@ -69,10 +76,73 @@ def test_can_update_w_out_required_field(self):
         bf.save(True)
 
     def test_can_render(self):
-        bf = BookForm(data={'title': 'Harry Potter', 'format': 'P'})
+        
+        author_ageta = Author(name='Ageta').save()
+        author_jk = Author(name='JK').save()
+        author_medea = Author(name='Medea').save()
+        
+        shelf_drama = Shelf(name='Drama').save()
+        shelf_travel = Shelf(name='Travel').save()
+
+        # Need a new form, otherwise the choices don't load
+        class BookForm2(ModelForm):
+            status = forms.ChoiceField(choices=GEEKS_CHOICES, initial='available', required=False)
+
+            class Meta:
+                model = Book
+                fields = ('title', 'status', 'format',)
+
+                fields = ('title', 'status', 'format', 'authored_by', 'shelf')
+         
+        bf = BookForm2(data={'title': 'Harry Potter', 'format': 'P'})
+        
         self.assertIn('Harry Potter', bf.__html__())
-        self.assertIn('<select', bf.__html__())
-
+        self.assertIn('<select name="status"', bf.__html__())
+       
+        # The multi choices lists for authored_by 
+        self.assertIn('<select name="authored_by" id="id_authored_by" multiple', bf.__html__())
+        
+        # Check possible authers are listed
+        
+        self.assertIn(author_ageta.pk + '">Ageta</option>', bf.__html__())
+        self.assertIn(author_jk.pk + '">JK</option>', bf.__html__())
+        self.assertIn(author_medea.pk + '">Medea</option>', bf.__html__())
+        
+        # Emtpy value should NOT be present in the MultiChoiceField of ZeroOrMore
+        self.assertNotIn(BLANK_CHOICE_DASH[0], bf.fields['authored_by']._choices)
+        
+        # The single choice list for shelf 
+        self.assertIn('<select name="shelf" id="id_shelf">', bf.__html__())
+
+        # Test shelve options
+
+        self.assertIn(shelf_drama.pk + '">Drama</option>', bf.__html__())
+        self.assertIn(shelf_travel.pk + '">Travel</option>', bf.__html__())
+       
+        # Emtpy value should be present in the TypedChoiceField of ZeroOrOne
+        self.assertIn(BLANK_CHOICE_DASH[0], bf.fields['shelf']._choices)
+        
+        # Also make sure the empty value is present in the HTML (not limited 
+        # to the specific shelf field though.
+        self.assertIn(BLANK_CHOICE_DASH[0][1], bf.__html__())
+
+        # Next test also show the right one is 'selected'
+        book_instance = Book(title='Harry Potter 308', format='P').save()
+        
+        book_instance.shelf.connect(shelf_drama)
+        book_instance.authored_by.connect(author_jk)
+        book_instance.authored_by.connect(author_medea)
+
+        book_instance.save()
+
+        bf = BookForm2(instance=book_instance) 
+        self.assertIn(author_ageta.pk + '">Ageta</option>', bf.__html__())
+        self.assertIn(author_jk.pk + '" selected>JK</option>', bf.__html__())
+        self.assertIn(author_medea.pk + '" selected>Medea</option>', bf.__html__())
+        
+        self.assertIn(shelf_drama.pk + '" selected>Drama</option>', bf.__html__())
+        self.assertIn(shelf_travel.pk + '">Travel</option>', bf.__html__())
+        
     def test_choices(self):
         bf = BookForm(data={'title': 'Select1', 'status': 'damaged', 'format': 'P'})
         self.assertTrue(bf.is_valid())
@@ -80,5 +150,95 @@ def test_choices(self):
         self.assertEqual(book.status, 'damaged')
 
     def test_invalid_choice(self):
-        bf = BookForm(data={'title': 'Select1', 'status': 'Damaged'})
-        self.assertFalse(bf.is_valid())
\ No newline at end of file
+        bf = BookForm(data={'title': 'Select3', 'status': 'Damaged', 'format': 'P'})
+        self.assertFalse(bf.is_valid())
+   
+    def test_book_by_author(self):
+        author_patrick = Author(name='Patrick').save()
+        bf = BookForm(data={'title': 'Written by Patrick', 'status': 'damaged', 
+                            'format': 'P', 'authored_by' : [author_patrick.pk]})
+       
+        self.assertTrue(bf.is_valid())
+        
+        book = bf.save()
+        self.assertEqual(book.status, 'damaged')
+        self.assertEqual(author_patrick.name, 'Patrick')
+        self.assertEqual(book.authored_by.all(), [author_patrick])
+        
+    def test_book_by_invalid_author(self):
+        bf = BookForm(data={'title': 'Written by Kees', 'status': 'damaged',
+                            'format': 'P', 'authored_by': ['notavalidpk']})
+
+        self.assertFalse(bf.is_valid())
+        
+    def test_can_update_book_with_relationship(self):
+        """
+        Start with a Book and add Authors and remove them again 
+        """
+
+        hp = Book(title='potterr', format='P').save()
+
+        author_hera = Author(name='Hera').save()
+        author_jason = Author(name='Jason').save()
+        
+        # Set Hera as Author of the book
+        bf = UpdateBookStatusForm(data={'title': 'Hary Potter has an author!', 
+                                        'format': 'P', 'status': 'damaged',
+                                        'authored_by': [author_hera.pk]}, instance=hp)
+
+        self.assertTrue(bf.is_valid())
+        bf.save(True)
+        
+        self.assertEqual(hp.authored_by.all(),[author_hera])
+        
+        # Now make Jason also author
+        bf = UpdateBookStatusForm(data={'title': 'Hary Potter has an author!', 
+                                        'format': 'P', 'status': 'damaged',
+                                        'authored_by': [author_hera.pk, author_jason.pk]}, instance=hp)
+        self.assertTrue(bf.is_valid())
+        bf.save(True)
+        self.assertEqual(set([hp.authored_by.all()[0].pk, hp.authored_by.all()[1].pk]),
+            set([author_hera.pk, author_jason.pk]))
+        
+        # This will fail if object can't be hashed
+        self.assertEqual(set(hp.authored_by.all()), 
+            set([author_hera, author_jason]))
+        
+        # And remove both as author
+        bf = UpdateBookStatusForm(data={'title': 'Hary Potter has an author!', 
+                                        'format': 'P', 'status': 'damaged', 
+                                        'authored_by': []}, instance=hp)
+        self.assertTrue(bf.is_valid())
+        bf.save(True)
+        self.assertEqual(hp.authored_by.all(), [])
+    
+    def test_book_with_single_shelf(self):
+        """
+        A book can only be put nowhere or in one shelf (ZeroOrOne)
+        """
+        shelf_fiction = Shelf(name='fiction').save()
+        bf = BookForm(data={'title': 'A book with a lot of fantasy', 
+                            'status': 'damaged', 'format': 'P', 
+                            'shelf': shelf_fiction.pk})
+       
+        self.assertTrue(bf.is_valid())
+        book = bf.save()
+        self.assertEqual(book.status, 'damaged')
+        self.assertEqual(shelf_fiction.name, 'fiction')
+        self.assertEqual(book.shelf.all(), [shelf_fiction])
+    
+    def test_book_with_two_shelfs_invalid(self):
+        """
+        A book can only be put nowhere or in one shelf (ZeroOrOne)
+        """
+        
+        shelf_thriller = Shelf(name='thriller').save()
+        shelf_nf = Shelf(name='non-fiction').save()
+        
+        bf = BookForm(data={'title': 'A book with a lot of truth', 'status': 'damaged', 
+                            'format': 'P', 'shelf': [shelf_nf.pk, shelf_thriller]})
+      
+        # Im working on this test case. It is running the 'not found' validation error
+        # but it should already have chooked on receiving 2 pks?! 
+        bf.is_valid()
+        self.assertFalse(bf.is_valid())

From df775cb1b383d5cc05664c1fb59cb7d22a847f90 Mon Sep 17 00:00:00 2001
From: EvdH0 <i@iric.nl>
Date: Thu, 30 Dec 2021 21:51:53 +0100
Subject: [PATCH 04/13] Move from potential circular import of related models
 to Django app registry

---
 django_neomodel/__init__.py | 124 ++++++++++++++++++++++++++++++++++--
 1 file changed, 118 insertions(+), 6 deletions(-)

diff --git a/django_neomodel/__init__.py b/django_neomodel/__init__.py
index d71cb6a..e5220af 100644
--- a/django_neomodel/__init__.py
+++ b/django_neomodel/__init__.py
@@ -18,6 +18,7 @@
 
 from importlib import import_module
 from types import SimpleNamespace
+from django.apps import apps as current_apps
 
 
 __author__ = 'Robin Edwards'
@@ -55,6 +56,57 @@ class DjangoFormFieldTypedChoice(form_fields.TypedChoiceField):
     def validate(self, value):
         return True
 
+class DjangoEmptyField(object):
+    """ Base field where Properties and Relations Field should subclass from """
+
+    is_relation = False
+    concrete = True
+    editable = True
+    creation_counter = 0
+    unique = False
+    primary_key = False
+    auto_created = False
+
+    # Then from class RelatedField(FieldCacheMixin, Field): see https://docs.djangoproject.com/en/2.0/_modules/django/db/models/fields/related/
+    # Field flags
+    one_to_many = None
+    one_to_one = None
+    many_to_many = None
+    many_to_one = None
+   
+    creation_counter = 0
+
+    def __init__(self):
+        self.remote_field = None
+        self.creation_counter = DjangoBaseField.creation_counter
+        DjangoBaseField.creation_counter += 1
+
+    def __eq__(self, other):
+        # Needed for @total_ordering
+        if isinstance(other, DjangoBaseField):
+            return self.creation_counter == other.creation_counter
+        return NotImplemented
+
+    def __lt__(self, other):
+        # This is needed because bisect does not take a comparison function.
+        if isinstance(other, DjangoBaseField):
+            return self.creation_counter < other.creation_counter
+        return NotImplemented
+
+    def has_default(self):
+        return self._has_default
+
+    def to_python(self, value):
+        return value
+
+    def __hash__(self):
+        # The delete function in the Admin requires a hash
+        return hash(self.creation_counter)
+
+    def clone(self):
+        return self
+    
+
 
 @total_ordering
 class DjangoBaseField(object):
@@ -102,6 +154,9 @@ def to_python(self, value):
     def __hash__(self):
         # The delete function in the Admin requires a hash
         return hash(self.creation_counter)
+
+    def clone(self):
+        return self
     
 
 class DjangoPropertyField(DjangoBaseField):
@@ -119,6 +174,7 @@ def __init__(self, prop, name):
         self.prop = prop
         self.name = name
         self.remote_field = name
+        self.remote_field = None
         self.attname = name
         self.verbose_name = name
         self.help_text = getattr(prop, 'help_text', '')
@@ -195,6 +251,10 @@ def get_choices(self, include_blank=True):
         return first_choice + choices
 
 
+    def clone(self):
+        return self
+
+
 class DjangoRemoteField(object):
     """ Fake RemoteField to let the Django Admin work """
 
@@ -202,6 +262,7 @@ def __init__(self, b):
         # Fake this call https://github.com/django/django/blob/ac5cc6cf01463d90aa333d5f6f046c311019827b/django/contrib/admin/widgets.py#L278
         self.model = b 
         self.through = SimpleNamespace(_meta=SimpleNamespace(auto_created=True))
+        #pass
 
     def get_related_field(self):
         # Fake call https://github.com/django/django/blob/ac5cc6cf01463d90aa333d5f6f046c311019827b/django/contrib/admin/widgets.py#L282
@@ -276,7 +337,11 @@ def save_form_data(self, instance, data):
 
         instance_relation = getattr(instance, self.name)
         # Need to define which nodes to disconnect from first!
-        all_possible_nodes = self._related_model.nodes.all()
+
+        related_model = current_apps.get_model(self.prop.module_name.split('.')[-2],
+            self.prop._raw_class)
+
+        all_possible_nodes = related_model.nodes.all()
         
         # Gather the pks from these nodes
         list_of_ids = []
@@ -346,13 +411,18 @@ def _connect_node(self, data, instance_relation):
    
     def formfield(self, *args, **kwargs):
         """Return a django.forms.Field instance for this field."""
-
+        
         node_options = []
 
+        # Fetch the related_module from the apps registry (instead of circular imports)
+        related_model = current_apps.get_model(self.prop.module_name.split('.')[-2],
+            self.prop._raw_class)
+
         if self.prop.manager is ZeroOrOne:
             node_options = BLANK_CHOICE_DASH.copy()
 
-        for this_object in self._related_model.nodes.all():
+    
+        for this_object in related_model.nodes.all():
             node_options.append((this_object.pk, this_object.__str__))
 
         defaults = {'required': self.required,
@@ -364,6 +434,14 @@ def formfield(self, *args, **kwargs):
         defaults['choices'] = node_options
         return self.form_class(**defaults)
 
+    def clone(self):
+        """ 
+        Upon cloning a relationship, provide an empty field wrapper, so circular
+        imports are prevented by the Django app registry
+        """
+
+        return DjangoEmptyField()
+
 
 class Query:
     select_related = False
@@ -383,31 +461,50 @@ def count(self):
     def _clone(self):
         return self
 
+    def iterator(self):
+        """ Needed to run pytest after adding app/model register """
+        return []
+
 
 class NeoManager:
     def __init__(self, model):
         self.model = model
-
+        
     def get_queryset(self):
         return NeoNodeSet(self.model)
 
+    def using(self, connection):
+        """ Needed to run pytest after adding app/model register"""
+        return NeoNodeSet(self.model)
+
 
 class MetaClass(NodeMeta):
     def __new__(cls, *args, **kwargs):
         super_new = super().__new__
         new_cls = super_new(cls, *args, **kwargs)
         setattr(new_cls, "_default_manager", NeoManager(new_cls))
+
+        # Needed to run pytest, after adding app/model register
+        setattr(new_cls, "_base_manager", NeoManager(new_cls))
+       
         return new_cls
 
 
 class DjangoNode(StructuredNode, metaclass=MetaClass):
     __abstract_node__ = True
 
+    
     @classproperty
     def _meta(self):
+
         if hasattr(self.Meta, 'unique_together'):
             raise NotImplementedError('unique_together property not supported by neomodel')
-        
+
+    
+        #def can_migrate(self, connection):
+        #    return False
+
+
         # Need a ModelState for the admin to delete an object
         self._state = ModelState() 
         self._state.adding = False 
@@ -432,10 +529,25 @@ def _meta(self):
                 self.pk = AliasProperty(to=key)
         
         for key, relation in self.__all_relationships__:
-            opts.add_field(DjangoRelationField(relation,key), getattr(prop, 'private', False))
+            opts.add_field(DjangoRelationField(relation, key), getattr(prop, 'private', False))
+
+        # Register the model in the Django app registry. 
+        # Django will try to clone to make a ModelState and upon cloning
+        # the relations will result in an empty object, so there are no
+        # circular imports
+        
+        #raise Warning(self.__module__.split('.')[-2])
+        current_apps.register_model(self.__module__.split('.')[-2],  self)
 
         return opts
 
+   
+   
+    @classmethod
+    def check(cls, **kwargs):
+        """ Needed for app registry, always provide empty list of errors """
+        return []
+
     def __hash__(self):
         # The delete function in the Admin requires a hash
         return hash(self.pk)

From d99fcb5b8cd08a835fcf43dab1ec9ef69182668c Mon Sep 17 00:00:00 2001
From: EvdH0 <i@iric.nl>
Date: Thu, 30 Dec 2021 22:31:44 +0100
Subject: [PATCH 05/13] Move use of app registry for referenced models

---
 django_neomodel/__init__.py | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/django_neomodel/__init__.py b/django_neomodel/__init__.py
index e5220af..4b6560b 100644
--- a/django_neomodel/__init__.py
+++ b/django_neomodel/__init__.py
@@ -314,11 +314,14 @@ def __init__(self, prop, name):
             self.form_class = DjangoFormFieldMultipleChoice 
     
         # Need to load the related model in so we can fetch
-        # all nodes.
+        # all nodes. This solution, instead of using the app
+        # registry is far from idea, because it can cause
+        # circular imports
 
         a = import_module(self.prop.module_name)
         b = getattr(a, self.prop._raw_class)
-        self._related_model = b 
+        #self._related_model = b 
+
         
         self.remote_field = DjangoRemoteField(b)
 
@@ -388,20 +391,27 @@ def save_form_data(self, instance, data):
     def _disconnect_node(self, should_not_be_connected, instance_relation):
         """ Given a list pk's, remove the relationship """
 
+        related_model = current_apps.get_model(self.prop.module_name.split('.')[-2],
+            self.prop._raw_class)
+
         # Internals used by save_form_data to 
         for this_object in should_not_be_connected:
-            remover = self._related_model.nodes.get_or_none(pk=this_object)
+            remover = related_model.nodes.get_or_none(pk=this_object)
             instance_relation.disconnect(remover)
 
     def _connect_node(self, data, instance_relation):
         """ Given a list pk's, add the relationship """
 
+        related_model = current_apps.get_model(self.prop.module_name.split('.')[-2],
+            self.prop._raw_class)
+
+
         # If ChoiceField, it is not a list
         data = [data] if not isinstance(data, list) else data  
         
         for this_object in data:
             # Retreive the node-to-connect-to
-            adder = self._related_model.nodes.get_or_none(pk=this_object)
+            adder = related_model.nodes.get_or_none(pk=this_object)
             # If the connection is there, leave it
             if not adder:
                 raise ValidationError({self.name: ' not found'})

From 7663a3da053974cde3703848fda08bdb53af653f Mon Sep 17 00:00:00 2001
From: EvdH0 <i@iric.nl>
Date: Sat, 8 Jan 2022 23:59:18 +0100
Subject: [PATCH 06/13] Use AppRegistry for model tracking

---
 django_neomodel/__init__.py | 170 ++++++++++++++++++------------------
 1 file changed, 86 insertions(+), 84 deletions(-)

diff --git a/django_neomodel/__init__.py b/django_neomodel/__init__.py
index 4b6560b..725b1a8 100644
--- a/django_neomodel/__init__.py
+++ b/django_neomodel/__init__.py
@@ -16,10 +16,16 @@
 from neomodel.match import NodeSet
 from neomodel.cardinality import OneOrMore, One, ZeroOrOne, ZeroOrMore
 
-from importlib import import_module
 from types import SimpleNamespace
 from django.apps import apps as current_apps
 
+# Need to following to get the relationships to work
+RECURSIVE_RELATIONSHIP_CONSTANT = 'self'
+
+from django.db.models.fields.related import resolve_relation, RECURSIVE_RELATIONSHIP_CONSTANT, lazy_related_operation
+from django.db.models.utils import make_model_tuple
+from functools import partial
+
 
 __author__ = 'Robin Edwards'
 __email__ = 'robin.ge@gmail.com'
@@ -56,57 +62,6 @@ class DjangoFormFieldTypedChoice(form_fields.TypedChoiceField):
     def validate(self, value):
         return True
 
-class DjangoEmptyField(object):
-    """ Base field where Properties and Relations Field should subclass from """
-
-    is_relation = False
-    concrete = True
-    editable = True
-    creation_counter = 0
-    unique = False
-    primary_key = False
-    auto_created = False
-
-    # Then from class RelatedField(FieldCacheMixin, Field): see https://docs.djangoproject.com/en/2.0/_modules/django/db/models/fields/related/
-    # Field flags
-    one_to_many = None
-    one_to_one = None
-    many_to_many = None
-    many_to_one = None
-   
-    creation_counter = 0
-
-    def __init__(self):
-        self.remote_field = None
-        self.creation_counter = DjangoBaseField.creation_counter
-        DjangoBaseField.creation_counter += 1
-
-    def __eq__(self, other):
-        # Needed for @total_ordering
-        if isinstance(other, DjangoBaseField):
-            return self.creation_counter == other.creation_counter
-        return NotImplemented
-
-    def __lt__(self, other):
-        # This is needed because bisect does not take a comparison function.
-        if isinstance(other, DjangoBaseField):
-            return self.creation_counter < other.creation_counter
-        return NotImplemented
-
-    def has_default(self):
-        return self._has_default
-
-    def to_python(self, value):
-        return value
-
-    def __hash__(self):
-        # The delete function in the Admin requires a hash
-        return hash(self.creation_counter)
-
-    def clone(self):
-        return self
-    
-
 
 @total_ordering
 class DjangoBaseField(object):
@@ -159,6 +114,14 @@ def clone(self):
         return self
     
 
+class DjangoEmptyField(DjangoBaseField):
+    """ Empty  field """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.remote_field = None
+        
+
 class DjangoPropertyField(DjangoBaseField):
     """
     Fake Django model field object which wraps a neomodel Property
@@ -250,7 +213,6 @@ def get_choices(self, include_blank=True):
                         not blank_defined else [])
         return first_choice + choices
 
-
     def clone(self):
         return self
 
@@ -258,17 +220,18 @@ def clone(self):
 class DjangoRemoteField(object):
     """ Fake RemoteField to let the Django Admin work """
 
-    def __init__(self, b):
+    def __init__(self, name):
         # Fake this call https://github.com/django/django/blob/ac5cc6cf01463d90aa333d5f6f046c311019827b/django/contrib/admin/widgets.py#L278
-        self.model = b 
+        self.related_name = name 
+        self.related_query_name = name
+        self.model = name
         self.through = SimpleNamespace(_meta=SimpleNamespace(auto_created=True))
-        #pass
-
+    
     def get_related_field(self):
         # Fake call https://github.com/django/django/blob/ac5cc6cf01463d90aa333d5f6f046c311019827b/django/contrib/admin/widgets.py#L282
         # from the Django Admin
         return SimpleNamespace(name=self.model.pk.target)
-
+       
 
 class DjangoRelationField(DjangoBaseField):
     """
@@ -314,19 +277,26 @@ def __init__(self, prop, name):
             self.form_class = DjangoFormFieldMultipleChoice 
     
         # Need to load the related model in so we can fetch
-        # all nodes. This solution, instead of using the app
-        # registry is far from idea, because it can cause
-        # circular imports
+        # all nodes. 
+        self.remote_field = DjangoRemoteField(self.prop._raw_class)
 
-        a = import_module(self.prop.module_name)
-        b = getattr(a, self.prop._raw_class)
-        #self._related_model = b 
+        super().__init__()
 
-        
-        self.remote_field = DjangoRemoteField(b)
+    def set_attributes_from_rel(self):
+        """ From https://github.com/django/django/blob/1be99e4e0a590d9a008da49e8e3b118b57e14075/django/db/models/fields/related.py#L393 """
+        self.name = (
+            self.name or
+            (self.remote_field.model._meta.model_name + '_' + self.remote_field.model._meta.pk.name)
+        )
+        if self.verbose_name is None:
+            self.verbose_name = self.remote_field.model._meta.verbose_name
+        # self.remote_field.set_field_name()
+
+    def do_related_class(self, other, cls):
+        """ from https://github.com/django/django/blob/1be99e4e0a590d9a008da49e8e3b118b57e14075/django/db/models/fields/related.py#L402 """
+        self.set_attributes_from_rel()
+        # self.contribute_to_related_class(other, self.remote_field)
 
-        super().__init__()
-        
     def value_from_object(self, instance):
         instance_relation = getattr(instance, self.name)
         node_ids_selected = []
@@ -405,7 +375,6 @@ def _connect_node(self, data, instance_relation):
         related_model = current_apps.get_model(self.prop.module_name.split('.')[-2],
             self.prop._raw_class)
 
-
         # If ChoiceField, it is not a list
         data = [data] if not isinstance(data, list) else data  
         
@@ -430,8 +399,7 @@ def formfield(self, *args, **kwargs):
 
         if self.prop.manager is ZeroOrOne:
             node_options = BLANK_CHOICE_DASH.copy()
-
-    
+   
         for this_object in related_model.nodes.all():
             node_options.append((this_object.pk, this_object.__str__))
 
@@ -452,6 +420,36 @@ def clone(self):
 
         return DjangoEmptyField()
 
+    def contribute_to_class(self, cls, name, private_only=False, **kwargs):
+        """ Modified from https://github.com/django/django/blob/2a66c102d9c674fadab252a28d8def32a8b626ec/django/db/models/fields/related.py#L305 """
+        #super().contribute_to_class(cls, name, private_only=private_only, **kwargs)
+        self.opts = cls._meta
+
+        if not cls._meta.abstract:
+            if self.remote_field.related_name:
+                related_name = self.remote_field.related_name
+            else:
+                related_name = self.opts.default_related_name
+            if related_name:
+                related_name = related_name % {
+                    'class': cls.__name__.lower(),
+                    'model_name': cls._meta.model_name.lower(),
+                    'app_label': cls._meta.app_label.lower()
+                }
+                self.remote_field.related_name = related_name
+
+            if self.remote_field.related_query_name:
+                related_query_name = self.remote_field.related_query_name % {
+                    'class': cls.__name__.lower(),
+                    'app_label': cls._meta.app_label.lower(),
+                }
+                self.remote_field.related_query_name = related_query_name
+
+            def resolve_related_class(model, related, field):
+                field.remote_field.model = related
+                field.do_related_class(related, model)
+            lazy_related_operation(resolve_related_class, cls, self.remote_field.model, field=self)
+
 
 class Query:
     select_related = False
@@ -496,25 +494,28 @@ def __new__(cls, *args, **kwargs):
 
         # Needed to run pytest, after adding app/model register
         setattr(new_cls, "_base_manager", NeoManager(new_cls))
-       
+
+        if new_cls.__module__ is __package__: # Do not populate DjangoNode
+            pass
+        elif new_cls.__module__.split('.')[-2] == 'tests': # Also skip test signals
+            pass
+        else:
+            
+            meta = getattr(new_cls, 'Meta', None)
+            current_apps.register_model(new_cls.__module__.split('.')[-2],  new_cls)
+
         return new_cls
 
 
 class DjangoNode(StructuredNode, metaclass=MetaClass):
     __abstract_node__ = True
-
-    
+  
     @classproperty
     def _meta(self):
 
         if hasattr(self.Meta, 'unique_together'):
             raise NotImplementedError('unique_together property not supported by neomodel')
 
-    
-        #def can_migrate(self, connection):
-        #    return False
-
-
         # Need a ModelState for the admin to delete an object
         self._state = ModelState() 
         self._state.adding = False 
@@ -539,20 +540,21 @@ def _meta(self):
                 self.pk = AliasProperty(to=key)
         
         for key, relation in self.__all_relationships__:
-            opts.add_field(DjangoRelationField(relation, key), getattr(prop, 'private', False))
+            new_relation_field = DjangoRelationField(relation, key)
+            new_relation_field.contribute_to_class(self, key)
+            opts.add_field(new_relation_field, getattr(prop, 'private', False))
+
+        # Need to do some model reloading here ^^
 
         # Register the model in the Django app registry. 
         # Django will try to clone to make a ModelState and upon cloning
         # the relations will result in an empty object, so there are no
         # circular imports
+        #current_apps.register_model(self.__module__.split('.')[-2],  self)
         
-        #raise Warning(self.__module__.split('.')[-2])
-        current_apps.register_model(self.__module__.split('.')[-2],  self)
 
         return opts
 
-   
-   
     @classmethod
     def check(cls, **kwargs):
         """ Needed for app registry, always provide empty list of errors """

From dd71391b8bbbfe3a4374d42644cd8217606cea48 Mon Sep 17 00:00:00 2001
From: EvdH0 <i@iric.nl>
Date: Sun, 9 Jan 2022 15:49:44 +0100
Subject: [PATCH 07/13] Prevent removing node that do not exist

---
 django_neomodel/__init__.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/django_neomodel/__init__.py b/django_neomodel/__init__.py
index 725b1a8..c4cfcd5 100644
--- a/django_neomodel/__init__.py
+++ b/django_neomodel/__init__.py
@@ -365,9 +365,11 @@ def _disconnect_node(self, should_not_be_connected, instance_relation):
             self.prop._raw_class)
 
         # Internals used by save_form_data to 
+        # TODO: first get list of connected nodes, so don't run lots of disconnects
         for this_object in should_not_be_connected:
             remover = related_model.nodes.get_or_none(pk=this_object)
-            instance_relation.disconnect(remover)
+            if remover:
+                instance_relation.disconnect(remover)
 
     def _connect_node(self, data, instance_relation):
         """ Given a list pk's, add the relationship """

From 755a2a6a1a6342fc9f3eb605689a2de4e9f2036f Mon Sep 17 00:00:00 2001
From: EvdH0 <i@iric.nl>
Date: Fri, 14 Jan 2022 23:13:10 +0100
Subject: [PATCH 08/13] Update tests with app registry

---
 tests/someapp/tests/test_model_form.py | 24 +++++++++++++++++++++++-
 1 file changed, 23 insertions(+), 1 deletion(-)

diff --git a/tests/someapp/tests/test_model_form.py b/tests/someapp/tests/test_model_form.py
index 9c09f6f..1fe2cef 100644
--- a/tests/someapp/tests/test_model_form.py
+++ b/tests/someapp/tests/test_model_form.py
@@ -7,6 +7,8 @@
 from django.db.models.fields import BLANK_CHOICE_DASH
 
 from neomodel import db, clear_neo4j_database
+  
+from django.apps import AppConfig, apps
 
 GEEKS_CHOICES =(('available', 'A'),
             ('on_loan', 'L'),
@@ -90,7 +92,6 @@ class BookForm2(ModelForm):
 
             class Meta:
                 model = Book
-                fields = ('title', 'status', 'format',)
 
                 fields = ('title', 'status', 'format', 'authored_by', 'shelf')
          
@@ -242,3 +243,24 @@ def test_book_with_two_shelfs_invalid(self):
         # but it should already have chooked on receiving 2 pks?! 
         bf.is_valid()
         self.assertFalse(bf.is_valid())
+
+    def test_app_registry(self):
+        """
+        To parse the relationships, models need to be loaded in the app registry
+        """
+        
+        model_return = apps.get_model('someapp','book')
+        self.assertEqual(model_return, Book)
+
+        model_return = apps.get_model('someapp','Author')
+        self.assertEqual(model_return, Author)
+
+        model_return = apps.get_model('someapp','Shelf')
+        self.assertEqual(model_return, Shelf)
+
+    def test_app_registry_non_model(self):
+        import pytest
+        with pytest.raises(Exception) as execinfo:
+            model_return = apps.get_model('someapp','nonxsitingmodel')
+ 
+        assert execinfo.value.args[0] == "App 'someapp' doesn't have a 'nonxsitingmodel' model."

From 64728331597b96ddf4595df1b3e67c347c0a54bc Mon Sep 17 00:00:00 2001
From: EvdH0 <i@iric.nl>
Date: Sun, 16 Jan 2022 22:23:49 +0100
Subject: [PATCH 09/13] Let datetime widgets work in admin

---
 django_neomodel/__init__.py | 38 +++++++++++++++++++++++++++++++++----
 1 file changed, 34 insertions(+), 4 deletions(-)

diff --git a/django_neomodel/__init__.py b/django_neomodel/__init__.py
index c4cfcd5..ecae9be 100644
--- a/django_neomodel/__init__.py
+++ b/django_neomodel/__init__.py
@@ -3,7 +3,7 @@
 from django.db.models import signals
 from django.db.models.fields import BLANK_CHOICE_DASH
 from django.db.models.base import ModelState
-from django.db.models import ManyToManyField
+from django.db.models import ManyToManyField, DateField, DateTimeField
 
 from django.conf import settings
 from django.forms import fields as form_fields
@@ -151,6 +151,7 @@ def __init__(self, prop, name):
         self.label = prop.label if prop.label else name
 
         form_cls = getattr(prop, 'form_field_class', 'Field')  # get field string
+        self.form_clsx = form_cls  # Use for class faking in __class__
         self.form_class = getattr(form_fields, form_cls, form_fields.CharField)
 
         self._has_default = prop.has_default
@@ -176,7 +177,7 @@ def formfield(self, **kwargs):
                     'help_text': self.help_text}
 
         if self.has_default():
-                defaults['initial'] = self.prop.default_value()
+            defaults['initial'] = self.prop.default_value()
 
         if self.choices:
             # Fields with choices get special treatment.
@@ -195,9 +196,15 @@ def formfield(self, **kwargs):
                     del kwargs[k]
 
         defaults.update(kwargs)
+
+        # This needs to be fixed but at https://github.com/django/django/blob/dc9deea8e85641695e489e43ed5d5638134c15c7/django/contrib/admin/options.py#L80
+        # the Admin injects a form_class. For now just remove this
+        defaults.pop('form_class', None)
+
         return self.form_class(**defaults)
 
     def get_choices(self, include_blank=True):
+        
         blank_defined = False
         blank_choice = BLANK_CHOICE_DASH
         choices = list(self.choices) if self.choices else []
@@ -216,6 +223,20 @@ def get_choices(self, include_blank=True):
     def clone(self):
         return self
 
+    @property
+    def __class__(self):
+        # Fake the class for 
+        # https://github.com/django/django/blob/dc9deea8e85641695e489e43ed5d5638134c15c7/django/contrib/admin/options.py#L144
+        # so we can get the admin Field specific widgets to work, ie the DateTime widget
+        
+        if self.form_clsx == 'DateField':
+            return DateField
+        elif self.form_clsx == 'DateTimeField':
+            return DateTimeField
+        else:
+            return DjangoBaseField
+
+
 
 class DjangoRemoteField(object):
     """ Fake RemoteField to let the Django Admin work """
@@ -231,7 +252,8 @@ def get_related_field(self):
         # Fake call https://github.com/django/django/blob/ac5cc6cf01463d90aa333d5f6f046c311019827b/django/contrib/admin/widgets.py#L282
         # from the Django Admin
         return SimpleNamespace(name=self.model.pk.target)
-       
+    
+
 
 class DjangoRelationField(DjangoBaseField):
     """
@@ -250,9 +272,15 @@ def __class__(self):
         # so we can get the admin ManyToMany field widgets to work
         return ManyToManyField
 
+    
     def __init__(self, prop, name):
         self.prop = prop
-        self.choices = None 
+        self.choices = None
+        # See https://github.com/django/django/blob/2a66c102d9c674fadab252a28d8def32a8b626ec/django/contrib/admin/options.py#L140
+        # if db_field.choices:
+        #    return self.formfield_for_choice_field(db_field, request, **kwargs)
+        # So set this to None
+
         
         self.required = False
         if prop.manager is OneOrMore or prop.manager is One:
@@ -280,8 +308,10 @@ def __init__(self, prop, name):
         # all nodes. 
         self.remote_field = DjangoRemoteField(self.prop._raw_class)
 
+        
         super().__init__()
 
+
     def set_attributes_from_rel(self):
         """ From https://github.com/django/django/blob/1be99e4e0a590d9a008da49e8e3b118b57e14075/django/db/models/fields/related.py#L393 """
         self.name = (

From ba8985d8d8eebd9473b9ffb857798d3dcb16fe5e Mon Sep 17 00:00:00 2001
From: EvdH0 <i@iric.nl>
Date: Sun, 20 Mar 2022 16:10:12 +0100
Subject: [PATCH 10/13] Remove support for DateTime widget, only Date widget
 works. Furthermore cleanup the choices option

---
 django_neomodel/__init__.py            | 55 +++++++++++---------------
 tests/someapp/tests/test_model_form.py |  3 ++
 2 files changed, 26 insertions(+), 32 deletions(-)

diff --git a/django_neomodel/__init__.py b/django_neomodel/__init__.py
index ecae9be..9e47a89 100644
--- a/django_neomodel/__init__.py
+++ b/django_neomodel/__init__.py
@@ -3,11 +3,10 @@
 from django.db.models import signals
 from django.db.models.fields import BLANK_CHOICE_DASH
 from django.db.models.base import ModelState
-from django.db.models import ManyToManyField, DateField, DateTimeField
+from django.db.models import ManyToManyField, DateField
 
 from django.conf import settings
 from django.forms import fields as form_fields
-from django.forms import ModelMultipleChoiceField as form_ModelMultipleChoiceField 
 from django.db.models.options import Options
 from django.core.exceptions import ValidationError 
 
@@ -19,14 +18,11 @@
 from types import SimpleNamespace
 from django.apps import apps as current_apps
 
+from django.db.models.fields.related import lazy_related_operation
+
 # Need to following to get the relationships to work
 RECURSIVE_RELATIONSHIP_CONSTANT = 'self'
 
-from django.db.models.fields.related import resolve_relation, RECURSIVE_RELATIONSHIP_CONSTANT, lazy_related_operation
-from django.db.models.utils import make_model_tuple
-from functools import partial
-
-
 __author__ = 'Robin Edwards'
 __email__ = 'robin.ge@gmail.com'
 __license__ = 'MIT'
@@ -158,7 +154,7 @@ def __init__(self, prop, name):
         self.required = prop.required
         self.blank = not self.required
         self.choices = getattr(prop, 'choices', None)
-
+    
         super().__init__()
 
     def save_form_data(self, instance, data):
@@ -181,8 +177,10 @@ def formfield(self, **kwargs):
 
         if self.choices:
             # Fields with choices get special treatment.
-            include_blank = (not self.required or
+            # So following this: https://github.com/django/django/blob/35c2474f168fd10ac50886024d5879de81be5bd3/django/db/models/fields/__init__.py#L1005
+            include_blank = (not self.required and
                              not (self.has_default() or 'initial' in kwargs))
+                   
             defaults['choices'] = self.get_choices(include_blank=include_blank)
             defaults['coerce'] = self.to_python
 
@@ -209,13 +207,16 @@ def get_choices(self, include_blank=True):
         blank_choice = BLANK_CHOICE_DASH
         choices = list(self.choices) if self.choices else []
         if issubclass(type(self.choices), dict):
-            # Ensure list of tuples with proper key-value pairing
+            # Ensure list of tuples with proper key-value pairing when passing dict
             choices = [(k, v) for k, v in self.choices.items()] 
+        
         for choice, __ in choices:
             if choice in ('', None):
                 blank_defined = True
                 break
-
+        
+        # For now overwrite include_blank, so neomodel will not error on '' not being in self.choices
+        include_blank = False 
         first_choice = (blank_choice if include_blank and
                         not blank_defined else [])
         return first_choice + choices
@@ -227,17 +228,17 @@ def clone(self):
     def __class__(self):
         # Fake the class for 
         # https://github.com/django/django/blob/dc9deea8e85641695e489e43ed5d5638134c15c7/django/contrib/admin/options.py#L144
-        # so we can get the admin Field specific widgets to work, ie the DateTime widget
+        # so we can get the admin Field specific widgets to work, ie the Date widget
+        # the SplitDateTimewidget (which is invoked by the admin when a DateTimeField is passed) doesn't work yet.
         
         if self.form_clsx == 'DateField':
             return DateField
-        elif self.form_clsx == 'DateTimeField':
-            return DateTimeField
+        # elif self.form_clsx == 'DateTimeField':
+        #    return DateTimeField
         else:
             return DjangoBaseField
 
 
-
 class DjangoRemoteField(object):
     """ Fake RemoteField to let the Django Admin work """
 
@@ -254,7 +255,6 @@ def get_related_field(self):
         return SimpleNamespace(name=self.model.pk.target)
     
 
-
 class DjangoRelationField(DjangoBaseField):
     """
     Fake Django model field object which wraps a neomodel Relationship
@@ -272,7 +272,6 @@ def __class__(self):
         # so we can get the admin ManyToMany field widgets to work
         return ManyToManyField
 
-    
     def __init__(self, prop, name):
         self.prop = prop
         self.choices = None
@@ -281,7 +280,6 @@ def __init__(self, prop, name):
         #    return self.formfield_for_choice_field(db_field, request, **kwargs)
         # So set this to None
 
-        
         self.required = False
         if prop.manager is OneOrMore or prop.manager is One:
             self.required = True
@@ -307,11 +305,9 @@ def __init__(self, prop, name):
         # Need to load the related model in so we can fetch
         # all nodes. 
         self.remote_field = DjangoRemoteField(self.prop._raw_class)
-
-        
+     
         super().__init__()
 
-
     def set_attributes_from_rel(self):
         """ From https://github.com/django/django/blob/1be99e4e0a590d9a008da49e8e3b118b57e14075/django/db/models/fields/related.py#L393 """
         self.name = (
@@ -527,13 +523,17 @@ def __new__(cls, *args, **kwargs):
         # Needed to run pytest, after adding app/model register
         setattr(new_cls, "_base_manager", NeoManager(new_cls))
 
-        if new_cls.__module__ is __package__: # Do not populate DjangoNode
+        if new_cls.__module__ is __package__:  # Do not populate DjangoNode
             pass
-        elif new_cls.__module__.split('.')[-2] == 'tests': # Also skip test signals
+        elif new_cls.__module__.split('.')[-2] == 'tests':  # Also skip test signals
             pass
         else:
             
             meta = getattr(new_cls, 'Meta', None)
+            # Register the model in the Django app registry. 
+            # Django will try to clone to make a ModelState and upon cloning
+            # the relations will result in an empty object, so there are no
+            # circular imports
             current_apps.register_model(new_cls.__module__.split('.')[-2],  new_cls)
 
         return new_cls
@@ -575,16 +575,7 @@ def _meta(self):
             new_relation_field = DjangoRelationField(relation, key)
             new_relation_field.contribute_to_class(self, key)
             opts.add_field(new_relation_field, getattr(prop, 'private', False))
-
-        # Need to do some model reloading here ^^
-
-        # Register the model in the Django app registry. 
-        # Django will try to clone to make a ModelState and upon cloning
-        # the relations will result in an empty object, so there are no
-        # circular imports
-        #current_apps.register_model(self.__module__.split('.')[-2],  self)
         
-
         return opts
 
     @classmethod
diff --git a/tests/someapp/tests/test_model_form.py b/tests/someapp/tests/test_model_form.py
index 1fe2cef..526a9f8 100644
--- a/tests/someapp/tests/test_model_form.py
+++ b/tests/someapp/tests/test_model_form.py
@@ -248,13 +248,16 @@ def test_app_registry(self):
         """
         To parse the relationships, models need to be loaded in the app registry
         """
+        #from django.apps.registry import Apps
         
         model_return = apps.get_model('someapp','book')
         self.assertEqual(model_return, Book)
 
+
         model_return = apps.get_model('someapp','Author')
         self.assertEqual(model_return, Author)
 
+
         model_return = apps.get_model('someapp','Shelf')
         self.assertEqual(model_return, Shelf)
 

From 2b47184fd9b58dac817f2b679629f3be2c924d2d Mon Sep 17 00:00:00 2001
From: MariusC <marius.conjeaud@outlook.com>
Date: Tue, 21 May 2024 17:09:28 +0200
Subject: [PATCH 11/13] Update models.py

neomodel 5.3.0 moved some internals
---
 tests/someapp/models.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/someapp/models.py b/tests/someapp/models.py
index e4a0d1e..4feb225 100644
--- a/tests/someapp/models.py
+++ b/tests/someapp/models.py
@@ -3,7 +3,7 @@
 from django.db import models
 from django_neomodel import DjangoNode 
 from neomodel import StringProperty, DateTimeProperty, UniqueIdProperty, RelationshipTo, RelationshipFrom, AliasProperty, StructuredRel
-from neomodel.cardinality import OneOrMore, ZeroOrOne
+from neomodel.sync_.cardinality import OneOrMore, ZeroOrOne
 
 
 class Library(models.Model):

From e28ec81c1e296c810c9a86dcf4292fcc8116ed52 Mon Sep 17 00:00:00 2001
From: Marius Conjeaud <rmcj@novonordisk.com>
Date: Wed, 22 May 2024 11:47:09 +0200
Subject: [PATCH 12/13] Passthrough implementation of prefetching to fix tests

---
 django_neomodel/__init__.py | 300 +++++++++++++++++++++---------------
 1 file changed, 176 insertions(+), 124 deletions(-)

diff --git a/django_neomodel/__init__.py b/django_neomodel/__init__.py
index 0c7ca57..274abdb 100644
--- a/django_neomodel/__init__.py
+++ b/django_neomodel/__init__.py
@@ -8,9 +8,16 @@
 from django.conf import settings
 from django.forms import fields as form_fields
 from django.db.models.options import Options
-from django.core.exceptions import ValidationError 
-
-from neomodel import RequiredProperty, DeflateError, StructuredNode, UniqueIdProperty, AliasProperty, UniqueProperty 
+from django.core.exceptions import ValidationError
+
+from neomodel import (
+    RequiredProperty,
+    DeflateError,
+    StructuredNode,
+    UniqueIdProperty,
+    AliasProperty,
+    UniqueProperty,
+)
 from neomodel.sync_.core import NodeMeta
 from neomodel.sync_.match import NodeSet
 from neomodel.sync_.cardinality import OneOrMore, One, ZeroOrOne, ZeroOrMore
@@ -21,7 +28,7 @@
 from django.db.models.fields.related import lazy_related_operation
 
 # Need to following to get the relationships to work
-RECURSIVE_RELATIONSHIP_CONSTANT = 'self'
+RECURSIVE_RELATIONSHIP_CONSTANT = "self"
 
 __author__ = "Robin Edwards"
 __email__ = "robin.ge@gmail.com"
@@ -49,20 +56,22 @@ class NOT_PROVIDED:
 
 
 class DjangoFormFieldMultipleChoice(form_fields.MultipleChoiceField):
-    """ Sublcass of Djangos MultipleChoiceField but without working validator """
+    """Sublcass of Djangos MultipleChoiceField but without working validator"""
+
     def validate(self, value):
-        return True 
+        return True
 
 
 class DjangoFormFieldTypedChoice(form_fields.TypedChoiceField):
-    """ Sublcass of Djangos TypedChoiceField but without working validator """
+    """Sublcass of Djangos TypedChoiceField but without working validator"""
+
     def validate(self, value):
         return True
 
 
 @total_ordering
 class DjangoBaseField(object):
-    """ Base field where Properties and Relations Field should subclass from """
+    """Base field where Properties and Relations Field should subclass from"""
 
     is_relation = False
     concrete = True
@@ -78,7 +87,7 @@ class DjangoBaseField(object):
     one_to_one = None
     many_to_many = None
     many_to_one = None
-   
+
     creation_counter = 0
 
     def __init__(self):
@@ -109,15 +118,15 @@ def __hash__(self):
 
     def clone(self):
         return self
-    
+
 
 class DjangoEmptyField(DjangoBaseField):
-    """ Empty  field """
+    """Empty  field"""
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.remote_field = None
-        
+
 
 class DjangoPropertyField(DjangoBaseField):
     """
@@ -126,7 +135,7 @@ class DjangoPropertyField(DjangoBaseField):
 
     is_relation = False
     concrete = True
-    editable = True   
+    editable = True
     unique = False
     primary_key = False
     auto_created = False
@@ -148,15 +157,15 @@ def __init__(self, prop, name):
         self.primary_key = getattr(prop, "primary_key", False)
         self.label = prop.label if prop.label else name
 
-        form_cls = getattr(prop, 'form_field_class', 'Field')  # get field string
+        form_cls = getattr(prop, "form_field_class", "Field")  # get field string
         self.form_clsx = form_cls  # Use for class faking in __class__
         self.form_class = getattr(form_fields, form_cls, form_fields.CharField)
 
         self._has_default = prop.has_default
         self.required = prop.required
         self.blank = not self.required
-        self.choices = getattr(prop, 'choices', None)
-    
+        self.choices = getattr(prop, "choices", None)
+
         super().__init__()
 
     def save_form_data(self, instance, data):
@@ -177,16 +186,17 @@ def formfield(self, **kwargs):
         }
 
         if self.has_default():
-            defaults['initial'] = self.prop.default_value()
+            defaults["initial"] = self.prop.default_value()
 
         if self.choices:
             # Fields with choices get special treatment.
             # So following this: https://github.com/django/django/blob/35c2474f168fd10ac50886024d5879de81be5bd3/django/db/models/fields/__init__.py#L1005
-            include_blank = (not self.required and
-                             not (self.has_default() or 'initial' in kwargs))
-                   
-            defaults['choices'] = self.get_choices(include_blank=include_blank)
-            defaults['coerce'] = self.to_python
+            include_blank = not self.required and not (
+                self.has_default() or "initial" in kwargs
+            )
+
+            defaults["choices"] = self.get_choices(include_blank=include_blank)
+            defaults["coerce"] = self.to_python
 
             # Many of the subclass-specific formfield arguments (min_value,
             # max_value) don't apply for choice fields, so be sure to only pass
@@ -210,28 +220,26 @@ def formfield(self, **kwargs):
 
         # This needs to be fixed but at https://github.com/django/django/blob/dc9deea8e85641695e489e43ed5d5638134c15c7/django/contrib/admin/options.py#L80
         # the Admin injects a form_class. For now just remove this
-        defaults.pop('form_class', None)
+        defaults.pop("form_class", None)
 
         return self.form_class(**defaults)
 
     def get_choices(self, include_blank=True):
-        
         blank_defined = False
         blank_choice = BLANK_CHOICE_DASH
         choices = list(self.choices) if self.choices else []
         if issubclass(type(self.choices), dict):
             # Ensure list of tuples with proper key-value pairing when passing dict
-            choices = [(k, v) for k, v in self.choices.items()] 
-        
+            choices = [(k, v) for k, v in self.choices.items()]
+
         for choice, __ in choices:
             if choice in ("", None):
                 blank_defined = True
                 break
-        
+
         # For now overwrite include_blank, so neomodel will not error on '' not being in self.choices
-        include_blank = False 
-        first_choice = (blank_choice if include_blank and
-                        not blank_defined else [])
+        include_blank = False
+        first_choice = blank_choice if include_blank and not blank_defined else []
         return first_choice + choices
 
     def clone(self):
@@ -239,12 +247,12 @@ def clone(self):
 
     @property
     def __class__(self):
-        # Fake the class for 
+        # Fake the class for
         # https://github.com/django/django/blob/dc9deea8e85641695e489e43ed5d5638134c15c7/django/contrib/admin/options.py#L144
         # so we can get the admin Field specific widgets to work, ie the Date widget
         # the SplitDateTimewidget (which is invoked by the admin when a DateTimeField is passed) doesn't work yet.
-        
-        if self.form_clsx == 'DateField':
+
+        if self.form_clsx == "DateField":
             return DateField
         # elif self.form_clsx == 'DateTimeField':
         #    return DateTimeField
@@ -253,25 +261,26 @@ def __class__(self):
 
 
 class DjangoRemoteField(object):
-    """ Fake RemoteField to let the Django Admin work """
+    """Fake RemoteField to let the Django Admin work"""
 
     def __init__(self, name):
         # Fake this call https://github.com/django/django/blob/ac5cc6cf01463d90aa333d5f6f046c311019827b/django/contrib/admin/widgets.py#L278
-        self.related_name = name 
+        self.related_name = name
         self.related_query_name = name
         self.model = name
         self.through = SimpleNamespace(_meta=SimpleNamespace(auto_created=True))
-    
+
     def get_related_field(self):
         # Fake call https://github.com/django/django/blob/ac5cc6cf01463d90aa333d5f6f046c311019827b/django/contrib/admin/widgets.py#L282
         # from the Django Admin
         return SimpleNamespace(name=self.model.pk.target)
-    
+
 
 class DjangoRelationField(DjangoBaseField):
     """
     Fake Django model field object which wraps a neomodel Relationship
     """
+
     one_to_many = False
     one_to_one = False
     many_to_one = False
@@ -280,7 +289,7 @@ class DjangoRelationField(DjangoBaseField):
 
     @property
     def __class__(self):
-        # Fake the class for 
+        # Fake the class for
         # https://github.com/django/django/blob/ac5cc6cf01463d90aa333d5f6f046c311019827b/django/contrib/admin/options.py#L144
         # so we can get the admin ManyToMany field widgets to work
         return ManyToManyField
@@ -297,8 +306,8 @@ def __init__(self, prop, name):
         if prop.manager is OneOrMore or prop.manager is One:
             self.required = True
 
-        self.blank = False 
-       
+        self.blank = False
+
         # See https://docs.djangoproject.com/en/2.0/_modules/django/db/models/fields/
         # Need a way to signal that there is no default
         self._has_default = NOT_PROVIDED
@@ -306,33 +315,34 @@ def __init__(self, prop, name):
         self.name = name
         self.attname = name
         self.verbose_name = name
-        self.help_text = getattr(prop, 'help_text', '')
-        
-        if prop.manager is ZeroOrOne: 
+        self.help_text = getattr(prop, "help_text", "")
+
+        if prop.manager is ZeroOrOne:
             # This form_class has its validator set to True
             self.form_class = DjangoFormFieldTypedChoice
         else:
             # This form_class has its validator set to True
-            self.form_class = DjangoFormFieldMultipleChoice 
-    
+            self.form_class = DjangoFormFieldMultipleChoice
+
         # Need to load the related model in so we can fetch
-        # all nodes. 
+        # all nodes.
         self.remote_field = DjangoRemoteField(self.prop._raw_class)
-     
+
         super().__init__()
 
     def set_attributes_from_rel(self):
-        """ From https://github.com/django/django/blob/1be99e4e0a590d9a008da49e8e3b118b57e14075/django/db/models/fields/related.py#L393 """
-        self.name = (
-            self.name or
-            (self.remote_field.model._meta.model_name + '_' + self.remote_field.model._meta.pk.name)
+        """From https://github.com/django/django/blob/1be99e4e0a590d9a008da49e8e3b118b57e14075/django/db/models/fields/related.py#L393"""
+        self.name = self.name or (
+            self.remote_field.model._meta.model_name
+            + "_"
+            + self.remote_field.model._meta.pk.name
         )
         if self.verbose_name is None:
             self.verbose_name = self.remote_field.model._meta.verbose_name
         # self.remote_field.set_field_name()
 
     def do_related_class(self, other, cls):
-        """ from https://github.com/django/django/blob/1be99e4e0a590d9a008da49e8e3b118b57e14075/django/db/models/fields/related.py#L402 """
+        """from https://github.com/django/django/blob/1be99e4e0a590d9a008da49e8e3b118b57e14075/django/db/models/fields/related.py#L402"""
         self.set_attributes_from_rel()
         # self.contribute_to_related_class(other, self.remote_field)
 
@@ -342,7 +352,7 @@ def value_from_object(self, instance):
         for this_object in instance_relation.all():
             node_ids_selected.append(this_object.pk)
         return node_ids_selected
-   
+
     def save_form_data(self, instance, data):
         # instance is the current node which needs to get connected
         # data is a list of ids/uids of the nodes-to-connect-to
@@ -350,60 +360,62 @@ def save_form_data(self, instance, data):
         instance_relation = getattr(instance, self.name)
         # Need to define which nodes to disconnect from first!
 
-        related_model = current_apps.get_model(self.prop.module_name.split('.')[-2],
-            self.prop._raw_class)
+        related_model = current_apps.get_model(
+            self.prop.module_name.split(".")[-2], self.prop._raw_class
+        )
 
         all_possible_nodes = related_model.nodes.all()
-        
+
         # Gather the pks from these nodes
         list_of_ids = []
         for this_node in all_possible_nodes:
             list_of_ids.append(this_node.pk)
         # So which nodes are not selected?
         should_not_be_connected = set(list_of_ids) - set(data)
-       
+
         # Need to save the instance before relations can be made
         try:
             instance.save()
         except UniqueProperty as e:
-            raise ValidationError(e)  
+            raise ValidationError(e)
         # Cardinality needs to be observed, so use following order:
         # if One: replace
         # if OneOreMore: first connect, then disconnect
         # if ZeroOrMore: doesn't matter
         # if ZeroOrOne: First disconnect, then connect
-     
+
         if self.prop.manager is ZeroOrMore or self.prop.manager is ZeroOrOne:
-            # Instead of checking the relationship exists, just disconnect 
+            # Instead of checking the relationship exists, just disconnect
             # In the future when specific relationships are implemented, this
             # should be updated
             self._disconnect_node(should_not_be_connected, instance_relation)
 
             # Now time to setup new connections
-            if data:  # In case we selected an empty unit, don't do anything 
+            if data:  # In case we selected an empty unit, don't do anything
                 self._connect_node(data, instance_relation)
-        
+
         elif self.prop.manager is OneOrMore:
             # First setup new connections
             self._connect_node(data, instance_relation)
             try:
                 instance.save()
             except UniqueProperty as e:
-                raise ValidationError(e)  
-        
-            # Instead of checking the relationship exists, just disconnect 
+                raise ValidationError(e)
+
+            # Instead of checking the relationship exists, just disconnect
             self._disconnect_node(should_not_be_connected, instance_relation)
         else:
             # This would require replacing the current relation with a new one
-            raise NotImplementedError('Cardinality of One is not supported yet')
+            raise NotImplementedError("Cardinality of One is not supported yet")
 
     def _disconnect_node(self, should_not_be_connected, instance_relation):
-        """ Given a list pk's, remove the relationship """
+        """Given a list pk's, remove the relationship"""
 
-        related_model = current_apps.get_model(self.prop.module_name.split('.')[-2],
-            self.prop._raw_class)
+        related_model = current_apps.get_model(
+            self.prop.module_name.split(".")[-2], self.prop._raw_class
+        )
 
-        # Internals used by save_form_data to 
+        # Internals used by save_form_data to
         # TODO: first get list of connected nodes, so don't run lots of disconnects
         for this_object in should_not_be_connected:
             remover = related_model.nodes.get_or_none(pk=this_object)
@@ -411,50 +423,53 @@ def _disconnect_node(self, should_not_be_connected, instance_relation):
                 instance_relation.disconnect(remover)
 
     def _connect_node(self, data, instance_relation):
-        """ Given a list pk's, add the relationship """
+        """Given a list pk's, add the relationship"""
 
-        related_model = current_apps.get_model(self.prop.module_name.split('.')[-2],
-            self.prop._raw_class)
+        related_model = current_apps.get_model(
+            self.prop.module_name.split(".")[-2], self.prop._raw_class
+        )
 
         # If ChoiceField, it is not a list
-        data = [data] if not isinstance(data, list) else data  
-        
+        data = [data] if not isinstance(data, list) else data
+
         for this_object in data:
             # Retreive the node-to-connect-to
             adder = related_model.nodes.get_or_none(pk=this_object)
             # If the connection is there, leave it
             if not adder:
-                raise ValidationError({self.name: ' not found'})
+                raise ValidationError({self.name: " not found"})
 
             if not instance_relation.is_connected(adder):
                 instance_relation.connect(adder)
-   
+
     def formfield(self, *args, **kwargs):
         """Return a django.forms.Field instance for this field."""
-        
+
         node_options = []
 
         # Fetch the related_module from the apps registry (instead of circular imports)
-        related_model = current_apps.get_model(self.prop.module_name.split('.')[-2],
-            self.prop._raw_class)
+        related_model = current_apps.get_model(
+            self.prop.module_name.split(".")[-2], self.prop._raw_class
+        )
 
         if self.prop.manager is ZeroOrOne:
             node_options = BLANK_CHOICE_DASH.copy()
-   
+
         for this_object in related_model.nodes.all():
             node_options.append((this_object.pk, this_object.__str__))
 
-        defaults = {'required': self.required,
-                    'label': self.verbose_name,
-                    'help_text': self.help_text,
-                    **kwargs,
-                    }
+        defaults = {
+            "required": self.required,
+            "label": self.verbose_name,
+            "help_text": self.help_text,
+            **kwargs,
+        }
 
-        defaults['choices'] = node_options
+        defaults["choices"] = node_options
         return self.form_class(**defaults)
 
     def clone(self):
-        """ 
+        """
         Upon cloning a relationship, provide an empty field wrapper, so circular
         imports are prevented by the Django app registry
         """
@@ -462,8 +477,8 @@ def clone(self):
         return DjangoEmptyField()
 
     def contribute_to_class(self, cls, name, private_only=False, **kwargs):
-        """ Modified from https://github.com/django/django/blob/2a66c102d9c674fadab252a28d8def32a8b626ec/django/db/models/fields/related.py#L305 """
-        #super().contribute_to_class(cls, name, private_only=private_only, **kwargs)
+        """Modified from https://github.com/django/django/blob/2a66c102d9c674fadab252a28d8def32a8b626ec/django/db/models/fields/related.py#L305"""
+        # super().contribute_to_class(cls, name, private_only=private_only, **kwargs)
         self.opts = cls._meta
 
         if not cls._meta.abstract:
@@ -473,23 +488,26 @@ def contribute_to_class(self, cls, name, private_only=False, **kwargs):
                 related_name = self.opts.default_related_name
             if related_name:
                 related_name = related_name % {
-                    'class': cls.__name__.lower(),
-                    'model_name': cls._meta.model_name.lower(),
-                    'app_label': cls._meta.app_label.lower()
+                    "class": cls.__name__.lower(),
+                    "model_name": cls._meta.model_name.lower(),
+                    "app_label": cls._meta.app_label.lower(),
                 }
                 self.remote_field.related_name = related_name
 
             if self.remote_field.related_query_name:
                 related_query_name = self.remote_field.related_query_name % {
-                    'class': cls.__name__.lower(),
-                    'app_label': cls._meta.app_label.lower(),
+                    "class": cls.__name__.lower(),
+                    "app_label": cls._meta.app_label.lower(),
                 }
                 self.remote_field.related_query_name = related_query_name
 
             def resolve_related_class(model, related, field):
                 field.remote_field.model = related
                 field.do_related_class(related, model)
-            lazy_related_operation(resolve_related_class, cls, self.remote_field.model, field=self)
+
+            lazy_related_operation(
+                resolve_related_class, cls, self.remote_field.model, field=self
+            )
 
 
 class Query:
@@ -503,27 +521,59 @@ class NeoNodeSet(NodeSet):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.model = self.source
-    
+        self._prefetch_related_lookups = []
+        self._result_cache = None
+
     def count(self):
         return len(self)
 
     def _clone(self):
         return self
 
-    def iterator(self):
-        """ Needed to run pytest after adding app/model register """
+    def iterator(self, chunk_size=2000):
+        """Needed to run pytest after adding app/model register"""
+        # Basic iterator implementation to fetch nodes
+        # This is a placeholder to demonstrate functionality
+        # return self.source_class.nodes.all()
         return []
 
+    # The code below was added to stop the tests from failing for Python 3.10+
+    # It would be interesting to actually implement prefetching
+    def prefetch_related(self, *lookups):
+        self._prefetch_related_lookups.extend(lookups)
+        return self
+
+    def _fetch_all(self):
+        if self._result_cache is None:
+            self._result_cache = list(self.iterator())
+            self._prefetch_related_objects()
+
+    def _prefetch_related_objects(self):
+        for lookup in self._prefetch_related_lookups:
+            self._perform_prefetch(lookup)
+
+    def _perform_prefetch(self, lookup):
+        # Simplified example of prefetching related objects
+        # Assuming `lookup` is a relation name from the node class
+        # if hasattr(self.source_class, lookup):
+        #     relationship_manager = getattr(self.node_class, lookup)
+        #     for parent_node in self._result_cache:
+        #         # Accessing the related nodes directly via neomodel relationship manager
+        #         related_nodes = list(getattr(parent_node, lookup).all())
+        #         # Store the fetched nodes in a cache attribute
+        #         setattr(parent_node, f"_{lookup}_cache", related_nodes)
+        pass
+
 
 class NeoManager:
     def __init__(self, model):
         self.model = model
-        
+
     def get_queryset(self):
         return NeoNodeSet(self.model)
 
     def using(self, connection):
-        """ Needed to run pytest after adding app/model register"""
+        """Needed to run pytest after adding app/model register"""
         return NeoNodeSet(self.model)
 
 
@@ -538,68 +588,70 @@ def __new__(cls, *args, **kwargs):
 
         if new_cls.__module__ is __package__:  # Do not populate DjangoNode
             pass
-        elif new_cls.__module__.split('.')[-2] == 'tests':  # Also skip test signals
+        elif new_cls.__module__.split(".")[-2] == "tests":  # Also skip test signals
             pass
         else:
-            
-            meta = getattr(new_cls, 'Meta', None)
-            # Register the model in the Django app registry. 
+            meta = getattr(new_cls, "Meta", None)
+            # Register the model in the Django app registry.
             # Django will try to clone to make a ModelState and upon cloning
             # the relations will result in an empty object, so there are no
             # circular imports
-            current_apps.register_model(new_cls.__module__.split('.')[-2],  new_cls)
+            current_apps.register_model(new_cls.__module__.split(".")[-2], new_cls)
 
         return new_cls
 
 
 class DjangoNode(StructuredNode, metaclass=MetaClass):
     __abstract_node__ = True
-  
+
     @classproperty
     def _meta(self):
-
-        if hasattr(self.Meta, 'unique_together'):
-            raise NotImplementedError('unique_together property not supported by neomodel')
+        if hasattr(self.Meta, "unique_together"):
+            raise NotImplementedError(
+                "unique_together property not supported by neomodel"
+            )
 
         # Need a ModelState for the admin to delete an object
-        self._state = ModelState() 
-        self._state.adding = False 
+        self._state = ModelState()
+        self._state.adding = False
 
         opts = Options(self.Meta, app_label=self.Meta.app_label)
         opts.contribute_to_class(self, self.__name__)
 
-        # Again, otherwise delete from admin doesn't work, see: 
-        # https://github.com/django/django/blob/0e656c02fe945389246f0c08f51c6db4a0849bd2/django/db/models/deletion.py#L252 
-        opts.concrete_model = self 
+        # Again, otherwise delete from admin doesn't work, see:
+        # https://github.com/django/django/blob/0e656c02fe945389246f0c08f51c6db4a0849bd2/django/db/models/deletion.py#L252
+        opts.concrete_model = self
 
         for key, prop in self.__all_properties__:
-            opts.add_field(DjangoPropertyField(prop, key), getattr(prop, 'private', False))
+            opts.add_field(
+                DjangoPropertyField(prop, key), getattr(prop, "private", False)
+            )
             if getattr(prop, "primary_key", False):
                 # a reference using self.pk = prop fails in some cases where
-                # django references the .pk attribute directly. ie in 
+                # django references the .pk attribute directly. ie in
                 # https://github.com/django/django/blob/ac5cc6cf01463d90aa333d5f6f046c311019827b/django/contrib/admin/options.py#L860
-                # causes non-consistent behaviour because Django sometimes looks up the 
+                # causes non-consistent behaviour because Django sometimes looks up the
                 # attribute name via 'pk = cl.lookup_opts.pk.attname'.
                 # instead provide an AliasProperty to the property tagged
                 # as primary_key
                 self.pk = AliasProperty(to=key)
-        
+
         for key, relation in self.__all_relationships__:
             new_relation_field = DjangoRelationField(relation, key)
             new_relation_field.contribute_to_class(self, key)
-            opts.add_field(new_relation_field, getattr(prop, 'private', False))
-        
+            opts.add_field(new_relation_field, getattr(prop, "private", False))
+
         return opts
 
     @classmethod
     def check(cls, **kwargs):
-        """ Needed for app registry, always provide empty list of errors """
+        """Needed for app registry, always provide empty list of errors"""
         return []
 
     def __hash__(self):
         # The delete function in the Admin requires a hash
         return hash(self.pk)
-   
+
     def full_clean(self, exclude, validate_unique=False):
         """
         Validate node, on error raising ValidationErrors which can be handled by django forms
@@ -615,7 +667,7 @@ def full_clean(self, exclude, validate_unique=False):
         except DeflateError as e:
             raise ValidationError({e.property_name: e.msg})
         except RequiredProperty as e:
-            raise ValidationError({e.property_name: 'is required'})
+            raise ValidationError({e.property_name: "is required"})
         except UniqueProperty as e:
             raise ValidationError({e.property_name: e.msg})
 

From 15941f1730399411f8ff712b37e1e6d5f7323699 Mon Sep 17 00:00:00 2001
From: Marius Conjeaud <rmcj@novonordisk.com>
Date: Wed, 22 May 2024 11:51:45 +0200
Subject: [PATCH 13/13] Update changelog

---
 Changelog | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Changelog b/Changelog
index 7438f09..266e6f3 100644
--- a/Changelog
+++ b/Changelog
@@ -1,6 +1,8 @@
 Version 0.2.0 2024-05
 * Bump neomodel to 5.3.0
 * Bump Django to 4.2.8 LTS
+* Add relationships as editable to Django admin
+* Passthrough implementation of prefetch to avoid failures
 
 Version 0.1.1 2023-08
 * Bump neomodel to 5.1.0 - full support of Neo4j version 5.x (and 4.4 LTS)