radarsys Commit - r272:8a3674516291 · Jicamarca Repository

Task #1119: bugs and jars_new_filter.html has been deleted...

Fiorella Quino -

r272:8a3674516291

parent child

Context file:

r272:8a3674516291

Collapse all files

apps/jars/forms.py +1 -1

             import os
             from django import forms
             from apps.main.models import Device, Experiment
             from .models import JARSConfiguration, JARSfilter
             from .widgets import SpectralWidget
             from apps.main.forms import add_empty_choice
             def create_choices_from_model(model, filter_id=None):
                 #instance = globals()[model]
                 choices = model.objects.all().values_list('pk', 'name')
                 choices = add_empty_choice(choices)
                 return choices
             class JARSConfigurationForm(forms.ModelForm):
                 def __init__(self, *args, **kwargs):
                     super(JARSConfigurationForm, self).__init__(*args, **kwargs)
                     instance = getattr(self, 'instance', None)
                     if instance and instance.pk:
                         devices = Device.objects.filter(device_type__name='jars')
                         if instance.experiment:
                             experiments = Experiment.objects.filter(pk=instance.experiment.id)
                             self.fields['experiment'].widget.choices = [(experiment.id, experiment) for experiment in experiments]
                         self.fields['device'].widget.choices = [(device.id, device) for device in devices]
                         #self.fields['spectral'].widget = SpectralWidget()
                     self.fields['spectral_number'].widget.attrs['readonly'] = True
                     self.fields['spectral'].widget = SpectralWidget()
                 #-------------JARS Configuration needs an Experiment-----------------
                 def clean(self):
                     cleaned_data = super(JARSConfigurationForm, self).clean()
                     experiment = cleaned_data.get('experiment')
                     if experiment == None:
                         msg = "Error: Jars Configuration needs an Experiment"
                         self.add_error('experiment', msg)
                 class Meta:
                     model = JARSConfiguration
                     exclude = ('type', 'parameters', 'status', 'filter_parms')
             class JARSfilterForm(forms.ModelForm):
                 def __init__(self, *args, **kwargs):
                     super(JARSfilterForm, self).__init__(*args, **kwargs)
                     instance = getattr(self, 'instance', None)
                     self.fields['fch_decimal'].widget.attrs['readonly'] = True
                     if 'initial' in kwargs:
                         if 'filter_id' not in kwargs['initial']:
                             self.fields.pop('name')
                         else:
                             self.fields['name'] = forms.ChoiceField(choices=create_choices_from_model(JARSfilter))
                             filter_id = kwargs['initial']['filter_id']
                             if filter_id == 0:
                                 for value in self.fields:
                                     if value != 'name':
                                         self.fields.pop(value)
                                 self.fields['name'].label = "Filter Template Name"
                             else:
                                 self.fields['name'] = forms.ChoiceField(choices=create_choices_from_model(JARSfilter, kwargs['initial']['filter_id']))
                                 jars_filter = JARSfilter.objects.get(pk=kwargs['initial']['filter_id'])
                                 labels = [f.name for f in jars_filter._meta.get_fields()]
-                                for label in ['id', 'jarsconfiguration']:
+                                for label in ['id']:
                                     labels.remove(label)
                                 for label in labels:
                                     self.fields['name'].initial = kwargs['initial']['filter_id']
                                     self.fields[label].initial = getattr(jars_filter,label)
                                 self.fields['name'].label = "Filter Template Name"
                 class Meta:
                     model = JARSfilter
                     exclude = ('type', 'parameters', 'status')
             class ExtFileField(forms.FileField):
                 """
                 Same as forms.FileField, but you can specify a file extension whitelist.
                 >>> from django.core.files.uploadedfile import SimpleUploadedFile
                 >>>
                 >>> t = ExtFileField(ext_whitelist=(".pdf", ".txt"))
                 >>>
                 >>> t.clean(SimpleUploadedFile('filename.pdf', 'Some File Content'))
                 >>> t.clean(SimpleUploadedFile('filename.txt', 'Some File Content'))
                 >>>
                 >>> t.clean(SimpleUploadedFile('filename.exe', 'Some File Content'))
                 Traceback (most recent call last):
                 ...
                 ValidationError: [u'Not allowed filetype!']
                 """
                 def __init__(self, *args, **kwargs):
                     extensions = kwargs.pop("extensions")
                     self.extensions = [i.lower() for i in extensions]
                     super(ExtFileField, self).__init__(*args, **kwargs)
                 def clean(self, *args, **kwargs):
                     data = super(ExtFileField, self).clean(*args, **kwargs)
                     filename = data.name
                     ext = os.path.splitext(filename)[1]
                     ext = ext.lower()
                     if ext not in self.extensions:
                         raise forms.ValidationError('Not allowed file type: %s' % ext)
             class JARSImportForm(forms.Form):
                 #file_name = ExtFileField(extensions=['.racp', '.json', '.dat'])
                 file_name = ExtFileField(extensions=['.json'])

