def test_simple_mergedict(self):
d1 = {
'chris': 'cool',
'camri': 'cute',
'cotton': 'adorable',
'tulip': 'snuggable',
'twoofme': 'firstone'
}
d2 = {
'chris2': 'cool2',
'camri2': 'cute2',
'cotton2': 'adorable2',
'tulip2': 'snuggable2'
}
d3 = {
'chris3': 'cool3',
'camri3': 'cute3',
'cotton3': 'adorable3',
'tulip3': 'snuggable3'
}
md = MergeDict(d1, d2, d3)
self.assertEqual(md['chris'], 'cool')
self.assertEqual(md['camri'], 'cute')
self.assertEqual(md['twoofme'], 'firstone')
md2 = md.copy()
self.assertEqual(md2['chris'], 'cool')
def test_mergedict_merges_multivaluedict(self):
""" MergeDict can merge MultiValueDicts """
multi1 = MultiValueDict({"key1": ["value1"], "key2": ["value2", "value3"]})
multi2 = MultiValueDict({"key2": ["value4"], "key4": ["value5", "value6"]})
mm = MergeDict(multi1, multi2)
# Although 'key2' appears in both dictionaries,
# only the first value is used.
self.assertEqual(mm.getlist("key2"), ["value2", "value3"])
self.assertEqual(mm.getlist("key4"), ["value5", "value6"])
self.assertEqual(mm.getlist("undefined"), [])
self.assertEqual(sorted(six.iterkeys(mm)), ["key1", "key2", "key4"])
self.assertEqual(len(list(six.itervalues(mm))), 3)
self.assertIn("value1", six.itervalues(mm))
self.assertEqual(
sorted(six.iteritems(mm), key=lambda k: k[0]), [("key1", "value1"), ("key2", "value3"), ("key4", "value6")]
)
self.assertEqual(
[(k, mm.getlist(k)) for k in sorted(mm)],
[("key1", ["value1"]), ("key2", ["value2", "value3"]), ("key4", ["value5", "value6"])],
)
def test_mergedict_merges_multivaluedict(self):
""" MergeDict can merge MultiValueDicts """
multi1 = MultiValueDict({
'key1': ['value1'],
'key2': ['value2', 'value3']
})
multi2 = MultiValueDict({
'key2': ['value4'],
'key4': ['value5', 'value6']
})
mm = MergeDict(multi1, multi2)
# Although 'key2' appears in both dictionaries,
# only the first value is used.
self.assertEqual(mm.getlist('key2'), ['value2', 'value3'])
self.assertEqual(mm.getlist('key4'), ['value5', 'value6'])
self.assertEqual(mm.getlist('undefined'), [])
self.assertEqual(sorted(six.iterkeys(mm)), ['key1', 'key2', 'key4'])
self.assertEqual(len(list(six.itervalues(mm))), 3)
self.assertTrue('value1' in six.itervalues(mm))
self.assertEqual(sorted(six.iteritems(mm), key=lambda k: k[0]),
[('key1', 'value1'), ('key2', 'value3'),
('key4', 'value6')])
self.assertEqual([(k, mm.getlist(k)) for k in sorted(mm)],
[('key1', ['value1']), ('key2', ['value2', 'value3']),
('key4', ['value5', 'value6'])])
def test_mergedict_merges_multivaluedict(self):
""" MergeDict can merge MultiValueDicts """
multi1 = MultiValueDict({'key1': ['value1'],
'key2': ['value2', 'value3']})
multi2 = MultiValueDict({'key2': ['value4'],
'key4': ['value5', 'value6']})
mm = MergeDict(multi1, multi2)
# Although 'key2' appears in both dictionaries,
# only the first value is used.
self.assertEqual(mm.getlist('key2'), ['value2', 'value3'])
self.assertEqual(mm.getlist('key4'), ['value5', 'value6'])
self.assertEqual(mm.getlist('undefined'), [])
self.assertEqual(sorted(six.iterkeys(mm)), ['key1', 'key2', 'key4'])
self.assertEqual(len(list(six.itervalues(mm))), 3)
self.assertTrue('value1' in six.itervalues(mm))
self.assertEqual(sorted(six.iteritems(mm), key=lambda k: k[0]),
[('key1', 'value1'), ('key2', 'value3'),
('key4', 'value6')])
self.assertEqual([(k,mm.getlist(k)) for k in sorted(mm)],
[('key1', ['value1']),
('key2', ['value2', 'value3']),
('key4', ['value5', 'value6'])])
def test_simple_mergedict(self):
d1 = {"chris": "cool", "camri": "cute", "cotton": "adorable", "tulip": "snuggable", "twoofme": "firstone"}
d2 = {"chris2": "cool2", "camri2": "cute2", "cotton2": "adorable2", "tulip2": "snuggable2"}
d3 = {"chris3": "cool3", "camri3": "cute3", "cotton3": "adorable3", "tulip3": "snuggable3"}
md = MergeDict(d1, d2, d3)
self.assertEqual(md["chris"], "cool")
self.assertEqual(md["camri"], "cute")
self.assertEqual(md["twoofme"], "firstone")
md2 = md.copy()
self.assertEqual(md2["chris"], "cool")
def _fetch(self, params, required, defaults):
"""Make the NVP request and store the response."""
defaults.update(params)
pp_params = self._check_and_update_params(required, defaults)
pp_string = self.signature + urlencode(pp_params)
response = self._request(pp_string)
response_params = self._parse_response(response)
# log.info( 'PayPal Request:%s\nPayPal Response:%s'%
# (pprint.pformat(defaults),pprint.pformat(response_params)))
# Gather all NVP parameters to pass to a new instance.
nvp_params = {}
for k, v in MergeDict(defaults, response_params).items():
if k in NVP_FIELDS:
nvp_params[str(k)] = v
# PayPal timestamp has to be formatted.
if 'timestamp' in nvp_params:
nvp_params['timestamp'] = paypaltime2datetime(
nvp_params['timestamp'])
nvp_obj = PayPalNVP(**nvp_params)
nvp_obj.init(self.request, params, response_params)
nvp_obj.custom = params.get('PAYMENTREQUEST_0_CUSTOM', '')
nvp_obj.save()
return nvp_obj
def import_excel(request,
FormClass=ImportExcelForm,
template_name='import_excel/import_excel.html',
with_good=True,
next_url='.'):
comment_initial = {'comment': 'Imported %s' % datetime.datetime.now()}
form = FormClass(data=request.POST or None,
files=request.FILES or None,
initial=comment_initial)
form_class_name = FormClass.__name__
extra_context = {}
if form.is_valid():
cleaned_data = form.cleaned_data
try:
converted_data = form.get_converted_data(cleaned_data)
except Exception, e:
error_message = u'Error with excel file: %s' % str(e)
form.errors['excel_file'] = ErrorList([error_message])
else:
if not with_good or form.cleaned_data['is_good']:
form.update_callback(request, converted_data)
messages.success(request, 'Excel Data is succefully imported')
next_url = request.GET.get('next', next_url) or '.'
return redirect(next_url)
initial = MergeDict(comment_initial, {
'converted_data': json.dumps(converted_data),
}, cleaned_data)
form = FormClass(initial=initial)
form.fields['is_good'].widget = forms.CheckboxInput()
form.fields['excel_file'].widget = forms.HiddenInput()
extra_context['converted_data'] = converted_data
def __init__(self, **attrs):
# Compiling group regex ...
if not "regex" in attrs:
# warn("Account type doesn't declare group regex, using slug value.")
attrs["regex"] = "^%s$" % attrs['slug']
attrs["regex"] = re.compile(attrs["regex"])
# ... and assigning default values.
defaults = {"login_required": False,
"_account_form": "platforms.mt4.forms.Mt4AccountForm",
"_profile_form": "profiles.forms.BriefProfileForm",
"agreements": ['client_agreement', 'risk_disclosure', 'order_execution_policy'],
"notification_name": "account_created",
"group_choices": {},
"available_options": HAS_NO_OPTIONS,
"can_change_leverage": False,
'engine': 'default',
'is_ib_account': False,
'min_deposit': 0,
'max_per_user': 5, # How many active accounts of this type can a single user have
'no_inout': False, # In/Out operations for this account should be disabled
'creation_callback': None, # Allows to specify a callback function executed after account creation
"leverage_choices": (100, 75, 66, 50, 33, 25, 20, 15, 10, 5, 3, 2, 1)}
defaults.update( # Note: the rest default to None.
dict.fromkeys(["deposit", "group", "leverage_default"]))
for attr, value in MergeDict(attrs, defaults).iteritems():
setattr(self, attr, value)
self.__class__.register[self.slug] = self
def process_request(self, request):
request.DATA = {}
# for key in request.GET:
# request.DATA[key] = request.GET[key]
# for key in request.POST:
# request.DATA[key] = request.POST[key]
# for key in request.FILES:
# request.DATA[key] = request.FILES[key]
request.DATA = MergeDict(request.REQUEST, request.FILES)
j_data = {}
try:
if request.body and request.body[0] in ['[', '{']:
j_data = json.loads(request.body)
except:
pass
if j_data:
request.json = j_data
return
j_data = {}
for key in request.DATA.keys():
arr = key.split('.')
tmp = j_data
for k in arr[:-1]:
if k not in tmp:
tmp[k] = {}
tmp = tmp[k]
j = None
tmp[arr[-1]] = request.DATA[key]
request.json = j_data
def _fetch(self, params, required, defaults):
"""Make the NVP request and store the response."""
defaults.update(params)
pp_params = self._check_and_update_params(required, defaults)
pp_string = self.signature + urlencode(pp_params)
response = self._request(pp_string)
response_params = self._parse_response(response)
if getattr(settings, 'PAYPAL_DEBUG', settings.DEBUG):
print 'PayPal Request:'
pprint.pprint(defaults)
print '\nPayPal Response:'
pprint.pprint(response_params)
# Gather all NVP parameters to pass to a new instance.
nvp_params = {}
for k, v in MergeDict(defaults, response_params).items():
if k in NVP_FIELDS:
nvp_params[str(k)] = v
# PayPal timestamp has to be formatted.
if 'timestamp' in nvp_params:
nvp_params['timestamp'] = paypaltime2datetime(
nvp_params['timestamp'])
nvp_obj = PayPalNVP(**nvp_params)
nvp_obj.init(self.request, params, response_params)
nvp_obj.save()
return nvp_obj
def test_key_error(self):
"""
Test that the message of KeyError contains the missing key name.
"""
d1 = MergeDict({'key1': 42})
with six.assertRaisesRegex(self, KeyError, 'key2'):
d1['key2']
def node_annotation_edit(request, node_id, node_slug):
"""
Node Annotation Edit
"""
node = get_object_or_404(Node, pk=node_id)
if node.slug != node_slug:
return HttpResponseRedirect(
reverse('node_annotation_edit',
kwargs={
'node_id': node_id,
'node_slug': node.slug
}))
if not request.user.has_openode_perm('node_edit_annotation', node):
return render_forbidden(request)
text = getattr(node.description, "text", u"")
data = {"text": text} if text else None
if request.method == "POST":
data = MergeDict(request.POST, data)
form = NodeAnnotationEditForm(data=data, node=node)
if form.is_valid():
text = form.cleaned_data["text"]
# edit
if node.description:
node.description.apply_edit(edited_by=request.user, text=text)
# create new one
else:
post = Post.objects.create_new(
thread=None,
author=request.user,
added_at=datetime.now(),
text=text,
post_type="node_description",
)
post.save()
node.description = post
node.save()
request.user.message_set.create(
message=_('Node annotation has been succesfully saved.'))
return HttpResponseRedirect(
reverse('node_annotation_edit', args=[node.pk, node.slug]))
else:
form = NodeAnnotationEditForm(data=data, node=node)
template_data = {
'node': node,
'form': form,
'page_class': 'node-edit',
}
return render_into_skin('node/annotation/edit.html', template_data,
request)
def test_simple_mergedict(self):
d1 = {'chris': 'cool', 'camri': 'cute', 'cotton': 'adorable',
'tulip': 'snuggable', 'twoofme': 'firstone'}
d2 = {'chris2': 'cool2', 'camri2': 'cute2', 'cotton2': 'adorable2',
'tulip2': 'snuggable2'}
d3 = {'chris3': 'cool3', 'camri3': 'cute3', 'cotton3': 'adorable3',
'tulip3': 'snuggable3'}
md = MergeDict(d1, d2, d3)
self.assertEqual(md['chris'], 'cool')
self.assertEqual(md['camri'], 'cute')
self.assertEqual(md['twoofme'], 'firstone')
md2 = md.copy()
self.assertEqual(md2['chris'], 'cool')
def test__get_request(self):
wsgi_r = WsgiHttpRequest()
expected_items = MergeDict({}, {}).items()
wsgi_r.GET = {}
wsgi_r.POST = {}
self.assertListEqual(sorted(expected_items),
sorted(wsgi_r._get_request().items()))
def test__get_request(self):
from django.utils.datastructures import MergeDict
wsgi_r = WsgiHttpRequest()
expected_items = MergeDict({}, {}).items()
wsgi_r.GET = {}
wsgi_r.POST = {}
self.assertListEqual(sorted(expected_items),
sorted(wsgi_r._get_request().items()))
class PreviousSubmissionsView(HTMLView, RedisView, ErrorCatchingView):
error_template_names = MergeDict({httplib.FORBIDDEN: 'dataset/403'},
ErrorCatchingView.error_template_names)
@method_decorator(login_required)
def dispatch(self, request):
return super(PreviousSubmissionsView, self).dispatch(request)
def common(self, request):
path = request.REQUEST.get('path')
if not path:
raise Http404
path_parts = path.rstrip('/').split('/')
path_on_disk = os.path.normpath(
os.path.join(settings.DATA_DIRECTORY, *path_parts))
try:
permissions = get_permissions(path_on_disk,
request.user.username,
check_prefixes=True)
except IOError, e:
if e.errno == errno.ENOENT:
raise Http404
elif e.errno == errno.EACCES:
raise PermissionDenied
raise
if posix1e.ACL_WRITE not in permissions:
raise PermissionDenied
previous_submissions = DatasetSubmission.objects.filter(
path_on_disk=path_on_disk)
if 'id' in request.REQUEST:
dataset_submission = get_object_or_404(
DatasetSubmission,
id=request.REQUEST['id'],
status='new',
submitting_user=request.user)
else:
dataset_submission = DatasetSubmission(
path_on_disk=path_on_disk, submitting_user=request.user)
form = forms.DatasetSubmissionForm(request.POST or None,
instance=dataset_submission)
return {
'path': path,
'form': form,
'path_on_disk': path_on_disk,
'previous_submissions': previous_submissions,
'dataset_submission': dataset_submission,
'queued': request.GET.get('queued') == 'true'
}
def tinyurl(request, base_62):
base_62 = base62.to_decimal(base_62)
link = get_object_or_404(Link, pk=base_62)
REQUEST = {'url': link.url,
'server': 1,
'username': settings.PUBLIC_USER,
'password': settings.PUBLIC_PASSWORD}
REQUEST = MergeDict(REQUEST, request.REQUEST)
dummy_request = DummyHttpRequest(REQUEST, request.session, request.method)
to_return = webclient_login(dummy_request)
conn = getBlitzConnection(dummy_request, useragent="OMERO.web")
conn.changeActiveGroup(link.group)
return to_return
def auth_complete(self, *args, **kwargs):
"""Yammer API is a little strange"""
if 'error' in self.data:
logging.error("%s: %s:\n%s" %
(self.data('error'), self.data('error_reason'),
self.data('error_description')))
raise AuthCanceled(self)
# now we need to clean up the data params
data = dict(self.data.copy())
redirect_state = data.get('redirect_state')
if redirect_state and '?' in redirect_state:
redirect_state, extra = redirect_state.split('?', 1)
extra = parse_qs(extra)
data['redirect_state'] = redirect_state
if 'code' in extra:
data['code'] = extra['code'][0]
self.data = MergeDict(data)
return super(YammerOAuth2, self).auth_complete(*args, **kwargs)
class IndexView(BaseBrowseView):
data_directory = None
error_template_names = MergeDict({httplib.FORBIDDEN: 'browse/403'},
ErrorCatchingView.error_template_names)
bad_request_view = staticmethod(BadRequestView.as_view())
directory_views = {'upload': UploadView.as_view(),
None: DirectoryView.as_view()}
file_views = {'delete': FileDeleteView.as_view(),
None: FileView.as_view()}
dav_view = staticmethod(DAVView.as_view(data_directory=settings.DATA_DIRECTORY))
@method_decorator(login_required)
def dispatch(self, request, path):
self.path = path
self.path = urllib.unquote(path)
# Make sure that directories have a trailing slash.
if os.path.isdir(self.path_on_disk) and path and not path.endswith('/'):
abs_path = request.build_absolute_uri(reverse('browse:index', kwargs={'path': path + '/'}))
message = request.GET.get('message')
uri = abs_path + "?" + urllib.urlencode({'message': message}) if message else abs_path
return HttpResponsePermanentRedirect(uri)
views = self.directory_views if os.path.isdir(self.path_on_disk) else self.file_views
if request.method.lower() in DAVView.http_method_names:
view = self.dav_view
else:
try:
view = views[request.REQUEST.get('action')]
except KeyError:
return self.bad_request_view(request, path)
response = view(request, path)
response['Allow'] = ','.join(m.upper() for m in self.http_method_names)
response['DAV'] = "1,2"
response['MS-Author-Via'] = 'DAV'
return response
def auth_complete(self, *args, **kwargs):
"""Yammer API is a little strange"""
if 'error' in self.data:
logging.error("%s: %s:\n%s" %
(self.data('error'), self.data('error_reason'),
self.data('error_description')))
raise AuthCanceled(self)
# now we need to clean up the data params
data = dict(self.data.copy())
redirect_state = data.get('redirect_state')
try:
parts = redirect_state.split('?')
data['redirect_state'] = parts[0]
extra = parse_qs(parts[1])
data['code'] = extra['code'][0]
self.data = MergeDict(data)
except Exception as e:
logging.exception(e)
return super(YammerOAuth2, self).auth_complete(*args, **kwargs)
def process_request(self, req):
"""Interpret POST variables that indicate fake file uploads."""
# Bail out if any real files were uploaded
if len(req.FILES) > 0:
return None
# Find any post variables named like "fakefile_*".
# These contain the fake files that are to be uploaded.
fakefiles = []
for (k, v) in req.POST.iteritems():
if k.startswith(self.field_name):
if v == "": continue
fakefiles.append((k[len(self.field_name):], self.file_spec[v]))
if not fakefiles:
return None
# Remove the fakefile keys from POST
for f in fakefiles:
del req.POST[self.field_name + f[0]]
# Construct a fake request body and META object
fake_data = FakeFilesData(fakefiles)
fake_meta = MergeDict(fake_data.META, req.META)
# Re-parse the fake data, triggering upload handlers etc.
parser = MultiPartParser(fake_meta, fake_data, req.upload_handlers,
req.encoding)
(_, req._files) = parser.parse()
def _get_request(self):
if not hasattr(self, '_request'):
self._request = MergeDict(self.POST, self.GET)
return self._request
def test_bool_casting(self):
empty = MergeDict({}, {}, {})
not_empty = MergeDict({}, {}, {"key": "value"})
self.assertFalse(empty)
self.assertTrue(not_empty)
def _get_request(self):
from django.utils.datastructures import MergeDict
if not hasattr(self, '_request'):
self._request = MergeDict(self.POST, self.GET)
return self._request
def process_request(self, request):
request.DATA = MergeDict(request.GET, request.POST, request.FILES)
