def __init__(self, projectfolder):
self._projectfolder = os.path.normpath(projectfolder)
self._validation_context = ValidationContext(self.projectfolder,
locality='Configs')
self._validation_errors = ErrorCollector()
try:
self._configdata = self.get_configs_file()
except IOError:
raise self.NoProjectErrorType(self._projectfolder)
def validation_errors(self):
# Regenerate Validation reconstructed structures
lverrors = self._validate()
rval = ErrorCollector()
rval.add(self._validation_errors)
# Obtain validation errors from Configs load
rval.add(self._configs.validation_errors)
# Obtain validation errors collected during construction
# from Parser -> BOM -> OBOM
rval.add(self._obom.validation_errors)
rval.add(lverrors)
return rval
def __init__(self, configfile, use_cached=True):
"""
:type configfile: gedaif.conffile.ConfigsFile
"""
super(EntityElnBom, self).__init__()
self.configurations = configfile
self._included_motifs = []
self._motifs = []
self._configured_for = None
self._validation_context = ValidationContext(
self.configurations.projectfolder, 'BOM')
self._group_policy = None
self._validation_errors = ErrorCollector()
self.create_groups()
self.populate_bom(use_cached=use_cached)
def __init__(self, projectfolder, use_cached=True, **kwargs):
self.projectfolder = os.path.normpath(projectfolder)
self._namebase = os.path.relpath(self.projectfolder, PROJECTS_ROOT)
self._validation_context = ValidationContext(self.projectfolder,
'BOMParser')
self._validation_errors = ErrorCollector()
self.line_gen = None
self._use_cached = use_cached
self._generator_args = kwargs
def _reload(self):
# Not handled :
# - Name changes
# - Ripple effects to any downstream objects
self._validation_errors = ErrorCollector()
self._configs = None
self._bom = None
self._obom = None
self._status = None
self._strategy = None
self._changelog = None
self.ident = self._modulename
self.validate()
def __init__(self, bom_list, name=None):
super(CompositeOutputBom, self).__init__()
self.descriptors = []
self.colcount = len(bom_list)
self.descriptor = OutputElnBomDescriptor(None, None, name, None, 1)
self._validation_context = ValidationContext(
self.descriptor.configname, 'ICOBOM'
)
self.sourcing_policy = SourcingIdentPolicy(self._validation_context)
self.validation_errors = ErrorCollector()
i = 0
for bom in bom_list:
self._insert_bom(bom, i)
i += 1
self.sort_by_ident()
def __init__(self, descriptor):
"""
:type descriptor: outputbase.OutputElnBomDescriptor
"""
super(OutputBom, self).__init__()
self.descriptor = descriptor
if self.descriptor.groupname is not None:
locality = 'OBOM.{0}'.format(self.descriptor.groupname)
else:
locality = 'OBOM'
self._validation_context = ValidationContext(
self.descriptor.configname, locality
)
self.sourcing_policy = SourcingIdentPolicy(self._validation_context)
self.validation_errors = ErrorCollector()
def _validate(self):
# One Time Validators
temp = self.configs
temp = self.status
temp = self.strategy
temp = self.changelog
temp = self.bom
# Validators for Reconstructed Structures
lvalidation_errors = ErrorCollector()
# Validate all OBOM line devices
# Validate all OBOM line idents
# Validate all OBOM line quantity types
self._validate_obom(lvalidation_errors)
self._sourcing_errors = self.obom.sourcing_errors
# TODO Check for valid snoseries
# TODO Check for empty groups?
# TODO Check for unused motifs?
# TODO Validate all motifs as configured
# TODO Validate all SJs are accounted for
# TODO Validate all Generators are expected
# TODO Higher order configuration validation
self._validated = True
return lvalidation_errors
class EntityElnBom(EntityBomBase):
def __init__(self, configfile, use_cached=True):
"""
:type configfile: gedaif.conffile.ConfigsFile
"""
super(EntityElnBom, self).__init__()
self.configurations = configfile
self._included_motifs = []
self._motifs = []
self._configured_for = None
self._validation_context = ValidationContext(
self.configurations.projectfolder, 'BOM')
self._group_policy = None
self._validation_errors = ErrorCollector()
self.create_groups()
self.populate_bom(use_cached=use_cached)
@property
def validation_errors(self):
return self._validation_errors
@property
def pcbname(self):
warnings.warn("Deprecated access of pcbname",
DeprecationWarning)
return self.configurations.pcbname
@property
def projfile(self):
warnings.warn("Deprecated access of projfile",
DeprecationWarning)
return self.configurations.projectfile
@property
def projectfolder(self):
warnings.warn("Deprecated access of projectfolder",
DeprecationWarning)
return self.configurations.projectfolder
@property
def motifs(self, all_defined=False):
if all_defined:
return sorted(self._motifs,
key=lambda x: (x._type, int(x._ident)))
else:
return sorted(self._included_motifs,
key=lambda x: (x._type, int(x._ident)))
def create_groups(self):
groupnamelist = self.configurations.group_names
file_groups = self.configurations.file_groups
if 'default' not in groupnamelist:
groupnamelist.append('default')
for group in groupnamelist:
logger.debug("Creating Group: " + str(group))
x = EntityElnGroup(group, self.configurations.pcbname)
self.grouplist.append(x)
self._group_policy = BomGroupPolicy(self._validation_context,
groupnamelist, file_groups)
def find_group(self, groupname):
"""
:rtype : EntityElnGroup
"""
for group in self.grouplist:
if group.groupname == groupname:
return group
def find_tgroup(self, item):
"""
:rtype : EntityElnGroup
"""
try:
gname = self._group_policy.check(item)
except ValidationError as e:
self._validation_errors.add(e)
gname = self._group_policy.default
return self.find_group(gname)
def _add_item(self, item):
# TODO This function includes very specific special cases
# These need to come out of core and into the instance.
if item.data['device'] in {'TESTPOINT', 'PCB EDGE'}:
return
tgroup = self.find_tgroup(item)
skip = False
if item.data['footprint'] == 'MY-TO220':
comp = EntityElnComp()
comp.define('HS' + item.data['refdes'][1:],
'HEAT SINK', 'TO220')
tgroup.insert_eln_comp(comp)
if item.data['device'] == 'MODULE LCD' and \
item.data['value'] == "CHARACTER PARALLEL 16x2" and \
item.data['footprint'] == "MY-MTA100-16":
comp = EntityElnComp()
comp.define(
item.data['refdes'], 'CONN SIP',
"16PIN PM ST", "MY-MTA100-16"
)
tgroup.insert_eln_comp(comp)
skip = True
if item.data['device'] == 'RES SMD' and \
item.data['value'] == '0E':
comp = EntityElnComp()
comp.define(
item.data['refdes'], 'SOLDER DOT', '0E',
footprint='MY-0603', fillstatus=item.data['fillstatus']
)
tgroup.insert_eln_comp(comp)
skip = True
if item.data['value'].startswith('DUAL'):
fp = item.data['footprint']
# if fp.endswith('-2'):
# fp = fp[:-1 * len('-2')]
comp = EntityElnComp()
comp.define(
refdes=item.data['refdes'] + '.1',
device=item.data['device'],
value=item.data['value'].split(' ', 1)[1],
footprint=fp,
fillstatus=item.data['fillstatus']
)
tgroup.insert_eln_comp(comp)
comp = EntityElnComp()
comp.define(
refdes=item.data['refdes'] + '.2',
device=item.data['device'],
value=item.data['value'].split(' ', 1)[1],
footprint=fp,
fillstatus=item.data['fillstatus']
)
tgroup.insert_eln_comp(comp)
skip = True
if not skip:
# TODO Add support for controlling harmonization within configs
if EDA_HARMONIZE_IDENTS:
item = jb_harmonize(item)
tgroup.insert(item)
def populate_bom(self, use_cached=True):
if self.configurations.pcbname is not None:
tgroup = self.find_group('default')
comp = EntityElnComp()
comp.define('PCB', 'PCB', self.configurations.pcbname)
tgroup.insert_eln_comp(comp)
parser = MotifAwareBomParser(self.configurations.projectfolder,
use_cached=use_cached, backend="bom")
for item in parser.line_gen:
self._add_item(item)
for motif in parser.motif_gen:
self._motifs.append(motif)
self._validation_errors.add(parser.validation_errors)
def get_motif_by_refdes(self, refdes):
for motif in self._motifs:
if refdes == motif.refdes:
return motif
return None
@property
def configured_for(self):
return self._configured_for
def configure_motifs(self, configname):
self._configured_for = configname
self._included_motifs = []
ctx = copy.copy(self._validation_context)
ctx.locality = 'BOM_CM_{0}'.format(configname)
motifconfs = self.configurations.configuration_motiflist(configname)
if motifconfs is not None:
policy = ConfigMotifPolicy(ctx)
for key, motifconf in motifconfs.iteritems():
motif = self.get_motif_by_refdes(key)
if motif is None:
e = ConfigMotifMissingError(policy, key)
self._validation_errors.add(e)
continue
motif_actconf = motif.get_configdict_stub()
if self.configurations.motiflist is not None:
motif_actconf.update(self.configurations.motif_baseconf(key))
motif_actconf.update(motifconf)
motif.configure(motif_actconf)
self._included_motifs.append(motif)
def create_output_bom(self, configname, groupname=None):
if configname not in self.configurations.configuration_names:
raise ValueError
outbomdescriptor = OutputElnBomDescriptor(
self.configurations.pcbname,
self.configurations.projectfolder,
configname, self.configurations,
groupname=groupname
)
outbom = OutputBom(outbomdescriptor)
if groupname is None:
is_group_bom = False
outgroups = self.configurations.configuration_grouplist(configname) # noqa
else:
is_group_bom = True
outgroups = [groupname]
genlist = self.configurations.configuration_genlist(configname)
gen_refdeslist = None
if genlist is not None:
gen_refdeslist = genlist.keys()
sjlist = self.configurations.configuration_sjlist(configname)
sj_refdeslist = None
if sjlist is not None:
sj_refdeslist = sjlist.keys()
ctx = self._validation_context
_policy_ge = ConfigGroupPolicy(ctx, self._group_policy.known_groups)
_policy_sj = ConfigSJPolicy(ctx)
for group in outgroups:
grpobj = self.find_group(group)
if grpobj is None:
e = ConfigGroupError(_policy_ge, group)
self._validation_errors.add(e)
continue
for comp in grpobj.complist:
if gen_refdeslist is not None and \
comp.refdes in gen_refdeslist:
# TODO Verify refdes has Generator status in schematic
if fpiswire(comp.device):
comp.footprint = genlist[comp.refdes]
else:
comp.value = genlist[comp.refdes]
if sj_refdeslist is not None and comp.refdes in sj_refdeslist:
if not comp.fillstatus == 'CONF':
e = ConfigSJUnexpectedError(_policy_sj,
comp.refdes,
comp.fillstatus)
self._validation_errors.add(e)
if sjlist[comp.refdes]:
logger.debug("Setting Fillstatus : " + comp.refdes)
comp.fillstatus = ''
else:
logger.debug("Clearing Fillstatus : " + comp.refdes)
comp.fillstatus = 'DNP'
outbom.insert_component(comp)
motifconfs = self.configurations.configuration_motiflist(configname)
if motifconfs is None:
outbom.sort_by_ident()
outbom.validation_errors.add(self._validation_errors)
return outbom
if self._configured_for != configname:
self.configure_motifs(configname)
for key, motifconf in motifconfs.iteritems():
motif = self.get_motif_by_refdes(key)
if motif is None:
# This error would already have beed reported when
# motifs were configured.
logger.error("Motif not defined : " + key)
continue
for item in motif.get_line_gen():
item_group = self.find_tgroup(item).groupname
if item_group == 'unknown' or item_group in outgroups and \
item.data['fillstatus'] != 'DNP':
outbom.insert_component(EntityElnComp(item))
outbom.sort_by_ident()
outbom.validation_errors.add(self._validation_errors)
return outbom
def get_group_boms(self, configname):
if configname not in self.configurations.configuration_names:
raise ValueError
rval = []
for group in self.configurations.configuration_grouplist(configname):
rval.append(self.create_output_bom(configname, groupname=group))
return rval
def indicative_cost_hierarchical_breakup(self, configname):
group_boms = self.get_group_boms(configname)
if len(group_boms) == 1:
raise NoStructureHereException
rval = HierachicalCostingBreakup(configname)
for obom in group_boms:
rval.insert(obom.descriptor.groupname,
obom.indicative_cost_breakup)
return rval
class ConfigBase(object):
NoProjectErrorType = NoProjectError
schema_name = None
schema_version_max = None
schema_version_min = None
def __init__(self, projectfolder):
self._projectfolder = os.path.normpath(projectfolder)
self._validation_context = ValidationContext(self.projectfolder,
locality='Configs')
self._validation_errors = ErrorCollector()
try:
self._configdata = self.get_configs_file()
except IOError:
raise self.NoProjectErrorType(self._projectfolder)
@property
def _cfpath(self):
raise NotImplementedError
def get_configs_file(self):
configdata = yaml.load(self._cfpath)
try:
return self._verify_schema_decl(configdata)
except SchemaNotSupportedError as e:
self._validation_errors.add(e)
@property
def _schema_name_policy(self):
return ConfigOptionPolicy(self._validation_context, ('schema', 'name'))
@property
def _schema_ver_policy(self):
return ConfigOptionPolicy(self._validation_context,
('schema', 'version'))
def _verify_schema_decl(self, configdata):
schema_policy = SchemaPolicy(self._validation_context,
self.schema_name, self.schema_version_max,
self.schema_version_min)
schema_name = get_dict_val(configdata, self._schema_name_policy)
schema_version = Decimal(
get_dict_val(configdata, self._schema_ver_policy))
if schema_policy.validate(schema_name, schema_version):
return configdata
else:
raise SchemaNotSupportedError(
schema_policy, '{0}v{1}'.format(schema_name, schema_version))
def validate(self):
raise NotImplementedError
@property
def projectfolder(self):
return self._projectfolder
@property
def docfolder(self):
raise NotImplementedError
@property
def pricingfolder(self):
raise NotImplementedError
@property
def indicative_pricing_folder(self):
warnings.warn("Deprecated Access of indicative_pricing_folder",
DeprecationWarning)
return self.pricingfolder
@property
def grouplist(self):
if "grouplist" in self._configdata.keys():
return self._configdata["grouplist"]
else:
return [{'name': 'default', 'desc': 'Unclassified'}]
@property
def file_groups(self):
rval = {}
# TODO Verify file names are correct
for group in self.grouplist:
if 'file' in group.keys():
if isinstance(group['file'], list):
for f in group['file']:
rval[f] = group['name']
else:
rval[group['file']] = group['name']
return rval
@property
def group_names(self):
return [x['name'] for x in self.grouplist]
def get_group_desc(self, groupname):
for group in self.grouplist:
if group['name'] == groupname:
return group['desc']
@property
def motiflist(self):
if "motiflist" in self._configdata.keys():
return self._configdata["motiflist"]
else:
return []
@property
def motif_refdeslist(self):
return self.motiflist.keys()
def motif_baseconf(self, refdes):
for mrefdes, mconf in self.motiflist.iteritems():
if mrefdes == refdes:
return mconf
raise ValueError("Motif with refdes {0} not defined for {1}"
"".format(refdes, self._projectfolder))
@property
def sjlist(self):
if "sjlist" in self._configdata.keys():
return self._configdata["sjlist"]
else:
return {}
@property
def genlist(self):
raise NotImplementedError
# Configmatrices #
@property
def configmatrices(self):
if "configmatrix" in self._configdata.keys():
return self._configdata["configmatrix"]
else:
return []
def _configmatrix_baseconfigs(self):
return [x['baseconfig'] for x in self.configmatrices]
def _get_configmatrix(self, baseconfig):
for configmatrix in self.configmatrices:
if configmatrix['baseconfig'] == baseconfig:
return configmatrix
raise ValueError("No configmatrix uses {0} as a baseconfig for {1}"
"".format(baseconfig, self._projectfolder))
def _expand_configmatrix(self, baseconfig):
matrix = self._get_configmatrix(baseconfig['configname'])
dimensions = {d['name']: d['options'] for d in matrix['dimensions']}
rval = []
for subconfig in matrix['subconfigs']:
ldimensions = []
laxes = []
lactions = subconfig['actions']
for dimension, options in dimensions.iteritems():
if dimension in subconfig['dimensions']:
ldimensions.append(dimension)
laxes.append(options)
for vector in itertools.product(*laxes):
nconfig = copy.deepcopy(baseconfig)
nconfig['configname'] = subconfig['configname']
nconfig['desc'] = subconfig['desc']
for idx, component in enumerate(vector):
dimname = ldimensions[idx]
# Update configname
nconfig['configname'] = nconfig['configname'].replace(
'<{0}:{1}>'.format(dimname, 'npart'),
component['npart'])
# Collapse repeated separators
nconfig['configname'] = '-'.join(
re.split('-+', nconfig['configname']))
# Update desc
nconfig['desc'] = nconfig['desc'].replace(
'<{0}:{1}>'.format(dimname, 'tpart'),
component['tpart'])
# Update all others
for param, action in lactions.iteritems():
if action == 'pass':
continue
if action == 'extend':
if param == 'grouplist':
if param not in nconfig.keys():
nconfig[param] = []
if param not in component.keys():
# TODO Consider a valdation warning here
continue
nlist = [
x for x in component[param]
if x is not None
]
nconfig[param].extend(nlist)
continue
if action == 'update':
if param in ['genlist', 'sjlist']:
if param not in nconfig.keys():
nconfig[param] = {}
if param not in component.keys():
# TODO Consider a valdation warning here
continue
nconfig[param].update(component[param])
continue
raise AttributeError("{0} Action not recognized for "
"{1} {2}".format(
action, param,
self._projectfolder))
rval.append(nconfig)
return rval
# Configsections #
@property
def configsections(self):
if "configsections" in self._configdata.keys():
return self._configdata["configsections"]
else:
return []
@property
def configsection_names(self):
return [x['sectionname'] for x in self.configsections]
def get_configsections(self):
warnings.warn("Deprecated access of get_configsections",
DeprecationWarning)
return self.configsection_names
def configsection(self, sectionname):
for configsection in self.configsections:
if configsection['sectionname'] == sectionname:
return configsection
raise ValueError('Configsection {0} not found for {1}'
''.format(sectionname, self._projectfolder))
def configsection_groups(self, sectionname):
return self.configsection(sectionname)['grouplist']
def configsection_configs(self, sectionname):
return self.configsection(sectionname)['configurations']
def configsection_config(self, sectionname, configname):
for config in self.configsection_configs(sectionname):
if config['configname'] == configname:
return config
raise ValueError('Config {0} not found for section {1} for {2}'
''.format(configname, sectionname,
self._projectfolder))
def configsection_configgroups(self, sectionname, configname):
return self.configsection_config(sectionname, configname)['groups']
def get_sec_groups(self, sectionname, config):
warnings.warn("Deprecated access of get_sec_groups",
DeprecationWarning)
return self.configsection_configgroups(sectionname, config)
# Configurations #
@property
def configurations(self):
if 'configurations' not in self._configdata.keys():
raise AttributeError("No configuration defined for {0}"
"".format(self._projectfolder))
configurations = self._configdata['configurations']
rval = []
for configuration in configurations:
if configuration['configname'] in self._configmatrix_baseconfigs(
): # noqa
rval.extend(self._expand_configmatrix(configuration))
else:
rval.append(configuration)
return rval
@property
def configuration_names(self):
return [x['configname'] for x in self.configurations]
def get_configurations(self):
warnings.warn("Deprecated access of get_configurations",
DeprecationWarning)
return self.configuration_names
def configuration(self, configname):
for x in self.configurations:
if x['configname'] == configname:
return x
raise ValueError(configname + ' Not Found')
def _configuration_direct_grouplist(self, configname):
configuration = self.configuration(configname)
if 'grouplist' in configuration.keys():
return configuration['grouplist']
else:
return []
def configuration_grouplist(self, configname):
rval = ["default"]
configuration = self.configuration(configname)
if 'config' in configuration.keys():
for section, sconfig in configuration['config'].iteritems():
rval.extend(self.configsection_configgroups(section, sconfig))
rval.extend(self._configuration_direct_grouplist(configname))
while None in rval:
rval.remove(None)
return list(set(rval))
def get_configuration(self, configname):
warnings.warn("Deprecated access of get_configuration",
DeprecationWarning)
return self.configuration_grouplist(configname)
def configuration_motiflist(self, configname):
# TODO Also deal with defaults here?
configuration = self.configuration(configname)
if 'motiflist' in configuration.keys():
return configuration['motiflist']
else:
return None
def get_configuration_motifs(self, configname):
warnings.warn("Deprecated access of get_configuration_motifs",
DeprecationWarning)
return self.configuration_motiflist(configname)
def configuration_genlist(self, configname):
configuration = self.configuration(configname)
if 'genlist' in configuration.keys():
return configuration['genlist']
else:
return None
def get_configuration_gens(self, configname):
warnings.warn("Deprecated access of get_configuration_gens",
DeprecationWarning)
return self.configuration_genlist(configname)
def configuration_sjlist(self, configname):
if self.sjlist is not None:
sjlist = copy.copy(self.sjlist)
else:
sjlist = None
configuration = self.configuration(configname)
if 'sjlist' in configuration.keys():
csjlist = configuration['sjlist']
if sjlist is not None:
sjlist.update(csjlist)
return sjlist
else:
return csjlist
else:
return sjlist
def get_configuration_sjs(self, configname):
warnings.warn("Deprecated access of get_configuration_sjs",
DeprecationWarning)
return self.configuration_sjlist(configname)
def maintainer(self, configname=None):
if configname is not None:
for configuration in self.configurations:
if configuration['configname'] == configname:
try:
return configuration['maintainer']
except KeyError:
pass
return self._configdata.get('maintainer', None)
def description(self, configname=None):
if configname is None:
return self._configdata['desc']
else:
for configuration in self.configurations:
if configuration['configname'] == configname:
return configuration['desc']
raise ValueError
def status_config(self, configname):
raise NotImplementedError
@property
def status(self):
raise NotImplementedError
@property
def snoseries(self):
if 'snoseries' in self._configdata.keys():
return self._configdata['snoseries']
else:
raise AttributeError('snoseries not defined or not found for {0}'
''.format(self._projectfolder))
def testvars(self, configname):
rval = {}
for motif in self.motiflist:
for k, v in self._configdata['motiflist'][motif].iteritems():
rval[':'.join([motif, k])] = v
for configuration in self._configdata['configurations']:
if configuration['configname'] == configname:
try:
rval.update(configuration['testvars'])
except KeyError:
pass
if "motiflist" in configuration.keys():
for motif in configuration['motiflist']:
for k, v in configuration['motiflist'][
motif].iteritems():
rval[':'.join([motif, k])] = v
return rval
def tests(self):
return self._configdata['tests']
@property
def rawconfig(self):
return self._configdata
@property
def configdata(self):
warnings.warn("Deprecated Access of configdata", DeprecationWarning)
return self._configdata
@property
def validation_errors(self):
return self._validation_errors
def _get_production_strategy(self):
rval = {}
configdata = self.configs.rawconfig
ec = ErrorCollector()
try:
am = get_dict_val(configdata, self._pspol_doc_am)
except ValidationError as e:
am = e.policy.default
ec.add(e)
if am is True:
# Assembly manifest should be used
rval['prodst'] = "@AM"
rval['genmanifest'] = True
else:
# No Assembly manifest needed
rval['prodst'] = "@THIS"
rval['genmanifest'] = False
try:
testing = get_dict_val(configdata, self._pspol_testing)
except ValidationError as e:
testing = e.policy.default
ec.add(e)
if testing == 'normal':
# Normal test procedure, Test when made
rval['testst'] = "@NOW"
if testing == 'lazy':
# Lazy test procedure, Test when used
rval['testst'] = "@USE"
try:
labelling = get_dict_val(configdata, self._pspol_labelling)
except ValidationError as e:
labelling = e.policy.default
ec.add(e)
if labelling == 'normal':
# Normal test procedure, Label when made
rval['lblst'] = "@NOW"
if labelling == 'lazy':
# Lazy test procedure, Label when used
rval['lblst'] = "@USE"
rval['genlabel'] = False
rval['labels'] = []
try:
labeldefs = get_dict_val(configdata, self._pspol_labeldefs)
except ValidationError as e:
labeldefs = e.policy.default
ec.add(e)
if labeldefs is not None:
if isinstance(labeldefs, dict):
for k in sorted(labeldefs.keys()):
rval['labels'].append({
'code':
k,
'ident':
self.ident + '.' + configdata['label'][k]
})
rval['genlabel'] = True
elif isinstance(labeldefs, str):
rval['labels'].append({'code': labeldefs, 'ident': self.ident})
rval['genlabel'] = True
return rval