4891038286

Build Type

push

github

Committed by Oliver

Commit Message

Check for 'dnp' attribute introduced in kicad v7

Run Details

4 of 4 new or added lines in 1 file covered. (100.0%)

1245 of 1581 relevant lines covered (78.75%)

0.79 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

66.58

/kibom/component.py

# -*- coding: utf-8 -*-
from __future__ import unicode_literals

import re
import sys

from .columns import ColumnList
from .preferences import BomPref
from . import units
from . import debug
from .sort import natural_sort

# String matches for marking a component as "do not fit"
DNF = [
    "dnf",
    "dnl",
    "dnp",
    "do not fit",
    "do not place",
    "do not load",
    "nofit",
    "nostuff",
    "noplace",
    "noload",
    "not fitted",
    "not loaded",
    "not placed",
    "no stuff",
]

# String matches for marking a component as "do not change" or "fixed"
DNC = [
    "dnc",
    "do not change",
    "no change",
    "fixed"
]


class Component():
    """Class for a component, aka 'comp' in the xml netlist file.
    This component class is implemented by wrapping an xmlElement instance
    with accessors.  The xmlElement is held in field 'element'.
    """

    def __init__(self, xml_element, prefs=None):
        self.element = xml_element
        self.libpart = None

        if not prefs:
            prefs = BomPref()

        self.prefs = prefs

        # Set to true when this component is included in a component group
        self.grouped = False

    # Compare the value of this part, to the value of another part (see if they match)
    def compareValue(self, other):
        # Simple string comparison
        if self.getValue().lower() == other.getValue().lower():
            return True

        # Otherwise, perform a more complicated value comparison
        if units.compareValues(self.getValue(), other.getValue()):
            return True

        # Ignore value if both components are connectors
        if self.prefs.groupConnectors:
            if 'connector' in self.getLibName().lower() and 'connector' in other.getLibName().lower():
                return True

        # No match, return False
        return False

    # Determine if two parts have the same name
    def comparePartName(self, other):
        pn1 = self.getPartName().lower()
        pn2 = other.getPartName().lower()

        # Simple direct match
        if pn1 == pn2:
            return True

        # Compare part aliases e.g. "c" to "c_small"
        for alias in self.prefs.aliases:
            if pn1 in alias and pn2 in alias:
                return True

        return False

    def compareField(self, other, field):

        this_field = self.getField(field).lower()
        other_field = other.getField(field).lower()

        # If blank comparisons are allowed
        if this_field == "" or other_field == "":
            if not self.prefs.mergeBlankFields:
                return False

        if this_field == other_field:
            return True

        return False

    def __eq__(self, other):
        """
        Equivalency operator is used to determine if two parts are 'equal'
        """
        
        # 'fitted' value must be the same for both parts
        if self.isFitted() != other.isFitted():
            return False

        # 'fixed' value must be the same for both parts
        if self.isFixed() != other.isFixed():
            return False

        if len(self.prefs.groups) == 0:
            return False

        for c in self.prefs.groups:
            # Perform special matches
            if c.lower() == ColumnList.COL_VALUE.lower():
                if not self.compareValue(other):
                    return False
            # Match part name
            elif c.lower() == ColumnList.COL_PART.lower():
                if not self.comparePartName(other):
                    return False

            # Generic match
            elif not self.compareField(other, c):
                return False

        return True

    def setLibPart(self, part):
        self.libpart = part

    def getPrefix(self):
        """
        Get the reference prefix
        e.g. if this component has a reference U12, will return "U"
        """
        
        prefix = ""

        for c in self.getRef():
            if c.isalpha():
                prefix += c
            else:
                break

        return prefix

    def getSuffix(self):
        """
        Return the reference suffix #
        e.g. if this component has a reference U12, will return "12"
        """
        
        suffix = ""

        for c in self.getRef():
            if c.isalpha():
                suffix = ""
            else:
                suffix += c

        return int(suffix)

    def getLibPart(self):
        return self.libpart

    def getPartName(self):
        return self.element.get("libsource", "part")

    def getLibName(self):
        return self.element.get("libsource", "lib")

    def getSheetpathNames(self):
        return self.element.get("sheetpath", "names")

    def getDescription(self):
        """Extract the 'description' field for this component"""

        # Give priority to a user "description" field
        ret = self.element.get("field", "name", "description")
        if ret:
            return ret

        ret = self.element.get("field", "name", "Description")
        if ret:
            return ret

        try:
            ret = self.element.get("libsource", "description")
        except:
            # Compatibility with old KiCad versions (4.x)
            ret = self.element.get("field", "name", "description")

        if ret == "":
            try:
                ret = self.libpart.getDescription()
            except AttributeError:
                # Raise a good error description here, so the user knows what the culprit component is.
                # (sometimes libpart is None)
                raise AttributeError('Could not get description for part {}{}.'.format(self.getPrefix(),
                                     self.getSuffix()))

        return ret

    def setValue(self, value):
        """Set the value of this component"""
        v = self.element.getChild("value")
        if v:
            v.setChars(value)

    def getValue(self):
        return self.element.get("value")

    # Try to better sort R, L and C components
    def getValueSort(self):
        pref = self.getPrefix()
        if pref in 'RLC' or pref == 'RV':
            res = units.compMatch(self.getValue())
            if res:
                value, mult, unit = res
                if pref in "CL":
                    # fempto Farads
                    value = "{0:15d}".format(int(value * 1e15 * mult + 0.1))
                else:
                    # milli Ohms
                    value = "{0:15d}".format(int(value * 1000 * mult + 0.1))
                return value
        return self.element.get("value")

    def setField(self, name, value):
        """ Set the value of the specified field """

        # Description field
        doc = self.element.getChild('libsource')
        if doc:
            for att_name, att_value in doc.attributes.items():
                if att_name.lower() == name.lower():
                    doc.attributes[att_name] = value
                    return value

        # Common fields
        field = self.element.getChild(name.lower())
        if field:
            field.setChars(value)
            return value

        # Other fields
        fields = self.element.getChild('fields')
        if fields:
            for field in fields.getChildren():
                if field.get('field', 'name') == name:
                    field.setChars(value)
                    return value

        return None

    def getField(self, name, ignoreCase=True, libraryToo=True):
        """Return the value of a field named name. The component is first
        checked for the field, and then the components library part is checked
        for the field. If the field doesn't exist in either, an empty string is
        returned

        Keywords:
        name -- The name of the field to return the value for
        libraryToo --   look in the libpart's fields for the same name if not found
                        in component itself
        """

        fp = self.getFootprint().split(":")

        if name.lower() == ColumnList.COL_REFERENCE.lower():
            return self.getRef().strip()

        elif name.lower() == ColumnList.COL_DESCRIPTION.lower():
            return self.getDescription().strip()

        elif name.lower() == ColumnList.COL_DATASHEET.lower():
            return self.getDatasheet().strip()

        # Footprint library is first element
        elif name.lower() == ColumnList.COL_FP_LIB.lower():
            if len(fp) > 1:
                return fp[0].strip()
            else:
                # Explicit empty return
                return ""

        elif name.lower() == ColumnList.COL_FP.lower():
            if len(fp) > 1:
                return fp[1].strip()
            elif len(fp) == 1:
                return fp[0]
            else:
                return ""

        elif name.lower() == ColumnList.COL_VALUE.lower():
            return self.getValue().strip()

        elif name.lower() == ColumnList.COL_PART.lower():
            return self.getPartName().strip()

        elif name.lower() == ColumnList.COL_PART_LIB.lower():
            return self.getLibName().strip()

        elif name.lower() == ColumnList.COL_SHEETPATH.lower():
            return self.getSheetpathNames().strip()

        # Other fields (case insensitive)
        for f in self.getFieldNames():
            if f.lower() == name.lower():
                field = self.element.get("field", "name", f)

                if field == "" and libraryToo:
                    field = self.libpart.getField(f)

                return field.strip()

        # Could not find a matching field
        return ""

    def getFieldNames(self):
        """Return a list of field names in play for this component.  Mandatory
        fields are not included, and they are: Value, Footprint, Datasheet, Ref.
        The netlist format only includes fields with non-empty values.  So if a field
        is empty, it will not be present in the returned list.
        """

        fieldNames = []
        
        fields = self.element.getChild('fields')
        
        if fields:
            for f in fields.getChildren():
                fieldNames.append(f.get('field', 'name'))
        
        return fieldNames

    def getRef(self):
        return self.element.get("comp", "ref")

    def isFitted(self):
        """ Determine if a component is FITTED or not """

        # First, check for the 'dnp' attribute (added in KiCad 7.0)
        for child in self.element.getChildren():
            if child.name == 'property':
                if child.attributes.get('name', '').lower() == 'dnp':
                    return False

        # Check the value field first
        if self.getValue().lower() in DNF:
            return False

        check = self.getField(self.prefs.configField).lower()
        # Empty value means part is fitted
        if check == "":
            return True

        # Also support space separated list (simple cases)
        opts = check.split(" ")
        for opt in opts:
            if opt.lower() in DNF:
                return False

        # Variants logic
        opts = check.split(",")
        # Exclude components that match a -VARIANT
        for opt in opts:
            opt = opt.strip()
            # Any option containing a DNF is not fitted
            if opt in DNF:
                return False
            # Options that start with '-' are explicitly removed from certain configurations
            if opt.startswith("-") and opt[1:] in self.prefs.pcbConfig:
                return False
        # Include components that match +VARIANT
        exclusive = False
        for opt in opts:
            # Options that start with '+' are fitted only for certain configurations
            if opt.startswith("+"):
                exclusive = True
                if opt[1:] in self.prefs.pcbConfig:
                    return True
        # No match
        return not exclusive

    def isFixed(self):
        """ Determine if a component is FIXED or not.
            Fixed components shouldn't be replaced without express authorization """

        # Check the value field first
        if self.getValue().lower() in DNC:
            return True

        check = self.getField(self.prefs.configField).lower()
        # Empty is not fixed
        if check == "":
            return False

        opts = check.split(" ")
        for opt in opts:
            if opt.lower() in DNC:
                return True

        opts = check.split(",")
        for opt in opts:
            if opt.lower() in DNC:
                return True

        return False

    # Test if this part should be included, based on any regex expressions provided in the preferences
    def testRegExclude(self):

        for reg in self.prefs.regExcludes:

            if type(reg) == list and len(reg) == 2:
                field_name, regex = reg
                field_value = self.getField(field_name)

                # Attempt unicode escaping...
                # Filthy hack
                try:
                    regex = regex.decode("unicode_escape")
                except:
                    pass

                if re.search(regex, field_value, flags=re.IGNORECASE) is not None:
                    debug.info("Excluding '{ref}': Field '{field}' ({value}) matched '{reg}'".format(
                        ref=self.getRef(),
                        field=field_name,
                        value=field_value,
                        reg=regex).encode('utf-8')
                    )

                    # Found a match
                    return True

        # Default, could not find any matches
        return False

    def testRegInclude(self):

        if len(self.prefs.regIncludes) == 0:  # Nothing to match against
            return True

        for reg in self.prefs.regIncludes:

            if type(reg) == list and len(reg) == 2:
                field_name, regex = reg
                field_value = self.getField(field_name)

                debug.info(field_name, field_value, regex)

                if re.search(regex, field_value, flags=re.IGNORECASE) is not None:

                    # Found a match
                    return True

        # Default, could not find a match
        return False

    def getFootprint(self, libraryToo=True):
        ret = self.element.get("footprint")
        if ret == "" and libraryToo:
            if self.libpart:
                ret = self.libpart.getFootprint()
        return ret

    def getDatasheet(self, libraryToo=True):
        ret = self.element.get("datasheet")
        if ret == "" and libraryToo:
            ret = self.libpart.getDatasheet()
        return ret

    def getTimestamp(self):
        return self.element.get("tstamp")


