Coverage for dcim/graphql/filters.py: 93%

1from typing import TYPE_CHECKING, Annotated

3import strawberry

4import strawberry_django

5from django.db.models import Q

6from strawberry.scalars import ID

7from strawberry_django import (

8 BaseFilterLookup,

9 ComparisonFilterLookup,

10 DateFilterLookup,

11 FilterLookup,

12 StrFilterLookup,

13)

15from dcim import models

16from dcim.constants import *

17from dcim.graphql.enums import InterfaceKindEnum

18from dcim.graphql.filter_mixins import (

19 ComponentModelFilterMixin,

20 ComponentTemplateFilterMixin,

21 ModularComponentFilterMixin,

22 ModularComponentTemplateFilterMixin,

23 RackFilterMixin,

24)

25from extras.graphql.filter_mixins import ConfigContextFilterMixin

26from netbox.graphql.filter_mixins import ImageAttachmentFilterMixin, WeightFilterMixin

27from netbox.graphql.filters import (

28 BaseModelFilter,

29 ChangeLoggedModelFilter,

30 NestedGroupModelFilter,

31 NetBoxModelFilter,

32 OrganizationalModelFilter,

33 PrimaryModelFilter,

34 register_filter,

35)

36from tenancy.graphql.filter_mixins import ContactFilterMixin, TenancyFilterMixin

37from virtualization.models import VMInterface

39from .filter_mixins import (

40 CabledObjectModelFilterMixin,

41 InterfaceBaseFilterMixin,

42 RenderConfigFilterMixin,

43)

45if TYPE_CHECKING: 45 ↛ 46line 45 didn't jump to line 46 because the condition on line 45 was never true

46 from core.graphql.filters import ContentTypeFilter

47 from extras.graphql.filters import ConfigTemplateFilter, ImageAttachmentFilter

48 from ipam.graphql.filters import (

49 ASNFilter,

50 FHRPGroupAssignmentFilter,

51 IPAddressFilter,

52 PrefixFilter,

53 VLANGroupFilter,

54 VRFFilter,

55 )

56 from netbox.graphql.enums import ColorEnum

57 from netbox.graphql.filter_lookups import (

58 BigIntegerLookup,

59 FloatLookup,

60 IntegerArrayLookup,

61 IntegerLookup,

62 TreeNodeFilter,

63 )

64 from users.graphql.filters import UserFilter

65 from virtualization.graphql.filters import ClusterFilter

66 from vpn.graphql.filters import L2VPNFilter, TunnelTerminationFilter

67 from wireless.graphql.enums import WirelessChannelEnum, WirelessRoleEnum

68 from wireless.graphql.filters import WirelessLANFilter, WirelessLinkFilter

70 from .enums import *

72__all__ = (

73 'CableBundleFilter',

74 'CableFilter',

75 'CableTerminationFilter',

76 'ConsolePortFilter',

77 'ConsolePortTemplateFilter',

78 'ConsoleServerPortFilter',

79 'ConsoleServerPortTemplateFilter',

80 'CoolingFeedFilter',

81 'CoolingIntakeFilter',

82 'CoolingIntakeTemplateFilter',

83 'CoolingOutflowFilter',

84 'CoolingOutflowTemplateFilter',

85 'CoolingSourceFilter',

86 'DeviceBayFilter',

87 'DeviceBayTemplateFilter',

88 'DeviceFilter',

89 'DeviceRoleFilter',

90 'DeviceTypeFilter',

91 'FrontPortFilter',

92 'FrontPortTemplateFilter',

93 'InterfaceFilter',

94 'InterfaceTemplateFilter',

95 'InventoryItemFilter',

96 'InventoryItemRoleFilter',

97 'InventoryItemTemplateFilter',

98 'LocationFilter',

99 'MACAddressFilter',

100 'ManufacturerFilter',

101 'ModuleBayFilter',

102 'ModuleBayTemplateFilter',

103 'ModuleBayTypeFilter',

104 'ModuleFilter',

105 'ModuleTypeFilter',

106 'ModuleTypeProfileFilter',

107 'PlatformFilter',

108 'PortMappingFilter',

109 'PortTemplateMappingFilter',

110 'PowerFeedFilter',

111 'PowerOutletFilter',

112 'PowerOutletTemplateFilter',

113 'PowerPanelFilter',

114 'PowerPortFilter',

115 'PowerPortTemplateFilter',

116 'RackFilter',

117 'RackGroupFilter',

118 'RackReservationFilter',

119 'RackRoleFilter',

120 'RackTypeFilter',

121 'RearPortFilter',

122 'RearPortTemplateFilter',

123 'RegionFilter',

124 'SiteFilter',

125 'SiteGroupFilter',

126 'VirtualChassisFilter',

127 'VirtualDeviceContextFilter',

128)

129

130

131@register_filter(models.CableBundle, lookups=True)

132class CableBundleFilter(PrimaryModelFilter):

133 name: StrFilterLookup | None = strawberry_django.filter_field()

134

135

136@register_filter(models.Cable, lookups=True)

137class CableFilter(TenancyFilterMixin, PrimaryModelFilter):

