def _permissions(self): permissions = Permission.objects.all() self.permission_relation = [] for permission in permissions: right_name = "%s.%s" % ( permission.content_type.app_label, permission.codename) if right_name in PERMISSION_CODENAMES.keys(): perm_value = PERMISSION_CODENAMES[right_name] if isinstance(perm_value[0], six.text_type): perm_value = [perm_value] rigth_id = None for rigth_name, ext_name in perm_value: cur = self.old_db.open() sql_text = six.text_type("SELECT R.id FROM CORE_extension_rights R,CORE_extension E WHERE R.extension=E.id AND R.description='%s' AND E.extensionId='%s'") % ( six.text_type(rigth_name), ext_name) try: cur.execute(sql_text) except: self.print_debug("SQL error:%s", sql_text) rigth_id = cur.fetchone() if rigth_id is not None: break if rigth_id is not None: self.permission_relation.append( (permission.id, rigth_id[0])) else: self.print_debug("=> not found %s", (sql_text,))
def test_overriding_prefetch(self): with self.assertNumQueries(3): qs = Author.objects.prefetch_related('books', 'books__read_by') lists = [[[six.text_type(r) for r in b.read_by.all()] for b in a.books.all()] for a in qs] self.assertEqual(lists, [ [["Amy"], ["Belinda"]], # Charlotte - Poems, Jane Eyre [["Amy"]], # Anne - Poems [["Amy"], []], # Emily - Poems, Wuthering Heights [["Amy", "Belinda"]], # Jane - Sense and Sense ]) with self.assertNumQueries(3): qs = Author.objects.prefetch_related('books__read_by', 'books') lists = [[[six.text_type(r) for r in b.read_by.all()] for b in a.books.all()] for a in qs] self.assertEqual(lists, [ [["Amy"], ["Belinda"]], # Charlotte - Poems, Jane Eyre [["Amy"]], # Anne - Poems [["Amy"], []], # Emily - Poems, Wuthering Heights [["Amy", "Belinda"]], # Jane - Sense and Sense ])
def __init__(self, var_node, **kwargs): super(BaseVariableContextFinding, self).__init__(**kwargs) self._var_node = var_node self._line_number = kwargs.get('line_number') self._filename = six.text_type(kwargs.get('filename')) self._vulnerability_text = six.text_type( kwargs.get('vulnerability_text'))
def test_initial(self): relation0 = self.model.objects.create(name='relation0' + self.id()) relation1 = self.model.objects.create(name='relation1' + self.id()) fixture = self.model.objects.create(name=self.id()) self.add_relations(fixture, [relation0, relation1]) # Instanciate the modelform for that instance form = self.form(instance=fixture) # Ensure that the widget rendered right, with only the selection self.assertHTMLEqual( forms.SelectMultiple( choices=( (self.get_value(relation0), six.text_type(relation0)), (self.get_value(relation1), six.text_type(relation1)), ), attrs={ 'data-autocomplete-light-function': 'select2', 'data-autocomplete-light-url': reverse(self.url_name), 'id': 'id_test', } ).render('test', value=[ self.get_value(relation0), self.get_value(relation1), ]), six.text_type(form['test'].as_widget()) )
def test_abstract(self): # The Student and Worker models both have 'name' and 'age' fields on # them and inherit the __str__() method, just as with normal Python # subclassing. This is useful if you want to factor out common # information for programming purposes, but still completely # independent separate models at the database level. w1 = Worker.objects.create(name="Fred", age=35, job="Quarry worker") Worker.objects.create(name="Barney", age=34, job="Quarry worker") s = Student.objects.create(name="Pebbles", age=5, school_class="1B") self.assertEqual(six.text_type(w1), "Worker Fred") self.assertEqual(six.text_type(s), "Student Pebbles") # The children inherit the Meta class of their parents (if they don't # specify their own). self.assertQuerysetEqual(Worker.objects.values("name"), [{"name": "Barney"}, {"name": "Fred"}], lambda o: o) # Since Student does not subclass CommonInfo's Meta, it has the effect # of completely overriding it. So ordering by name doesn't take place # for Students. self.assertEqual(Student._meta.ordering, []) # However, the CommonInfo class cannot be used as a normal model (it # doesn't exist as a model). with self.assertRaises(AttributeError): CommonInfo.objects.all()
def list_dir(self, path): """Lists the contents of the specified path. The result will be an ordered dictionary of contents, mapping filenames or directory names with a dictionary containing: * ``path`` - The full path of the file or directory. * ``created_rev`` - The revision where the file or directory was created. """ result = SortedDict() if api_version()[:2] >= (1, 5): depth = 2 # Immediate files in this path. Only in 1.5+. else: depth = 0 # This will trigger recurse=False for SVN < 1.5. dirents = self.client.list(B(self.normalize_path(path)), None, depth) for name, dirent in six.iteritems(dirents): if name: result[six.text_type(name)] = { 'path': '%s/%s' % (path.strip('/'), name), 'created_rev': six.text_type(dirent['created_rev']), } return result
def format_value(value): if getattr(value, 'is_hyperlink', False): name = six.text_type(value.obj) return mark_safe('<a href=%s>%s</a>' % (value, escape(name))) if value is None or isinstance(value, bool): return mark_safe('<code>%s</code>' % {True: 'true', False: 'false', None: 'null'}[value]) elif isinstance(value, list): if any([isinstance(item, (list, dict)) for item in value]): template = loader.get_template('rest_framework/admin/list_value.html') else: template = loader.get_template('rest_framework/admin/simple_list_value.html') context = {'value': value} return template.render(context) elif isinstance(value, dict): template = loader.get_template('rest_framework/admin/dict_value.html') context = {'value': value} return template.render(context) elif isinstance(value, six.string_types): if ( (value.startswith('http:') or value.startswith('https:')) and not re.search(r'\s', value) ): return mark_safe('<a href="{value}">{value}</a>'.format(value=escape(value))) elif '@' in value and not re.search(r'\s', value): return mark_safe('<a href="mailto:{value}">{value}</a>'.format(value=escape(value))) elif '\n' in value: return mark_safe('<pre>%s</pre>' % escape(value)) return six.text_type(value)
def date_error_message(self, lookup_type, field, unique_for): opts = self._meta return _("%(field_name)s must be unique for %(date_field)s %(lookup)s.") % { 'field_name': six.text_type(capfirst(opts.get_field(field).verbose_name)), 'date_field': six.text_type(capfirst(opts.get_field(unique_for).verbose_name)), 'lookup': lookup_type, }
def test_tag_render(self): "Check unicode tag name renders" t1 = self.model.objects.get(name="Test") tags = list(t1.tags.all()) self.assertEqual(six.text_type(tags[0]), 'boy') self.assertEqual(six.text_type(tags[1]), 'niño') self.assertEqual(six.text_type(tags[2]), '男の子')
def get_gateway_url(self, request): "Routes a payment to Gateway, should return URL for redirection." params = { 'id': self.get_backend_setting('id'), 'opis': self.get_order_description(self.payment, self.payment.order), # Here we put payment.pk as we can get order through payment model 'crc': self.payment.pk, # amount is in format XXX.YY PLN 'kwota': text_type(self.payment.amount), } self._build_user_data(params) self._build_md5sum(params) self._build_urls(params) method = self.get_backend_setting('method', 'get').lower() if method not in ('post', 'get'): raise ImproperlyConfigured( 'Transferuj.pl payment backend accepts only GET or POST' ) if method == 'post': return (self._GATEWAY_URL, 'POST', params) params = {k: text_type(v).encode('utf-8') for k, v in params.items()} return ( "{}?{}".format(self._GATEWAY_URL, urlencode(params)), "GET", {} )
def test_delete_decreases_correct(self): """ Check that the actual tag in the database is decreased, not the one in the instance at time of deletion """ t1 = test_models.SingleTagFieldModel.objects.create(name='Test 1', title='Mr') t2 = test_models.SingleTagFieldModel.objects.create(name='Test 2', title='Mrs') self.assertEqual(six.text_type(t1.title.name), 'Mr') self.assertEqual(six.text_type(t2.title.name), 'Mrs') self.assertTagModel(self.tag_model, { 'Mr': 1, 'Mrs': 1, }) # Now change the title and delete without saving t1.title = 'Mrs' self.assertEqual(six.text_type(t1.title.name), 'Mrs') self.assertTagModel(self.tag_model, { 'Mr': 1, 'Mrs': 1, }) t1.delete() # Check the original tag 'Mr' was decremented (and deleted) self.assertTagModel(self.tag_model, { 'Mrs': 1, }) # But check that tagulous still thinks the tag is 'Mrs' self.assertEqual(six.text_type(t1.title.name), 'Mrs')
def test_view_get(self): self.login(usertype="staff") # first access via .get() -> returned the default value "initial value" url = reverse("test_user_settings", kwargs={"test_name": "get", "key": "Foo", "value": "initial value"} ) response = self.client.get(url) self.failUnlessEqual(response.status_code, 200) self.failUnlessEqual(six.text_type(response.content, "UTF-8"), "initial value") # change with .setitem() url = reverse("test_user_settings", kwargs={"test_name": "setitem", "key": "Foo", "value": "new value"} ) response = self.client.get(url) self.failUnlessEqual(response.status_code, 200) self.failUnlessEqual(six.text_type(response.content, "UTF-8"), "new value") # now, the .get() method should returned the current value url = reverse("test_user_settings", kwargs={"test_name": "get", "key": "Foo", "value": "initial value"} ) response = self.client.get(url) self.failUnlessEqual(response.status_code, 200) self.failUnlessEqual(six.text_type(response.content, "UTF-8"), "new value")
def compute_sig(params, fields, key): text = u'' for field in fields: text += text_type(params.get(field, '')) text += key text_encoded = text.encode('utf-8') return text_type(hashlib.md5(text_encoded).hexdigest())
def _make_token_with_timestamp(self, user, timestamp): # timestamp is number of days since 2001-1-1. Converted to # base 36, this gives us a 3 digit string until about 2121 ts_b36 = int_to_base36(timestamp) # By hashing on the internal state of the user and using state # that is sure to change (the password salt will change as soon as # the password is set, at least for current Django auth, and # last_login will also change), we produce a hash that will be # invalid as soon as it is used. # We limit the hash to 20 chars to keep URL short key_salt = "django.contrib.auth.tokens.PasswordResetTokenGenerator" # Ensure results are consistent across DB backends user_last_login = UserLastLogin.objects.get_by_username(user.username) if user_last_login is None: from seahub.utils.timeutils import dt login_dt = dt(user.ctime) else: login_dt = user_last_login.last_login login_timestamp = login_dt.replace(microsecond=0, tzinfo=None) value = (six.text_type(user.id) + user.enc_password + six.text_type(login_timestamp) + six.text_type(timestamp)) hash = salted_hmac(key_salt, value).hexdigest()[::2] return "%s-%s" % (ts_b36, hash)
def force_bytes(s, encoding='utf-8', strings_only=False, errors='strict'): """ Similar to smart_bytes, except that lazy instances are resolved to strings, rather than kept as lazy objects. If strings_only is True, don't convert (some) non-string-like objects. """ if isinstance(s, bytes): if encoding == 'utf-8': return s else: return s.decode('utf-8', errors).encode(encoding, errors) if strings_only and (s is None or isinstance(s, int)): return s if isinstance(s, Promise): return six.text_type(s).encode(encoding, errors) if not isinstance(s, six.string_types): try: if six.PY3: return six.text_type(s).encode(encoding) else: return bytes(s) except UnicodeEncodeError: if isinstance(s, Exception): # An Exception subclass containing non-ASCII data that doesn't # know how to print itself properly. We shouldn't raise a # further exception. return ' '.join([force_bytes(arg, encoding, strings_only, errors) for arg in s]) return six.text_type(s).encode(encoding, errors) else: return s.encode(encoding, errors)
def test_listing(self): self.factory.xfer = ChartsAccountListing() self.call( "/diacamma.accounting/chartsAccountListing", {"year": "1", "type_of_account": "-1", "PRINT_MODE": "4", "MODEL": 6}, False, ) self.assert_observer("core.print", "diacamma.accounting", "chartsAccountListing") csv_value = b64decode(six.text_type(self.get_first_xpath("PRINT").text)).decode("utf-8") content_csv = csv_value.split("\n") self.assertEqual(len(content_csv), 22, str(content_csv)) self.assertEqual(content_csv[1].strip(), '"Liste de plan comptable"') self.assertEqual( content_csv[3].strip(), '"code";"nom";"total de l\'exercice précédent";"total exercice";"total validé";' ) self.assertEqual( content_csv[4].strip(), '"106";"106";"Crédit: 1250.38€";"Crédit: 1250.38€";"Crédit: 1250.38€";' ) self.assertEqual(content_csv[9].strip(), '"512";"512";"Débit: 1135.93€";"Débit: 1130.29€";"Débit: 1130.29€";') self.assertEqual(content_csv[10].strip(), '"531";"531";"Débit: 114.45€";"Crédit: 79.63€";"Débit: 114.45€";') self.factory.xfer = ChartsAccountListing() self.call( "/diacamma.accounting/chartsAccountListing", {"year": "1", "type_of_account": "4", "PRINT_MODE": "4", "MODEL": 6}, False, ) self.assert_observer("core.print", "diacamma.accounting", "chartsAccountListing") csv_value = b64decode(six.text_type(self.get_first_xpath("PRINT").text)).decode("utf-8") content_csv = csv_value.split("\n") self.assertEqual(len(content_csv), 12, str(content_csv))
def delete(request, extra_context=None, next_override=None, *args, **kwargs): if extra_context is None: extra_context = {} avatar, avatars = _get_avatars(request.user) delete_avatar_form = DeleteAvatarForm(request.POST or None, user=request.user, avatars=avatars) if request.method == 'POST': if delete_avatar_form.is_valid(): ids = delete_avatar_form.cleaned_data['choices'] if six.text_type(avatar.id) in ids and avatars.count() > len(ids): # Find the next best avatar, and set it as the new primary for a in avatars: if six.text_type(a.id) not in ids: a.primary = True a.save() avatar_updated.send(sender=Avatar, user=request.user, avatar=avatar) break Avatar.objects.filter(id__in=ids).delete() messages.success(request, _("Successfully deleted the requested avatars.")) return redirect(next_override or _get_next(request)) context = { 'avatar': avatar, 'avatars': avatars, 'delete_avatar_form': delete_avatar_form, 'next': next_override or _get_next(request), } context.update(extra_context) return render(request, 'avatar/confirm_delete.html', context)
def render(self, context): field = self.field.resolve(context) if "." not in self.field_name: verbose_name = six.text_type(context[self.field_name]._meta.verbose_name) else: instance, field_name = self.field_name.rsplit(".", 1) model = context[instance].__class__ model_field = model._meta.get_field(field_name) verbose_name = six.text_type(model_field.verbose_name) if self.unit is None: try: self.unit = model_field.unit except AttributeError: pass verbose_name = jb_common.utils.base.capitalize_first_letter(verbose_name) if self.unit == "yes/no": field = jb_common.templatetags.juliabase.fancy_bool(field) unit = None elif self.unit == "user": field = get_really_full_name(field, autoescape=True) unit = None elif self.unit == "sccm_collapse": if not field: return """<td colspan="2"></td>""" unit = "sccm" elif not field and field != 0: unit = None field = "—" else: unit = self.unit if self.significant_digits and field != "—": field = jb_common.utils.base.round(field, self.significant_digits) return """<td class="field-label">{label}:</td><td class="field-value">{value}</td>""".format( label=verbose_name, value=conditional_escape(field) if unit is None else quantity(field, unit))
def test_abstract(self): # The Student and Worker models both have 'name' and 'age' fields on # them and inherit the __unicode__() method, just as with normal Python # subclassing. This is useful if you want to factor out common # information for programming purposes, but still completely # independent separate models at the database level. w1 = Worker.objects.create(name="Fred", age=35, job="Quarry worker") w2 = Worker.objects.create(name="Barney", age=34, job="Quarry worker") s = Student.objects.create(name="Pebbles", age=5, school_class="1B") self.assertEqual(six.text_type(w1), "Worker Fred") self.assertEqual(six.text_type(s), "Student Pebbles") # The children inherit the Meta class of their parents (if they don't # specify their own). self.assertQuerysetEqual( Worker.objects.values("name"), [ {"name": "Barney"}, {"name": "Fred"}, ], lambda o: o ) # Since Student does not subclass CommonInfo's Meta, it has the effect # of completely overriding it. So ordering by name doesn't take place # for Students. self.assertEqual(Student._meta.ordering, []) # However, the CommonInfo class cannot be used as a normal model (it # doesn't exist as a model). self.assertRaises(AttributeError, lambda: CommonInfo.objects.all()) # A StudentWorker which does not exist is both a Student and Worker # which does not exist. self.assertRaises(Student.DoesNotExist, StudentWorker.objects.get, pk=12321321 ) self.assertRaises(Worker.DoesNotExist, StudentWorker.objects.get, pk=12321321 ) # MultipleObjectsReturned is also inherited. # This is written out "long form", rather than using __init__/create() # because of a bug with diamond inheritance (#10808) sw1 = StudentWorker() sw1.name = "Wilma" sw1.age = 35 sw1.save() sw2 = StudentWorker() sw2.name = "Betty" sw2.age = 24 sw2.save() self.assertRaises(Student.MultipleObjectsReturned, StudentWorker.objects.get, pk__lt=sw2.pk + 100 ) self.assertRaises(Worker.MultipleObjectsReturned, StudentWorker.objects.get, pk__lt=sw2.pk + 100 )
def smart_str(s, encoding='utf-8', strings_only=False, errors='strict'): """ Returns a bytestring version of 's', encoded as specified in 'encoding'. If strings_only is True, don't convert (some) non-string-like objects. """ if strings_only and (s is None or isinstance(s, int)): return s if isinstance(s, Promise): return six.text_type(s).encode(encoding, errors) elif not isinstance(s, six.string_types): try: if six.PY3: return six.text_type(s).encode(encoding) else: return bytes(s) except UnicodeEncodeError: if isinstance(s, Exception): # An Exception subclass containing non-ASCII data that doesn't # know how to print itself properly. We shouldn't raise a # further exception. return ' '.join([smart_str(arg, encoding, strings_only, errors) for arg in s]) return six.text_type(s).encode(encoding, errors) elif isinstance(s, six.text_type): return s.encode(encoding, errors) elif s and encoding != 'utf-8': return s.decode('utf-8', errors).encode(encoding, errors) else: return s
def assert_coordcomp_equal(self, xpath, coord): self.assert_attrib_equal(xpath, "x", six.text_type(coord[0])) self.assert_attrib_equal(xpath, "y", six.text_type(coord[1])) self.assert_attrib_equal(xpath, "colspan", six.text_type(coord[2])) self.assert_attrib_equal(xpath, "rowspan", six.text_type(coord[3])) if len(coord) > 4: self.assert_attrib_equal(xpath, "tab", six.text_type(coord[4]))
def test_sidebar(self): """Testing submitter view sidebar""" user = User.objects.get(username='******') user.review_groups.clear() group1 = Group.objects.create(name='test-group-1') group1.users.add(user) group2 = Group.objects.create(name='test-group-2', invite_only=True) group2.users.add(user) # Now load the page and get the sidebar items. response = self.client.get('/users/grumpy/') self.assertEqual(response.status_code, 200) datagrid = self._get_context_var(response, 'datagrid') self.assertIsNotNone(datagrid) sidebar_items = \ self._get_context_var(response, 'datagrid').sidebar_items self.assertEqual(len(sidebar_items), 2) # Test the User Profile section. section = sidebar_items[0] self.assertIsInstance(section, UserProfileItem) # Test the Groups section. section = sidebar_items[1] self.assertIsInstance(section, UserGroupsItem) self.assertEqual(six.text_type(section.label), 'Groups') self.assertEqual(len(section.items), 1) self.assertEqual(six.text_type(section.items[0].label), 'test-group-1')
def setup_basic_post_test(self, user, with_local_site, local_site_name, post_valid_data): if post_valid_data: self.create_review_group(name='group1', with_local_site=with_local_site) self.create_review_group(name='group2', with_local_site=with_local_site) repo1 = self.create_repository(name='Test Repo 1', with_local_site=with_local_site, path='test-repo-1') repo2 = self.create_repository(name='Test Repo 2', with_local_site=with_local_site, path='test-repo-2') if with_local_site: site = self.get_local_site(name=local_site_name) site.users.add(User.objects.get(username='******')) site.users.add(User.objects.get(username='******')) post_data = { 'name': 'my-default', 'file_regex': '.*', 'users': 'doc,dopey', 'groups': 'group1,group2', 'repositories': ','.join([six.text_type(repo1.pk), six.text_type(repo2.pk)]), } else: post_data = {} return (get_default_reviewer_list_url(local_site_name), default_reviewer_item_mimetype, post_data, [local_site_name])
def test_initial(self): tag = self.tag.objects.create(name='tag' + self.id()) fixture = self.model.objects.create(name=self.id()) fixture.test.add(tag) # Instanciate the modelform for that instance form = self.form(instance=fixture) # Ensure that the widget rendered right, with only the selection self.assertHTMLEqual( forms.SelectMultiple( choices=( (six.text_type(tag), six.text_type(tag)), ), attrs={ 'data-autocomplete-light-function': 'select2', 'data-autocomplete-light-url': reverse(self.url_name), 'data-tags': 1, 'id': 'id_test', } ).render('test', value=[ six.text_type(tag), ]), six.text_type(form['test'].as_widget()) )
def test_change_form_deletion_when_invalid(self): """ Make sure that a change form that is filled out, but marked for deletion doesn't cause validation errors. """ PoemFormSet = inlineformset_factory(Poet, Poem, can_delete=True, fields="__all__") poet = Poet.objects.create(name='test') poem = poet.poem_set.create(name='test poem') data = { 'poem_set-TOTAL_FORMS': '1', 'poem_set-INITIAL_FORMS': '1', 'poem_set-MAX_NUM_FORMS': '0', 'poem_set-0-id': six.text_type(poem.id), 'poem_set-0-poem': six.text_type(poem.id), 'poem_set-0-name': 'x' * 1000, } formset = PoemFormSet(data, instance=poet) # Make sure this form doesn't pass validation. self.assertEqual(formset.is_valid(), False) self.assertEqual(Poem.objects.count(), 1) # Then make sure that it *does* pass validation and delete the object, # even though the data isn't actually valid. data['poem_set-0-DELETE'] = 'on' formset = PoemFormSet(data, instance=poet) self.assertEqual(formset.is_valid(), True) formset.save() self.assertEqual(Poem.objects.count(), 0)
def test_form(self, mock_randint, mock_hash_answer, mock_get_operator): ops = ['+', '-'] ints = [1, 3, 1, 3] mock_randint.side_effect = lambda x, y: ints.pop(0) mock_hash_answer.side_effect = lambda x: "answer=%s" % x mock_get_operator.side_effect = lambda: ops.pop(0) class F(forms.Form): captcha = MathCaptchaField() f = F() result1 = six.text_type(f) result2 = six.text_type(f) self.assertHTMLEqual(result1, """ <tr><th><label for="id_captcha_0">Captcha:</label></th><td> <span class="captcha-question">What is 1 + 3?</span> <input id="id_captcha_0" required name="captcha_0" size="5" type="text" /> <input id="id_captcha_1" required name="captcha_1" type="hidden" value="answer=4" /> </td></tr>""") self.assertHTMLEqual(result2, """ <tr><th><label for="id_captcha_0">Captcha:</label></th><td> <span class="captcha-question">What is 3 - 1?</span> <input id="id_captcha_0" required name="captcha_0" size="5" type="text" /> <input id="id_captcha_1" required name="captcha_1" type="hidden" value="answer=2" /> </td></tr>""")
def accept_payment(self, session_id): params = { 'pos_id': PaymentProcessor.get_backend_setting('pos_id'), 'session_id': session_id, 'ts': time.time() } key1 = PaymentProcessor.get_backend_setting('key1') key2 = PaymentProcessor.get_backend_setting('key2') params['sig'] = PaymentProcessor.compute_sig( params, self._GET_SIG_FIELDS, key1) for key in params.keys(): params[key] = six.text_type(params[key]).encode('utf-8') data = six.text_type(urlencode(params)).encode('utf-8') url = self._GATEWAY_URL + 'UTF/Payment/confirm/txt' request = Request(url, data) response = urlopen(request) response_data = response.read().decode('utf-8') response_params = PaymentProcessor._parse_text_response(response_data) if response_params['status'] == 'OK': if PaymentProcessor.compute_sig( response_params, self._GET_ACCEPT_SIG_FIELDS, key2) != response_params['trans_sig']: logger.error(u'Wrong signature for Payment/confirm response: %s' % response_params) return if int(response_params['trans_pos_id']) != int(params['pos_id']): logger.error(u'Wrong pos_id for Payment/confirm response: %s' % response_params) return logger.info(u'Payment accepted: %s' % response_params) else: logger.warning(u'Payment not accepted, error: %s' % response_params)
def test_admin_edits_field(self): """admin form allows admins to edit field""" response = self.client.post( self.test_link, data={ 'username': '******', 'rank': six.text_type(self.user.rank_id), 'roles': six.text_type(self.user.roles.all()[0].pk), 'email': '*****@*****.**', 'twitter': 'lorem_ipsum', 'new_password': '', 'signature': '', 'is_signature_locked': '0', 'is_hiding_presence': '0', 'limits_private_thread_invites_to': '0', 'signature_lock_staff_message': '', 'signature_lock_user_message': '', 'subscribe_to_started_threads': '2', 'subscribe_to_replied_threads': '2', } ) self.assertEqual(response.status_code, 302) self.reload_user() self.assertEqual(self.user.profile_fields['twitter'], 'lorem_ipsum')
def default(self, obj): if isinstance(obj, Promise): return force_text(obj) elif isinstance(obj, datetime.timedelta): return six.text_type(total_seconds(obj)) elif isinstance(obj, decimal.Decimal): # Serializers will coerce decimals to strings by default. return float(obj) elif isinstance(obj, uuid.UUID): return six.text_type(obj) elif isinstance(obj, QuerySet): return tuple(obj) elif hasattr(obj, 'tolist'): # Numpy arrays and array scalars. return obj.tolist() elif hasattr(obj, '__getitem__'): try: return dict(obj) except: pass elif hasattr(obj, '__iter__'): return tuple(item for item in obj) return super(JSONEncoder, self).default(obj)
def render_to_response(self, methods, basket): pairs = [ ('METHOD', 'CallbackResponse'), ('CURRENCYCODE', self.request.POST.get('CURRENCYCODE', 'GBP')), ] for index, method in enumerate(methods): if hasattr(method, 'set_basket'): # Oscar < 0.8 method.set_basket(basket) charge = method.charge_incl_tax else: cost = method.calculate(basket) charge = cost.incl_tax pairs.append(('L_SHIPPINGOPTIONNAME%d' % index, six.text_type(method.name))) pairs.append(('L_SHIPPINGOPTIONLABEL%d' % index, six.text_type(method.name))) pairs.append(('L_SHIPPINGOPTIONAMOUNT%d' % index, charge)) # For now, we assume tax and insurance to be zero pairs.append(('L_TAXAMT%d' % index, D('0.00'))) pairs.append(('L_INSURANCEAMT%d' % index, D('0.00'))) # We assume that the first returned method is the default one pairs.append(('L_SHIPPINGOPTIONISDEFAULT%d' % index, 1 if index == 0 else 0)) else: # No shipping methods available - we flag this up to PayPal indicating that we # do not ship to the shipping address. pairs.append(('NO_SHIPPING_OPTION_DETAILS', 1)) payload = urlencode(pairs) return HttpResponse(payload)
def test_initial(self): form = self.EnumForm(initial={'choice': MyEnum.bar}) html = six.text_type(form['choice']) self.assertInHTML('<option value="bar" selected>Bar</option>', html)
def as_p(self): "Returns this formset rendered as HTML <p>s." forms = ' '.join(form.as_p() for form in self) return mark_safe('\n'.join( [six.text_type(self.management_form), forms]))
def __str__(self): return six.text_type(self.exc)
def get_initkwargs(cls, form_list=None, initial_dict=None, instance_dict=None, condition_dict=None, *args, **kwargs): """ Creates a dict with all needed parameters for the form wizard instances. * `form_list` - is a list of forms. The list entries can be single form classes or tuples of (`step_name`, `form_class`). If you pass a list of forms, the wizardview will convert the class list to (`zero_based_counter`, `form_class`). This is needed to access the form for a specific step. * `initial_dict` - contains a dictionary of initial data dictionaries. The key should be equal to the `step_name` in the `form_list` (or the str of the zero based counter - if no step_names added in the `form_list`) * `instance_dict` - contains a dictionary whose values are model instances if the step is based on a ``ModelForm`` and querysets if the step is based on a ``ModelFormSet``. The key should be equal to the `step_name` in the `form_list`. Same rules as for `initial_dict` apply. * `condition_dict` - contains a dictionary of boolean values or callables. If the value of for a specific `step_name` is callable it will be called with the wizardview instance as the only argument. If the return value is true, the step's form will be used. """ kwargs.update({ 'initial_dict': initial_dict or kwargs.pop('initial_dict', getattr(cls, 'initial_dict', None)) or {}, 'instance_dict': instance_dict or kwargs.pop('instance_dict', getattr(cls, 'instance_dict', None)) or {}, 'condition_dict': condition_dict or kwargs.pop('condition_dict', getattr(cls, 'condition_dict', None)) or {} }) form_list = form_list or kwargs.pop('form_list', getattr(cls, 'form_list', None)) or [] computed_form_list = OrderedDict() assert len(form_list) > 0, 'at least one form is needed' # walk through the passed form list for i, form in enumerate(form_list): if isinstance(form, (list, tuple)): # if the element is a tuple, add the tuple to the new created # sorted dictionary. computed_form_list[six.text_type(form[0])] = form[1] else: # if not, add the form with a zero based counter as unicode computed_form_list[six.text_type(i)] = form # walk through the new created list of forms for form in six.itervalues(computed_form_list): if issubclass(form, formsets.BaseFormSet): # if the element is based on BaseFormSet (FormSet/ModelFormSet) # we need to override the form variable. form = form.form # check if any form contains a FileField, if yes, we need a # file_storage added to the wizardview (by subclassing). for field in six.itervalues(form.base_fields): if (isinstance(field, forms.FileField) and not hasattr(cls, 'file_storage')): raise NoFileStorageConfigured( "You need to define 'file_storage' in your " "wizard view in order to handle file uploads.") # build the kwargs for the wizardview instances kwargs['form_list'] = computed_form_list return kwargs
def _get_position_from_instance(self, instance, ordering): attr = getattr(instance, ordering[0].lstrip('-')) return six.text_type(attr)
class TestModuleStoreSerializer(TestDumpToNeo4jCommandBase): """ Tests for the ModuleStoreSerializer """ @classmethod def setUpClass(cls): """Any ModuleStore course/content operations can go here.""" super(TestModuleStoreSerializer, cls).setUpClass() cls.mss = ModuleStoreSerializer.create() def test_serialize_item(self): """ Tests the serialize_item method. """ fields, label = serialize_item(self.course) self.assertEqual(label, "course") self.assertIn("edited_on", fields.keys()) self.assertIn("display_name", fields.keys()) self.assertIn("org", fields.keys()) self.assertIn("course", fields.keys()) self.assertIn("run", fields.keys()) self.assertIn("course_key", fields.keys()) self.assertIn("location", fields.keys()) self.assertIn("block_type", fields.keys()) self.assertIn("detached", fields.keys()) self.assertNotIn("checklist", fields.keys()) def test_serialize_course(self): """ Tests the serialize_course method. """ nodes, relationships = serialize_course(self.course.id) self.assertEqual(len(nodes), 9) # the course has 7 "PARENT_OF" relationships and 3 "PRECEDES" self.assertEqual(len(relationships), 10) def test_strip_version_and_branch(self): """ Tests that the _strip_version_and_branch function strips the version and branch from a location """ location = self.course.id.make_usage_key( 'test_block_type', 'test_block_id').for_branch( 'test_branch').for_version('test_version') self.assertIsNotNone(location.branch) self.assertIsNotNone(location.version_guid) stripped_location = strip_branch_and_version(location) self.assertIsNone(stripped_location.branch) self.assertIsNone(stripped_location.version_guid) @staticmethod def _extract_relationship_pairs(relationships, relationship_type): """ Extracts a list of XBlock location tuples from a list of Relationships. Arguments: relationships: list of py2neo `Relationship` objects relationship_type: the type of relationship to filter `relationships` by. Returns: List of tuples of the locations of of the relationships' constituent nodes. """ relationship_pairs = [ tuple([node["location"] for node in rel.nodes()]) for rel in relationships if rel.type() == relationship_type ] return relationship_pairs @staticmethod def _extract_location_pair(xblock1, xblock2): """ Returns a tuple of locations from two XBlocks. Arguments: xblock1: an xblock xblock2: also an xblock Returns: A tuple of the string representations of those XBlocks' locations. """ return (six.text_type(xblock1.location), six.text_type(xblock2.location)) def assertBlockPairIsRelationship(self, xblock1, xblock2, relationships, relationship_type): """ Helper assertion that a pair of xblocks have a certain kind of relationship with one another. """ relationship_pairs = self._extract_relationship_pairs( relationships, relationship_type) location_pair = self._extract_location_pair(xblock1, xblock2) self.assertIn(location_pair, relationship_pairs) def assertBlockPairIsNotRelationship(self, xblock1, xblock2, relationships, relationship_type): """ The opposite of `assertBlockPairIsRelationship`: asserts that a pair of xblocks do NOT have a certain kind of relationship. """ relationship_pairs = self._extract_relationship_pairs( relationships, relationship_type) location_pair = self._extract_location_pair(xblock1, xblock2) self.assertNotIn(location_pair, relationship_pairs) def test_precedes_relationship(self): """ Tests that two nodes that should have a precedes relationship have it. """ __, relationships = serialize_course(self.course.id) self.assertBlockPairIsRelationship(self.video, self.video2, relationships, "PRECEDES") self.assertBlockPairIsNotRelationship(self.video2, self.video, relationships, "PRECEDES") self.assertBlockPairIsNotRelationship(self.vertical, self.video, relationships, "PRECEDES") self.assertBlockPairIsNotRelationship(self.html, self.video, relationships, "PRECEDES") def test_parent_relationship(self): """ Test that two nodes that should have a parent_of relationship have it. """ __, relationships = serialize_course(self.course.id) self.assertBlockPairIsRelationship(self.vertical, self.video, relationships, "PARENT_OF") self.assertBlockPairIsRelationship(self.vertical, self.html, relationships, "PARENT_OF") self.assertBlockPairIsRelationship(self.course, self.chapter, relationships, "PARENT_OF") self.assertBlockPairIsNotRelationship(self.course, self.video, relationships, "PARENT_OF") self.assertBlockPairIsNotRelationship(self.video, self.vertical, relationships, "PARENT_OF") self.assertBlockPairIsNotRelationship(self.video, self.html, relationships, "PARENT_OF") def test_nodes_have_indices(self): """ Test that we add index values on nodes """ nodes, relationships = serialize_course(self.course.id) # the html node should have 0 index, and the problem should have 1 html_nodes = [node for node in nodes if node['block_type'] == 'html'] self.assertEqual(len(html_nodes), 1) problem_nodes = [ node for node in nodes if node['block_type'] == 'problem' ] self.assertEqual(len(problem_nodes), 1) html_node = html_nodes[0] problem_node = problem_nodes[0] self.assertEqual(html_node['index'], 0) self.assertEqual(problem_node['index'], 1) @ddt.data( (1, 1), (object, "<type 'object'>"), (1.5, 1.5), ("úñîçø∂é", "úñîçø∂é"), (b"plain string", b"plain string"), (True, True), (None, "None"), ((1, ), "(1,)"), # list of elements should be coerced into a list of the # string representations of those elements ([object, object], ["<type 'object'>", "<type 'object'>"])) @ddt.unpack def test_coerce_types(self, original_value, coerced_expected): """ Tests the coerce_types helper """ coerced_value = coerce_types(original_value) self.assertEqual(coerced_value, coerced_expected) @mock.patch('openedx.core.djangoapps.coursegraph.tasks.NodeSelector') @mock.patch( 'openedx.core.djangoapps.coursegraph.tasks.authenticate_and_create_graph' ) def test_dump_to_neo4j(self, mock_graph_constructor, mock_selector_class): """ Tests the dump_to_neo4j method works against a mock py2neo Graph """ mock_graph = MockGraph() mock_graph_constructor.return_value = mock_graph mock_selector_class.return_value = MockNodeSelector(mock_graph) mock_credentials = mock.Mock() submitted, skipped = self.mss.dump_courses_to_neo4j(mock_credentials) self.assertCourseDump( mock_graph, number_of_courses=2, number_commits=2, number_rollbacks=0, ) # 9 nodes + 7 relationships from the first course # 2 nodes and no relationships from the second self.assertEqual(len(mock_graph.nodes), 11) self.assertItemsEqual(submitted, self.course_strings) @mock.patch('openedx.core.djangoapps.coursegraph.tasks.NodeSelector') @mock.patch( 'openedx.core.djangoapps.coursegraph.tasks.authenticate_and_create_graph' ) def test_dump_to_neo4j_rollback(self, mock_graph_constructor, mock_selector_class): """ Tests that the the dump_to_neo4j method handles the case where there's an exception trying to write to the neo4j database. """ mock_graph = MockGraph(transaction_errors=True) mock_graph_constructor.return_value = mock_graph mock_selector_class.return_value = MockNodeSelector(mock_graph) mock_credentials = mock.Mock() submitted, skipped = self.mss.dump_courses_to_neo4j(mock_credentials) self.assertCourseDump( mock_graph, number_of_courses=0, number_commits=0, number_rollbacks=2, ) self.assertItemsEqual(submitted, self.course_strings) @mock.patch('openedx.core.djangoapps.coursegraph.tasks.NodeSelector') @mock.patch( 'openedx.core.djangoapps.coursegraph.tasks.authenticate_and_create_graph' ) @ddt.data((True, 2), (False, 0)) @ddt.unpack def test_dump_to_neo4j_cache( self, override_cache, expected_number_courses, mock_graph_constructor, mock_selector_class, ): """ Tests the caching mechanism and override to make sure we only publish recently updated courses. """ mock_graph = MockGraph() mock_graph_constructor.return_value = mock_graph mock_selector_class.return_value = MockNodeSelector(mock_graph) mock_credentials = mock.Mock() # run once to warm the cache self.mss.dump_courses_to_neo4j(mock_credentials, override_cache=override_cache) # when run the second time, only dump courses if the cache override # is enabled submitted, __ = self.mss.dump_courses_to_neo4j( mock_credentials, override_cache=override_cache) self.assertEqual(len(submitted), expected_number_courses) @mock.patch('openedx.core.djangoapps.coursegraph.tasks.NodeSelector') @mock.patch( 'openedx.core.djangoapps.coursegraph.tasks.authenticate_and_create_graph' ) def test_dump_to_neo4j_published(self, mock_graph_constructor, mock_selector_class): """ Tests that we only dump those courses that have been published after the last time the command was been run. """ mock_graph = MockGraph() mock_graph_constructor.return_value = mock_graph mock_selector_class.return_value = MockNodeSelector(mock_graph) mock_credentials = mock.Mock() # run once to warm the cache submitted, skipped = self.mss.dump_courses_to_neo4j(mock_credentials) self.assertEqual(len(submitted), len(self.course_strings)) # simulate one of the courses being published listen_for_course_publish(None, self.course.id) # make sure only the published course was dumped submitted, __ = self.mss.dump_courses_to_neo4j(mock_credentials) self.assertEqual(len(submitted), 1) self.assertEqual(submitted[0], six.text_type(self.course.id)) @mock.patch( 'openedx.core.djangoapps.coursegraph.tasks.get_course_last_published') @mock.patch( 'openedx.core.djangoapps.coursegraph.tasks.get_command_last_run') @ddt.data( (six.text_type(datetime( 2016, 3, 30)), six.text_type(datetime(2016, 3, 31)), True), (six.text_type(datetime( 2016, 3, 31)), six.text_type(datetime(2016, 3, 30)), False), (six.text_type(datetime(2016, 3, 31)), None, False), (None, six.text_type(datetime(2016, 3, 30)), True), (None, None, True), ) @ddt.unpack def test_should_dump_course( self, last_command_run, last_course_published, should_dump, mock_get_command_last_run, mock_get_course_last_published, ): """ Tests whether a course should be dumped given the last time it was dumped and the last time it was published. """ mock_get_command_last_run.return_value = last_command_run mock_get_course_last_published.return_value = last_course_published mock_course_key = mock.Mock() mock_graph = mock.Mock() self.assertEqual( should_dump_course(mock_course_key, mock_graph), should_dump, )
def to_representation(self, value): value = '<br/>'.join(value.splitlines()) return six.text_type(value)
def _make_hash_value(self, user, timestamp): return (six.text_type(user.pk) + six.text_type(timestamp) + six.text_type(user.profile.email_confirmed))
def create(self, request, extra_fields={}, *args, **kwargs): """Creates a new diff by parsing an uploaded diff file. This will implicitly create the new Review Request draft, which can be updated separately and then published. This accepts a unified diff file, validates it, and stores it along with the draft of a review request. The new diff will have a revision of 0. A parent diff can be uploaded along with the main diff. A parent diff is a diff based on an existing commit in the repository, which will be applied before the main diff. The parent diff will not be included in the diff viewer. It's useful when developing a change based on a branch that is not yet committed. In this case, a parent diff of the parent branch would be provided along with the diff of the new commit, and only the new commit will be shown. It is expected that the client will send the data as part of a :mimetype:`multipart/form-data` mimetype. The main diff's name and content would be stored in the ``path`` field. If a parent diff is provided, its name and content would be stored in the ``parent_diff_path`` field. An example of this would be:: -- SoMe BoUnDaRy Content-Disposition: form-data; name=path; filename="foo.diff" <Unified Diff Content Here> -- SoMe BoUnDaRy -- Extra data can be stored later lookup. See :ref:`webapi2.0-extra-data` for more information. """ # Prevent a circular dependency, as ReviewRequestDraftResource # needs DraftDiffResource, which needs DiffResource. from reviewboard.webapi.resources.review_request_draft import \ ReviewRequestDraftResource try: review_request = \ resources.review_request.get_object(request, *args, **kwargs) except ReviewRequest.DoesNotExist: return DOES_NOT_EXIST if not review_request.is_mutable_by(request.user): return self.get_no_access_error(request) if review_request.repository is None: return INVALID_ATTRIBUTE, { 'reason': 'This review request was created as attachments-' 'only, with no repository.' } form_data = request.POST.copy() form = UploadDiffForm(review_request, form_data, request.FILES, request=request) if not form.is_valid(): return INVALID_FORM_DATA, { 'fields': self._get_form_errors(form), } try: diffset = form.create(request.FILES['path'], request.FILES.get('parent_diff_path')) except FileNotFoundError as e: return REPO_FILE_NOT_FOUND, { 'file': e.path, 'revision': six.text_type(e.revision) } except EmptyDiffError as e: return DIFF_EMPTY except DiffTooBigError as e: return DIFF_TOO_BIG, { 'reason': six.text_type(e), 'max_size': e.max_diff_size, } except Exception as e: # This could be very wrong, but at least they'll see the error. # We probably want a new error type for this. logging.error("Error uploading new diff: %s", e, exc_info=1, request=request) return INVALID_FORM_DATA, {'fields': {'path': [six.text_type(e)]}} discarded_diffset = None try: draft = review_request.draft.get() if draft.diffset and draft.diffset != diffset: discarded_diffset = draft.diffset except ReviewRequestDraft.DoesNotExist: try: draft = ReviewRequestDraftResource.prepare_draft( request, review_request) except PermissionDenied: return self.get_no_access_error(request) draft.diffset = diffset # We only want to add default reviewers the first time. Was bug 318. if review_request.diffset_history.diffsets.count() == 0: draft.add_default_reviewers() draft.save() if extra_fields: try: self.import_extra_data(diffset, diffset.extra_data, extra_fields) except ImportExtraDataError as e: return e.error_payload diffset.save(update_fields=['extra_data']) if discarded_diffset: discarded_diffset.delete() # E-mail gets sent when the draft is saved. return 201, { self.item_result_key: diffset, }
def get_print_name(self): if len(self.items) == 1: current_owner = self.items[0] return current_owner.get_document_filename() else: return six.text_type(self.caption)
def __unicode__(self): return "%s (%s)" % (self.revision, six.text_type(self.repository))
def writerow(self, row): if self.writer is None: self.writer = csv.writer(self.f, dialect=self.dialect, **self.kw) if not PY3: row = [six.text_type(s).encode(self.encoding) for s in row] self.writer.writerow(list(row))
def __str__(self): return six.text_type(self.header)
def custom_method(self): return six.text_type('{}-{}').format(self.name, self.surname)
def __init__(self, message): self.message = message self.reply_channel = self.message.reply_channel self._content_length = 0 self._post_parse_error = False self._read_started = False self.resolver_match = None # Path info self.path = self.message['path'] self.script_name = self.message.get('root_path', '') if self.script_name: # TODO: Better is-prefix checking, slash handling? self.path_info = self.path[len(self.script_name):] else: self.path_info = self.path # HTTP basics self.method = self.message['method'].upper() self.META = { "REQUEST_METHOD": self.method, "QUERY_STRING": self.message.get('query_string', ''), "SCRIPT_NAME": self.script_name, "PATH_INFO": self.path_info, # Old code will need these for a while "wsgi.multithread": True, "wsgi.multiprocess": True, } if self.message.get('client', None): self.META['REMOTE_ADDR'] = self.message['client'][0] self.META['REMOTE_HOST'] = self.META['REMOTE_ADDR'] self.META['REMOTE_PORT'] = self.message['client'][1] if self.message.get('server', None): self.META['SERVER_NAME'] = self.message['server'][0] self.META['SERVER_PORT'] = six.text_type(self.message['server'][1]) else: self.META['SERVER_NAME'] = "unknown" self.META['SERVER_PORT'] = "0" # Handle old style-headers for a transition period if "headers" in self.message and isinstance(self.message['headers'], dict): self.message['headers'] = [ (x.encode("latin1"), y) for x, y in self.message['headers'].items() ] # Headers go into META for name, value in self.message.get('headers', []): name = name.decode("latin1") if name == "content-length": corrected_name = "CONTENT_LENGTH" elif name == "content-type": corrected_name = "CONTENT_TYPE" else: corrected_name = 'HTTP_%s' % name.upper().replace("-", "_") # HTTPbis say only ASCII chars are allowed in headers, but we latin1 just in case value = value.decode("latin1") if corrected_name in self.META: value = self.META[corrected_name] + "," + value self.META[corrected_name] = value # Pull out request encoding if we find it if "CONTENT_TYPE" in self.META: self.content_type, self.content_params = cgi.parse_header( self.META["CONTENT_TYPE"]) if 'charset' in self.content_params: try: codecs.lookup(self.content_params['charset']) except LookupError: pass else: self.encoding = self.content_params['charset'] else: self.content_type, self.content_params = "", {} # Pull out content length info if self.META.get('CONTENT_LENGTH', None): try: self._content_length = int(self.META['CONTENT_LENGTH']) except (ValueError, TypeError): pass # Body handling self._body = message.get("body", b"") if message.get("body_channel", None): body_handle_start = time.time() while True: # Get the next chunk from the request body channel chunk = None while chunk is None: # If they take too long, raise request timeout and the handler # will turn it into a response if time.time( ) - body_handle_start > self.body_receive_timeout: raise RequestTimeout() _, chunk = message.channel_layer.receive_many( [message['body_channel']], block=True, ) # If chunk contains close, abort. if chunk.get("closed", False): raise RequestAborted() # Add content to body self._body += chunk.get("content", "") # Exit loop if this was the last if not chunk.get("more_content", False): break assert isinstance(self._body, six.binary_type), "Body is not bytes" # Add a stream-a-like for the body self._stream = BytesIO(self._body) # Other bits self.resolver_match = None
def _make_hash_value(self, user, timestamp): return ( six.text_type(user.pk) + six.text_type(timestamp) + six.text_type(user.profile.signup_confirmation) )
def _generate_reference(self): obj = hmac.new(key=settings.SECRET_KEY.encode(), msg=six.text_type(self.id).encode()) return obj.hexdigest().upper()
def _make_hash_value(self, user, timestamp): return (six.text_type(user.pk) + six.text_type(timestamp)) + six.text_type(user.is_active)
def test_limit_quotes(self): with self.assertRaises(ValueError) as cm: tag_utils.parse_tags('"adam","brian",chris', 2) e = cm.exception self.assertEqual(six.text_type(e), "This field can only have 2 arguments")
def coerce_result(cls, value): return None if value is None else six.text_type(value)
def show(request, claim_id): """View for reviewing a claim. :param request: the current HTTP Request object :param claim_id: the primary key of the claim to be viewed :type request: HttpRequest :type claim_id: unicode :return: the HTTP response object :rtype: HttpResponse """ _ = ugettext claim = get_object_or_404(models.SampleClaim, pk=utils.convert_id_to_int(claim_id)) is_reviewer = request.user == claim.reviewer or request.user.is_superuser is_requester = request.user == claim.requester if not is_reviewer and not is_requester: raise permissions.PermissionError( request.user, _("You are neither the requester nor the reviewer of this claim.")) if request.method == "POST" and not claim.closed: withdraw_form = CloseForm(_("withdraw claim"), request.POST, prefix="withdraw") if is_requester else None approve_form = CloseForm(_("approve claim"), request.POST, prefix="approve") if is_reviewer else None all_valid = (withdraw_form is None or withdraw_form.is_valid()) and ( approve_form is None or approve_form.is_valid()) referencially_valid = is_referentially_valid(withdraw_form, approve_form) if all_valid and referencially_valid: approved = approve_form and approve_form.cleaned_data["close"] closed = approved or (withdraw_form and withdraw_form.cleaned_data["close"]) response = None if approved: sample_list = list(claim.samples.all()) for sample in sample_list: sample.currently_responsible_person = claim.requester sample.save() sample_enumeration = " " + ",\n ".join( six.text_type(sample) for sample in sample_list) _ = lambda x: x send_email( _("Sample request approved"), _("""Hello {requester}, your sample claim was approved. You are now the “currently responsible person” of the following samples: {samples} JuliaBase. """), claim.requester, { "requester": get_really_full_name(claim.requester), "samples": sample_enumeration }) _ = ugettext response = \ utils.successful_response(request, _("Sample claim {id_} was successfully approved.").format(id_=claim.pk)) if closed: claim.closed = True claim.save() response = response or \ utils.successful_response(request, _("Sample claim {id_} was successfully withdrawn.").format(id_=claim.pk)) return response else: withdraw_form = CloseForm(_("withdraw claim"), prefix="withdraw") if is_requester else None approve_form = CloseForm(_("approve claim"), prefix="approve") if is_reviewer else None return render( request, "samples/show_claim.html", { "title": _("Claim #{number}").format(number=claim_id), "claim": claim, "is_reviewer": is_reviewer, "is_requester": is_requester, "withdraw": withdraw_form, "approve": approve_form })
def __init__(self, translations): if not isinstance(translations, dict): translations = {FALLBACK_LANG: text_type(translations)} self._src = translations
def make_checksum(parsed, unique_values=None): unique_values = unique_values or [] seeds = [parsed] + [six.text_type(v) for v in unique_values] return sha256('+'.join(seeds).encode("utf-8")).hexdigest()
def test_limit(self): with self.assertRaises(ValueError) as cm: tag_utils.parse_tags("adam,brian,chris", 1) e = cm.exception self.assertEqual(six.text_type(e), "This field can only have 1 argument")
def __str__(self): return six.text_type('{} ({})'.format(self.subject, self.language))
class Meta: model = Person fields = (six.text_type('first_name'), )
def assignment_only_unlimited_args(*args): """Expected assignment_only_unlimited_args __doc__""" return "assignment_only_unlimited_args - Expected result: %s" % ', '.join( six.text_type(arg) for arg in args)
def update_id_mapping(self, data): user_id = text_type(data["id"]) screen_name = data["screen_name"] self.screen_name_to_user_id[screen_name.lower()] = user_id self.user_id_to_screen_name[user_id] = screen_name self.user_id_to_photo_url[user_id] = data["profile_image_url_https"]
def simple_only_unlimited_args(*args): """Expected simple_only_unlimited_args __doc__""" return "simple_only_unlimited_args - Expected result: %s" % ', '.join( six.text_type(arg) for arg in args)
def simple_unlimited_args(one, two='hi', *args): """Expected simple_unlimited_args __doc__""" return "simple_unlimited_args - Expected result: %s" % (', '.join( six.text_type(arg) for arg in [one, two] + list(args)))