apps/jars/models.py +1 -6

             import json
             import requests
             from django.db import models
             from django.core.validators import MinValueValidator, MaxValueValidator
             from django.core.urlresolvers import reverse
             from apps.main.models import Configuration
             from apps.main.utils import Params
             # Create your models here.
             EXPERIMENT_TYPE = (
                                (0, 'RAW_DATA'),
                                (1, 'PDATA'),
                                )
             DATA_TYPE = (
                          (0, 'SHORT'),
                          (1, 'FLOAT'),
                          )
             DECODE_TYPE = (
                          (0, 'None'),
                          (1, 'TimeDomain'),
                          (2, 'FreqDomain'),
                          (3, 'InvFreqDomain'),
                          )
             class JARSfilter(models.Model):
                 JARS_NBITS = 32
                 name        = models.CharField(max_length=60, unique=True, default='')
                 clock       = models.FloatField(verbose_name='Clock In (MHz)',validators=[MinValueValidator(5), MaxValueValidator(75)], null=True, default=60)
                 mult        = models.PositiveIntegerField(verbose_name='Multiplier',validators=[MinValueValidator(1), MaxValueValidator(20)], default=5)
                 fch         = models.FloatField(verbose_name='Frequency (MHz)', validators=[MaxValueValidator(150)], null=True, default=49.9200)
                 fch_decimal = models.BigIntegerField(verbose_name='Frequency (Decimal)',validators=[MinValueValidator(-9223372036854775808), MaxValueValidator(2**JARS_NBITS-1)], null=True, default=721554505)
                 filter_2    = models.PositiveIntegerField(verbose_name='Filter 2',validators=[MinValueValidator(2), MaxValueValidator(100)], default = 10)
                 filter_5    = models.PositiveIntegerField(verbose_name='Filter 5',validators=[MinValueValidator(1), MaxValueValidator(100)], default = 1)
                 filter_fir  = models.PositiveIntegerField(verbose_name='FIR Filter',validators=[MinValueValidator(1), MaxValueValidator(100)], default = 6)
                 class Meta:
                     db_table = 'jars_filters'
                 def __unicode__(self):
                     return u'%s' % (self.name)
                 def parms_to_dict(self):
                     parameters = {}
                     #parameters['name']        = self.name
                     parameters['clock']       = float(self.clock)
                     parameters['mult']        = int(self.mult)
                     parameters['fch']         = float(self.fch)
                     parameters['fch_decimal'] = int(self.fch)
                     parameters['filter_fir']  = int(self.filter_fir)
                     parameters['filter_2']    = int(self.filter_2)
                     parameters['filter_5']    = int(self.filter_5)
                     return parameters
                 def dict_to_parms(self, parameters):
                     #self.name        = parameters['name']
                     self.clock       = parameters['clock']
                     self.mult        = parameters['mult']
                     self.fch         = parameters['fch']
                     self.fch_decimal = parameters['fch_decimal']
                     self.filter_fir  = parameters['filter_fir']
                     self.filter_2    = parameters['filter_2']
                     self.filter_5    = parameters['filter_5']
             class JARSConfiguration(Configuration):
                 ADC_RESOLUTION   = 8
                 PCI_DIO_BUSWIDTH = 32
                 HEADER_VERSION   = 1103
                 BEGIN_ON_START   = True
                 REFRESH_RATE     = 1
                 exp_type         = models.PositiveIntegerField(verbose_name='Experiment Type', choices=EXPERIMENT_TYPE, default=0)
                 cards_number     = models.PositiveIntegerField(verbose_name='Number of Cards', validators=[MinValueValidator(1), MaxValueValidator(4)], default = 1)
                 channels_number  = models.PositiveIntegerField(verbose_name='Number of Channels', validators=[MinValueValidator(1), MaxValueValidator(8)], default = 5)
                 channels         = models.CharField(verbose_name='Channels', max_length=15, default = '1,2,3,4,5')
                 data_type        = models.PositiveIntegerField(verbose_name='Data Type', choices=DATA_TYPE, default=0)
                 raw_data_blocks  = models.PositiveIntegerField(verbose_name='Raw Data Blocks', validators=[MaxValueValidator(5000)], default=60)
                 profiles_block   = models.PositiveIntegerField(verbose_name='Profiles Per Block', default=400)
                 acq_profiles     = models.PositiveIntegerField(verbose_name='Acquired Profiles', default=400)
                 ftp_interval     = models.PositiveIntegerField(verbose_name='FTP Interval', default=60)
                 fftpoints        = models.PositiveIntegerField(verbose_name='FFT Points',default=16)
                 cohe_integr_str  = models.PositiveIntegerField(verbose_name='Coh. Int. Stride',validators=[MinValueValidator(1)], default=30)
                 cohe_integr      = models.PositiveIntegerField(verbose_name='Coherent Integrations',validators=[MinValueValidator(1)], default=30)
                 incohe_integr    = models.PositiveIntegerField(verbose_name='Incoherent Integrations',validators=[MinValueValidator(1)], default=30)
                 decode_data      = models.PositiveIntegerField(verbose_name='Decode Data', choices=DECODE_TYPE, default=0)
                 post_coh_int     = models.BooleanField(verbose_name='Post Coherent Integration', default=False)
