Move python_scripts up one folder in eeschema

eeschema/python_scripts/CMakeLists.txt

@@ -0,0 +1,19 @@
+# EESCHEMA's netlist and bom sample scripts
+
+set( PYTHON_SCRIPTS_LIST
+    README-bom.txt
+    kicad_utils.py
+    kicad_netlist_reader.py
+    bom_csv_grouped_by_value.py
+    bom_csv_grouped_by_value_with_fp.py
+    bom_csv_grouped_extra.py
+    bom_csv_sorted_by_ref.py
+    bom_html_grouped_by_value.py
+    bom_html_with_advanced_grouping.py
+    bom_txt_sorted_by_ref.py
+    )
+
+install( FILES ${PYTHON_SCRIPTS_LIST}
+    DESTINATION ${KICAD_PLUGINS}
+    COMPONENT binary
+    )

eeschema/python_scripts/README-bom.txt

@@ -0,0 +1,38 @@
+bom_?.py are some python scripts which read a generic xml netlist from eeschema,
+and create a bom.
+
+All examples use kicad_netlist_reader.py, which is a python utility to read
+and parse this generic xml netlist and create the corresponding data
+used to build the bom.
+
+You can modify them to build the bom you want.
+
+to use them, you should install python, and run:
+python bom_example?.py <netlist name> <bom list netname>
+
+See Eeschema doc, chapter 14 for info about the generic xml netlist format,
+and how to run a script from Eeschema to create a customized netlist or BOM.
+
+If the python comment
+"""
+    @package
+    some comments
+"""
+is added to the beginning of the python script, the comment will be displayed
+in Eescheam, in the BOM dialog
+
+For instance:
+"""
+    @package
+    Generate a HTML BOM list.
+    Components are sorted and grouped by value
+    Fields are (if exist)
+    Ref, Quantity, Value, Part, Datasheet, Description, Vendor
+"""
+
+displays:
+    Generate a HTML BOM list.
+    Components are sorted and grouped by value
+    Fields are (if exist)
+    Ref, Quantity, Value, Part, Datasheet, Description, Vendor
+in BOM dialog

eeschema/python_scripts/bom_csv_grouped_by_value.py

@@ -0,0 +1,158 @@
+#
+# Example python script to generate a BOM from a KiCad generic netlist
+#
+# Example: Sorted and Grouped CSV BOM
+#
+
+"""
+    @package
+    Output: CSV (comma-separated)
+    Grouped By: Value, Symbol Name, Footprint, DNP
+    Sorted By: Ref
+    Fields: Item, Qty, Reference(s), Value, LibPart, Footprint, Datasheet, DNP, all additional symbol fields
+
+    Outputs ungrouped components first, then outputs grouped components.
+
+    Command line:
+    python "pathToFile/bom_csv_grouped_by_value.py" "%I" "%O.csv"
+"""
+
+from __future__ import print_function
+
+# Import the KiCad python helper module and the csv formatter
+import kicad_netlist_reader
+import kicad_utils
+import csv
+import sys
+
+# A helper function to filter/convert a string read in netlist
+#currently: do nothing
+def fromNetlistText( aText ):
+    return aText
+
+def myEqu(self, other):
+    """myEqu is a more advanced equivalence function for components which is
+    used by component grouping. Normal operation is to group components based
+    on their value and footprint.
+
+    In this example of a custom equivalency operator we compare the
+    value, the part name and the footprint.
+    """
+    result = True
+    if self.getValue() != other.getValue():
+        result = False
+    elif self.getPartName() != other.getPartName():
+        result = False
+    elif self.getFootprint() != other.getFootprint():
+        result = False
+    elif self.getDNP() != other.getDNP():
+        result = False
+
+    return result
+
+# Override the component equivalence operator - it is important to do this
+# before loading the netlist, otherwise all components will have the original
+# equivalency operator.
+kicad_netlist_reader.comp.__eq__ = myEqu
+
+if len(sys.argv) != 3:
+    print("Usage ", __file__, "<generic_netlist.xml> <output.csv>", file=sys.stderr)
+    sys.exit(1)
+
+
+# Generate an instance of a generic netlist, and load the netlist tree from
+# the command line option. If the file doesn't exist, execution will stop
+net = kicad_netlist_reader.netlist(sys.argv[1])
+
+# Open a file to write to, if the file cannot be opened output to stdout
+# instead
+canOpenFile = True
+try:
+    f = kicad_utils.open_file_writeUTF8(sys.argv[2], 'w')
+except IOError:
+    e = "Can't open output file for writing: " + sys.argv[2]
+    print( __file__, ":", e, sys.stderr )
+    f = sys.stdout
+    canOpenFile = False
+
+# subset the components to those wanted in the BOM, controlled
+# by <configure> block in kicad_netlist_reader.py
+components = net.getInterestingComponents( excludeBOM=True )
+
+compfields = net.gatherComponentFieldUnion(components)
+partfields = net.gatherLibPartFieldUnion()
+
+# remove Reference, Value, Datasheet, and Footprint, they will come from 'columns' below
+partfields -= set( ['Reference', 'Value', 'Datasheet', 'Footprint'] )
+
+columnset = compfields | partfields     # union
+
+# prepend an initial 'hard coded' list and put the enchillada into list 'columns'
+hardcoded_columns = ['Item', 'Qty', 'Reference(s)', 'Value', 'LibPart', 'Footprint', 'Datasheet', 'DNP']
+columns = hardcoded_columns + sorted(list(columnset))
+
+# Create a new csv writer object to use as the output formatter
+out = csv.writer( f, lineterminator='\n', delimiter=',', quotechar='\"', quoting=csv.QUOTE_ALL )
+
+# override csv.writer's writerow() to support encoding conversion (initial encoding is utf8):
+def writerow( acsvwriter, columns ):
+    utf8row = []
+    for col in columns:
+        utf8row.append( fromNetlistText( str(col) ) )
+    acsvwriter.writerow( utf8row )
+
+# Output a set of rows as a header providing general information
+writerow( out, ['Source:', net.getSource()] )
+writerow( out, ['Date:', net.getDate()] )
+writerow( out, ['Tool:', net.getTool()] )
+writerow( out, ['Generator:', sys.argv[0]] )
+writerow( out, ['Component Count:', len(components)] )
+writerow( out, [] )
+
+writerow( out, ['Collated Components:'] )
+writerow( out, [] )                        # blank line
+writerow( out, columns )                   # reuse same columns
+
+row=[]
+
+# Get all of the components in groups of matching parts + values
+# (see kicad_netlist_reader.py)
+grouped = net.groupComponents(components)
+
+
+# Output component information organized by group, aka as collated:
+item = 0
+for group in grouped:
+    del row[:]
+    refs = ""
+
+    # Add the reference of every component in the group and keep a reference
+    # to the component so that the other data can be filled in once per group
+    for component in group:
+        if len(refs) > 0:
+            refs += ", "
+        refs += component.getRef()
+        c = component
+
+    # Fill in the component groups common data
+    # columns = ['Item', 'Qty', 'Reference(s)', 'Value', 'LibPart', 'Footprint', 'Datasheet', 'DNP'] + sorted(list(columnset))
+    item += 1
+    row.append( item )
+    row.append( len(group) )
+    row.append( refs );
+    row.append( c.getValue() )
+    row.append( c.getLibName() + ":" + c.getPartName() )
+    row.append( net.getGroupFootprint(group) )
+    row.append( net.getGroupDatasheet(group) )
+    row.append( c.getDNPString() )
+
+    # add user fields by name
+    for field in columns[len(hardcoded_columns):]:
+        row.append( net.getGroupField(group, field) );
+
+    writerow( out, row  )
+
+f.close()
+
+if not canOpenFile:
+    sys.exit(1)

eeschema/python_scripts/bom_csv_grouped_by_value_with_fp.py

