def owns_segments(self, segments, security):
"""
check if shareholder owns all those segments either as share
does not check any kind of options. use owns_options_segments for this
"""
logger.info('checking if {} owns {}'.format(self, segments))
if isinstance(segments, str):
segments = string_list_to_json(segments)
logger.info('converted string to json')
logger.info('getting current segments...')
segments_owning = inflate_segments(
self.current_segments(security=security))
failed_segments = []
logger.info('calculating segments not owning...')
# shareholder does not own this
failed_segments = substract_list(inflate_segments(segments),
segments_owning)
logger.info('check segment ownership done')
return (len(failed_segments) == 0, deflate_segments(failed_segments),
deflate_segments(segments_owning))
def test_deflate_segments(self):
"""
watch the end of deflation logic!
"""
# closing lonely int
segments = [1, 2, 3, 4, 6, 9, 10, 11, 12, 13, 14, 18]
res = deflate_segments(segments)
self.assertEqual(res, [u'1-4', 6, u'9-14', 18])
# closing range
segments = [1, 2, 3, 4, 6, 9, 10, 11, 12, 13, 14]
res = deflate_segments(segments)
self.assertEqual(res, [u'1-4', 6, u'9-14'])
def owns_options_segments(self, segments, security):
"""
check if shareholder owns all those segments either as share
"""
if isinstance(segments, str):
segments = string_list_to_json(segments)
segments_owning = inflate_segments(
self.current_options_segments(security=security))
failed_segments = []
for segment in inflate_segments(segments):
# shareholder does not own this
if segment not in segments_owning:
failed_segments.append(segment)
return (len(failed_segments) == 0, deflate_segments(failed_segments),
deflate_segments(segments_owning))
def current_options_segments(self, security, optionplan=None, date=None):
"""
returns deflated segments which are owned by this shareholder.
includes segments blocked for options.
"""
date = date or datetime.datetime.now().date()
if optionplan:
qs_bought = self.option_buyer.filter(option_plan=optionplan)
qs_sold = self.option_seller.filter(option_plan=optionplan)
# all pos before date
qs_bought = self.option_buyer.filter(bought_at__lte=date)
qs_sold = self.option_seller.filter(bought_at__lte=date)
qs_bought = qs_bought.filter(option_plan__security=security)
qs_sold = qs_sold.filter(option_plan__security=security)
# -- flat list of bought items
segments_bought = qs_bought.values_list('number_segments', flat=True)
# flatten, unsorted with duplicates
segments_bought = [
segment for sublist in segments_bought for segment in sublist
]
# flat list of sold segments
segments_sold = qs_sold.values_list('number_segments', flat=True)
segments_sold = [
segment for sublist in segments_sold for segment in sublist
]
segments_owning = []
# inflate to have int only
segments_bought = inflate_segments(segments_bought)
segments_sold = inflate_segments(segments_sold)
counter_bought = Counter(segments_bought)
counter_sold = Counter(segments_sold)
# set as items can occur only once
segments_owning = set(counter_bought - counter_sold)
return deflate_segments(segments_owning)
def test_deflate_segments_performance(self):
"""
watch the end of deflation logic!
"""
segments = []
segments.extend(range(1, 1000001))
segments.extend([1500000, 1600000])
segments.extend(range(2000000, 8000001))
segments.extend([9000000])
t0 = time.clock()
res = deflate_segments(segments)
t1 = time.clock()
delta = t1 - t0
print("deflate list took {0:.4f} seconds.".format(t1 - t0))
self.assertEqual(
res, [u'1-1000000', 1500000, 1600000, u'2000000-8000000', 9000000])
if delta > 1.1:
logger.error(
'BUILD performance error: test_substract_list_performance',
extra={'delta': delta})
self.assertLess(delta, 1.5)
def current_segments(self, security, date=None):
"""
returns deflated segments which are owned by this shareholder.
includes segments blocked for options.
"""
logger.info('current items: starting')
date = date or datetime.datetime.now()
# all pos before date
qs_bought = self.buyer.filter(bought_at__lte=date)
qs_sold = self.seller.filter(bought_at__lte=date)
qs_bought = qs_bought.filter(security=security)
qs_sold = qs_sold.filter(security=security)
logger.info('current items: qs done')
# -- flat list of bought items
segments_bought = qs_bought.values_list('number_segments', flat=True)
# flatten, unsorted with duplicates
segments_bought = [
segment for sublist in segments_bought for segment in sublist
]
# flat list of sold segments
segments_sold = qs_sold.values_list('number_segments', flat=True)
segments_sold = [
segment for sublist in segments_sold for segment in sublist
]
logger.info('current items: flat lists done. inflating...')
segments_owning = []
# inflate to have int only
segments_bought = inflate_segments(segments_bought)
segments_sold = inflate_segments(segments_sold)
logger.info('current items: iterating through bought segments...')
segments_owning = substract_list(segments_bought, segments_sold)
logger.info('current items: finished')
return deflate_segments(segments_owning)