class joiner:
    def __init__(self):
        self.stack = []

    def add(self, P, N):
        
        if self.stack == []:
            self.stack.append(((P, N), (P, N)))
            return

        S, E = self.stack[-1]

        if N == E[1] + 1:
            self.stack[-1] = (S, (P, N))
        else:
            self.stack.append(((P, N), (P, N)))

    def flush(self, sep, N=None, dash='-'):

        refstr = u''
        c = 0

        for Q in self.stack:
            if bool(N) and c != 0 and c % N == 0:
                refstr += u'\n'
            elif c != 0:
                refstr += sep + " "

            S, E = Q

            if S == E:
                refstr += "%s%d" % S
                c += 1
            else:
                # Do we have space?
                if bool(N) and (c + 1) % N == 0:
                    refstr += u'\n'
                    c += 1

                refstr += "%s%d%s%s%d" % (S[0], S[1], dash, E[0], E[1])
                c += 2
        return refstr


class ComponentGroup():

    """
    Initialize the group with no components, and default fields
    """
    def __init__(self, prefs=None):
        self.components = []
        self.fields = dict.fromkeys(ColumnList._COLUMNS_DEFAULT)  # Columns loaded from KiCad

        if not prefs:
            prefs = BomPref()

        self.prefs = prefs

    def getField(self, field):

        if field not in self.fields.keys():
            return ""
        
        if not self.fields[field]:
            return ""
        
        return u''.join((self.fields[field]))

    def getCount(self):
        return len(self.components)

    # Test if a given component fits in this group
    def matchComponent(self, c):
        if len(self.components) == 0:
            return True
        if c == self.components[0]:
            return True

        return False

    def containsComponent(self, c):
        # Test if a given component is already contained in this grop
        if not self.matchComponent(c):
            return False

        for comp in self.components:
            if comp.getRef() == c.getRef():
                return True

        return False

    def addComponent(self, c):
        # Add a component to the group

        if len(self.components) == 0:
            self.components.append(c)
        elif self.containsComponent(c):
            return
        elif self.matchComponent(c):
            self.components.append(c)

    def isFitted(self):
        return any([c.isFitted() for c in self.components])

    def isFixed(self):
        return any([c.isFixed() for c in self.components])

    def getRefs(self):
        # Return a list of the components
        separator = self.prefs.refSeparator
        return separator.join([c.getRef() for c in self.components])

    def getAltRefs(self):
        S = joiner()

        for n in self.components:
            P, N = (n.getPrefix(), n.getSuffix())
            S.add(P, N)

        return S.flush(self.prefs.refSeparator)

    # Sort the components in correct order
    def sortComponents(self):
        self.components = sorted(self.components, key=lambda c: natural_sort(c.getRef()))

    # Update a given field, based on some rules and such
    def updateField(self, field, fieldData):

        # Protected fields cannot be overwritten
        if field in ColumnList._COLUMNS_PROTECTED:
            return

        if field is None or field == "":
            return
        elif fieldData == "" or fieldData is None:
            return

        if (field not in self.fields.keys()) or (self.fields[field] is None) or (self.fields[field] == ""):
            self.fields[field] = fieldData
        elif fieldData.lower() in self.fields[field].lower():
            return
        else:
            debug.warning("Field conflict: ({refs}) [{name}] : '{flds}' <- '{fld}'".format(
                refs=self.getRefs(),
                name=field,
                flds=self.fields[field],
                fld=fieldData).encode('utf-8'))
            self.fields[field] += " " + fieldData

    def updateFields(self, usealt=False, wrapN=None):
        for c in self.components:
            for f in c.getFieldNames():

                # These columns are handled explicitly below
                if f in ColumnList._COLUMNS_PROTECTED:
                    continue

                self.updateField(f, c.getField(f))

        # Update 'global' fields
        if usealt:
            self.fields[ColumnList.COL_REFERENCE] = self.getAltRefs()
        else:
            self.fields[ColumnList.COL_REFERENCE] = self.getRefs()

        q = self.getCount()
        self.fields[ColumnList.COL_GRP_QUANTITY] = "{n}{dnf}{dnc}".format(
            n=q,
            dnf=" (DNF)" if not self.isFitted() else "",
            dnc=" (DNC)" if self.isFixed() else "")

        self.fields[ColumnList.COL_GRP_BUILD_QUANTITY] = str(q * self.prefs.boards) if self.isFitted() else "0"
        self.fields[ColumnList.COL_VALUE] = self.components[0].getValue()
        self.fields[ColumnList.COL_PART] = self.components[0].getPartName()
        self.fields[ColumnList.COL_PART_LIB] = self.components[0].getLibName()
        self.fields[ColumnList.COL_DESCRIPTION] = self.components[0].getDescription()
        self.fields[ColumnList.COL_DATASHEET] = self.components[0].getDatasheet()
        self.fields[ColumnList.COL_SHEETPATH] = self.components[0].getSheetpathNames()

        # Footprint field requires special attention
        fp = self.components[0].getFootprint().split(":")

        if len(fp) >= 2:
            self.fields[ColumnList.COL_FP_LIB] = fp[0]
            self.fields[ColumnList.COL_FP] = fp[1]
        elif len(fp) == 1:
            self.fields[ColumnList.COL_FP_LIB] = ""
            self.fields[ColumnList.COL_FP] = fp[0]
        else:
            self.fields[ColumnList.COL_FP_LIB] = ""
            self.fields[ColumnList.COL_FP] = ""

    # Return a dict of the KiCad data based on the supplied columns
    # NOW WITH UNICODE SUPPORT!
    def getRow(self, columns):
        row = []
        for key in columns:
            val = self.getField(key)

            # Join fields (appending to current value) (#81)
            for join_l in self.prefs.join:
                # Each list is "target, source..." so we need at least 2 elements
                elements = len(join_l)
                target = join_l[0]
                if elements > 1 and target == key:
                    # Append data from the other fields
                    for source in join_l[1:]:
                        v = self.getField(source)
                        if v:
                            val = val + ' ' + v

            if val is None:
                val = ""
            else:
                val = u'' + val
                if sys.version_info[0] < 3:
                    val = val.encode('utf-8')

            row.append(val)

        return row