@@ -0,0 +1,82 @@
+#
+# Example python script to generate a BOM from a KiCad generic netlist
+#
+# Example: Sorted and Grouped CSV BOM
+#
+
+"""
+    @package
+    Output: CSV (comma-separated)
+    Grouped By: Value, Footprint, DNP
+    Sorted By: Ref
+    Fields: Ref, Qnty, Value, Cmp name, Footprint, Description, Vendor, DNP
+
+    Command line:
+    python "pathToFile/bom_csv_grouped_by_value_with_fp.py" "%I" "%O.csv"
+"""
+
+# Import the KiCad python helper module and the csv formatter
+import kicad_netlist_reader
+import kicad_utils
+import csv
+import sys
+
+# A helper function to filter/convert a string read in netlist
+#currently: do nothing
+def fromNetlistText( aText ):
+    return aText
+
+# Generate an instance of a generic netlist, and load the netlist tree from
+# the command line option. If the file doesn't exist, execution will stop
+net = kicad_netlist_reader.netlist(sys.argv[1])
+
+# Open a file to write to, if the file cannot be opened output to stdout
+# instead
+canOpenFile = True
+try:
+    f = kicad_utils.open_file_writeUTF8(sys.argv[2], 'w')
+except IOError:
+    e = "Can't open output file for writing: " + sys.argv[2]
+    print(__file__, ":", e, sys.stderr)
+    f = sys.stdout
+    canOpenFile = False
+
+# Create a new csv writer object to use as the output formatter
+out = csv.writer(f, lineterminator='\n', delimiter=',', quotechar='\"', quoting=csv.QUOTE_ALL)
+
+# Output a set of rows for a header providing general information
+out.writerow(['Source:', net.getSource()])
+out.writerow(['Date:', net.getDate()])
+out.writerow(['Tool:', net.getTool()])
+out.writerow( ['Generator:', sys.argv[0]] )
+out.writerow(['Component Count:', len(net.components)])
+out.writerow(['Ref', 'Qnty', 'Value', 'Cmp name', 'Footprint', 'Description', 'Vendor', 'DNP'])
+
+
+# Get all of the components in groups of matching parts + values
+# (see ky_generic_netlist_reader.py)
+grouped = net.groupComponents()
+
+# Output all of the component information
+for group in grouped:
+    refs = ""
+
+    # Add the reference of every component in the group and keep a reference
+    # to the component so that the other data can be filled in once per group
+    for component in group:
+        if refs != "":
+            refs += ", "
+        refs += fromNetlistText( component.getRef() )
+        c = component
+
+    # Fill in the component groups common data
+    out.writerow([refs, len(group),
+        fromNetlistText( c.getValue() ),
+        fromNetlistText( c.getPartName() ),
+        fromNetlistText( c.getFootprint() ),
+        fromNetlistText( c.getDescription() ),
+        fromNetlistText( c.getField("Vendor") ),
+        c.getDNPString()])
+
+if not canOpenFile:
+    sys.exit(1)

eeschema/python_scripts/bom_csv_grouped_extra.py

@@ -0,0 +1,122 @@
+#
+# Example python script to generate a BOM from a KiCad generic netlist
+#
+# Example: Sorted and Grouped CSV BOM
+#
+
+"""
+    @package
+    Output: CSV (comma-separated)
+    Grouped By: Value, Footprint, DNP, specified extra fields
+    Sorted By: Reference
+    Fields: #, Reference, Qty, Value, Footprint, DNP, specified extra fields
+
+    Outputs components grouped by Value, Footprint, and specified extra fields.
+    Extra fields can be passed as command line arguments at the end, one field per argument.
+
+    Command line:
+    python "pathToFile/bom_csv_grouped_extra.py" "%I" "%O.csv" "Extra_Field1" "Extra_Field2"
+"""
+
+# Import the KiCad python helper module and the csv formatter
+import kicad_netlist_reader
+import kicad_utils
+import csv
+import sys
+
+# Get extra fields from the command line
+extra_fields = sys.argv[3:]
+
+comp_fields = ['Value', 'Footprint', 'DNP'] + extra_fields
+header_names = ['#', 'Reference', 'Qty'] + comp_fields
+
+def getComponentString(comp, field_name):
+    if field_name == "Value":
+        return comp.getValue()
+    elif field_name == "Footprint":
+        return comp.getFootprint()
+    elif field_name == "DNP":
+        return comp.getDNPString()
+    elif field_name == "Datasheet":
+        return comp.getDatasheet()
+    else:
+        return comp.getField( field_name )
+
+def myEqu(self, other):
+    """myEqu is a more advanced equivalence function for components which is
+    used by component grouping. Normal operation is to group components based
+    on their Value and Footprint.
+
+    In this example of a more advanced equivalency operator we also compare the
+    Footprint, Value, DNP and all extra fields passed from the command line. If
+    these fields are not used in some parts they will simply be ignored (they
+    will match as both will be empty strings).
+
+    """
+    result = True
+    for field_name in comp_fields:
+        if getComponentString(self, field_name) != getComponentString(other, field_name):
+            result = False
+
+    return result
+
+# Override the component equivalence operator - it is important to do this
+# before loading the netlist, otherwise all components will have the original
+# equivalency operator.
+kicad_netlist_reader.comp.__eq__ = myEqu
+
+# Generate an instance of a generic netlist, and load the netlist tree from
+# the command line option. If the file doesn't exist, execution will stop
+net = kicad_netlist_reader.netlist(sys.argv[1])
+
+# Open a file to write to, if the file cannot be opened output to stdout
+# instead
+canOpenFile = True
+try:
+    f = kicad_utils.open_file_writeUTF8(sys.argv[2], 'w')
+except IOError:
+    e = "Can't open output file for writing: " + sys.argv[2]
+    print(__file__, ":", e, sys.stderr)
+    f = sys.stdout
+    canOpenFile = False
+
+# Create a new csv writer object to use as the output formatter
+out = csv.writer(f, lineterminator='\n', delimiter=',', quotechar='\"', quoting=csv.QUOTE_ALL)
+
+# Output a CSV header
+out.writerow(header_names)
+
+# Get all of the components in groups of matching parts + values
+# (see kicad_netlist_reader.py)
+grouped = net.groupComponents()
+
+# Output all of the component information
+index = 1
+for group in grouped:
+    refs = ""
+
+    # Add the reference of every component in the group and keep a reference
+    # to the component so that the other data can be filled in once per group
+    for component in group:
+        refs += component.getRef() + ", "
+        c = component
+
+    # Remove trailing comma
+    refs = refs[:-2]
+
+    # Fill in the component groups common data
+    row = []
+    row.append( index )
+    row.append( refs )
+    row.append( len(group) )
+
+    # Add the values of component-specific data
+    for field_name in comp_fields:
+        row.append( getComponentString( c, field_name ) )
+
+    out.writerow(row)
+
+    index += 1
+
+if not canOpenFile:
+    sys.exit(1)

eeschema/python_scripts/bom_csv_sorted_by_ref.py

@@ -0,0 +1,72 @@
+#
+# Example python script to generate a BOM from a KiCad generic netlist
+#
+# Example: Ungrouped (One component per row) CSV output
+#
+
+"""
+    @package
+    Output: CSV (comma-separated)
+    Grouped By: ungrouped, one component per line
+    Sorted By: Ref
+    Fields: Ref, Value, Part, Footprint, Datasheet, Manufacturer, Vendor, DNP
+
+    Command line:
+    python "pathToFile/bom_csv_sorted_by_ref.py" "%I" "%O.csv"
+"""
+
+from __future__ import print_function
+
+# Import the KiCad python helper module
+import kicad_netlist_reader
+import kicad_utils
+import csv
+import sys
+
+# A helper function to filter/convert a string read in netlist
+#currently: do nothing
+def fromNetlistText( aText ):
+    return aText
+
+# Generate an instance of a generic netlist, and load the netlist tree from
+# the command line option. If the file doesn't exist, execution will stop
+net = kicad_netlist_reader.netlist(sys.argv[1])
+
+# Open a file to write to, if the file cannot be opened output to stdout
+# instead
+canOpenFile = True
+try:
+    f = kicad_utils.open_file_writeUTF8(sys.argv[2], 'w')
+except IOError:
+    e = "Can't open output file for writing: " + sys.argv[2]
+    print( __file__, ":", e, sys.stderr )
+    f = sys.stdout
+    canOpenFile = False
+
+# Create a new csv writer object to use as the output formatter
+out = csv.writer(f, lineterminator='\n', delimiter=',', quotechar="\"", quoting=csv.QUOTE_ALL)
+
+# override csv.writer's writerow() to support utf8 encoding:
+def writerow( acsvwriter, columns ):
+    utf8row = []
+    for col in columns:
+        utf8row.append( fromNetlistText( str(col) ) )
+    acsvwriter.writerow( utf8row )
+
+components = net.getInterestingComponents( excludeBOM=True )
+
+# Output a field delimited header line
+writerow( out, ['Source:', net.getSource()] )
+writerow( out, ['Date:', net.getDate()] )
+writerow( out, ['Tool:', net.getTool()] )
+writerow( out, ['Component Count:', len(components)] )
+writerow( out, ['Ref', 'Value', 'Footprint', 'Datasheet', 'Manufacturer', 'Vendor', 'DNP'] )
+
+# Output all of the component information (One component per row)
+for c in components:
+    writerow( out, [c.getRef(), c.getValue(), c.getFootprint(), c.getDatasheet(),
+        c.getField("Manufacturer"), c.getField("Vendor"), c.getDNPString()])
+
+
+if not canOpenFile:
+    sys.exit(1)

eeschema/python_scripts/bom_html_grouped_by_value.py

@@ -0,0 +1,113 @@
+#
+# Example python script to generate a BOM from a KiCad generic netlist
+# The KiCad generic xml netlist is expected to be encoded UTF-8
+#
+# Example: Sorted and Grouped HTML BOM
+#
+
+"""
+    @package
+    Output: HTML
+    Grouped By: Value, DNP
+    Sorted By: Ref
+    Fields: Ref, Qnty, Value, Part, Datasheet, Description, Vendor, DNP
+
+    Command line:
+    python "pathToFile/bom_html_grouped_by_value.py" "%I" "%O.html"
+"""
+
+from __future__ import print_function
+
+# Import the KiCad python helper module and the csv formatter
+import kicad_netlist_reader
+import kicad_utils
+import sys
+
+# Start with a basic html template
+html = """
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+    <head>
+        <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    </head>
+    <body>
+    <h1><!--SOURCE--></h1>
+    <p><!--DATE--></p>
+    <p><!--TOOL--></p>
+    <p><!--COMPCOUNT--></p>
+    <table>
+    <!--TABLEROW-->
+    </table>
+    </body>
+</html>
+    """
+
+# Generate an instance of a generic netlist, and load the netlist tree from
+# the command line option. If the file doesn't exist, execution will stop
+net = kicad_netlist_reader.netlist(sys.argv[1])
+
+# Open a file to write to, if the file cannot be opened output to stdout
+# instead
+canOpenFile = True
+try:
+    f = kicad_utils.open_file_write(sys.argv[2], 'wb')
+except IOError:
+    e = "Can't open output file for writing: " + sys.argv[2]
+    print(__file__, ":", e, file=sys.stderr)
+    f = sys.stdout
+    canOpenFile = False
+
+components = net.getInterestingComponents( excludeBOM=True )
+
+# Output a set of rows for a header providing general information
+html = html.replace('<!--SOURCE-->', net.getSource())
+html = html.replace('<!--DATE-->', net.getDate())
+html = html.replace('<!--TOOL-->', net.getTool())
+html = html.replace('<!--COMPCOUNT-->', "<b>Component Count:</b>" + \
+    str(len(components)))
+
+row =""
+row += "<tr><th>Ref</th>"
+row += "<th>Qnty</th>"
+row += "<th>Value</th>" + "<th>Part</th>" + "<th>Datasheet</th>"
+row += "<th>Description</th>" + "<th>Vendor</th>" + "<th>DNP</th></tr>"
+
+html = html.replace('<!--TABLEROW-->', row + "<!--TABLEROW-->")
+
+# Get all of the components in groups of matching parts + values
+# (see kicad_netlist_reader.py)
+grouped = net.groupComponents(components)
+
+# Output all of the component information
+for group in grouped:
+    refs = ""
+
+    # Add the reference of every component in the group and keep a reference
+    # to the component so that the other data can be filled in once per group
+    for component in group:
+        if len(refs) > 0:
+            refs += ", "
+        refs += component.getRef()
+        c = component
+
+    row = "<tr><td>" + refs +"</td><td>" + str(len(group))
+    row += "</td><td>" + c.getValue()
+    row += "</td><td>" + c.getLibName() + ":" + c.getPartName()
+    row += "</td><td>" + c.getDatasheet()
+    row += "</td><td>" + c.getDescription()
+    row += "</td><td>" + c.getField("Vendor")
+    row += "</td><td>" + c.getDNPString() + "</td></tr>"
+    row += "\n"
+
+    html = html.replace('<!--TABLEROW-->', row + "<!--TABLEROW-->")
+
+# Write the formatted html to the file
+if sys.version_info[0] < 3:
+    f.write(html)
+else:
+    f.write(html.encode('utf-8'))
+f.close()
+
+if not canOpenFile:
+    sys.exit(1)

eeschema/python_scripts/bom_html_with_advanced_grouping.py

@@ -0,0 +1,146 @@
+#
+# Example python script to generate a BOM from a KiCad generic netlist
+# The KiCad generic xml netlist is expected to be encoded UTF-8
+#
+# Example: Sorted and Grouped HTML BOM with advanced grouping
+#
+
+"""
+    @package
+    Output: HTML
+    Grouped By: Value, Part, Footprint, Tolerance, Manufacturer, Voltage, DNP
+    Sorted By: Ref
+    Fields: Ref, Qnty, Value, Part, Footprint, Description, Vendor, DNP
+
+    Command line:
+    python "pathToFile/bom_with_advanced_grouping.py" "%I" "%O.html"
+"""
+
+from __future__ import print_function
+
+# Import the KiCad python helper module and the csv formatter
+import kicad_netlist_reader
+import kicad_utils
+import sys
+
+
+# Start with a basic html template
+html = """
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+    <head>
+        <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+        <title>KiCad BOM Example 5</title>
+    </head>
+    <body>
+    <h1><!--SOURCE--></h1>
+    <p><!--DATE--></p>
+    <p><!--TOOL--></p>
+    <p><!--COMPCOUNT--></p>
+    <table>
+    <!--TABLEROW-->
+    </table>
+    </body>
+</html>
+    """
+
+def myEqu(self, other):
+    """myEqu is a more advanced equivalence function for components which is
+    used by component grouping. Normal operation is to group components based
+    on their Value and Footprint.
+
+    In this example of a more advanced equivalency operator we also compare the
+    custom fields Voltage, Tolerance and Manufacturer as well as the assigned
+    footprint. If these fields are not used in some parts they will simply be
+    ignored (they will match as both will be empty strings).
+
+    """
+    result = True
+    if self.getValue() != other.getValue():
+        result = False
+    elif self.getPartName() != other.getPartName():
+        result = False
+    elif self.getFootprint() != other.getFootprint():
+        result = False
+    elif self.getField("Tolerance") != other.getField("Tolerance"):
+        result = False
+    elif self.getField("Manufacturer") != other.getField("Manufacturer"):
+        result = False
+    elif self.getField("Voltage") != other.getField("Voltage"):
+        result = False
+    elif self.getDNP() != other.getDNP():
+        result = False
+
+    return result
+
+# Override the component equivalence operator - it is important to do this
+# before loading the netlist, otherwise all components will have the original
+# equivalency operator.
+kicad_netlist_reader.comp.__eq__ = myEqu
+
+# Generate an instance of a generic netlist, and load the netlist tree from
+# <file>.tmp. If the file doesn't exist, execution will stop
+net = kicad_netlist_reader.netlist(sys.argv[1])
+
+# Open a file to write to, if the file cannot be opened output to stdout
+# instead
+canOpenFile = True
+try:
+    f = kicad_utils.open_file_write(sys.argv[2], 'wb')
+except IOError:
+    e = "Can't open output file for writing: " + sys.argv[2]
+    print(__file__, ":", e, file=sys.stderr)
+    f = sys.stdout
+    canOpenFile = False
+
+# Output a set of rows for a header providing general information
+html = html.replace('<!--SOURCE-->', net.getSource())
+html = html.replace('<!--DATE-->', net.getDate())
+html = html.replace('<!--TOOL-->', net.getTool())
+html = html.replace('<!--COMPCOUNT-->', "<b>Component Count:</b>" + \
+    str(len(net.components)))
+
+row  = "<tr><th style='width:640px'>Ref</th>" + "<th>Qnty</th>"
+row += "<th>Value</th>" + "<th>Part</th>" + "<th>Footprint</th>"
+row += "<th>Description</th>" + "<th>Vendor</th>" + "<th>DNP</th></tr>"
+
+html = html.replace('<!--TABLEROW-->', row + "<!--TABLEROW-->")
+
+components = net.getInterestingComponents( excludeBOM=True )
+
+# Get all of the components in groups of matching parts + values
+# (see kicad_netlist_reader.py)
+grouped = net.groupComponents(components)
+
+# Output all of the component information
+for group in grouped:
+    refs = ""
+
+    # Add the reference of every component in the group and keep a reference
+    # to the component so that the other data can be filled in once per group
+    for component in group:
+        if len(refs) > 0:
+            refs += ", "
+        refs += component.getRef()
+        c = component
+
+    row = "\n    "
+    row += "<tr><td>" + refs +"</td><td>" + str(len(group))
+    row += "</td><td>" + c.getValue() + "</td><td>" + c.getLibName() + ":"
+    row += c.getPartName() + "</td><td>" + c.getFootprint() + "</td><td>"
+    row += c.getDescription() + "</td><td>" + c.getField("Vendor") + "</td><td>"
+    row += c.getDNPString()
+    row += "</td></tr>"
+
+    html = html.replace('<!--TABLEROW-->', row + "<!--TABLEROW-->")
+
+# Write the formatted html to the file
+if sys.version_info[0] < 3:
+    f.write(html)
+else:
+    f.write(html.encode('utf-8'))
+f.close
+
+if not canOpenFile:
+    sys.exit(1)

