start work on #58 and #162

Author: bckohan

django_typer/management/__init__.py

@@ -34,7 +34,7 @@
 
 from ..completers.model import ModelObjectCompleter  # noqa: E402
 from ..config import traceback_config  # noqa: E402
-from ..parsers.model import ModelObjectParser  # noqa: E402
+from ..parsers.model import ModelObjectParser, ReturnType  # noqa: E402
 from ..types import (  # noqa: E402
     ForceColor,
     NoColor,
@@ -126,6 +126,7 @@ def model_parser_completer(
     distinct: bool = ModelObjectCompleter.distinct,
     on_error: t.Optional[ModelObjectParser.error_handler] = ModelObjectParser.on_error,
     order_by: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+    return_type: ReturnType = ModelObjectParser.return_type,
 ) -> t.Dict[str, t.Any]:
     """
     A factory function that returns a dictionary that can be used to specify
@@ -161,13 +162,16 @@ def handle(
         completion suggestions, True by default
     :param on_error: a callable that will be called if the parser lookup fails
         to produce a matching object - by default a CommandError will be raised
+    :param return_type: An enumeration switch to return either a model instance,
+        queryset or model field value type.
     """
     return {
         "parser": ModelObjectParser(
             model_or_qry if inspect.isclass(model_or_qry) else model_or_qry.model,  # type: ignore
             lookup_field,
             case_insensitive=case_insensitive,
             on_error=on_error,
+            return_type=return_type,
         ),
         "shell_complete": ModelObjectCompleter(
             model_or_qry,

django_typer/parsers/model.py

@@ -1,5 +1,6 @@
 import typing as t
 from datetime import date, datetime, time
+from enum import Enum
 from uuid import UUID
 
 from click import Context, Parameter, ParamType
@@ -10,6 +11,12 @@
 from django_typer.completers.model import ModelObjectCompleter
 
 
+class ReturnType(Enum):
+    MODEL_INSTANCE = 0
+    FIELD_VALUE = 1
+    QUERY_SET = 2
+
+
 class ModelObjectParser(ParamType):
     """
     A parser that will turn strings into model object instances based on the
@@ -44,6 +51,9 @@ def handle(
         The callable should accept three arguments: the model class, the
         value that failed to lookup, and the exception that was raised.
         If not provided, a CommandError will be raised.
+    :param return_type: The model object parser can return types other than the model
+        instance (default) - use the ReturnType enumeration to return other types
+        from the parser including QuerySets or the primitive values of the model fields.
     """
 
     error_handler = t.Callable[[t.Type[models.Model], str, Exception], None]
@@ -52,6 +62,7 @@ def handle(
     lookup_field: str
     case_insensitive: bool = False
     on_error: t.Optional[error_handler] = None
+    return_type: ReturnType = ReturnType.MODEL_INSTANCE
 
     _lookup: str = ""
     _field: models.Field
@@ -90,6 +101,7 @@ def __init__(
         lookup_field: t.Optional[str] = None,
         case_insensitive: bool = case_insensitive,
         on_error: t.Optional[error_handler] = on_error,
+        return_type: ReturnType = return_type,
     ):
         from django.contrib.contenttypes.fields import GenericForeignKey
 
@@ -98,6 +110,7 @@ def __init__(
             lookup_field or getattr(self.model_cls._meta.pk, "name", "id")
         )
         self.on_error = on_error
+        self.return_type = return_type
         self.case_insensitive = case_insensitive
         field = self.model_cls._meta.get_field(self.lookup_field)
         assert not isinstance(field, (models.ForeignObjectRel, GenericForeignKey)), _(
@@ -126,7 +139,7 @@ def convert(
         """
         original = value
         try:
-            if isinstance(value, self.model_cls):
+            if not isinstance(value, str):
                 return value
             elif isinstance(self._field, models.UUIDField):
                 uuid = ""
@@ -147,6 +160,12 @@ def convert(
                 if ambiguous:
                     raise ValueError(f"Invalid duration: {value}")
                 value = parsed
+            if self.return_type is ReturnType.QUERY_SET:
+                return self.model_cls.objects.filter(
+                    **{f"{self.lookup_field}{self._lookup}": value}
+                )
+            elif self.return_type is ReturnType.FIELD_VALUE:
+                return value
             return self.model_cls.objects.get(
                 **{f"{self.lookup_field}{self._lookup}": value}
             )

tests/apps/test_app/management/commands/field_value.py

@@ -0,0 +1,27 @@
+from typing import Annotated
+
+import typer
+from django.utils.translation import gettext_lazy as _
+from datetime import timedelta
+
+from django_typer.management import TyperCommand, model_parser_completer
+from django_typer.parsers.model import ReturnType
+from tests.apps.test_app.models import ShellCompleteTester
+from django_typer.utils import duration_iso_string
+
+
+class Command(TyperCommand, rich_markup_mode="rich"):
+    def handle(
+        self,
+        duration: Annotated[
+            timedelta,
+            typer.Argument(
+                **model_parser_completer(
+                    ShellCompleteTester, return_type=ReturnType.FIELD_VALUE
+                )
+            ),
+        ],
+    ):
+        assert self.__class__ is Command
+        assert isinstance(duration, timedelta)
+        return duration_iso_string(duration)