Better configurability of urls [feature request]

[shayneoAtNorwood]

Currently the only way I can find to add url is via the metaclass.

The problem with this is, when writing software, its often necessary to have dynamic choices in URLs (Ie devel server/production server, or in the case of turnkey systems, there might be a self hosted server somewhere).

Heres neat trick I worked out with Django DRF. My first call to the system is the API root , with the username and password. This returns an error if the auth is on crack, but if the auth succeeds returns a dictionary with endpoint names and urls. So for instance in my current project;-
{
"processchanges": "http://localhost:8000/api/v1/processchanges/",
"annotations": "http://localhost:8000/api/v1/annotations/",
"relationships": "http://localhost:8000/api/v1/relationships/",
"entity": "http://localhost:8000/api/v1/entity/"
}
What would be great is to be able to pass the system a dictionary like the above, and then instead of meta.url="http://localhost:8000/api/v1/processchanges/" have meta.endpoint="processchanges" which could then lookup the dictionary. This also has an even more magical property that those end points dont even have to be on the same server.

[shayneoneill]

As an addendum to my suggestion. OpenAPI/Swagger/etc might be more cross-platform for URL discovery than DRF's index

[shayneoAtNorwood]

Ok. I came up with a solution. Its a bit of a hack, and could do with cleanup, but heres the basic concept.

In my models I have this in my Meta

    class Meta:
        url_manager=URLDictionaryManager('entity')
        url="http://localhost:8000/api/v1/entity/"
        paginator_class = DjangoRestFrameworkLimitOffsetPaginator

(the url= bit is still there because it wont work without it. That perhaps could change to be not needed if the optional url_manager is provided, as this solution just ignores url's value if it is)
And then I provide this class;-

class URLDictionaryManager:
    dict = {}
    def __init__(self,endpoint):
        self.endpoint = endpoint
    @staticmethod
    def set_urls(dict):
        URLDictionaryManager.dict=dict
    @property
    def url(self):
        return URLDictionaryManager.dict[self.endpoint]

So that before the first use of the models I would make a call like
my_models.URLDictManager.set_urls(dictionary_of_urls)

To get this to work, all I did was this change in models.

   def get_base_url(cls, bits=[]):
        # Assemble from the base url
        url_bits = [cls._meta.url_manager.url.rstrip('/'),] if hasattr(cls._meta,'url_manager') else [cls._meta.url, ]
        url_bits.extend(bits)

Inelegant, but it does work. Probably moving forward , it would be better to have something like a DjangoRestFrameworkURLManager that one could simply provide the base URL for and optionally authentication, and it could do it itself. Perhaps if supplied as a prefab, one could add OpenAPI/Swagger/etc URLManagers too.

If I get a chance I'll send through a pull request. But its mixed in with a bunch of other hacks I did to get it work with python3. I'll need to disentagle them into a separate cleaned up Py3 compatibility push, and after I finish with the current project as I'm a bit strapped for time.