-                filter           = models.ForeignKey(JARSfilter, on_delete=models.CASCADE, null=True)
                 spectral_number  = models.PositiveIntegerField(verbose_name='# Spectral Combinations',validators=[MinValueValidator(1)], default=1)
                 spectral         = models.CharField(verbose_name='Combinations', max_length=5000, default = '[0, 0],')
                 create_directory = models.BooleanField(verbose_name='Create Directory Per Day', default=True)
                 include_expname  = models.BooleanField(verbose_name='Experiment Name in Directory', default=False)
                 #view_raw_data    = models.BooleanField(verbose_name='View Raw Data', default=True)
                 save_ch_dc       = models.BooleanField(verbose_name='Save Channels DC', default=True)
                 save_data        = models.BooleanField(verbose_name='Save Data', default=True)
-                filter_parms     = models.CharField(max_length=10000, default='{"name": "49_92MHz_clock60MHz_F1KHz_12_25_2", "clock": 60, "mult": 5, "fch": 49.92, "fch_decimal":	721554506, "filter_fir": 2, "filter_2": 12, "filter_5": 25}, "model": "jars.jarsfilter", "pk": 1}')
+                filter_parms     = models.CharField(max_length=10000, default='{"clock": 60, "mult": 5, "fch": 49.92, "fch_decimal":	721554506, "filter_fir": 2, "filter_2": 12, "filter_5": 25}, "model": "jars.jarsfilter", "pk": 1}')
                 class Meta:
                     db_table = 'jars_configurations'
-                def add_parms_to_filter(self):
-                    self.filter_parms = self.filter.parms_to_dict()
-                    self.save()
                 def filter_resolution(self):
                     filter_parms = eval(self.filter_parms)
                     if filter_parms.__class__.__name__=='str':
                         filter_parms = eval(filter_parms)
                     filter_clock = filter_parms['clock']
                     filter_2 = filter_parms['filter_2']
                     filter_5 = filter_parms['filter_5']
                     filter_fir = filter_parms['filter_fir']
                     resolution = round((filter_clock/(filter_2*filter_5*filter_fir)),2)
                     return resolution
                 def dict_to_parms(self, params, id=None):
                     if id is not None:
                         data = Params(params).get_conf(id_conf=id)
                     else:
                         data = Params(params).get_conf(dtype='jars')
                     self.name           = data['name']
                     self.exp_type        = data['exp_type']
                     #if data['exp_type'] in (1, '1') :
                     self.incohe_integr   = data['incohe_integr']
                     self.spectral_number = data['spectral_number']
                     self.spectral        = data['spectral']
                     #self.pd_directory    = data['pd_directory']
                     self.cards_number    = data['cards_number']
                     self.channels_number = data['channels_number']
                     self.channels        = data['channels']
                     #self.rd_directory    = data['rd_directory']
                     #self.raw_data_blocks = data['raw_data_blocks']
                     self.data_type       = data['data_type']
                     self.cohe_integr_str = data['cohe_integr_str']
                     self.acq_profiles    = data['acq_profiles']
                     self.profiles_block  = data['profiles_block']
                     self.ftp_interval    = data['ftp_interval']
                     self.fftpoints       = data['fftpoints']
                     self.cohe_integr     = data['cohe_integr']
                     self.filter_parms = json.dumps(data['filter_parms'])
                     self.create_directory = data['create_directory']
                     self.include_expname  = data['include_expname']
                     #self.acq_link         = data['acq_link']
                     #self.view_raw_data    = data['view_raw_data']
                     self.save_ch_dc       = data['save_ch_dc']
                     self.save_data        = data['save_data']
                     self.save()
                 def request(self, cmd, method='get', **kwargs):
                     req = getattr(requests, method)(self.device.url(cmd), **kwargs)
                     payload = req.json()
                     return payload
                 def status_device(self):
                     try:
                         payload = self.request('status',
                                                params={'name': self.experiment.name})
                         self.device.status = payload['status']
                         self.device.save()
                         self.message = payload['message']
                     except Exception as e:
                         self.device.status = 0
                         self.message = str(e)
                         self.device.save()
                         return False
                     return True
                 def stop_device(self):
                     try:
                         payload = self.request('stop', 'post')
                         self.device.status = payload['status']
                         self.device.save()
                         self.message = payload['message']
                     except Exception as e:
                         self.device.status = 0
                         self.message = str(e)
                         self.device.save()
                         return False
                     return True
                 def read_device(self):
                     try:
                         payload = self.request('read', params={'name': self.experiment.name})
                         self.message = 'Configuration loaded'
                     except:
                         self.device.status = 0
                         self.device.save()
                         self.message = 'Could not read JARS configuration.'
                         return False
                     return payload
                 def write_device(self):
                     if self.device.status == 3:
                         self.message = 'Could not configure device. Software Acquisition is running'
                         return False
                     data = self.experiment.parms_to_dict()
                     for key in data['configurations']['allIds']:
                         if data['configurations']['byId'][key]['device_type'] in ('dds', 'cgs'):
                             data['configurations']['allIds'].remove(key)
                             data['configurations']['byId'].pop(key)
                         elif data['configurations']['byId'][key]['device_type'] == 'jars':
                             data['configurations']['byId'][key] = self.parms_to_dict()['configurations']['byId'][str(self.pk)]
                         elif data['configurations']['byId'][key]['device_type'] == 'rc':
                                 data['configurations']['byId'][key]['pulses'] = ''
                                 data['configurations']['byId'][key]['delays'] = ''
                     rc_ids = [pk for pk in data['configurations']['allIds'] if data['configurations']['byId'][pk]['device_type']=='rc']
                     mix_ids = [pk for pk in rc_ids if data['configurations']['byId'][pk]['mix']]
                     if mix_ids:
                         params = data['configurations']['byId'][mix_ids[0]]['parameters']
                         rc = data['configurations']['byId'][params.split('-')[0].split('|')[0]]
                         rc['mix'] = True
                         data['configurations']['byId'][rc['id']] = rc
                     elif len(rc_ids)==0:
                         self.message = 'Missing RC configuration'
                         return False
                     json_data = json.dumps(data)
                     print json_data
                     try:
                         payload = self.request('write', 'post', json=json_data)
                         self.device.status = payload['status']
                         self.message = payload['message']
                         self.device.save()
                         if self.device.status == 1:
                             return False
                     except Exception as e:
                         self.device.status = 0
                         self.message = str(e)
                         self.device.save()
                         return False
                     return True
                 def start_device(self):
                     try:
                         payload = self.request('start', 'post',
                                                json={'name': self.experiment.name})
                         self.device.status = payload['status']
                         self.message = payload['message']
                         self.device.save()
                         if self.device.status == 1:
                             return False
                     except Exception as e:
                         self.device.status = 0
                         self.message = str(e)
                         self.device.save()
                         return False
                     return True
                 def update_from_file(self, filename):
                     f = JARSFile(filename)
                     self.dict_to_parms(f.data)
                     self.save()
                 def get_absolute_url_import(self):
                     return reverse('url_import_jars_conf', args=[str(self.id)])
                 def get_absolute_url_read(self):
                     return reverse('url_read_jars_conf', args=[str(self.id)])

