def __init__(self, data=None, user=None, *args, **kwargs):
super(XputStructureForm, self).__init__(data=data, *args, **kwargs)
more_choices = CompoundDatatype.choices(user)
self.fields['compounddatatype'].choices = [('', '--------'),
('__raw__', 'Unstructured')
] + more_choices
def __init__(self, data=None, files=None, user=None, *args, **kwargs):
super(ArchiveAddDatasetForm, self).__init__(data, files, *args,
**kwargs)
user_specific_choices = ([DatasetForm.RAW_CDT_CHOICE] +
CompoundDatatype.choices(user))
self.fields["compound_datatype"].choices = user_specific_choices
def set_structure(self, xput, column_datatype_ids):
if column_datatype_ids:
cdt = CompoundDatatype()
for datatype_id in column_datatype_ids:
cdt.members.add(
CompoundDatatypeMember(datatype=Datatype(id=datatype_id)))
xput.structure = XputStructure(compounddatatype=cdt)
def test_copy_io_from_parent_with_structure(self):
cdt = CompoundDatatype()
min_row = 1
max_row = 100
structure = XputStructure(compounddatatype=cdt,
min_row=min_row,
max_row=max_row)
parent = self.create_parent()
def get_structure(xput_self):
if xput_self.dataset_idx == 1:
return structure
# noinspection PyUnresolvedReferences
raise XputStructure.DoesNotExist
TransformationXput.structure = property(get_structure)
expected_inputs = {inp.dataset_idx for inp in parent.inputs}
expected_outputs = {out.dataset_idx for out in parent.outputs}
foo = Method(revision_parent=parent)
foo.copy_io_from_parent()
self.assertEqual(expected_inputs,
{inp.dataset_idx for inp in foo.inputs})
self.assertEqual(expected_outputs,
{out.dataset_idx for out in foo.outputs})
# noinspection PyUnresolvedReferences
create_args = XputStructure.objects.create.call_args_list # @UndefinedVariable
self.assertEqual(2, len(create_args))
_args, kwargs = create_args[0]
self.assertEqual(100, kwargs['max_row'])
def _get_compound_datatypes(request):
""" Get a sorted list of (name, id) pairs for compound datatypes. """
compound_datatypes = [
(cdt.name, cdt.pk)
for cdt in CompoundDatatype.filter_by_user(request.user)
]
compound_datatypes.sort()
return compound_datatypes
def create(self, validated_data):
"""
Create a CompoundDatatype from validated data.
"""
member_dictionaries = validated_data.pop("members", [])
users_allowed = validated_data.pop("users_allowed", [])
groups_allowed = validated_data.pop("groups_allowed", [])
cdt = CompoundDatatype(**validated_data)
cdt.save()
cdt.users_allowed.add(*users_allowed)
cdt.groups_allowed.add(*groups_allowed)
for member_dict in member_dictionaries:
member = CompoundDatatypeMember(compounddatatype=cdt, **member_dict)
member.save()
return cdt
def __init__(self, data=None, files=None, users_allowed=None, groups_allowed=None, user=None, *args, **kwargs):
super(DatasetForm, self).__init__(data, files, *args, **kwargs)
users_allowed = users_allowed or User.objects.all()
groups_allowed = groups_allowed or Group.objects.all()
self.fields["permissions"].set_users_groups_allowed(users_allowed, groups_allowed)
user_specific_choices = ([DatasetForm.RAW_CDT_CHOICE] +
CompoundDatatype.choices(user))
self.fields["compound_datatype"].choices = user_specific_choices
def create(self, validated_data):
"""
Create a CompoundDatatype from validated data.
"""
member_dictionaries = validated_data.pop("members", [])
users_allowed = validated_data.pop("users_allowed", [])
groups_allowed = validated_data.pop("groups_allowed", [])
cdt = CompoundDatatype(**validated_data)
cdt.save()
cdt.users_allowed.add(*users_allowed)
cdt.groups_allowed.add(*groups_allowed)
for member_dict in member_dictionaries:
member = CompoundDatatypeMember(compounddatatype=cdt,
**member_dict)
member.save()
return cdt
def __init__(self,
data=None,
files=None,
users_allowed=None,
groups_allowed=None,
user=None,
*args,
**kwargs):
super(DatasetForm, self).__init__(data, files, *args, **kwargs)
users_allowed = users_allowed or User.objects.all()
groups_allowed = groups_allowed or Group.objects.all()
self.fields["permissions"].set_users_groups_allowed(
users_allowed, groups_allowed)
user_specific_choices = ([DatasetForm.RAW_CDT_CHOICE] +
CompoundDatatype.choices(user))
self.fields["compound_datatype"].choices = user_specific_choices
def __init__(self, *args, **kwargs):
super(DatasetSerializer, self).__init__(*args, **kwargs)
self.fields["compounddatatype"].queryset = CompoundDatatype.filter_by_user(self.context["request"].user)
def __init__(self, *args, **kwargs):
super(DatasetSerializer, self).__init__(*args, **kwargs)
self.fields[
"compounddatatype"].queryset = CompoundDatatype.filter_by_user(
self.context["request"].user)
def __init__(self, data=None, files=None, user=None, *args, **kwargs):
super(ArchiveAddDatasetForm, self).__init__(data, files, *args, **kwargs)
user_specific_choices = ([DatasetForm.RAW_CDT_CHOICE] +
CompoundDatatype.choices(user))
self.fields["compound_datatype"].choices = user_specific_choices
def _get_compound_datatypes(request):
""" Get a sorted list of (name, id) pairs for compound datatypes. """
compound_datatypes = [(cdt.name, cdt.pk)
for cdt in CompoundDatatype.filter_by_user(request.user)]
compound_datatypes.sort()
return compound_datatypes
def __init__(self, data=None, user=None, *args, **kwargs):
super(XputStructureForm, self).__init__(data=data, *args, **kwargs)
more_choices = CompoundDatatype.choices(user)
self.fields['compounddatatype'].choices = [('', '--------'), ('__raw__', 'Unstructured')] + more_choices
def compound_datatype_add(request):
"""
Add CompoundDatatype from a dynamic set of CompoundDatatypeMember forms.
"""
c = {}
if request.method == 'POST':
# Create a parent CDT object so we can define its members.
dummy_cdt = CompoundDatatype(user=request.user)
cdt_form = CompoundDatatypeForm(request.POST, instance=dummy_cdt)
member_forms = make_cdm_forms(request, cdt=None)
try:
with transaction.atomic():
try:
if not cdt_form.is_valid():
# Note that this has already done all the hard work for us of annotating
# cdt_form with errors.
raise CDTDefException()
except ValidationError as e:
cdt_form.add_error(None, e)
raise CDTDefException()
compound_datatype = cdt_form.save()
compound_datatype.grant_from_json(
cdt_form.cleaned_data["permissions"])
compound_datatype.full_clean()
# Having reached here, we can now make proper forms.
member_forms = make_cdm_forms(request, compound_datatype)
all_good = True
for member_form in member_forms:
try:
if member_form.is_valid():
member_form.save()
else:
all_good = False
except ValidationError as e:
member_form.add_error(None, e)
raise e
if not all_good:
raise CDTDefException()
# If no name was specified, set its name to be its string representation.
# This only does anything if the name is blank.
compound_datatype.set_name()
compound_datatype.full_clean()
# Success!
return HttpResponseRedirect('/compound_datatypes')
except CDTDefException as e:
pass
except ValidationError as e:
cdt_form.add_error(None, e)
else:
# Make initial blank forms.
cdt_form = CompoundDatatypeForm()
member_forms = [
CompoundDatatypeMemberForm(user=request.user, auto_id='id_%s_0')
]
# Note that even if there were exceptions thrown the forms have been properly annotated with errors.
t = loader.get_template('metadata/compound_datatype_add.html')
c.update({
"cdt_form": cdt_form,
'cdm_forms': member_forms,
'first_form': member_forms and member_forms[0]
})
return HttpResponse(t.render(c, request))