Skip to content

BGP Models API Package

nautobot_bgp_models.api

REST API module for nautobot_bgp_models app.

filter_backends

Filter Backends in use by BGP models app.

IncludeInheritedFilterBackend

Bases: DjangoFilterBackend

Custom filtering backend for use with django-rest-framework and django-filters.

Source code in nautobot_bgp_models/api/filter_backends.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
class IncludeInheritedFilterBackend(DjangoFilterBackend):
    """Custom filtering backend for use with django-rest-framework and django-filters."""

    def get_filterset_kwargs(self, request, queryset, view):
        """
        Get the kwargs that should be passed through when constructing a FilterSet corresponding to a given request.

        This extends the base DjangoFilterBackend method to explicitly exclude query parameters that we know to be
        non-filterset parameters.
        """
        kwargs = super().get_filterset_kwargs(request, queryset, view)
        # The default 'data' is a reference to request.GET, which is immutable; copies of this data are mutable
        data = kwargs["data"].copy()

        for non_filter_param in (
            "api_version",  # used to select the Nautobot API version
            "brief",  # used to select NestedSerializer rather than Serializer
            "format",  # "json" or "api", used in the interactive HTML REST API views
            "include",  # used to include computed fields (excluded by default)
            "limit",  # pagination
            "offset",  # pagination
            "include_inherited",  # Non-Core, BGP specific `include_inherited` param
        ):
            data.pop(non_filter_param, None)

        kwargs["data"] = data
        return kwargs
get_filterset_kwargs(request, queryset, view)

Get the kwargs that should be passed through when constructing a FilterSet corresponding to a given request.

This extends the base DjangoFilterBackend method to explicitly exclude query parameters that we know to be non-filterset parameters.

Source code in nautobot_bgp_models/api/filter_backends.py 
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
def get_filterset_kwargs(self, request, queryset, view):
    """
    Get the kwargs that should be passed through when constructing a FilterSet corresponding to a given request.

    This extends the base DjangoFilterBackend method to explicitly exclude query parameters that we know to be
    non-filterset parameters.
    """
    kwargs = super().get_filterset_kwargs(request, queryset, view)
    # The default 'data' is a reference to request.GET, which is immutable; copies of this data are mutable
    data = kwargs["data"].copy()

    for non_filter_param in (
        "api_version",  # used to select the Nautobot API version
        "brief",  # used to select NestedSerializer rather than Serializer
        "format",  # "json" or "api", used in the interactive HTML REST API views
        "include",  # used to include computed fields (excluded by default)
        "limit",  # pagination
        "offset",  # pagination
        "include_inherited",  # Non-Core, BGP specific `include_inherited` param
    ):
        data.pop(non_filter_param, None)

    kwargs["data"] = data
    return kwargs

nested_serializers

Nested/brief alternate REST API serializers for nautobot_bgp_models models.

NestedAddressFamilySerializer

Bases: WritableNestedSerializer

Nested/brief serializer for AddressFamily.

Source code in nautobot_bgp_models/api/nested_serializers.py 
 95
 96
 97
 98
 99
100
101
102
class NestedAddressFamilySerializer(WritableNestedSerializer):
    """Nested/brief serializer for AddressFamily."""

    url = serializers.HyperlinkedIdentityField(view_name="plugins-api:nautobot_bgp_models-api:addressfamily-detail")

    class Meta:
        model = models.AddressFamily
        fields = ["id", "url", "afi_safi"]

NestedAutonomousSystemSerializer

Bases: WritableNestedSerializer

Nested/brief serializer for AutonomousSystem.

Source code in nautobot_bgp_models/api/nested_serializers.py 
23
24
25
26
27
28
29
30
class NestedAutonomousSystemSerializer(WritableNestedSerializer):
    """Nested/brief serializer for AutonomousSystem."""

    url = serializers.HyperlinkedIdentityField(view_name="plugins-api:nautobot_bgp_models-api:autonomoussystem-detail")

    class Meta:
        model = models.AutonomousSystem
        fields = ["id", "url", "asn"]

NestedBGPRoutingInstanceSerializer

Bases: WritableNestedSerializer