138 type: BaseFilterLookup[Annotated['CableTypeEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

139 strawberry_django.filter_field()

140 )

141 status: BaseFilterLookup[Annotated['LinkStatusEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

142 strawberry_django.filter_field()

143 )

144 label: StrFilterLookup | None = strawberry_django.filter_field()

145 color: BaseFilterLookup[Annotated['ColorEnum', strawberry.lazy('netbox.graphql.enums')]] | None = (

146 strawberry_django.filter_field()

147 )

148 length: Annotated['FloatLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

149 strawberry_django.filter_field()

150 )

151 length_unit: BaseFilterLookup[Annotated['CableLengthUnitEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

152 strawberry_django.filter_field()

153 )

154 terminations: Annotated['CableTerminationFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

155 strawberry_django.filter_field()

156 )

157

158

159@register_filter(models.CableTermination, lookups=True)

160class CableTerminationFilter(ChangeLoggedModelFilter):

161 cable: Annotated['CableFilter', strawberry.lazy('dcim.graphql.filters')] | None = strawberry_django.filter_field()

162 cable_id: ID | None = strawberry_django.filter_field()

163 cable_end: BaseFilterLookup[Annotated['CableEndEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

164 strawberry_django.filter_field()

165 )

166 termination_type: Annotated['CableTerminationFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

167 strawberry_django.filter_field()

168 )

169 termination_id: ID | None = strawberry_django.filter_field()

170

171 # Cached relations

172 _device: Annotated['DeviceFilter', strawberry.lazy('dcim.graphql.filters')] | None = strawberry_django.filter_field(

173 name='device'

174 )

175 _rack: Annotated['RackFilter', strawberry.lazy('dcim.graphql.filters')] | None = strawberry_django.filter_field(

176 name='rack'

177 )

178 _location: Annotated['LocationFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

179 strawberry_django.filter_field(name='location')

180 )

181 _site: Annotated['SiteFilter', strawberry.lazy('dcim.graphql.filters')] | None = strawberry_django.filter_field(

182 name='site'

183 )

184

185

186@register_filter(models.ConsolePort, lookups=True)

187class ConsolePortFilter(ModularComponentFilterMixin, CabledObjectModelFilterMixin, NetBoxModelFilter):

188 type: BaseFilterLookup[Annotated['ConsolePortTypeEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

189 strawberry_django.filter_field()

190 )

191 speed: BaseFilterLookup[Annotated['ConsolePortSpeedEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

192 strawberry_django.filter_field()

193 )

194

195

196@register_filter(models.ConsolePortTemplate, lookups=True)

197class ConsolePortTemplateFilter(ModularComponentTemplateFilterMixin, ChangeLoggedModelFilter):

198 type: BaseFilterLookup[Annotated['ConsolePortTypeEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

199 strawberry_django.filter_field()

200 )

201

202

203@register_filter(models.ConsoleServerPort, lookups=True)

204class ConsoleServerPortFilter(ModularComponentFilterMixin, CabledObjectModelFilterMixin, NetBoxModelFilter):

205 type: BaseFilterLookup[Annotated['ConsolePortTypeEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

206 strawberry_django.filter_field()

207 )

208 speed: BaseFilterLookup[Annotated['ConsolePortSpeedEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

209 strawberry_django.filter_field()

210 )

211

212

213@register_filter(models.ConsoleServerPortTemplate, lookups=True)

214class ConsoleServerPortTemplateFilter(ModularComponentTemplateFilterMixin, ChangeLoggedModelFilter):

215 type: BaseFilterLookup[Annotated['ConsolePortTypeEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

216 strawberry_django.filter_field()

217 )

218

219

220@register_filter(models.Device, lookups=True)

221class DeviceFilter(

222 ContactFilterMixin,

223 TenancyFilterMixin,

224 ImageAttachmentFilterMixin,

225 RenderConfigFilterMixin,

226 ConfigContextFilterMixin,

227 PrimaryModelFilter,

228):

229 device_type: Annotated['DeviceTypeFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

230 strawberry_django.filter_field()

231 )

232 device_type_id: ID | None = strawberry_django.filter_field()

233 role: Annotated['DeviceRoleFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

234 strawberry_django.filter_field()

235 )

236 role_id: ID | None = strawberry_django.filter_field()

237 platform: Annotated['PlatformFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

238 strawberry_django.filter_field()

239 )

240 name: StrFilterLookup | None = strawberry_django.filter_field()

241 serial: StrFilterLookup | None = strawberry_django.filter_field()

242 asset_tag: StrFilterLookup | None = strawberry_django.filter_field()

243 site: Annotated['SiteFilter', strawberry.lazy('dcim.graphql.filters')] | None = strawberry_django.filter_field()

244 site_id: ID | None = strawberry_django.filter_field()

245 location: Annotated['LocationFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

246 strawberry_django.filter_field()

247 )

248 location_id: Annotated['TreeNodeFilter', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

249 strawberry_django.filter_field()

250 )

251 rack: Annotated['RackFilter', strawberry.lazy('dcim.graphql.filters')] | None = strawberry_django.filter_field()

252 rack_id: ID | None = strawberry_django.filter_field()

253 position: Annotated['FloatLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

254 strawberry_django.filter_field()

255 )

256 face: BaseFilterLookup[Annotated['DeviceFaceEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

257 strawberry_django.filter_field()

258 )

259 status: BaseFilterLookup[Annotated['DeviceStatusEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

260 strawberry_django.filter_field()

261 )

262 airflow: BaseFilterLookup[Annotated['DeviceAirflowEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

263 strawberry_django.filter_field()

264 )

265 cooling_method: BaseFilterLookup[Annotated['CoolingMethodEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

266 strawberry_django.filter_field()

267 )

268 primary_ip4: Annotated['IPAddressFilter', strawberry.lazy('ipam.graphql.filters')] | None = (

269 strawberry_django.filter_field()

270 )

271 primary_ip4_id: ID | None = strawberry_django.filter_field()

272 primary_ip6: Annotated['IPAddressFilter', strawberry.lazy('ipam.graphql.filters')] | None = (

273 strawberry_django.filter_field()

274 )

275 primary_ip6_id: ID | None = strawberry_django.filter_field()

276 oob_ip: Annotated['IPAddressFilter', strawberry.lazy('ipam.graphql.filters')] | None = (

277 strawberry_django.filter_field()

278 )

279 oob_ip_id: ID | None = strawberry_django.filter_field()

280 cluster: Annotated['ClusterFilter', strawberry.lazy('virtualization.graphql.filters')] | None = (

281 strawberry_django.filter_field()

282 )

283 cluster_id: ID | None = strawberry_django.filter_field()

284 virtual_chassis: Annotated['VirtualChassisFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

285 strawberry_django.filter_field()

286 )

287 virtual_chassis_id: ID | None = strawberry_django.filter_field()

288 vc_position: Annotated['IntegerLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

289 strawberry_django.filter_field()

290 )

291 vc_priority: Annotated['IntegerLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

292 strawberry_django.filter_field()

293 )

294 latitude: Annotated['FloatLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

295 strawberry_django.filter_field()

296 )

297 longitude: Annotated['FloatLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

298 strawberry_django.filter_field()

299 )

300 consoleports: Annotated['ConsolePortFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

301 strawberry_django.filter_field(name='console_ports')

302 )

303 consoleserverports: Annotated['ConsoleServerPortFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

304 strawberry_django.filter_field(name='console_server_ports')

305 )

306 poweroutlets: Annotated['PowerOutletFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

307 strawberry_django.filter_field(name='power_outlets')

308 )

309 powerports: Annotated['PowerPortFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

310 strawberry_django.filter_field(name='power_ports')

311 )

312 interfaces: Annotated['InterfaceFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

313 strawberry_django.filter_field()

314 )

315 frontports: Annotated['FrontPortFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

316 strawberry_django.filter_field(name='front_ports')

317 )

318 rearports: Annotated['RearPortFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

319 strawberry_django.filter_field(name='rear_ports')

320 )

321 devicebays: Annotated['DeviceBayFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

322 strawberry_django.filter_field(name='device_bays')

323 )

324 modulebays: Annotated['ModuleBayFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

325 strawberry_django.filter_field(name='module_bays')

326 )

327 modules: Annotated['ModuleFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

328 strawberry_django.filter_field()

329 )

330 console_port_count: FilterLookup[int] | None = strawberry_django.filter_field()

331 console_server_port_count: FilterLookup[int] | None = strawberry_django.filter_field()

332 power_port_count: FilterLookup[int] | None = strawberry_django.filter_field()

333 power_outlet_count: FilterLookup[int] | None = strawberry_django.filter_field()

334 interface_count: FilterLookup[int] | None = strawberry_django.filter_field()

335 front_port_count: FilterLookup[int] | None = strawberry_django.filter_field()

336 rear_port_count: FilterLookup[int] | None = strawberry_django.filter_field()

337 device_bay_count: FilterLookup[int] | None = strawberry_django.filter_field()

338 module_bay_count: FilterLookup[int] | None = strawberry_django.filter_field()

339 inventory_item_count: FilterLookup[int] | None = strawberry_django.filter_field()

340

341

342@register_filter(models.DeviceBay, lookups=True)

343class DeviceBayFilter(ComponentModelFilterMixin, NetBoxModelFilter):

344 enabled: FilterLookup[bool] | None = strawberry_django.filter_field()

345 installed_device: Annotated['DeviceFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

346 strawberry_django.filter_field()

347 )

348 installed_device_id: ID | None = strawberry_django.filter_field()

349

350

351@register_filter(models.DeviceBayTemplate, lookups=True)

352class DeviceBayTemplateFilter(ComponentTemplateFilterMixin, ChangeLoggedModelFilter):

353 enabled: FilterLookup[bool] | None = strawberry_django.filter_field()

354

355

356@register_filter(models.InventoryItemTemplate, lookups=True)

357class InventoryItemTemplateFilter(ComponentTemplateFilterMixin, ChangeLoggedModelFilter):

358 parent: Annotated['InventoryItemTemplateFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

359 strawberry_django.filter_field()

360 )

361 component_type: Annotated['ContentTypeFilter', strawberry.lazy('core.graphql.filters')] | None = (

362 strawberry_django.filter_field()

363 )

364 component_id: ID | None = strawberry_django.filter_field()

365 role: Annotated['InventoryItemRoleFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

366 strawberry_django.filter_field()

367 )

368 role_id: ID | None = strawberry_django.filter_field()

369 manufacturer: Annotated['ManufacturerFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

370 strawberry_django.filter_field()

371 )

372 manufacturer_id: ID | None = strawberry_django.filter_field()

373 part_id: StrFilterLookup | None = strawberry_django.filter_field()

374

375

376@register_filter(models.DeviceRole, lookups=True)

377class DeviceRoleFilter(RenderConfigFilterMixin, OrganizationalModelFilter):

378 color: BaseFilterLookup[Annotated['ColorEnum', strawberry.lazy('netbox.graphql.enums')]] | None = (

379 strawberry_django.filter_field()

380 )

381 vm_role: FilterLookup[bool] | None = strawberry_django.filter_field()

382

383

384@register_filter(models.DeviceType, lookups=True)

385class DeviceTypeFilter(ImageAttachmentFilterMixin, WeightFilterMixin, PrimaryModelFilter):

386 manufacturer: Annotated['ManufacturerFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

387 strawberry_django.filter_field()

388 )

389 manufacturer_id: ID | None = strawberry_django.filter_field()

390 model: StrFilterLookup | None = strawberry_django.filter_field()

391 slug: StrFilterLookup | None = strawberry_django.filter_field()

392 default_platform: Annotated['PlatformFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

393 strawberry_django.filter_field()

394 )

395 default_platform_id: ID | None = strawberry_django.filter_field()

396 part_number: StrFilterLookup | None = strawberry_django.filter_field()

397 instances: Annotated['DeviceFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

398 strawberry_django.filter_field()

399 )

400 u_height: Annotated['FloatLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

401 strawberry_django.filter_field()

402 )

403 exclude_from_utilization: FilterLookup[bool] | None = strawberry_django.filter_field()

404 is_full_depth: FilterLookup[bool] | None = strawberry_django.filter_field()

405 subdevice_role: BaseFilterLookup[Annotated['SubdeviceRoleEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

406 strawberry_django.filter_field()

407 )

408 airflow: BaseFilterLookup[Annotated['DeviceAirflowEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

409 strawberry_django.filter_field()

410 )

411 cooling_method: BaseFilterLookup[Annotated['CoolingMethodEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

412 strawberry_django.filter_field()

413 )

414 end_of_life: DateFilterLookup | None = strawberry_django.filter_field()

415 front_image: Annotated['ImageAttachmentFilter', strawberry.lazy('extras.graphql.filters')] | None = (

416 strawberry_django.filter_field()

417 )

418 rear_image: Annotated['ImageAttachmentFilter', strawberry.lazy('extras.graphql.filters')] | None = (

419 strawberry_django.filter_field()

420 )

421 consoleporttemplates: Annotated['ConsolePortTemplateFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

422 strawberry_django.filter_field(name='console_port_templates')

423 )

424 consoleserverporttemplates: (

425 Annotated['ConsoleServerPortTemplateFilter', strawberry.lazy('dcim.graphql.filters')] | None

426 ) = strawberry_django.filter_field(name='console_server_port_templates')

427 powerporttemplates: Annotated['PowerPortTemplateFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

428 strawberry_django.filter_field(name='power_port_templates')

429 )

430 poweroutlettemplates: Annotated['PowerOutletTemplateFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

431 strawberry_django.filter_field(name='power_outlet_templates')

432 )

433 interfacetemplates: Annotated['InterfaceTemplateFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

434 strawberry_django.filter_field(name='interface_templates')

435 )

436 frontporttemplates: Annotated['FrontPortTemplateFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

437 strawberry_django.filter_field(name='front_port_templates')

438 )

439 rearporttemplates: Annotated['RearPortTemplateFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

440 strawberry_django.filter_field(name='rear_port_templates')

441 )

442 devicebaytemplates: Annotated['DeviceBayTemplateFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

443 strawberry_django.filter_field(name='device_bay_templates')

444 )

445 modulebaytemplates: Annotated['ModuleBayTemplateFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

446 strawberry_django.filter_field(name='module_bay_templates')

447 )

448 inventoryitemtemplates: Annotated['InventoryItemTemplateFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

449 strawberry_django.filter_field(name='inventory_item_templates')

450 )

451 console_port_template_count: FilterLookup[int] | None = strawberry_django.filter_field()

452 console_server_port_template_count: FilterLookup[int] | None = strawberry_django.filter_field()

453 power_port_template_count: FilterLookup[int] | None = strawberry_django.filter_field()

454 power_outlet_template_count: FilterLookup[int] | None = strawberry_django.filter_field()

455 interface_template_count: FilterLookup[int] | None = strawberry_django.filter_field()

456 front_port_template_count: FilterLookup[int] | None = strawberry_django.filter_field()

457 rear_port_template_count: FilterLookup[int] | None = strawberry_django.filter_field()

458 device_bay_template_count: FilterLookup[int] | None = strawberry_django.filter_field()

459 module_bay_template_count: FilterLookup[int] | None = strawberry_django.filter_field()

460 inventory_item_template_count: FilterLookup[int] | None = strawberry_django.filter_field()

461 device_count: ComparisonFilterLookup[int] | None = strawberry_django.filter_field()

462

463

464@register_filter(models.FrontPort, lookups=True)

465class FrontPortFilter(ModularComponentFilterMixin, CabledObjectModelFilterMixin, NetBoxModelFilter):

466 type: BaseFilterLookup[Annotated['PortTypeEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

467 strawberry_django.filter_field()

468 )

469 color: BaseFilterLookup[Annotated['ColorEnum', strawberry.lazy('netbox.graphql.enums')]] | None = (

470 strawberry_django.filter_field()

471 )

472

473

474@register_filter(models.FrontPortTemplate, lookups=True)

475class FrontPortTemplateFilter(ModularComponentTemplateFilterMixin, ChangeLoggedModelFilter):

476 type: BaseFilterLookup[Annotated['PortTypeEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

477 strawberry_django.filter_field()

478 )

479 color: BaseFilterLookup[Annotated['ColorEnum', strawberry.lazy('netbox.graphql.enums')]] | None = (

480 strawberry_django.filter_field()

481 )

482

483

484@register_filter(models.PortMapping, lookups=True)

485class PortMappingFilter(BaseModelFilter):

486 device: Annotated['DeviceFilter', strawberry.lazy('dcim.graphql.filters')] | None = strawberry_django.filter_field()

487 front_port: Annotated['FrontPortFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

488 strawberry_django.filter_field()

489 )

490 rear_port: Annotated['RearPortFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

491 strawberry_django.filter_field()

492 )

493 front_port_position: FilterLookup[int] | None = strawberry_django.filter_field()

494 rear_port_position: FilterLookup[int] | None = strawberry_django.filter_field()

495

496

497@register_filter(models.PortTemplateMapping, lookups=True)

498class PortTemplateMappingFilter(BaseModelFilter):

499 device_type: Annotated['DeviceTypeFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

500 strawberry_django.filter_field()

501 )

502 module_type: Annotated['ModuleTypeFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

503 strawberry_django.filter_field()

504 )

505 front_port: Annotated['FrontPortTemplateFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

506 strawberry_django.filter_field()

507 )

508 rear_port: Annotated['RearPortTemplateFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

509 strawberry_django.filter_field()

510 )

511 front_port_position: FilterLookup[int] | None = strawberry_django.filter_field()

512 rear_port_position: FilterLookup[int] | None = strawberry_django.filter_field()

513

514

515@register_filter(models.MACAddress, lookups=True)

516class MACAddressFilter(PrimaryModelFilter):

517 mac_address: StrFilterLookup | None = strawberry_django.filter_field()

518 assigned_object_type: Annotated['ContentTypeFilter', strawberry.lazy('core.graphql.filters')] | None = (

519 strawberry_django.filter_field()

520 )

521 assigned_object_id: ID | None = strawberry_django.filter_field()

522

523 @strawberry_django.filter_field()

524 def assigned(self, value: bool, prefix) -> Q:

525 return Q(**{f'{prefix}assigned_object_id__isnull': (not value)})

526

527 @strawberry_django.filter_field()

528 def primary(self, value: bool, prefix) -> Q:

529 interface_mac_ids = models.Interface.objects.filter(primary_mac_address_id__isnull=False).values_list(

530 'primary_mac_address_id', flat=True

531 )

532 vminterface_mac_ids = VMInterface.objects.filter(primary_mac_address_id__isnull=False).values_list(

533 'primary_mac_address_id', flat=True

534 )

535 query = Q(**{f'{prefix}pk__in': interface_mac_ids}) | Q(**{f'{prefix}pk__in': vminterface_mac_ids})

536 if value:

537 return Q(query)

538 return ~Q(query)

539

540

541@register_filter(models.Interface, lookups=True)

542class InterfaceFilter(

543 ModularComponentFilterMixin,

544 InterfaceBaseFilterMixin,

545 CabledObjectModelFilterMixin,

546 NetBoxModelFilter

547):

548 vcdcs: Annotated['VirtualDeviceContextFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

549 strawberry_django.filter_field()

550 )

551 lag: Annotated['InterfaceFilter', strawberry.lazy('dcim.graphql.filters')] | None = strawberry_django.filter_field()

552 lag_id: ID | None = strawberry_django.filter_field()

553 type: BaseFilterLookup[Annotated['InterfaceTypeEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

554 strawberry_django.filter_field()

555 )

556 channels: Annotated['IntegerLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

557 strawberry_django.filter_field()

558 )

559 channel_id: Annotated['IntegerLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

560 strawberry_django.filter_field()

561 )

562 mgmt_only: FilterLookup[bool] | None = strawberry_django.filter_field()

563 speed: Annotated['BigIntegerLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

564 strawberry_django.filter_field()

565 )

566 duplex: BaseFilterLookup[Annotated['InterfaceDuplexEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

567 strawberry_django.filter_field()

568 )

569 wwn: StrFilterLookup | None = strawberry_django.filter_field()

570 parent: Annotated['InterfaceFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

571 strawberry_django.filter_field()

572 )

573 parent_id: ID | None = strawberry_django.filter_field()

574 rf_role: BaseFilterLookup[Annotated['WirelessRoleEnum', strawberry.lazy('wireless.graphql.enums')]] | None = (

575 strawberry_django.filter_field()

576 )

577 rf_channel: BaseFilterLookup[Annotated['WirelessChannelEnum', strawberry.lazy('wireless.graphql.enums')]] | None = (

578 strawberry_django.filter_field()

579 )

580 rf_channel_frequency: Annotated['FloatLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

581 strawberry_django.filter_field()

582 )

583 rf_channel_width: Annotated['FloatLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

584 strawberry_django.filter_field()

585 )

586 tx_power: Annotated['IntegerLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

587 strawberry_django.filter_field()

588 )

589 poe_mode: BaseFilterLookup[Annotated['InterfacePoEModeEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

590 strawberry_django.filter_field()

591 )

592 poe_type: BaseFilterLookup[Annotated['InterfacePoETypeEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

593 strawberry_django.filter_field()

594 )

595 wireless_link: Annotated['WirelessLinkFilter', strawberry.lazy('wireless.graphql.filters')] | None = (

596 strawberry_django.filter_field()

597 )

598 wireless_link_id: ID | None = strawberry_django.filter_field()

599 wireless_lans: Annotated['WirelessLANFilter', strawberry.lazy('wireless.graphql.filters')] | None = (

600 strawberry_django.filter_field()

601 )

602 vrf: Annotated['VRFFilter', strawberry.lazy('ipam.graphql.filters')] | None = strawberry_django.filter_field()

603 vrf_id: ID | None = strawberry_django.filter_field()

604 ip_addresses: Annotated['IPAddressFilter', strawberry.lazy('ipam.graphql.filters')] | None = (

605 strawberry_django.filter_field()

606 )

607 mac_addresses: Annotated['MACAddressFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

608 strawberry_django.filter_field()

609 )

610 fhrp_group_assignments: Annotated['FHRPGroupAssignmentFilter', strawberry.lazy('ipam.graphql.filters')] | None = (

611 strawberry_django.filter_field()

612 )

613 tunnel_terminations: Annotated['TunnelTerminationFilter', strawberry.lazy('vpn.graphql.filters')] | None = (

614 strawberry_django.filter_field()

615 )

616 l2vpn_terminations: Annotated['L2VPNFilter', strawberry.lazy('vpn.graphql.filters')] | None = (

617 strawberry_django.filter_field()

618 )

619

620 @strawberry_django.filter_field

621 def cabled(self, value: bool, prefix: str):

622 return Q(**{f'{prefix}cable__isnull': (not value)})

623

624 @strawberry_django.filter_field

625 def connected(self, queryset, value: bool, prefix: str):

626 if value is True:

627 return queryset, Q(**{f"{prefix}_path__is_active": True})

628 return queryset, Q(**{f"{prefix}_path__isnull": True}) | Q(**{f"{prefix}_path__is_active": False})

629

630 @strawberry_django.filter_field

631 def kind(

632 self,

633 queryset,

634 value: Annotated['InterfaceKindEnum', strawberry.lazy('dcim.graphql.enums')],

635 prefix: str

636 ):

637 if value == InterfaceKindEnum.KIND_PHYSICAL:

638 # A channel subinterface is excluded even if its type is otherwise connectable: it derives its cable

639 # from its channelized parent and cannot be cabled directly (matches Interface.is_wired).

640 return queryset, ~Q(**{f"{prefix}type__in": NONCONNECTABLE_IFACE_TYPES}) & Q(

641 **{f"{prefix}channel_id__isnull": True}

642 )

643 if value == InterfaceKindEnum.KIND_VIRTUAL:

644 return queryset, Q(**{f"{prefix}type__in": VIRTUAL_IFACE_TYPES})

645 if value == InterfaceKindEnum.KIND_WIRELESS:

646 return queryset, Q(**{f"{prefix}type__in": WIRELESS_IFACE_TYPES})

647 return queryset, Q()

648

649

650@register_filter(models.InterfaceTemplate, lookups=True)

651class InterfaceTemplateFilter(ModularComponentTemplateFilterMixin, ChangeLoggedModelFilter):

652 type: BaseFilterLookup[Annotated['InterfaceTypeEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

653 strawberry_django.filter_field()

654 )

655 channels: Annotated['IntegerLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

656 strawberry_django.filter_field()

657 )

658 channel_id: Annotated['IntegerLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

659 strawberry_django.filter_field()

660 )

661 enabled: FilterLookup[bool] | None = strawberry_django.filter_field()

662 mgmt_only: FilterLookup[bool] | None = strawberry_django.filter_field()

663 parent: Annotated['InterfaceTemplateFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

664 strawberry_django.filter_field()

665 )

666 parent_id: ID | None = strawberry_django.filter_field()

667 bridge: Annotated['InterfaceTemplateFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

668 strawberry_django.filter_field()

669 )

670 bridge_id: ID | None = strawberry_django.filter_field()

671 poe_mode: BaseFilterLookup[Annotated['InterfacePoEModeEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

672 strawberry_django.filter_field()

673 )

674 poe_type: BaseFilterLookup[Annotated['InterfacePoETypeEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

675 strawberry_django.filter_field()

676 )

677 rf_role: BaseFilterLookup[Annotated['WirelessRoleEnum', strawberry.lazy('wireless.graphql.enums')]] | None = (

678 strawberry_django.filter_field()

679 )

680

681

682@register_filter(models.InventoryItem, lookups=True)

683class InventoryItemFilter(ComponentModelFilterMixin, NetBoxModelFilter):

684 parent: Annotated['InventoryItemFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

685 strawberry_django.filter_field()

686 )

687 parent_id: ID | None = strawberry_django.filter_field()

688 component_type: Annotated['ContentTypeFilter', strawberry.lazy('core.graphql.filters')] | None = (

689 strawberry_django.filter_field()

690 )

691 component_id: ID | None = strawberry_django.filter_field()

692 status: BaseFilterLookup[Annotated['InventoryItemStatusEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

693 strawberry_django.filter_field()

694 )

695 role: Annotated['InventoryItemRoleFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

696 strawberry_django.filter_field()

697 )

698 role_id: ID | None = strawberry_django.filter_field()

699 manufacturer: Annotated['ManufacturerFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

700 strawberry_django.filter_field()

701 )

702 manufacturer_id: ID | None = strawberry_django.filter_field()

703 part_id: StrFilterLookup | None = strawberry_django.filter_field()

704 serial: StrFilterLookup | None = strawberry_django.filter_field()

705 asset_tag: StrFilterLookup | None = strawberry_django.filter_field()

706 discovered: FilterLookup[bool] | None = strawberry_django.filter_field()

707

708

709@register_filter(models.InventoryItemRole, lookups=True)

710class InventoryItemRoleFilter(OrganizationalModelFilter):

711 color: BaseFilterLookup[Annotated['ColorEnum', strawberry.lazy('netbox.graphql.enums')]] | None = (

712 strawberry_django.filter_field()

713 )

714

715

716@register_filter(models.Location, lookups=True)

717class LocationFilter(ContactFilterMixin, ImageAttachmentFilterMixin, TenancyFilterMixin, NestedGroupModelFilter):

718 site: Annotated['SiteFilter', strawberry.lazy('dcim.graphql.filters')] | None = strawberry_django.filter_field()

719 site_id: ID | None = strawberry_django.filter_field()

720 status: BaseFilterLookup[Annotated['LocationStatusEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

721 strawberry_django.filter_field()

722 )

723 facility: StrFilterLookup | None = strawberry_django.filter_field()

724 prefixes: Annotated['PrefixFilter', strawberry.lazy('ipam.graphql.filters')] | None = (

725 strawberry_django.filter_field()

726 )

727 vlan_groups: Annotated['VLANGroupFilter', strawberry.lazy('ipam.graphql.filters')] | None = (

728 strawberry_django.filter_field()

729 )

730

731

732@register_filter(models.Manufacturer, lookups=True)

733class ManufacturerFilter(ContactFilterMixin, OrganizationalModelFilter):

734 pass

735

736

737@register_filter(models.Module, lookups=True)

738class ModuleFilter(ConfigContextFilterMixin, PrimaryModelFilter):

739 device: Annotated['DeviceFilter', strawberry.lazy('dcim.graphql.filters')] | None = strawberry_django.filter_field()

740 device_id: ID | None = strawberry_django.filter_field()

741 module_bay: Annotated['ModuleBayFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

742 strawberry_django.filter_field()

743 )

744 module_bay_id: ID | None = strawberry_django.filter_field()

745 module_type: Annotated['ModuleTypeFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

746 strawberry_django.filter_field()

747 )

748 module_type_id: ID | None = strawberry_django.filter_field()

749 status: BaseFilterLookup[Annotated['ModuleStatusEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

750 strawberry_django.filter_field()

751 )

752 serial: StrFilterLookup | None = strawberry_django.filter_field()

753 asset_tag: StrFilterLookup | None = strawberry_django.filter_field()

754 consoleports: Annotated['ConsolePortFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

755 strawberry_django.filter_field(name='console_ports')

756 )

757 consoleserverports: Annotated['ConsoleServerPortFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

758 strawberry_django.filter_field(name='console_server_ports')

759 )

760 poweroutlets: Annotated['PowerOutletFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

761 strawberry_django.filter_field(name='power_outlets')

762 )

763 powerports: Annotated['PowerPortFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

764 strawberry_django.filter_field(name='power_ports')

765 )

766 interfaces: Annotated['InterfaceFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

767 strawberry_django.filter_field()

768 )

769 frontports: Annotated['FrontPortFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

770 strawberry_django.filter_field(name='front_ports')

771 )

772 rearports: Annotated['RearPortFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

773 strawberry_django.filter_field(name='rear_ports')

774 )

775 devicebays: Annotated['DeviceBayFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

776 strawberry_django.filter_field(name='device_bays')

777 )

778 modulebays: Annotated['ModuleBayFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

779 strawberry_django.filter_field(name='module_bays')

780 )

781 modules: Annotated['ModuleFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

782 strawberry_django.filter_field()

783 )

784

785

786@register_filter(models.ModuleBay, lookups=True)

787class ModuleBayFilter(ModularComponentFilterMixin, NetBoxModelFilter):

788 parent: Annotated['ModuleBayFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

789 strawberry_django.filter_field()

790 )

791 parent_id: ID | None = strawberry_django.filter_field()

792 position: StrFilterLookup | None = strawberry_django.filter_field()

793 enabled: FilterLookup[bool] | None = strawberry_django.filter_field()

794 module_bay_types: Annotated['ModuleBayTypeFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

795 strawberry_django.filter_field()

796 )

797 module_bay_type_id: ID | None = strawberry_django.filter_field()

798

799

800@register_filter(models.ModuleBayTemplate, lookups=True)

801class ModuleBayTemplateFilter(ModularComponentTemplateFilterMixin, ChangeLoggedModelFilter):

802 position: StrFilterLookup | None = strawberry_django.filter_field()

803 enabled: FilterLookup[bool] | None = strawberry_django.filter_field()

804 module_bay_types: Annotated['ModuleBayTypeFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

805 strawberry_django.filter_field()

806 )

807 module_bay_type_id: ID | None = strawberry_django.filter_field()

808

809

810@register_filter(models.ModuleBayType, lookups=True)

811class ModuleBayTypeFilter(PrimaryModelFilter):

812 name: StrFilterLookup | None = strawberry_django.filter_field()

813 slug: StrFilterLookup | None = strawberry_django.filter_field()

814 manufacturer: Annotated['ManufacturerFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

815 strawberry_django.filter_field()

816 )

817 manufacturer_id: ID | None = strawberry_django.filter_field()

818

819

820@register_filter(models.ModuleTypeProfile, lookups=True)

821class ModuleTypeProfileFilter(PrimaryModelFilter):

822 name: StrFilterLookup | None = strawberry_django.filter_field()

823

824

825@register_filter(models.ModuleType, lookups=True)

826class ModuleTypeFilter(ImageAttachmentFilterMixin, WeightFilterMixin, PrimaryModelFilter):

827 manufacturer: Annotated['ManufacturerFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

828 strawberry_django.filter_field()

829 )

830 manufacturer_id: ID | None = strawberry_django.filter_field()

831 profile: Annotated['ModuleTypeProfileFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

832 strawberry_django.filter_field()

833 )

834 profile_id: ID | None = strawberry_django.filter_field()

835 module_bay_types: Annotated['ModuleBayTypeFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

836 strawberry_django.filter_field()

837 )

838 module_bay_type_id: ID | None = strawberry_django.filter_field()

839 model: StrFilterLookup | None = strawberry_django.filter_field()

840 part_number: StrFilterLookup | None = strawberry_django.filter_field()

841 instances: Annotated['ModuleFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

842 strawberry_django.filter_field()

843 )

844 airflow: BaseFilterLookup[Annotated['ModuleAirflowEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

845 strawberry_django.filter_field()

846 )

847 cooling_method: BaseFilterLookup[Annotated['CoolingMethodEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

848 strawberry_django.filter_field()

849 )

850 end_of_life: DateFilterLookup | None = strawberry_django.filter_field()

851 consoleporttemplates: Annotated['ConsolePortTemplateFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

852 strawberry_django.filter_field(name='console_port_templates')

853 )

854 consoleserverporttemplates: (

855 Annotated['ConsoleServerPortTemplateFilter', strawberry.lazy('dcim.graphql.filters')] | None

856 ) = strawberry_django.filter_field(name='console_server_port_templates')

857 powerporttemplates: Annotated['PowerPortTemplateFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

858 strawberry_django.filter_field(name='power_port_templates')

859 )

860 poweroutlettemplates: Annotated['PowerOutletTemplateFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

861 strawberry_django.filter_field(name='power_outlet_templates')

862 )

863 interfacetemplates: Annotated['InterfaceTemplateFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

864 strawberry_django.filter_field(name='interface_templates')

865 )

866 frontporttemplates: Annotated['FrontPortTemplateFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

867 strawberry_django.filter_field(name='front_port_templates')

868 )

869 rearporttemplates: Annotated['RearPortTemplateFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

870 strawberry_django.filter_field(name='rear_port_templates')

871 )

872 devicebaytemplates: Annotated['DeviceBayTemplateFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

873 strawberry_django.filter_field(name='device_bay_templates')

874 )

875 modulebaytemplates: Annotated['ModuleBayTemplateFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

876 strawberry_django.filter_field(name='module_bay_templates')

877 )

878 module_count: ComparisonFilterLookup[int] | None = strawberry_django.filter_field()

879

880

881@register_filter(models.Platform, lookups=True)

882class PlatformFilter(OrganizationalModelFilter):

883 manufacturer: Annotated['ManufacturerFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

884 strawberry_django.filter_field()

885 )

886 manufacturer_id: ID | None = strawberry_django.filter_field()

887 config_template: Annotated['ConfigTemplateFilter', strawberry.lazy('extras.graphql.filters')] | None = (

888 strawberry_django.filter_field()

889 )

890 config_template_id: ID | None = strawberry_django.filter_field()

891

892

893@register_filter(models.PowerFeed, lookups=True)

894class PowerFeedFilter(CabledObjectModelFilterMixin, TenancyFilterMixin, PrimaryModelFilter):

895 power_panel: Annotated['PowerPanelFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

896 strawberry_django.filter_field()

897 )

898 power_panel_id: ID | None = strawberry_django.filter_field()

899 rack: Annotated['RackFilter', strawberry.lazy('dcim.graphql.filters')] | None = strawberry_django.filter_field()

900 rack_id: ID | None = strawberry_django.filter_field()

901 name: StrFilterLookup | None = strawberry_django.filter_field()

902 status: BaseFilterLookup[Annotated['PowerFeedStatusEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

903 strawberry_django.filter_field()

904 )

905 type: BaseFilterLookup[Annotated['PowerFeedTypeEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

906 strawberry_django.filter_field()

907 )

908 supply: BaseFilterLookup[Annotated['PowerFeedSupplyEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

909 strawberry_django.filter_field()

910 )

911 phase: BaseFilterLookup[Annotated['PowerFeedPhaseEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

912 strawberry_django.filter_field()

913 )

914 voltage: Annotated['IntegerLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

915 strawberry_django.filter_field()

916 )

917 amperage: Annotated['IntegerLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

918 strawberry_django.filter_field()

919 )

920 max_utilization: Annotated['IntegerLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

921 strawberry_django.filter_field()

922 )

923 available_power: Annotated['IntegerLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

924 strawberry_django.filter_field()

925 )

926

927

928@register_filter(models.PowerOutlet, lookups=True)

929class PowerOutletFilter(ModularComponentFilterMixin, CabledObjectModelFilterMixin, NetBoxModelFilter):

930 type: BaseFilterLookup[Annotated['PowerOutletTypeEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

931 strawberry_django.filter_field()

932 )

933 power_port: Annotated['PowerPortFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

934 strawberry_django.filter_field()

935 )

936 power_port_id: ID | None = strawberry_django.filter_field()

937 feed_leg: BaseFilterLookup[Annotated['PowerOutletFeedLegEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

938 strawberry_django.filter_field()

939 )

940 color: BaseFilterLookup[Annotated['ColorEnum', strawberry.lazy('netbox.graphql.enums')]] | None = (

941 strawberry_django.filter_field()

942 )

943 status: BaseFilterLookup[Annotated['PowerOutletStatusEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

944 strawberry_django.filter_field()

945 )

946

947

948@register_filter(models.PowerOutletTemplate, lookups=True)

949class PowerOutletTemplateFilter(ModularComponentTemplateFilterMixin, ChangeLoggedModelFilter):

950 type: BaseFilterLookup[Annotated['PowerOutletTypeEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

951 strawberry_django.filter_field()

952 )

953 power_port: Annotated['PowerPortTemplateFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

954 strawberry_django.filter_field()

955 )

956 power_port_id: ID | None = strawberry_django.filter_field()

957 feed_leg: BaseFilterLookup[Annotated['PowerOutletFeedLegEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

958 strawberry_django.filter_field()

959 )

960

961

962@register_filter(models.PowerPanel, lookups=True)

963class PowerPanelFilter(ContactFilterMixin, ImageAttachmentFilterMixin, PrimaryModelFilter):

964 site: Annotated['SiteFilter', strawberry.lazy('dcim.graphql.filters')] | None = strawberry_django.filter_field()

965 site_id: ID | None = strawberry_django.filter_field()

966 location: Annotated['LocationFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

967 strawberry_django.filter_field()

968 )

969 location_id: Annotated['TreeNodeFilter', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

970 strawberry_django.filter_field()

971 )

972 name: StrFilterLookup | None = strawberry_django.filter_field()

973

974

975@register_filter(models.PowerPort, lookups=True)

976class PowerPortFilter(ModularComponentFilterMixin, CabledObjectModelFilterMixin, NetBoxModelFilter):

977 type: BaseFilterLookup[Annotated['PowerPortTypeEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

978 strawberry_django.filter_field()

979 )

980 maximum_draw: Annotated['IntegerLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

981 strawberry_django.filter_field()

982 )

983 allocated_draw: Annotated['IntegerLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

984 strawberry_django.filter_field()

985 )

986

987

988@register_filter(models.PowerPortTemplate, lookups=True)

989class PowerPortTemplateFilter(ModularComponentTemplateFilterMixin, ChangeLoggedModelFilter):

990 type: BaseFilterLookup[Annotated['PowerPortTypeEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

991 strawberry_django.filter_field()

992 )

993 maximum_draw: Annotated['IntegerLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

994 strawberry_django.filter_field()

995 )

996 allocated_draw: Annotated['IntegerLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

997 strawberry_django.filter_field()

998 )

999

1000

1001@register_filter(models.CoolingFeed, lookups=True)

1002class CoolingFeedFilter(TenancyFilterMixin, PrimaryModelFilter):

1003 cooling_source: Annotated['CoolingSourceFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

1004 strawberry_django.filter_field()

1005 )

1006 cooling_source_id: ID | None = strawberry_django.filter_field()

1007 rack: Annotated['RackFilter', strawberry.lazy('dcim.graphql.filters')] | None = strawberry_django.filter_field()

1008 rack_id: ID | None = strawberry_django.filter_field()

1009 name: StrFilterLookup | None = strawberry_django.filter_field()

1010 status: BaseFilterLookup[Annotated['CoolingFeedStatusEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

1011 strawberry_django.filter_field()

1012 )

1013 cooling_capacity: Annotated['FloatLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

1014 strawberry_django.filter_field()

1015 )

1016 max_flow: Annotated['FloatLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

1017 strawberry_django.filter_field()

1018 )

1019 max_flow_unit: (

1020 BaseFilterLookup[Annotated['FlowRateUnitEnum', strawberry.lazy('dcim.graphql.enums')]] | None

1021 ) = strawberry_django.filter_field()

1022

1023

1024@register_filter(models.CoolingOutflow, lookups=True)

1025class CoolingOutflowFilter(ModularComponentFilterMixin, NetBoxModelFilter):

1026 type: BaseFilterLookup[

1027 Annotated['CoolingConnectorTypeEnum', strawberry.lazy('dcim.graphql.enums')]

1028 ] | None = strawberry_django.filter_field()

1029 diameter: Annotated['FloatLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

1030 strawberry_django.filter_field()

1031 )

1032 diameter_unit: BaseFilterLookup[Annotated['DiameterUnitEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

1033 strawberry_django.filter_field()

1034 )

1035 cooling_intake: Annotated['CoolingIntakeFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

1036 strawberry_django.filter_field()

1037 )

1038 cooling_intake_id: ID | None = strawberry_django.filter_field()

1039

1040

1041@register_filter(models.CoolingOutflowTemplate, lookups=True)

1042class CoolingOutflowTemplateFilter(ModularComponentTemplateFilterMixin, ChangeLoggedModelFilter):

1043 type: BaseFilterLookup[

1044 Annotated['CoolingConnectorTypeEnum', strawberry.lazy('dcim.graphql.enums')]

1045 ] | None = strawberry_django.filter_field()

1046 diameter: Annotated['FloatLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

1047 strawberry_django.filter_field()

1048 )

1049 diameter_unit: BaseFilterLookup[Annotated['DiameterUnitEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

1050 strawberry_django.filter_field()

1051 )

1052 cooling_intake: Annotated['CoolingIntakeTemplateFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

1053 strawberry_django.filter_field()

1054 )

1055 cooling_intake_id: ID | None = strawberry_django.filter_field()

1056

1057

1058@register_filter(models.CoolingIntake, lookups=True)

1059class CoolingIntakeFilter(ModularComponentFilterMixin, NetBoxModelFilter):

1060 type: BaseFilterLookup[

1061 Annotated['CoolingConnectorTypeEnum', strawberry.lazy('dcim.graphql.enums')]

1062 ] | None = strawberry_django.filter_field()

1063 diameter: Annotated['FloatLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

1064 strawberry_django.filter_field()

1065 )

1066 diameter_unit: BaseFilterLookup[Annotated['DiameterUnitEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

1067 strawberry_django.filter_field()

1068 )

1069 max_flow: Annotated['FloatLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

1070 strawberry_django.filter_field()

1071 )

1072 max_flow_unit: BaseFilterLookup[

1073 Annotated['FlowRateUnitEnum', strawberry.lazy('dcim.graphql.enums')]

1074 ] | None = strawberry_django.filter_field()

1075 cooling_outflow: Annotated['CoolingOutflowFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

1076 strawberry_django.filter_field()

1077 )

1078 cooling_outflow_id: ID | None = strawberry_django.filter_field()

1079

1080

1081@register_filter(models.CoolingIntakeTemplate, lookups=True)

1082class CoolingIntakeTemplateFilter(ModularComponentTemplateFilterMixin, ChangeLoggedModelFilter):

1083 type: BaseFilterLookup[

1084 Annotated['CoolingConnectorTypeEnum', strawberry.lazy('dcim.graphql.enums')]

1085 ] | None = strawberry_django.filter_field()

1086 diameter: Annotated['FloatLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

1087 strawberry_django.filter_field()

1088 )

1089 diameter_unit: BaseFilterLookup[Annotated['DiameterUnitEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

1090 strawberry_django.filter_field()

1091 )

1092 max_flow: Annotated['FloatLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

1093 strawberry_django.filter_field()

1094 )

1095 max_flow_unit: BaseFilterLookup[

1096 Annotated['FlowRateUnitEnum', strawberry.lazy('dcim.graphql.enums')]

1097 ] | None = strawberry_django.filter_field()

1098

1099

1100@register_filter(models.CoolingSource, lookups=True)

1101class CoolingSourceFilter(ContactFilterMixin, ImageAttachmentFilterMixin, PrimaryModelFilter):

1102 site: Annotated['SiteFilter', strawberry.lazy('dcim.graphql.filters')] | None = strawberry_django.filter_field()

1103 site_id: ID | None = strawberry_django.filter_field()

1104 location: Annotated['LocationFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

1105 strawberry_django.filter_field()

1106 )

1107 location_id: Annotated['TreeNodeFilter', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

1108 strawberry_django.filter_field()

1109 )

1110 name: StrFilterLookup | None = strawberry_django.filter_field()

1111 type: BaseFilterLookup[Annotated['CoolingSourceTypeEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

1112 strawberry_django.filter_field()

1113 )

1114 status: BaseFilterLookup[Annotated['CoolingSourceStatusEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

1115 strawberry_django.filter_field()

1116 )

1117 fluid_type: BaseFilterLookup[Annotated['FluidTypeEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

1118 strawberry_django.filter_field()

1119 )

1120 cooling_capacity: Annotated['FloatLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

1121 strawberry_django.filter_field()

1122 )

1123

1124

1125@register_filter(models.RackType, lookups=True)

1126class RackTypeFilter(ImageAttachmentFilterMixin, RackFilterMixin, WeightFilterMixin, PrimaryModelFilter):

1127 form_factor: BaseFilterLookup[Annotated['RackFormFactorEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

1128 strawberry_django.filter_field()

1129 )

1130 manufacturer: Annotated['ManufacturerFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

1131 strawberry_django.filter_field()

1132 )

1133 manufacturer_id: ID | None = strawberry_django.filter_field()

1134 model: StrFilterLookup | None = strawberry_django.filter_field()

1135 slug: StrFilterLookup | None = strawberry_django.filter_field()

1136 racks: Annotated['RackFilter', strawberry.lazy('dcim.graphql.filters')] | None = strawberry_django.filter_field()

1137 rack_count: ComparisonFilterLookup[int] | None = strawberry_django.filter_field()

1138

1139

1140@register_filter(models.Rack, lookups=True)

1141class RackFilter(

1142 ContactFilterMixin,

1143 ImageAttachmentFilterMixin,

1144 TenancyFilterMixin,

1145 WeightFilterMixin,

1146 RackFilterMixin,

1147 PrimaryModelFilter

1148):

1149 form_factor: BaseFilterLookup[Annotated['RackFormFactorEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

1150 strawberry_django.filter_field()

1151 )

1152 rack_type: Annotated['RackTypeFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

1153 strawberry_django.filter_field()

1154 )

1155 rack_type_id: ID | None = strawberry_django.filter_field()

1156 name: StrFilterLookup | None = strawberry_django.filter_field()

1157 facility_id: StrFilterLookup | None = strawberry_django.filter_field()

1158 site: Annotated['SiteFilter', strawberry.lazy('dcim.graphql.filters')] | None = strawberry_django.filter_field()

1159 site_id: ID | None = strawberry_django.filter_field()

1160 location: Annotated['LocationFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

1161 strawberry_django.filter_field()

1162 )

1163 location_id: Annotated['TreeNodeFilter', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

1164 strawberry_django.filter_field()

1165 )

1166 group: Annotated['RackGroupFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

1167 strawberry_django.filter_field()

1168 )

1169 group_id: ID | None = strawberry_django.filter_field()

1170 status: BaseFilterLookup[Annotated['RackStatusEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

1171 strawberry_django.filter_field()

1172 )

1173 role: Annotated['RackRoleFilter', strawberry.lazy('dcim.graphql.filters')] | None = strawberry_django.filter_field()

1174 role_id: ID | None = strawberry_django.filter_field()

1175 serial: StrFilterLookup | None = strawberry_django.filter_field()

1176 asset_tag: StrFilterLookup | None = strawberry_django.filter_field()

1177 airflow: BaseFilterLookup[Annotated['RackAirflowEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

1178 strawberry_django.filter_field()

1179 )

1180 vlan_groups: Annotated['VLANGroupFilter', strawberry.lazy('ipam.graphql.filters')] | None = (

1181 strawberry_django.filter_field()

1182 )

1183

1184

1185@register_filter(models.RackGroup, lookups=True)

1186class RackGroupFilter(OrganizationalModelFilter):

1187 pass

1188

1189

1190@register_filter(models.RackReservation, lookups=True)

1191class RackReservationFilter(TenancyFilterMixin, PrimaryModelFilter):

1192 rack: Annotated['RackFilter', strawberry.lazy('dcim.graphql.filters')] | None = strawberry_django.filter_field()

1193 rack_id: ID | None = strawberry_django.filter_field()

1194 units: Annotated['IntegerArrayLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

1195 strawberry_django.filter_field()

1196 )

1197 unit_count: ComparisonFilterLookup[int] | None = strawberry_django.filter_field()

1198 user: Annotated['UserFilter', strawberry.lazy('users.graphql.filters')] | None = strawberry_django.filter_field()

1199 user_id: ID | None = strawberry_django.filter_field()

1200 description: StrFilterLookup | None = strawberry_django.filter_field()

1201 status: BaseFilterLookup[Annotated['RackReservationStatusEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

1202 strawberry_django.filter_field()

1203 )

1204

1205

1206@register_filter(models.RackRole, lookups=True)

1207class RackRoleFilter(OrganizationalModelFilter):

1208 color: BaseFilterLookup[Annotated['ColorEnum', strawberry.lazy('netbox.graphql.enums')]] | None = (

1209 strawberry_django.filter_field()

1210 )

1211

1212

1213@register_filter(models.RearPort, lookups=True)

1214class RearPortFilter(ModularComponentFilterMixin, CabledObjectModelFilterMixin, NetBoxModelFilter):

1215 type: BaseFilterLookup[Annotated['PortTypeEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

1216 strawberry_django.filter_field()

1217 )

1218 color: BaseFilterLookup[Annotated['ColorEnum', strawberry.lazy('netbox.graphql.enums')]] | None = (

1219 strawberry_django.filter_field()

1220 )

1221 positions: Annotated['IntegerLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

1222 strawberry_django.filter_field()

1223 )

1224

1225

1226@register_filter(models.RearPortTemplate, lookups=True)

1227class RearPortTemplateFilter(ModularComponentTemplateFilterMixin, ChangeLoggedModelFilter):

1228 type: BaseFilterLookup[Annotated['PortTypeEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

1229 strawberry_django.filter_field()

1230 )

1231 color: BaseFilterLookup[Annotated['ColorEnum', strawberry.lazy('netbox.graphql.enums')]] | None = (

1232 strawberry_django.filter_field()

1233 )

1234 positions: Annotated['IntegerLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

1235 strawberry_django.filter_field()

1236 )

1237

1238

1239@register_filter(models.Region, lookups=True)

1240class RegionFilter(ContactFilterMixin, NestedGroupModelFilter):

1241 prefixes: Annotated['PrefixFilter', strawberry.lazy('ipam.graphql.filters')] | None = (

1242 strawberry_django.filter_field()

1243 )

1244 vlan_groups: Annotated['VLANGroupFilter', strawberry.lazy('ipam.graphql.filters')] | None = (

1245 strawberry_django.filter_field()

1246 )

1247

1248

1249@register_filter(models.Site, lookups=True)

1250class SiteFilter(ContactFilterMixin, ImageAttachmentFilterMixin, TenancyFilterMixin, PrimaryModelFilter):

1251 name: StrFilterLookup | None = strawberry_django.filter_field()

1252 slug: StrFilterLookup | None = strawberry_django.filter_field()

1253 status: BaseFilterLookup[Annotated['SiteStatusEnum', strawberry.lazy('dcim.graphql.enums')]] | None = (

1254 strawberry_django.filter_field()

1255 )

1256 region: Annotated['RegionFilter', strawberry.lazy('dcim.graphql.filters')] | None = strawberry_django.filter_field()

1257 region_id: Annotated['TreeNodeFilter', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

1258 strawberry_django.filter_field()

1259 )

1260 group: Annotated['SiteGroupFilter', strawberry.lazy('dcim.graphql.filters')] | None = (

1261 strawberry_django.filter_field()

1262 )

1263 group_id: Annotated['TreeNodeFilter', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

1264 strawberry_django.filter_field()

1265 )

1266 facility: StrFilterLookup | None = strawberry_django.filter_field()

1267 asns: Annotated['ASNFilter', strawberry.lazy('ipam.graphql.filters')] | None = strawberry_django.filter_field()

1268 time_zone: StrFilterLookup | None = strawberry_django.filter_field()

1269 physical_address: StrFilterLookup | None = strawberry_django.filter_field()

1270 shipping_address: StrFilterLookup | None = strawberry_django.filter_field()

1271 latitude: Annotated['FloatLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

1272 strawberry_django.filter_field()

1273 )

1274 longitude: Annotated['FloatLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

1275 strawberry_django.filter_field()

1276 )

1277 prefixes: Annotated['PrefixFilter', strawberry.lazy('ipam.graphql.filters')] | None = (

1278 strawberry_django.filter_field()

1279 )

1280 vlan_groups: Annotated['VLANGroupFilter', strawberry.lazy('ipam.graphql.filters')] | None = (

1281 strawberry_django.filter_field()

1282 )

1283

1284

1285@register_filter(models.SiteGroup, lookups=True)

1286class SiteGroupFilter(ContactFilterMixin, NestedGroupModelFilter):

1287 prefixes: Annotated['PrefixFilter', strawberry.lazy('ipam.graphql.filters')] | None = (

1288 strawberry_django.filter_field()

1289 )

1290 vlan_groups: Annotated['VLANGroupFilter', strawberry.lazy('ipam.graphql.filters')] | None = (

1291 strawberry_django.filter_field()

1292 )

1293

1294

1295@register_filter(models.VirtualChassis, lookups=True)

1296class VirtualChassisFilter(PrimaryModelFilter):

1297 master: Annotated['DeviceFilter', strawberry.lazy('dcim.graphql.filters')] | None = strawberry_django.filter_field()

1298 master_id: ID | None = strawberry_django.filter_field()

1299 name: StrFilterLookup | None = strawberry_django.filter_field()

1300 domain: StrFilterLookup | None = strawberry_django.filter_field()

1301 members: (

1302 Annotated['DeviceFilter', strawberry.lazy('dcim.graphql.filters')] | None

1303 ) = strawberry_django.filter_field()

1304 member_count: FilterLookup[int] | None = strawberry_django.filter_field()

1305

1306

1307@register_filter(models.VirtualDeviceContext, lookups=True)

1308class VirtualDeviceContextFilter(TenancyFilterMixin, PrimaryModelFilter):

1309 device: Annotated['DeviceFilter', strawberry.lazy('dcim.graphql.filters')] | None = strawberry_django.filter_field()

1310 device_id: ID | None = strawberry_django.filter_field()

1311 name: StrFilterLookup | None = strawberry_django.filter_field()

1312 status: (

1313 BaseFilterLookup[Annotated['VirtualDeviceContextStatusEnum', strawberry.lazy('dcim.graphql.enums')]] | None

1314 ) = (

1315 strawberry_django.filter_field()

1316 )

1317 identifier: Annotated['IntegerLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (

1318 strawberry_django.filter_field()

1319 )

1320 primary_ip4: Annotated['IPAddressFilter', strawberry.lazy('ipam.graphql.filters')] | None = (

1321 strawberry_django.filter_field()

1322 )

1323 primary_ip4_id: ID | None = strawberry_django.filter_field()

1324 primary_ip6: Annotated['IPAddressFilter', strawberry.lazy('ipam.graphql.filters')] | None = (

1325 strawberry_django.filter_field()

1326 )

1327 primary_ip6_id: ID | None = strawberry_django.filter_field()

1328 comments: StrFilterLookup | None = strawberry_django.filter_field()

1329 interfaces: (

1330 Annotated['InterfaceFilter', strawberry.lazy('dcim.graphql.filters')] | None

1331 ) = strawberry_django.filter_field()