def test_ParamFormField(self):
test_dict = {'rule': 'test', 'nd': 5, 'par_type': 'exit'}
params = params_exit.exit_test(**test_dict)
parameters = params.parameters
from django import forms
class ParamTestForm(forms.Form):
chars = forms.CharField()
params = ParamFormField(par_type='exit', parameters=parameters)
# empty form
ptf = ParamTestForm()
self.assertFalse(ptf.is_bound)
self.assertFalse(ptf.is_valid())
self.assertFalse(ptf.errors)
self.assertIn('value="20"', str(ptf['params']))
self.assertIn('value="test"', str(ptf['params']))
self.assertNotIn('value="exit"', str(ptf['params']))
# bound_form
ptf2 = ParamTestForm({'params_0': 'test', 'params_1': 5, 'chars': 'Hello'})
self.assertIsInstance(params, _Param)
self.assertTrue(ptf2.is_bound)
self.assertTrue(ptf2.is_valid())
self.assertFalse(ptf2.errors)
self.assertIsInstance(ptf2.cleaned_data['params'], _Param)
self.assertEqual(str2dict(unicode(ptf2.cleaned_data['params'])), str2dict(unicode(params)))
def make_system(self, parameters):
'''
Sets all parameters with variable ranges to fixed values. This turns
a MetaSystem into a system.
'''
self.build_structure()
self._set_variable_parameters(str2dict(parameters))
self._traverse_structure('initialise', pool=self.pool)
def test_custom_field(self):
test_dict = {'rule': 'test', 'nd': 5, 'par_type': 'exit'}
params = params_exit.exit_test(**test_dict)
pm = ParamModel.objects.create(params=params)
self.assertEqual(pm._meta.get_field('params').verbose_name, 'parameters')
self.assertEqual(pm.params._nd, 5)
self.assertEqual(pm.params.rule, 'test')
self.assertEqual(pm.params.par_type, 'exit')
pm1 = ParamModel.objects.get(pk=pm.pk)
self.assertIsInstance(pm1.params, _Param)
self.assertEqual(str2dict(unicode(pm1.params)), {'rule': 'test', 'nd': 5})
test_dict2 = {'rule': 'test', 'nd': 8, 'par_type': 'exit'}
params2 = params_exit.exit_test(**test_dict2)
self.assertQuerysetEqual(ParamModel.objects.filter(
params__in=[params, params2]), [{'rule': 'test', 'nd': 5}],
lambda qs: str2dict(unicode(qs.params)))
self.assertRaises(TypeError, lambda: ParamModel.objects.filter(
params__lt=params))
stream = serializers.serialize("json", ParamModel.objects.all())
self.assertEqual(stream, '[{"pk": %d, "model": "metasystem.parammodel", "fields": {"params": "ccollections\\nOrderedDict\\np1\\n((lp2\\n(lp3\\nS\'rule\'\\np4\\naS\'test\'\\np5\\naa(lp6\\nS\'nd\'\\np7\\naI5\\naatRp8\\n."}}]' % pm1.pk)
obj = list(serializers.deserialize("json", stream))[0]
self.assertEqual(obj.object, pm)
pm.delete()
test_dict = {'rule': 'test', 'nd': 5, 'par_type': 'exit'}
params = params_exit.exit_test(**test_dict)
pm1 = ParamModel.objects.create(params=params)
test_dict = {'rule': 'test', 'nd': 8, 'par_type': 'exit'}
params = params_exit.exit_test(**test_dict)
pm2 = ParamModel.objects.create(params=params)
self.assertQuerysetEqual(
ParamModel.objects.all(), [
{'rule': 'test', 'nd': 5},
{'rule': 'test', 'nd': 8},
],
lambda qs: str2dict(unicode(qs.params))
)
def get_params(self, method_from=None):
'''
Returns a dict with all parameters. If method_from and _to are
specified, the method id in the unique parameter name will be translated.
'''
param_dict = {}
for key, value in str2dict(self.params).items():
key1, unused, key2 = key.partition(' {}'.format(method_from.id))
param_dict['{} {}'.format(key1, key2)] = value
return param_dict
def test_ParamFormField_MODEL(self):
test_dict = {'rule': 'test', 'nd': 5, 'par_type': 'exit'}
params = params_exit.exit_test(**test_dict)
pm = ParamModel.objects.create(params=params)
parameters = params.parameters
from django import forms
class ParamTestForm(forms.ModelForm):
params = ParamFormField(par_type='exit', parameters=parameters)
class Meta:
model = ParamModel
# create an empty form
ptf = ParamTestForm()
self.assertFalse(ptf.is_bound)
self.assertFalse(ptf.is_valid())
self.assertFalse(ptf.errors)
self.assertIn('value="20"', str(ptf['params']))
self.assertIn('value="test"', str(ptf['params']))
self.assertNotIn('value="exit"', str(ptf['params']))
# create an unbound form
pm = ParamModel.objects.get(pk=pm.pk)
ptf2 = ParamTestForm(instance=pm)
self.assertFalse(ptf2.is_bound)
self.assertFalse(ptf2.errors)
self.assertIn('value="5"', str(ptf2['params']))
self.assertIn('value="test"', str(ptf2['params']))
self.assertNotIn('value="exit"', str(ptf2['params']))
# create an bound form
ptf2 = ParamTestForm({'params_0': 'test', 'params_1': 5, 'chars': 'Hello'})
self.assertIsInstance(params, _Param)
self.assertTrue(ptf2.is_bound)
self.assertTrue(ptf2.is_valid())
self.assertFalse(ptf2.errors)
self.assertIsInstance(ptf2.cleaned_data['params'], _Param)
self.assertEqual(str2dict(unicode(ptf2.cleaned_data['params'])), str2dict(unicode(params)))
def export_systems_to_csv(request, metasystem_id):
'''
View that returns csv files with all trades for this system/result.
'''
response = HttpResponse(mimetype='text/csv')
response['Content-Disposition'] = 'attachment;filename="results_{}.csv"'.\
format(metasystem_id)
results = System.objects.filter(metasystem=metasystem_id).values()
column_list = [k for k in OUTPUT_FORMATS]
column_list.extend(str2dict_keys(results[0]['params']))
writer = csv.DictWriter(response, column_list, extrasaction='ignore')
writer.writeheader()
for result in results:
result.update(str2dict(result['params']))
writer.writerow(result)
return response
def show_market_type(request):
'''
Market conditions page
'''
rs = None
message = ''
startdate = datetime.date(2010,1,1)
enddate = datetime.date.today()
data = None
if request.method == 'POST':
dateform = DateForm(request.POST, prefix='chart1')
if dateform.is_valid():
startdate = dateform.cleaned_data['startdate']
enddate = dateform.cleaned_data['enddate']
settingsform = ChartSettingsForm(request.POST)
if settingsform.is_valid():
data = settingsform.cleaned_data
settings = get_settings(data)
rs.set('market_conditions_settings', settings)
else:
settings = str2dict(rs.get('market_conditions_settings'))
if settings:
data = get_initial(settings)
settingsform = ChartSettingsForm(initial=data)
else:
settingsform = ChartSettingsForm()
dateform = DateForm(initial={'startdate': startdate, 'enddate': enddate},
prefix='chart1')
if data:
stock = data['symbol']
today = datetime.date.today()
# stock.set_prices(last_year(today), today)
current = '{} {}'.format(*get_market_condition(stock.price, today,
settings))
if stock.name[0] == '^':
symbol = '0' + stock.name[1:]
else:
symbol = stock.name
else:
symbol = None
current = None
return render(request, 'show_market.html',
{'symbol': symbol,
'dateform': dateform,
'settingsform': settingsform,
'current_condition': current,
'message': message})
def to_python(self, value):
'''
Converts a database value to a python object.
'''
if not value:
return
if isinstance(value, _Param):
return value
elif isinstance(value, unicode) and value.startswith('{'):
# This is to work with readable dict strings in admin
param_dict = str2dict(value)
else:
try:
param_dict = pickle.loads(str(value))
except:
raise TypeError('unable to process {}'.format(value))
param_dict['par_type'] = self.par_type
classname = '{}_{}'.format(self.par_type, param_dict['rule'])
return getattr(get_module(self.par_type), classname)(**param_dict)
def test_str2dict(self):
self.assertEqual(su.str2dict("{'a':1, 4:'asdf'}"), {'a':1, 4:'asdf'})
self.assertIsNone(su.str2dict("{'a':1 4:'asdf'}"))
self.assertIsNone(su.str2dict('raise SystemExit'))
self.assertIsNone(su.str2dict('(1,2,3)'))
