class MySearch(BaseSearchView):
""" a browser view for searching
"""
ptype = 'MyContentType'
show_result_with_no_query = True
search_fields = OrderedDict([
('foo', u'Foo'),
('bar', u'Bar'),
('review_state', u'State'),
])
display_fields = OrderedDict([
('foo', u'Foo'),
('bar', u'Bar'),
('review_state', u'State'),
('baz', u'Baz'),
])
@property
def _display_converters(self):
converters = super(MySearch, self)._display_converters
baz_vocab = self.get_vocab('my_vocab')
converters.update({
'baz':
lambda x, **kw: baz_vocab.getTermByToken(x).title
})
return converters
def default(self, obj):
if isinstance(obj, UBCalcState):
d = OrderedDict()
d['name'] = obj.name
d['crystal'] = obj.crystal
d['reflist'] = obj.reflist
d['tau'] = obj.tau
d['sigma'] = obj.sigma
d['reference'] = obj.reference
d['u'] = obj.manual_U
d['ub'] = obj.manual_UB
d['or0'] = obj.or0
d['or1'] = obj.or1
return d
if isinstance(obj, CrystalUnderTest):
return repr([obj._name, obj._a1, obj._a2, obj._a3, obj._alpha1 * TODEG,
obj._alpha2 * TODEG, obj._alpha3 * TODEG])
if isinstance(obj, matrix):
l = [', '.join((repr(e) for e in row)) for row in obj.tolist()]
return l
if isinstance(obj, ReflectionList):
d = OrderedDict()
for n, ref in enumerate(obj._reflist):
d[str(n+1)] = ref
return d
if isinstance(obj, _Reflection):
d = OrderedDict()
d['tag'] = obj.tag
d['hkl'] = repr([obj.h, obj.k, obj.l])
d['pos'] = repr(list(obj.pos.totuple()))
d['energy'] = obj.energy
dt = eval(obj.time) # e.g. --> datetime.datetime(2013, 8, 5, 15, 47, 7, 962432)
d['time'] = None if dt is None else dt.isoformat()
return d
if isinstance(obj, YouReference):
d = OrderedDict()
if obj.n_hkl_configured is not None:
d['n_hkl_configured'] = repr(obj.n_hkl_configured.T.tolist()[0])
else:
d['n_hkl_configured'] = None
if obj.n_phi_configured is not None:
d['n_phi_configured'] = repr(obj.n_phi_configured.T.tolist()[0])
else:
d['n_phi_configured'] = None
return d
return json.JSONEncoder.default(self, obj)
def thinfilter(thin, dadidict):
"""
"""
dadidictOrdered = OrderedDict(sorted(dadidict.items()))
for site in dadidictOrdered.keys():
first_chrom = site.split(":")[0]
first_site = int(site.split(":")[1])
break
for site in dadidictOrdered.keys():
if site.split(":")[0] == first_chrom:
if int(site.split(":")[1]) < (first_site + thin):
del dadidictOrdered[site]
else:
first_site = int(site.split(":")[1])
else:
first_chrom = site.split(":")[0]
first_site = int(site.split(":")[1])
return(dadidict)
def bottomView(self):
if self.root == None:
return
lst = []
dit = OrderedDict()
lst.append((0,self.root))
while len(lst) != 0:
v,root = lst[0]
dit[v] = root.data
if root.left != None:
lst.append((v-1,root.left))
if root.right != None:
lst.append((v+1,root.right))
lst.pop(0)
for i in sorted(dit.keys()):
print(dit[i],end=' ')
def thinfilter(thin, dadidict):
"""
"""
dadidictOrdered = OrderedDict(sorted(dadidict.items()))
for site in dadidictOrdered.keys():
first_chrom = site.split(":")[0]
first_site = int(site.split(":")[1])
break
for site in dadidictOrdered.keys():
if site.split(":")[0] == first_chrom:
if int(site.split(":")[1]) < (first_site + thin):
del dadidictOrdered[site]
else:
first_site = int(site.split(":")[1])
else:
first_chrom = site.split(":")[0]
first_site = int(site.split(":")[1])
return (dadidict)
def training_step(self, batch, batch_idx):
x, y = batch
y_logits = self.forward(x)
y_pred = torch.argmax(nn.Softmax(y_logits))
y_true = y.view((-1, 1)).type_as(x)
train_loss = self.loss(y_logits, y_true)
num_correct = torch.eq(y_pred.view(-1), y_true.view(-1)).sum()
tqdm_dict = {'train_loss': train_loss}
output = OrderedDict({
'loss': train_loss,
'num_correct': num_correct,
'log': tqdm_dict,
'progress_bar': tqdm_dict
})
return output
from collection import OrderedDict
file_name = "/home/deepak/Project/files/outputs/wordnet/dumped.txt"
pairs = OrderedDict([])
with open(file_name, "r") as f:
for line in f:
line = line.strip().split()
if ((line[2], line[1]) in pairs.keys()):
continue
else:
pairs[(line[1], line[2])] = line[0]
for i in pairs.keys():
print("%s %s %s", (pairs[i], i[0], i[1]))
statesAndCapitals = {
'Gujarat': 'Gandhinagar',
'Maharashtra': 'Mumbai',
'Rajasthan': 'Jaipur',
'Bihar': 'Patna'
}
for state in statesAndCapitals:
print(state)
# iterate through all keys in a dictionary in a specific order
from collection import OrderedDict
statesAndCapitals = OrderedDict([('Gujarat', 'Gandhinagar'),
('Maharashtra', 'Mumbai'),
('Rajasthan', 'Jaipur'), ('Bihar', 'Patna')])
for state in statesAndCapitals:
print(state)
# Iterate through all values
statesAndCapitals = {
'Gujarat': 'Gandhinagar',
'Maharashtra': 'Mumbai',
'Rajasthan': 'Jaipur',
'Bihar': 'Patna'
}
for capital in statesAndCapitals.values():
game= hlt.Game("Destructor-V1")
logging.info("Starting Destructor")
while True:
game_map = game.update_map()
command_queue = []
team_ships = game_map.get_me().all_ships()
for ship in team_ships:
shipid = ship.id
if ship.docking_status != ship.DockingStatus.UNDOCKED:
continue
entities_by_distance = game_map.nearby_entities_by_distance(ship)
entities_by_distance = OrderedDict(sorted(entities_by_distance.items(), key=lambda t: t[0]))
closest_empty_planets = [entities_by_distance[distance][0] for distance in entities_by_distance if isinstance(entities_by_distance[distance][0], hlt.entity.Planet) and not entities_by_distance[distance][0].is_owned()]
closest_enemy_ships = [entities_by_distance[distance][0] for distance in entities_by_distance if isinstance(entities_by_distance[distance][0], hlt.entity.Ship) and entities_by_distance[distance][0] not in team_ships]
if len(closest_empty_planets) > 0:
target_planet = closest_empty_planets[0]
if ship.can_dock(target_planet);
command_queue.append(ship.dock(target_planet))
else:
navigate_command = ship.navigate(ship.closest_point_to(target_planet),
game_map,
speed = int(hlt.constants.MAX_SPEED),ignore_ships=False)
if navigate_command:
command_queue.append(navigate_command)
class ProjectsOverview(Search):
main_search_field = 'Title'
forced_portal_types = ('Project',)
allow_portal_types_filter = False
# this allows for results with no query
default_query = {
'portal_type': 'Project',
'review_state': [
# use `list` because `tuple` breakes
# zope `make_query` utils ;)
'development',
'maintenance',
'offer',
'planning',
],
'sort_on': 'modified',
'sort_order': 'reverse',
}
show_breadcrumbs = False
updated_search_view_name = 'updated_projects_overview'
_states_blacklist = ()
display_fields = OrderedDict([
('Title', u'Title'),
('review_state', u'State'),
('modified', u'Date'),
])
def sort_options(self):
""" Sorting options for search results view. """
return (
SortOption(
self.request,
_(u'modified (inv)'),
sortkey='modified',
search_view=self,
reverse=1,
),
SortOption(
self.request,
_(u'alphabetically'),
sortkey='sortable_title',
search_view=self,
),
SortOption(
self.request,
_(u'alphabetically (inv)'),
sortkey='sortable_title',
search_view=self,
reverse=1,
)
)
@property
def wftool(self):
wftool = api.portal.get_tool('portal_workflow')
return wftool
@view.memoize_contextless
def _review_states(self):
states_blacklist = self._states_blacklist
wf_id = self.wftool.getChainForPortalType(
self.default_query['portal_type'])[0]
wf = self.wftool[wf_id]
return [{'name': x.id, 'title': x.title}
for x in wf.states.objectValues()
if x.id not in states_blacklist]
def review_states(self):
items = []
for item in self._review_states():
selected = item['name'] in self.request.get('review_state')
selected = selected or \
item['name'] in self.default_query.get('review_state', [])
item['selected'] = selected
items.append(item)
return items
@property
def _display_converters(self):
plone_view = self.context.restrictedTraverse('@@plone')
get_date = lambda ob, value, **kw: plone_view.toLocalizedTime(value)
# get_state_display comes from ViewMixin
get_state = lambda ob, value, **kw: self.get_state_display(ob, value)
return {
# klass converters
'datetime': get_date,
'DateTime': get_date,
'review_state': get_state,
}
def get_display_values(self, brain):
# defaults to brain attributes
data = {}
# @@search view actually returns CatalogContentListingObject
brain = brain._brain
default_converter = lambda ob, value: value
for k in self.display_fields.iterkeys():
if hasattr(brain, k):
value = getattr(brain, k, None)
converter = self._display_converters.get(k)
if converter is None:
# look for klass converter
klass_name = value.__class__.__name__
converter = self._display_converters.get(klass_name,
default_converter)
data[k] = converter(brain, value)
# insert always these
data['title'] = brain.Title
data['url'] = brain.getURL()
data['review_state'] = brain.review_state
return data
def get_state_display(self, brain, value):
_type = brain.portal_type
return self.wftool.getTitleForStateOnType(value, _type)
print(nums) # defaultdict(<class 'int>, {'a':10, 'b':20})
print(nums['a']) # 10
print(
nums['c']
) # 0 <-- NOTE: the key 'c' doesnt exist. So, the key will now be created with value 0
print(nums) # defaultdict(<class 'int'>, {'a':10, 'b':20, 'c':0})
############################################################################################################################
'''
ORDERED DICT
- It is a dictionary where keys maintain the order in which they are inserted
- that is - if we change the value of a key later, it will not change the position of the key
'''
from collection import OrderedDict
od = OrderedDict() # OrderedDict()
od['a'] = 1 # OrderedDict([('a', 1)])
od['b'] = 2 # OrderedDict([('a', 1), ('b', 2)])
od['a'] = 4 # OrderedDict([('a', 4), ('b', 2)])
############################################################################################################################
'''
DEQUE
- deque is a list optimized for inserted and removing items from both ends
'''
from collections import deque
lst = ['a', 'b', ' c'] # ['a', 'b', 'c']
deq = deque(lst) # deque(['a', 'b', 'c'])
deq.append("d") # deque(['a', 'b', 'c', 'd'])
deq.appendleft("z") # deque(['z', 'a', 'b', 'c', 'd'])
deq.pop() # deque(['z', 'a', 'b', 'c'])