Nested/brief serializer for PeerEndpoint.

Source code in nautobot_bgp_models/api/nested_serializers.py 
73
74
75
76
77
78
79
80
81
82
class NestedBGPRoutingInstanceSerializer(WritableNestedSerializer):
    """Nested/brief serializer for PeerEndpoint."""

    url = serializers.HyperlinkedIdentityField(
        view_name="plugins-api:nautobot_bgp_models-api:bgproutinginstance-detail"
    )

    class Meta:
        model = models.BGPRoutingInstance
        fields = ["display", "id", "url"]

NestedPeerEndpointAddressFamilySerializer

Bases: WritableNestedSerializer

Nested/brief serializer for PeerEndpointAddressFamily.

Source code in nautobot_bgp_models/api/nested_serializers.py 
117
118
119
120
121
122
123
124
125
126
class NestedPeerEndpointAddressFamilySerializer(WritableNestedSerializer):
    """Nested/brief serializer for PeerEndpointAddressFamily."""

    url = serializers.HyperlinkedIdentityField(
        view_name="plugins-api:nautobot_bgp_models-api:peerendpointaddressfamily-detail"
    )

    class Meta:
        model = models.PeerEndpointAddressFamily
        fields = ["id", "url"]

NestedPeerEndpointSerializer

Bases: WritableNestedSerializer

Nested/brief serializer for PeerEndpoint.

Source code in nautobot_bgp_models/api/nested_serializers.py 
63
64
65
66
67
68
69
70
class NestedPeerEndpointSerializer(WritableNestedSerializer):
    """Nested/brief serializer for PeerEndpoint."""

    url = serializers.HyperlinkedIdentityField(view_name="plugins-api:nautobot_bgp_models-api:peerendpoint-detail")

    class Meta:
        model = models.PeerEndpoint
        fields = ["id", "url"]

NestedPeerGroupAddressFamilySerializer

Bases: WritableNestedSerializer

Nested/brief serializer for PeerGroupAddressFamily.

Source code in nautobot_bgp_models/api/nested_serializers.py 
105
106
107
108
109
110
111
112
113
114
class NestedPeerGroupAddressFamilySerializer(WritableNestedSerializer):
    """Nested/brief serializer for PeerGroupAddressFamily."""

    url = serializers.HyperlinkedIdentityField(
        view_name="plugins-api:nautobot_bgp_models-api:peergroupaddressfamily-detail"
    )

    class Meta:
        model = models.PeerGroupAddressFamily
        fields = ["id", "url"]

NestedPeerGroupSerializer

Bases: WritableNestedSerializer

Nested/brief serializer for PeerGroup.

Source code in nautobot_bgp_models/api/nested_serializers.py 
43
44
45
46
47
48
49
50
class NestedPeerGroupSerializer(WritableNestedSerializer):
    """Nested/brief serializer for PeerGroup."""

    url = serializers.HyperlinkedIdentityField(view_name="plugins-api:nautobot_bgp_models-api:peergroup-detail")

    class Meta:
        model = models.PeerGroup
        fields = ["id", "url", "name", "role", "enabled"]

NestedPeerGroupTemplateSerializer

Bases: WritableNestedSerializer

Nested/brief serializer for PeerGroup.

Source code in nautobot_bgp_models/api/nested_serializers.py 
53
54
55
56
57
58
59
60
class NestedPeerGroupTemplateSerializer(WritableNestedSerializer):
    """Nested/brief serializer for PeerGroup."""

    url = serializers.HyperlinkedIdentityField(view_name="plugins-api:nautobot_bgp_models-api:peergrouptemplate-detail")

    class Meta:
        model = models.PeerGroupTemplate
        fields = ["id", "url", "name"]

NestedPeeringRoleSerializer

Bases: WritableNestedSerializer

Nested/brief serializer for PeeringRole.

Source code in nautobot_bgp_models/api/nested_serializers.py 
33
34
35
36
37
38
39
40
class NestedPeeringRoleSerializer(WritableNestedSerializer):
    """Nested/brief serializer for PeeringRole."""

    url = serializers.HyperlinkedIdentityField(view_name="plugins-api:nautobot_bgp_models-api:peeringrole-detail")

    class Meta:
        model = models.PeeringRole
        fields = ["id", "url", "name", "slug", "color"]

NestedPeeringSerializer

Bases: WritableNestedSerializer

Nested/brief serializer for Peering.

Source code in nautobot_bgp_models/api/nested_serializers.py 
85
86
87
88
89
90
91
92
class NestedPeeringSerializer(WritableNestedSerializer):
    """Nested/brief serializer for Peering."""

    url = serializers.HyperlinkedIdentityField(view_name="plugins-api:nautobot_bgp_models-api:peering-detail")

    class Meta:
        model = models.Peering
        fields = ["id", "url", "status"]

serializers

REST API serializers for nautobot_bgp_models models.

AddressFamilySerializer

Bases: NautobotModelSerializer, ExtraAttributesSerializerMixin

REST API serializer for AddressFamily records.

Source code in nautobot_bgp_models/api/serializers.py 
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
class AddressFamilySerializer(NautobotModelSerializer, ExtraAttributesSerializerMixin):
    """REST API serializer for AddressFamily records."""

    url = serializers.HyperlinkedIdentityField(view_name="plugins-api:nautobot_bgp_models-api:addressfamily-detail")

    routing_instance = NestedBGPRoutingInstanceSerializer(required=True)  # noqa: F405

    vrf = NestedVRFSerializer(required=False, allow_null=True)

    class Meta:
        model = models.AddressFamily
        fields = [
            "id",
            "url",
            "afi_safi",
            "routing_instance",
            "vrf",
            "extra_attributes",
        ]

AutonomousSystemSerializer

Bases: NautobotModelSerializer, TaggedModelSerializerMixin, StatusModelSerializerMixin

REST API serializer for AutonomousSystem records.

Source code in nautobot_bgp_models/api/serializers.py 
23
24
25
26
27
28
29
30
31
32
33
34
35
class AutonomousSystemSerializer(
    NautobotModelSerializer,
    TaggedModelSerializerMixin,
    StatusModelSerializerMixin,
):
    """REST API serializer for AutonomousSystem records."""

    url = serializers.HyperlinkedIdentityField(view_name="plugins-api:nautobot_bgp_models-api:autonomoussystem-detail")
    provider = NestedProviderSerializer(required=False, allow_null=True)

    class Meta:
        model = models.AutonomousSystem
        fields = ["id", "url", "asn", "description", "status", "provider", "tags"]

BGPRoutingInstanceSerializer

Bases: NautobotModelSerializer, StatusModelSerializerMixin, ExtraAttributesSerializerMixin

REST API serializer for Peering records.

Source code in nautobot_bgp_models/api/serializers.py 
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
class BGPRoutingInstanceSerializer(NautobotModelSerializer, StatusModelSerializerMixin, ExtraAttributesSerializerMixin):
    """REST API serializer for Peering records."""

    url = serializers.HyperlinkedIdentityField(
        view_name="plugins-api:nautobot_bgp_models-api:bgproutinginstance-detail"
    )

    endpoints = NestedPeerEndpointSerializer(required=False, many=True)  # noqa: F405

    device = NestedDeviceSerializer()

    autonomous_system = NestedAutonomousSystemSerializer(required=False, allow_null=True)  # noqa: F405

    router_id = NestedIPAddressSerializer(required=False, allow_null=True)  # noqa: F405

    class Meta:
        model = models.BGPRoutingInstance
        fields = [
            "id",
            "url",
            "device",
            "status",
            "description",
            "router_id",
            "autonomous_system",
            "endpoints",
            "extra_attributes",
        ]

ExtraAttributesSerializerMixin

Bases: Serializer

Common mixin for BGP Extra Attributes.

Source code in nautobot_bgp_models/api/serializers.py 
64
65
66
67
68
69
70
71
72
73
74
75
76
77
class ExtraAttributesSerializerMixin(serializers.Serializer):  # pylint: disable=abstract-method
    """Common mixin for BGP Extra Attributes."""

    extra_attributes = serializers.JSONField(required=False, allow_null=True)

    def to_representation(self, instance):
        """Render the model instance to a Python dict.

        If `include_inherited` is specified as a request parameter, include object's get_extra_attributes().
        """
        req = self.context["request"]
        if hasattr(req, "query_params") and is_truthy(req.query_params.get("include_inherited", False)):
            setattr(instance, "extra_attributes", instance.get_extra_attributes())
        return super().to_representation(instance)
to_representation(instance)

Render the model instance to a Python dict.

If include_inherited is specified as a request parameter, include object's get_extra_attributes().

Source code in nautobot_bgp_models/api/serializers.py 
69
70
71
72
73
74
75
76
77
def to_representation(self, instance):
    """Render the model instance to a Python dict.

    If `include_inherited` is specified as a request parameter, include object's get_extra_attributes().
    """
    req = self.context["request"]
    if hasattr(req, "query_params") and is_truthy(req.query_params.get("include_inherited", False)):
        setattr(instance, "extra_attributes", instance.get_extra_attributes())
    return super().to_representation(instance)

InheritableFieldsSerializerMixin

Common mixin for Serializers that support an additional include_inherited query parameter.

Source code in nautobot_bgp_models/api/serializers.py 
48
49
50
51
52
53
54
55
56
57
58
59
60
61
class InheritableFieldsSerializerMixin:
    """Common mixin for Serializers that support an additional `include_inherited` query parameter."""

    def to_representation(self, instance):
        """Render the model instance to a Python dict.

        If `include_inherited` is specified as a request parameter, include inherited field values as appropriate.
        """
        req = self.context["request"]
        if hasattr(req, "query_params") and is_truthy(req.query_params.get("include_inherited", False)):
            inherited_fields = instance.get_fields(include_inherited=True)
            for field, data in inherited_fields.items():
                setattr(instance, field, data["value"])
        return super().to_representation(instance)
to_representation(instance)

Render the model instance to a Python dict.

If include_inherited is specified as a request parameter, include inherited field values as appropriate.

Source code in nautobot_bgp_models/api/serializers.py 
51
52
53
54
55
56
57
58
59
60
61
def to_representation(self, instance):
    """Render the model instance to a Python dict.

    If `include_inherited` is specified as a request parameter, include inherited field values as appropriate.
    """
    req = self.context["request"]
    if hasattr(req, "query_params") and is_truthy(req.query_params.get("include_inherited", False)):
        inherited_fields = instance.get_fields(include_inherited=True)
        for field, data in inherited_fields.items():
            setattr(instance, field, data["value"])
    return super().to_representation(instance)

PeerEndpointAddressFamilySerializer

Bases: NautobotModelSerializer, ExtraAttributesSerializerMixin

REST API serializer for PeerEndpointAddressFamily records.

Source code in nautobot_bgp_models/api/serializers.py 
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
class PeerEndpointAddressFamilySerializer(NautobotModelSerializer, ExtraAttributesSerializerMixin):
    """REST API serializer for PeerEndpointAddressFamily records."""

    url = serializers.HyperlinkedIdentityField(
        view_name="plugins-api:nautobot_bgp_models-api:peerendpointaddressfamily-detail"
    )

    peer_endpoint = NestedPeerEndpointSerializer(required=True)  # noqa: F405

    class Meta:
        model = models.PeerEndpointAddressFamily
        fields = [
            "id",
            "url",
            "afi_safi",
            "peer_endpoint",
            "import_policy",
            "export_policy",
            "multipath",
            "extra_attributes",
        ]

PeerEndpointSerializer

Bases: InheritableFieldsSerializerMixin, TaggedModelSerializerMixin, NautobotModelSerializer, ExtraAttributesSerializerMixin

REST API serializer for PeerEndpoint records.