apps/jars/views.py +2 -2

             from django.shortcuts import render_to_response
             from django.template import RequestContext
             from django.shortcuts import redirect, render, get_object_or_404
             from django.contrib import messages
             from apps.main.models import Device
             from apps.main.views import sidebar
             from .models import JARSConfiguration, JARSfilter
             from .forms import JARSConfigurationForm, JARSfilterForm, JARSImportForm
             import json
             # Create your views here.
             def jars_conf(request, id_conf):
                 conf = get_object_or_404(JARSConfiguration, pk=id_conf)
                 filter_parms = eval(conf.filter_parms)
                 if filter_parms.__class__.__name__=='str':
                     filter_parms = eval(filter_parms)
                 kwargs = {}
                 kwargs['filter'] = filter_parms
                 kwargs['filter_keys']  = ['clock', 'mult', 'fch', 'fch_decimal',
                                             'filter_fir', 'filter_2', 'filter_5']
                 filter_resolution=conf.filter_resolution()
                 kwargs['resolution'] = '{} (MHz)'.format(filter_resolution)
                 if filter_resolution < 1:
                     kwargs['resolution'] = '{} (kHz)'.format(filter_resolution*1000)
                 kwargs['status'] = conf.device.get_status_display()
                 kwargs['dev_conf'] = conf
                 kwargs['dev_conf_keys'] = ['name',
                                            'cards_number', 'channels_number', 'channels',
                                            #'rd_directory', 'pd_directory',
                                            'data_type',
                                            'acq_profiles', 'profiles_block', 'raw_data_blocks', 'ftp_interval', 'fftpoints',
                                            'cohe_integr_str', 'decode_data',
                                            'incohe_integr', 'cohe_integr', 'spectral_number',
                                            'spectral', 'create_directory', 'include_expname',
                                            'save_ch_dc', 'save_data']
                 kwargs['title'] = 'JARS Configuration'
                 kwargs['suptitle'] = 'Details'
                 kwargs['button'] = 'Edit Configuration'
                 #kwargs['no_play'] = True
                 #kwargs['only_stop'] = True
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 return render(request, 'jars_conf.html', kwargs)
             def jars_conf_edit(request, id_conf):
                 conf = get_object_or_404(JARSConfiguration, pk=id_conf)
                 filter_parms = eval(conf.filter_parms)
                 if filter_parms.__class__.__name__=='str':
                     filter_parms = eval(filter_parms)
                 if request.method=='GET':
                     form = JARSConfigurationForm(instance=conf)
                     filter_form = JARSfilterForm(initial=filter_parms)
                 if request.method=='POST':
                     form = JARSConfigurationForm(request.POST, instance=conf)
                     filter_form = JARSfilterForm(request.POST)
                     if filter_form.is_valid():
                         jars_filter = filter_form.cleaned_data
                         try:
                             jars_filter.pop('name')
                         except:
                             pass
                     if form.is_valid():
                         conf = form.save(commit=False)
                         conf.filter_parms = json.dumps(jars_filter)
                         conf.save()
                         return redirect('url_jars_conf', id_conf=conf.id)
                 kwargs = {}
                 kwargs['id_dev'] = conf.id
                 kwargs['form'] = form
                 kwargs['filter_form'] = filter_form
                 kwargs['title'] = 'Device Configuration'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Save'
                 return render(request, 'jars_conf_edit.html', kwargs)
             def import_file(request, conf_id):
                 conf = get_object_or_404(JARSConfiguration, pk=conf_id)
                 if request.method=='POST':
                     form = JARSImportForm(request.POST, request.FILES)
                     if form.is_valid():
                         #try:
                         if True:
                             data = conf.import_from_file(request.FILES['file_name'])
                             conf.dict_to_parms(data)
                             messages.success(request, 'Configuration "%s" loaded succesfully' % request.FILES['file_name'])
                             return redirect(conf.get_absolute_url_edit())
                         #except Exception as e:
                         #    messages.error(request, 'Error parsing file: "%s" - %s' % (request.FILES['file_name'], e))
                 else:
                     messages.warning(request, 'Your current configuration will be replaced')
                     form = JARSImportForm()
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'JARS Configuration'
                 kwargs['suptitle'] = 'Import file'
                 kwargs['button'] = 'Upload'
                 kwargs['previous'] = conf.get_absolute_url()
                 return render(request, 'jars_import.html', kwargs)
             def read_conf(request, conf_id):
                 conf   = get_object_or_404(JARSConfiguration, pk=conf_id)
                 #filter = get_object_or_404(JARSfilter, pk=filter_id)
                 if request.method=='GET':
                     parms = conf.read_device()
                     conf.status_device()
                     if not parms:
                         messages.error(request, conf.message)
                         return redirect(conf.get_absolute_url())
                     form = JARSConfigurationForm(initial=parms, instance=conf)
                 if request.method=='POST':
                     form = JARSConfigurationForm(request.POST, instance=conf)
                     if form.is_valid():
                         form.save()
                         return redirect(conf.get_absolute_url())
                     messages.error(request, "Parameters could not be saved")
                 kwargs = {}
                 kwargs['id_dev'] = conf.id
                 kwargs['filter_id'] = conf.filter.id
                 kwargs['form'] = form
                 kwargs['title'] = 'Device Configuration'
                 kwargs['suptitle'] = 'Parameters read from device'
                 kwargs['button'] = 'Save'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 return render(request, 'jars_conf_edit.html', kwargs)
             def change_filter(request, conf_id, filter_id=None):
                 conf = get_object_or_404(JARSConfiguration, pk=conf_id)
                 if filter_id:
                     if filter_id.__class__.__name__ not in ['int', 'float']:
                         filter_id = eval(filter_id)
                 if filter_id == 0:
                     return redirect('url_change_jars_filter', conf_id=conf.id)
                 if request.method=='GET':
                     if not filter_id:
-                        form = JARSfilterForm(initial={'jars_configuration':conf_id, 'filter_id': 0})
+                        form = JARSfilterForm(initial={'filter_id': 0})
                     else:
-                        form = JARSfilterForm(initial={'jars_configuration':conf_id, 'filter_id': filter_id})
+                        form = JARSfilterForm(initial={'filter_id': filter_id})
                 if request.method=='POST':
                     form = JARSfilterForm(request.POST)
                     if form.is_valid():
                         jars_filter = form.cleaned_data
                         try:
                             jars_filter.pop('name')
                         except:
                             pass
                         conf.filter_parms = json.dumps(jars_filter)
                         conf.save()
                         return redirect('url_edit_jars_conf', id_conf=conf.id)
                     else:
                         messages.error(request, "Select a Filter Template")
                         return redirect('url_change_jars_filter', conf_id=conf.id)
                 kwargs = {}
                 kwargs['title'] = 'JARS Configuration'
                 kwargs['suptitle'] = 'Change Filter'
                 kwargs['form'] = form
                 kwargs['button'] = 'Change'
                 kwargs['conf_id'] = conf.id
                 kwargs['filter_id'] = filter_id
                 return render(request, 'change_jars_filter.html', kwargs)

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages