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 ?

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

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

Use case that may lead to raising the wrong exception:

• https://github.com/tomchristie/django-rest-framework/pull/3816/files#diff-5ee455e6a1f5b0502efd536d4bbcf2d8R58 raise theNoReverseMatch
• https://github.com/tomchristie/django-rest-framework/pull/3816/files#diff-5ee455e6a1f5b0502efd536d4bbcf2d8R63 raise aAttributeError thanHttp404

Guess what raise will raise when url is None ?

Is that use case possible ?

NB:

>>>try:...0/0...exceptException:...try:...'a'+1...exceptTypeError:...pass...raise...Traceback (mostrecentcalllast):File"<stdin>",line5,in<module>TypeError:cannotconcatenate'str'and'int'objects>>>

My super quick review --> I can see a lot of code, and not much explanation. What caseexactly 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.

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.

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

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.

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 ofHyperlinkField 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)

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.

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

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

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. :)

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