1	# -- coding: utf-8 --
2	from __future__ import unicode_literals	1✔
3
4	import re	1✔
5	import sys	1✔
6
7	from .columns import ColumnList	1✔
8	from .preferences import BomPref	1✔
9	from . import units	1✔
10	from . import debug	1✔
11	from .sort import natural_sort	1✔
12
13	# String matches for marking a component as "do not fit"
14	DNF = [	1✔
15	"dnf",
16	"dnl",
17	"dnp",
18	"do not fit",
19	"do not place",
20	"do not load",
21	"nofit",
22	"nostuff",
23	"noplace",
24	"noload",
25	"not fitted",
26	"not loaded",
27	"not placed",
28	"no stuff",
29	]
30
31	# String matches for marking a component as "do not change" or "fixed"
32	DNC = [	1✔
33	"dnc",
34	"do not change",
35	"no change",
36	"fixed"
37	]
38
39
40	class Component():	1✔
41	"""Class for a component, aka 'comp' in the xml netlist file.
42	This component class is implemented by wrapping an xmlElement instance
43	with accessors. The xmlElement is held in field 'element'.
44	"""
45
46	def __init__(self, xml_element, prefs=None):	1✔
47	self.element = xml_element	1✔
48	self.libpart = None	1✔
49
50	if not prefs:	1✔
51	prefs = BomPref()	×
52
53	self.prefs = prefs	1✔
54
55	# Set to true when this component is included in a component group
56	self.grouped = False	1✔
57
58	# Compare the value of this part, to the value of another part (see if they match)
59	def compareValue(self, other):	1✔
60	# Simple string comparison
61	if self.getValue().lower() == other.getValue().lower():	1✔
62	return True	1✔
63
64	# Otherwise, perform a more complicated value comparison
65	if units.compareValues(self.getValue(), other.getValue()):	1✔
66	return True	1✔
67
68	# Ignore value if both components are connectors
69	if self.prefs.groupConnectors:	1✔
70	if 'connector' in self.getLibName().lower() and 'connector' in other.getLibName().lower():	1✔
71	return True	×
72
73	# No match, return False
74	return False	1✔
75
76	# Determine if two parts have the same name
77	def comparePartName(self, other):	1✔
78	pn1 = self.getPartName().lower()	1✔
79	pn2 = other.getPartName().lower()	1✔
80
81	# Simple direct match
82	if pn1 == pn2:	1✔
83	return True	1✔
84
85	# Compare part aliases e.g. "c" to "c_small"
86	for alias in self.prefs.aliases:	1✔
87	if pn1 in alias and pn2 in alias:	1✔
88	return True	×
89
90	return False	1✔
91
92	def compareField(self, other, field):	1✔
93
94	this_field = self.getField(field).lower()	1✔
95	other_field = other.getField(field).lower()	1✔
96
97	# If blank comparisons are allowed
98	if this_field == "" or other_field == "":	1✔
99	if not self.prefs.mergeBlankFields:	×
100	return False	×
101
102	if this_field == other_field:	1✔
103	return True	1✔
104
105	return False	1✔
106
107	def __eq__(self, other):	1✔
108	"""
109	Equivalency operator is used to determine if two parts are 'equal'
110	"""
111
112	# 'fitted' value must be the same for both parts
113	if self.isFitted() != other.isFitted():	1✔
114	return False	1✔
115
116	# 'fixed' value must be the same for both parts
117	if self.isFixed() != other.isFixed():	1✔
118	return False	1✔
119
120	if len(self.prefs.groups) == 0:	1✔
121	return False	×
122
123	for c in self.prefs.groups:	1✔
124	# Perform special matches
125	if c.lower() == ColumnList.COL_VALUE.lower():	1✔
126	if not self.compareValue(other):	1✔
127	return False	1✔
128	# Match part name
129	elif c.lower() == ColumnList.COL_PART.lower():	1✔
130	if not self.comparePartName(other):	1✔
131	return False	1✔
132
133	# Generic match
134	elif not self.compareField(other, c):	1✔
135	return False	1✔
136
137	return True	1✔
138
139	def setLibPart(self, part):	1✔
140	self.libpart = part	1✔
141
142	def getPrefix(self):	1✔
143	"""
144	Get the reference prefix
145	e.g. if this component has a reference U12, will return "U"
146	"""
147
148	prefix = ""	1✔
149
150	for c in self.getRef():	1✔
151	if c.isalpha():	1✔
152	prefix += c	1✔
153	else:
154	break	1✔
155
156	return prefix	1✔
157
158	def getSuffix(self):	1✔
159	"""
160	Return the reference suffix #
161	e.g. if this component has a reference U12, will return "12"
162	"""
163
164	suffix = ""	×
165
166	for c in self.getRef():	×
167	if c.isalpha():	×
168	suffix = ""	×
169	else:
170	suffix += c	×
171
172	return int(suffix)	×
173
174	def getLibPart(self):	1✔
175	return self.libpart	1✔
176
177	def getPartName(self):	1✔
178	return self.element.get("libsource", "part")	1✔
179
180	def getLibName(self):	1✔
181	return self.element.get("libsource", "lib")	1✔
182
183	def getSheetpathNames(self):	1✔
184	return self.element.get("sheetpath", "names")	1✔
185
186	def getDescription(self):	1✔
187	"""Extract the 'description' field for this component"""
188
189	# Give priority to a user "description" field
190	ret = self.element.get("field", "name", "description")	1✔
191	if ret:	1✔
192	return ret	×
193
194	ret = self.element.get("field", "name", "Description")	1✔
195	if ret:	1✔
196	return ret	×
197
198	try:	1✔
199	ret = self.element.get("libsource", "description")	1✔
200	except:	×
201	# Compatibility with old KiCad versions (4.x)
202	ret = self.element.get("field", "name", "description")	×
203
204	if ret == "":	1✔
205	try:	×
206	ret = self.libpart.getDescription()	×
207	except AttributeError:	×
208	# Raise a good error description here, so the user knows what the culprit component is.
209	# (sometimes libpart is None)
210	raise AttributeError('Could not get description for part {}{}.'.format(self.getPrefix(),	×
211	self.getSuffix()))
212
213	return ret	1✔
214
215	def setValue(self, value):	1✔
216	"""Set the value of this component"""
217	v = self.element.getChild("value")	×
218	if v:	×
219	v.setChars(value)	×
220
221	def getValue(self):	1✔
222	return self.element.get("value")	1✔
223
224	# Try to better sort R, L and C components
225	def getValueSort(self):	1✔
226	pref = self.getPrefix()	1✔
227	if pref in 'RLC' or pref == 'RV':	1✔
228	res = units.compMatch(self.getValue())	1✔
229	if res:	1✔
230	value, mult, unit = res	1✔
231	if pref in "CL":	1✔
232	# fempto Farads
233	value = "{0:15d}".format(int(value * 1e15 * mult + 0.1))	1✔
234	else:
235	# milli Ohms
236	value = "{0:15d}".format(int(value * 1000 * mult + 0.1))	1✔
237	return value	1✔
238	return self.element.get("value")	×
239
240	def setField(self, name, value):	1✔
241	""" Set the value of the specified field """
242
243	# Description field
244	doc = self.element.getChild('libsource')	×
245	if doc:	×
246	for att_name, att_value in doc.attributes.items():	×
247	if att_name.lower() == name.lower():	×
248	doc.attributes[att_name] = value	×
249	return value	×
250
251	# Common fields
252	field = self.element.getChild(name.lower())	×
253	if field:	×
254	field.setChars(value)	×
255	return value	×
256
257	# Other fields
258	fields = self.element.getChild('fields')	×
259	if fields:	×
260	for field in fields.getChildren():	×
261	if field.get('field', 'name') == name:	×
262	field.setChars(value)	×
263	return value	×
264
265	return None	×
266
267	def getField(self, name, ignoreCase=True, libraryToo=True):	1✔
268	"""Return the value of a field named name. The component is first
269	checked for the field, and then the components library part is checked
270	for the field. If the field doesn't exist in either, an empty string is
271	returned
272
273	Keywords:
274	name -- The name of the field to return the value for
275	libraryToo -- look in the libpart's fields for the same name if not found
276	in component itself
277	"""
278
279	fp = self.getFootprint().split(":")	1✔
280
281	if name.lower() == ColumnList.COL_REFERENCE.lower():	1✔
282	return self.getRef().strip()	1✔
283
284	elif name.lower() == ColumnList.COL_DESCRIPTION.lower():	1✔
285	return self.getDescription().strip()	×
286
287	elif name.lower() == ColumnList.COL_DATASHEET.lower():	1✔
288	return self.getDatasheet().strip()	×
289
290	# Footprint library is first element
291	elif name.lower() == ColumnList.COL_FP_LIB.lower():	1✔
292	if len(fp) > 1:	1✔
293	return fp[0].strip()	1✔
294	else:
295	# Explicit empty return
296	return ""	×
297
298	elif name.lower() == ColumnList.COL_FP.lower():	1✔
299	if len(fp) > 1:	1✔
300	return fp[1].strip()	1✔
301	elif len(fp) == 1:	×
302	return fp[0]	×
303	else:
304	return ""	×
305
306	elif name.lower() == ColumnList.COL_VALUE.lower():	1✔
307	return self.getValue().strip()	×
308
309	elif name.lower() == ColumnList.COL_PART.lower():	1✔
310	return self.getPartName().strip()	1✔
311
312	elif name.lower() == ColumnList.COL_PART_LIB.lower():	1✔
313	return self.getLibName().strip()	1✔
314
315	elif name.lower() == ColumnList.COL_SHEETPATH.lower():	1✔
316	return self.getSheetpathNames().strip()	×
317
318	# Other fields (case insensitive)
319	for f in self.getFieldNames():	1✔
320	if f.lower() == name.lower():	1✔
321	field = self.element.get("field", "name", f)	1✔
322
323	if field == "" and libraryToo:	1✔
324	field = self.libpart.getField(f)	×
325
326	return field.strip()	1✔
327
328	# Could not find a matching field
329	return ""	1✔
330
331	def getFieldNames(self):	1✔
332	"""Return a list of field names in play for this component. Mandatory
333	fields are not included, and they are: Value, Footprint, Datasheet, Ref.
334	The netlist format only includes fields with non-empty values. So if a field
335	is empty, it will not be present in the returned list.
336	"""
337
338	fieldNames = []	1✔
339
340	fields = self.element.getChild('fields')	1✔
341
342	if fields:	1✔
343	for f in fields.getChildren():	1✔
344	fieldNames.append(f.get('field', 'name'))	1✔
345
346	return fieldNames	1✔
347
348	def getRef(self):	1✔
349	return self.element.get("comp", "ref")	1✔
350
351	def isFitted(self):	1✔
352	""" Determine if a component is FITTED or not """
353
354	# First, check for the 'dnp' attribute (added in KiCad 7.0)
355	for child in self.element.getChildren():	1✔
356	if child.name == 'property':	1✔
357	if child.attributes.get('name', '').lower() == 'dnp':	×
358	return False	×
359
360	# Check the value field first
361	if self.getValue().lower() in DNF:	1✔
362	return False	×
363
364	check = self.getField(self.prefs.configField).lower()	1✔
365	# Empty value means part is fitted
366	if check == "":	1✔
367	return True	1✔
368
369	# Also support space separated list (simple cases)
370	opts = check.split(" ")	1✔
371	for opt in opts:	1✔
372	if opt.lower() in DNF:	1✔
373	return False	1✔
374
375	# Variants logic
376	opts = check.split(",")	1✔
377	# Exclude components that match a -VARIANT
378	for opt in opts:	1✔
379	opt = opt.strip()	1✔
380	# Any option containing a DNF is not fitted
381	if opt in DNF:	1✔
382	return False	×
383	# Options that start with '-' are explicitly removed from certain configurations
384	if opt.startswith("-") and opt[1:] in self.prefs.pcbConfig:	1✔
385	return False	×
386	# Include components that match +VARIANT
387	exclusive = False	1✔
388	for opt in opts:	1✔
389	# Options that start with '+' are fitted only for certain configurations
390	if opt.startswith("+"):	1✔
391	exclusive = True	×
392	if opt[1:] in self.prefs.pcbConfig:	×
393	return True	×
394	# No match
395	return not exclusive	1✔
396
397	def isFixed(self):	1✔
398	""" Determine if a component is FIXED or not.
399	Fixed components shouldn't be replaced without express authorization """
400
401	# Check the value field first
402	if self.getValue().lower() in DNC:	1✔
403	return True	×
404
405	check = self.getField(self.prefs.configField).lower()	1✔
406	# Empty is not fixed
407	if check == "":	1✔
408	return False	1✔
409
410	opts = check.split(" ")	1✔
411	for opt in opts:	1✔
412	if opt.lower() in DNC:	1✔
413	return True	1✔
414
415	opts = check.split(",")	1✔
416	for opt in opts:	1✔
417	if opt.lower() in DNC:	1✔
418	return True	×
419
420	return False	1✔
421
422	# Test if this part should be included, based on any regex expressions provided in the preferences
423	def testRegExclude(self):	1✔
424
425	for reg in self.prefs.regExcludes:	1✔
426
427	if type(reg) == list and len(reg) == 2:	1✔
428	field_name, regex = reg	1✔
429	field_value = self.getField(field_name)	1✔
430
431	# Attempt unicode escaping...
432	# Filthy hack
433	try:	1✔
434	regex = regex.decode("unicode_escape")	1✔
435	except:	1✔
436	pass	1✔
437
438	if re.search(regex, field_value, flags=re.IGNORECASE) is not None:	1✔
439	debug.info("Excluding '{ref}': Field '{field}' ({value}) matched '{reg}'".format(	×
440	ref=self.getRef(),
441	field=field_name,
442	value=field_value,
443	reg=regex).encode('utf-8')
444	)
445
446	# Found a match
447	return True	×
448
449	# Default, could not find any matches
450	return False	1✔
451
452	def testRegInclude(self):	1✔
453
454	if len(self.prefs.regIncludes) == 0: # Nothing to match against	1✔
455	return True	1✔
456
457	for reg in self.prefs.regIncludes:	×
458
459	if type(reg) == list and len(reg) == 2:	×
460	field_name, regex = reg	×
461	field_value = self.getField(field_name)	×
462
463	debug.info(field_name, field_value, regex)	×
464
465	if re.search(regex, field_value, flags=re.IGNORECASE) is not None:	×
466
467	# Found a match
468	return True	×
469
470	# Default, could not find a match
471	return False	×
472
473	def getFootprint(self, libraryToo=True):	1✔
474	ret = self.element.get("footprint")	1✔
475	if ret == "" and libraryToo:	1✔
476	if self.libpart:	×
477	ret = self.libpart.getFootprint()	×
478	return ret	1✔
479
480	def getDatasheet(self, libraryToo=True):	1✔
481	ret = self.element.get("datasheet")	1✔
482	if ret == "" and libraryToo:	1✔
483	ret = self.libpart.getDatasheet()	×
484	return ret	1✔
485
486	def getTimestamp(self):	1✔
487	return self.element.get("tstamp")	×
488
489
490	class joiner:	1✔
491	def __init__(self):	1✔
492	self.stack = []	×
493
494	def add(self, P, N):	1✔
495
496	if self.stack == []:	×
497	self.stack.append(((P, N), (P, N)))	×
498	return	×
499
500	S, E = self.stack[-1]	×
501
502	if N == E[1] + 1:	×
503	self.stack[-1] = (S, (P, N))	×
504	else:
505	self.stack.append(((P, N), (P, N)))	×
506
507	def flush(self, sep, N=None, dash='-'):	1✔
508
509	refstr = u''	×
510	c = 0	×
511
512	for Q in self.stack:	×
513	if bool(N) and c != 0 and c % N == 0:	×
514	refstr += u'\n'	×
515	elif c != 0:	×
516	refstr += sep + " "	×
517
518	S, E = Q	×
519
520	if S == E:	×
521	refstr += "%s%d" % S	×
522	c += 1	×
523	else:
524	# Do we have space?
525	if bool(N) and (c + 1) % N == 0:	×
526	refstr += u'\n'	×
527	c += 1	×
528
529	refstr += "%s%d%s%s%d" % (S[0], S[1], dash, E[0], E[1])	×
530	c += 2	×
531	return refstr	×
532
533
534	class ComponentGroup():	1✔
535
536	"""
537	Initialize the group with no components, and default fields
538	"""
539	def __init__(self, prefs=None):	1✔
540	self.components = []	1✔
541	self.fields = dict.fromkeys(ColumnList._COLUMNS_DEFAULT) # Columns loaded from KiCad	1✔
542
543	if not prefs:	1✔
544	prefs = BomPref()	×
545
546	self.prefs = prefs	1✔
547
548	def getField(self, field):	1✔
549
550	if field not in self.fields.keys():	1✔
551	return ""	1✔
552
553	if not self.fields[field]:	1✔
554	return ""	×
555
556	return u''.join((self.fields[field]))	1✔
557
558	def getCount(self):	1✔
559	return len(self.components)	1✔
560
561	# Test if a given component fits in this group
562	def matchComponent(self, c):	1✔
563	if len(self.components) == 0:	1✔
564	return True	×
565	if c == self.components[0]:	1✔
566	return True	1✔
567
568	return False	1✔
569
570	def containsComponent(self, c):	1✔
571	# Test if a given component is already contained in this grop
572	if not self.matchComponent(c):	1✔
573	return False	×
574
575	for comp in self.components:	1✔
576	if comp.getRef() == c.getRef():	1✔
577	return True	×
578
579	return False	1✔
580
581	def addComponent(self, c):	1✔
582	# Add a component to the group
583
584	if len(self.components) == 0:	1✔
585	self.components.append(c)	1✔
586	elif self.containsComponent(c):	1✔
587	return	×
588	elif self.matchComponent(c):	1✔
589	self.components.append(c)	1✔
590
591	def isFitted(self):	1✔
592	return any([c.isFitted() for c in self.components])	1✔
593
594	def isFixed(self):	1✔
595	return any([c.isFixed() for c in self.components])	1✔
596
597	def getRefs(self):	1✔
598	# Return a list of the components
599	separator = self.prefs.refSeparator	1✔
600	return separator.join([c.getRef() for c in self.components])	1✔
601
602	def getAltRefs(self):	1✔
603	S = joiner()	×
604
605	for n in self.components:	×
606	P, N = (n.getPrefix(), n.getSuffix())	×
607	S.add(P, N)	×
608
609	return S.flush(self.prefs.refSeparator)	×
610
611	# Sort the components in correct order
612	def sortComponents(self):	1✔
613	self.components = sorted(self.components, key=lambda c: natural_sort(c.getRef()))	1✔
614
615	# Update a given field, based on some rules and such
616	def updateField(self, field, fieldData):	1✔
617
618	# Protected fields cannot be overwritten
619	if field in ColumnList._COLUMNS_PROTECTED:	1✔
620	return	×
621
622	if field is None or field == "":	1✔
623	return	×
624	elif fieldData == "" or fieldData is None:	1✔
625	return	×
626
627	if (field not in self.fields.keys()) or (self.fields[field] is None) or (self.fields[field] == ""):	1✔
628	self.fields[field] = fieldData	1✔
629	elif fieldData.lower() in self.fields[field].lower():	×
630	return	×
631	else:
632	debug.warning("Field conflict: ({refs}) [{name}] : '{flds}' <- '{fld}'".format(	×
633	refs=self.getRefs(),
634	name=field,
635	flds=self.fields[field],
636	fld=fieldData).encode('utf-8'))
637	self.fields[field] += " " + fieldData	×
638
639	def updateFields(self, usealt=False, wrapN=None):	1✔
640	for c in self.components:	1✔
641	for f in c.getFieldNames():	1✔
642
643	# These columns are handled explicitly below
644	if f in ColumnList._COLUMNS_PROTECTED:	1✔
645	continue	×
646
647	self.updateField(f, c.getField(f))	1✔
648
649	# Update 'global' fields
650	if usealt:	1✔
651	self.fields[ColumnList.COL_REFERENCE] = self.getAltRefs()	×
652	else:
653	self.fields[ColumnList.COL_REFERENCE] = self.getRefs()	1✔
654
655	q = self.getCount()	1✔
656	self.fields[ColumnList.COL_GRP_QUANTITY] = "{n}{dnf}{dnc}".format(	1✔
657	n=q,
658	dnf=" (DNF)" if not self.isFitted() else "",
659	dnc=" (DNC)" if self.isFixed() else "")
660
661	self.fields[ColumnList.COL_GRP_BUILD_QUANTITY] = str(q * self.prefs.boards) if self.isFitted() else "0"	1✔
662	self.fields[ColumnList.COL_VALUE] = self.components[0].getValue()	1✔
663	self.fields[ColumnList.COL_PART] = self.components[0].getPartName()	1✔
664	self.fields[ColumnList.COL_PART_LIB] = self.components[0].getLibName()	1✔
665	self.fields[ColumnList.COL_DESCRIPTION] = self.components[0].getDescription()	1✔
666	self.fields[ColumnList.COL_DATASHEET] = self.components[0].getDatasheet()	1✔
667	self.fields[ColumnList.COL_SHEETPATH] = self.components[0].getSheetpathNames()	1✔
668
669	# Footprint field requires special attention
670	fp = self.components[0].getFootprint().split(":")	1✔
671
672	if len(fp) >= 2:	1✔
673	self.fields[ColumnList.COL_FP_LIB] = fp[0]	1✔
674	self.fields[ColumnList.COL_FP] = fp[1]	1✔
675	elif len(fp) == 1:	×
676	self.fields[ColumnList.COL_FP_LIB] = ""	×
677	self.fields[ColumnList.COL_FP] = fp[0]	×
678	else:
679	self.fields[ColumnList.COL_FP_LIB] = ""	×
680	self.fields[ColumnList.COL_FP] = ""	×
681
682	# Return a dict of the KiCad data based on the supplied columns
683	# NOW WITH UNICODE SUPPORT!
684	def getRow(self, columns):	1✔
685	row = []	1✔
686	for key in columns:	1✔
687	val = self.getField(key)	1✔
688
689	# Join fields (appending to current value) (#81)
690	for join_l in self.prefs.join:	1✔
691	# Each list is "target, source..." so we need at least 2 elements
692	elements = len(join_l)	×
693	target = join_l[0]	×
694	if elements > 1 and target == key:	×
695	# Append data from the other fields
696	for source in join_l[1:]:	×
697	v = self.getField(source)	×
698	if v:	×
699	val = val + ' ' + v	×
700
701	if val is None:	1✔
702	val = ""	×
703	else:
704	val = u'' + val	1✔
705	if sys.version_info[0] < 3:	1✔
706	val = val.encode('utf-8')	×
707
708	row.append(val)	1✔
709
710	return row	1✔

SchrodingersGat / KiBoM / 4891038286

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous