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)