content: from django import forms
  from django.contrib.contenttypes.models import ContentType
  from django.contrib.postgres.forms.array import SimpleArrayField
  from django.core.exceptions import ObjectDoesNotExist
  from django.utils.safestring import mark_safe
  from django.utils.translation import gettext_lazy as _
  
  from dcim.choices import *
  from dcim.constants import *
  from dcim.models import *
  from extras.models import ConfigTemplate
  from ipam.choices import VLANQinQRoleChoices
  from ipam.models import VLAN, VRF, IPAddress, VLANGroup
  from netbox.choices import *
  from netbox.forms import NetBoxModelImportForm
  from tenancy.models import Tenant
  from utilities.forms.fields import (
      CSVChoiceField, CSVContentTypeField, CSVModelChoiceField, CSVModelMultipleChoiceField, CSVTypedChoiceField,
      SlugField,
  )
  from virtualization.models import Cluster, VirtualMachine, VMInterface
  from wireless.choices import WirelessRoleChoices
  from .common import ModuleCommonForm
  
  __all__ = (
      'CableImportForm',
      'ConsolePortImportForm',
      'ConsoleServerPortImportForm',
      'DeviceBayImportForm',
      'DeviceImportForm',
      'DeviceRoleImportForm',
      'DeviceTypeImportForm',
      'FrontPortImportForm',
      'InterfaceImportForm',
      'InventoryItemImportForm',
      'InventoryItemRoleImportForm',
      'LocationImportForm',
      'MACAddressImportForm',
      'ManufacturerImportForm',
      'ModuleImportForm',
      'ModuleBayImportForm',
      'ModuleTypeImportForm',
      'ModuleTypeProfileImportForm',
      'PlatformImportForm',
      'PowerFeedImportForm',
      'PowerOutletImportForm',
      'PowerPanelImportForm',
      'PowerPortImportForm',
      'RackImportForm',
      'RackReservationImportForm',
      'RackRoleImportForm',
      'RackTypeImportForm',
      'RearPortImportForm',
      'RegionImportForm',
      'SiteImportForm',
      'SiteGroupImportForm',
      'VirtualChassisImportForm',
      'VirtualDeviceContextImportForm'
  )
  
  
  class RegionImportForm(NetBoxModelImportForm):
      parent = CSVModelChoiceField(
          label=_('Parent'),
          queryset=Region.objects.all(),
          required=False,
          to_field_name='name',
          help_text=_('Name of parent region')
      )
  
      class Meta:
          model = Region
          fields = ('name', 'slug', 'parent', 'description', 'tags', 'comments')
  
  
  class SiteGroupImportForm(NetBoxModelImportForm):
      parent = CSVModelChoiceField(
          label=_('Parent'),
          queryset=SiteGroup.objects.all(),
          required=False,
          to_field_name='name',
          help_text=_('Name of parent site group')
      )
  
      class Meta:
          model = SiteGroup
          fields = ('name', 'slug', 'parent', 'description', 'comments', 'tags')
  
  
  class SiteImportForm(NetBoxModelImportForm):
      status = CSVChoiceField(
          label=_('Status'),
          choices=SiteStatusChoices,
          help_text=_('Operational status')
      )
      region = CSVModelChoiceField(
          label=_('Region'),
          queryset=Region.objects.all(),
          required=False,
          to_field_name='name',
          help_text=_('Assigned region')
      )
      group = CSVModelChoiceField(
          label=_('Group'),
          queryset=SiteGroup.objects.all(),
          required=False,
          to_field_name='name',
          help_text=_('Assigned group')
      )
      tenant = CSVModelChoiceField(
          label=_('Tenant'),
          queryset=Tenant.objects.all(),
          required=False,
          to_field_name='name',
          help_text=_('Assigned tenant')
      )
  
      class Meta:
          model = Site
          fields = (
              'name', 'slug', 'status', 'region', 'group', 'tenant', 'facility', 'time_zone', 'description',
              'physical_address', 'shipping_address', 'latitude', 'longitude', 'comments', 'tags'
          )
          help_texts = {
              'time_zone': mark_safe(
                  '{} (<a href="https://en.wikipedia.org/wiki/List_of_tz_database_time_zones">{}</a>)'.format(
                      _('Time zone'), _('available options')
                  )
              )
          }
  
  
  class LocationImportForm(NetBoxModelImportForm):
      site = CSVModelChoiceField(
          label=_('Site'),
          queryset=Site.objects.all(),
          to_field_name='name',
          help_text=_('Assigned site')
      )
      parent = CSVModelChoiceField(
          label=_('Parent'),
          queryset=Location.objects.all(),
          required=False,
          to_field_name='name',
          help_text=_('Parent location'),
          error_messages={
              'invalid_choice': _('Location not found.'),
          }
      )
      status = CSVChoiceField(
          label=_('Status'),
          choices=LocationStatusChoices,
          help_text=_('Operational status')
      )
      tenant = CSVModelChoiceField(
          label=_('Tenant'),
          queryset=Tenant.objects.all(),
          required=False,
          to_field_name='name',
          help_text=_('Assigned tenant')
      )
  
      class Meta:
          model = Location
          fields = (
              'site', 'parent', 'name', 'slug', 'status', 'tenant', 'facility', 'description',
              'tags', 'comments',
          )
  
      def __init__(self, data=None, *args, **kwargs):
          super().__init__(data, *args, **kwargs)
  
          if data:
              # Limit location queryset by assigned site
              params = {f"site__{self.fields['site'].to_field_name}": data.get('site')}
              self.fields['parent'].queryset = self.fields['parent'].queryset.filter(**params)
  
  
  class RackRoleImportForm(NetBoxModelImportForm):
      slug = SlugField()
  
      class Meta:
          model = RackRole
          fields = ('name', 'slug', 'color', 'description', 'tags')
  
  
  class RackTypeImportForm(NetBoxModelImportForm):
      manufacturer = forms.ModelChoiceField(
          label=_('Manufacturer'),
          queryset=Manufacturer.objects.all(),
          to_field_name='name',
          help_text=_('The manufacturer of this rack type')
      )
      form_factor = CSVChoiceField(
          label=_('Type'),
          choices=RackFormFactorChoices,
          required=False,
          help_text=_('Form factor')
      )
      starting_unit = forms.IntegerField(
          required=False,
          min_value=1,
          help_text=_('The lowest-numbered position in the rack')
      )
      width = forms.ChoiceField(
          label=_('Width'),
          choices=RackWidthChoices,
          help_text=_('Rail-to-rail width (in inches)')
      )
      outer_unit = CSVChoiceField(
          label=_('Outer unit'),
          choices=RackDimensionUnitChoices,
          required=False,
          help_text=_('Unit for outer dimensions')
      )
      weight_unit = CSVChoiceField(
          label=_('Weight unit'),
          choices=WeightUnitChoices,
          required=False,
          help_text=_('Unit for rack weights')
      )
  
      class Meta:
          model = RackType
          fields = (
              'manufacturer', 'model', 'slug', 'form_factor', 'width', 'u_height', 'starting_unit', 'desc_units',
              'outer_width', 'outer_height', 'outer_depth', 'outer_unit', 'mounting_depth', 'weight', 'max_weight',
              'weight_unit', 'description', 'comments', 'tags',
          )
  
      def __init__(self, data=None, *args, **kwargs):
          super().__init__(data, *args, **kwargs)
  
  
  class RackImportForm(NetBoxModelImportForm):
      site = CSVModelChoiceField(
          label=_('Site'),
          queryset=Site.objects.all(),
          to_field_name='name'
      )
      location = CSVModelChoiceField(
          label=_('Location'),
          queryset=Location.objects.all(),
          required=False,
          to_field_name='name'
      )
      tenant = CSVModelChoiceField(
          label=_('Tenant'),
          queryset=Tenant.objects.all(),
          required=False,
          to_field_name='name',
          help_text=_('Name of assigned tenant')
      )
      status = CSVChoiceField(
          label=_('Status'),
          choices=RackStatusChoices,
          help_text=_('Operational status')
      )
      role = CSVModelChoiceField(
          label=_('Role'),
          queryset=RackRole.objects.all(),
          required=False,
          to_field_name='name',
          help_text=_('Name of assigned role')
      )
      rack_type = CSVModelChoiceField(
          label=_('Rack type'),
          queryset=RackType.objects.all(),
          to_field_name='model',
          required=False,
          help_text=_('Rack type model')
      )
      form_factor = CSVChoiceField(
          label=_('Type'),
          choices=RackFormFactorChoices,
          required=False,
          help_text=_('Form factor')
      )
      width = forms.ChoiceField(
          label=_('Width'),
          choices=RackWidthChoices,
          required=False,
          help_text=_('Rail-to-rail width (in inches)')
      )
      u_height = forms.IntegerField(
          required=False,
          label=_('Height (U)')
      )
      outer_unit = CSVChoiceField(
          label=_('Outer unit'),
          choices=RackDimensionUnitChoices,
          required=False,
          help_text=_('Unit for outer dimensions')
      )
      airflow = CSVChoiceField(
          label=_('Airflow'),
          choices=RackAirflowChoices,
          required=False,
          help_text=_('Airflow direction')
      )
      weight_unit = CSVChoiceField(
          label=_('Weight unit'),
          choices=WeightUnitChoices,
          required=False,
          help_text=_('Unit for rack weights')
      )
  
      class Meta:
          model = Rack
          fields = (
              'site', 'location', 'name', 'facility_id', 'tenant', 'status', 'role', 'rack_type', 'form_factor', 'serial',
              'asset_tag', 'width', 'u_height', 'desc_units', 'outer_width', 'outer_height', 'outer_depth', 'outer_unit',
              'mounting_depth', 'airflow', 'weight', 'max_weight', 'weight_unit', 'description', 'comments', 'tags',
          )
  
      def __init__(self, data=None, *args, **kwargs):
          super().__init__(data, *args, **kwargs)
  
          if data:
  
              # Limit location queryset by assigned site
              params = {f"site__{self.fields['site'].to_field_name}": data.get('site')}
              self.fields['location'].queryset = self.fields['location'].queryset.filter(**params)
  
      def clean(self):
          super().clean()
  
          # width & u_height must be set if not specifying a rack type on import
          if not self.instance.pk:
              if not self.cleaned_data.get('rack_type') and not self.cleaned_data.get('width'):
                  raise forms.ValidationError(_("Width must be set if not specifying a rack type."))
              if not self.cleaned_data.get('rack_type') and not self.cleaned_data.get('u_height'):
                  raise forms.ValidationError(_("U height must be set if not specifying a rack type."))
  
  
  class RackReservationImportForm(NetBoxModelImportForm):
      site = CSVModelChoiceField(
          label=_('Site'),
          queryset=Site.objects.all(),
          to_field_name='name',
          help_text=_('Parent site')
      )
      location = CSVModelChoiceField(
          label=_('Location'),
          queryset=Location.objects.all(),
          to_field_name='name',
          required=False,
          help_text=_("Rack's location (if any)")
      )
      rack = CSVModelChoiceField(
          label=_('Rack'),
          queryset=Rack.objects.all(),
          to_field_name='name',
          help_text=_('Rack')
      )
      units = SimpleArrayField(
          label=_('Units'),
          base_field=forms.IntegerField(),
          required=True,
          help_text=_('Comma-separated list of individual unit numbers')
      )
      status = CSVChoiceField(
          label=_('Status'),
          choices=RackReservationStatusChoices,
          help_text=_('Operational status')
      )
      tenant = CSVModelChoiceField(
          label=_('Tenant'),
          queryset=Tenant.objects.all(),
          required=False,
          to_field_name='name',
          help_text=_('Assigned tenant')
      )
  
      class Meta:
          model = RackReservation
          fields = ('site', 'location', 'rack', 'units', 'status', 'tenant', 'description', 'comments', 'tags')
  
      def __init__(self, data=None, *args, **kwargs):
          super().__init__(data, *args, **kwargs)
  
          if data:
  
              # Limit location queryset by assigned site
              params = {f"site__{self.fields['site'].to_field_name}": data.get('site')}
              self.fields['location'].queryset = self.fields['location'].queryset.filter(**params)
  
              # Limit rack queryset by assigned site and group
              params = {
                  f"site__{self.fields['site'].to_field_name}": data.get('site'),
                  f"location__{self.fields['location'].to_field_name}": data.get('location'),
              }
              self.fields['rack'].queryset = self.fields['rack'].queryset.filter(**params)
  
  
  class ManufacturerImportForm(NetBoxModelImportForm):
  
      class Meta:
          model = Manufacturer
          fields = ('name', 'slug', 'description', 'tags')
  
  
  class DeviceTypeImportForm(NetBoxModelImportForm):
      manufacturer = CSVModelChoiceField(
          label=_('Manufacturer'),
          queryset=Manufacturer.objects.all(),
          to_field_name='name',
          help_text=_('The manufacturer which produces this device type')
      )
      default_platform = CSVModelChoiceField(
          label=_('Default platform'),
          queryset=Platform.objects.all(),
          to_field_name='name',
          required=False,
          help_text=_('The default platform for devices of this type (optional)')
      )
      weight = forms.DecimalField(
          label=_('Weight'),
          required=False,
          help_text=_('Device weight'),
      )
      weight_unit = CSVChoiceField(
          label=_('Weight unit'),
          choices=WeightUnitChoices,
          required=False,
          help_text=_('Unit for device weight')
      )
  
      class Meta:
          model = DeviceType
          fields = [
              'manufacturer', 'default_platform', 'model', 'slug', 'part_number', 'u_height', 'exclude_from_utilization',
              'is_full_depth', 'subdevice_role', 'airflow', 'description', 'weight', 'weight_unit', 'comments', 'tags',
          ]
  
  
  class ModuleTypeProfileImportForm(NetBoxModelImportForm):
  
      class Meta:
          model = ModuleTypeProfile
          fields = [
              'name', 'description', 'schema', 'comments', 'tags',
          ]
  
  
  class ModuleTypeImportForm(NetBoxModelImportForm):
      profile = forms.ModelChoiceField(
          label=_('Profile'),
          queryset=ModuleTypeProfile.objects.all(),
          to_field_name='name',
          required=False
      )
      manufacturer = forms.ModelChoiceField(
          label=_('Manufacturer'),
          queryset=Manufacturer.objects.all(),
          to_field_name='name'
      )
      airflow = CSVChoiceField(
          label=_('Airflow'),
          choices=ModuleAirflowChoices,
          required=False,
          help_text=_('Airflow direction')
      )
      weight = forms.DecimalField(
          label=_('Weight'),
          required=False,
          help_text=_('Module weight'),
      )
      weight_unit = CSVChoiceField(
          label=_('Weight unit'),
          choices=WeightUnitChoices,
          required=False,
          help_text=_('Unit for module weight')
      )
      attribute_data = forms.JSONField(
          label=_('Attributes'),
          required=False,
          help_text=_('Attribute values for the assigned profile, passed as a dictionary')
      )
  
      class Meta:
          model = ModuleType
          fields = [
              'manufacturer', 'model', 'part_number', 'description', 'airflow', 'weight', 'weight_unit', 'profile',
              'attribute_data', 'comments', 'tags',
          ]
  
      def clean(self):
          super().clean()
  
          # Attribute data may be included only if a profile is specified
          if self.cleaned_data.get('attribute_data') and not self.cleaned_data.get('profile'):
              raise forms.ValidationError(_("Profile must be specified if attribute data is provided."))
  
          # Default attribute_data to an empty dictionary if a profile is specified (to enforce schema validation)
          if self.cleaned_data.get('profile') and not self.cleaned_data.get('attribute_data'):
              self.cleaned_data['attribute_data'] = {}
  
  
  class DeviceRoleImportForm(NetBoxModelImportForm):
      parent = CSVModelChoiceField(
          label=_('Parent'),
          queryset=DeviceRole.objects.all(),
          required=False,
          to_field_name='name',
          help_text=_('Parent Device Role'),
          error_messages={
              'invalid_choice': _('Device role not found.'),
          }
      )
      config_template = CSVModelChoiceField(
          label=_('Config template'),
          queryset=ConfigTemplate.objects.all(),
          to_field_name='name',
          required=False,
          help_text=_('Config template')
      )
      slug = SlugField()
  
      class Meta:
          model = DeviceRole
          fields = (
              'name', 'slug', 'parent', 'color', 'vm_role', 'config_template', 'description', 'comments', 'tags'
          )
  
  
  class PlatformImportForm(NetBoxModelImportForm):
      slug = SlugField()
      parent = CSVModelChoiceField(
          label=_('Parent'),
          queryset=Platform.objects.all(),
          required=False,
          to_field_name='name',
          help_text=_('Parent platform'),
          error_messages={
              'invalid_choice': _('Platform not found.'),
          }
      )
      manufacturer = CSVModelChoiceField(
          label=_('Manufacturer'),
          queryset=Manufacturer.objects.all(),
          required=False,
          to_field_name='name',
          help_text=_('Limit platform assignments to this manufacturer')
      )
      config_template = CSVModelChoiceField(
          label=_('Config template'),
          queryset=ConfigTemplate.objects.all(),
          to_field_name='name',
          required=False,
          help_text=_('Config template')
      )
  
      class Meta:
          model = Platform
          fields = (
              'name', 'slug', 'parent', 'manufacturer', 'config_template', 'description', 'tags',
          )
  
  
  class BaseDeviceImportForm(NetBoxModelImportForm):
      role = CSVModelChoiceField(
          label=_('Device role'),
          queryset=DeviceRole.objects.all(),
          to_field_name='name',
          help_text=_('Assigned role')
      )
      tenant = CSVModelChoiceField(
          label=_('Tenant'),
          queryset=Tenant.objects.all(),
          required=False,
          to_field_name='name',
          help_text=_('Assigned tenant')
      )
      manufacturer = CSVModelChoiceField(
          label=_('Manufacturer'),
          queryset=Manufacturer.objects.all(),
          to_field_name='name',
          help_text=_('Device type manufacturer')
      )
      device_type = CSVModelChoiceField(
          label=_('Device type'),
          queryset=DeviceType.objects.all(),
          to_field_name='model',
          help_text=_('Device type model')
      )
      platform = CSVModelChoiceField(
          label=_('Platform'),
          queryset=Platform.objects.all(),
          required=False,
          to_field_name='name',
          help_text=_('Assigned platform')
      )
      status = CSVChoiceField(
          label=_('Status'),
          choices=DeviceStatusChoices,
          help_text=_('Operational status')
      )
      virtual_chassis = CSVModelChoiceField(
          label=_('Virtual chassis'),
          queryset=VirtualChassis.objects.all(),
          to_field_name='name',
          required=False,
          help_text=_('Virtual chassis')
      )
      cluster = CSVModelChoiceField(
          label=_('Cluster'),
          queryset=Cluster.objects.all(),
          to_field_name='name',
          required=False,
          help_text=_('Virtualization cluster')
      )
  
      class Meta:
          fields = []
          model = Device
  
      def __init__(self, data=None, *args, **kwargs):
          super().__init__(data, *args, **kwargs)
  
          if data:
  
              # Limit device type queryset by manufacturer
              params = {f"manufacturer__{self.fields['manufacturer'].to_field_name}": data.get('manufacturer')}
              self.fields['device_type'].queryset = self.fields['device_type'].queryset.filter(**params)
  
  
  class DeviceImportForm(BaseDeviceImportForm):
      site = CSVModelChoiceField(
          label=_('Site'),
          queryset=Site.objects.all(),
          to_field_name='name',
          help_text=_('Assigned site')
      )
      location = CSVModelChoiceField(
          label=_('Location'),
          queryset=Location.objects.all(),
          to_field_name='name',
          required=False,
          help_text=_("Assigned location (if any)")
      )
      rack = CSVModelChoiceField(
          label=_('Rack'),
          queryset=Rack.objects.all(),
          to_field_name='name',
          required=False,
          help_text=_("Assigned rack (if any)")
      )
      face = CSVChoiceField(
          label=_('Face'),
          choices=DeviceFaceChoices,
          required=False,
          help_text=_('Mounted rack face')
      )
      parent = CSVModelChoiceField(
          label=_('Parent'),
          queryset=Device.objects.all(),
          to_field_name='name',
          required=False,
          help_text=_('Parent device (for child devices)')
      )
      device_bay = CSVModelChoiceField(
          label=_('Device bay'),
          queryset=DeviceBay.objects.all(),
          to_field_name='name',
          required=False,
          help_text=_('Device bay in which this device is installed (for child devices)')
      )
      airflow = CSVChoiceField(
          label=_('Airflow'),
          choices=DeviceAirflowChoices,
          required=False,
          help_text=_('Airflow direction')
      )
      config_template = CSVModelChoiceField(
          label=_('Config template'),
          queryset=ConfigTemplate.objects.all(),
          to_field_name='name',
          required=False,
          help_text=_('Config template')
      )
  
      class Meta(BaseDeviceImportForm.Meta):
          fields = [
              'name', 'role', 'tenant', 'manufacturer', 'device_type', 'platform', 'serial', 'asset_tag', 'status',
              'site', 'location', 'rack', 'position', 'face', 'latitude', 'longitude', 'parent', 'device_bay', 'airflow',
              'virtual_chassis', 'vc_position', 'vc_priority', 'cluster', 'description', 'config_template', 'comments',
              'tags',
          ]
  
      def __init__(self, data=None, *args, **kwargs):
          super().__init__(data, *args, **kwargs)
  
          if data:
  
              # Limit location queryset by assigned site
              params = {f"site__{self.fields['site'].to_field_name}": data.get('site')}
              self.fields['location'].queryset = self.fields['location'].queryset.filter(**params)
              self.fields['parent'].queryset = self.fields['parent'].queryset.filter(**params)
  
              # Limit rack queryset by assigned site and location
              params = {
                  f"site__{self.fields['site'].to_field_name}": data.get('site'),
              }
              if location := data.get('location'):
                  params.update({
                      f"location__{self.fields['location'].to_field_name}": location,
                  })
              self.fields['rack'].queryset = self.fields['rack'].queryset.filter(**params)
  
              # Limit platform queryset by manufacturer
              params = {f"manufacturer__{self.fields['manufacturer'].to_field_name}": data.get('manufacturer')}
              self.fields['platform'].queryset = self.fields['platform'].queryset.filter(
                  Q(**params) | Q(manufacturer=None)
              )
  
              # Limit device bay queryset by parent device
              if parent := data.get('parent'):
                  params = {f"device__{self.fields['parent'].to_field_name}": parent}
                  self.fields['device_bay'].queryset = self.fields['device_bay'].queryset.filter(**params)
  
      def clean(self):
          super().clean()
  
          # Inherit site and rack from parent device
          if parent := self.cleaned_data.get('parent'):
              self.instance.site = parent.site
              self.instance.rack = parent.rack
  
          # Set parent_bay reverse relationship
          if device_bay := self.cleaned_data.get('device_bay'):
              self.instance.parent_bay = device_bay
  
  
  class ModuleImportForm(ModuleCommonForm, NetBoxModelImportForm):
      device = CSVModelChoiceField(
          label=_('Device'),
          queryset=Device.objects.all(),
          to_field_name='name',
          help_text=_('The device in which this module is installed')
      )
      module_bay = CSVModelChoiceField(
          label=_('Module bay'),
          queryset=ModuleBay.objects.all(),
          to_field_name='name',
          help_text=_('The module bay in which this module is installed')
      )
      module_type = CSVModelChoiceField(
          label=_('Module type'),
          queryset=ModuleType.objects.all(),
          to_field_name='model',
          help_text=_('The type of module')
      )
      status = CSVChoiceField(
          label=_('Status'),
          choices=ModuleStatusChoices,
          help_text=_('Operational status')
      )
      replicate_components = forms.BooleanField(
          label=_('Replicate components'),
          required=False,
          help_text=_('Automatically populate components associated with this module type (enabled by default)')
      )
      adopt_components = forms.BooleanField(
          label=_('Adopt components'),
          required=False,
          help_text=_('Adopt already existing components')
      )
  
      class Meta:
          model = Module
          fields = (
              'device', 'module_bay', 'module_type', 'serial', 'asset_tag', 'status', 'description', 'comments',
              'replicate_components', 'adopt_components', 'tags',
          )
  
      def __init__(self, data=None, *args, **kwargs):
          super().__init__(data, *args, **kwargs)
  
          if data:
              # Limit module_bay queryset by assigned device
              params = {f"device__{self.fields['device'].to_field_name}": data.get('device')}
              self.fields['module_bay'].queryset = self.fields['module_bay'].queryset.filter(**params)
  
      def clean_replicate_components(self):
          # Make sure replicate_components is True when it's not included in the uploaded data
          if 'replicate_components' not in self.data:
              return True
          else:
              return self.cleaned_data['replicate_components']
  
  
  #
  # Device components
  #
  
  class ConsolePortImportForm(NetBoxModelImportForm):
      device = CSVModelChoiceField(
          label=_('Device'),
          queryset=Device.objects.all(),
          to_field_name='name'
      )
      type = CSVChoiceField(
          label=_('Type'),
          choices=ConsolePortTypeChoices,
          required=False,
          help_text=_('Port type')
      )
      speed = CSVTypedChoiceField(
          label=_('Speed'),
          choices=ConsolePortSpeedChoices,
          coerce=int,
          empty_value=None,
          required=False,
          help_text=_('Port speed in bps')
      )
  
      class Meta:
          model = ConsolePort
          fields = ('device', 'name', 'label', 'type', 'speed', 'mark_connected', 'description', 'tags')
  
  
  class ConsoleServerPortImportForm(NetBoxModelImportForm):
      device = CSVModelChoiceField(
          label=_('Device'),
          queryset=Device.objects.all(),
          to_field_name='name'
      )
      type = CSVChoiceField(
          label=_('Type'),
          choices=ConsolePortTypeChoices,
          required=False,
          help_text=_('Port type')
      )
      speed = CSVTypedChoiceField(
          label=_('Speed'),
          choices=ConsolePortSpeedChoices,
          coerce=int,
          empty_value=None,
          required=False,
          help_text=_('Port speed in bps')
      )
  
      class Meta:
          model = ConsoleServerPort
          fields = ('device', 'name', 'label', 'type', 'speed', 'mark_connected', 'description', 'tags')
  
  
  class PowerPortImportForm(NetBoxModelImportForm):
      device = CSVModelChoiceField(
          label=_('Device'),
          queryset=Device.objects.all(),
          to_field_name='name'
      )
      type = CSVChoiceField(
          label=_('Type'),
          choices=PowerPortTypeChoices,
          required=False,
          help_text=_('Port type')
      )
  
      class Meta:
          model = PowerPort
          fields = (
              'device', 'name', 'label', 'type', 'mark_connected', 'maximum_draw', 'allocated_draw', 'description', 'tags'
          )
  
  
  class PowerOutletImportForm(NetBoxModelImportForm):
      device = CSVModelChoiceField(
          label=_('Device'),
          queryset=Device.objects.all(),
          to_field_name='name'
      )
      type = CSVChoiceField(
          label=_('Type'),
          choices=PowerOutletTypeChoices,
          required=False,
          help_text=_('Outlet type')
      )
      power_port = CSVModelChoiceField(
          label=_('Power port'),
          queryset=PowerPort.objects.all(),
          required=False,
          to_field_name='name',
          help_text=_('Local power port which feeds this outlet')
      )
      feed_leg = CSVChoiceField(
          label=_('Feed leg'),
          choices=PowerOutletFeedLegChoices,
          required=False,
          help_text=_('Electrical phase (for three-phase circuits)')
      )
  
      class Meta:
          model = PowerOutlet
          fields = (
              'device', 'name', 'label', 'type', 'color', 'mark_connected', 'power_port', 'feed_leg', 'description',
              'tags',
          )
  
      def __init__(self, *args, **kwargs):
          super().__init__(*args, **kwargs)
  
          # Limit PowerPort choices to those belonging to this device (or VC master)
          if self.is_bound and 'device' in self.data:
              try:
                  device = self.fields['device'].to_python(self.data['device'])
              except forms.ValidationError:
                  device = None
          else:
              try:
                  device = self.instance.device
              except Device.DoesNotExist:
                  device = None
  
          if device:
              self.fields['power_port'].queryset = PowerPort.objects.filter(
                  device__in=[device, device.get_vc_master()]
              )
          else:
              self.fields['power_port'].queryset = PowerPort.objects.none()
  
  
  class InterfaceImportForm(NetBoxModelImportForm):
      device = CSVModelChoiceField(
          label=_('Device'),
          queryset=Device.objects.all(),
          to_field_name='name'
      )
      parent = CSVModelChoiceField(
          label=_('Parent'),
          queryset=Interface.objects.all(),
          required=False,
          to_field_name='name',
          help_text=_('Parent interface')
      )
      bridge = CSVModelChoiceField(
          label=_('Bridge'),
          queryset=Interface.objects.all(),
          required=False,
          to_field_name='name',
          help_text=_('Bridged interface')
      )
      lag = CSVModelChoiceField(
          label=_('Lag'),
          queryset=Interface.objects.all(),
          required=False,
          to_field_name='name',
          help_text=_('Parent LAG interface')
      )
      vdcs = CSVModelMultipleChoiceField(
          label=_('Vdcs'),
          queryset=VirtualDeviceContext.objects.all(),
          required=False,
          to_field_name='name',
          help_text=mark_safe(
              _('VDC names separated by commas, encased with double quotes. Example:') + ' <code>"vdc1,vdc2,vdc3"</code>'
          )
      )
      type = CSVChoiceField(
          label=_('Type'),
          choices=InterfaceTypeChoices,
          help_text=_('Physical medium')
      )
      duplex = CSVChoiceField(
          label=_('Duplex'),
          choices=InterfaceDuplexChoices,
          required=False
      )
      poe_mode = CSVChoiceField(
          label=_('Poe mode'),
          choices=InterfacePoEModeChoices,
          required=False,
          help_text=_('PoE mode')
      )
      poe_type = CSVChoiceField(
          label=_('Poe type'),
          choices=InterfacePoETypeChoices,
          required=False,
          help_text=_('PoE type')
      )
      mode = CSVChoiceField(
          label=_('Mode'),
          choices=InterfaceModeChoices,
          required=False,
          help_text=_('IEEE 802.1Q operational mode (for L2 interfaces)'),
      )
      vlan_group = CSVModelChoiceField(
          label=_('VLAN group'),
          queryset=VLANGroup.objects.all(),
          required=False,
          to_field_name='name',
          help_text=_('Filter VLANs available for assignment by group'),
      )
      untagged_vlan = CSVModelChoiceField(
          label=_('Untagged VLAN'),
          queryset=VLAN.objects.all(),
          required=False,
          to_field_name='vid',
          help_text=_('Assigned untagged VLAN ID (filtered by VLAN group)'),
      )
      tagged_vlans = CSVModelMultipleChoiceField(
          label=_('Tagged VLANs'),
          queryset=VLAN.objects.all(),
          required=False,
          to_field_name='vid',
          help_text=mark_safe(
              _(
                  'Assigned tagged VLAN IDs separated by commas, encased with double quotes '
                  '(filtered by VLAN group). Example:'
              )
              + ' <code>"100,200,300"</code>'
          ),
      )
      qinq_svlan = CSVModelChoiceField(
          label=_('Q-in-Q Service VLAN'),
          queryset=VLAN.objects.filter(qinq_role=VLANQinQRoleChoices.ROLE_SERVICE),
          required=False,
          to_field_name='vid',
  