django-bom 1.262__py3-none-any.whl

bom/__init__.py

@@ -0,0 +1 @@
+default_app_config = 'bom.apps.BomConfig'

bom/admin.py

@@ -0,0 +1,207 @@
+from django.conf import settings
+from django.contrib import admin
+from django.contrib.auth import get_user_model
+from django.contrib.auth.admin import UserAdmin
+
+from .models import (
+    Assembly,
+    Manufacturer,
+    ManufacturerPart,
+    Part,
+    PartClass,
+    PartRevision,
+    PartRevisionProperty,
+    PartRevisionPropertyDefinition,
+    Seller,
+    SellerPart,
+    Subpart,
+    UnitDefinition,
+    QuantityOfMeasure,
+    get_organization_model,
+    get_user_meta_model
+)
+
+User = get_user_model()
+UserMeta = get_user_meta_model()
+Organization = get_organization_model()
+
+class UserMetaInline(admin.TabularInline):
+    model = UserMeta
+    verbose_name = 'BOM User Meta'
+    raw_id_fields = ('organization',)
+    can_delete = False
+
+
+class OrganizationAdmin(admin.ModelAdmin):
+    list_display = ('name',)
+
+
+class SubpartInline(admin.TabularInline):
+    model = Subpart
+    fk_name = 'part_revision'
+    raw_id_fields = ('part_revision',)
+    # readonly_fields = ('get_full_part_number', )
+    #
+    # def get_full_part_number(self, obj):
+    #     return obj.assembly_subpart.part.full_part_number()
+    # get_full_part_number.short_description = 'PartNumber'
+
+
+class SellerAdmin(admin.ModelAdmin):
+    list_display = ('name',)
+
+
+class SellerPartAdmin(admin.ModelAdmin):
+    list_display = (
+        'manufacturer_part',
+        'seller',
+        'seller_part_number',
+        'minimum_order_quantity',
+        'minimum_pack_quantity',
+        'unit_cost',
+        'lead_time_days',
+        'nre_cost',
+        'ncnr')
+
+
+class SellerPartAdminInline(admin.TabularInline):
+    model = SellerPart
+    raw_id_fields = ('seller', 'manufacturer_part',)
+
+
+class ManufacturerPartAdmin(admin.ModelAdmin):
+    list_display = (
+        'manufacturer_part_number',
+        'manufacturer',
+        'part',)
+    raw_id_fields = ('manufacturer', 'part',)
+    inlines = [
+        SellerPartAdminInline,
+    ]
+
+
+class ManufacturerPartAdminInline(admin.TabularInline):
+    model = ManufacturerPart
+    raw_id_fields = ('part', 'manufacturer',)
+
+
+class PartClassAdmin(admin.ModelAdmin):
+    list_display = ('code', 'name', 'comment',)
+
+
+class PartRevisionAdminInline(admin.TabularInline):
+    model = PartRevision
+    extra = 0
+    raw_id_fields = ('assembly',)
+    readonly_fields = ('timestamp',)
+    show_change_link = True
+
+
+class PartAdmin(admin.ModelAdmin):
+    ordering = ('organization', 'number_class__code', 'number_item', 'number_variation')
+    readonly_fields = ('get_full_part_number',)
+    list_display = (
+        'organization',
+        'get_full_part_number',
+    )
+    list_filter = ('organization', 'number_class',)
+    raw_id_fields = ('number_class', 'primary_manufacturer_part',)
+    inlines = [
+        PartRevisionAdminInline,
+        ManufacturerPartAdminInline,
+    ]
+
+    def get_full_part_number(self, obj):
+        return obj.full_part_number()
+
+    get_full_part_number.short_description = 'PartNumber'
+    get_full_part_number.admin_order_field = 'number_class__part_number'
+
+
+class QuantityOfMeasureAdmin(admin.ModelAdmin):
+    list_display = ('name', 'organization')
+    list_filter = ('organization',)
+
+
+class PartRevisionPropertyInline(admin.TabularInline):
+    model = PartRevisionProperty
+    extra = 1
+    raw_id_fields = ('property_definition', 'part_revision', 'unit_definition')
+
+
+class PartRevisionAdmin(admin.ModelAdmin):
+    list_display = ('part', 'revision', 'description', 'get_assembly_size', 'timestamp',)
+    raw_id_fields = ('assembly',)
+    readonly_fields = ('timestamp',)
+    inlines = [PartRevisionPropertyInline]
+
+    def get_assembly_size(self, obj):
+        return None if obj.assembly is None else obj.assembly.subparts.count()
+
+    get_assembly_size.short_description = 'AssemblySize'
+
+
+class ManufacturerAdmin(admin.ModelAdmin):
+    list_display = ('name', 'organization',)
+
+
+class SubpartAdmin(admin.ModelAdmin):
+    list_display = ('part_revision', 'count', 'reference',)
+
+
+class SubpartsInline(admin.TabularInline):
+    model = Assembly.subparts.through
+    raw_id_fields = ('subpart',)
+
+
+class AssemblyAdmin(admin.ModelAdmin):
+    list_display = ('id',)
+    exclude = ('subparts',)
+    inlines = [
+        SubpartsInline,
+    ]
+
+
+class UnitDefinitionAdmin(admin.ModelAdmin):
+    list_display = ('name', 'symbol', 'quantity_of_measure', 'base_multiplier', 'organization')
+    list_filter = ('organization',)
+
+
+class PartRevisionPropertyDefinitionAdmin(admin.ModelAdmin):
+    list_display = ('code', 'name', 'type', 'organization', 'quantity_of_measure')
+    list_filter = ('organization',)
+
+
+if settings.BOM_USER_META_MODEL == 'bom.UserMeta':
+    current_user_admin = admin.site._registry.get(User)
+
+    if current_user_admin:
+        user_admin_class = current_user_admin.__class__
+        existing_inlines = list(user_admin_class.inlines or [])
+        if UserMetaInline not in existing_inlines:
+            existing_inlines.append(UserMetaInline)
+            user_admin_class.inlines = existing_inlines
+    else:
+        class BomUserAdmin(UserAdmin):
+            inlines = [UserMetaInline]
+
+
+        admin.site.register(User, BomUserAdmin)
+
+if settings.BOM_ORGANIZATION_MODEL == 'bom.Organization':
+    from .models import Organization
+
+    admin.site.register(Organization, OrganizationAdmin)
+
+admin.site.register(Seller, SellerAdmin)
+admin.site.register(SellerPart, SellerPartAdmin)
+admin.site.register(ManufacturerPart, ManufacturerPartAdmin)
+admin.site.register(PartClass, PartClassAdmin)
+admin.site.register(Part, PartAdmin)
+admin.site.register(PartRevision, PartRevisionAdmin)
+admin.site.register(Manufacturer, ManufacturerAdmin)
+admin.site.register(Assembly, AssemblyAdmin)
+admin.site.register(Subpart, SubpartAdmin)
+admin.site.register(UnitDefinition, UnitDefinitionAdmin)
+admin.site.register(PartRevisionPropertyDefinition, PartRevisionPropertyDefinitionAdmin)
+admin.site.register(QuantityOfMeasure, QuantityOfMeasureAdmin)

bom/apps.py

@@ -0,0 +1,8 @@
+from __future__ import unicode_literals
+
+from django.apps import AppConfig
+
+
+class BomConfig(AppConfig):
+    name = 'bom'
+    mouser_api_key = None

bom/auth_backends.py

@@ -0,0 +1,47 @@
+from typing import Optional
+
+from . import constants
+from .models import get_organization_model
+
+Organization = get_organization_model()
+
+
+class OrganizationPermissionBackend:
+    """
+    Object-level permission backend for django-bom.
+
+    - Uses Django's has_perm(user, perm, obj) to evaluate permissions tied to an Organization.
+    - Superusers are granted all permissions.
+    - For `bom.manage_members`: User must be owner or admin within the organization.
+    """
+
+    def authenticate(self, request, **credentials):  # pragma: no cover - not used for auth
+        return None
+
+    def has_perm(self, user_obj, perm: str, obj: Optional[object] = None):
+        # Only handle our specific object-level permission. Let other backends process others.
+        if not user_obj or not user_obj.is_authenticated:
+            return False
+
+        if user_obj.is_superuser:
+            return True
+
+        if perm != 'bom.manage_members':
+            return None
+
+        if obj is None or not isinstance(obj, Organization):
+            return False
+
+        profile = user_obj.bom_profile()
+        if not profile or profile.organization_id != obj.id:
+            return False
+
+        if obj.subscription != constants.SUBSCRIPTION_TYPE_PRO:
+            return False
+
+        is_owner = obj.owner_id == user_obj.id
+        is_admin = getattr(profile, 'role', None) == constants.ROLE_TYPE_ADMIN
+        if not (is_owner or is_admin):
+            return False
+
+        return True

bom/base_classes.py

@@ -0,0 +1,31 @@
+from collections import OrderedDict
+from django.forms.models import model_to_dict
+
+
+class AsDictModel:
+    def as_dict(self):
+        try:
+            return model_to_dict(self)
+        except (TypeError, AttributeError):
+            return dict(self)
+
+    def __iter__(self):
+        for key in dir(self):
+            if not key.startswith("_") and not key == "objects":
+                value = getattr(self, key)
+                if not callable(value):
+                    if isinstance(value, (dict, OrderedDict)):
+                        for subkey, subvalue in value.items():
+                            try:
+                                value[subkey] = subvalue.as_dict()
+                            except AttributeError:
+                                pass
+                        yield key, value
+                    else:
+                        try:
+                            yield key, value.as_dict()
+                        except AttributeError:
+                            if isinstance(value, (int, float, complex, bool)):
+                                yield key, value
+                            else:
+                                yield key, str(value)

bom/constants.py

@@ -0,0 +1,217 @@
+NO_CHOICE = ('', '-----')
+
+SUBSCRIPTION_TYPE_FREE = 'F'
+SUBSCRIPTION_TYPE_PRO = 'P'
+SUBSCRIPTION_TYPES = ((SUBSCRIPTION_TYPE_FREE, 'Free'), (SUBSCRIPTION_TYPE_PRO, 'Pro'),)
+
+ROLE_TYPE_ADMIN = 'A'
+ROLE_TYPE_VIEWER = 'V'
+ROLE_TYPES = ((ROLE_TYPE_ADMIN, 'Admin'), (ROLE_TYPE_VIEWER, 'Viewer'),)
+
+CONFIGURATION_TYPE_RELEASED = 'R'
+CONFIGURATION_TYPE_WORKING = 'W'
+CONFIGURATION_TYPES = ((CONFIGURATION_TYPE_RELEASED, 'Released'), (CONFIGURATION_TYPE_WORKING, 'Working'),)
+
+NUMBER_SCHEME_INTELLIGENT = 'I'
+NUMBER_SCHEME_SEMI_INTELLIGENT = 'S'
+NUMBER_SCHEMES = ((NUMBER_SCHEME_INTELLIGENT, 'Intelligent'), (NUMBER_SCHEME_SEMI_INTELLIGENT, 'Semi-Intelligent'),)
+
+NUMBER_CLASS_CODE_LEN_MIN = 2
+NUMBER_CLASS_CODE_LEN_MAX = 16
+NUMBER_CLASS_CODE_LEN_DEFAULT = 3
+NUMBER_ITEM_LEN_MIN = 3
+NUMBER_ITEM_LEN_MAX = 128
+NUMBER_ITEM_LEN_DEFAULT = 4
+NUMBER_VARIATION_LEN_MIN = 0
+NUMBER_VARIATION_LEN_MAX = 16
+NUMBER_VARIATION_LEN_DEFAULT = 2
+
+DATA_SOURCE_OCTOPART = 'octopart'
+DATA_SOURCE_MOUSER = 'mouser'
+DATA_SOURCES = (
+    NO_CHOICE,
+    (DATA_SOURCE_OCTOPART, 'octopart'),
+    (DATA_SOURCE_MOUSER, 'mouser'),
+)
+
+PART_REVISION_PROPERTY_TYPE_STRING = 'S'
+PART_REVISION_PROPERTY_TYPE_DECIMAL = 'D'
+PART_REVISION_PROPERTY_TYPE_BOOLEAN = 'B'
+PART_REVISION_PROPERTY_TYPES = ((PART_REVISION_PROPERTY_TYPE_STRING, 'String'),
+                                (PART_REVISION_PROPERTY_TYPE_DECIMAL, 'Number'),
+                                (PART_REVISION_PROPERTY_TYPE_BOOLEAN, 'Boolean'),)
+
+VALUE_UNITS = (
+    NO_CHOICE,
+    ('Ohms', '\u03A9'),
+    ('mOhms', 'm\u03A9'),
+    ('kOhms', 'k\u03A9'),
+    ('MOhms', 'M\u03A9'),
+    ('F', 'F'),
+    ('pF', 'pF'),
+    ('nF', 'nF'),
+    ('uF', '\u03BCF'),
+    ('V', 'V'),
+    ('uV', '\u03BCV'),
+    ('mV', 'mV'),
+    ('A', 'A'),
+    ('uA', '\u03BCA'),
+    ('mA', 'mA'),
+    ('C', '\u00B0C'),
+    ('F', '\u00B0F'),
+    ('H', 'H'),
+    ('nH', 'nH'),
+    ('mH', 'mH'),
+    ('uH', '\u03BCH'),
+    ('Hz', 'Hz'),
+    ('kHz', 'kHz'),
+    ('MHz', 'MHz'),
+    ('GHz', 'GHz'),
+    ('Other', 'Other'),
+)
+
+PACKAGE_TYPES = (
+    NO_CHOICE,
+    ('0201 smd', '0201 smd'),
+    ('0402 smd', '0402 smd'),
+    ('0603 smd', '0603 smd'),
+    ('0805 smd', '0805 smd'),
+    ('1206 smd', '1206 smd'),
+    ('1210 smd', '1210 smd'),
+    ('1812 smd', '1812 smd'),
+    ('2010 smd', '2010 smd'),
+    ('2512 smd', '2512 smd'),
+    ('1/8 radial', '1/8 radial'),
+    ('1/4 radial', '1/4 radial'),
+    ('1/2 radial', '1/2 radial'),
+    ('Size A', 'Size A'),
+    ('Size B', 'Size B'),
+    ('Size C', 'Size C'),
+    ('Size D', 'Size D'),
+    ('Size E', 'Size E'),
+    ('SOT-23', 'SOT-23'),
+    ('SOT-223', 'SOT-233'),
+    ('DIL', 'DIL'),
+    ('SOP', 'SOP'),
+    ('SOIC', 'SOIC'),
+    ('QFN', 'QFN'),
+    ('QFP', 'QFP'),
+    ('QFT', 'QFT'),
+    ('PLCC', 'PLCC'),
+    ('VGA', 'VGA'),
+    ('BGA', 'BGA'),
+    ('CSP', 'CSP'),
+    ('Other', 'Other'),
+)
+
+DISTANCE_UNITS = (
+    NO_CHOICE,
+    ('mil', 'mil'),
+    ('in', 'in'),
+    ('ft', 'ft'),
+    ('yd', 'yd'),
+    ('km', 'km'),
+    ('m', 'm'),
+    ('cm', 'cm'),
+    ('mm', 'mm'),
+    ('um', '\u03BCm'),
+    ('nm', 'nm'),
+    ('Other', 'Other'),
+)
+
+WEIGHT_UNITS = (
+    NO_CHOICE,
+    ('mg', 'mg'),
+    ('g', 'g'),
+    ('kg', 'kg'),
+    ('oz', 'oz'),
+    ('lb', 'lb'),
+    ('Other', 'Other'),
+)
+
+TEMPERATURE_UNITS = (
+    NO_CHOICE,
+    ('C', '\u00B0C'),
+    ('F', '\u00B0F'),
+    ('Other', 'Other'),
+)
+
+WAVELENGTH_UNITS = (
+    NO_CHOICE,
+    ('km', 'km'),
+    ('m', 'm'),
+    ('cm', 'cm'),
+    ('mm', 'mm'),
+    ('um', '\u03BCm'),
+    ('nm', 'nm'),
+    ('A', '\u212B'),
+    ('Other', 'Other'),
+)
+
+FREQUENCY_UNITS = (
+    NO_CHOICE,
+    ('Hz', 'Hz'),
+    ('kHz', 'kHz'),
+    ('MHz', 'MHz'),
+    ('GHz', 'GHz'),
+    ('Other', 'Other'),
+)
+
+MEMORY_UNITS = (
+    NO_CHOICE,
+    ('KB', 'KB'),
+    ('MB', 'MB'),
+    ('GB', 'GB'),
+    ('TB', 'TB'),
+    ('Other', 'Other'),
+)
+
+INTERFACE_TYPES = (
+    NO_CHOICE,
+    ('I2C', 'I2C'),
+    ('SPI', 'SPI'),
+    ('CAN', 'CAN'),
+    ('One-Wire', '1-Wire'),
+    ('RS485', 'RS-485'),
+    ('RS232', 'RS-232'),
+    ('WiFi', 'Wi-Fi'),
+    ('4G', '4G'),
+    ('BT', 'Bluetooth'),
+    ('BTLE', 'Bluetooth LE'),
+    ('Z_Wave', 'Z-Wave'),
+    ('Zigbee', 'Zigbee'),
+    ('LAN', 'LAN'),
+    ('USB', 'USB'),
+    ('HDMI', 'HDMI'),
+    ('Other', 'Other'),
+)
+
+POWER_UNITS = (
+    NO_CHOICE,
+    ('W', 'W'),
+    ('uW', '\u03BCW'),
+    ('mW', 'mW'),
+    ('kW', 'kW'),
+    ('MW', 'MW'),
+    ('Other', 'Other'),
+)
+
+VOLTAGE_UNITS = (
+    NO_CHOICE,
+    ('V', 'V'),
+    ('uV', '\u03BCV'),
+    ('mV', 'mV'),
+    ('kV', 'kV'),
+    ('MV', 'MV'),
+    ('Other', 'Other'),
+)
+
+CURRENT_UNITS = (
+    NO_CHOICE,
+    ('A', 'A'),
+    ('uA', '\u03BCV'),
+    ('mA', 'mA'),
+    ('kA', 'kA'),
+    ('MA', 'MA'),
+    ('Other', 'Other'),
+)

bom/context_processors.py

@@ -0,0 +1,9 @@
+from django.conf import settings  # import the settings file
+
+
+def bom_config(request):
+    base_template = 'bom/base.html'
+    if settings.BOM_CONFIG:
+        if 'base_template' in settings.BOM_CONFIG:
+            base_template = settings.BOM_CONFIG['base_template']
+    return {'BASE_TEMPLATE': base_template}