Resolving APIs URL to different namespaces

[debnet]

An enough tested revision in order to allow resolving APIs URL using APIs in different namespaces.

Used as a patch in production environment since about one year without issue.

See #1495

[xordoquy]

Open question, would it be worth to alter the tests so they include one model in common and make sure it's resolved correctly for each namespace ?

[xordoquy]

I wonder if some of the code can't be factorized with Django's.

[xordoquy]

I'd really like to see an explicit raise here.
This syntax will work as long as no other exception is being thrown - no matter whether they are caught or not.
Given the code quantity between the initial except and this line it's subject to caution imho.

[xordoquy]

OK, with the restriction on the raise statement it looks good to me.

[xordoquy]

Use case that may lead to raising the wrong exception:

• https://github.com/tomchristie/django-rest-framework/pull/3816/files#diff-5ee455e6a1f5b0502efd536d4bbcf2d8R58 raise the NoReverseMatch
• https://github.com/tomchristie/django-rest-framework/pull/3816/files#diff-5ee455e6a1f5b0502efd536d4bbcf2d8R63 raise a AttributeError than Http404

Guess what raise will raise when url is None ?

Is that use case possible ?

NB:

>>> try:
...     0/0
... except Exception:
...     try:
...         'a' + 1
...     except TypeError:
...         pass
...     raise
... 
Traceback (most recent call last):
  File "<stdin>", line 5, in <module>
TypeError: cannot concatenate 'str' and 'int' objects
>>> 

[tomchristie]

My super quick review --> I can see a lot of code, and not much explanation. What case exactly is being resolved here? If there's any other kind of workaround or the case isn't 100% clear cut then I'm unlikely to be in favor of this change.

[xordoquy]

The point I don't get here is why it does try every namespace if it can't resolve without namespace or with the current namespace.

[debnet]

For example, in a case when a model from an application under a namespace references another application model under a different namespace.

[nwp90]

I don't see how #4219 justifies closing this. This has nothing to do with versioning. If a namespace is in use, it would be nice for HyperlinkedModelSerializers to continue to function, at least where the linked detail route is in the same namespace as the current request.

I'm not sure what the right thing to do is when it's in a different namespace - it's conceivable that the current app would know about a subtree of the overall namespace but not the whole thing.

e.g. app with routes under "foo:api:firstapp" knows about the "api:firstapp" portion of the namespace, and that the model it's after is in "api:otherapp", but not that that is also now under the top-level "foo" namespace.

Seems to me that it would be desirable to infer a prefix based on what is expected and experienced (expect to be in "api:firstapp" but discover that we're in "foo:api:firstapp", so infer "foo" prefix), and then use that to help find other known routes.

[debnet]

In my use-case, the current version doesn't solve the problem.

I still have to deal with models referencing each others through differents namespaces myself.

Fortunatly, @xordoquy gives me the evidence that my previous solution have some caveats and can lead to undesired behaviour.

Since, I changed the whole implementation of HyperlinkField in which I have to scan all the application URLs in order to find the '-detail' API of my related models.

class CustomHyperlinkedField:
    urls_for_model = {}
    pk_field = None

    def get_name(self, obj):
        return str(obj.pk)

    def get_url(self, obj, view_name, request, format):
        if hasattr(obj, 'pk') and obj.pk in (None, ''):
            return None

        model = getattr(getattr(self, 'queryset', None), 'model', None) or type(obj)
        urls = self.urls_for_model[model] = self.urls_for_model.get(model) or list(recursive_get_urls(model=model))
        for urlname, url in urls:
            if urlname.endswith(view_name):
                view_name = urlname

        lookup_value = getattr(obj, self.lookup_field)
        kwargs = {self.lookup_url_kwarg: lookup_value}
        return self.reverse(view_name, kwargs=kwargs, request=request, format=format)

[nwp90]

For the moment I'm working around this with:

class SBCoreRelatedField(serializers.HyperlinkedRelatedField):
    def __init__(self, view_prefix=None, view_name=None, **kwargs):
        if view_name is not None and view_prefix is not None:
            view_name = "%s:%s" % (view_prefix, view_name)
        kwargs['view_name'] = view_name
        super().__init__(**kwargs)


class SBCoreIdentityField(serializers.HyperlinkedIdentityField):
    def __init__(self, view_prefix=None, view_name=None, **kwargs):
        if view_name is not None and view_prefix is not None:
            view_name = "%s:%s" % (view_prefix, view_name)
        kwargs['view_name'] = view_name
        super().__init__(**kwargs)


class SBCoreSerializer(serializers.HyperlinkedModelSerializer):
    serializer_related_field = SBCoreRelatedField
    serializer_url_field = SBCoreIdentityField

    def __init__(self, *args, **kwargs):
        context = kwargs.get('context', None)
        super().__init__(*args, **kwargs)
        if not hasattr(self, 'serializer_namespace'):
            if context is not None:
                request = context.get('request', None)
                if request is not None:
                    self.serializer_namespace = request.resolver_match.namespace

    def build_url_field(self, *args, **kwargs):
        field_class, field_kwargs = super().build_url_field(*args, **kwargs)
        field_kwargs['view_prefix'] = self.serializer_namespace
        return field_class, field_kwargs

    def build_relational_field(self, *args, **kwargs):
        field_class, field_kwargs = super().build_relational_field(*args, **kwargs)
        field_kwargs['view_prefix'] = self.serializer_namespace
        return field_class, field_kwargs

i.e. the serializer now knows which namespace it's in, and can pass this through to the fields. If a field is referring to an object in a different namespace, I have to specify that on the field.

[nwp90]

Oh, I've added get_extra_kwargs as below, to allow setting those prefixes from the serializer's Meta class too:

def get_extra_kwargs(self):
    extra_kwargs = super().get_extra_kwargs()
    namespaces = getattr(self.Meta, 'namespaces', None)
    if namespaces is not None:
        if not isinstance(namespaces, (dict,)):
            raise TypeError(
                'The `namespaces` option must be a dict. '
                'Got %s.' % type(namespaces).__name__
            )
        for field_name, view_prefix in namespaces.items():
            kwargs = extra_kwargs.get(field_name, {})
            kwargs['view_prefix'] = view_prefix
            extra_kwargs[field_name] = kwargs

    return extra_kwargs

[tomchristie]

Can't we enforce explicitly namespaced view names in this case rather than magically inferring them?

[debnet]

It depends how you want use your viewsets. In my case, we have a framework above our project in order to dynamically generate APIs from models with all filters, orders, related models and prefetchs... so having to deal with namespaces could lead to a lot of redundant work.

Nevertheless, I understand your point of view: explicit is better than implicit. But I guess through this issue I'm not alone to require that kind of feature. :)

[nwp90]

You can't be explicit when you don't know the full namespace a pluggable app might be included under.