def officeVocab(self):
""" """
offices = DisplayList()
offices.add('', _(u'-- not specified --'))
for office in self.aq_parent.getElenco_uffici():
offices.add(office, office)
return offices
def getProviderQuicksearch(self):
""" return a DisplayList of all providers """
provRes = self._validProviders()
DL = DisplayList()
for r in provRes:
DL.add(r.UID, r.Title)
return DL
def getTipologiaprofilo(self):
""" ottengo le tipologie di profilo in formato DisplayList"""
tipiprofilo = DisplayList()
tipiprofilo.add('', _(u'-- seleziona --'))
for tipo in self.aq_parent.getElencotipologieprofilo():
tipiprofilo.add(tipo, tipo)
return tipiprofilo
def getArchi(self):
""" ottengo gli archi temporali in formato DisplayList"""
archi = DisplayList()
archi.add('', _(u'-- seleziona --'))
for arco in self.aq_parent.getElencoarchi():
archi.add(arco, arco)
return archi
def getDipartimento(self):
""" ottengo la lista dei dipartimenti settata in pannello di configurazione formato DisplayList"""
dipartimenti = DisplayList()
dipartimenti.add('', _(u'-- seleziona --'))
for dipartimento in self.aq_parent.getElencodipartimenti():
dipartimenti.add(dipartimento, dipartimento)
return dipartimenti
def getTipologiacontratto(self):
""" ottengo le tipologie contrattuali"""
tipologiecontrattuali = DisplayList()
tipologiecontrattuali.add('', _(u'-- seleziona --'))
for tipo in self.aq_parent.getElencotipologiecontrattuali():
tipologiecontrattuali.add(tipo, tipo)
return tipologiecontrattuali
def awardProceduresVocab(self):
""" """
award_procedures = DisplayList()
award_procedures.add('', _(u'-- not specified --'))
for award_procedure in self.aq_parent.getModalita_affidamento():
award_procedures.add(award_procedure, award_procedure)
return award_procedures
def getElencoTipologie(self):
""" restituisce l'elenco delle tipologie sulla folder padre
"""
elenco_tipologie = DisplayList()
items = self.getPrenotazioniFolder().getTipologia()
for item in items:
elenco_tipologie.add(item, item)
return elenco_tipologie
def vocNumeroAppuntamenti(self):
"""
"""
res = DisplayList()
for x in range(0, 21):
res.add(str(x), str(x))
return res
def getSubjectList(self):
"""See interface"""
pc = getToolByName(self, 'portal_catalog')
vals = pc.uniqueValuesFor('Subject')
result = DisplayList()
for v in vals:
result.add(v, v)
return result
def test_add(self):
ta = ('a', 'b', 'c')
l = zip(ta, ta)
dl = DisplayList(l)[:]
self.assertTrue(dl == l)
l.append(('d', 'd'))
dl.append(('d', 'd'))
self.assertTrue(dl == l)
def test_add(self):
ta = ('a', 'b', 'c')
l = zip(ta, ta)
dl = DisplayList(l)[:]
self.failUnless(dl == l)
l.append(('d', 'd'))
dl.append(('d', 'd'))
self.failUnless(dl == l)
def getAvailableCategories(self):
"""
"""
from Products.Archetypes.utils import DisplayList
dl = DisplayList()
dl.add("derniere-minute", u"Dernières minutes")
dl.add("promotion", u"Promotion")
return dl
def getDivisionsVocab(self):
""" Get the list of current divisions and return it as a vocabulary. """
path = {'query':('/'), }
brains = self.portal_catalog.searchResults(path=path, Type='Division', sort_on='sortable_title')
dl = DisplayList()
dl.add('None', 'None')
for brain in brains:
if brain.getId != self.aq_parent.id:
dl.add(brain.getId, brain.Title)
return dl
def getAvailableCategories(self):
""" """
pv = getToolByName(self, 'portal_vocabularies')
VOCAB = pv.get('provider_category')
if VOCAB:
dl = VOCAB.getDisplayList(self)
else:
dl = DisplayList()
dl.add('nocat', 'No specific category')
return dl
def getDisplayList(self, instance):
"""Returns a object of class DisplayList as defined in Products.Archetypes.utils.
The instance of the content class is given as parameter.
The list is sorted accordingly to the sortMethod chosen.
"""
dl = DisplayList()
vdict=self.getVocabularyDict(instance)
for key in self.getSortedKeys():
dl.add(key,vdict[key])
return dl
def getCategoria(self):
catalog = getToolByName(self, 'portal_catalog')
categorias = catalog(portal_type='MJCategoria',
sort_on='id',)
listCategorias = DisplayList()
if categorias:
listCategorias.add('', '')
for i in categorias:
categoria = i.Title
cor = i.cor_categoria
listCategorias.add(cor, categoria)
return listCategorias
def getNaceList(self):
"""See interface"""
result = DisplayList()
pv = getToolByName(self, 'portal_vocabularies')
VOCAB = getattr(pv, 'NACE', None)
if not VOCAB:
return result
vd = VOCAB.getVocabularyDict(self)
result = DisplayList()
for k in vd.keys():
result.add(k, vd[k][0])
return result
def getCampi(self):
""" tramite questo metodo mostro i campi della presente classe
utile per il tipo di oggetto 'Rettifica'
in formato DisplayList (utile per costruire Vocabulary)"""
dl = DisplayList()
# filtro i campi della presente classe ottenendo solo quelli della schemata default e approvazione
campi = self.schema.getSchemataFields('default')
campiapprovazione = self.schema.getSchemataFields('approvazione')
for campo in campiapprovazione: campi.append(campo)
# costruisco il dizionaro in DisplayList
# testo anche se hanno l'attributo default posto
dl.fromList([(x.getName(), x.widget.label.default) for x in campi if hasattr(x.widget.label, 'default')])
return dl
def getSearchKeywordsFromResults(self, results):
keywords = self.getUniqueKeywordsFromResults(results)
results_len = len(results)
for key, count in keywords.items():
if count == results_len:
del keywords[key]
keywords = keywords.keys()
keywords.sort()
result = DisplayList()
if len(keywords):
result.add('', '[no keywords]', msgid='label_no_keywords')
for item in keywords:
result.add(item, item)
return result
def getCountryList(self):
"""See interface"""
result = DisplayList()
pv = getToolByName(self, 'portal_vocabularies')
VOCAB = getattr(pv, 'Country', None)
if not VOCAB:
return result
vd = VOCAB.getVocabularyDict(self)
for k in vd.keys():
result.add('_%s' % k, '-- %s --' % vd[k][0])
for r in vd[k][1].keys():
result.add(r, vd[k][1][r][0])
return result
def vocOreInizio(self):
"""
"""
hours = ['07', '08', '09', '10', '11', '12', '13',
'14', '15', '16', '17', '18', '19', '20']
minutes = ['00', '15', '30', '45']
res = DisplayList()
res.add('0', '--:--')
for hour in hours:
for minute in minutes:
time = hour + ':' + minute
index_time = hour + minute
res.add(index_time, time)
return res
def _initStringValidators(self):
""" Initialize string validators from config
"""
self.stringValidators = {}
self.stringValidatorsDL = DisplayList()
self.stringValidatorsDL.add('vocabulary_none_text', u'None')
for kwa in config.stringValidators:
id = kwa['id']
title = kwa.get('title', id)
i18nid = kwa.get('i18nid', title)
errmsg = kwa.get('errmsg', 'Validation failed: %s' % id)
errid = kwa.get('errid', errmsg)
if HAS_PLONE25:
errmsg = _(errid, errmsg)
validatorId = 'pfgv_%s' % id
self.stringValidators[id] = {
'title' : title,
'i18nid' : i18nid,
'errmsg' : errmsg,
'errid' : errid,
# 'revalid': revalid,
'id' : validatorId,
}
self.stringValidatorsDL.add( id, title, msgid=i18nid )
def normVocabulary(self):
normTypes = DisplayList()
normTypes.add('', _(u'-- not specified --'))
for normType in self.aq_parent.getNorma_o_titolo():
normTypes.add(normType, normType)
normTypes.add('other', _(u'other'))
return normTypes
def getSiteMembers(self, *args, **kw):
"""
For use when members are authors, return a DisplayList of members
Alternative to 'getMembers' if 'no reference' must not be empty
(to work around a bug in the 'Records' packager)
"""
pas=getToolByName(self.context, "acl_users")
results=pas.searchUsers(**(True and dict(sort_by='userid') ))
results = dict([(result["userid"], result) for result in results]).values()
dl = DisplayList()
#zzz todo: Make this translateable, how?
dl.add('',"Select a site member")
for r in results:
title = r['title']
if title=="":
title=r['userid']
dl.add(r['userid'],title)
return dl
def getAtividades(self, id):
listAtividade = DisplayList()
if id != '':
url = self.getURLWebservice()
client = Client(url)
filtro = client.factory.create('wsFiltros')
if id == '1':
self.idTipoServico = 1
self.siglaTipoServico = "INFR"
if id == '2':
self.idTipoServico = 2
self.siglaTipoServico = "CRTL"
if id == '3':
self.idTipoServico = 3
self.siglaTipoServico = "SUST"
if id == '4':
self.idTipoServico = 4
self.siglaTipoServico = "PLAN"
filtro.tipoServico.id = self.idTipoServico
filtro.tipoServico.sigla = self.siglaTipoServico
search = client.service.consultarAtividades(filtro)
if search:
item = search.item
for item in item:
listAtividade.add('', '')
atividade = item.listAtividade[0]
codAtividade = atividade.codigo
descAtividade = atividade.codigo + ' - ' + atividade.descricao
#self.descricaoAtividade = descAtividade
listAtividade.add(codAtividade, descAtividade)
listAtividade = listAtividade.sortedByValue()
return listAtividade
def getComplexidades(self, id):
listComplexidade = DisplayList()
if id != '' and id != 'null':
try:
url = self.getURLWebservice()
client = Client(url)
filtro = client.factory.create('wsFiltros')
filtro.tipoServico.id = self.idTipoServico
filtro.tipoServico.sigla = self.siglaTipoServico
filtro.codigoAtividade = id
search = client.service.consultarAtividades(filtro)
complexidades = search.item[0].listAtividade[0].listComplexidade
if complexidades.__len__() > 0:
for complexidade in complexidades:
quantidade = str(complexidade.quantidade)
descricao = getattr(complexidade, 'descricao', '')
nome = complexidade.nome + ' - ' + descricao + ' - ' + quantidade + 'HST'
listComplexidade.add(quantidade, nome)
return listComplexidade
except:
return listComplexidade
return listComplexidade
def test_sort(self):
a = (('a', 'a',), ('b', 'b'), ('c', 'c'))
b = (('z', 'Z',), ('y', 'Y'), ('x', 'X'))
c = (('a', 'Z',), ('c', 'Y'), ('b', 'X'))
dla = DisplayList(a)
dlb = DisplayList(b)
dlc = DisplayList(c)
assert dla.values() == ['a', 'b', 'c']
dlb_s = dlb.sortedByValue()
assert dlb_s.values() == ['X', 'Y', 'Z']
dlc_s = dlc.sortedByKey()
assert dlc_s.values() == ['Z', 'X', 'Y']
def _departmentsVoc(self):
"""
Returns a vocabulary object with the available departments.
"""
bsc = getToolByName(self, 'bika_setup_catalog')
items = [
(o.UID, o.Title)
for o in bsc(portal_type='Department', inactive_state='active')
]
# Getting the departments uids
deps_uids = [i[0] for i in items]
# Getting the assigned departments
objs = self.getDepartments()
# If one department assigned to the Lab Contact is disabled, it will
# be shown in the list until the department has been unassigned.
for o in objs:
if o and o.UID() not in deps_uids:
items.append((o.UID(), o.Title()))
items.sort(lambda x, y: cmp(x[1], y[1]))
return DisplayList(list(items))
def getContacts(self, dl=True):
pc = getToolByName(self, 'portal_catalog')
bsc = getToolByName(self, 'bika_setup_catalog')
pairs = []
objects = []
# All Doctors
for contact in pc(portal_type='Doctor',
inactive_state='active',
sort_on='sortable_title'):
pairs.append((contact.UID, contact.Title))
if not dl:
objects.append(contact.getObject())
# All LabContacts
for contact in bsc(portal_type='LabContact',
inactive_state='active',
sort_on='sortable_title'):
pairs.append((contact.UID, contact.Title))
if not dl:
objects.append(contact.getObject())
return dl and DisplayList(pairs) or objects
def get_portal_metadata(self, field):
"""Returns the portal_metadata for a field.
"""
pmt = getToolByName(self, 'portal_metadata')
policy = None
try:
schema = getattr(pmt, 'DCMI', None)
spec = schema.getElementSpec(field.accessor)
policy = spec.getPolicy(self.portal_type)
except (ConflictError, KeyboardInterrupt):
raise
except:
log_exc()
return None, False
if not policy:
policy = spec.getPolicy(None)
return DisplayList(map(lambda x: (x, x), policy.allowedVocabulary())), \
policy.enforceVocabulary()
def getCategoria(self):
catalog = getToolByName(self, 'portal_catalog')
categorias = catalog(portal_type='SimpleVocabularyTerm',
sort_on='id',
review_state='published')
listCategorias = DisplayList()
if categorias:
listCategorias.add('', '')
for i in categorias:
categoria = i.Title
id = i.id
#cor = i.cor_categoria
#listCategorias.add(cor, categoria)
listCategorias.add(id, categoria)
return listCategorias
def _initStringValidators(self):
""" Initialize string validators from config
"""
self.stringValidators = {}
self.stringValidatorsDL = DisplayList()
self.stringValidatorsDL.add('vocabulary_none_text', u'None')
for kwa in config.stringValidators:
id = kwa['id']
title = kwa.get('title', id)
errmsg = kwa.get('errmsg', _('Validation failed: $id',
mapping={'id': id}))
validatorId = 'pfgv_%s' % id
self.stringValidators[id] = {
'title' : title,
'errmsg' : errmsg,
'id' : validatorId}
self.stringValidatorsDL.add(id, title)
def _Vocabulary(self, content_instance):
rel_vocab = utils.adddeleteVocab(content_instance,
ruleset_ids=[self.relationship])
if rel_vocab:
tuples = rel_vocab[0]['tuples']
else:
tuples = []
brains = [t[0] for t in tuples]
pairs = [(t[0].UID, t[0].Title) for t in tuples]
if i18n and not self.required and not self.multiValued:
no_reference = i18n.translate(domain='archetypes',
msgid='label_no_reference',
context=content_instance,
default='<no reference>')
pairs.insert(0, ('', no_reference))
__traceback_info__ = (content_instance, self.getName(), pairs)
return DisplayList(pairs)
def vocOreInizio(self):
"""
"""
hours = [
'07', '08', '09', '10', '11', '12', '13', '14', '15', '16', '17',
'18', '19', '20'
]
minutes = ['00', '15', '30', '45']
res = DisplayList()
res.add('', '--:--')
for hour in hours:
for minute in minutes:
time = hour + ':' + minute
index_time = hour + minute
res.add(index_time, time)
return res
def getDisplayList(self, context):
""" returns an object of class DisplayList as defined in
Products.Archetypes.utils.
The instance of the content is given as parameter.
"""
portal = api.portal.get()
bsc = getToolByName(portal, 'portal_catalog')
licenses = [
['', ''],
]
client = context.getClient()
for license in client.getLicenses():
license_types = bsc(portal_type='ClientType',
UID=license['LicenseType'])
if len(license_types) == 1:
license_type = license_types[0].Title
longstring = '{},{LicenseID},{LicenseNumber},{Authority}'
id_value = longstring.format(license_type, **license)
value = license_type
licenses.append([id_value, value])
return DisplayList(licenses)
def getSiteMembers(self, *args, **kw):
"""
For use when members are authors, return a DisplayList of members
Alternative to 'getMembers' if 'no reference' must not be empty
(to work around a bug in the 'Records' packager)
"""
pas = getToolByName(self.context, "acl_users")
results = pas.searchUsers(**(True and dict(sort_by='userid')))
results = dict([(result["userid"], result)
for result in results]).values()
dl = DisplayList()
#zzz todo: Make this translateable, how?
dl.add('', "Select a site member")
for r in results:
title = r['title']
if title == "":
title = r['userid']
dl.add(r['userid'], title)
return dl
from eea.facetednavigation.widgets.widget import CountableWidget
from eea.facetednavigation import EEAMessageFactory as _
EditSchema = Schema((
StringField('index',
schemata="default",
required=True,
vocabulary_factory='eea.faceted.vocabularies.CatalogIndexes',
widget=SelectionWidget(
label=_(u'Catalog index'),
description=_(u'Catalog index to use for search'),
i18n_domain="eea")),
StringField('operator',
schemata='default',
required=True,
vocabulary=DisplayList([('or', 'OR'), ('and', 'AND')]),
default='or',
widget=SelectionWidget(
format='select',
label=_(u'Default operator'),
description=_(u'Search with AND/OR between elements'),
i18n_domain="eea")),
BooleanField('operator_visible',
schemata='default',
required=False,
default=False,
widget=BooleanWidget(
label=_(u"Operator visible"),
description=_(u"Let the end-user choose to search with "
"AND or OR between elements"),
)),
def getWidgets(self,
instance=None,
package=None,
type=None,
context=None,
mode='edit',
fields=None,
schemata=None,
nosort=None):
# Empty widgets for standalone rendering.
widgets = []
w_keys = {}
context = context is not None and context or self
instances = instance is not None and [instance] or []
f_names = fields
if not instances:
for t in self.listTypes(package, type):
instance = t('fake_instance')
instance._at_is_fake_instance = True
wrapped = instance.__of__(context)
wrapped.initializeArchetype()
instances.append(wrapped)
for instance in instances:
if schemata is not None:
schema = instance.Schemata()[schemata].copy()
else:
schema = instance.Schema().copy()
fields = schema.fields()
if mode == 'search':
# Include only fields which have an index
# XXX duplicate fieldnames may break this,
# as different widgets with the same name
# on different schemas means only the first
# one found will be used
indexes = self.portal_catalog.indexes()
fields = [
f for f in fields
if (f.accessor and not f.accessor in w_keys
and f.accessor in indexes)
]
if f_names is not None:
fields = filter(lambda f: f.getName() in f_names, fields)
for field in fields:
widget = field.widget
field_name = field.getName()
accessor = field.getAccessor(instance)
if mode == 'search':
field.required = False
field.addable = False # for ReferenceField
if not isinstance(field.vocabulary, DisplayList):
field.vocabulary = field.Vocabulary(instance)
if '' not in field.vocabulary.keys():
field.vocabulary = DisplayList([('', _(u'at_search_any', default=u'<any>'))]) + \
field.vocabulary
widget.populate = False
field_name = field.accessor
# accessor must be a method which doesn't take an argument
# this lambda is facking an accessor
accessor = lambda: field.getDefault(instance)
w_keys[field_name] = None
widgets.append((field_name,
WidgetWrapper(field_name=field_name,
mode=mode,
widget=widget,
instance=instance,
field=field,
accessor=accessor)))
if mode == 'search' and nosort == None:
widgets.sort()
return [widget for name, widget in widgets]
def listTemplates(self):
# Lists all the templates.
return DisplayList(self._registeredTemplates.items()).sortedByValue()
def test_values(self):
ta = ('a', 'b', 'c')
l = zip(ta, ta)
dl = DisplayList(l)
self.assertTrue(tuple(dl.values()) == ta)
def test_item(self):
ta = ('a', 'b', 'c')
l = zip(ta, ta)
for i in range(0, 2):
item = ta[i]
self.assertTrue(DisplayList(l)[i] == item)
def getStickerTemplates(self):
"""Get the sticker templates
"""
out = [[t['id'], t['title']] for t in _getStickerTemplates()]
return DisplayList(out)
from bika.lims.config import ARIMPORT_OPTIONS
from bika.lims.config import ATTACHMENT_OPTIONS
from bika.lims.config import CURRENCIES
from bika.lims.config import DECIMAL_MARKS
from bika.lims.config import DEFAULT_AR_SPECS
from bika.lims.config import MULTI_VERIFICATION_TYPE
from bika.lims.config import PROJECTNAME
from bika.lims.config import SCINOTATION_OPTIONS
from bika.lims.config import WORKSHEET_LAYOUT_OPTIONS
from bika.lims.locales import COUNTRIES
from bika.lims import bikaMessageFactory as _
ROUNDING_METHODS = DisplayList((
('NONE', _("No rounding")),
('DECIMAL_PRECISION', _("Round to decimal places")),
('SIGNIFICANT_FIGURES', _("Round to significant figures")),
))
class PrefixesField(RecordsField):
"""A list of prefixes per portal_type
"""
_properties = RecordsField._properties.copy()
_properties.update({
'type': 'prefixes',
'subfields': ('portal_type', 'prefix', 'separator', 'padding', 'sequence_start'),
'subfield_labels': {'portal_type': 'Portal type',
'prefix': 'Prefix',
'separator': 'Prefix Separator',
'padding': 'Padding',
'sequence_start': 'Sequence Start'},
# Schema definition
schema = ATCTContent.schema.copy() + atapi.Schema(
(
atapi.StringField(
name='tipo_servico',
required=True,
searchable=True,
#vocabulary=DisplayList(
# (('', ''),
# ('1', 'Infraestrutura'),
# ('2', 'Apoio ao Controle'),
# ('3', 'Sustentação'),
# ('4', 'Apoio ao Planejamento'),)),
vocabulary=DisplayList((
('', ''),
('2', 'Apoio ao Controle'),
('3', 'Sustentação'),
('4', 'Apoio ao Planejamento'),
)),
widget=MasterSelectWidget(
label=_(u"Tipo de Serviço"),
description=_(u"Tipo de Serviço"),
slave_fields=({
'name': 'atividade',
'action': 'vocabulary',
'vocab_method': 'getAtividades',
'control_param': 'id',
}, ),
)),
atapi.StringField(name='atividade',
required=True,
searchable=True,
def vocEsfera(self):
return DisplayList(
((u'federal', u'Federal'), (u'estadual', u'Estadual'),
(u'municipal', u'Municipal')))
def test_repr(self):
ta = ('a', 'b', 'c')
l = zip(ta, ta)
dl = DisplayList(l)
self.assertTrue(repr(dl).find(str(l)))
def test_getValue(self):
a = ((
'a',
'A',
), ('b', '\xc3\xab'), ('c', u'xeb'), ('d', 42))
dla = DisplayList(a)
self.assertEqual(dla.getValue('a'), 'A')
self.assertEqual(dla.getValue('b'), '\xc3\xab')
self.assertEqual(dla.getValue('c'), u'xeb')
self.assertEqual(dla.getValue('d'), 42)
self.assertEqual(dla.getValue('e'), None)
self.assertEqual(dla.getValue('e', 'default'), 'default')
# Switch the keys and values around.
b = ((
'A',
'a',
), ('\xc3\xab', 'b'), (u'xeb', 'c'))
dlb = DisplayList(b)
self.assertEqual(dlb.getValue('A'), 'a')
self.assertEqual(dlb.getValue('\xc3\xab'), 'b')
self.assertEqual(dlb.getValue(u'xeb'), 'c')
self.assertEqual(dlb.getValue('e'), None)
self.assertEqual(dlb.getValue('e', 'default'), 'default')
'padding': 12,
'separator': 5,
'sequence_start': 12
},
'subfield_types': {
'padding': 'int',
'sequence_start': 'int'
},
})
security = ClassSecurityInfo()
STICKER_AUTO_OPTIONS = DisplayList((
('None', _('None')),
('register', _('Register')),
('receive', _('Receive')),
))
schema = BikaFolderSchema.copy() + Schema((
IntegerField(
'PasswordLifetime',
schemata="Security",
required=1,
default=0,
widget=IntegerWidget(
label=_("Password lifetime"),
description=
_("The number of days before a password expires. 0 disables password expiry"
),
)),
def getRotaItemVocab(self):
"""
"""
ris = self.getRotaItems()
return DisplayList([(ri.UID(), ri.Title()) for ri in ris])
def vocAtuacao(self):
return DisplayList(((u'cidadao', u'Cidadão'), (u'gestao', u'Gestão'),
(u'integracao', u'Integração')))
def test_values(self):
ta = ('a', 'b', 'c')
l = zip(ta, ta)
dl = DisplayList(l)
self.assertTrue(tuple(dl.values()) == ta)
def test_str(self):
ta = ('a', 'b', 'c')
l = zip(ta, ta)
dl = DisplayList(l)
self.assertTrue(str(dl) == str(l))
def amountTypeVocab(self):
amountTypes = DisplayList()
amountTypes.add('', _(u'-- not specified --'))
for amountType in self.aq_parent.getNatura_importo():
amountTypes.add(amountType, amountType)
return amountTypes
def test_slice(self):
ta = ('a', 'b', 'c')
l = zip(ta, ta)
sub = l[1:]
self.assertTrue(DisplayList(l)[1:] == sub)
def getInstrumentsDisplayList(self):
"""Instruments capable to perform this method
"""
items = [(i.UID(), i.Title()) for i in self.getInstruments()]
return DisplayList(list(items))
def test_len(self):
ta = ('a', 'b', 'c')
l = zip(ta, ta)
dl = DisplayList(l)
self.assertTrue(len(dl) == len(l))
def getSequenceTypes(self, instance=None):
return DisplayList([
('', ''),
('counter', 'Counter'),
('generated', 'Generated')
])
def test_items(self):
ta = ('a', 'b', 'c')
l = zip(ta, ta)
dl = DisplayList(l)
self.assertTrue(dl.items() == tuple(l))
def getCounterTypes(self, instance=None):
return DisplayList([
('', ''),
('backreference', 'Backreference'),
('contained', 'Contained')
])
