def group_by_date(results):
grouped_results = OrderedDict()
grouped_results['today'] = []
grouped_results['yesterday'] = []
grouped_results['this_week'] = []
grouped_results['this_month'] = []
grouped_results['older'] = []
today = datetime.today().day
yesterday = (datetime.today() - timedelta(1)).day
this_week = int(datetime.today().strftime("%V")) # isoweek
this_month = datetime.today().month
this_year = datetime.today().year
for result in results:
modified = result.modified
if modified.month() == this_month and modified.year() == this_year:
if modified.day() == today:
grouped_results['today'].append(result)
elif modified.day() == yesterday:
grouped_results['yesterday'].append(result)
elif int(modified.strftime("%V")) == this_week:
grouped_results['this_week'].append(result)
else:
grouped_results['this_month'].append(result)
else:
grouped_results['older'].append(result)
return grouped_results.items()
def scenariosByCategory(self):
""" prepare scenarios in this folder """
scitems = self.context.objectValues('Scenario')
categories = [item.getAccident_category().strip() for item in scitems]
categories.sort()
scmap = OrderedDict()
for cat in categories:
scmap[cat] = []
for item in scitems:
cat = item.getAccident_category().strip()
# save the english cat equivalents for later lookup to enable the schwusch anchors
ccat = item.getCanonical().getAccident_category().strip()
self._en_catnames[cat] = ccat
scs = scmap.get(cat)
scs.append(item)
scmap[cat] = scs
return scmap
def activity(self):
query=dict(
path="/".join(self.context.getPhysicalPath()),
start=dict(query=[self.start, self.end], range="minmax"),
portal_type="ExtropyHours",
sort_on="start",
sort_order="descending")
if self.person!="all":
query["Creator"]=self.person
data=[self.MorphHourBrain(brain) for brain in self.tool(query)]
grouping = dict(project=lambda x: x["chain"][0]["title"],
person=lambda x: x["fullname"],
day=lambda x: x["start"].earliestTime(),
)
results=OrderedDict()
keyfunc=grouping.get(self.group_by, grouping["day"])
for booking in data:
key=keyfunc(booking)
if key not in results:
results[key]=[]
results[key].append(booking)
results=[dict(title=key, summary=self.summarize(value), bookings=value)
for (key, value) in results.items()]
if self.group_by != "day":
results.sort(key=lambda x: x["title"])
return results
def getSchemata(obj):
"""Returns an ordered dictionary, which maps all Schemata names to fields
that belong to the Schemata."""
schema = obj.Schema()
schemata = OrderedDict()
for f in schema.fields():
sub = schemata.get(f.schemata, WrappedSchemata(name=f.schemata))
sub.addField(f)
schemata[f.schemata] = sub.__of__(obj)
return schemata
def getSchemata(obj):
"""Returns an ordered dictionary, which maps all Schemata names to fields
that belong to the Schemata."""
schema = obj.Schema()
schemata = OrderedDict()
for f in schema.fields():
sub = schemata.get(f.schemata, WrappedSchemata(name=f.schemata))
sub.addField(f)
schemata[f.schemata] = sub.__of__(obj)
return schemata
def __init__(self, results, context, request):
"""Take the results and the request.
"""
self.context = context
self.results = results
self.currentresults = []
self.pagemap = OrderedDict()
self.request = request
self.showBatch = True
if len(results) < self.threshold:
self.showBatch = False
self.currentresults = results
else:
self.initialize()
def get_header_info(self,
fields,
request,
context,
from_addr=None,
to_addr=None,
subject=None):
"""Return header info
header info is a dictionary
Keyword arguments:
request -- (optional) alternate request object to use
"""
portal = getToolByName(context, 'portal_url').getPortalObject()
utils = getToolByName(context, 'plone_utils')
(to, from_addr, reply) = self.get_addresses(fields, request, context)
subject = self.get_subject(fields, request, context)
headerinfo = OrderedDict()
headerinfo['To'] = self.secure_header_line(to)
headerinfo['From'] = self.secure_header_line(from_addr)
if reply:
headerinfo['Reply-To'] = self.secure_header_line(reply)
# transform subject into mail header encoded string
email_charset = portal.getProperty('email_charset', 'utf-8')
if not isinstance(subject, unicode):
site_charset = utils.getSiteEncoding()
subject = unicode(subject, site_charset, 'replace')
msgSubject = self.secure_header_line(subject).encode(
email_charset, 'replace')
msgSubject = str(Header(msgSubject, email_charset))
headerinfo['Subject'] = msgSubject
# CC
cc_recips = filter(None, self.cc_recipients)
if hasattr(self, 'ccOverride') and self.ccOverride and get_expression(
context, self.ccOverride):
cc_recips = get_expression(context, self.ccOverride)
if cc_recips:
headerinfo['Cc'] = self._destFormat(cc_recips)
# BCC
bcc_recips = filter(None, self.bcc_recipients)
if hasattr(self,
'bccOverride') and self.bccOverride and get_expression(
context, self.bccOverride):
bcc_recips = get_expression(context, self.bccOverride)
if bcc_recips:
headerinfo['Bcc'] = self._destFormat(bcc_recips)
for key in getattr(self, 'xinfo_headers', []):
headerinfo['X-{0}'.format(key)] = self.secure_header_line(
request.get(key, 'MISSING'))
return headerinfo
def getOrder(self, original):
neworder = OrderedDict()
keys = original.keys()
last = keys.pop()
keys.insert(1, last)
for schemata in keys:
neworder[schemata] = original[schemata]
return neworder
def testSwapTwoSchemata(self):
schema = ManagedSchema()
schema.addField(MockField("one", "one"))
schema.addField(MockField("two", "two"))
command = OrderedDict()
command["two"] = ["two"]
command["one"] = ["one"]
set_schema_order(schema, command)
self.assertEqual(schema.getSchemataNames(), ["two", "one"])
def lookupVocabulary(context, field):
if IVocabulary.providedBy(field.vocabulary):
return field.vocabulary.getVocabularyDict(context)
else:
vocab = field.Vocabulary(context)
tree = OrderedDict()
for key in vocab:
tree[key] = vocab.getValue(key)
return tree
def _getUntranslatedVocabularyDict(self):
"""returns a vocabulary dictionary as defined in the interface
"""
vdict = OrderedDict()
for obj in self.contentValues():
vsubdict = obj._getUntranslatedVocabularyDict()
vdict[obj.getVocabularyKey()] = ( \
obj.getVocabularyValue(), vsubdict)
return vdict
def get_schema_order(schema):
"""Return the order of all schemata and their fields.
The ordering is returned as an OrderedList for schemata
with the schemata names as keys fields names as values.
"""
result = OrderedDict()
for name in schema.getSchemataNames():
fields = schema.getSchemataFields(name)
result[name] = list(x.getName() for x in fields)
return result
def getOrder(self, original):
res = OrderedDict()
# Make "default" come first:
res['default'] = original['default']
del original['default']
# Go through any extensions:
schematas = []
for name, extension in component.getAdapters((self, self.context),
IEventSchemaExtension):
schematas.extend(extension.getOrders())
schematas.sort()
for order, schemata in schematas:
res[schemata] = original[schemata]
del original[schemata]
# And tag on anything left over:
res.update(original)
self._order = res
return res
def show_project_membership(self):
portal = getToolByName(self, 'portal_url').getPortalObject()
result_map = OrderedDict()
pfolder = portal.projects
proj_ids = list(pfolder.objectIds(spec='OpenProject'))
proj_ids.sort()
for proj_id in proj_ids:
proj_map = result_map[proj_id] = OrderedDict()
proj = pfolder._getOb(proj_id)
mem_ids = list(proj.projectMemberIds())
mem_ids.sort()
for mem_id in mem_ids:
proj_map[mem_id] = proj.get_local_roles_for_userid(mem_id)
out = ""
for proj_id, proj_map in result_map.items():
out += "PROJECT: %s\n" % proj_id
for mem_id, mem_roles in proj_map.items():
out +="\t%s: %s\n" % (mem_id, str(mem_roles))
out += "\n"
return out
def __init__(self, results, context, request):
"""Take the results and the request.
"""
self.context = context
self.results = results
self.currentresults = []
self.pagemap = OrderedDict()
self.request = request
self.showBatch = True
if len(results) < self.threshold:
self.showBatch = False
self.currentresults = results
else:
self.initialize()
def _getTranslatedVocabularyDict(self, lang):
"""returns a vocabulary dict using the titles of the
translations for language ``lang``
Only canonical objects are used to build up this
dictionary. If available, the translation's titles
are used.
"""
vdict = OrderedDict()
for obj in self.contentValues():
if obj.isCanonical():
# we only add the canonical objects to this dict
key = obj.getTermKey()
# but use the title of the appropriate translation
# if it is available (getTermValue is LP aware)
vsubdict = obj._getTranslatedVocabularyDict(lang)
vdict[key] = (obj.getTermValue(lang=lang), vsubdict)
return vdict
def _get_issues(self):
" fetch all oshmail issues "
folder = self.context.data.oshmail
pc = self.context.portal_catalog
yearmap = dict()
allissues = []
latestissue = None
for issue in pc(portal_type='Collage', review_state="published"):
if not 'oshmail' in issue['getId']:
continue
# Don't list OSHMails that are both expired and outdated,
# aka "deleted"
if getattr(issue, 'outdated', False) and isExpired(issue):
continue
date = issue['effective']
if latestissue is None or date > latestissue['effective']:
latestissue = issue
(name, num) = issue['getId'].split('-')
yearlist = yearmap.get(date.year(), [])
yearlist.append((int(num),
dict(id=issue['getId'],
day=date.Day(),
month=date.Month(),
year=date.year(),
url=issue.getURL(),
title=issue['Title'])))
yearmap[date.year()] = yearlist
ordered_yearmap = OrderedDict()
years = yearmap.keys()
years.sort()
years.reverse()
for year in years:
yearlist = yearmap[year]
yearlist.sort()
yearlist.reverse()
ordered_yearmap[year] = yearlist
return latestissue, ordered_yearmap
def getVocabularyDict(self, instance=None):
"""Returns a vocabulary dictionary as defined in the interface
"""
if self.isLinguaPloneInstalled():
# if lp is installed
# obtain language and return translated dict
try:
# we use the language of instance for this dictionary
lang = instance.getLanguage()
except AttributeError:
# we retrieve the current language
langtool = getToolByName(self, 'portal_languages')
lang = langtool.getPreferredLanguage()
return self._getTranslatedVocabularyDict(lang)
else:
# just return all terms
vdict = OrderedDict()
for obj in self.contentValues():
vdict[obj.getTermKey()] = obj.getTermValue()
return vdict
def sortByDate(self, competitions):
yearmap = dict()
for competition in competitions:
date = competition.effective()
yearlist = yearmap.get(date.year(), [])
yearlist.append((
date.month(),
dict(id=competition.getId(),
url=competition.absolute_url(),
title=competition.Title()),
))
yearmap[date.year()] = yearlist
ordered_yearmap = OrderedDict()
keys = yearmap.keys()
keys.sort()
keys.reverse()
for year in keys:
yearlist = yearmap[year]
yearlist.sort()
yearlist.reverse()
ordered_yearmap[year] = yearlist
return ordered_yearmap
# See CMFPlone/tests/dummy.py for faking a FileField
return "Created %d PHC Videos." % i
def CreateTestData(self, portal):
out = []
out.append(CreateRootPHC(self, portal))
out.append(CreateUsers(self, portal))
out.append(CreateHowtos(self, portal))
out.append(CreateTutorials(self, portal))
out.append(CreateFaqs(self, portal))
out.append(CreateErrorRefs(self, portal))
out.append(CreateDefinitions(self, portal))
out.append(CreateLinks(self, portal))
out.append(CreateReferenceManuals(self, portal))
out.append(CreateVideos(self, portal))
return ' \n'.join(out)
functions = OrderedDict()
functions['Create Test Data'] = CreateTestData
functions['Create Test Users'] = CreateUsers
functions['Create Test PloneHelpCenter'] = CreateRootPHC
functions['Create Test Tutorials'] = CreateTutorials
functions['Create Test Howtos'] = CreateHowtos
functions['Create Test FAQs'] = CreateFaqs
functions['Create Test Error References'] = CreateReferenceManuals
functions['Create Test Definitions'] = CreateDefinitions
functions['Create Test Links'] = CreateLinks
functions['Create Test Reference Manuals'] = CreateReferenceManuals
functions['Create Test Videos'] = CreateVideos
def get_header_body_tuple(self,
fields,
request,
from_addr=None,
to_addr=None,
subject=None,
**kwargs):
"""Return header and body of e-mail as an 3-tuple:
(header, additional_header, body)
header is a dictionary, additional header is a list, body is a StringIO
Keyword arguments:
request -- (optional) alternate request object to use
"""
pprops = getToolByName(self, 'portal_properties')
site_props = getToolByName(pprops, 'site_properties')
portal = getToolByName(self, 'portal_url').getPortalObject()
pms = getToolByName(self, 'portal_membership')
utils = getToolByName(self, 'plone_utils')
body = self.get_mail_body(fields, **kwargs)
# fields = self.fgFields()
# get Reply-To
reply_addr = None
if shasattr(self, 'replyto_field'):
reply_addr = request.form.get(self.replyto_field, None)
# get subject header
nosubject = '(no subject)'
if shasattr(self, 'subjectOverride') and self.getRawSubjectOverride():
# subject has a TALES override
subject = self.getSubjectOverride().strip()
else:
subject = getattr(self, 'msg_subject', nosubject)
subjectField = request.form.get(self.subject_field, None)
if subjectField is not None:
subject = subjectField
else:
# we only do subject expansion if there's no field chosen
subject = self._dreplace(subject)
# Get From address
if shasattr(self, 'senderOverride') and self.getRawSenderOverride():
from_addr = self.getSenderOverride().strip()
else:
from_addr = from_addr or site_props.getProperty('email_from_address') or \
portal.getProperty('email_from_address')
# Get To address and full name
if shasattr(self,
'recipientOverride') and self.getRawRecipientOverride():
recip_email = self.getRecipientOverride()
else:
recip_email = None
if shasattr(self, 'to_field'):
recip_email = request.form.get(self.to_field, None)
if not recip_email:
recip_email = self.recipient_email
recip_email = self._destFormat(recip_email)
recip_name = self.recipient_name.encode('utf-8')
# if no to_addr and no recip_email specified, use owner adress if possible.
# if not, fall back to portal email_from_address.
# if still no destination, raise an assertion exception.
if not recip_email and not to_addr:
ownerinfo = self.getOwner()
ownerid = ownerinfo.getId()
fullname = ownerid
userdest = pms.getMemberById(ownerid)
if userdest is not None:
fullname = userdest.getProperty('fullname', ownerid)
toemail = ''
if userdest is not None:
toemail = userdest.getProperty('email', '')
if not toemail:
toemail = portal.getProperty('email_from_address')
assert toemail, """
Unable to mail form input because no recipient address has been specified.
Please check the recipient settings of the PloneFormGen "Mailer" within the
current form folder.
"""
to = formataddr((fullname, toemail))
else:
to = to_addr or '%s %s' % (recip_name, recip_email)
headerinfo = OrderedDict()
headerinfo['To'] = self.secure_header_line(to)
headerinfo['From'] = self.secure_header_line(from_addr)
if reply_addr:
headerinfo['Reply-To'] = self.secure_header_line(reply_addr)
# transform subject into mail header encoded string
email_charset = portal.getProperty('email_charset', 'utf-8')
if not isinstance(subject, unicode):
site_charset = utils.getSiteEncoding()
subject = unicode(subject, site_charset, 'replace')
msgSubject = self.secure_header_line(subject).encode(
email_charset, 'replace')
msgSubject = str(Header(msgSubject, email_charset))
headerinfo['Subject'] = msgSubject
# CC
cc_recips = filter(None, self.cc_recipients)
if shasattr(self, 'ccOverride') and self.getRawCcOverride():
cc_recips = self.getCcOverride()
if cc_recips:
headerinfo['Cc'] = self._destFormat(cc_recips)
# BCC
bcc_recips = filter(None, self.bcc_recipients)
if shasattr(self, 'bccOverride') and self.getRawBccOverride():
bcc_recips = self.getBccOverride()
if bcc_recips:
headerinfo['Bcc'] = self._destFormat(bcc_recips)
for key in getattr(self, 'xinfo_headers', []):
headerinfo['X-%s' % key] = self.secure_header_line(
request.get(key, 'MISSING'))
# return 3-Tuple
return (headerinfo, self.additional_headers, body)
<field>
<name>%(name)s</name>
%(properties)s %(widget)s
</field>
"""
XML_WIDGET = u"""
<widget>
%(properties)s
</widget>
"""
TEXT_FIELD_CONTENT_TYPES = ( 'text/plain', 'text/html', )
# init routines for field,widget and storage management
field_registry = OrderedDict()
widget_registry = OrderedDict()
storage_registry = OrderedDict()
for k, v in FIELD_REGISTRY_INFO:
field_registry[k] = v
for k, v in WIDGET_REGISTRY_INFO:
widget_registry[k] = v
for k, v in STORAGE_REGISTRY_INFO:
storage_registry[k] = v
# support for ATReferenceBrowserWidget
HAS_ATREF_WIDGET = False
try:
class AlphaBatch(object):
"""Object used to batch results alphabetically.
"""
security = ClassSecurityInfo()
JOKER = '*'
vocab = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
JOKER]
threshold = 30
def __init__(self, results, context, request):
"""Take the results and the request.
"""
self.context = context
self.results = results
self.currentresults = []
self.pagemap = OrderedDict()
self.request = request
self.showBatch = True
if len(results) < self.threshold:
self.showBatch = False
self.currentresults = results
else:
self.initialize()
def initialize(self):
"""Initialize this batch object.
"""
current = self.request.get('currentPage', None)
pointer = 0
hasResults = len(self.results)
nonresults = []
for term in self.vocab:
# full init for term
self.pagemap[term] = dict()
self.pagemap[term]['value'] = term
self.pagemap[term]['visible'] = False
self.pagemap[term]['current'] = False
# special handling for joker
if term == self.JOKER:
continue
# assume alpha sorted results here
for result in self.results[pointer:]:
title = safe_unicode(result['fullname']).upper()
# title.replace(u'ü',u'Ü')
# title.replace(u'ö',u'Ö')
# title.replace(u'ä',u'Ä')
currentTerm = title and title[0] or None
if currentTerm is None or currentTerm not in self.vocab:
nonresults.append(result)
pointer += 1
continue
if title.startswith(term):
self.pagemap[term]['visible'] = True
if current is None:
current = term
if term == current:
self.currentresults.append(result)
pointer += 1
else:
break
# check for current after processing
if term == current:
self.pagemap[term]['current'] = True
if nonresults:
self.pagemap[self.JOKER]['visible'] = True
if current == '*':
self.currentresults = nonresults
self.pagemap[self.JOKER]['current'] = True
security.declarePublic('showBatch')
def showBatch(self):
"""Return True if results reaches threshold.
"""
return self.showBatch
security.declarePublic('getPages')
def getPages(self):
"""Return a list of dicts containing page definitions.
"""
return self.pagemap.values()
security.declarePublic('getResults')
def getResults(self):
"""Return the current result.
"""
return self.currentresults
class OrderedDictTest(ATTestCase):
def afterSetUp(self):
self.d = OrderedDict()
self.d['a'] = '1'
self.d['b'] = '2'
self.d['c'] = '3'
def test_order(self):
self.assertTrue(self.d.keys() == ['a', 'b', 'c'])
self.assertTrue(self.d.values() == ['1', '2', '3'])
self.assertTrue(self.d.items() == [('a', '1'), ('b', '2'), ('c', '3')])
self.assertTrue(self.d.reverse() == [
('c', '3'), ('b', '2'), ('a', '1')])
def test_setitem(self):
self.d['d'] = '4'
self.assertTrue(self.d.keys() == ['a', 'b', 'c', 'd'])
self.assertTrue(self.d.values() == ['1', '2', '3', '4'])
self.assertTrue(self.d.items() == [
('a', '1'), ('b', '2'), ('c', '3'), ('d', '4')])
self.assertTrue(self.d.reverse() == [
('d', '4'), ('c', '3'), ('b', '2'), ('a', '1')])
self.d['c'] = 'C'
self.assertTrue(self.d.keys() == ['a', 'b', 'c', 'd'])
self.assertTrue(self.d.values() == ['1', '2', 'C', '4'])
self.assertTrue(self.d.items() == [
('a', '1'), ('b', '2'), ('c', 'C'), ('d', '4')])
self.assertTrue(self.d.reverse() == [
('d', '4'), ('c', 'C'), ('b', '2'), ('a', '1')])
def test_del(self):
del self.d['b']
self.assertTrue(self.d.keys() == ['a', 'c'])
self.assertTrue(self.d.values() == ['1', '3'])
self.assertTrue(self.d.items() == [('a', '1'), ('c', '3')])
self.assertTrue(self.d.reverse() == [('c', '3'), ('a', '1')])
self.assertTrue('b' not in self.d)
self.assertTrue(self.d.get('b', None) == None)
def test_clear(self):
self.d.clear()
self.assertTrue(self.d.keys() == [])
self.assertTrue(self.d.values() == [])
self.assertTrue(self.d.items() == [])
self.assertTrue(self.d.reverse() == [])
def test_update(self):
d2 = {'b': 'B', 'd': '4'}
self.d.update(d2)
self.assertTrue(self.d.keys() == ['a', 'b', 'c', 'd'])
self.assertTrue(self.d.values() == ['1', 'B', '3', '4'])
self.assertTrue(self.d.items() == [
('a', '1'), ('b', 'B'), ('c', '3'), ('d', '4')])
self.assertTrue(self.d.reverse() == [
('d', '4'), ('c', '3'), ('b', 'B'), ('a', '1')])
def test_popitem(self):
(k, v) = self.d.popitem()
self.assertTrue(k == 'c')
self.assertTrue(v == '3')
def afterSetUp(self):
self.d = OrderedDict()
self.d['a'] = '1'
self.d['b'] = '2'
self.d['c'] = '3'
class AlphaBatch(object):
"""Object used to batch results alphabetically.
"""
security = ClassSecurityInfo()
JOKER = '*'
vocab = [
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', JOKER
]
threshold = 30
def __init__(self, results, context, request):
"""Take the results and the request.
"""
self.context = context
self.results = results
self.currentresults = []
self.pagemap = OrderedDict()
self.request = request
self.showBatch = True
if len(results) < self.threshold:
self.showBatch = False
self.currentresults = results
else:
self.initialize()
def initialize(self):
"""Initialize this batch object.
"""
current = self.request.get('currentPage', None)
pointer = 0
hasResults = len(self.results)
nonresults = []
for term in self.vocab:
# full init for term
self.pagemap[term] = dict()
self.pagemap[term]['value'] = term
self.pagemap[term]['visible'] = False
self.pagemap[term]['current'] = False
# special handling for joker
if term == self.JOKER:
continue
# assume alpha sorted results here
for result in self.results[pointer:]:
title = safe_unicode(result['fullname']).upper()
# title.replace(u'ü',u'Ü')
# title.replace(u'ö',u'Ö')
# title.replace(u'ä',u'Ä')
currentTerm = title and title[0] or None
if currentTerm is None or currentTerm not in self.vocab:
nonresults.append(result)
pointer += 1
continue
if title.startswith(term):
self.pagemap[term]['visible'] = True
if current is None:
current = term
if term == current:
self.currentresults.append(result)
pointer += 1
else:
break
# check for current after processing
if term == current:
self.pagemap[term]['current'] = True
if nonresults:
self.pagemap[self.JOKER]['visible'] = True
if current == '*':
self.currentresults = nonresults
self.pagemap[self.JOKER]['current'] = True
security.declarePublic('showBatch')
def showBatch(self):
"""Return True if results reaches threshold.
"""
return self.showBatch
security.declarePublic('getPages')
def getPages(self):
"""Return a list of dicts containing page definitions.
"""
return self.pagemap.values()
security.declarePublic('getResults')
def getResults(self):
"""Return the current result.
"""
return self.currentresults
def getOrder(self, original):
neworder = OrderedDict()
for schemata in original.keys():
neworder[schemata] = original[schemata]
return neworder
class OrderedDictTest(ATTestCase):
def afterSetUp(self):
self.d = OrderedDict()
self.d['a'] = '1'
self.d['b'] = '2'
self.d['c'] = '3'
def test_order(self):
self.assertTrue(self.d.keys() == ['a', 'b', 'c'])
self.assertTrue(self.d.values() == ['1', '2', '3'])
self.assertTrue(self.d.items() == [('a', '1'), ('b', '2'), ('c', '3')])
self.assertTrue(self.d.reverse() == [('c', '3'), ('b', '2'), ('a', '1')])
def test_setitem(self):
self.d['d'] = '4'
self.assertTrue(self.d.keys() == ['a', 'b', 'c', 'd'])
self.assertTrue(self.d.values() == ['1', '2', '3', '4'])
self.assertTrue(self.d.items() == [('a', '1'), ('b', '2'), ('c', '3'), ('d', '4')])
self.assertTrue(self.d.reverse() == [('d', '4'), ('c', '3'), ('b', '2'), ('a', '1')])
self.d['c'] = 'C'
self.assertTrue(self.d.keys() == ['a', 'b', 'c', 'd'])
self.assertTrue(self.d.values() == ['1', '2', 'C', '4'])
self.assertTrue(self.d.items() == [('a', '1'), ('b', '2'), ('c', 'C'), ('d', '4')])
self.assertTrue(self.d.reverse() == [('d', '4'), ('c', 'C'), ('b', '2'), ('a', '1')])
def test_del(self):
del self.d['b']
self.assertTrue(self.d.keys() == ['a', 'c'])
self.assertTrue(self.d.values() == ['1', '3'])
self.assertTrue(self.d.items() == [('a', '1'), ('c', '3')])
self.assertTrue(self.d.reverse() == [('c', '3'), ('a', '1')])
self.assertTrue('b' not in self.d)
self.assertTrue(self.d.get('b', None) == None)
def test_clear(self):
self.d.clear()
self.assertTrue(self.d.keys() == [])
self.assertTrue(self.d.values() == [])
self.assertTrue(self.d.items() == [])
self.assertTrue(self.d.reverse() == [])
def test_update(self):
d2 = {'b': 'B', 'd': '4'}
self.d.update(d2)
self.assertTrue(self.d.keys() == ['a', 'b', 'c', 'd'])
self.assertTrue(self.d.values() == ['1', 'B', '3', '4'])
self.assertTrue(self.d.items() == [('a', '1'), ('b', 'B'), ('c', '3'), ('d', '4')])
self.assertTrue(self.d.reverse() == [('d', '4'), ('c', '3'), ('b', 'B'), ('a', '1')])
def test_popitem(self):
(k, v) = self.d.popitem()
self.assertTrue(k == 'c')
self.assertTrue(v == '3')
def afterSetUp(self):
self.d = OrderedDict()
self.d['a'] = '1'
self.d['b'] = '2'
self.d['c'] = '3'
def _getTranslatedVocabularyDict(self, lang):
vdict = OrderedDict()
for obj in self.contentValues():
vdict[obj.getTermKey()] = obj.getTermValue(lang)
return vdict
