Use typehint to automatically get Django model if appropriate when calling an action. Clean up model example to show the one-true way to use Django models.

Author: adamghill

django_unicorn/decorators.py

@@ -15,7 +15,7 @@ def db_model(func, *args, **kwargs):
         @db_model
         def delete(self, model):
             ...
-    
+
     Will get converted to:
         `component.delete({ 'name': 'modelName', pk: 1})` -> `component.delete(modelInstance)`
     """

django_unicorn/utils.py

@@ -1,25 +1,30 @@
 import hmac
 import logging
 import pickle
+from inspect import signature
+from typing import Dict, List, Union
 from typing import get_type_hints as typing_get_type_hints
 
 from django.conf import settings
 
 import shortuuid
 from cachetools.lru import LRUCache
 
+import django_unicorn
 from django_unicorn.errors import UnicornCacheError
 
 
 logger = logging.getLogger(__name__)
 
 type_hints_cache = LRUCache(maxsize=100)
+function_signature_cache = LRUCache(maxsize=100)
 
 
-def generate_checksum(data):
+def generate_checksum(data: Union[str, bytes]) -> str:
     """
     Generates a checksum for the passed-in data.
     """
+
     if isinstance(data, str):
         data_bytes = str.encode(data)
     else:
@@ -33,10 +38,11 @@ def generate_checksum(data):
     return checksum
 
 
-def dicts_equal(dictionary_one, dictionary_two):
+def dicts_equal(dictionary_one: Dict, dictionary_two: Dict) -> bool:
     """
     Return True if all keys and values are the same between two dictionaries.
     """
+
     return all(
         k in dictionary_two and dictionary_one[k] == dictionary_two[k]
         for k in dictionary_one
@@ -46,10 +52,13 @@ def dicts_equal(dictionary_one, dictionary_two):
     )
 
 
-def get_cacheable_component(component):
+def get_cacheable_component(
+    component: "django_unicorn.views.UnicornView",
+) -> "django_unicorn.views.UnicornView":
     """
     Converts a component into something that is cacheable/pickleable.
     """
+
     component.request = None
 
     if component.parent:
@@ -77,13 +86,14 @@ def get_cacheable_component(component):
     return component
 
 
-def get_type_hints(obj):
+def get_type_hints(obj) -> Dict:
     """
     Get type hints from an object. These get cached in a local memory cache for quicker look-up later.
 
     Returns:
         An empty dictionary if no type hints can be retrieved.
     """
+
     try:
         if obj in type_hints_cache:
             return type_hints_cache[obj]
@@ -103,3 +113,20 @@ def get_type_hints(obj):
         # raised if the argument is not of a type that can contain annotations, and an empty dictionary
         # is returned if no annotations are present"
         return {}
+
+
+def get_method_arguments(func) -> List[str]:
+    """
+    Gets the arguments for a method.
+
+    Returns:
+        A list of strings, one for each argument.
+    """
+
+    if func in function_signature_cache:
+        return function_signature_cache[func]
+
+    function_signature = signature(func)
+    function_signature_cache[func] = list(function_signature.parameters)
+
+    return function_signature_cache[func]

django_unicorn/views/action_parsers/call_method.py

@@ -1,12 +1,15 @@
 from typing import Any, Dict, List
 
+from django.db.models import Model
+
 from django_unicorn.call_method_parser import (
     InvalidKwarg,
     parse_call_method_name,
     parse_kwarg,
 )
 from django_unicorn.components import UnicornView
 from django_unicorn.decorators import timed
+from django_unicorn.utils import get_method_arguments, get_type_hints
 from django_unicorn.views.action_parsers.utils import set_property_value
 from django_unicorn.views.objects import ComponentRequest, Return
 from django_unicorn.views.utils import set_property_from_data
@@ -103,6 +106,27 @@ def _call_method_name(
     if method_name is not None and hasattr(component, method_name):
         func = getattr(component, method_name)
 
+        if len(args) == 1 or len(kwargs.keys()) == 1:
+            arguments = get_method_arguments(func)
+            type_hints = get_type_hints(func)
+
+            for argument in arguments:
+                if argument in type_hints:
+                    if issubclass(type_hints[argument], Model):
+                        DbModel = type_hints[argument]
+                        key = "pk"
+                        value = None
+
+                        if args:
+                            value = args.pop()
+                        elif kwargs:
+                            (key, value) = list(kwargs.items())[0]
+                            del kwargs[key]
+
+                        model = DbModel.objects.get(**{key: value})
+
+                        args.append(model)
+
         if args and kwargs:
             return func(*args, **kwargs)
         elif args:

django_unicorn/views/action_parsers/utils.py

@@ -75,5 +75,17 @@ class TestView(UnicornView):
             else:
                 component_or_field = component_or_field[property_name_part]
                 data_or_dict = data_or_dict.get(property_name_part, {})
+        elif isinstance(component_or_field, list):
+            # TODO: Check for iterable instad of list? `from collections.abc import Iterable`
+            property_name_part = int(property_name_part)
+
+            if idx == len(property_name_parts) - 1:
+                component_or_field[property_name_part] = property_value
+                data_or_dict[property_name_part] = property_value
+            else:
+                component_or_field = component_or_field[property_name_part]
+                data_or_dict = data_or_dict[property_name_part]
+        else:
+            break
 
     component.updated(property_name, property_value)

django_unicorn/views/utils.py

@@ -47,7 +47,11 @@ def set_property_from_data(
             if is_dataclass(type_hints[name]):
                 value = type_hints[name](**value)
             else:
-                value = type_hints[name](value)
+                try:
+                    value = type_hints[name](value)
+                except TypeError:
+                    # Ignore this exception because some type-hints can't be instantiated like this (e.g. `List[]`)
+                    pass
 
         if hasattr(component_or_field, "_set_property"):
             # Can assume that `component_or_field` is a component

example/unicorn/components/models.py

@@ -1,60 +1,28 @@
-from django.shortcuts import redirect
-from django.utils.functional import cached_property
+from typing import List
 
-from django_unicorn.components import HashUpdate, LocationUpdate, UnicornView
-from django_unicorn.db import DbModel
-from django_unicorn.decorators import db_model
+from django_unicorn.components import UnicornView
 from example.coffee.models import Flavor
 
 
 class ModelsView(UnicornView):
-    flavors = Flavor.objects.none()
-
-    # Demonstrates how to use an instantiated model; class attributes get stored on
-    # the class, so django-unicorn handles clearing this with `_resettable_attributes_cache`
-    # in components.py
-    class_flavor: Flavor = Flavor()
-
-    def __init__(self, **kwargs):
-        # Demonstrates how to use an instance variable on the class
-        self.instance_flavor = Flavor()
-
-        # super() `has` to be called at the end
-        super().__init__(**kwargs)
-
-    def hydrate(self):
-        # Using `hydrate` is the best way to make sure that QuerySets
-        # are re-queried every time the component is loaded
-        self.flavors = Flavor.objects.all().order_by("-id")[:2]
-
-    def add_instance_flavor(self):
-        self.instance_flavor.save()
-        id = self.instance_flavor.id
-        self.reset()
-
-        # return HashUpdate(f"#createdId={id}")
-        return LocationUpdate(redirect(f"/models?createdId={id}"), title="new title")
-
-    def add_class_flavor(self):
-        self.class_flavor.save()
-        id = self.class_flavor.id
-        self.reset()
-
-        # Note: this can cause inputs to appear to be cached
-        return redirect(f"/models?createdId={id}")
-
-    @db_model
-    def delete(self, model):
-        model.delete()
-
-    @cached_property
-    def available_flavors(self):
-        flavors = Flavor.objects.all()
-
-        if self.instance_flavor and self.instance_flavor.pk:
-            return flavors.exclude(pk=self.instance_flavor.pk)
-
-        return flavors
-
-    class Meta:
-        db_models = [DbModel("flavor", Flavor)]
+    # class attributes get stored on the class, so django-unicorn handles clearing
+    # this with `_resettable_attributes_cache` in components.py
+    flavor: Flavor = Flavor()
+    flavors: List[Flavor] = []
+
+    def mount(self):
+        self.flavors = list(Flavor.objects.all().order_by("-id")[:2])
+
+    def save_flavor(self):
+        self.flavor.save()
+        self.flavor = Flavor()
+
+    def save(self, flavors_idx):
+        flavor_data = self.flavors[flavors_idx]
+        print("call save for idx", flavors_idx)
+        flavor = Flavor(**flavor_data)
+        flavor.save()
+
+    def save_specific(self, flavor: Flavor):
+        flavor.save()
+        print("call save on flavor", flavor)

example/unicorn/templates/unicorn/models.html

@@ -6,82 +6,50 @@
     </style>
 
     <h3>Current flavors</h3>
-    <ul>
-        {% for flavor in flavors %}
-        <li>{{ flavor.id }} - {{ flavor.name }} - {{ flavor.label }}</li>
-        {% endfor %}
-    </ul>
-    
-    <div>
-        <h3>New Flavor (instance variable)</h3>
-
-        <label>Name</label>
-        <input type="text" unicorn:model.defer="instance_flavor.name"></input>
-
-        <label>Label</label>
-        <input type="text" unicorn:model.defer="instance_flavor.label"></input>
-
-        <br />
-        <button unicorn:click="add_instance_flavor">Add Flavor (instance variable)</button>
-    </div>
 
     <div>
-        <h3>New Flavor (class attribute)</h3>
-
-        <label>Name</label>
-        <input type="text" unicorn:model.defer="class_flavor.name"></input>
-
-        <label>Label</label>
-        <input type="text" unicorn:model.defer="class_flavor.label"></input>
+        <h3>Using unicorn:model with Django models</h3>
 
-        <br />
-        <button unicorn:click="add_class_flavor">Add Flavor (class attribute)</button>
-    </div>
-
-    <div>
-        <h3>Using unicorn:db</h3>
-
-        <div unicorn:db="flavor">
+        <div>
             <div>
                 <label>Name</label>
-                <input type="text" unicorn:field.defer="name" u:dirty.class="dirty"></input>
+                <input type="text" unicorn:model="flavor.name"></input>
             </div>
 
             <div>
                 <label>Label</label>
-                <input type="text" unicorn:field.defer="label" u:dirty.class="dirty"></input>
+                <input type="text" unicorn:model="flavor.label"></input>
             </div>
 
+            <button unicorn:click="save_flavor">save_flavor</button>
+
             {% for flavor in flavors %}
-            <div unicorn:pk="{{ flavor.pk }}">
+            <div>
                 <h4>{{ flavor.pk }}</h4>
                 <label>Name</label>
-                <input type="text" unicorn:field.defer="name" u:dirty.class="dirty" value="{{ flavor.name }}"></input>
+                <input type="text" unicorn:model="flavors.{{ forloop.counter0 }}.name" u:dirty.class="dirty"></input>
                 {{ flavor.name }}
                 <br />
 
                 <label>Label</label>
-                <input type="text" unicorn:field.defer="label" u:dirty.class="dirty" value="{{ flavor.label }}"></input>
+                <input type="text" unicorn:model="flavors.{{ forloop.counter0 }}.label" u:dirty.class="dirty"></input>
                 {{ flavor.label }}
                 <br />
 
                 <label>Float</label>
-                <input type="text" unicorn:field.defer="float_value"></input>
+                <input type="text" unicorn:model="flavors.{{ forloop.counter0 }}.float_value"></input>
                 {{ flavor.float_value }}
                 <br />
 
                 <label>Decimal value</label>
-                <input type="text" unicorn:field.defer="decimal_value"></input>
+                <input type="text" unicorn:model="flavors.{{ forloop.counter0 }}.decimal_value"></input>
                 {{ flavor.decimal_value }}
                 <br />
 
-                <button unicorn:click="delete($model)">delete($model)</button>
+                <button unicorn:click="save({{ forloop.counter0 }})">save(flavors_idx)</button>
+                <button unicorn:click="delete({{ flavor.pk }})">delete(flavor.pk)</button>
             </div>
             {% endfor %}
         </div>
     </div>
-    
-    <br /><br />
-    <button unicorn:click="$refresh">$refresh</button>
-    <button unicorn:click="$reset">$reset</button>
 </div>