Rename gerbonara/gerber package to just gerbonara

1 files changed, 0 insertions, 482 deletions

diff --git a/gerbonara/gerber/layers.py b/gerbonara/gerber/layers.py
deleted file mode 100644
index fcaf0fc..0000000
--- a/gerbonara/gerber/layers.py
+++ /dev/null
@@ -1,482 +0,0 @@
-#! /usr/bin/env python

-# -*- coding: utf-8 -*-

-#

-# Copyright 2014 Hamilton Kibbe <ham@hamiltonkib.be>

-# Copyright 2021 Jan Götte <code@jaseg.de>

-#

-# Licensed under the Apache License, Version 2.0 (the "License");

-# you may not use this file except in compliance with the License.

-# You may obtain a copy of the License at

-#

-#     http://www.apache.org/licenses/LICENSE-2.0

-#

-# Unless required by applicable law or agreed to in writing, software

-# distributed under the License is distributed on an "AS IS" BASIS,

-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

-# See the License for the specific language governing permissions and

-# limitations under the License.

-

-import os

-import re

-import warnings

-from collections import namedtuple

-from pathlib import Path

-

-from .excellon import ExcellonFile

-from .rs274x import GerberFile

-from .ipc356 import Netlist

-from .cam import FileSettings

-from .layer_rules import MATCH_RULES

-

-

-STANDARD_LAYERS = [

-        'mechanical outline',

-        'top copper',

-        'top mask',

-        'top silk',

-        'top paste',

-        'bottom copper',

-        'bottom mask',

-        'bottom silk',

-        'bottom paste',

-        ]

-

-

-def match_files(filenames):

-    matches = {}

-    for generator, rules in MATCH_RULES.items():

-        gen = {}

-        matches[generator] = gen

-        for layer, regex in rules.items():

-            for fn in filenames:

-                if (m := re.fullmatch(regex, fn.name, re.IGNORECASE)):

-                    if layer == 'inner copper':

-                        target = 'inner_' + ''.join(e or '' for e in m.groups()) + ' copper'

-                    else:

-                        target = layer

-                    gen[target] = gen.get(target, []) + [fn]

-    return matches

-

-def best_match(filenames):

-    matches = match_files(filenames)

-    matches = sorted(matches.items(), key=lambda pair: len(pair[1]))

-    generator, files = matches[-1]

-    return generator, files

-

-def identify_file(data):

-    if 'M48' in data:

-        return 'excellon'

-

-    if 'G90' in data and ';LEADER:' in data: # yet another allegro special case

-        return 'excellon'

-

-    if 'FSLAX' in data or 'FSTAX' in data:

-        return 'gerber'

-

-    if 'UNITS CUST' in data:

-        return 'ipc356'

-

-    return None

-

-def common_prefix(l):

-    out = []

-    for cand in l:

-        score = lambda n: sum(elem.startswith(cand[:n]) for elem in l)

-        baseline = score(1)

-        if len(l) - baseline > 5:

-            continue

-        for n in range(2, len(cand)):

-            if len(l) - score(n) > 5:

-                break

-        out.append(cand[:n-1])

- 

-    if not out:

-        return ''

- 

-    return sorted(out, key=len)[-1]

-

-def autoguess(filenames):

-    prefix = common_prefix([f.name for f in filenames])

-

-    matches = {}

-    for f in filenames:

-        name = layername_autoguesser(f.name[len(prefix):] if f.name.startswith(prefix) else f.name)

-        if name != 'unknown unknown':

-            matches[name] = matches.get(name, []) + [f]

-

-    inner_layers = [ m for m in matches if 'inner' in m ]

-    if len(inner_layers) >= 4 and 'copper top' not in matches and 'copper bottom' not in matches:

-        if 'inner_01 copper' in matches:

-            warnings.warn('Could not find copper layer. Re-assigning outermost inner layers to top/bottom copper.')

-            matches['top copper'] = matches.pop('inner_01 copper')

-            last_inner = sorted(inner_layers, key=lambda name: int(name.partition(' ')[0].partition('_')[2]))[-1]

-            matches['bottom copper'] = matches.pop(last_inner)

-

-    return matches

-

-def layername_autoguesser(fn):

-    fn, _, ext = fn.lower().rpartition('.')

-    

-    if ext in ('log', 'err'):

-        return 'unknown unknown'

-

-    side, use = 'unknown', 'unknown'

-    if re.search('top|front|pri?m?(ary)?', fn):

-        side = 'top'

-        use = 'copper'

-    if re.search('bot(tom)?|back|sec(ondary)?', fn):

-        side = 'bottom'

-        use = 'copper'

-

-    if re.search('silks?(creen)?', fn):

-        use = 'silk'

-

-    elif re.search('(solder)?paste', fn):

-        use = 'paste'

-

-    elif re.search('(solder)?mask', fn):

-        use = 'mask'

-

-    elif re.search('drill|rout?e?', fn):

-        use = 'drill'

-        side = 'unknown'

-

-        if re.search(r'np(th)?|(non|un)\W*plated|(non|un)\Wgalv', fn):

-            side = 'nonplated'

-

-        elif re.search('pth|plated|galv', fn):

-            side = 'plated'

-

-    elif (m := re.search(r'(la?y?e?r?|in(ner)?)\W*(?P<num>[0-9]+)', fn)):

-        use = 'copper'

-        side = f'inner_{int(m["num"]):02d}'

-

-    elif re.search('film', fn):

-        use = 'copper'

-

-    elif re.search('out(line)?', fn):

-        use = 'outline'

-        side = 'mechanical'

-

-    elif 'ipc' in fn and '356' in fn:

-        use = 'netlist'

-        side = 'other'

-

-    elif 'netlist' in fn:

-        use = 'netlist'

-        side = 'other'

-

-    return f'{side} {use}'

-

-class LayerStack:

-    @classmethod

-    def from_directory(kls, directory, board_name=None, verbose=False):

-

-        directory = Path(directory)

-        if not directory.is_dir():

-            raise FileNotFoundError(f'{directory} is not a directory')

-

-        files = [ path for path in directory.glob('**/*') if path.is_file() ]

-        generator, filemap = best_match(files)

-        print('detected generator', generator)

-

-        if len(filemap) < 6:

-            warnings.warn('Ambiguous gerber filenames. Trying last-resort autoguesser.')

-            generator = None

-            filemap = autoguess(files)

-            if len(filemap) < 6:

-                raise ValueError('Cannot figure out gerber file mapping. Partial map is: ', filemap)

-

-        if generator == 'geda':

-            # geda is written by geniuses who waste no bytes of unnecessary output so it doesn't actually include the

-            # number format in files that use imperial units. Unfortunately it also doesn't include any hints that the

-            # file was generated by geda, so we have to guess by context whether this is just geda being geda or

-            # potential user error.

-            excellon_settings = FileSettings(number_format=(2, 4))

-

-        elif generator == 'allegro':

-            # Allegro puts information that is absolutely vital for parsing its excellon files... into another file,

-            # next to the actual excellon file. Despite pretty much everyone else having figured out a way to put that

-            # info into the excellon file itself, even if only as a comment.

-            if 'excellon params' in filemap:

-                excellon_settings = parse_allegro_ncparam(filemap['excellon params'][0].read_text())

-                del filemap['excellon params']

-            # Ignore if we can't find the param file -- maybe the user has convinced Allegro to actually put this

-            # information into a comment, or maybe they have made Allegro just use decimal points like XNC does.

-

-            filemap = autoguess([ f for files in filemap for f in files ])

-            if len(filemap < 6):

-                raise SystemError('Cannot figure out gerber file mapping')

-            # FIXME use layer metadata from comments and ipc file if available

-

-        elif generator == 'altium':

-            excellon_settings = None

-

-            if 'mechanical outline' in filemap:

-                # Use lowest-numbered mechanical layer as outline, ignore others.

-                mechs = {}

-                for layer in filemap['mechanical outline']:

-                    if layer.name.lower().endswith('gko'):

-                        filemap['mechanical outline'] = [layer]

-                        break

-

-                    if (m := re.match(r'.*\.gm([0-9]+)', layer.name, re.IGNORECASE)):

-                        mechs[int(m[1])] = layer

-                    else:

-                        break

-                else:

-                    filemap['mechanical outline'] = [sorted(mechs.items(), key=lambda x: x[0])[0][1]]

-

-        else:

-            excellon_settings = None

-

-        import pprint

-        pprint.pprint(filemap)

-

-        ambiguous = [ key for key, value in filemap.items() if len(value) > 1 and not 'drill' in key ]

-        if ambiguous:

-            raise SystemError(f'Ambiguous layer names for {", ".join(ambiguous)}')

-

-        drill_layers = []

-        netlist = None

-        layers = {} # { tuple(key.split()): None for key in STANDARD_LAYERS }

-        for key, paths in filemap.items():

-            if len(paths) > 1 and not 'drill' in key:

-                raise ValueError(f'Multiple matching files found for {key} layer: {", ".join(value)}')

-

-            for path in paths:

-                id_result = identify_file(path.read_text())

-                print('id_result', id_result)

-

-                if 'netlist' in key:

-                    layer = Netlist.open(path)

-

-                elif ('outline' in key or 'drill' in key) and id_result != 'gerber':

-                    if id_result is None:

-                        # Since e.g. altium uses ".txt" as the extension for its drill files, we have to assume the

-                        # current file might not be a drill file after all.

-                        continue

-

-                    if 'nonplated' in key:

-                        plated = False

-                    elif 'plated' in key:

-                        plated = True

-                    else:

-                        plated = None

-                    layer = ExcellonFile.open(path, plated=plated, settings=excellon_settings)

-                else:

-

-                    layer = GerberFile.open(path)

-

-                if key == 'mechanical outline':

-                    layers['mechanical', 'outline'] = layer

-

-                elif 'drill' in key:

-                    drill_layers.append(layer)

-

-                elif 'netlist' in key:

-                    if netlist:

-                        warnings.warn(f'Found multiple netlist files, using only first one. Have: {netlist.original_path.name}, got {path.name}')

-                    else:

-                        netlist = layer

-

-                else:

-                    side, _, use = key.partition(' ')

-                    layers[(side, use)] = layer

-

-                hints = set(layer.generator_hints) | { generator }

-                if len(hints) > 1:

-                    warnings.warn('File identification returned ambiguous results. Please raise an issue on the gerbonara '

-                            'tracker and if possible please provide these input files for reference.')

-

-        board_name = common_prefix([l.original_path.name for l in layers.values() if l is not None])

-        board_name = re.sub(r'^\W+', '', board_name)

-        board_name = re.sub(r'\W+$', '', board_name)

-        return kls(layers, drill_layers, netlist, board_name=board_name)

-

-    def __init__(self, graphic_layers, drill_layers, netlist=None, board_name=None):

-        self.graphic_layers = graphic_layers

-        self.drill_layers = drill_layers

-        self.board_name = board_name

-        self.netlist = netlist

-

-    def __str__(self):

-        names = [ f'{side} {use}' for side, use in self.graphic_layers ]

-        return f'<LayerStack {self.board_name} [{", ".join(names)}] and {len(self.drill_layers)} drill layers>'

-

-    def __repr__(self):

-        return str(self)

-

-    def merge_drill_layers(self):

-        target = ExcellonFile(comments='Drill files merged by gerbonara')

-

-        for layer in self.drill_layers:

-            if isinstance(layer, GerberFile):

-                layer = layer.to_excellon()

-

-            target.merge(layer)

-

-        self.drill_layers = [target]

-

-    def normalize_drill_layers(self):

-        # TODO: maybe also separate into drill and route?

-        drill_pth, drill_npth, drill_aux = [], [], []

-

-        for layer in self.drill_layers:

-            if isinstance(layer, GerberFile):

-                layer = layer.to_excellon()

-

-            if layer.is_plated:

-                drill_pth.append(layer)

-            elif layer.is_nonplated:

-                drill_pth.append(layer)

-            else:

-                drill_aux.append(layer)

-        

-        pth_out, *rest = drill_pth or [ExcellonFile()]

-        for layer in rest:

-            pth_out.merge(layer)

-

-        npth_out, *rest = drill_npth or [ExcellonFile()]

-        for layer in rest:

-            npth_out.merge(layer)

-

-        unknown_out = ExcellonFile()

-        for layer in drill_aux:

-            for obj in layer.objects:

-                if obj.plated is None:

-                    unknown_out.append(obj)

-                elif obj.plated:

-                    pth_out.append(obj)

-                else:

-                    npth_out.append(obj)

-

-        self.drill_pth, self.drill_npth = pth_out, npth_out

-        self.drill_unknown = unknown_out if unknown_out else None

-        self._drill_layers = []

-

-    @property

-    def drill_layers(self):

-        if self._drill_layers:

-            return self._drill_layers

-        if self.drill_pth or self.drill_npth or self.drill_unknown:

-            return [self.drill_pth, self.drill_npth, self.drill_unknown]

-        return []

-

-    @drill_layers.setter

-    def drill_layers(self, value):

-        self._drill_layers = value

-        self.drill_pth = self.drill_npth = self.drill_unknown = None

-

-    def __len__(self):

-        return len(self.layers)

-

-    def get(self, index, default=None):

-        if self.contains(key):

-            return self[key]

-        else:

-            return default

-

-    def __contains__(self, index):

-        if isinstance(index, str):

-            side, _, use = index.partition(' ')

-            return (side, use) in self.layers

-

-        elif isinstance(index, tuple):

-            return index in self.graphic_layers

-

-        return index < len(self.copper_layers)

-

-    def __getitem__(self, index):

-        if isinstance(index, str):

-            side, _, use = index.partition(' ')

-            return self.graphic_layers[(side, use)]

-

-        elif isinstance(index, tuple):

-            return self.graphic_layers[index]

-

-        return self.copper_layers[index]

-

-    @property

-    def copper_layers(self):

-        copper_layers = [ (key, layer) for key, layer in self.layers.items() if key.endswith('copper') ]

-

-        def sort_layername(val):

-            key, _layer = val

-            if key.startswith('top'):

-                return -1

-            if key.startswith('bottom'):

-                return 1e99

-            assert key.startswith('inner_')

-            return int(key[len('inner_'):])

-

-        return [ layer for _key, layer in sorted(copper_layers, key=sort_layername) ]

-

-    @property

-    def top_side(self):

-        return { key: self[key] for key in ('top copper', 'top mask', 'top silk', 'top paste', 'mechanical outline') }

-

-    @property

-    def bottom_side(self):

-        return { key: self[key] for key in ('bottom copper', 'bottom mask', 'bottom silk', 'bottom paste', 'mechanical outline') }

-

-    @property

-    def outline(self):

-        return self['mechanical outline']

-    

-    def _merge_layer(self, target, source):

-        if source is None:

-            return

-        

-        if self[target] is None:

-            self[target] = source

-

-        else:

-            self[target].merge(source)

-

-    def merge(self, other):

-        all_keys = set(self.layers.keys()) | set(other.layers.keys())

-        exclude = { key.split() for key in STANDARD_LAYERS }

-        all_keys = { key for key in all_keys if key not in exclude }

-        if all_keys:

-            warnings.warn('Cannot merge unknown layer types: {" ".join(all_keys)}')

-

-        for side in 'top', 'bottom':

-            for use in 'copper', 'mask', 'silk', 'paste':

-                self._merge_layer((side, use), other[side, use])

-

-        our_inner, their_inner = self.copper_layers[1:-1], other.copper_layers[1:-1]

-

-        if bool(our_inner) != bool(their_inner):

-            warnings.warn('Merging board without inner layers into board with inner layers, inner layers will be empty on first board.')

-

-        elif our_inner and their_inner:

-            warnings.warn('Merging boards with different inner layer counts. Will fill inner layers starting at core.')

-

-        diff = len(our_inner) - len(their_inner)

-        their_inner = ([None] * max(0, diff//2)) + their_inner + ([None] * max(0, diff//2))

-        our_inner = ([None] * max(0, -diff//2)) + their_inner + ([None] * max(0, -diff//2))

-

-        new_inner = []

-        for ours, theirs in zip(our_inner, their_inner):

-            if ours is None:

-                new_inner.append(theirs)

-            elif theirs is None:

-                new_inner.append(ours)

-            else:

-                ours.merge(theirs)

-                new_inner.append(ours)

-

-        for i, layer in enumerate(new_inner, start=1):

-            self[f'inner_{i} copper'] = layer

-

-        self._merge_layer('mechanical outline', other['mechanical outline'])

-

-        self.normalize_drill_layers()

-        other.normalize_drill_layers()

-

-        self.drill_pth.merge(other.drill_pth)

-        self.drill_npth.merge(other.drill_npth)

-        self.drill_unknown.merge(other.drill_unknown)

-        self.netlist.merge(other.netlist)

-