authentik.blueprints.v1.meta.registry

Base models

 1"""Base models"""
 2
 3from django.apps import apps
 4from django.db.models import Model
 5from rest_framework.serializers import Serializer
 6
 7
 8class BaseMetaModel(Model):
 9    """Base models"""
10
11    class Meta:
12        abstract = True
13
14    @staticmethod
15    def serializer() -> Serializer:
16        """Serializer similar to SerializerModel, but as a static method since
17        this is an abstract model"""
18        raise NotImplementedError
19
20
21class MetaResult:
22    """Result returned by Meta Models' serializers. Empty class but we can't return none as
23    the framework doesn't allow that"""
24
25
26class MetaModelRegistry:
27    """Registry for pseudo meta models"""
28
29    models: dict[str, BaseMetaModel]
30    virtual_prefix: str
31
32    def __init__(self, prefix: str) -> None:
33        self.models = {}
34        self.virtual_prefix = prefix
35
36    def register(self, model_id: str):
37        """Register model class under `model_id`"""
38
39        def inner_wrapper(cls):
40            self.models[model_id] = cls
41            return cls
42
43        return inner_wrapper
44
45    def get_models(self):
46        """Wrapper for django's `get_models` to list all models"""
47        models = apps.get_models()
48        for _, value in self.models.items():
49            models.append(value)
50        return sorted(models, key=str)
51
52    def get_model(self, app_label: str, model_id: str) -> type[Model]:
53        """Get model checks if any virtual models are registered, and falls back
54        to actual django models"""
55        if app_label.lower() == self.virtual_prefix:
56            if model_id.lower() in self.models:
57                return self.models[model_id]
58        return apps.get_model(app_label, model_id)
59
60
61registry = MetaModelRegistry("authentik_blueprints")
class BaseMetaModel(django.db.models.base.Model): 
 9class BaseMetaModel(Model):
10    """Base models"""
11
12    class Meta:
13        abstract = True
14
15    @staticmethod
16    def serializer() -> Serializer:
17        """Serializer similar to SerializerModel, but as a static method since
18        this is an abstract model"""
19        raise NotImplementedError

Base models

@staticmethod
def serializer() -> rest_framework.serializers.Serializer: 
15    @staticmethod
16    def serializer() -> Serializer:
17        """Serializer similar to SerializerModel, but as a static method since
18        this is an abstract model"""
19        raise NotImplementedError

Serializer similar to SerializerModel, but as a static method since this is an abstract model

class BaseMetaModel.Meta: 
12    class Meta:
13        abstract = True
abstract = False
class MetaResult: 
22class MetaResult:
23    """Result returned by Meta Models' serializers. Empty class but we can't return none as
24    the framework doesn't allow that"""

Result returned by Meta Models' serializers. Empty class but we can't return none as the framework doesn't allow that

class MetaModelRegistry: 
27class MetaModelRegistry:
28    """Registry for pseudo meta models"""
29
30    models: dict[str, BaseMetaModel]
31    virtual_prefix: str
32
33    def __init__(self, prefix: str) -> None:
34        self.models = {}
35        self.virtual_prefix = prefix
36
37    def register(self, model_id: str):
38        """Register model class under `model_id`"""
39
40        def inner_wrapper(cls):
41            self.models[model_id] = cls
42            return cls
43
44        return inner_wrapper
45
46    def get_models(self):
47        """Wrapper for django's `get_models` to list all models"""
48        models = apps.get_models()
49        for _, value in self.models.items():
50            models.append(value)
51        return sorted(models, key=str)
52
53    def get_model(self, app_label: str, model_id: str) -> type[Model]:
54        """Get model checks if any virtual models are registered, and falls back
55        to actual django models"""
56        if app_label.lower() == self.virtual_prefix:
57            if model_id.lower() in self.models:
58                return self.models[model_id]
59        return apps.get_model(app_label, model_id)

Registry for pseudo meta models

MetaModelRegistry(prefix: str) 
33    def __init__(self, prefix: str) -> None:
34        self.models = {}
35        self.virtual_prefix = prefix
models: dict[str, BaseMetaModel]
virtual_prefix: str
def register(self, model_id: str): 
37    def register(self, model_id: str):
38        """Register model class under `model_id`"""
39
40        def inner_wrapper(cls):
41            self.models[model_id] = cls
42            return cls
43
44        return inner_wrapper

Register model class under model_id

def get_models(self): 
46    def get_models(self):
47        """Wrapper for django's `get_models` to list all models"""
48        models = apps.get_models()
49        for _, value in self.models.items():
50            models.append(value)
51        return sorted(models, key=str)

Wrapper for django's get_models to list all models

def get_model(self, app_label: str, model_id: str) -> type[django.db.models.base.Model]: 
53    def get_model(self, app_label: str, model_id: str) -> type[Model]:
54        """Get model checks if any virtual models are registered, and falls back
55        to actual django models"""
56        if app_label.lower() == self.virtual_prefix:
57            if model_id.lower() in self.models:
58                return self.models[model_id]
59        return apps.get_model(app_label, model_id)

Get model checks if any virtual models are registered, and falls back to actual django models

registry = <MetaModelRegistry object>