eeschema/python_scripts/bom_txt_sorted_by_ref.py

@@ -0,0 +1,72 @@
+#
+# Example python script to generate a BOM from a KiCad generic netlist
+#
+
+"""
+    @package
+    Output: text file (tab-separated)
+    Grouped By: ungrouped, one component per line
+    Sorted By: Ref
+    Fields: Ref, Value, Part, Footprint, Description, Vendor, DNP
+
+    Command line:
+    python "pathToFile/bom_txt_sorted_by_ref.py" "%I" "%O.txt"
+"""
+
+from __future__ import print_function
+
+# Import the KiCad python helper module and the csv formatter
+import kicad_netlist_reader
+import kicad_utils
+import csv
+import sys
+
+
+# A helper function to filter/convert a string read in netlist
+#currently: do nothing
+def fromNetlistText( aText ):
+    return aText
+
+# Generate an instance of a generic netlist, and load the netlist tree from
+# the command line option. If the file doesn't exist, execution will stop
+net = kicad_netlist_reader.netlist(sys.argv[1])
+
+# Open a file to write to, if the file cannot be opened output to stdout
+# instead
+canOpenFile = True
+try:
+    f = kicad_utils.open_file_writeUTF8(sys.argv[2], 'w' )
+except IOError:
+    e = "Can't open output file for writing: " + sys.argv[2]
+    print(__file__, ":", e, sys.stderr)
+    f = sys.stdout
+    canOpenFile = False
+
+# Create a new csv writer object to use as the output formatter, although we
+# are created a tab delimited list instead!
+out = csv.writer(f, lineterminator='\n', delimiter='\t', quotechar="\"", quoting=csv.QUOTE_ALL)
+
+# override csv.writer's writerow() to support utf8 encoding:
+def writerow( acsvwriter, columns ):
+    utf8row = []
+    for col in columns:
+        txt=str(col);
+        utf8row.append( fromNetlistText(txt) )
+    acsvwriter.writerow( utf8row )
+
+components = net.getInterestingComponents( excludeBOM=True )
+
+# Output a field delimited header line
+writerow( out, ['Source:', net.getSource()] )
+writerow( out, ['Date:', net.getDate()] )
+writerow( out, ['Tool:', net.getTool()] )
+writerow( out, ['Component Count:', len(components)] )
+writerow( out, ['Ref', 'Value', 'Part', 'Footprint', 'Description', 'Vendor', 'DNP'] )
+
+# Output all of the component information
+for c in components:
+    writerow( out, [c.getRef(), c.getValue(), c.getLibName() + ":" + c.getPartName(),
+        c.getFootprint(), c.getDescription(), c.getField("Vendor"), c.getDNPString()])
+
+if not canOpenFile:
+    sys.exit(1)

eeschema/python_scripts/kicad_netlist_reader.py

@@ -0,0 +1,899 @@
+#
+# KiCad python module for interpreting generic netlists which can be used
+# to generate Bills of materials, etc.
+#
+# Remember these files use UTF8 encoding
+#
+# No string formatting is used on purpose as the only string formatting that
+# is current compatible with python 2.4+ to 3.0+ is the '%' method, and that
+# is due to be deprecated in 3.0+ soon
+#
+
+"""
+    @package
+    Helper module for interpreting generic netlist and build custom
+    bom generators or netlists in foreign format
+"""
+
+
+from __future__ import print_function
+import sys
+import xml.sax as sax
+import re
+import pdb
+import string
+
+#-----<Configure>----------------------------------------------------------------
+
+# excluded_fields is a list of regular expressions.  If any one matches a field
+# from either a component or a libpart, then that will not be included as a
+# column in the BOM.  Otherwise all columns from all used libparts and components
+# will be unionized and will appear.  Some fields are impossible to blacklist, such
+# as Ref, Value, Footprint, and Datasheet.  Additionally Qty and Item are supplied
+# unconditionally as columns, and may not be removed.
+excluded_fields = [
+    #'Price@1000'
+    ]
+
+
+# You may exclude components from the BOM by either:
+#
+# 1) adding a custom field named "Installed" to your components and filling it
+# with a value of "NU" (Normally Uninstalled).
+# See netlist.getInterestingComponents(), or
+#
+# 2) blacklisting it in any of the three following lists:
+
+
+# regular expressions which match component 'Reference' fields of components that
+# are to be excluded from the BOM.
+excluded_references = [
+    # 'TP[0-9]+'              # all test points
+    ]
+
+
+# regular expressions which match component 'Value' fields of components that
+# are to be excluded from the BOM.
+excluded_values = [
+    # 'MOUNTHOLE',
+    # 'SCOPETEST',
+    # 'MOUNT_HOLE',
+    # 'SOLDER_BRIDGE.*'
+    ]
+
+
+# regular expressions which match component 'Footprint' fields of components that
+# are to be excluded from the BOM.
+excluded_footprints = [
+    #'MOUNTHOLE'
+    ]
+
+#-----</Configure>---------------------------------------------------------------
+
+
+class xmlElement():
+    """xml element which can represent all nodes of the netlist tree.  It can be
+    used to easily generate various output formats by propagating format
+    requests to children recursively.
+    """
+    def __init__(self, name, parent=None):
+        self.name = name
+        self.attributes = {}
+        self.parent = parent
+        self.chars = ""
+        self.children = []
+
+    def __str__(self):
+        """String representation of this netlist element
+
+        """
+        return self.name + "[" + self.chars + "]" + " attr_count:" + str(len(self.attributes))
+
+    def formatXML(self, nestLevel=0, amChild=False):
+        """Return this element formatted as XML
+
+        Keywords:
+        nestLevel -- increases by one for each level of nesting.
+        amChild -- If set to True, the start of document is not returned.
+
+        """
+        s = ""
+
+        indent = ""
+        for i in range(nestLevel):
+            indent += "    "
+
+        if not amChild:
+            s = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
+
+        s += indent + "<" + self.name
+        for a in self.attributes:
+            s += " " + a + "=\"" + self.attributes[a] + "\""
+
+        if (len(self.chars) == 0) and (len(self.children) == 0):
+            s += "/>"
+        else:
+            s += ">" + self.chars
+
+        for c in self.children:
+            s += "\n"
+            s += c.formatXML(nestLevel+1, True)
+
+        if (len(self.children) > 0):
+            s += "\n" + indent
+
+        if (len(self.children) > 0) or (len(self.chars) > 0):
+            s += "</" + self.name + ">"
+
+        return s
+
+    def formatHTML(self, amChild=False):
+        """Return this element formatted as HTML
+
+        Keywords:
+        amChild -- If set to True, the start of document is not returned
+
+        """
+        s = ""
+
+        if not amChild:
+            s = """<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+                "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+                <html xmlns="http://www.w3.org/1999/xhtml">
+                <head>
+                <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+                <title></title>
+                </head>
+                <body>
+                <table>
+                """
+
+        s += "<tr><td><b>" + self.name + "</b><br>" + self.chars + "</td><td><ul>"
+        for a in self.attributes:
+            s += "<li>" + a + " = " + self.attributes[a] + "</li>"
+
+        s += "</ul></td></tr>\n"
+
+        for c in self.children:
+            s += c.formatHTML(True)
+
+        if not amChild:
+            s += """</table>
+                </body>
+                </html>"""
+
+        return s
+
+    def addAttribute(self, attr, value):
+        """Add an attribute to this element"""
+        if type(value) != str: value = value.encode('utf-8')
+        self.attributes[attr] = value
+
+    def setAttribute(self, attr, value):
+        """Set an attributes value - in fact does the same thing as add
+        attribute
+
+        """
+        self.attributes[attr] = value
+
+    def setChars(self, chars):
+        """Set the characters for this element"""
+        self.chars = chars
+
+    def addChars(self, chars):
+        """Add characters (textual value) to this element"""
+        self.chars += chars
+
+    def addChild(self, child):
+        """Add a child element to this element"""
+        self.children.append(child)
+        return self.children[len(self.children) - 1]
+
+    def getParent(self):
+        """Get the parent of this element (Could be None)"""
+        return self.parent
+
+    def getChild(self, name):
+        """Returns the first child element named 'name'
+
+        Keywords:
+        name -- The name of the child element to return"""
+        for child in self.children:
+            if child.name == name:
+                return child
+        return None
+
+    def getChildren(self, name=None):
+        if name:
+            # return _all_ children named "name"
+            ret = []
+            for child in self.children:
+                if child.name == name:
+                    ret.append(child)
+            return ret
+        else:
+            return self.children
+
+    def get(self, elemName, attribute="", attrmatch=""):
+        """Return the text data for either an attribute or an xmlElement
+        """
+        if (self.name == elemName):
+            if attribute != "":
+                try:
+                    if attrmatch != "":
+                        if self.attributes[attribute] == attrmatch:
+                            ret = self.chars
+                            if type(ret) != str: ret = ret.encode('utf-8')
+                            return ret
+                    else:
+                        ret = self.attributes[attribute]
+                        if type(ret) != str: ret = ret.encode('utf-8')
+                        return ret
+                except AttributeError:
+                    ret = ""
+                    if type(ret) != str: ret = ret.encode('utf-8')
+                    return ret
+            else:
+                ret = self.chars
+                if type(ret) != str: ret = ret.encode('utf-8')
+                return ret
+
+        for child in self.children:
+            ret = child.get(elemName, attribute, attrmatch)
+            if ret != "":
+                if type(ret) != str: ret = ret.encode('utf-8')
+                return ret
+
+        ret = ""
+        if type(ret) != str: ret = ret.encode('utf-8')
+        return ret
+
+
+
+class libpart():
+    """Class for a library part, aka 'libpart' in the xml netlist file.
+    (Components in eeschema are instantiated from library parts.)
+    This part class is implemented by wrapping an xmlElement with accessors.
+    This xmlElement instance is held in field 'element'.
+    """
+    def __init__(self, xml_element):
+        #
+        self.element = xml_element
+
+    #def __str__(self):
+        # simply print the xmlElement associated with this part
+        #return str(self.element)
+
+    def getLibName(self):
+        return self.element.get("libpart", "lib")
+
+    def getPartName(self):
+        return self.element.get("libpart", "part")
+
+    def getDescription(self):
+        return self.element.get("description")
+
+    def getField(self, name):
+        return self.element.get("field", "name", name)
+
+    def getFieldNames(self):
+        """Return a list of field names in play for this libpart.
+        """
+        fieldNames = []
+        fields = self.element.getChild('fields')
+        if fields:
+            for f in fields.getChildren():
+                fieldNames.append( f.get('field','name') )
+        return fieldNames
+
+    def getPinList(self):
+        """Return a list of pins in play for this libpart.
+        """
+        pinList = []
+        pins = self.element.getChild('pins')
+        if pins:
+            for f in pins.getChildren():
+                pinList.append( f )
+        return pinList
+
+    def getDatasheet(self):
+        return self.getField("Datasheet")
+
+    def getFootprint(self):
+        return self.getField("Footprint")
+
+    def getAliases(self):
+        """Return a list of aliases or None"""
+        aliases = self.element.getChild("aliases")
+        if aliases:
+            ret = []
+            children = aliases.getChildren()
+            # grab the text out of each child:
+            for child in children:
+                ret.append( child.get("alias") )
+            return ret
+        return None
+
+
+class comp():
+    """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):
+        self.element = xml_element
+        self.libpart = None
+
+        # Set to true when this component is included in a component group
+        self.grouped = False
+
+    def __eq__(self, other):
+        """ Equivalency operator, remember this can be easily overloaded
+            2 components are equivalent ( i.e. can be grouped
+            if they have same value and same footprint and are both set to be populated
+
+            Override the component equivalence operator must be done before
+            loading the netlist, otherwise all components will have the original
+            equivalency operator.
+
+            You have to define a comparison module (for instance named myEqu)
+            and add the line;
+                kicad_netlist_reader.comp.__eq__ = myEqu
+            in your bom generator script before calling the netliste reader by something like:
+                net = kicad_netlist_reader.netlist(sys.argv[1])
+        """
+        result = False
+        if self.getValue() == other.getValue():
+            if self.getFootprint() == other.getFootprint():
+                if self.getRef().rstrip(string.digits) == other.getRef().rstrip(string.digits):
+                    if self.getDNP() == other.getDNP():
+                        result = True
+        return result
+
+    def setLibPart(self, part):
+        self.libpart = part
+
+    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 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")
+
+    def getField(self, name, aLibraryToo = 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
+        aLibraryToo --  look in the libpart's fields for the same name if not found
+                        in component itself
+        """
+
+        field = self.element.get("field", "name", name)
+        if field == "" and aLibraryToo and self.libpart:
+            field = self.libpart.getField(name)
+        return field
+
+    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")
+
+    '''
+    Return true if the component has the DNP property set
+    '''
+    def getDNP(self):
+        for child in self.element.getChildren( "property"):
+            try:
+                if child.attributes['name'] == 'dnp':
+                    return True
+            except KeyError:
+                continue
+
+        return False
+
+    '''
+    Return 'DNP' if the component has the DNP property set
+    '''
+    def getDNPString(self):
+        if self.getDNP():
+            return 'DNP'
+
+        return ''
+
+    '''
+    Return true if the component has the exclude from BOM property set
+    '''
+    def getExcludeFromBOM(self):
+        for child in self.element.getChildren( "property"):
+            try:
+                if child.attributes['name'] == 'exclude_from_bom':
+                    return True
+            except KeyError:
+                continue
+
+        return False
+
+    '''
+    Return true if the component has the exclude from Board property set
+    '''
+    def getExcludeFromBoard(self):
+        for child in self.element.getChildren( "property"):
+            try:
+                if child.attributes['name'] == 'exclude_from_board':
+                    return True
+            except KeyError:
+                continue
+
+        return False
+
+    '''
+    return the footprint name. if empty and aLibraryToo = True, return the
+    footprint name from libary
+    '''
+    def getFootprint(self, aLibraryToo = True):
+        ret = self.element.get("footprint")
+
+        if ret == "" and aLibraryToo and self.libpart:
+            ret = self.libpart.getFootprint()
+
+        return ret
+
+    '''
+    return the datasheet name. if empty and aLibraryToo = True, return the
+    datasheet name from libary
+    '''
+    def getDatasheet(self, aLibraryToo = True):
+        ret = self.element.get("datasheet")
+        if ret == "" and aLibraryToo and self.libpart:
+            ret = self.libpart.getDatasheet()
+        return ret
+
+    def getTimestamp(self):
+        """
+        Kicad 5 uses tstamp keyword for time stamp (8 digits) as UUID
+        Kicad 6 uses tstamps keyword for UUID and a multi unit symbol has more than one UUID
+        (UUIDs are separated by spaces)
+        """
+        ret = self.element.get("tstamp")
+        if ret == "":
+            ret = self.element.get("tstamps")
+        return ret
+
+    def getDescription(self):
+        return self.element.get("libsource", "description")
+
+    '''
+    return the netname of the pin aPinNum in netlist aNetlist
+    if aSkipEmptyNet = True, net having only one pin will return a empty name
+    '''
+    def getPinNetname(self, aPinNum, aNetlist, aSkipEmptyNet):
+        ref = self.getRef()
+
+        for net in aNetlist.nets:
+            net_name = net.get( "net", "name" )
+
+            item_cnt = 1
+            netitems = net.children
+
+            for node in netitems:
+                curr_item_ref = node.get( "node", "ref" )
+
+                if curr_item_ref == ref:
+                    curr_pin = node.get( "node", "pin" )
+
+                    if aPinNum == curr_pin:
+                        if aSkipEmptyNet:   #ensure at least 2 pins are in net
+                            pin_count = 0
+
+                            for curr_node in netitems:
+                                pin_count += 1
+
+                                if pin_count > 1:
+                                    return net_name
+
+                            return ""
+                        else:
+                            return net_name
+
+        return "?"
+
+
+class netlist():
+    """ Kicad generic netlist class. Generally loaded from a kicad generic
+    netlist file. Includes several helper functions to ease BOM creating
+    scripts
+
+    """
+    def __init__(self, fname=""):
+        """Initialiser for the genericNetlist class
+
+        Keywords:
+        fname -- The name of the generic netlist file to open (Optional)
+
+        """
+        self.design = None
+        self.components = []
+        self.libparts = []
+        self.libraries = []
+        self.nets = []
+
+        # The entire tree is loaded into self.tree
+        self.tree = []
+
+        self._curr_element = None
+
+        # component blacklist regexs, made from excluded_* above.
+        self.excluded_references = []
+        self.excluded_values = []
+        self.excluded_footprints = []
+
+        if fname != "":
+            self.load(fname)
+
+    def addChars(self, content):
+        """Add characters to the current element"""
+        self._curr_element.addChars(content)
+
+    def addElement(self, name):
+        """Add a new kicad generic element to the list"""
+        if self._curr_element is None:
+            self.tree = xmlElement(name)
+            self._curr_element = self.tree
+        else:
+            self._curr_element = self._curr_element.addChild(
+                xmlElement(name, self._curr_element))
+
+        # If this element is a component, add it to the components list
+        if self._curr_element.name == "comp":
+            self.components.append(comp(self._curr_element))
+
+        # Assign the design element
+        if self._curr_element.name == "design":
+            self.design = self._curr_element
+
+        # If this element is a library part, add it to the parts list
+        if self._curr_element.name == "libpart":
+            self.libparts.append(libpart(self._curr_element))
+
+        # If this element is a net, add it to the nets list
+        if self._curr_element.name == "net":
+            self.nets.append(self._curr_element)
+
+        # If this element is a library, add it to the libraries list
+        if self._curr_element.name == "library":
+            self.libraries.append(self._curr_element)
+
+        return self._curr_element
+
+    def endDocument(self):
+        """Called when the netlist document has been fully parsed"""
+        # When the document is complete, the library parts must be linked to
+        # the components as they are separate in the tree so as not to
+        # duplicate library part information for every component
+        for c in self.components:
+            for p in self.libparts:
+                if p.getLibName() == c.getLibName():
+                    if p.getPartName() == c.getPartName():
+                        c.setLibPart(p)
+                        break
+                    else:
+                        aliases = p.getAliases()
+                        if aliases and self.aliasMatch( c.getPartName(), aliases ):
+                            c.setLibPart(p)
+                            break;
+
+            if not c.getLibPart():
+                print( 'missing libpart for ref:', c.getRef(), c.getPartName(), c.getLibName() )
+
+
+    def aliasMatch(self, partName, aliasList):
+        for alias in aliasList:
+            if partName == alias:
+                return True
+        return False
+
+    def endElement(self):
+        """End the current element and switch to its parent"""
+        self._curr_element = self._curr_element.getParent()
+
+    def getDate(self):
+        """Return the date + time string generated by the tree creation tool"""
+        return self.design.get("date")
+
+    def getSource(self):
+        """Return the source string for the design"""
+        return self.design.get("source")
+
+    def getTool(self):
+        """Return the tool string which was used to create the netlist tree"""
+        return self.design.get("tool")
+
+    def getNets(self):
+        """Return the nets """
+        return self.nets
+
+    def gatherComponentFieldUnion(self, components=None):
+        """Gather the complete 'set' of unique component fields, fields found in any component.
+        """
+        if not components:
+            components=self.components
+
+        s = set()
+        for c in components:
+            s.update( c.getFieldNames() )
+
+        # omit anything matching any regex in excluded_fields
+        ret = set()
+        for field in s:
+            exclude = False
+            for rex in excluded_fields:
+                if re.match( rex, field ):
+                    exclude = True
+                    break
+            if not exclude:
+                ret.add(field)
+
+        return ret       # this is a python 'set'
+
+    def gatherLibPartFieldUnion(self):
+        """Gather the complete 'set' of part fields, fields found in any part.
+        """
+        s = set()
+        for p in self.libparts:
+            s.update( p.getFieldNames() )
+
+        # omit anything matching any regex in excluded_fields
+        ret = set()
+        for field in s:
+            exclude = False
+            for rex in excluded_fields:
+                if re.match( rex, field ):
+                    exclude = True
+                    break
+            if not exclude:
+                ret.add(field)
+
+        return ret       # this is a python 'set'
+
+    def getInterestingComponents(self, excludeBOM=False, excludeBoard=False, DNP=False):
+        """Return a subset of all components, those that should show up in the BOM.
+        Omit those that should not, by consulting the blacklists:
+        excluded_values, excluded_refs, and excluded_footprints, which hold one
+        or more regular expressions.  If any of the regular expressions match
+        the corresponding field's value in a component, then the component is excluded.
+        """
+
+        # pre-compile all the regex expressions:
+        del self.excluded_references[:]
+        del self.excluded_values[:]
+        del self.excluded_footprints[:]
+
+        for rex in excluded_references:
+            self.excluded_references.append( re.compile( rex ) )
+
+        for rex in excluded_values:
+            self.excluded_values.append( re.compile( rex ) )
+
+        for rex in excluded_footprints:
+            self.excluded_footprints.append( re.compile( rex ) )
+
+        # the subset of components to return, considered as "interesting".
+        ret = []
+
+        # run each component thru a series of tests, if it passes all, then add it
+        # to the interesting list 'ret'.
+        for c in self.components:
+            exclude = False
+            if not exclude:
+                for refs in self.excluded_references:
+                    if refs.match(c.getRef()):
+                        exclude = True
+                        break
+            if not exclude:
+                for vals in self.excluded_values:
+                    if vals.match(c.getValue()):
+                        exclude = True
+                        break
+            if not exclude:
+                for mods in self.excluded_footprints:
+                    if mods.match(c.getFootprint()):
+                        exclude = True
+                        break
+
+            if excludeBOM and c.getExcludeFromBOM():
+                exclude = True
+
+            if excludeBoard and c.getExcludeFromBoard():
+                exclude = True
+
+            if DNP and c.getDNP():
+                exclude = True
+
+            if not exclude:
+                ret.append(c)
+
+        # The key to sort the components in the BOM
+        # This sorts using a natural sorting order (e.g. 100 after 99), and if it wasn't used
+        # the normal sort would place 100 before 99 since it only would look at the first digit.
+        def sortKey( str ):
+            return [ int(t) if t.isdigit() else t.lower()
+                    for t in re.split( '(\d+)', str ) ]
+
+        ret.sort(key=lambda g: sortKey(g.getRef()))
+
+        return ret
+
+
+    def groupComponents(self, components = None):
+        """Return a list of component lists. Components are grouped together
+        when the value, library and part identifiers match.
+
+        Keywords:
+        components -- is a list of components, typically an interesting subset
+        of all components, or None.  If None, then all components are looked at.
+        """
+        if not components:
+            components = self.components
+
+        groups = []
+
+        # Make sure to start off will all components ungrouped to begin with
+        for c in components:
+            c.grouped = False
+
+        # Group components based on the value, library and part identifiers
+        for c in components:
+            if c.grouped == False:
+                c.grouped = True
+                newgroup = []
+                newgroup.append(c)
+
+                # Check every other ungrouped component against this component
+                # and add to the group as necessary
+                for ci in components:
+                    if ci.grouped == False and ci == c:
+                        newgroup.append(ci)
+                        ci.grouped = True
+
+                # Add the new component group to the groups list
+                groups.append(newgroup)
+
+        # The key to sort the components in the BOM
+        # This sorts using a natural sorting order (e.g. 100 after 99), and if it wasn't used
+        # the normal sort would place 100 before 99 since it only would look at the first digit.
+        def sortKey( str ):
+            return [ int(t) if t.isdigit() else t.lower()
+                    for t in re.split( '(\d+)', str ) ]
+
+        for g in groups:
+            #g = sorted(g, key=lambda g: sortKey(g.getRef()))
+            g.sort(key=lambda g: sortKey(g.getRef()))
+
+        # Finally, sort the groups to order the references alphabetically
+        groups.sort(key=lambda group: sortKey(group[0].getRef()))
+
+        return groups
+
+    def getGroupField(self, group, field):
+        """Return the whatever is known about the given field by consulting each
+        component in the group.  If any of them know something about the property/field,
+        then return that first non-blank value.
+        """
+        for c in group:
+            ret = c.getField(field, False)
+            if ret != '':
+                return ret
+
+        libpart = group[0].getLibPart()
+        if not libpart:
+            return ''
+
+        return libpart.getField(field)
+
+    def getGroupFootprint(self, group):
+        """Return the whatever is known about the Footprint by consulting each
+        component in the group.  If any of them know something about the Footprint,
+        then return that first non-blank value.
+        """
+        for c in group:
+            ret = c.getFootprint()
+            if ret != "":
+                return ret
+        return group[0].getLibPart().getFootprint()
+
+    def getGroupDatasheet(self, group):
+        """Return the whatever is known about the Datasheet by consulting each
+        component in the group.  If any of them know something about the Datasheet,
+        then return that first non-blank value.
+        """
+        for c in group:
+            ret = c.getDatasheet()
+            if ret != "":
+                return ret
+
+        if len(group) > 0:
+            return group[0].getLibPart().getDatasheet()
+        else:
+            print("NULL!")
+        return ''
+
+    def formatXML(self):
+        """Return the whole netlist formatted in XML"""
+        return self.tree.formatXML()
+
+    def formatHTML(self):
+        """Return the whole netlist formatted in HTML"""
+        return self.tree.formatHTML()
+
+    def load(self, fname):
+        """Load a kicad generic netlist
+
+        Keywords:
+        fname -- The name of the generic netlist file to open
+
+        """
+        try:
+            self._reader = sax.make_parser()
+            self._reader.setContentHandler(_gNetReader(self))
+            self._reader.parse(fname)
+        except IOError as e:
+            print( __file__, ":", e, file=sys.stderr )
+            sys.exit(-1)
+
+
+
+class _gNetReader(sax.handler.ContentHandler):
+    """SAX kicad generic netlist content handler - passes most of the work back
+    to the 'netlist' class which builds a complete tree in RAM for the design
+
+    """
+    def __init__(self, aParent):
+        self.parent = aParent
+
+    def startElement(self, name, attrs):
+        """Start of a new XML element event"""
+        element = self.parent.addElement(name)
+
+        for name in attrs.getNames():
+            element.addAttribute(name, attrs.getValue(name))
+
+    def endElement(self, name):
+        self.parent.endElement()
+
+    def characters(self, content):
+        # Ignore erroneous white space - ignoreableWhitespace does not get rid
+        # of the need for this!
+        if not content.isspace():
+            self.parent.addChars(content)
+
+    def endDocument(self):
+        """End of the XML document event"""
+        self.parent.endDocument()

eeschema/python_scripts/kicad_utils.py

@@ -0,0 +1,27 @@
+#
+# KiCad python module for some helper functions
+#
+
+import os
+
+def open_file_write(path, mode):
+    ''' Open "path" for writing, creating any parent directories as needed.
+    '''
+    dir_path = os.path.dirname(path)
+
+    if not os.path.isdir(dir_path):
+        os.makedirs(dir_path)
+
+    return open(path, mode)
+
+def open_file_writeUTF8(path, mode):
+    '''
+    Open "path" for writing, creating any parent directories as needed.
+    Use it only for text files. Force text encoding in UTF-8.
+    '''
+    dir_path = os.path.dirname(path)
+
+    if not os.path.isdir(dir_path):
+        os.makedirs(dir_path)
+
+    return open(path, mode, encoding='utf-8')

eeschema/python_scripts/netlist_form_OrcadPcb2.py

@@ -0,0 +1,115 @@
+#
+# Example python script to generate a BOM from a KiCad generic netlist
+#
+
+"""
+    @package
+    Output: old OrcadPcb2 netlist format
+    Sorted By: Ref
+
+    Command line:
+    python "pathToFile/netlist_form_OrcadPcb2.py" "%I" "%O.net"
+"""
+
+from __future__ import print_function
+
+# Import the KiCad python helper module
+import kicad_netlist_reader
+import sys
+
+# A helper function to convert a UTF8/Unicode/locale string read in netlist
+# for python2 or python3 (Windows/unix)
+def fromNetlistText( aText ):
+    if sys.platform.startswith('win32'):
+        try:
+            return aText.encode('utf-8').decode('cp1252')
+        except UnicodeDecodeError:
+            return aText
+    else:
+        return aText
+
+# Generate an instance of a generic netlist, and load the netlist tree from
+# the command line option. If the file doesn't exist, execution will stop
+netlist = kicad_netlist_reader.netlist(sys.argv[1])
+
+# Open a file to write to, if the file cannot be opened output to stdout
+# instead
+canOpenFile = True
+try:
+    f = open(sys.argv[2], 'wb')
+except IOError:
+    e = "Can't open output file for writing: " + sys.argv[2]
+    print(__file__, ":", e, sys.stderr)
+    f = sys.stdout
+    canOpenFile = False
+
+components = netlist.getInterestingComponents( excludeBoard=True )
+
+row =""
+
+''' Netlist header:
+( { EESchema Netlist Version 1.1  02/09/2021 11:10:00
+Eeschema (5.99.0-12178-ge03257b55f-dirty)}
+'''
+''' Generate line ( { EESchema Netlist Version 1.1 <time> '''
+row += '( { EESchema Netlist Version 1.1 ' + netlist.getDate() + '\n'
+''' Generate line Eeschema <eeschema version> '''
+row += 'Eeschema ' + netlist.getTool() + ' }\n\n'
+
+
+'''
+    This template read each component and creates lines:
+     ( 3EBF7DBD $noname U1 74LS125
+      ... pin list ...
+      )
+    and calls "create_pin_list" template to build the pin list
+'''
+
+for c in components:
+    fp_name = c.getFootprint( False )
+
+    if fp_name == "":
+        fp_name = "$noname"
+
+    row += "( " + c.getTimestamp() + ' ' + fp_name
+    row += ' ' + c.getRef()
+    row += ' ' + c.getValue()
+    row += '\n'
+
+    '''
+    generate pin list
+    The pin list from library description is something like
+          <pins>
+            <pin num="1" type="passive"/>
+            <pin num="2" type="passive"/>
+          </pins>
+    Output pin list is ( <pin num> <net name> )
+    something like
+            ( 1 VCC )
+            ( 2 GND )
+    for not connected pins:
+            ( 3 ? )
+    '''
+    lib = c.getLibPart()
+    pinlist = lib.getPinList()
+
+    for pin in pinlist:
+        pin_num = pin.get('pin','num')
+        row += "   ( " + pin_num + " "
+        netname = c.getPinNetname( pin_num, netlist, True )
+
+        if netname == "":
+            netname = "?"
+
+        row += netname
+        row += " )\n"
+
+    row += ')\n'
+
+row += '\n)\n'
+
+f.write(row.encode('utf-8'))
+f.close()
+
+if not canOpenFile:
+    sys.exit(1)

eeschema/python_scripts/netlist_form_cadstar.py

@@ -0,0 +1,124 @@
+#
+# Example python script to generate a BOM from a KiCad generic netlist
+#
+
+"""
+    @package
+    Output: Cadstar RINF netlist
+    Sorted By: Ref
+
+    Command line:
+    python "pathToFile/netlist_form_cadstar.py" "%I" "%O.frp"
+"""
+
+from __future__ import print_function
+
+# Import the KiCad python helper module
+import kicad_netlist_reader
+import sys
+
+# A helper function to convert a UTF8/Unicode/locale string read in netlist
+# for python2 or python3 (Windows/unix)
+def fromNetlistText( aText ):
+    if sys.platform.startswith('win32'):
+        try:
+            return aText.encode('utf-8').decode('cp1252')
+        except UnicodeDecodeError:
+            return aText
+    else:
+        return aText
+
+# Generate an instance of a generic netlist, and load the netlist tree from
+# the command line option. If the file doesn't exist, execution will stop
+netlist = kicad_netlist_reader.netlist(sys.argv[1])
+
+# Open a file to write to, if the file cannot be opened output to stdout
+# instead
+canOpenFile = True
+try:
+    f = open(sys.argv[2], 'wb')
+except IOError:
+    e = "Can't open output file for writing: " + sys.argv[2]
+    print(__file__, ":", e, sys.stderr)
+    f = sys.stdout
+    canOpenFile = False
+
+components = netlist.getInterestingComponents( excludeBoard=True )
+
+row =""
+
+''' Netlist header '''
+row += ".HEA" + '\n'
+''' Generate line .TIM <time> '''
+row += '.TIM ' + netlist.getDate() + '\n'
+''' Generate line .APP <eeschema version> '''
+row += '.APP ' + netlist.getTool() + '\n'
+row += '.TYP FULL' + '\n\n'
+
+
+''' Generate list of component
+ for each component  create lines like
+    .ADD_COM U3 "74LS541"   (when no footprint name specified)
+    .ADD_COM JP1 "CONN_8X2" "pin_array_8x2"   (with a specified footprint name)
+'''
+
+for c in components:
+    c.getExcludeFromBOM
+    row += ".ADD_COM " + " " + c.getRef() + " \"" + c.getValue() + "\""
+
+    fp_name = c.getFootprint( False )
+
+    if fp_name != "":
+        row += " \"" + fp_name + "\""
+
+    row += '\n'
+
+'''
+generate for each net create lines like
+.ADD_TER U3.9 "/PC-RST"
+.TER     U3.8
+         BUS1.2
+.ADD_TER BUS1.14 "/PC-IOR"
+.TER     U3.7
+'''
+nets = netlist.getNets()
+
+row += '\n'
+
+for net in nets:
+    # count the number of pads in net. nets with only one pad are skipped
+    netitems = net.children
+    pad_count = 0
+
+    for node in netitems:
+        pad_count += 1
+
+    item_cnt = 1
+    netitems = net.children
+
+    if pad_count > 1:
+        for node in netitems:
+
+            if item_cnt == 1:
+                row += ".ADD_TER " + net.get( "node", "ref" ) + '.' + net.get( "node", "pin" )
+                row += " \"" + net.get( "net", "name" ) + '\"\n'
+
+            if item_cnt == 2:
+                row += ".TER     "
+
+            if item_cnt > 2:
+                row += "         "
+
+            if item_cnt > 1:
+                    row += node.get('node','ref') + '.' + node.get('node','pin') + '\n'
+
+            item_cnt += 1
+
+
+row += '\n.END\n'
+
+f.write(row.encode('utf-8'))
+f.close()
+
+if not canOpenFile:
+    sys.exit(1)

eeschema/python_scripts/netlist_form_pads-pcb-asc.py

@@ -0,0 +1,103 @@
+#
+# Example python script to generate a BOM from a KiCad generic netlist
+#
+
+"""
+    @package
+    Output: PADS  format netlist
+    Sorted By: Ref
+
+    Command line:
+    python "pathToFile/netlist_form_pads-pcb-asc.py" "%I" "%O.net"
+"""
+
+from __future__ import print_function
+
+# Import the KiCad python helper module
+import kicad_netlist_reader
+import sys
+
+# A helper function to convert a UTF8/Unicode/locale string read in netlist
+# for python2 or python3 (Windows/unix)
+def fromNetlistText( aText ):
+    if sys.platform.startswith('win32'):
+        try:
+            return aText.encode('utf-8').decode('cp1252')
+        except UnicodeDecodeError:
+            return aText
+    else:
+        return aText
+
+# Generate an instance of a generic netlist, and load the netlist tree from
+# the command line option. If the file doesn't exist, execution will stop
+netlist = kicad_netlist_reader.netlist(sys.argv[1])
+
+# Open a file to write to, if the file cannot be opened output to stdout
+# instead
+canOpenFile = True
+try:
+    f = open(sys.argv[2], 'wb')
+except IOError:
+    e = "Can't open output file for writing: " + sys.argv[2]
+    print(__file__, ":", e, sys.stderr)
+    f = sys.stdout
+    canOpenFile = False
+
+components = netlist.getInterestingComponents( excludeBoard=True )
+
+row =""
+
+''' Netlist header '''
+row += "!PADS-POWERPCB-V2.0-MILS!" + '\n'
+row += '*PART*' + '\n'
+
+
+''' Generate list of component
+ for each component  create lines like
+ C1 Capacitor_THT:CP_Axial_L18.0mm_D6.5mm_P25.00mm_Horizontal
+ C2 Capacitor_THT:CP_Axial_L18.0mm_D6.5mm_P25.00mm_Horizontal
+'''
+
+for c in components:
+    row += " " + c.getRef()
+
+    fp_name = c.getFootprint( False )
+
+    if fp_name != "":
+        row += " " + fp_name
+
+    row += '\n'
+
+'''
+generate for each net create lines like
+*SIGNAL* /CLOCK-RB6
+ P2.27
+ P3.39
+'''
+nets = netlist.getNets()
+
+row += '\n*NET*' + '\n'
+
+for net in nets:
+    # count the number of pads in net. nets with only one pad are skipped
+    netitems = net.children
+    pad_count = 0
+
+    for node in netitems:
+        pad_count += 1
+
+    netitems = net.children
+
+    if pad_count > 1:
+        row += "*SIGNAL* " + net.get( "net", "name" ) + '\n'
+
+        for node in netitems:
+            row += node.get('node','ref') + '.' + node.get('node','pin') + '\n'
+
+row += '*END*\n'
+
+f.write(row.encode('utf-8'))
+f.close()
+
+if not canOpenFile:
+    sys.exit(1)

eeschema/python_scripts/round_robin.py

@@ -0,0 +1,33 @@
+#
+# Example python script to generate an equivalent XML document from XML input
+#
+# Example: Round robin, XML to XML conversion
+#
+
+from __future__ import print_function
+
+# Import the KiCad python helper module and the csv formatter
+import kicad_netlist_reader
+import sys
+import pdb
+
+
+# Generate an instance of a generic netlist, and load the netlist tree from
+# the command line option. If the file doesn't exist, execution will stop
+net = kicad_netlist_reader.netlist(sys.argv[1])
+
+# Open a file to write to, if the file cannot be opened output to stdout
+# instead
+canOpenFile = True
+try:
+    f = open(sys.argv[2], 'w')
+except IOError:
+    e = "Can't open output file for writing: " + sys.argv[2]
+    print( __file__, ":", e, sys.stderr)
+    f = sys.stdout
+    canOpenFile = False
+
+print(net.formatXML(), file=f)
+
+if not canOpenFile:
+    sys.exit(1)

eeschema/python_scripts/round_value_robin.py

@@ -0,0 +1,79 @@
+#
+# Example python script to generate an equivalent XML document from XML input
+#
+# Example: Round value robin, XML to XML conversion with partial value monging
+#
+
+from __future__ import print_function
+
+# Import the KiCad python helper module and the csv formatter
+import kicad_netlist_reader
+import sys
+
+def checkvalue(self):
+    """Check values, and replace with preferred/consistent values"""
+    ref = self.getRef()
+    r = ref.split("R")
+    c = ref.split("C")
+    v = self.getValue()
+
+    # Common to all values - convert decimation if necessary
+    dec = v.split(",")
+    if (len(dec) == 2):
+        newval = dec[0] + "." + dec[1]
+        self.setValue(newval)
+        v = self.getValue()
+
+    if len(r) == 2 and r[1].isdigit():
+        # This is a resistor - make values consistent
+        # If the value is a pure value, add R to the end of the value
+        if v.isdigit():
+            i = int(v)
+            if (i > 1000000):
+                i = i / 1000000
+                v = str(i) + "M"
+            if (i > 1000):
+                i = i / 1000
+                v = str(i) + "K"
+            else:
+                v = str(i) + "R"
+
+            self.setValue(v)
+        else:
+            # Get the multiplier character
+            multiplier = v[len(v) - 1]
+            v = v.strip(multiplier)
+            v = v.split(".")
+            if (len(v) == 2):
+                newval = v[0] + multiplier + v[1]
+                self.setValue(newval)
+                v = self.getValue()
+
+
+
+# Give components a new method for checking the values (this could easily be a
+# Company Part Number generator method instead)
+kicad_netlist_reader.comp.checkvalue = checkvalue
+
+# Generate an instance of a generic netlist, and load the netlist tree from
+# the command line option. If the file doesn't exist, execution will stop
+net = kicad_netlist_reader.netlist(sys.argv[1])
+
+# Open a file to write to, if the file cannot be opened output to stdout
+# instead
+canOpenFile = True
+try:
+    f = open(sys.argv[2], 'w')
+except IOError:
+    e = "Can't open output file for writing: " + sys.argv[2]
+    print(__file__, ":", e, file=sys.stderr)
+    f = sys.stdout
+    canOpenFile = False
+
+for c in net.components:
+    c.checkvalue()
+
+print(net.formatXML(), file=f)
+
+if not canOpenFile:
+    sys.exit(1)