Source code in nautobot_bgp_models/api/serializers.py 
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
class PeerEndpointSerializer(
    InheritableFieldsSerializerMixin,
    TaggedModelSerializerMixin,
    NautobotModelSerializer,
    ExtraAttributesSerializerMixin,
):
    """REST API serializer for PeerEndpoint records."""

    url = serializers.HyperlinkedIdentityField(view_name="plugins-api:nautobot_bgp_models-api:peerendpoint-detail")
    source_ip = NestedIPAddressSerializer(required=False, allow_null=True)  # noqa: F405
    source_interface = NestedInterfaceSerializer(required=False, allow_null=True)  # noqa: F405
    peer = NestedPeerEndpointSerializer(required=False, allow_null=True)  # noqa: F405
    peering = NestedPeeringSerializer(required=True, allow_null=True)  # noqa: F405
    peer_group = NestedPeerGroupSerializer(required=False, allow_null=True)  # noqa: F405
    routing_instance = NestedBGPRoutingInstanceSerializer(required=False, allow_null=True)  # noqa: F405
    autonomous_system = NestedAutonomousSystemSerializer(required=False, allow_null=True)  # noqa: F405
    secret = NestedSecretSerializer(required=False, allow_null=True)

    class Meta:
        model = models.PeerEndpoint
        fields = [
            "id",
            "url",
            "routing_instance",
            "source_ip",
            "source_interface",
            "autonomous_system",
            "peer_group",
            "peer",
            "peering",
            "secret",
            "tags",
            "enabled",
            "extra_attributes",
        ]

    def create(self, validated_data):
        """Create a new PeerEndpoint and update the peer on both sides."""
        record = super().create(validated_data)
        record.peering.update_peers()
        return record

    def update(self, instance, validated_data):
        """When updating an existing PeerEndpoint, ensure peer is properly setup on both side."""
        peering_has_been_updated = False
        if instance.peering.pk != validated_data.get("peering"):
            peering_has_been_updated = True

        result = super().update(instance, validated_data)

        if peering_has_been_updated:
            result.peering.update_peers()

        return result
create(validated_data)

Create a new PeerEndpoint and update the peer on both sides.

Source code in nautobot_bgp_models/api/serializers.py 
192
193
194
195
196
def create(self, validated_data):
    """Create a new PeerEndpoint and update the peer on both sides."""
    record = super().create(validated_data)
    record.peering.update_peers()
    return record
update(instance, validated_data)

When updating an existing PeerEndpoint, ensure peer is properly setup on both side.

Source code in nautobot_bgp_models/api/serializers.py 
198
199
200
201
202
203
204
205
206
207
208
209
def update(self, instance, validated_data):
    """When updating an existing PeerEndpoint, ensure peer is properly setup on both side."""
    peering_has_been_updated = False
    if instance.peering.pk != validated_data.get("peering"):
        peering_has_been_updated = True

    result = super().update(instance, validated_data)

    if peering_has_been_updated:
        result.peering.update_peers()

    return result

PeerGroupAddressFamilySerializer

Bases: NautobotModelSerializer, ExtraAttributesSerializerMixin

REST API serializer for PeerGroupAddressFamily records.

Source code in nautobot_bgp_models/api/serializers.py 
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
class PeerGroupAddressFamilySerializer(NautobotModelSerializer, ExtraAttributesSerializerMixin):
    """REST API serializer for PeerGroupAddressFamily records."""

    url = serializers.HyperlinkedIdentityField(
        view_name="plugins-api:nautobot_bgp_models-api:peergroupaddressfamily-detail"
    )

    peer_group = NestedPeerGroupSerializer(required=True)  # noqa: F405

    class Meta:
        model = models.PeerGroupAddressFamily
        fields = [
            "id",
            "url",
            "afi_safi",
            "peer_group",
            "import_policy",
            "export_policy",
            "multipath",
            "extra_attributes",
        ]

PeerGroupSerializer

Bases: InheritableFieldsSerializerMixin, NautobotModelSerializer, ExtraAttributesSerializerMixin

REST API serializer for PeerGroup records.

Source code in nautobot_bgp_models/api/serializers.py 
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
class PeerGroupSerializer(
    InheritableFieldsSerializerMixin,
    NautobotModelSerializer,
    ExtraAttributesSerializerMixin,
):
    """REST API serializer for PeerGroup records."""

    url = serializers.HyperlinkedIdentityField(view_name="plugins-api:nautobot_bgp_models-api:peergroup-detail")
    source_ip = NestedIPAddressSerializer(required=False, allow_null=True)  # noqa: F405
    source_interface = NestedInterfaceSerializer(required=False, allow_null=True)  # noqa: F405

    routing_instance = NestedBGPRoutingInstanceSerializer(required=True)  # noqa: F405

    autonomous_system = NestedAutonomousSystemSerializer(required=False, allow_null=True)  # noqa: F405

    vrf = NestedVRFSerializer(required=False, allow_null=True)

    peergroup_template = NestedPeerGroupTemplateSerializer(required=False, allow_null=True)  # noqa: F405

    secret = NestedSecretSerializer(required=False, allow_null=True)

    class Meta:
        model = models.PeerGroup
        fields = [
            "id",
            "url",
            "name",
            "source_ip",
            "source_interface",
            "description",
            "enabled",
            "autonomous_system",
            "routing_instance",
            "vrf",
            "peergroup_template",
            "secret",
            "extra_attributes",
            "role",
        ]
        validators = []

    def validate(self, data):
        """Custom validation logic to handle unique-together with a nullable field."""
        if data.get("vrf"):
            validator = validators.UniqueTogetherValidator(
                queryset=models.PeerGroup.objects.all(), fields=("routing_instance", "name", "vrf")
            )
            validator(data, self)

        super().validate(data)
        return data
validate(data)

Custom validation logic to handle unique-together with a nullable field.

Source code in nautobot_bgp_models/api/serializers.py 
144
145
146
147
148
149
150
151
152
153
def validate(self, data):
    """Custom validation logic to handle unique-together with a nullable field."""
    if data.get("vrf"):
        validator = validators.UniqueTogetherValidator(
            queryset=models.PeerGroup.objects.all(), fields=("routing_instance", "name", "vrf")
        )
        validator(data, self)

    super().validate(data)
    return data

PeerGroupTemplateSerializer

Bases: NautobotModelSerializer, ExtraAttributesSerializerMixin

REST API serializer for PeerGroup records.

Source code in nautobot_bgp_models/api/serializers.py 
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
class PeerGroupTemplateSerializer(NautobotModelSerializer, ExtraAttributesSerializerMixin):
    """REST API serializer for PeerGroup records."""

    url = serializers.HyperlinkedIdentityField(view_name="plugins-api:nautobot_bgp_models-api:peergrouptemplate-detail")

    autonomous_system = NestedAutonomousSystemSerializer(required=False, allow_null=True)  # noqa: F405
    secret = NestedSecretSerializer(required=False, allow_null=True)

    class Meta:
        model = models.PeerGroupTemplate
        fields = [
            "id",
            "url",
            "name",
            "role",
            "description",
            "enabled",
            "autonomous_system",
            "extra_attributes",
            "secret",
        ]

PeeringRoleSerializer

Bases: NautobotModelSerializer

REST API serializer for PeeringRole records.

Source code in nautobot_bgp_models/api/serializers.py 
38
39
40
41
42
43
44
45
class PeeringRoleSerializer(NautobotModelSerializer):
    """REST API serializer for PeeringRole records."""

    url = serializers.HyperlinkedIdentityField(view_name="plugins-api:nautobot_bgp_models-api:peeringrole-detail")

    class Meta:
        model = models.PeeringRole
        fields = ["id", "url", "name", "slug", "color", "description"]

PeeringSerializer

Bases: NautobotModelSerializer, StatusModelSerializerMixin

REST API serializer for Peering records.

Source code in nautobot_bgp_models/api/serializers.py 
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
class PeeringSerializer(NautobotModelSerializer, StatusModelSerializerMixin):
    """REST API serializer for Peering records."""

    url = serializers.HyperlinkedIdentityField(view_name="plugins-api:nautobot_bgp_models-api:peering-detail")

    endpoints = NestedPeerEndpointSerializer(required=False, many=True)  # noqa: F405

    class Meta:
        model = models.Peering
        fields = [
            "id",
            "url",
            "status",
            "endpoints",
        ]

urls

REST API URL registration for nautobot_bgp_models.

views

REST API viewsets for nautobot_bgp_models.

AddressFamilyViewSet

Bases: InheritableFieldsViewSetMixin, PluginModelViewSet

REST API viewset for AddressFamily records.

Source code in nautobot_bgp_models/api/views.py 
110
111
112
113
114
115
class AddressFamilyViewSet(InheritableFieldsViewSetMixin, PluginModelViewSet):
    """REST API viewset for AddressFamily records."""

    queryset = models.AddressFamily.objects.all()
    serializer_class = serializers.AddressFamilySerializer
    filterset_class = filters.AddressFamilyFilterSet

AutonomousSystemViewSet

Bases: PluginModelViewSet, StatusViewSetMixin

REST API viewset for AutonomousSystem records.

Source code in nautobot_bgp_models/api/views.py 
37
38
39
40
41
42
class AutonomousSystemViewSet(PluginModelViewSet, StatusViewSetMixin):
    """REST API viewset for AutonomousSystem records."""

    queryset = models.AutonomousSystem.objects.all()
    serializer_class = serializers.AutonomousSystemSerializer
    filterset_class = filters.AutonomousSystemFilterSet

BGPRoutingInstanceViewSet

Bases: PluginModelViewSet, StatusViewSetMixin

REST API viewset for BGPRoutingInstance records.

Source code in nautobot_bgp_models/api/views.py 
29
30
31
32
33
34
class BGPRoutingInstanceViewSet(PluginModelViewSet, StatusViewSetMixin):
    """REST API viewset for BGPRoutingInstance records."""

    queryset = models.BGPRoutingInstance.objects.all()
    serializer_class = serializers.BGPRoutingInstanceSerializer
    filterset_class = filters.BGPRoutingInstanceFilterSet

InheritableFieldsViewSetMixin

Common mixin for ViewSets that support an additional include_inherited query parameter.

Source code in nautobot_bgp_models/api/views.py 
62
63
64
65
66
67
68
69
70
71
72
73
class InheritableFieldsViewSetMixin:
    """Common mixin for ViewSets that support an additional `include_inherited` query parameter."""

    @extend_schema(parameters=[include_inherited])
    def list(self, request):
        """List all objects of this type."""
        return super().list(request)

    @extend_schema(parameters=[include_inherited])
    def retrieve(self, request, pk=None):
        """Retrieve a specific object instance."""
        return super().retrieve(request, pk=pk)
list(request)

List all objects of this type.

Source code in nautobot_bgp_models/api/views.py 
65
66
67
68
@extend_schema(parameters=[include_inherited])
def list(self, request):
    """List all objects of this type."""
    return super().list(request)
retrieve(request, pk=None)

Retrieve a specific object instance.

Source code in nautobot_bgp_models/api/views.py 
70
71
72
73
@extend_schema(parameters=[include_inherited])
def retrieve(self, request, pk=None):
    """Retrieve a specific object instance."""
    return super().retrieve(request, pk=pk)

PeerEndpointAddressFamilyViewSet

Bases: InheritableFieldsViewSetMixin, PluginModelViewSet

REST API viewset for PeerEndpointAddressFamily records.

Source code in nautobot_bgp_models/api/views.py 
126
127
128
129
130
131
class PeerEndpointAddressFamilyViewSet(InheritableFieldsViewSetMixin, PluginModelViewSet):
    """REST API viewset for PeerEndpointAddressFamily records."""

    queryset = models.PeerEndpointAddressFamily.objects.all()
    serializer_class = serializers.PeerEndpointAddressFamilySerializer
    filterset_class = filters.PeerEndpointAddressFamilyFilterSet

PeerEndpointViewSet

Bases: InheritableFieldsViewSetMixin, PluginModelViewSet

REST API viewset for PeerEndpoint records.

Source code in nautobot_bgp_models/api/views.py 
93
94
95
96
97
98
99
class PeerEndpointViewSet(InheritableFieldsViewSetMixin, PluginModelViewSet):
    """REST API viewset for PeerEndpoint records."""

    queryset = models.PeerEndpoint.objects.all()
    serializer_class = serializers.PeerEndpointSerializer
    filter_backends = [IncludeInheritedFilterBackend]
    filterset_class = filters.PeerEndpointFilterSet

PeerGroupAddressFamilyViewSet

Bases: InheritableFieldsViewSetMixin, PluginModelViewSet

REST API viewset for PeerGroupAddressFamily records.

Source code in nautobot_bgp_models/api/views.py 
118
119
120
121
122
123
class PeerGroupAddressFamilyViewSet(InheritableFieldsViewSetMixin, PluginModelViewSet):
    """REST API viewset for PeerGroupAddressFamily records."""

    queryset = models.PeerGroupAddressFamily.objects.all()
    serializer_class = serializers.PeerGroupAddressFamilySerializer
    filterset_class = filters.PeerGroupAddressFamilyFilterSet

PeerGroupTemplateViewSet

Bases: InheritableFieldsViewSetMixin, PluginModelViewSet

REST API viewset for PeerGroupTemplate records.

Source code in nautobot_bgp_models/api/views.py 
85
86
87
88
89
90
class PeerGroupTemplateViewSet(InheritableFieldsViewSetMixin, PluginModelViewSet):
    """REST API viewset for PeerGroupTemplate records."""

    queryset = models.PeerGroupTemplate.objects.all()
    serializer_class = serializers.PeerGroupTemplateSerializer
    filterset_class = filters.PeerGroupTemplateFilterSet

PeerGroupViewSet

Bases: InheritableFieldsViewSetMixin, PluginModelViewSet

REST API viewset for PeerGroup records.

Source code in nautobot_bgp_models/api/views.py 
76
77
78
79
80
81
82
class PeerGroupViewSet(InheritableFieldsViewSetMixin, PluginModelViewSet):
    """REST API viewset for PeerGroup records."""

    queryset = models.PeerGroup.objects.all()
    serializer_class = serializers.PeerGroupSerializer
    filter_backends = [IncludeInheritedFilterBackend]
    filterset_class = filters.PeerGroupFilterSet

PeeringRoleViewSet

Bases: PluginModelViewSet

REST API viewset for PeeringRole records.

Source code in nautobot_bgp_models/api/views.py 
45
46
47
48
49
50
class PeeringRoleViewSet(PluginModelViewSet):
    """REST API viewset for PeeringRole records."""

    queryset = models.PeeringRole.objects.all()
    serializer_class = serializers.PeeringRoleSerializer
    filterset_class = filters.PeeringRoleFilterSet

PeeringViewSet

Bases: PluginModelViewSet, StatusViewSetMixin

REST API viewset for Peering records.

Source code in nautobot_bgp_models/api/views.py 
102
103
104
105
106
107
class PeeringViewSet(PluginModelViewSet, StatusViewSetMixin):
    """REST API viewset for Peering records."""

    queryset = models.Peering.objects.all()
    serializer_class = serializers.PeeringSerializer
    filterset_class = filters.PeeringFilterSet

PluginModelViewSet

Bases: NautobotModelViewSet

Base class for all REST API viewsets in this app.

Source code in nautobot_bgp_models/api/views.py 
14
15
16
17
18
19
20
21
22
23
24
25
26
class PluginModelViewSet(NautobotModelViewSet):
    """Base class for all REST API viewsets in this app."""

    def get_serializer_class(self):
        """Override the default ModelViewSet implementation as it doesn't handle apps correctly."""
        app_label, model_name = self.queryset.model._meta.label.split(".")
        if self.brief:
            try:
                return dynamic_import(f"{app_label}.api.serializers.Nested{model_name}Serializer")
            except AttributeError:
                pass

        return self.serializer_class
get_serializer_class()

Override the default ModelViewSet implementation as it doesn't handle apps correctly.

Source code in nautobot_bgp_models/api/views.py 
17
18
19
20
21
22
23
24
25
26
def get_serializer_class(self):
    """Override the default ModelViewSet implementation as it doesn't handle apps correctly."""
    app_label, model_name = self.queryset.model._meta.label.split(".")
    if self.brief:
        try:
            return dynamic_import(f"{app_label}.api.serializers.Nested{model_name}Serializer")
        except AttributeError:
            pass

    return self.serializer_class