django-bom 1.243__py3-none-any.whl → 1.257__py3-none-any.whl

bom/forms.py

@@ -1,53 +1,26 @@
 import codecs
 import csv
 import logging
-from typing import Type, TypeVar
 
 from django import forms
 from django.contrib.auth.forms import UserCreationForm
 from django.core.exceptions import ValidationError
-from django.core.validators import MaxLengthValidator, MaxValueValidator, MinLengthValidator, MinValueValidator
+from django.core.validators import MaxLengthValidator, MinLengthValidator
 from django.db import IntegrityError
 from django.forms.models import model_to_dict
 from django.utils.translation import gettext_lazy as _
-
 from djmoney.money import Money
 
 from .constants import (
-    CONFIGURATION_TYPES,
-    CURRENT_UNITS,
-    DISTANCE_UNITS,
-    FREQUENCY_UNITS,
-    INTERFACE_TYPES,
-    MEMORY_UNITS,
-    NUMBER_CLASS_CODE_LEN_DEFAULT,
-    NUMBER_CLASS_CODE_LEN_MAX,
-    NUMBER_CLASS_CODE_LEN_MIN,
-    NUMBER_ITEM_LEN_DEFAULT,
-    NUMBER_ITEM_LEN_MAX,
-    NUMBER_ITEM_LEN_MIN,
     NUMBER_SCHEME_INTELLIGENT,
     NUMBER_SCHEME_SEMI_INTELLIGENT,
-    NUMBER_VARIATION_LEN_DEFAULT,
-    NUMBER_VARIATION_LEN_MAX,
-    NUMBER_VARIATION_LEN_MIN,
-    PACKAGE_TYPES,
-    POWER_UNITS,
     ROLE_TYPE_VIEWER,
-    ROLE_TYPES,
-    SUBSCRIPTION_TYPES,
-    TEMPERATURE_UNITS,
-    VALUE_UNITS,
-    VOLTAGE_UNITS,
-    WAVELENGTH_UNITS,
-    WEIGHT_UNITS,
+    PART_REVISION_PROPERTY_TYPE_DECIMAL,
+    PART_REVISION_PROPERTY_TYPE_BOOLEAN,
 )
 from .csv_headers import (
-    BOMFlatCSVHeaders,
-    BOMIndentedCSVHeaders,
     CSVHeaderError,
     PartClassesCSVHeaders,
-    PartsListCSVHeaders,
 )
 from .form_fields import AutocompleteTextInput
 from .models import (
@@ -55,39 +28,143 @@ from .models import (
     AssemblySubparts,
     Manufacturer,
     ManufacturerPart,
-    Organization,
     Part,
     PartClass,
     PartRevision,
+    PartRevisionProperty,
+    PartRevisionPropertyDefinition,
+    QuantityOfMeasure,
     Seller,
     SellerPart,
     Subpart,
+    UnitDefinition,
     User,
-    UserMeta,
-)
-from .utils import (
-    check_references_for_duplicates,
-    get_from_dict,
-    listify_string,
-    prep_for_sorting_nicely,
-    stringify_list,
+    get_user_meta_model,
+    get_organization_model,
 )
-from .validators import alphanumeric, decimal, numeric
-
+from .utils import listify_string, stringify_list
+from .validators import alphanumeric
 
 logger = logging.getLogger(__name__)
+Organization = get_organization_model()
+UserMeta = get_user_meta_model()
+
+
+# ==========================================
+# MIXINS & BASE CLASSES
+# ==========================================
+
+class OrganizationFormMixin:
+    """Mixin to handle organization injection."""
+
+    def __init__(self, *args, **kwargs):
+        self.organization = kwargs.pop('organization', None)
+        super().__init__(*args, **kwargs)
+
+
+class PlaceholderMixin:
+    """Mixin to move help_text to widget placeholders automatically."""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        for _, field in self.fields.items():
+            if field.help_text:
+                field.widget.attrs['placeholder'] = field.help_text
+                field.help_text = ''
+
+
+class BaseCSVForm(OrganizationFormMixin, forms.Form):
+    """Abstract Base Class for CSV Import Forms to DRY up file handling."""
+    file = forms.FileField(required=False)
+
+    def get_csv_headers_handler(self):
+        """Subclasses must return the CSV headers handler instance."""
+        raise NotImplementedError
+
+    def get_header_assertions(self):
+        """Subclasses must return a list of header assertions."""
+        raise NotImplementedError
+
+    def process_row(self, row_data, row_count, headers_handler):
+        """Subclasses implement specific row logic here."""
+        raise NotImplementedError
+
+    def clean(self):
+        cleaned_data = super().clean()
+        file = self.cleaned_data.get('file')
+        self.successes = []
+        self.warnings = []
+
+        if not file:
+            return cleaned_data
+
+        try:
+            # Decode and Sniff
+            csvline_decoded = file.readline().decode('utf-8')
+            dialect = csv.Sniffer().sniff(csvline_decoded)
+            file.open()
 
+            # handle BOM
+            reader = csv.reader(codecs.iterdecode(file, 'utf-8'), dialect)
+            headers = [h.lower() for h in next(reader)]
+
+            if headers and "\ufeff" in headers[0]:
+                file.seek(0)
+                reader = csv.reader(codecs.iterdecode(file, 'utf-8-sig'), dialect)
+                headers = [h.lower() for h in next(reader)]
+
+            # Header Validation
+            csv_headers = self.get_csv_headers_handler()
+
+            try:
+                csv_headers.validate_header_names(headers)
+            except CSVHeaderError as e:
+                self.warnings.append(f"{e}. Columns ignored.")
+
+            try:
+                csv_headers.validate_header_assertions(headers, self.get_header_assertions())
+                headers = csv_headers.get_defaults_list(headers)
+            except CSVHeaderError as e:
+                raise ValidationError(f"{e}. Uploading stopped.", code='invalid')
+
+            # Row Processing
+            row_count = 1
+            for row in reader:
+                row_count += 1
+                row_data = {}
+                for idx, hdr in enumerate(headers):
+                    if idx < len(row):
+                        row_data[hdr] = row[idx]
+
+                self.process_row(row_data, row_count, csv_headers)
+
+        except UnicodeDecodeError as e:
+            self.add_error(None, forms.ValidationError(
+                "CSV File Encoding error. Please encode as utf-8.", code='invalid'
+            ))
+            logger.warning(f"UnicodeDecodeError: {e}")
+            raise ValidationError(f"Specific Error: {e}", code='invalid')
+        except Exception as e:
+            # Catch-all for unexpected errors during processing to ensure they bubble up cleanly
+            if isinstance(e, ValidationError):
+                raise e
+            logger.error(f"Error processing CSV: {e}")
+            self.add_error(None, f"An unexpected error occurred: {str(e)}")
+
+        return cleaned_data
+
+
+# ==========================================
+# USER & AUTH FORMS
+# ==========================================
 
 class UserModelChoiceField(forms.ModelChoiceField):
     def label_from_instance(self, user):
-        l = "[" + user.username + "]"
-        if user.first_name:
-            l += " " + user.first_name
-        if user.last_name:
-            l += " " + user.last_name
-        if user.email:
-            l += ", " + user.email
-        return l
+        parts = [f"[{user.username}]"]
+        if user.first_name: parts.append(user.first_name)
+        if user.last_name: parts.append(user.last_name)
+        if user.email: parts.append(f", {user.email}")
+        return " ".join(parts)
 
 
 class UserCreateForm(UserCreationForm):
@@ -97,103 +174,88 @@ class UserCreateForm(UserCreationForm):
 
     def clean_email(self):
         email = self.cleaned_data['email']
-        exists = User.objects.filter(email__iexact=email).count() > 0
-        if exists:
+        if User.objects.filter(email__iexact=email).exists():
             raise ValidationError('An account with this email address already exists.')
         return email
 
     def save(self, commit=True):
-        user = super(UserCreateForm, self).save(commit=commit)
+        user = super().save(commit=commit)
         user.email = self.cleaned_data['email']
         user.first_name = self.cleaned_data['first_name']
         user.last_name = self.cleaned_data['last_name']
-        user.save()
+        if commit:
+            user.save()
         return user
 
 
 class UserForm(forms.ModelForm):
     class Meta:
         model = User
-        fields = ['first_name', 'last_name', 'email', ]
+        fields = ['first_name', 'last_name', 'email']
 
 
-class UserAddForm(forms.ModelForm):
+class UserAddForm(OrganizationFormMixin, forms.ModelForm):
     class Meta:
         model = UserMeta
         fields = ['role']
 
-    field_order = ['username', 'role', ]
+    field_order = ['username', 'role']
     username = forms.CharField(initial=None, required=False)
 
     def __init__(self, *args, **kwargs):
-        self.organization = kwargs.pop('organization', None)
-        super(UserAddForm, self).__init__(*args, **kwargs)
+        hide_username = kwargs.pop('exclude_username', False)
+        super().__init__(*args, **kwargs)
         self.fields['role'].required = False
+        if hide_username and self.instance.pk:
+            self.fields['username'].widget = forms.HiddenInput()
+            self.fields['username'].initial = self.instance.user.username
 
     def clean_username(self):
-        cleaned_data = super(UserAddForm, self).clean()
-        username = cleaned_data.get('username')
+        username = self.cleaned_data.get('username')
         try:
             user = User.objects.get(username=username)
-            user_meta = UserMeta.objects.get(user=user)
+            user_meta = user.bom_profile()
             if user_meta.organization == self.organization:
-                validation_error = forms.ValidationError("User '{0}' already belongs to {1}.".format(username, self.organization), code='invalid')
-                self.add_error('username', validation_error)
+                self.add_error('username', f"User '{username}' already belongs to {self.organization}.")
             elif user_meta.organization:
-                validation_error = forms.ValidationError("User '{}' belongs to another organization.".format(username), code='invalid')
-                self.add_error('username', validation_error)
+                self.add_error('username', f"User '{username}' belongs to another organization.")
         except User.DoesNotExist:
-            validation_error = forms.ValidationError("User '{}' does not exist.".format(username), code='invalid')
-            self.add_error('username', validation_error)
-
+            self.add_error('username', f"User '{username}' does not exist.")
         return username
 
     def clean_role(self):
-        cleaned_data = super(UserAddForm, self).clean()
-        role = cleaned_data.get('role', None)
-        if not role:
-            role = ROLE_TYPE_VIEWER
-        return role
+        return self.cleaned_data.get('role') or ROLE_TYPE_VIEWER
 
-    def save(self, *args, **kwargs):
+    def save(self, commit=True):
         username = self.cleaned_data.get('username')
-        role = self.cleaned_data.get('role', ROLE_TYPE_VIEWER)
         user = User.objects.get(username=username)
         user_meta = user.bom_profile()
         user_meta.organization = self.organization
-        user_meta.role = role
+        user_meta.role = self.cleaned_data.get('role')
         user_meta.save()
         return user_meta
 
 
-class UserMetaForm(forms.ModelForm):
+class UserMetaForm(OrganizationFormMixin, forms.ModelForm):
     class Meta:
         model = UserMeta
-        exclude = ['user', ]
-
-    def __init__(self, *args, **kwargs):
-        self.organization = kwargs.pop('organization', None)
-        super(UserMetaForm, self).__init__(*args, **kwargs)
+        exclude = ['user']
 
-    def save(self):
+    def save(self, commit=True):
         self.instance.organization = self.organization
-        self.instance.save()
+        if commit:
+            self.instance.save()
         return self.instance
 
 
-class OrganizationCreateForm(forms.ModelForm):
-    def __init__(self, *args, **kwargs):
-        super(OrganizationCreateForm, self).__init__(*args, **kwargs)
-        if self.data.get('number_scheme') == NUMBER_SCHEME_INTELLIGENT:
-            # make the QueryDict mutable
-            self.data = self.data.copy()
-            self.data['number_class_code_len'] = 3
-            self.data['number_item_len'] = 128
-            self.data['number_variation_len'] = 2
+# ==========================================
+# ORGANIZATION FORMS
+# ==========================================
 
+class OrganizationBaseForm(forms.ModelForm):
     class Meta:
         model = Organization
-        fields = ['name', 'number_scheme', 'number_class_code_len', 'number_item_len', 'number_variation_len', ]
+        fields = ['name', 'number_class_code_len', 'number_item_len', 'number_variation_len']
         labels = {
             "name": "Organization Name",
             "number_class_code_len": "Number Class Code Length (C)",
@@ -202,57 +264,54 @@ class OrganizationCreateForm(forms.ModelForm):
         }
 
 
-class OrganizationForm(forms.ModelForm):
-    class Meta:
-        model = Organization
-        exclude = ['owner', 'subscription', 'subscription_quantity', 'google_drive_parent', 'number_scheme', ]
-        labels = {
-            "name": "Organization Name",
-            "number_class_code_len": "Number Class Code Length (C)",
-            "number_item_len": "Number Item Length (N)",
-            "number_variation_len": "Number Variation Length (V)",
-        }
+class OrganizationCreateForm(OrganizationBaseForm):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if self.data.get('number_scheme') == NUMBER_SCHEME_INTELLIGENT:
+            self.data = self.data.copy()
+            self.data.update({
+                'number_class_code_len': 3,
+                'number_item_len': 128,
+                'number_variation_len': 2
+            })
 
+    class Meta(OrganizationBaseForm.Meta):
+        fields = OrganizationBaseForm.Meta.fields + ['number_scheme']
+
+
+class OrganizationForm(OrganizationBaseForm):
     def __init__(self, *args, **kwargs):
         user = kwargs.pop('user', None)
-        super(OrganizationForm, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
         if user and self.instance.owner == user:
-            user_queryset = User.objects.filter(
-                id__in=UserMeta.objects.filter(organization=self.instance, role='A').values_list('user', flat=True)).order_by(
-                'first_name', 'last_name', 'email')
-            self.fields['owner'] = UserModelChoiceField(queryset=user_queryset, label='Owner', initial=self.instance.owner, required=True)
+            # Only show owner selection if current user is owner
+            admin_ids = UserMeta.objects.filter(
+                organization=self.instance, role='A'
+            ).values_list('user', flat=True)
+            user_qs = User.objects.filter(id__in=admin_ids).order_by('first_name', 'last_name')
 
+            self.fields['owner'] = UserModelChoiceField(
+                queryset=user_qs, label='Owner', initial=self.instance.owner, required=True
+            )
 
-class OrganizationFormEditSettings(OrganizationForm):
-    def __init__(self, *args, **kwargs):
-        super(OrganizationFormEditSettings, self).__init__(*args, **kwargs)
-        user = kwargs.get('user', None)
 
-    class Meta:
-        model = Organization
-        exclude = ['subscription', 'subscription_quantity', 'google_drive_parent', 'number_scheme', 'number_item_len', 'number_class_code_len', 'number_variation_len', 'owner', ]
-        labels = {
-            "name": "Organization Name",
-        }
+class OrganizationFormEditSettings(OrganizationForm):
+    class Meta(OrganizationBaseForm.Meta):
+        fields = ['name', 'owner', 'currency']
 
 
-class OrganizationNumberLenForm(forms.ModelForm):
-    class Meta:
-        model = Organization
-        fields = ['number_class_code_len', 'number_item_len', 'number_variation_len', ]
-        labels = {
-            "number_class_code_len": "Number Class Code Length (C)",
-            "number_item_len": "Number Item Length (N)",
-            "number_variation_len": "Number Variation Length (V)",
-        }
+class OrganizationNumberLenForm(OrganizationBaseForm):
+    class Meta(OrganizationBaseForm.Meta):
+        fields = ['number_class_code_len', 'number_item_len', 'number_variation_len']
 
     def __init__(self, *args, **kwargs):
-        self.organization = kwargs.get('instance', None)
-        super(OrganizationNumberLenForm, self).__init__(*args, **kwargs)
-        # self.fields['number_class_code_len'].validators.append(MinValueValidator(self.organization.number_class_code_len))
-        # self.fields['number_item_len'].validators.append(MinValueValidator(self.organization.number_item_len))
-        # self.fields['number_variation_len'].validators.append(MinValueValidator(self.organization.number_variation_len))
+        self.organization = kwargs.get('instance')
+        super().__init__(*args, **kwargs)
+
 
+# ==========================================
+# PART & MFG FORMS
+# ==========================================
 
 class PartInfoForm(forms.Form):
     quantity = forms.IntegerField(label='Quantity for Est Cost', min_value=1)
@@ -261,540 +320,248 @@ class PartInfoForm(forms.Form):
 class ManufacturerForm(forms.ModelForm):
     class Meta:
         model = Manufacturer
-        exclude = ['organization', ]
+        exclude = ['organization']
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.fields['name'].required = False
 
 
-class ManufacturerPartForm(forms.ModelForm):
+class ManufacturerPartForm(OrganizationFormMixin, forms.ModelForm):
     class Meta:
         model = ManufacturerPart
-        exclude = ['part', ]
+        exclude = ['part']
 
     field_order = ['manufacturer_part_number', 'manufacturer']
 
     def __init__(self, *args, **kwargs):
-        self.organization = kwargs.pop('organization', None)
-        super(ManufacturerPartForm, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
         self.fields['manufacturer'].required = False
         self.fields['manufacturer_part_number'].required = False
-        self.fields['manufacturer'].queryset = Manufacturer.objects.filter(organization=self.organization).order_by('name')
+        self.fields['manufacturer'].queryset = Manufacturer.objects.filter(
+            organization=self.organization
+        ).order_by('name')
         self.fields['mouser_disable'].initial = True
 
 
 class SellerForm(forms.ModelForm):
     class Meta:
         model = Seller
-        exclude = ['organization', ]
+        exclude = ['organization']
 
 
-class SellerPartForm(forms.ModelForm):
+class SellerPartForm(OrganizationFormMixin, forms.ModelForm):
+    new_seller = forms.CharField(max_length=128, label='-or- Create new seller', required=False)
+
     class Meta:
         model = SellerPart
-        exclude = ['manufacturer_part', 'data_source', ]
+        exclude = ['manufacturer_part', 'data_source']
 
-    new_seller = forms.CharField(max_length=128, label='-or- Create new seller (leave blank if selecting)', required=False)
-    field_order = ['seller', 'new_seller', 'unit_cost', 'nre_cost', 'lead_time_days', 'minimum_order_quantity', 'minimum_pack_quantity', ]
+    field_order = ['seller', 'new_seller', 'unit_cost', 'nre_cost', 'lead_time_days', 'minimum_order_quantity',
+                   'minimum_pack_quantity']
 
     def __init__(self, *args, **kwargs):
-        self.organization = kwargs.pop('organization', None)
         self.manufacturer_part = kwargs.pop('manufacturer_part', None)
-        self.base_fields['unit_cost'] = forms.DecimalField(required=True, decimal_places=4, max_digits=17)
-        self.base_fields['nre_cost'] = forms.DecimalField(required=True, decimal_places=4, max_digits=17, label='NRE cost')
-
-        instance = kwargs.get('instance')
-        if instance:
-            initial = kwargs.get('initial', {})
-            initial['unit_cost'] = instance.unit_cost.amount
-            initial['nre_cost'] = instance.nre_cost.amount
-            kwargs['initial'] = initial
-        super(SellerPartForm, self).__init__(*args, **kwargs)
-        if self.manufacturer_part is not None:
+        super().__init__(*args, **kwargs)
+
+        # Currency formatting
+        self.fields['unit_cost'] = forms.DecimalField(required=True, decimal_places=4, max_digits=17)
+        self.fields['nre_cost'] = forms.DecimalField(required=True, decimal_places=4, max_digits=17, label='NRE cost')
+
+        if self.instance.pk:
+            self.initial['unit_cost'] = self.instance.unit_cost.amount
+            self.initial['nre_cost'] = self.instance.nre_cost.amount
+
+        if self.manufacturer_part:
             self.instance.manufacturer_part = self.manufacturer_part
+
         self.fields['seller'].queryset = Seller.objects.filter(organization=self.organization).order_by('name')
         self.fields['seller'].required = False
 
     def clean(self):
-        cleaned_data = super(SellerPartForm, self).clean()
+        cleaned_data = super().clean()
         seller = cleaned_data.get('seller')
         new_seller = cleaned_data.get('new_seller')
-        unit_cost = cleaned_data.get('unit_cost')
-        nre_cost = cleaned_data.get('nre_cost')
-        if unit_cost is None:
-            raise forms.ValidationError("Invalid unit cost.", code='invalid')
-        self.instance.unit_cost = Money(unit_cost, self.organization.currency)
 
-        if nre_cost is None:
-            raise forms.ValidationError("Invalid NRE cost.", code='invalid')
-        self.instance.nre_cost = Money(nre_cost, self.organization.currency)
+        # Handle Money fields
+        for field in ['unit_cost', 'nre_cost']:
+            val = cleaned_data.get(field)
+            if val is None:
+                self.add_error(field, "Invalid cost.")
+            else:
+                setattr(self.instance, field, Money(val, self.organization.currency))
 
         if seller and new_seller:
-            raise forms.ValidationError("Cannot have a seller and a new seller.", code='invalid')
+            raise forms.ValidationError("Cannot have a seller and a new seller.")
         elif new_seller:
-            obj, created = Seller.objects.get_or_create(name__iexact=new_seller, organization=self.organization, defaults={'name': new_seller})
-            self.cleaned_data['seller'] = obj
+            obj, _ = Seller.objects.get_or_create(
+                name__iexact=new_seller, organization=self.organization,
+                defaults={'name': new_seller}
+            )
+            cleaned_data['seller'] = obj
         elif not seller:
-            raise forms.ValidationError("Must specify a seller.", code='invalid')
-
-
-class PartClassForm(forms.ModelForm):
-    class Meta:
-        model = PartClass
-        fields = ['code', 'name', 'comment']
+            raise forms.ValidationError("Must specify a seller.")
 
-    def __init__(self, *args, **kwargs):
-        self.organization = kwargs.pop('organization', None)
-        self.ignore_unique_constraint = kwargs.pop('ignore_unique_constraint', False)
-        super(PartClassForm, self).__init__(*args, **kwargs)
-        self.fields['code'].required = False
-        self.fields['name'].required = False
-        self.fields['code'].validators.extend([MaxLengthValidator(self.organization.number_class_code_len), MinLengthValidator(self.organization.number_class_code_len)])
+        return cleaned_data
 
-    def clean_name(self):
-        cleaned_data = super(PartClassForm, self).clean()
-        name = cleaned_data.get('name')
-        if self.ignore_unique_constraint:
-            return name
-        try:
-            part_class_with_name = PartClass.objects.get(name__iexact=name, organization=self.organization)
-            if part_class_with_name and self.instance and self.instance.id != part_class_with_name.id:
-                validation_error = forms.ValidationError("Part class with name {} is already defined.".format(name), code='invalid')
-                self.add_error('name', validation_error)
-        except PartClass.DoesNotExist:
-            pass
-        return name
 
-    def clean_code(self):
-        cleaned_data = super(PartClassForm, self).clean()
-        code = cleaned_data.get('code')
-        if self.ignore_unique_constraint:
-            return code
-        if PartClass.objects.filter(code=code, organization=self.organization).exclude(pk=self.instance.pk).count() > 0:
-            validation_error = forms.ValidationError(f"Part class with code {code} is already defined.", code='invalid')
-            self.add_error('code', validation_error)
-        return code
+class QuantityOfMeasureForm(OrganizationFormMixin, forms.ModelForm):
+    class Meta:
+        model = QuantityOfMeasure
+        fields = ['name']
 
     def clean(self):
-        cleaned_data = super(PartClassForm, self).clean()
-        cleaned_data['organization_id'] = self.organization
+        cleaned_data = super().clean()
         self.instance.organization = self.organization
         return cleaned_data
 
 
-PartClassFormSet = forms.formset_factory(PartClassForm, extra=2, can_delete=True)
-
+class UnitDefinitionForm(OrganizationFormMixin, forms.ModelForm):
+    class Meta:
+        model = UnitDefinition
+        fields = ['name', 'symbol', 'base_multiplier', ]
 
-class PartClassSelectionForm(forms.Form):
-    def __init__(self, *args, **kwargs):
-        self.organization = kwargs.pop('organization', None)
-        super(PartClassSelectionForm, self).__init__(*args, **kwargs)
-        self.fields['part_class'] = forms.CharField(required=False,
-                                                    widget=AutocompleteTextInput(attrs={'placeholder': 'Select a part class.'},
-                                                                                 autocomplete_submit=True,
-                                                                                 queryset=PartClass.objects.filter(organization=self.organization)))
+    def clean(self):
+        cleaned_data = super().clean()
+        self.instance.organization = self.organization
+        return cleaned_data
 
-    def clean_part_class(self):
-        part_class = self.cleaned_data['part_class']
-        if part_class == '':
-            return None
 
-        try:
-            return PartClass.objects.get(organization=self.organization, code=part_class.split(':')[0])
-        except PartClass.DoesNotExist:
-            pc = PartClass.objects.filter(name__icontains=part_class).order_by('name').first()
-            if pc is not None:
-                return pc
-            else:
-                self.add_error('part_class', 'Select a valid part class.')
-        return None
+UnitDefinitionFormSet = forms.modelformset_factory(
+    UnitDefinition,
+    form=UnitDefinitionForm,
+    can_delete=True,
+    extra=0
+)
 
 
-class PartClassCSVForm(forms.Form):
-    file = forms.FileField(required=False)
+class PartRevisionPropertyDefinitionForm(OrganizationFormMixin, forms.ModelForm):
+    class Meta:
+        model = PartRevisionPropertyDefinition
+        fields = ['name', 'type', 'required', 'quantity_of_measure']
 
     def __init__(self, *args, **kwargs):
-        self.organization = kwargs.pop('organization', None)
-        super(PartClassCSVForm, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
+        self.fields['quantity_of_measure'].queryset = QuantityOfMeasure.objects.available_to(
+            self.organization).order_by('name')
 
-    def clean(self):
-        cleaned_data = super(PartClassCSVForm, self).clean()
-        file = self.cleaned_data.get('file')
-        self.successes = list()
-        self.warnings = list()
 
-        try:
-            csvline_decoded = file.readline().decode('utf-8')
-            dialect = csv.Sniffer().sniff(csvline_decoded)
-            file.open()
-            reader = csv.reader(codecs.iterdecode(file, 'utf-8'), dialect)
-            headers = [h.lower().replace('\ufeff', '') for h in next(reader)]
+class PartRevisionPropertyDefinitionSelectForm(OrganizationFormMixin, forms.Form):
+    property_definition = forms.ModelChoiceField(queryset=PartRevisionPropertyDefinition.objects.none())
 
-            csv_headers = PartClassesCSVHeaders()
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.fields['property_definition'].queryset = PartRevisionPropertyDefinition.objects.available_to(
+            self.organization).order_by('name')
 
-            try:
-                # Issue warning if unrecognized column header names appear in file.
-                csv_headers.validate_header_names(headers)
-            except CSVHeaderError as e:
-                self.warnings.append(e.__str__() + ". Column(s) ignored.")
 
-            try:
-                # Make sure that required columns appear in the file, then convert whatever
-                # header synonym names were used to default header names.
-                hdr_assertions = [
-                    ('comment', 'description', 'mex'),  # MUTUALLY EXCLUSIVE part_class or part_number but not both
-                    ('code', 'in'),  # CONTAINS revision
-                    ('name', 'in'),  # CONTAINS name
-                ]
-                csv_headers.validate_header_assertions(headers, hdr_assertions)
-                headers = csv_headers.get_defaults_list(headers)
-            except CSVHeaderError as e:
-                raise ValidationError(e.__str__() + ". Uploading stopped. No part classes uploaded.", code='invalid')
+PartRevisionPropertyDefinitionFormSet = forms.formset_factory(
+    PartRevisionPropertyDefinitionSelectForm,
+    can_delete=True,
+    extra=0
+)
 
-            row_count = 1  # Skip over header row
-            for row in reader:
-                row_count += 1
-                part_class_data = {}
 
-                for idx, hdr in enumerate(headers):
-                    if idx == len(row): break
-                    part_class_data[hdr] = row[idx]
+class PartClassForm(OrganizationFormMixin, forms.ModelForm):
+    class Meta:
+        model = PartClass
+        fields = ['code', 'name', 'comment']
 
-                name = csv_headers.get_val_from_row(part_class_data, 'name')
-                code = csv_headers.get_val_from_row(part_class_data, 'code')
-                description = csv_headers.get_val_from_row(part_class_data, 'description')
-                comment = csv_headers.get_val_from_row(part_class_data, 'comment')
+    def __init__(self, *args, **kwargs):
+        self.ignore_unique_constraint = kwargs.pop('ignore_unique_constraint', False)
+        super().__init__(*args, **kwargs)
+        self.fields['code'].required = False
+        self.fields['name'].required = False
+        self.fields['code'].validators.extend([
+            MaxLengthValidator(self.organization.number_class_code_len),
+            MinLengthValidator(self.organization.number_class_code_len)
+        ])
 
-                try:
-                    if code is None:
-                        validation_error = forms.ValidationError(
-                            "Part class 'code' in row {} does not have a value. Uploading of this part class skipped.".format(row_count),
-                            code='invalid')
-                        self.add_error(None, validation_error)
-                        continue
-                    elif len(code) != self.organization.number_class_code_len:
-                        validation_error = forms.ValidationError(
-                            "Length of part class 'code' in row {} is different than the organization class length {}. Uploading of this part class skipped.".format(row_count, self.organization.number_class_code_len),
-                            code='invalid')
-                        self.add_error(None, validation_error)
-                        continue
-
-                    description_or_comment = ''
-                    if description is not None:
-                        description_or_comment = description
-                    elif comment is not None:
-                        description_or_comment = comment
-                    PartClass.objects.create(code=code, name=name, comment=description_or_comment, organization=self.organization)
-                    self.successes.append("Part class {0} {1} on row {2} created.".format(code, name, row_count))
-
-                except IntegrityError:
-                    validation_error = forms.ValidationError(
-                        "Part class {0} {1} on row {2} is already defined. Uploading of this part class skipped.".format(code, name, row_count),
-                        code='invalid')
-                    self.add_error(None, validation_error)
+    def clean_name(self):
+        name = self.cleaned_data.get('name')
+        if not self.ignore_unique_constraint:
+            if PartClass.objects.filter(name__iexact=name, organization=self.organization).exclude(
+                    pk=self.instance.pk).exists():
+                self.add_error('name', f"Part class with name {name} is already defined.")
+        return name
 
-        except UnicodeDecodeError as e:
-            self.add_error(None, forms.ValidationError("CSV File Encoding error, try encoding your file as utf-8, and upload again. \
-                If this keeps happening, reach out to info@indabom.com with your csv file and we'll do our best to \
-                fix your issue!", code='invalid'))
-            logger.warning("UnicodeDecodeError: {}".format(e))
-            raise ValidationError("Specific Error: {}".format(e),
-                                  code='invalid')
+    def clean_code(self):
+        code = self.cleaned_data.get('code')
+        if not self.ignore_unique_constraint:
+            if PartClass.objects.filter(code=code, organization=self.organization).exclude(
+                    pk=self.instance.pk).exists():
+                self.add_error('code', f"Part class with code {code} is already defined.")
+        return code
 
+    def clean(self):
+        cleaned_data = super().clean()
+        self.instance.organization = self.organization
         return cleaned_data
 
 
-class PartCSVForm(forms.Form):
-    file = forms.FileField(required=False)
+PartClassFormSet = forms.formset_factory(PartClassForm, extra=2, can_delete=True)
+
 
+class PartClassSelectionForm(OrganizationFormMixin, forms.Form):
     def __init__(self, *args, **kwargs):
-        self.organization = kwargs.pop('organization', None)
-        super(PartCSVForm, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
+        self.fields['part_class'] = forms.CharField(
+            required=False,
+            widget=AutocompleteTextInput(
+                attrs={'placeholder': 'Select a part class.'},
+                autocomplete_submit=True,
+                queryset=PartClass.objects.filter(organization=self.organization)
+            )
+        )
 
-    def clean(self):
-        cleaned_data = super(PartCSVForm, self).clean()
-        file = self.cleaned_data.get('file')
-        self.successes = list()
-        self.warnings = list()
+    def clean_part_class(self):
+        pc_input = self.cleaned_data['part_class']
+        if not pc_input:
+            return None
 
         try:
-            csvline_decoded = file.readline().decode('utf-8')
-            dialect = csv.Sniffer().sniff(csvline_decoded)
-            file.open()
-            reader = csv.reader(codecs.iterdecode(file, 'utf-8'), dialect)
-            headers = [h.lower() for h in next(reader)]
-
-            # Handle utf-8-sig encoding
-            if "\ufeff" in headers[0]:
-                reader = csv.reader(codecs.iterdecode(file, 'utf-8-sig'), dialect)
-                headers = [h.lower() for h in next(reader)]
-
-            csv_headers = self.organization.part_list_csv_headers()
-
-            try:
-                # Issue warning if unrecognized column header names appear in file.
-                csv_headers.validate_header_names(headers)
-            except CSVHeaderError as e:
-                self.warnings.append(e.__str__() + ". Columns ignored.")
+            return PartClass.objects.get(organization=self.organization, code=pc_input.split(':')[0])
+        except PartClass.DoesNotExist:
+            pc = PartClass.objects.filter(name__icontains=pc_input).order_by('name').first()
+            if pc:
+                return pc
+            self.add_error('part_class', 'Select a valid part class.')
+        return None
 
-            try:
-                # Make sure that required columns appear in the file, then convert whatever
-                # header synonym names were used to default header names.
-                hdr_assertions = [
-                    ('part_class', 'part_number', 'or'), # part_class OR part_number
-                    ('revision', 'in'), # CONTAINS revision
-                    ('value', 'value_units', 'and', 'description', 'or'), # (value AND value units) OR description
-                ]
-                csv_headers.validate_header_assertions(headers, hdr_assertions)
-                headers = csv_headers.get_defaults_list(headers)
-            except CSVHeaderError as e:
-                raise ValidationError(e.__str__() + ". Uploading stopped. No parts uploaded.", code='invalid')
 
-            row_count = 1  # Skip over header row
-            for row in reader:
-                row_count += 1
-                part_data = {}
+# ==========================================
+# PART FORMS
+# ==========================================
 
-                for idx, hdr in enumerate(headers):
-                    if idx == len(row): break
-                    part_data[hdr] = row[idx]
-
-                part_number = csv_headers.get_val_from_row(part_data, 'part_number')
-                part_class = csv_headers.get_val_from_row(part_data, 'part_class')
-                number_item = None
-                number_variation = None
-                revision = csv_headers.get_val_from_row(part_data, 'revision')
-                mpn = csv_headers.get_val_from_row(part_data, 'mpn')
-                mfg_name = csv_headers.get_val_from_row(part_data, 'mfg_name')
-                description = csv_headers.get_val_from_row(part_data, 'description')
-                value = csv_headers.get_val_from_row(part_data, 'value')
-                value_units = csv_headers.get_val_from_row(part_data, 'value_units')
-                seller_name = csv_headers.get_val_from_row(part_data, 'seller')
-                seller_part_number = csv_headers.get_val_from_row(part_data, 'seller_part_number')
-                unit_cost = csv_headers.get_val_from_row(part_data, 'unit_cost')
-                nre_cost = csv_headers.get_val_from_row(part_data, 'part_nre_cost')
-                moq = csv_headers.get_val_from_row(part_data, 'moq')
-                mpq = csv_headers.get_val_from_row(part_data, 'minimum_pack_quantity')
-
-                # Check part number for uniqueness. If part number not specified
-                # then Part.save() will create one.
-                if part_number:
-                    if self.organization.number_scheme == NUMBER_SCHEME_SEMI_INTELLIGENT:
-                        try:
-                            (number_class, number_item, number_variation) = Part.parse_part_number(part_number, self.organization)
-                            part_class = PartClass.objects.get(code=number_class, organization=self.organization)
-                            Part.objects.get(number_class=part_class, number_item=number_item, number_variation=number_variation, organization=self.organization)
-                            self.add_error(None, "Part number {0} in row {1} already exists. Uploading of this part skipped.".format(part_number, row_count))
-                            continue
-                        except AttributeError as e:
-                            self.add_error(None, str(e) + " on row {}. Creation of this part skipped.".format(row_count))
-                            continue
-                        except PartClass.DoesNotExist:
-                            self.add_error(None, "No part class found for part number {0} in row {1}. Creation of this part skipped.".format(part_number, row_count))
-                            continue
-                        except Part.DoesNotExist:
-                            pass
-                    else:
-                        try:
-                            number_item = part_number
-                            Part.objects.get(number_class=None, number_item=number_item, number_variation=None, organization=self.organization)
-                            self.add_error(None, f"Part number {part_number} in row {row_count} already exists. Uploading of this part skipped.")
-                            continue
-                        except Part.DoesNotExist:
-                            pass
-                elif part_class:
-                    try:
-                        part_class = PartClass.objects.get(code=part_data[csv_headers.get_default('part_class')], organization=self.organization)
-                    except PartClass.DoesNotExist:
-                        self.add_error(None, "Part class {0} in row {1} doesn't exist. Create part class on Settings > IndaBOM and try again."
-                                             "Uploading of this part skipped.".format(part_data[csv_headers.get_default('part_class')], row_count))
-                        continue
-                else:
-                    if self.organization.number_scheme == NUMBER_SCHEME_SEMI_INTELLIGENT:
-                        self.add_error(None, "In row {} need to specify a part_class or part_number. Uploading of this part skipped.".format(row_count))
-                    else:
-                        self.add_error(None, "In row {} need to specify a part_number. Uploading of this part skipped.".format(row_count))
-                    continue
-
-                if not revision:
-                    self.add_error(None, f"Missing revision in row {row_count}. Uploading of this part skipped.")
-                    continue
-                elif len(revision) > 4:
-                    self.add_error(None, "Revision {0} in row {1} is more than the maximum 4 characters. "
-                                         "Uploading of this part skipped.".format(part_data[csv_headers.get_default('revision')], row_count))
-                    continue
-                elif revision.isdigit() and int(revision) < 0:
-                    self.add_error(None, "Revision {0} in row {1} cannot be a negative number. "
-                                         "Uploading of this part skipped.".format(part_data[csv_headers.get_default('revision')], row_count))
-                    continue
-
-                if mpn and mfg_name:
-                    manufacturer_part = ManufacturerPart.objects.filter(manufacturer_part_number=mpn,
-                                                                        manufacturer__name=mfg_name,
-                                                                        manufacturer__organization=self.organization)
-                    if manufacturer_part.count() > 0:
-                        self.add_error(None, "Part already exists for manufacturer part {0} in row {1}. "
-                                             "Uploading of this part skipped.".format(row_count, mpn, row_count))
-                        continue
-
-                skip = False
-                part_revision = PartRevision()
-                part_revision.revision = revision
-
-                # Required properties:
-                if description is None:
-                    if value is None and value_units is None:
-                        self.add_error(None, "Missing 'description' or 'value' plus 'value_units' for part in row {}. Uploading of this part skipped.".format(row_count))
-                        skip = True
-                        break
-                    elif value is None and value_units is not None:
-                        self.add_error(None, "Missing 'value' for part in row {}. Uploading of this part skipped.".format(row_count))
-                        skip = True
-                        break
-                    elif value is not None and value_units is None:
-                        self.add_error(None, "Missing 'value_units' for part in row {}. Uploading of this part skipped.".format(row_count))
-                        skip = True
-                        break
-
-                part_revision.description = description
-
-                # Part revision's value and value_units set below, after have had a chance to validate unit choice.
-
-                def is_valid_choice(choice, choices):
-                    for c in choices:
-                        if choice == c[0]:
-                            return True
-                    return False
-
-                # Optional properties with free-form values:
-                props_free_form = ['tolerance', 'pin_count', 'color', 'material', 'finish', 'attribute']
-                for prop_free_form in props_free_form:
-                    prop_free_form = csv_headers.get_default(prop_free_form)
-                    if prop_free_form in part_data:
-                        setattr(part_revision, prop_free_form, part_data[prop_free_form])
-
-                # Optional properties with choices for values:
-                props_with_value_choices = {'package': PACKAGE_TYPES, 'interface': INTERFACE_TYPES}
-                for k, v in props_with_value_choices.items():
-                    k = csv_headers.get_default(k)
-                    if k in part_data:
-                        if is_valid_choice(part_data[k], v):
-                            setattr(part_revision, k, part_data[k])
-                        else:
-                            self.warnings.append("'{0}' is an invalid choice of value for '{1}' for part in row {2} . Uploading of this property skipped. "
-                                                       "Part will still be uploaded".format(part_data[k], k, row_count))
-
-                # Optional properties with units:
-                props_with_unit_choices = {
-                    'value': VALUE_UNITS,
-                    'supply_voltage': VOLTAGE_UNITS, 'power_rating': POWER_UNITS,
-                    'voltage_rating': VOLTAGE_UNITS, 'current_rating': CURRENT_UNITS,
-                    'temperature_rating': TEMPERATURE_UNITS, 'memory': MEMORY_UNITS,
-                    'frequency': FREQUENCY_UNITS, 'wavelength': WAVELENGTH_UNITS,
-                    'length': DISTANCE_UNITS, 'width': DISTANCE_UNITS,
-                    'height': DISTANCE_UNITS, 'weight': WEIGHT_UNITS,
-                }
-                for k, v in props_with_unit_choices.items():
-                    k = csv_headers.get_default(k)
-                    if k in part_data and k + '_units' in part_data:
-                        if part_data[k] and not part_data[k + '_units']:
-                            self.add_error(None, "Missing '{0}' for part in row {1}. Uploading of this part skipped.".format(k, row_count))
-                            skip = True
-                            break
-                        elif not part_data[k] and part_data[k + '_units']:
-                            self.add_error(None, "Missing '{0}' for part in row {1}. Uploading of this part skipped.".format(k + '_units', row_count))
-                            skip = True
-                            break
-                        elif part_data[k + '_units']:
-                            if is_valid_choice(part_data[k + '_units'], v):
-                                setattr(part_revision, k, part_data[k])
-                                setattr(part_revision, k + '_units', part_data[k + '_units'])
-                            else:
-                                self.add_error(None, "'{0}' is an invalid choice of units for '{1}' for part in row {2}. Uploading of this part skipped."
-                                               .format(part_data[k + '_units'], k + '_units', row_count))
-                                skip = True
-                                break
-
-                if self.organization.number_scheme == NUMBER_SCHEME_INTELLIGENT and number_item is None:
-                    self.add_error(None, "Can't upload a part without a number_item header for part in row {}. Uploading of this part skipped.".format(row_count))
-                    skip = True
-
-                if skip:
-                    continue
-
-                PartForm = part_form_from_organization(self.organization)
-                part = Part(number_class=part_class, number_item=number_item, number_variation=number_variation, organization=self.organization)
-                part_dict = model_to_dict(part)
-                part_dict.update({'number_class': str(part.number_class)})
-                pf = PartForm(data=part_dict, organization=self.organization)
-                prf = PartRevisionForm(data=model_to_dict(part_revision))
-
-                if pf.is_valid() and prf.is_valid():
-                    part = pf.save(commit=False)
-                    part.organization = self.organization
-                    part.save()
-                    part_revision = prf.save(commit=False)
-                    part_revision.part = part
-                    part_revision.save()
-
-                    if mfg_name and mpn:
-                        mfg, created = Manufacturer.objects.get_or_create(name__iexact=mfg_name, organization=self.organization, defaults={'name': mfg_name})
-                        manufacturer_part, created = ManufacturerPart.objects.get_or_create(part=part, manufacturer_part_number=mpn, manufacturer=mfg)
-                        if part.primary_manufacturer_part is None and manufacturer_part is not None:
-                            part.primary_manufacturer_part = manufacturer_part
-                            part.save()
-
-                        if seller_name and unit_cost and nre_cost:
-                            seller, created = Seller.objects.get_or_create(name__iexact=seller_name, organization=self.organization, defaults={'name': seller_name})
-                            seller_part, created = SellerPart.objects.get_or_create(manufacturer_part=manufacturer_part, seller=seller, seller_part_number=seller_part_number, unit_cost=unit_cost, nre_cost=nre_cost, minimum_order_quantity=moq, minimum_pack_quantity=mpq)
-
-                    self.successes.append("Part {0} on row {1} created.".format(part.full_part_number(), row_count))
-                else:
-                    for k, error in prf.errors.items():
-                        for idx, msg in enumerate(error):
-                            error[idx] = f"Error on Row {row_count}, {k}: " + msg
-                        self.errors.update({k: error})
-                    for k, error in pf.errors.items():
-                        for idx, msg in enumerate(error):
-                            error[idx] = f"Error on Row {row_count}, {k}: " + msg
-                        self.errors.update({k: error})
-
-                # part = Part.objects.create(number_class=part_class, number_item=number_item, number_variation=number_variation, organization=self.organization)
+class BasePartForm(OrganizationFormMixin, PlaceholderMixin, forms.ModelForm):
+    """Base class for part forms to handle common init and placeholder logic."""
 
-        except UnicodeDecodeError as e:
-            self.add_error(None, forms.ValidationError("CSV File Encoding error, try encoding your file as utf-8, and upload again. \
-                If this keeps happening, reach out to info@indabom.com with your csv file and we'll do our best to \
-                fix your issue!", code='invalid'))
-            logger.warning("UnicodeDecodeError: {}".format(e))
-            raise ValidationError("Specific Error: {}".format(e), code='invalid')
+    def __init__(self, *args, **kwargs):
+        self.ignore_part_class = kwargs.pop('ignore_part_class', False)
+        self.ignore_unique_constraint = kwargs.pop('ignore_unique_constraint', False)
+        super().__init__(*args, **kwargs)
 
-        return cleaned_data
+        # Setup MFG Part Queryset if editing
+        if self.instance.pk:
+            self.fields['primary_manufacturer_part'].queryset = ManufacturerPart.objects.filter(
+                part__id=self.instance.id
+            ).order_by('manufacturer_part_number')
+        elif 'primary_manufacturer_part' in self.fields:
+            del self.fields['primary_manufacturer_part']
 
 
-class PartFormIntelligent(forms.ModelForm):
+class PartFormIntelligent(BasePartForm):
     class Meta:
         model = Part
-        exclude = ['number_class', 'number_variation', 'organization', 'google_drive_parent', ]
-        help_texts = {
-            'number_item': _('Enter a part number.'),
-        }
+        exclude = ['number_class', 'number_variation', 'organization', 'google_drive_parent']
+        help_texts = {'number_item': _('Enter a part number.')}
 
     def __init__(self, *args, **kwargs):
-        self.organization = kwargs.pop('organization', None)
-        self.ignore_number_class = kwargs.pop('ignore_part_class', False)
-        self.ignore_unique_constraint = kwargs.pop('ignore_unique_constraint', False)
-        super(PartFormIntelligent, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
         self.fields['number_item'].required = True
-        if self.instance and self.instance.id:
-            self.fields['primary_manufacturer_part'].queryset = ManufacturerPart.objects.filter(part__id=self.instance.id).order_by('manufacturer_part_number')
-        else:
-            del self.fields['primary_manufacturer_part']
-        for _, value in self.fields.items():
-            value.widget.attrs['placeholder'] = value.help_text
-            value.help_text = ''
 
-class PartFormSemiIntelligent(forms.ModelForm):
+
+class PartFormSemiIntelligent(BasePartForm):
     class Meta:
         model = Part
         exclude = ['organization', 'google_drive_parent', ]
@@ -804,146 +571,164 @@ class PartFormSemiIntelligent(forms.ModelForm):
         }
 
     def __init__(self, *args, **kwargs):
-        self.organization = kwargs.pop('organization', None)
-        self.ignore_number_class = kwargs.pop('ignore_part_class', False)
-        self.ignore_unique_constraint = kwargs.pop('ignore_unique_constraint', False)
-        super(PartFormSemiIntelligent, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
         self.fields['number_item'].validators.append(alphanumeric)
-        self.fields['number_class'] = forms.CharField(label='Part Number Class*', required=True, help_text='Select a number class.',
-                                                      widget=AutocompleteTextInput(queryset=PartClass.objects.filter(organization=self.organization)))
-        if kwargs.get('instance', None):  # To check uniqueness
-            self.id = kwargs['instance'].id
-
-        if self.instance and self.instance.id:
-            self.fields['primary_manufacturer_part'].queryset = ManufacturerPart.objects.filter(part__id=self.instance.id).order_by('manufacturer_part_number')
-        else:
-            del self.fields['primary_manufacturer_part']
-        for _, value in self.fields.items():
-            value.widget.attrs['placeholder'] = value.help_text
-            value.help_text = ''
+        self.fields['number_class'] = forms.CharField(
+            label='Part Number Class*', required=True,
+            help_text='Select a number class.',
+            widget=AutocompleteTextInput(queryset=PartClass.objects.filter(organization=self.organization))
+        )
 
+        # Convert ID to string for Autocomplete
         if self.initial.get('number_class'):
             try:
-                part_class = PartClass.objects.get(id=self.initial['number_class'])
-                self.initial['number_class'] = str(part_class)
+                self.initial['number_class'] = str(PartClass.objects.get(id=self.initial['number_class']))
             except PartClass.DoesNotExist:
                 self.initial['number_class'] = ""
 
-        if self.ignore_number_class:
-            self.fields.get('number_class').required = False
+        if self.ignore_part_class:
+            self.fields['number_class'].required = False
 
     def clean_number_class(self):
-        if self.ignore_number_class:
-            return None
-        number_class = self.cleaned_data['number_class']
+        if self.ignore_part_class: return None
+        nc = self.cleaned_data['number_class']
         try:
-            return PartClass.objects.get(organization=self.organization, code=number_class.split(':')[0])
+            return PartClass.objects.get(organization=self.organization, code=nc.split(':')[0])
         except PartClass.DoesNotExist:
-            self.add_error('number_class', f'Select an existing part class, or create `{number_class}` in Settings.')
+            self.add_error('number_class', f'Select an existing part class, or create `{nc}` in Settings.')
         return None
 
     def clean(self):
-        cleaned_data = super(PartFormSemiIntelligent, self).clean()
-        number_item = cleaned_data.get('number_item')
-        number_class = cleaned_data.get('number_class')
-        number_variation = cleaned_data.get('number_variation')
+        cleaned_data = super().clean()
+        n_item = cleaned_data.get('number_item')
+        n_class = cleaned_data.get('number_class')
+        n_var = cleaned_data.get('number_variation')
 
+        # Format Verification
         try:
-            if number_class is not None and number_class.code != '':
-                Part.verify_format_number_class(number_class.code, self.organization)
+            if n_class and n_class.code: Part.verify_format_number_class(n_class.code, self.organization)
         except AttributeError as e:
-            validation_error = forms.ValidationError(str(e), code='invalid')
-            self.add_error('number_class', validation_error)
+            self.add_error('number_class', str(e))
 
         try:
-            if number_item is not None and number_item != '':
-                Part.verify_format_number_item(number_item, self.organization)
+            if n_item: Part.verify_format_number_item(n_item, self.organization)
         except AttributeError as e:
-            validation_error = forms.ValidationError(str(e), code='invalid')
-            self.add_error('number_item', validation_error)
+            self.add_error('number_item', str(e))
 
         try:
-            if number_variation:
-                Part.verify_format_number_variation(number_variation, self.organization)
+            if n_var: Part.verify_format_number_variation(n_var, self.organization)
         except AttributeError as e:
-            validation_error = forms.ValidationError(str(e), code='invalid')
-            self.add_error('number_variation', validation_error)
+            self.add_error('number_variation', str(e))
 
-        if self.ignore_unique_constraint:
-            return cleaned_data
-
-        part = Part.objects.filter(
-            number_class=number_class,
-            number_item=number_item,
-            number_variation=number_variation,
-            organization=self.organization
-        )
+        # Uniqueness Check
+        if not self.ignore_unique_constraint:
+            qs = Part.objects.filter(number_class=n_class, number_item=n_item, number_variation=n_var,
+                                     organization=self.organization)
+            if self.instance.pk: qs = qs.exclude(pk=self.instance.pk)
 
-        try:
-            part = part.exclude(pk=self.id)
-        except AttributeError:
-            pass
+            if qs.exists():
+                self.add_error(None, f"Part number {n_class.code}-{n_item}-{n_var} already in use.")
 
-        if part.count() > 0:
-            validation_error = forms.ValidationError(
-                ("Part number {0}-{1}-{2} already in use.".format(number_class.code, number_item, number_variation)),
-                code='invalid')
-            self.add_error(None, validation_error)
         return cleaned_data
 
 
-class PartRevisionForm(forms.ModelForm):
+class PartRevisionForm(OrganizationFormMixin, PlaceholderMixin, forms.ModelForm):
     class Meta:
         model = PartRevision
         exclude = ['timestamp', 'assembly', 'part']
-        help_texts = {
-            'description': _('Additional part info, special instructions, etc.'),
-            'attribute': _('Additional part attributes (free form)'),
-            'value': _('Number or text'),
-        }
+        help_texts = {'description': _('Additional part info, special instructions, etc.')}
 
     def __init__(self, *args, **kwargs):
-        super(PartRevisionForm, self).__init__(*args, **kwargs)
-
+        self.part_class = kwargs.pop('part_class', None)
+        super().__init__(*args, **kwargs)
         self.fields['revision'].initial = 1
         self.fields['configuration'].required = False
+        if not self.part_class and self.instance.pk:
+            self.part_class = self.instance.part.number_class
+
+        if self.part_class:
+            self.property_definitions = self.part_class.property_definitions.all().order_by('name')
+        elif self.organization.number_scheme == NUMBER_SCHEME_INTELLIGENT:
+            self.property_definitions = PartRevisionPropertyDefinition.objects.available_to(self.organization).order_by(
+                'name')
+        else:
+            self.property_definitions = PartRevisionPropertyDefinition.objects.none()
 
-        self.fields['tolerance'].initial = '%'
-
-        # Fix up field labels to be succinct for use in rendered form:
-        for f in self.fields.values():
-            if 'units' in f.label: f.label = 'Units'
-            f.label.replace('rating', '')
-            # f.value = strip_trailing_zeros(f.value) # Harmless if field is not a number
-        self.fields['supply_voltage'].label = 'Vsupply'
-        self.fields['attribute'].label = ''
-
-        for _, value in self.fields.items():
-            value.widget.attrs['placeholder'] = value.help_text
-            value.help_text = ''
+        self._init_dynamic_properties()
 
-        if self.instance and not self.data.get('description') and self.instance.description:
-            self.data['description'] = self.instance.description
+    def _init_dynamic_properties(self):
+        """Dynamically add fields based on Property Definitions."""
+        model_field = PartRevisionProperty._meta.get_field('value_raw')
+        for pd in self.property_definitions:
+            field_name = pd.form_field_name
+            if self.organization.number_scheme == NUMBER_SCHEME_INTELLIGENT:
+                req = False
+            else:
+                req = pd.required
 
-    def clean(self):
-        cleaned_data = super(PartRevisionForm, self).clean()
-
-        if not cleaned_data.get('description') and not cleaned_data.get('value'):
-            validation_error = forms.ValidationError("Must specify either a description or both value and value units.", code='invalid')
-            self.add_error('description', validation_error)
-            self.add_error('value', validation_error)
-
-        for key in self.fields.keys():
-            if '_units' in key:
-                value_name = str.replace(key, '_units', '')
-                value = cleaned_data.get(value_name)
-                units = cleaned_data.get(key)
-                if not value and units:
-                    self.add_error(key, forms.ValidationError(f"Cannot specify {units} without an accompanying value", code='invalid'))
-                elif units and not units:
-                    self.add_error(key, forms.ValidationError(f"Cannot specify value {units} without an accompanying units", code='invalid'))
+            if pd.type == PART_REVISION_PROPERTY_TYPE_DECIMAL:
+                self.fields[field_name] = forms.DecimalField(label=pd.name, required=req)
+            elif pd.type == PART_REVISION_PROPERTY_TYPE_BOOLEAN:
+                self.fields[field_name] = forms.BooleanField(label=pd.name, required=req)
+            else:
+                self.fields[field_name] = forms.CharField(label=pd.name, required=req,
+                                                          max_length=model_field.max_length,
+                                                          widget=forms.TextInput(
+                                                              attrs={'maxlength': str(model_field.max_length)}))
+
+            # Pre-fill
+            prop = None
+            if self.instance.pk:
+                prop = self.instance.properties.filter(property_definition=pd).first()
+                if prop: self.fields[field_name].initial = prop.value_raw
+
+            # Unit Logic
+            if pd.quantity_of_measure:
+                unit_field = pd.form_unit_field_name
+                units = UnitDefinition.objects.filter(quantity_of_measure=pd.quantity_of_measure)
+                choices = [('', '---------')] + [(u.id, u.symbol) for u in units]
+                self.fields[unit_field] = forms.ChoiceField(choices=choices, required=False, label=f"{pd.name} Unit")
+                if self.instance.pk and prop and prop.unit_definition:
+                    self.fields[unit_field].initial = prop.unit_definition.id
+
+    def property_fields(self):
+        """Yields property fields grouped with their corresponding unit fields."""
+        for pd in self.property_definitions:
+            yield {
+                'property': self[pd.form_field_name],
+                'unit': self[pd.form_unit_field_name] if pd.quantity_of_measure else None,
+            }
+
+    @property
+    def property_field_names(self):
+        """Returns a list of all field names associated with dynamic properties."""
+        names = []
+        for pd in self.property_definitions:
+            names.append(pd.form_field_name)
+            if pd.quantity_of_measure:
+                names.append(pd.form_unit_field_name)
+        return names
+
+    def save_properties(self):
+        for defn in self.property_definitions:
+            val = self.cleaned_data.get(defn.form_field_name)
+            if val not in (None, ''):
+                unit_id = self.cleaned_data.get(defn.form_unit_field_name)
+                unit = UnitDefinition.objects.get(id=unit_id) if unit_id else None
+                PartRevisionProperty.objects.update_or_create(
+                    part_revision=self.instance, property_definition=defn,
+                    defaults={'value_raw': str(val), 'unit_definition': unit}
+                )
+            else:
+                PartRevisionProperty.objects.filter(part_revision=self.instance, property_definition=defn).delete()
 
-        return cleaned_data
+    def save(self, commit=True):
+        instance = super().save(commit=False)
+        if commit:
+            instance.save()
+            self.save_m2m()
+            self.save_properties()
+        return instance
 
 
 class PartRevisionNewForm(PartRevisionForm):
@@ -953,109 +738,82 @@ class PartRevisionNewForm(PartRevisionForm):
         self.part = kwargs.pop('part', None)
         self.revision = kwargs.pop('revision', None)
         self.assembly = kwargs.pop('assembly', None)
-        super(PartRevisionNewForm, self).__init__(*args, **kwargs)
-        for _, value in self.fields.items():
-            value.widget.attrs['placeholder'] = value.help_text
-            value.help_text = ''
-
-    def save(self):
-        cleaned_data = super(PartRevisionNewForm, self).clean()
-        self.instance.part = self.part
-        self.instance.revision = self.revision
-        self.instance.assembly = self.assembly
-        self.instance.save()
-        return self.instance
+        super().__init__(*args, **kwargs)
+
+    def save(self, commit=True):
+        if not self.instance.pk:
+            self.instance.part = self.part
+            self.instance.revision = self.revision
+            self.instance.assembly = self.assembly
+        else:
+            # If we are incrementing from an existing instance, we want to create a NEW record
+            self.instance.pk = None
+            self.instance.part = self.part
+            self.instance.revision = self.revision
+            self.instance.assembly = self.assembly
+        return super().save(commit=commit)
+
 
+# ==========================================
+# SUBPART / BOM FORMS
+# ==========================================
 
-class SubpartForm(forms.ModelForm):
+class SubpartForm(OrganizationFormMixin, forms.ModelForm):
     class Meta:
         model = Subpart
         fields = ['part_revision', 'reference', 'count', 'do_not_load']
 
     def __init__(self, *args, **kwargs):
-        self.organization = kwargs.pop('organization', None)
         self.part_id = kwargs.pop('part_id', None)
         self.ignore_part_revision = kwargs.pop('ignore_part_revision', False)
-        super(SubpartForm, self).__init__(*args, **kwargs)
-        if self.part_id is None:
+        super().__init__(*args, **kwargs)
+
+        if not self.part_id:
             self.Meta.exclude = ['part_revision']
         else:
-            self.fields['part_revision'].queryset = PartRevision.objects.filter(
-                part__id=self.part_id).order_by('-timestamp')
-        if self.ignore_part_revision:
-            self.fields.get('part_revision').required = False
+            self.fields['part_revision'].queryset = PartRevision.objects.filter(part__id=self.part_id).order_by(
+                '-timestamp')
 
-        if self.part_id:
-            part = Part.objects.get(id=self.part_id)
-            unusable_part_ids = [p.id for p in part.where_used_full()]
-            unusable_part_ids.append(part.id)
+        if self.ignore_part_revision:
+            self.fields['part_revision'].required = False
 
     def clean_count(self):
-        count = self.cleaned_data['count']
-        if not count:
-            count = 0
-        return count
+        return self.cleaned_data['count'] or 0
 
     def clean_reference(self):
-        reference = self.cleaned_data['reference']
-        reference = stringify_list(listify_string(reference))
-        return reference
-
-    def clean_part_revision(self):
-        if self.ignore_part_revision:
-            return None
-        part_revision = self.cleaned_data['part_revision']
-        return part_revision
+        return stringify_list(listify_string(self.cleaned_data['reference']))
 
     def clean(self):
-        cleaned_data = super(SubpartForm, self).clean()
-        reference_list = listify_string(cleaned_data.get('reference'))
+        cleaned_data = super().clean()
+        refs = listify_string(cleaned_data.get('reference'))
         count = cleaned_data.get('count')
-
-        if len(reference_list) > 0 and len(reference_list) != count:
-            raise forms.ValidationError(
-                ("The number of reference designators ({0}) did not match the subpart quantity ({1}).".format(len(reference_list), count)),
-                code='invalid')
-
+        if len(refs) > 0 and len(refs) != count:
+            raise ValidationError(f"Reference designators count ({len(refs)}) mismatch subpart quantity ({count}).")
         return cleaned_data
 
 
-class AddSubpartForm(forms.Form):
-    subpart_part_number = forms.CharField(required=True, label="Subpart part number")
+class AddSubpartForm(OrganizationFormMixin, forms.Form):
+    subpart_part_number = forms.CharField(label="Subpart part number", required=True)
     count = forms.FloatField(required=False, label='Quantity')
     reference = forms.CharField(required=False, label="Reference")
     do_not_load = forms.BooleanField(required=False, label="do_not_load")
 
     def __init__(self, *args, **kwargs):
-        self.organization = kwargs.pop('organization', None)
         self.part_id = kwargs.pop('part_id', None)
-        self.part = Part.objects.get(id=self.part_id)
-        self.part_revision = self.part.latest()
-        self.unusable_part_rev_ids = [pr.id for pr in self.part_revision.where_used_full()]
-        self.unusable_part_rev_ids.append(self.part_revision.id)
-        super(AddSubpartForm, self).__init__(*args, **kwargs)
-        self.fields['subpart_part_number'] = forms.CharField(required=True, label="Subpart part number",
-                                                    widget=AutocompleteTextInput(attrs={'placeholder': 'Select a part.'},
-                                                                                 queryset=Part.objects.filter(organization=self.organization).exclude(id=self.part_id),
-                                                                                 verbose_string_function=Part.verbose_str))
-
-    def clean_count(self):
-        count = self.cleaned_data['count']
-        if not count:
-            count = 0
-        return count
+        super().__init__(*args, **kwargs)
 
-    def clean_reference(self):
-        reference = self.cleaned_data['reference']
-        reference = stringify_list(listify_string(reference))
-        return reference
+        self.part = Part.objects.get(id=self.part_id)
+        # Filter logic
+        self.fields['subpart_part_number'].widget = AutocompleteTextInput(
+            attrs={'placeholder': 'Select a part.'},
+            queryset=Part.objects.filter(organization=self.organization).exclude(id=self.part_id),
+            verbose_string_function=Part.verbose_str
+        )
 
     def clean_subpart_part_number(self):
         subpart_part_number = self.cleaned_data['subpart_part_number']
-
         if not subpart_part_number:
-            validation_error = forms.ValidationError("Must specify a part number.", code='invalid')
-            self.add_error('subpart_part_number', validation_error)
+            raise ValidationError("Must specify a part number.")
 
         try:
             if self.organization.number_scheme == NUMBER_SCHEME_INTELLIGENT:
@@ -1068,333 +826,503 @@ class AddSubpartForm(forms.Form):
             if self.subpart_part is None:
                 self.add_error('subpart_part_number', f"No part revision exists for part {part.full_part_number()}. Create a revision before adding to an assembly.")
                 return subpart_part_number
-            if self.subpart_part.id in self.unusable_part_rev_ids:
-                validation_error = forms.ValidationError("Infinite recursion! Can't add a part to its self.", code='invalid')
-                self.add_error('subpart_part_number', validation_error)
-        except AttributeError as e:
-            validation_error = forms.ValidationError("Ill-formed subpart part number... " + str(e) + ".", code='invalid')
-            self.add_error('subpart_part_number', validation_error)
-        except PartClass.DoesNotExist:
-            validation_error = forms.ValidationError(f"No part class for in given part number {subpart_part_number}.", code='invalid')
-            self.add_error('subpart_part_number', validation_error)
-        except Part.DoesNotExist:
-            validation_error = forms.ValidationError(f"No part found with given part number {subpart_part_number}.", code='invalid')
-            self.add_error('subpart_part_number', validation_error)
 
-        return subpart_part_number
+            unusable_ids = [pr.id for pr in self.part.latest().where_used_full()] + [self.part.latest().id]
+            if self.subpart_part.id in unusable_ids:
+                raise ValidationError("Infinite recursion! Can't add a part to itself.")
 
-    def clean(self):
-        cleaned_data = super(AddSubpartForm, self).clean()
-        reference_list = listify_string(cleaned_data.get('reference'))
-        count = cleaned_data.get('count')
-
-        if len(reference_list) > 0 and len(reference_list) != count:
-            raise forms.ValidationError(
-                ("The number of reference designators ({0}) did not match the subpart quantity ({1}).".format(len(reference_list), count)),
-                code='invalid')
+        except (AttributeError, PartClass.DoesNotExist, Part.DoesNotExist) as e:
+            raise ValidationError(f"Invalid part number: {e}")
 
-        return cleaned_data
+        return subpart_part_number
 
+    def clean_count(self):
+        return self.cleaned_data.get('count') or 0
 
-class UploadBOMForm(forms.Form):
-    parent_part_number = forms.CharField(required=False, label="Parent part number")
+    def clean_reference(self):
+        return stringify_list(listify_string(self.cleaned_data.get('reference')))
 
-    def __init__(self, *args, **kwargs):
-        self.organization = kwargs.pop('organization', None)
-        self.parent_part = kwargs.pop('parent_part', None)
-        super(UploadBOMForm, self).__init__(*args, **kwargs)
+    def clean(self):
+        cleaned = super().clean()
+        refs = listify_string(cleaned.get('reference'))
+        count = cleaned.get('count')
+        if len(refs) > 0 and len(refs) != count:
+            raise ValidationError(f"Reference count ({len(refs)}) mismatch quantity ({count}).")
+        return cleaned
+
+
+# ==========================================
+# CSV IMPORT FORMS
+# ==========================================
+
+class PartClassCSVForm(BaseCSVForm):
+    def get_csv_headers_handler(self):
+        return PartClassesCSVHeaders()
+
+    def get_header_assertions(self):
+        return [
+            ('comment', 'description', 'mex'),
+            ('code', 'in'),
+            ('name', 'in'),
+        ]
+
+    def process_row(self, row_data, row_count, csv_headers):
+        name = csv_headers.get_val_from_row(row_data, 'name')
+        code = csv_headers.get_val_from_row(row_data, 'code')
+        desc = csv_headers.get_val_from_row(row_data, 'description')
+        comment = csv_headers.get_val_from_row(row_data, 'comment')
+
+        if not code:
+            self.add_error(None, f"Row {row_count}: Missing code.")
+            return
+
+        if len(code) != self.organization.number_class_code_len:
+            self.add_error(None, f"Row {row_count}: Invalid code length.")
+            return
+
+        description = desc or comment or ''
+        try:
+            PartClass.objects.create(code=code, name=name, comment=description, organization=self.organization)
+            self.successes.append(f"Part class {code} {name} on row {row_count} created.")
+        except IntegrityError:
+            self.add_error(None, f"Row {row_count}: Part class {code} {name} already defined.")
 
-    def clean_parent_part_number(self):
-        parent_part_number = self.cleaned_data['parent_part_number']
 
-        if parent_part_number: #  not required, so only validate if its provided
+class PartCSVForm(BaseCSVForm):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # Pre-fetch valid units
+        self.valid_units = {u.symbol: u.id for u in UnitDefinition.objects.available_to(self.organization)}
+
+    def get_csv_headers_handler(self):
+        return self.organization.part_list_csv_headers()
+
+    def get_header_assertions(self):
+        return [
+            ('part_class', 'part_number', 'or'),
+            ('revision', 'in'),
+            ('value', 'value_units', 'and', 'description', 'or'),
+        ]
+
+    def process_row(self, row_data, row_count, csv_headers):
+        part_number = csv_headers.get_val_from_row(row_data, 'part_number')
+        part_class = csv_headers.get_val_from_row(row_data, 'part_class')
+        number_item = None
+        number_variation = None
+        revision = csv_headers.get_val_from_row(row_data, 'revision')
+        mpn = csv_headers.get_val_from_row(row_data, 'mpn')
+        mfg_name = csv_headers.get_val_from_row(row_data, 'mfg_name')
+        description = csv_headers.get_val_from_row(row_data, 'description')
+        seller_name = csv_headers.get_val_from_row(row_data, 'seller')
+        seller_part_number = csv_headers.get_val_from_row(row_data, 'seller_part_number')
+        unit_cost = csv_headers.get_val_from_row(row_data, 'unit_cost')
+        nre_cost = csv_headers.get_val_from_row(row_data, 'part_nre_cost')
+        moq = csv_headers.get_val_from_row(row_data, 'moq')
+        mpq = csv_headers.get_val_from_row(row_data, 'minimum_pack_quantity')
+
+        # Check part number for uniqueness. If part number not specified
+        # then Part.save() will create one.
+        if part_number:
+            if self.organization.number_scheme == NUMBER_SCHEME_SEMI_INTELLIGENT:
+                try:
+                    (number_class, number_item, number_variation) = Part.parse_part_number(part_number,
+                                                                                           self.organization)
+                    part_class = PartClass.objects.get(code=number_class, organization=self.organization)
+                    Part.objects.get(number_class=part_class, number_item=number_item,
+                                     number_variation=number_variation, organization=self.organization)
+                    self.add_error(None,
+                                   "Part number {0} in row {1} already exists. Uploading of this part skipped.".format(
+                                       part_number, row_count))
+                    return
+                except AttributeError as e:
+                    self.add_error(None, str(e) + " on row {}. Creation of this part skipped.".format(row_count))
+                    return
+                except PartClass.DoesNotExist:
+                    self.add_error(None,
+                                   "No part class found for part number {0} in row {1}. Creation of this part skipped.".format(
+                                       part_number, row_count))
+                    return
+                except Part.DoesNotExist:
+                    pass
+            else:
+                try:
+                    number_item = part_number
+                    Part.objects.get(number_class=None, number_item=number_item, number_variation=None,
+                                     organization=self.organization)
+                    self.add_error(None,
+                                   f"Part number {part_number} in row {row_count} already exists. Uploading of this part skipped.")
+                    return
+                except Part.DoesNotExist:
+                    pass
+        elif part_class:
             try:
-                self.parent_part = Part.from_part_number(parent_part_number, self.organization)
-            except AttributeError as e:
-                validation_error = forms.ValidationError("Ill-formed parent part number... " + str(e) + ".", code='invalid')
-                self.add_error('parent_part_number', validation_error)
-            except Part.DoesNotExist:
-                validation_error = forms.ValidationError(("Parent part not found with given part number {}.".format(parent_part_number)), code='invalid')
-                self.add_error('parent_part_number', validation_error)
+                part_class = PartClass.objects.get(code=row_data[csv_headers.get_default('part_class')],
+                                                   organization=self.organization)
+            except PartClass.DoesNotExist:
+                self.add_error(None,
+                               "Part class {0} in row {1} doesn't exist. Create part class on Settings > IndaBOM and try again."
+                               "Uploading of this part skipped.".format(
+                                   row_data[csv_headers.get_default('part_class')], row_count))
+                return
+        else:
+            if self.organization.number_scheme == NUMBER_SCHEME_SEMI_INTELLIGENT:
+                self.add_error(None,
+                               "In row {} need to specify a part_class or part_number. Uploading of this part skipped.".format(
+                                   row_count))
+            else:
+                self.add_error(None, "In row {} need to specify a part_number. Uploading of this part skipped.".format(
+                    row_count))
+            return
+
+        if not revision:
+            self.add_error(None, f"Missing revision in row {row_count}. Uploading of this part skipped.")
+            return
+        elif len(revision) > 4:
+            self.add_error(None, "Revision {0} in row {1} is more than the maximum 4 characters. "
+                                 "Uploading of this part skipped.".format(
+                row_data[csv_headers.get_default('revision')], row_count))
+            return
+        elif revision.isdigit() and int(revision) < 0:
+            self.add_error(None, "Revision {0} in row {1} cannot be a negative number. "
+                                 "Uploading of this part skipped.".format(
+                row_data[csv_headers.get_default('revision')], row_count))
+            return
+
+        if mpn and mfg_name:
+            manufacturer_part = ManufacturerPart.objects.filter(manufacturer_part_number=mpn,
+                                                                manufacturer__name=mfg_name,
+                                                                manufacturer__organization=self.organization)
+            if manufacturer_part.count() > 0:
+                self.add_error(None, "Part already exists for manufacturer part {0} in row {1}. "
+                                     "Uploading of this part skipped.".format(row_count, mpn, row_count))
+                return
+
+        skip = False
+        row_data['revision'] = revision
+        row_data['description'] = description
+
+        if self.organization.number_scheme == NUMBER_SCHEME_INTELLIGENT and number_item is None:
+            self.add_error(None,
+                           "Can't upload a part without a number_item header for part in row {}. Uploading of this part skipped.".format(
+                               row_count))
+            skip = True
+
+        if skip:
+            return
+
+        PartForm = part_form_from_organization(self.organization)
+        part = Part(number_class=part_class, number_item=number_item, number_variation=number_variation,
+                    organization=self.organization)
+        part_dict = model_to_dict(part)
+        part_dict.update({'number_class': str(part.number_class)})
+        pf = PartForm(data=part_dict, organization=self.organization)
+        prf = PartRevisionForm(data=row_data, part_class=part_class, organization=self.organization)
+
+        if pf.is_valid() and prf.is_valid():
+            part = pf.save(commit=False)
+            part.organization = self.organization
+            part.save()
+            part_revision = prf.save(commit=False)
+            part_revision.part = part
+            part_revision.save()
+
+            if mfg_name and mpn:
+                mfg, created = Manufacturer.objects.get_or_create(name__iexact=mfg_name, organization=self.organization,
+                                                                  defaults={'name': mfg_name})
+                manufacturer_part, created = ManufacturerPart.objects.get_or_create(part=part,
+                                                                                    manufacturer_part_number=mpn,
+                                                                                    manufacturer=mfg)
+                if part.primary_manufacturer_part is None and manufacturer_part is not None:
+                    part.primary_manufacturer_part = manufacturer_part
+                    part.save()
 
-        return parent_part_number
+                if seller_name and unit_cost and nre_cost:
+                    seller, created = Seller.objects.get_or_create(name__iexact=seller_name,
+                                                                   organization=self.organization,
+                                                                   defaults={'name': seller_name})
+                    seller_part, created = SellerPart.objects.get_or_create(manufacturer_part=manufacturer_part,
+                                                                            seller=seller,
+                                                                            seller_part_number=seller_part_number,
+                                                                            unit_cost=unit_cost, nre_cost=nre_cost,
+                                                                            minimum_order_quantity=moq,
+                                                                            minimum_pack_quantity=mpq)
+
+            self.successes.append("Part {0} on row {1} created.".format(part.full_part_number(), row_count))
+        else:
+            for k, error in prf.errors.items():
+                for idx, msg in enumerate(error):
+                    error[idx] = f"Error on Row {row_count}, {k}: " + msg
+                self.errors.update({k: error})
+            for k, error in pf.errors.items():
+                for idx, msg in enumerate(error):
+                    error[idx] = f"Error on Row {row_count}, {k}: " + msg
+                self.errors.update({k: error})
 
 
-class BOMCSVForm(forms.Form):
-    file = forms.FileField(required=False)
-
+class BOMCSVForm(BaseCSVForm):
     def __init__(self, *args, **kwargs):
-        self.organization = kwargs.pop('organization', None)
         self.parent_part = kwargs.pop('parent_part', None)
-        super(BOMCSVForm, self).__init__(*args, **kwargs)
-
-    def clean(self):
-        cleaned_data = super(BOMCSVForm, self).clean()
-        file = self.cleaned_data.get('file')
-        self.successes = list()
-        self.warnings = list()
+        super().__init__(*args, **kwargs)
+        self.parent_part_revision = self.parent_part.latest() if self.parent_part else None
+        self.part_revision_tree = [self.parent_part_revision] if self.parent_part_revision else []
+        self.last_level = None
+        self.last_part_revision = self.parent_part_revision
+
+    def get_csv_headers_handler(self):
+        return self.organization.bom_indented_csv_headers()
+
+    def get_header_assertions(self):
+        return [
+            ('part_number', 'manufacturer_part_number', 'or'),
+            ('quantity', 'in'),
+        ]
+
+    def process_row(self, part_dict, row_count, csv_headers):
+        dnp = csv_headers.get_val_from_row(part_dict, 'dnp')
+        reference = csv_headers.get_val_from_row(part_dict, 'reference')
+        part_number = csv_headers.get_val_from_row(part_dict, 'part_number')
+        manufacturer_part_number = csv_headers.get_val_from_row(part_dict, 'mpn')
+        manufacturer_name = csv_headers.get_val_from_row(part_dict, 'manufacturer_name')
 
         try:
-            csv_row_decoded = file.readline().decode('utf-8')
-            dialect = csv.Sniffer().sniff(csv_row_decoded)
-            file.open()
-
-            reader = csv.reader(codecs.iterdecode(file, 'utf-8'), dialect, quotechar='"', escapechar='\\')
-            headers = [h.lower() for h in next(reader)]
+            level = int(float(csv_headers.get_val_from_row(part_dict, 'level')))
+        except ValueError as e:
+            # TODO: May want to validate whole file has acceptable levels first.
+            raise ValidationError(f"Row {row_count} - level: invalid level, can't continue.", code='invalid')
+        except TypeError as e:
+            # no level field was provided, we MUST have a parent part number to upload this way, and in this case all levels are the same
+            if self.parent_part_revision is None:
+                raise ValidationError(
+                    f"Row {row_count} - level: must provide either level, or a parent part to upload a part.",
+                    code='invalid')
+            else:
+                level = 1
 
-            # Handle utf-8-sig encoding
-            if len(headers) > 0 and "\ufeff" in headers[0]:
-                reader = csv.reader(codecs.iterdecode(file, 'utf-8-sig'), dialect, quotechar='"', escapechar='\\')
-                headers = [h.lower() for h in next(reader)]
-            elif len(headers) == 0:
-                self.warnings.append("No headers found in CSV file.")
+        if self.last_level is None:
+            self.last_level = level
 
-            csv_headers = BOMIndentedCSVHeaders()
+        # Extract some values
+        part_dict['reference'] = reference
+        part_dict['do_not_load'] = dnp in ['y', 'x', 'dnp', 'dnl', 'yes', 'true', ]
+        part_dict['revision'] = csv_headers.get_val_from_row(part_dict, 'revision') or 1
+        part_dict['count'] = csv_headers.get_val_from_row(part_dict, 'count')
+        part_dict['number_class'] = None
+        part_dict['number_variation'] = None
 
+        if part_number:
+            # TODO: Should this be in a clean function?
             try:
-                # Issue warning if unrecognized column header names appear in file.
-                csv_headers.validate_header_names(headers)
-            except CSVHeaderError as e:
-                self.warnings.append(e.__str__() + ". Columns ignored.")
-
+                (part_dict['number_class'], part_dict['number_item'],
+                 part_dict['number_variation']) = Part.parse_partial_part_number(part_number, self.organization)
+            except AttributeError as e:
+                self.add_error(None,
+                               f"Row {row_count} - part_number: Uploading of this subpart skipped. Couldn't parse part number.")
+                return
+        elif manufacturer_part_number:
             try:
-                # Make sure that required columns appear in the file, then convert whatever
-                # header synonym names were used to default header names.
-                hdr_assertions = [
-                    ('part_number', 'manufacturer_part_number', 'or'),  # part_class OR part_number
-                    ('quantity', 'in'),  # CONTAINS quantity
-                ]
-                csv_headers.validate_header_assertions(headers, hdr_assertions)
-                headers = csv_headers.get_defaults_list(headers)
-            except CSVHeaderError as e:
-                raise ValidationError(e.__str__() + ". Uploading stopped. No subparts uploaded.", code='invalid')
-
-            parent_part_revision = self.parent_part.latest() if self.parent_part else None
-
-            last_level = None
-            last_part_revision = parent_part_revision
-            part_revision_tree = [] if parent_part_revision is None else [parent_part_revision]
+                part = Part.from_manufacturer_part_number(manufacturer_part_number, self.organization)
+                if part is None:
+                    self.add_error(None,
+                                   f"Row {row_count} - manufacturer_part_number: Uploading of this subpart skipped. No part found for manufacturer part number.")
+                    return
+                part_dict['number_class'] = part.number_class.code
+                part_dict['number_item'] = part.number_item
+                part_dict['number_variation'] = part.number_variation
+                part_number = part.full_part_number()
+            except ValueError:
+                self.add_error(None,
+                               f"Row {row_count} - manufacturer_part_number: Uploading of this subpart skipped. Too many parts found for manufacturer part number.")
+                return
+        else:
+            raise ValidationError(
+                "No part_number or manufacturer_part_number found. Uploading stopped. No subparts uploaded.",
+                code='invalid')
 
-            row_count = 1  # Skip over header row
-            for row in reader:
-                row_count += 1
-                part_dict = {}
+        # Handle indented bom level changes
+        level_change = level - self.last_level
+        if level_change == 1:  # Level decreases, must only decrease by 1
+            self.part_revision_tree.append(self.last_part_revision)
+        elif level_change <= -1:  # Level increases, going up in assembly; intentionally empty tree if level change is very negative
+            self.part_revision_tree = self.part_revision_tree[:level_change]
+        elif level_change == 0:
+            pass
+        elif level - self.last_level > 1:
+            raise ValidationError(
+                f'Row {row_count} - level: Assembly levels must decrease by no more than 1 from sequential rows.',
+                code='invalid')
+        else:
+            raise ValidationError(f'Row {row_count} - level: Invalid assembly level.', code='invalid')
 
-                # First prepare data
-                for idx, hdr in enumerate(headers):
-                    if idx == len(row): break
-                    part_dict[hdr] = row[idx]
-
-                dnp = csv_headers.get_val_from_row(part_dict, 'dnp')
-                reference = csv_headers.get_val_from_row(part_dict, 'reference')
-                part_number = csv_headers.get_val_from_row(part_dict, 'part_number')
-                manufacturer_part_number = csv_headers.get_val_from_row(part_dict, 'mpn')
-                manufacturer_name = csv_headers.get_val_from_row(part_dict, 'manufacturer_name')
-                try:
-                    level = int(float(csv_headers.get_val_from_row(part_dict, 'level')))
-                except ValueError as e:
-                    # TODO: May want to validate whole file has acceptable levels first.
-                    raise ValidationError(f"Row {row_count} - level: invalid level, can't continue.", code='invalid')
-                except TypeError as e:
-                    # no level field was provided, we MUST have a parent part number to upload this way, and in this case all levels are the same
-                    if parent_part_revision is None:
-                        raise ValidationError(f"Row {row_count} - level: must provide either level, or a parent part to upload a part.", code='invalid')
-                    else:
-                        level = 1
-
-                if last_level is None:
-                    last_level = level
-
-                # Extract some values
-                part_dict['reference'] = reference
-                part_dict['do_not_load'] = dnp in ['y', 'x', 'dnp', 'dnl', 'yes', 'true', ]
-                part_dict['revision'] = csv_headers.get_val_from_row(part_dict, 'revision') or 1
-                part_dict['count'] = csv_headers.get_val_from_row(part_dict, 'count')
-                part_dict['number_class'] = None
-                part_dict['number_variation'] = None
-
-                if part_number:
-                    try:
-                        (part_dict['number_class'], part_dict['number_item'], part_dict['number_variation']) = Part.parse_partial_part_number(part_number, self.organization)
-                    except AttributeError as e:
-                        self.add_error(None, f"Row {row_count} - part_number: Uploading of this subpart skipped. Couldn't parse part number.")
-                        continue
-                elif manufacturer_part_number:
-                    try:
-                        part = Part.from_manufacturer_part_number(manufacturer_part_number, self.organization)
-                        if part is None:
-                            self.add_error(None, f"Row {row_count} - manufacturer_part_number: Uploading of this subpart skipped. No part found for manufacturer part number.")
-                            continue
-                        part_dict['number_class'] = part.number_class.code
-                        part_dict['number_item'] = part.number_item
-                        part_dict['number_variation'] = part.number_variation
-                        part_number = part.full_part_number()
-                    except ValueError:
-                        self.add_error(None, f"Row {row_count} - manufacturer_part_number: Uploading of this subpart skipped. Too many parts found for manufacturer part number.")
-                        continue
-                else:
-                    raise ValidationError("No part_number or manufacturer_part_number found. Uploading stopped. No subparts uploaded.", code='invalid')
-
-                # Handle indented bom level changes
-                level_change = level - last_level
-                if level_change == 1:  # Level decreases, must only decrease by 1
-                    part_revision_tree.append(last_part_revision)
-                elif level_change <= -1:  # Level increases, going up in assembly; intentionally empty tree if level change is very negative
-                    part_revision_tree = part_revision_tree[:level_change]
-                elif level_change == 0:
-                    pass
-                elif level - last_level > 1:
-                    raise ValidationError(f'Row {row_count} - level: Assembly levels must decrease by no more than 1 from sequential rows.', code='invalid')
-                else:
-                    raise ValidationError(f'Row {row_count} - level: Invalid assembly level.', code='invalid')
+        try:
+            parent_part_revision = self.part_revision_tree[-1]
+            if parent_part_revision.assembly is None:
+                parent_part_revision.assembly = Assembly.objects.create()
+                parent_part_revision.save()
+        except IndexError:
+            parent_part_revision = None
+
+        # Check for existing objects
+        existing_part_class = PartClass.objects.filter(code=part_dict['number_class'],
+                                                       organization=self.organization).first()
+
+        existing_part = None
+        if existing_part_class or self.organization.number_scheme == NUMBER_SCHEME_INTELLIGENT:
+            existing_part = Part.objects.filter(number_class=existing_part_class, number_item=part_dict['number_item'],
+                                                number_variation=part_dict['number_variation'],
+                                                organization=self.organization).first()
+
+        existing_part_revision = None
+        if existing_part:
+            existing_part_revision = PartRevision.objects.filter(part=existing_part,
+                                                                 revision=part_dict['revision']).first()
+
+        if existing_part_revision and parent_part_revision:  # Check for infinite recursion
+            contains_parent = False
+            indented_bom = existing_part_revision.indented()
+            for _, sp in indented_bom.parts.items():  # Make sure the subpart does not contain the parent - infinite recursion!
+                if sp.part_revision == parent_part_revision:
+                    contains_parent = True
+            if contains_parent:
+                raise ValidationError(
+                    f"Row {row_count} - Uploaded part {part_number} contains parent part in its assembly. Cannot add {part_number} as it would cause infinite recursion. Uploading of this subpart skipped.",
+                    code='invalid')
+
+        existing_subpart = None
+        existing_subpart_count = 0
+        existing_subpart_references = None
+        if existing_part_revision and parent_part_revision:
+            existing_subpart = parent_part_revision.assembly.subparts.all().filter(part_revision=existing_part_revision,
+                                                                                   do_not_load=part_dict[
+                                                                                       'do_not_load']).first()
+            existing_subpart_count = existing_subpart.count if existing_subpart else 0
+            existing_subpart_references = existing_subpart.reference if existing_subpart else None
+
+        # Now validate & save PartClass, Part, PartRevision, Subpart
+        part_class_dict = {'code': part_dict['number_class'], 'name': part_dict.get('part_class', None)}
+        part_class_form = PartClassForm(part_class_dict, instance=existing_part_class, ignore_unique_constraint=True,
+                                        organization=self.organization)
+        if self.organization.number_scheme == NUMBER_SCHEME_SEMI_INTELLIGENT and not part_class_form.is_valid():
+            add_nonfield_error_from_existing(part_class_form, self, f'Row {row_count} - ')
+            return
+
+        PartForm = part_form_from_organization(self.organization)
+        part_form = PartForm(part_dict, instance=existing_part, ignore_part_class=True, ignore_unique_constraint=True,
+                             organization=self.organization)
+        if not part_form.is_valid():
+            add_nonfield_error_from_existing(part_form, self, f'Row {row_count} - ')
+            return
+
+        part_revision_form = PartRevisionForm(part_dict, instance=existing_part_revision,
+                                              organization=self.organization)
+        if not part_revision_form.is_valid():
+            add_nonfield_error_from_existing(part_revision_form, self, f'Row {row_count} - ')
+            return
+
+        subpart_form = SubpartForm(part_dict, instance=existing_subpart, ignore_part_revision=True,
+                                   organization=self.organization)
+        if not subpart_form.is_valid():
+            add_nonfield_error_from_existing(subpart_form, self, f'Row {row_count} - ')
+            return
+
+        part_class = part_class_form.save(commit=False)
+        part = part_form.save(commit=False)
+        part_revision = part_revision_form.save(commit=False)
+        subpart = subpart_form.save(commit=False)
+
+        reference_list = listify_string(reference) if reference else []
+        if len(reference_list) != len(set(reference_list)):
+            self.add_warning(None,
+                             f"Row {row_count} -Duplicate reference designators '{reference}' for subpart on row {row_count}.")
+        if len(reference_list) != subpart.count and len(reference_list) > 0:
+            self.add_warning(None,
+                             f"Row {row_count} -The quantity of reference designators for {part_number} on row {row_count} does not match the subpart quantity ({len(reference_list)} != {subpart.count})")
+
+        if self.organization.number_scheme == NUMBER_SCHEME_SEMI_INTELLIGENT:
+            part_class.save()
+            part.number_class = part_class
+
+        part.organization = self.organization
+        part.save()
+        part_revision.part = part
+        part_revision.save()
+        if parent_part_revision:
+            subpart.count += existing_subpart_count  # append or create
+            subpart.reference = existing_subpart_references + ', ' + subpart.reference if existing_subpart_references else subpart.reference
+            subpart.part_revision = part_revision
+            subpart.save()
+            AssemblySubparts.objects.get_or_create(assembly=parent_part_revision.assembly, subpart=subpart)
+
+        info_msg = f"Row {row_count}: Added subpart {part_number}"
+        if reference:
+            info_msg += f" with reference designators {reference}"
+        if parent_part_revision:
+            info_msg += f" to parent part {parent_part_revision.part.full_part_number()}"
+        self.successes.append(info_msg + ".")
+
+        # Now validate & save optional fields - Manufacturer, ManufacturerPart, SellerParts
+        existing_manufacturer = Manufacturer.objects.filter(name=manufacturer_name,
+                                                            organization=self.organization).first()
+        manufacturer_form = ManufacturerForm({'name': manufacturer_name}, instance=existing_manufacturer)
+        if not manufacturer_form.is_valid():
+            add_nonfield_error_from_existing(manufacturer_form, self, f'Row {row_count} - ')
+
+        manufacturer_part_data = {'manufacturer_part_number': manufacturer_part_number}
+        manufacturer_part_form = ManufacturerPartForm(manufacturer_part_data)
+        if not manufacturer_part_form.is_valid():
+            add_nonfield_error_from_existing(manufacturer_part_form, self, f'Row {row_count} - ')
+
+        manufacturer = manufacturer_form.save(commit=False)
+        manufacturer.organization = self.organization
+        manufacturer.save()
+
+        manufacturer_part = manufacturer_part_form.save(commit=False)
+        existing_manufacturer_part = ManufacturerPart.objects.filter(part=part, manufacturer=manufacturer,
+                                                                     manufacturer_part_number=manufacturer_part.manufacturer_part_number).first()
+        manufacturer_part.id = existing_manufacturer_part.id if existing_manufacturer_part else None
+        manufacturer_part.manufacturer = manufacturer
+        manufacturer_part.part = part
+        manufacturer_part.save()
+
+        part.primary_manufacturer_part = manufacturer_part
+        part.save()
+
+        self.last_part_revision = part_revision
+        self.last_level = level
+
+
+class UploadBOMForm(OrganizationFormMixin, forms.Form):
+    parent_part_number = forms.CharField(required=False, label="Parent part number")
 
-                try:
-                    parent_part_revision = part_revision_tree[-1]
-                    if parent_part_revision.assembly is None:
-                        parent_part_revision.assembly = Assembly.objects.create()
-                        parent_part_revision.save()
-                except IndexError:
-                    parent_part_revision = None
-
-                # Check for existing objects
-                existing_part_class = PartClass.objects.filter(code=part_dict['number_class'], organization=self.organization).first()
-
-                existing_part = None
-                if existing_part_class or self.organization.number_scheme == NUMBER_SCHEME_INTELLIGENT:
-                    existing_part = Part.objects.filter(number_class=existing_part_class, number_item=part_dict['number_item'], number_variation=part_dict['number_variation'], organization=self.organization).first()
-
-                existing_part_revision = None
-                if existing_part:
-                    existing_part_revision = PartRevision.objects.filter(part=existing_part, revision=part_dict['revision']).first()
-
-                if existing_part_revision and parent_part_revision:  # Check for infinite recursion
-                    contains_parent = False
-                    indented_bom = existing_part_revision.indented()
-                    for _, sp in indented_bom.parts.items():  # Make sure the subpart does not contain the parent - infinite recursion!
-                        if sp.part_revision == parent_part_revision:
-                            contains_parent = True
-                    if contains_parent:
-                        raise ValidationError(
-                            f"Row {row_count} - Uploaded part {part_number} contains parent part in its assembly. Cannot add {part_number} as it would cause infinite recursion. Uploading of this subpart skipped.",
-                            code='invalid')
-
-                existing_subpart = None
-                existing_subpart_count = 0
-                existing_subpart_references = None
-                if existing_part_revision and parent_part_revision:
-                    existing_subpart = parent_part_revision.assembly.subparts.all().filter(part_revision=existing_part_revision, do_not_load=part_dict['do_not_load']).first()
-                    existing_subpart_count = existing_subpart.count if existing_subpart else 0
-                    existing_subpart_references = existing_subpart.reference if existing_subpart else None
-
-                # Now validate & save PartClass, Part, PartRevision, Subpart
-                part_class_dict = {'code': part_dict['number_class'], 'name': part_dict.get('part_class', None)}
-                part_class_form = PartClassForm(part_class_dict, instance=existing_part_class, ignore_unique_constraint=True, organization=self.organization)
-                if self.organization.number_scheme == NUMBER_SCHEME_SEMI_INTELLIGENT and not part_class_form.is_valid():
-                    add_nonfield_error_from_existing(part_class_form, self, f'Row {row_count} - ')
-                    continue
-
-                PartForm = part_form_from_organization(self.organization)
-                part_form = PartForm(part_dict, instance=existing_part, ignore_part_class=True, ignore_unique_constraint=True, organization=self.organization)
-                if not part_form.is_valid():
-                    add_nonfield_error_from_existing(part_form, self, f'Row {row_count} - ')
-                    continue
-
-                part_revision_form = PartRevisionForm(part_dict, instance=existing_part_revision)
-                if not part_revision_form.is_valid():
-                    add_nonfield_error_from_existing(part_revision_form, self, f'Row {row_count} - ')
-                    continue
-
-                subpart_form = SubpartForm(part_dict, instance=existing_subpart, ignore_part_revision=True, organization=self.organization)
-                if not subpart_form.is_valid():
-                    add_nonfield_error_from_existing(subpart_form, self, f'Row {row_count} - ')
-                    continue
-
-                part_class = part_class_form.save(commit=False)
-                part = part_form.save(commit=False)
-                part_revision = part_revision_form.save(commit=False)
-                subpart = subpart_form.save(commit=False)
-
-                reference_list = listify_string(reference) if reference else []
-                if len(reference_list) != len(set(reference_list)):
-                    self.add_warning(None, f"Row {row_count} -Duplicate reference designators '{reference}' for subpart on row {row_count}.")
-                if len(reference_list) != subpart.count and len(reference_list) > 0:
-                    self.add_warning(None, f"Row {row_count} -The quantity of reference designators for {part_number} on row {row_count} does not match the subpart quantity ({len(reference_list)} != {subpart.count})")
-
-                if self.organization.number_scheme == NUMBER_SCHEME_SEMI_INTELLIGENT:
-                    part_class.save()
-                    part.number_class = part_class
-
-                part.organization = self.organization
-                part.save()
-                part_revision.part = part
-                part_revision.save()
-                if parent_part_revision:
-                    subpart.count += existing_subpart_count  # append or create
-                    subpart.reference = existing_subpart_references + ', ' + subpart.reference if existing_subpart_references else subpart.reference
-                    subpart.part_revision = part_revision
-                    subpart.save()
-                    AssemblySubparts.objects.get_or_create(assembly=parent_part_revision.assembly, subpart=subpart)
-
-                info_msg = f"Row {row_count}: Added subpart {part_number}"
-                if reference:
-                    info_msg += f" with reference designators {reference}"
-                if parent_part_revision:
-                    info_msg += f" to parent part {parent_part_revision.part.full_part_number()}"
-                self.successes.append(info_msg + ".")
-
-                # Now validate & save optional fields - Manufacturer, ManufacturerPart, SellerParts
-                existing_manufacturer = Manufacturer.objects.filter(name=manufacturer_name, organization=self.organization).first()
-                manufacturer_form = ManufacturerForm({'name': manufacturer_name}, instance=existing_manufacturer)
-                if not manufacturer_form.is_valid():
-                    add_nonfield_error_from_existing(manufacturer_form, self, f'Row {row_count} - ')
-
-                manufacturer_part_data = {'manufacturer_part_number': manufacturer_part_number}
-                manufacturer_part_form = ManufacturerPartForm(manufacturer_part_data)
-                if not manufacturer_part_form.is_valid():
-                    add_nonfield_error_from_existing(manufacturer_part_form, self, f'Row {row_count} - ')
-
-                manufacturer = manufacturer_form.save(commit=False)
-                manufacturer.organization = self.organization
-                manufacturer.save()
-
-                manufacturer_part = manufacturer_part_form.save(commit=False)
-                existing_manufacturer_part = ManufacturerPart.objects.filter(part=part, manufacturer=manufacturer, manufacturer_part_number=manufacturer_part.manufacturer_part_number).first()
-                manufacturer_part.id = existing_manufacturer_part.id if existing_manufacturer_part else None
-                manufacturer_part.manufacturer = manufacturer
-                manufacturer_part.part = part
-                manufacturer_part.save()
-
-                part.primary_manufacturer_part = manufacturer_part
-                part.save()
-
-                last_part_revision = part_revision
-                last_level = level
-
-                # TODO: Add SellerParts
-        except UnicodeDecodeError as e:
-            self.add_error(None, forms.ValidationError("CSV File Encoding error, try encoding your file as utf-8, and upload again. \
-                If this keeps happening, reach out to info@indabom.com with your csv file and we'll do our best to \
-                fix your issue!", code='invalid'))
-            logger.warning("UnicodeDecodeError: {}".format(e))
-            raise ValidationError("Specific Error: {}".format(e), code='invalid')
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.parent_part = None
 
-        return cleaned_data
+    def clean_parent_part_number(self):
+        ppn = self.cleaned_data['parent_part_number']
+        if ppn:
+            try:
+                self.parent_part = Part.from_part_number(ppn, self.organization)
+            except (AttributeError, Part.DoesNotExist) as e:
+                raise ValidationError(f"Invalid parent part: {e}")
+        return ppn
 
 
 class FileForm(forms.Form):
     file = forms.FileField()
 
+
+# ==========================================
+# HELPERS
+# ==========================================
+
 def part_form_from_organization(organization):
-    return PartFormSemiIntelligent if organization.number_scheme == NUMBER_SCHEME_SEMI_INTELLIGENT else PartFormIntelligent
+    if organization.number_scheme == NUMBER_SCHEME_SEMI_INTELLIGENT:
+        return PartFormSemiIntelligent
+    return PartFormIntelligent
 
-def add_nonfield_error_from_existing(from_form, to_form, prefix=''):
-    for field, errors in from_form.errors.as_data().items():
-        for error in errors:
-            for msg in error.messages:
-                to_form.add_error(None, f'{prefix}{field}: {msg}')
 
-def add_nonfield_warning_from_existing(from_form, to_form, prefix=''):
+def add_nonfield_error_from_existing(from_form, to_form, prefix=''):
     for field, errors in from_form.errors.as_data().items():
         for error in errors:
             for msg in error.messages:
-                to_form.add_warning(None, f'{prefix}{field}: {msg}')
+                to_form.add_error(None, f'{prefix}{field}: {msg}')