signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
@lowercase<EOL><INDENT>def hostname(self, levels=<NUM_LIT:1>):<DEDENT> | if levels < <NUM_LIT:1>:<EOL><INDENT>return self.random_element(self.hostname_prefixes) + '<STR_LIT:->' + self.numerify('<STR_LIT>')<EOL><DEDENT>return self.random_element(self.hostname_prefixes) + '<STR_LIT:->' + self.numerify('<STR_LIT>') + '<STR_LIT:.>' + self.domain_name(levels)<EOL> | Produce a hostname with specified number of subdomain levels.
>>> hostname()
db-01.nichols-phillips.com
>>> hostname(0)
laptop-56
>>> hostname(2)
web-12.williamson-hopkins.jackson.com | f13771:c1:m11 |
@lowercase<EOL><INDENT>def domain_name(self, levels=<NUM_LIT:1>):<DEDENT> | if levels < <NUM_LIT:1>:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>if levels == <NUM_LIT:1>:<EOL><INDENT>return self.domain_word() + '<STR_LIT:.>' + self.tld()<EOL><DEDENT>else:<EOL><INDENT>return self.domain_word() + '<STR_LIT:.>' + self.domain_name(levels - <NUM_LIT:1>)<EOL><DEDENT> | Produce an Internet domain name with the specified number of
subdomain levels.
>>> domain_name()
nichols-phillips.com
>>> domain_name(2)
williamson-hopkins.jackson.com | f13771:c1:m12 |
def url(self, schemes=None): | if schemes is None:<EOL><INDENT>schemes = ['<STR_LIT:http>', '<STR_LIT>']<EOL><DEDENT>pattern = '<STR_LIT>'.format(<EOL>self.random_element(schemes) if schemes else "<STR_LIT>",<EOL>self.random_element(self.url_formats),<EOL>)<EOL>return self.generator.parse(pattern)<EOL> | :param schemes: a list of strings to use as schemes, one will chosen randomly.
If None, it will generate http and https urls.
Passing an empty list will result in schemeless url generation like "://domain.com".
:returns: a random url string. | f13771:c1:m15 |
def _random_ipv4_address_from_subnet(self, subnet, network=False): | address = str(<EOL>subnet[self.generator.random.randint(<EOL><NUM_LIT:0>, subnet.num_addresses - <NUM_LIT:1>,<EOL>)],<EOL>)<EOL>if network:<EOL><INDENT>address += '<STR_LIT:/>' + str(self.generator.random.randint(<EOL>subnet.prefixlen,<EOL>subnet.max_prefixlen,<EOL>))<EOL>address = str(ip_network(address, strict=False))<EOL><DEDENT>return address<EOL> | Produces a random IPv4 address or network with a valid CIDR
from within a given subnet.
:param subnet: IPv4Network to choose from within
:param network: Return a network address, and not an IP address | f13771:c1:m16 |
def _exclude_ipv4_networks(self, networks, networks_to_exclude): | for network_to_exclude in networks_to_exclude:<EOL><INDENT>def _exclude_ipv4_network(network):<EOL><INDENT>"""<STR_LIT>"""<EOL>try:<EOL><INDENT>return list(network.address_exclude(network_to_exclude))<EOL><DEDENT>except ValueError:<EOL><INDENT>if network.overlaps(network_to_exclude):<EOL><INDENT>return []<EOL><DEDENT>else:<EOL><INDENT>return [network]<EOL><DEDENT><DEDENT><DEDENT>networks = list(map(_exclude_ipv4_network, networks))<EOL>networks = [<EOL>item for nested in networks for item in nested<EOL>]<EOL><DEDENT>return networks<EOL> | Exclude the list of networks from another list of networks
and return a flat list of new networks.
:param networks: List of IPv4 networks to exclude from
:param networks_to_exclude: List of IPv4 networks to exclude
:returns: Flat list of IPv4 networks | f13771:c1:m17 |
def ipv4_network_class(self): | return self.random_element('<STR_LIT:abc>')<EOL> | Returns a IPv4 network class 'a', 'b' or 'c'.
:returns: IPv4 network class | f13771:c1:m18 |
def ipv4(self, network=False, address_class=None, private=None): | if private is True:<EOL><INDENT>return self.ipv4_private(address_class=address_class,<EOL>network=network)<EOL><DEDENT>elif private is False:<EOL><INDENT>return self.ipv4_public(address_class=address_class,<EOL>network=network)<EOL><DEDENT>if address_class:<EOL><INDENT>all_networks = [_IPv4Constants._network_classes[address_class]]<EOL><DEDENT>else:<EOL><INDENT>all_networks = [ip_network('<STR_LIT>')]<EOL><DEDENT>all_networks = self._exclude_ipv4_networks(<EOL>all_networks,<EOL>_IPv4Constants._excluded_networks,<EOL>)<EOL>random_network = self.generator.random.choice(all_networks)<EOL>return self._random_ipv4_address_from_subnet(random_network, network)<EOL> | Produce a random IPv4 address or network with a valid CIDR.
:param network: Network address
:param address_class: IPv4 address class (a, b, or c)
:param private: Public or private
:returns: IPv4 | f13771:c1:m19 |
def ipv4_private(self, network=False, address_class=None): | <EOL>supernet = _IPv4Constants._network_classes[<EOL>address_class or self.ipv4_network_class()<EOL>]<EOL>private_networks = [<EOL>subnet for subnet in _IPv4Constants._private_networks<EOL>if subnet.overlaps(supernet)<EOL>]<EOL>private_networks = self._exclude_ipv4_networks(<EOL>private_networks,<EOL>_IPv4Constants._excluded_networks,<EOL>)<EOL>private_network = self.generator.random.choice(private_networks)<EOL>return self._random_ipv4_address_from_subnet(private_network, network)<EOL> | Returns a private IPv4.
:param network: Network address
:param address_class: IPv4 address class (a, b, or c)
:returns: Private IPv4 | f13771:c1:m20 |
def ipv4_public(self, network=False, address_class=None): | <EOL>public_networks = [_IPv4Constants._network_classes[<EOL>address_class or self.ipv4_network_class()<EOL>]]<EOL>public_networks = self._exclude_ipv4_networks(<EOL>public_networks,<EOL>_IPv4Constants._private_networks +<EOL>_IPv4Constants._excluded_networks,<EOL>)<EOL>public_network = self.generator.random.choice(public_networks)<EOL>return self._random_ipv4_address_from_subnet(public_network, network)<EOL> | Returns a public IPv4 excluding private blocks.
:param network: Network address
:param address_class: IPv4 address class (a, b, or c)
:returns: Public IPv4 | f13771:c1:m21 |
def ipv6(self, network=False): | address = str(ip_address(self.generator.random.randint(<EOL><NUM_LIT:2> ** IPV4LENGTH, (<NUM_LIT:2> ** IPV6LENGTH) - <NUM_LIT:1>)))<EOL>if network:<EOL><INDENT>address += '<STR_LIT:/>' + str(self.generator.random.randint(<NUM_LIT:0>, IPV6LENGTH))<EOL>address = str(ip_network(address, strict=False))<EOL><DEDENT>return address<EOL> | Produce a random IPv6 address or network with a valid CIDR | f13771:c1:m22 |
@slugify<EOL><INDENT>def slug(self, value=None):<DEDENT> | if value is None:<EOL><INDENT>value = self.generator.text(<NUM_LIT:20>)<EOL><DEDENT>return value<EOL> | Django algorithm | f13771:c1:m28 |
def image_url(self, width=None, height=None): | width_ = width or self.random_int(max=<NUM_LIT>)<EOL>height_ = height or self.random_int(max=<NUM_LIT>)<EOL>placeholder_url = self.random_element(self.image_placeholder_services)<EOL>return placeholder_url.format(width=width_, height=height_)<EOL> | Returns URL to placeholder image
Example: http://placehold.it/640x480 | f13771:c1:m29 |
def romanized_name(self): | pattern = self.random_element(self.romanized_formats)<EOL>return self.generator.parse(pattern)<EOL> | @example 'Chao Bai' | f13791:c0:m0 |
def first_romanized_name(self): | return self.random_element(self.first_romanized_names)<EOL> | @example 'Chao' | f13791:c0:m1 |
def last_romanized_name(self): | return self.random_element(self.last_romanized_names)<EOL> | @example 'Chao' | f13791:c0:m2 |
def romanized_name(self): | pattern = self.random_element(self.romanized_formats)<EOL>return self.generator.parse(pattern)<EOL> | @example 'Chao Bai' | f13795:c0:m0 |
def first_romanized_name(self): | return self.random_element(self.first_romanized_names)<EOL> | @example 'Chao' | f13795:c0:m1 |
def last_romanized_name(self): | return self.random_element(self.last_romanized_names)<EOL> | @example 'Chao' | f13795:c0:m2 |
def checksum_identity_card_number(characters): | weights_for_check_digit = [<NUM_LIT:7>, <NUM_LIT:3>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:7>, <NUM_LIT:3>, <NUM_LIT:1>, <NUM_LIT:7>, <NUM_LIT:3>]<EOL>check_digit = <NUM_LIT:0><EOL>for i in range(<NUM_LIT:3>):<EOL><INDENT>check_digit += weights_for_check_digit[i] * (ord(characters[i]) - <NUM_LIT>)<EOL><DEDENT>for i in range(<NUM_LIT:4>, <NUM_LIT:9>):<EOL><INDENT>check_digit += weights_for_check_digit[i] * characters[i]<EOL><DEDENT>check_digit %= <NUM_LIT:10><EOL>return check_digit<EOL> | Calculates and returns a control digit for given list of characters basing on Identity Card Number standards. | f13797:m0 |
def identity_card_number(self): | identity = []<EOL>for _ in range(<NUM_LIT:3>):<EOL><INDENT>identity.append(self.random_letter().upper())<EOL><DEDENT>identity.append(<NUM_LIT:0>)<EOL>for _ in range(<NUM_LIT:5>):<EOL><INDENT>identity.append(self.random_digit())<EOL><DEDENT>identity[<NUM_LIT:3>] = checksum_identity_card_number(identity)<EOL>return '<STR_LIT>'.join(str(character) for character in identity)<EOL> | Returns 9 character Polish Identity Card Number,
Polish: Numer Dowodu Osobistego.
The card number consists of 3 letters followed by 6 digits (for example, ABA300000),
of which the first digit (at position 3) is the check digit.
https://en.wikipedia.org/wiki/Polish_identity_card | f13797:c0:m1 |
def name(self): | pattern = self.random_element(self.formats)<EOL>return self.generator.parse(pattern)<EOL> | :example 'John Doe' | f13821:c0:m0 |
def kana_name(self): | pattern = self.random_element(self.kana_formats)<EOL>return self.generator.parse(pattern)<EOL> | @example 'アオタ アキラ' | f13828:c0:m0 |
def first_kana_name(self): | return self.random_element(self.first_kana_names)<EOL> | @example 'アキラ' | f13828:c0:m1 |
def last_kana_name(self): | return self.random_element(self.last_kana_names)<EOL> | @example 'アオタ' | f13828:c0:m4 |
def romanized_name(self): | pattern = self.random_element(self.romanized_formats)<EOL>return self.generator.parse(pattern)<EOL> | @example 'Akira Aota' | f13828:c0:m5 |
def first_romanized_name(self): | return self.random_element(self.first_romanized_names)<EOL> | @example 'Akira' | f13828:c0:m6 |
def last_romanized_name(self): | return self.random_element(self.last_romanized_names)<EOL> | @example 'Aota' | f13828:c0:m9 |
def ssn(self): | def _checksum(digits):<EOL><INDENT>evensum = sum(digits[:-<NUM_LIT:1>:<NUM_LIT:2>])<EOL>oddsum = sum(digits[<NUM_LIT:1>::<NUM_LIT:2>])<EOL>return (<NUM_LIT:10> - ((evensum + oddsum * <NUM_LIT:3>) % <NUM_LIT:10>)) % <NUM_LIT:10><EOL><DEDENT>digits = [<NUM_LIT:7>, <NUM_LIT:5>, <NUM_LIT:6>]<EOL>digits += self.generator.random.sample(range(<NUM_LIT:10>), <NUM_LIT:9>)<EOL>digits.append(_checksum(digits))<EOL>digits = '<STR_LIT>'.join([str(d) for d in digits])<EOL>ssn = digits[:<NUM_LIT:3>] + '<STR_LIT:.>'+ digits[<NUM_LIT:3>:<NUM_LIT:7>] + '<STR_LIT:.>'+ digits[<NUM_LIT:7>:<NUM_LIT:11>] + '<STR_LIT:.>'+ digits[<NUM_LIT:11>:]<EOL>return ssn<EOL> | Returns a 13 digits Swiss SSN named AHV (German) or
AVS (French and Italian)
See: http://www.bsv.admin.ch/themen/ahv/00011/02185/ | f13837:c0:m0 |
def vat_id(self): | def _checksum(digits):<EOL><INDENT>code = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT:4>', '<STR_LIT:2>', '<STR_LIT:3>', '<STR_LIT:5>', '<STR_LIT>', '<STR_LIT>']<EOL>remainder = <NUM_LIT:11>-(sum(map(lambda x, y: int(x) * int(y), code, digits)) % <NUM_LIT:11>)<EOL>if remainder == <NUM_LIT:10>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>elif remainder == <NUM_LIT:11>:<EOL><INDENT>return <NUM_LIT:5><EOL><DEDENT>return remainder<EOL><DEDENT>vat_id = self.bothify('<STR_LIT>')<EOL>return '<STR_LIT>' + vat_id + str(_checksum(vat_id))<EOL> | :return: Swiss UID number | f13837:c0:m1 |
def vat_id(self): | return self.bothify(self.random_element(self.vat_id_formats))<EOL> | http://ec.europa.eu/taxation_customs/vies/faq.html#item_11
:return: A random Bulgarian VAT ID | f13838:c0:m0 |
def ssn(self): | <EOL>def _checksum(digits):<EOL><INDENT>factors = (<NUM_LIT:9>, <NUM_LIT:8>, <NUM_LIT:7>, <NUM_LIT:6>, <NUM_LIT:5>, <NUM_LIT:4>, <NUM_LIT:3>, <NUM_LIT:2>, -<NUM_LIT:1>)<EOL>s = <NUM_LIT:0><EOL>for i in range(len(digits)):<EOL><INDENT>s += digits[i] * factors[i]<EOL><DEDENT>return s<EOL><DEDENT>while True:<EOL><INDENT>digits = self.generator.random.sample(range(<NUM_LIT:10>), <NUM_LIT:8>)<EOL>s = _checksum(digits)<EOL>digits.append((s % <NUM_LIT:11>) % <NUM_LIT:10>)<EOL>if <NUM_LIT:0> == (_checksum(digits) % <NUM_LIT:11>):<EOL><INDENT>break<EOL><DEDENT><DEDENT>bsn = "<STR_LIT>".join([str(e) for e in digits])<EOL>return bsn<EOL> | Returns a 9 digits Dutch SSN called "burgerservicenummer (BSN)".
the Dutch "burgerservicenummer (BSN)" needs to pass the "11-proef",
which is a check digit approach; this function essentially reverses
the checksum steps to create a random valid BSN (which is 9 digits). | f13839:c0:m0 |
def vat_id(self): | return self.bothify(self.random_element(self.vat_id_formats))<EOL> | http://ec.europa.eu/taxation_customs/vies/faq.html#item_11
:return: A random Dutch VAT ID | f13839:c0:m1 |
def vat_id(self): | return self.bothify(self.random_element(self.vat_id_formats))<EOL> | http://ec.europa.eu/taxation_customs/vies/faq.html#item_11
:return: a random Lithuanian VAT ID | f13841:c0:m0 |
def vat_id(self): | return self.bothify(self.random_element(self.vat_id_formats))<EOL> | http://ec.europa.eu/taxation_customs/vies/faq.html#item_11
:return: A random Romanian VAT ID | f13842:c0:m0 |
def ssn(self, min_age=<NUM_LIT>, max_age=<NUM_LIT>): | def _luhn_checksum(number):<EOL><INDENT>def digits_of(n):<EOL><INDENT>return [int(d) for d in str(n)]<EOL><DEDENT>digits = digits_of(number)<EOL>odd_digits = digits[-<NUM_LIT:1>::-<NUM_LIT:2>]<EOL>even_digits = digits[-<NUM_LIT:2>::-<NUM_LIT:2>]<EOL>checksum = <NUM_LIT:0><EOL>checksum += sum(odd_digits)<EOL>for d in even_digits:<EOL><INDENT>checksum += sum(digits_of(d * <NUM_LIT:2>))<EOL><DEDENT>return checksum % <NUM_LIT:10><EOL><DEDENT>def _calculate_luhn(partial_number):<EOL><INDENT>check_digit = _luhn_checksum(int(partial_number) * <NUM_LIT:10>)<EOL>return check_digit if check_digit == <NUM_LIT:0> else <NUM_LIT:10> - check_digit<EOL><DEDENT>age = datetime.timedelta(<EOL>days=self.generator.random.randrange(min_age * <NUM_LIT>, max_age * <NUM_LIT>))<EOL>birthday = datetime.datetime.now() - age<EOL>pnr_date = birthday.strftime('<STR_LIT>')<EOL>suffix = str(self.generator.random.randrange(<NUM_LIT:0>, <NUM_LIT>)).zfill(<NUM_LIT:3>)<EOL>luhn_checksum = str(_calculate_luhn(pnr_date + suffix))<EOL>pnr = '<STR_LIT>'.format(pnr_date, suffix, luhn_checksum)<EOL>return pnr<EOL> | Returns a 10 digit Swedish SSN, "Personnummer".
It consists of 10 digits in the form YYMMDD-SSGQ, where
YYMMDD is the date of birth, SSS is a serial number
and Q is a control character (Luhn checksum).
http://en.wikipedia.org/wiki/Personal_identity_number_(Sweden) | f13843:c0:m0 |
def vat_id(self): | return self.bothify(self.random_element(self.vat_id_formats))<EOL> | http://ec.europa.eu/taxation_customs/vies/faq.html#item_11
:return: A random Swedish VAT ID | f13843:c0:m1 |
def checksum(digits): | weights_for_check_digit = [<NUM_LIT:9>, <NUM_LIT:7>, <NUM_LIT:3>, <NUM_LIT:1>, <NUM_LIT:9>, <NUM_LIT:7>, <NUM_LIT:3>, <NUM_LIT:1>, <NUM_LIT:9>, <NUM_LIT:7>]<EOL>check_digit = <NUM_LIT:0><EOL>for i in range(<NUM_LIT:0>, <NUM_LIT:10>):<EOL><INDENT>check_digit += weights_for_check_digit[i] * digits[i]<EOL><DEDENT>check_digit %= <NUM_LIT:10><EOL>return check_digit<EOL> | Calculates and returns a control digit for given list of digits basing on PESEL standard. | f13845:m0 |
def calculate_month(birth_date): | year = int(birth_date.strftime('<STR_LIT>'))<EOL>month = int(birth_date.strftime('<STR_LIT>')) + ((int(year / <NUM_LIT:100>) - <NUM_LIT>) % <NUM_LIT:5>) * <NUM_LIT:20><EOL>return month<EOL> | Calculates and returns a month number basing on PESEL standard. | f13845:m1 |
def ssn(self): | birth_date = self.generator.date_time()<EOL>year_without_century = int(birth_date.strftime('<STR_LIT>'))<EOL>month = calculate_month(birth_date)<EOL>day = int(birth_date.strftime('<STR_LIT>'))<EOL>pesel_digits = [<EOL>int(year_without_century / <NUM_LIT:10>),<EOL>year_without_century % <NUM_LIT:10>,<EOL>int(month / <NUM_LIT:10>),<EOL>month % <NUM_LIT:10>,<EOL>int(day / <NUM_LIT:10>), day % <NUM_LIT:10>,<EOL>]<EOL>for _ in range(<NUM_LIT:4>):<EOL><INDENT>pesel_digits.append(self.random_digit())<EOL><DEDENT>pesel_digits.append(checksum(pesel_digits))<EOL>return '<STR_LIT>'.join(str(digit) for digit in pesel_digits)<EOL> | Returns 11 character Polish national identity code (Public Electronic Census System,
Polish: Powszechny Elektroniczny System Ewidencji Ludności - PESEL).
It has the form YYMMDDZZZXQ, where YYMMDD is the date of birth (with century
encoded in month field), ZZZ is the personal identification number, X denotes sex
(even for females, odd for males) and Q is a parity number.
https://en.wikipedia.org/wiki/National_identification_number#Poland | f13845:c0:m0 |
def vat_id(self): | return self.bothify(self.random_element(self.vat_id_formats))<EOL> | http://ec.europa.eu/taxation_customs/vies/faq.html#item_11
:return: A random Polish VAT ID | f13845:c0:m1 |
def ssn(self): | digits = []<EOL>for digit in str((self.generator.date_object() -<EOL>date(<NUM_LIT>, <NUM_LIT:12>, <NUM_LIT>)).days):<EOL><INDENT>digits.append(int(digit))<EOL><DEDENT>for _ in range(<NUM_LIT:4>):<EOL><INDENT>digits.append(self.random_int(<NUM_LIT:0>, <NUM_LIT:9>))<EOL><DEDENT>checksum = (digits[<NUM_LIT:0>] * -<NUM_LIT:1> + digits[<NUM_LIT:1>] * <NUM_LIT:5> + digits[<NUM_LIT:2>] * <NUM_LIT:7> + digits[<NUM_LIT:3>] * <NUM_LIT:9> +<EOL>digits[<NUM_LIT:4>] * <NUM_LIT:4> + digits[<NUM_LIT:5>] * <NUM_LIT:6> + digits[<NUM_LIT:6>] * <NUM_LIT:10> + digits[<NUM_LIT:7>] * <NUM_LIT:5> +<EOL>digits[<NUM_LIT:8>] * <NUM_LIT:7>)<EOL>digits.append(checksum % <NUM_LIT:11> % <NUM_LIT:10>)<EOL>return '<STR_LIT>'.join(str(digit) for digit in digits)<EOL> | Ukrainian "Реєстраційний номер облікової картки платника податків"
also known as "Ідентифікаційний номер фізичної особи". | f13846:c0:m0 |
def ssn(self, min_age=<NUM_LIT:0>, max_age=<NUM_LIT>, artificial=False): | def _checksum(hetu):<EOL><INDENT>checksum_characters = "<STR_LIT>"<EOL>return checksum_characters[int(hetu) % <NUM_LIT>]<EOL><DEDENT>age = datetime.timedelta(<EOL>days=self.generator.random.randrange(min_age * <NUM_LIT>, max_age * <NUM_LIT>))<EOL>birthday = datetime.date.today() - age<EOL>hetu_date = "<STR_LIT>" % (<EOL>birthday.day, birthday.month, str(birthday.year)[-<NUM_LIT:2>:])<EOL>range = (<NUM_LIT>, <NUM_LIT>) if artificial is True else (<NUM_LIT:2>, <NUM_LIT>)<EOL>suffix = str(self.generator.random.randrange(*range)).zfill(<NUM_LIT:3>)<EOL>checksum = _checksum(hetu_date + suffix)<EOL>separator = self._get_century_code(birthday.year)<EOL>hetu = "<STR_LIT>".join([hetu_date, separator, suffix, checksum])<EOL>return hetu<EOL> | Returns 11 character Finnish personal identity code (Henkilötunnus,
HETU, Swedish: Personbeteckning). This function assigns random
gender to person.
HETU consists of eleven characters of the form DDMMYYCZZZQ, where
DDMMYY is the date of birth, C the century sign, ZZZ the individual
number and Q the control character (checksum). The sign for the
century is either + (1800–1899), - (1900–1999), or A (2000–2099).
The individual number ZZZ is odd for males and even for females.
For people born in Finland its range is 002-899
(larger numbers may be used in special cases).
An example of a valid code is 311280-888Y.
https://en.wikipedia.org/wiki/National_identification_number#Finland | f13847:c0:m0 |
@staticmethod<EOL><INDENT>def _get_century_code(year):<DEDENT> | if <NUM_LIT> <= year < <NUM_LIT>:<EOL><INDENT>separator = '<STR_LIT:A>'<EOL><DEDENT>elif <NUM_LIT> <= year < <NUM_LIT>:<EOL><INDENT>separator = '<STR_LIT:->'<EOL><DEDENT>elif <NUM_LIT> <= year < <NUM_LIT>:<EOL><INDENT>separator = '<STR_LIT:+>'<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return separator<EOL> | Returns the century code for a given year | f13847:c0:m1 |
def vat_id(self): | return self.bothify(self.random_element(self.vat_id_formats))<EOL> | http://ec.europa.eu/taxation_customs/vies/faq.html#item_11
:return: A random Finnish VAT ID | f13847:c0:m2 |
def checksum(value): | return chr(<NUM_LIT> + sum(CHECKSUM_TABLE[index % <NUM_LIT:2>][ALPHANUMERICS_DICT[char]]<EOL>for index, char in enumerate(value)) % <NUM_LIT>)<EOL> | Calculates the checksum char used for the 16th char.
Author: Vincenzo Palazzo | f13848:m0 |
def vat_id(self): | return self.bothify(self.random_element(self.vat_id_formats))<EOL> | http://ec.europa.eu/taxation_customs/vies/faq.html#item_11
:return: A random Italian VAT ID | f13848:c0:m1 |
def vat_id(self): | return self.bothify(self.random_element(self.vat_id_formats))<EOL> | http://ec.europa.eu/taxation_customs/vies/faq.html#item_11
:return: a random Latvian VAT ID | f13849:c0:m0 |
def vat_id(self): | return self.bothify(self.random_element(self.vat_id_formats))<EOL> | http://ec.europa.eu/taxation_customs/vies/faq.html#item_11
:return: a random Greek VAT ID | f13850:c0:m0 |
def ssn(self): | newID = str(self.generator.random.randrange(<NUM_LIT>, <NUM_LIT>))<EOL>newID = newID.zfill(<NUM_LIT:8>)<EOL>theSum = <NUM_LIT:0><EOL>indexRange = [<NUM_LIT:0>, <NUM_LIT:2>, <NUM_LIT:4>, <NUM_LIT:6>]<EOL>for i in indexRange:<EOL><INDENT>digit = newID[i]<EOL>num = int(digit)<EOL>theSum = theSum + num<EOL>num = int(newID[i + <NUM_LIT:1>]) * <NUM_LIT:2><EOL>if num > <NUM_LIT:9>:<EOL><INDENT>num = int(str(num)[<NUM_LIT:0>]) + int(str(num)[<NUM_LIT:1>])<EOL><DEDENT>theSum = theSum + num<EOL><DEDENT>lastDigit = theSum % <NUM_LIT:10><EOL>if lastDigit != <NUM_LIT:0>:<EOL><INDENT>lastDigit = <NUM_LIT:10> - lastDigit<EOL><DEDENT>return str(newID) + str(lastDigit)<EOL> | Returns an Israeli identity number, known as Teudat Zehut ("tz").
https://en.wikipedia.org/wiki/Israeli_identity_card | f13851:c0:m0 |
def itin(self): | area = self.random_int(min=<NUM_LIT>, max=<NUM_LIT>)<EOL>serial = self.random_int(min=<NUM_LIT:0>, max=<NUM_LIT>)<EOL>group = random.choice([x for x in range(<NUM_LIT>, <NUM_LIT:100>) if x not in [<NUM_LIT>, <NUM_LIT>]])<EOL>itin = "<STR_LIT>".format(area, group, serial)<EOL>return itin<EOL> | Generate a random United States Individual Taxpayer Identification Number (ITIN).
An United States Individual Taxpayer Identification Number
(ITIN) is a tax processing number issued by the Internal
Revenue Service. It is a nine-digit number that always begins
with the number 9 and has a range of 70-88 in the fourth and
fifth digit. Effective April 12, 2011, the range was extended
to include 900-70-0000 through 999-88-9999, 900-90-0000
through 999-92-9999 and 900-94-0000 through 999-99-9999.
https://www.irs.gov/individuals/international-taxpayers/general-itin-information | f13852:c0:m0 |
def ein(self): | <EOL>ein_prefix_choices = [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>']<EOL>ein_prefix = random.choice(ein_prefix_choices)<EOL>sequence = self.random_int(min=<NUM_LIT:0>, max=<NUM_LIT>)<EOL>ein = "<STR_LIT>".format(ein_prefix, sequence)<EOL>return ein<EOL> | Generate a random United States Employer Identification Number (EIN).
An United States An Employer Identification Number (EIN) is
also known as a Federal Tax Identification Number, and is
used to identify a business entity. EINs follow a format of a
two-digit prefix followed by a hyphen and a seven-digit sequence:
##-######
https://www.irs.gov/businesses/small-businesses-self-employed/employer-id-numbers | f13852:c0:m1 |
def ssn(self, taxpayer_identification_number_type=SSN_TYPE): | if taxpayer_identification_number_type == self.ITIN_TYPE:<EOL><INDENT>return self.itin()<EOL><DEDENT>elif taxpayer_identification_number_type == self.EIN_TYPE:<EOL><INDENT>return self.ein()<EOL><DEDENT>elif taxpayer_identification_number_type == self.SSN_TYPE:<EOL><INDENT>area = self.random_int(min=<NUM_LIT:1>, max=<NUM_LIT>)<EOL>if area == <NUM_LIT>:<EOL><INDENT>area += <NUM_LIT:1><EOL><DEDENT>group = self.random_int(<NUM_LIT:1>, <NUM_LIT>)<EOL>serial = self.random_int(<NUM_LIT:1>, <NUM_LIT>)<EOL>ssn = "<STR_LIT>".format(area, group, serial)<EOL>return ssn<EOL><DEDENT>else:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT> | Generate a random United States Taxpayer Identification Number of the specified type.
If no type is specified, a US SSN is returned. | f13852:c0:m2 |
def vat_id(self): | return self.bothify(self.random_element(self.vat_id_formats))<EOL> | http://ec.europa.eu/taxation_customs/vies/faq.html#item_11
:return: A random Maltese VAT ID | f13853:c0:m0 |
def vat_id(self): | return self.bothify(self.random_element(self.vat_id_formats))<EOL> | http://ec.europa.eu/taxation_customs/vies/faq.html#item_11
:return: A random Portuguese VAT ID | f13854:c0:m0 |
def vat_id(self): | return self.bothify(self.random_element(self.vat_id_formats))<EOL> | http://ec.europa.eu/taxation_customs/vies/faq.html#item_11
:return: a random Spanish VAT ID | f13855:c0:m0 |
def nie(self): | first_chr = random.randrange(<NUM_LIT:0>, <NUM_LIT:3>)<EOL>doi_body = str(random.randrange(<NUM_LIT:0>, <NUM_LIT>)).zfill(<NUM_LIT:7>)<EOL>control = self._calculate_control_doi(str(first_chr) + doi_body)<EOL>return "<STR_LIT>"[first_chr] + doi_body + control<EOL> | https://es.wikipedia.org/wiki/N%C3%BAmero_de_identidad_de_extranjero
:return: a random Spanish NIE | f13855:c0:m1 |
def nif(self): | nie_body = str(random.randrange(<NUM_LIT:0>, <NUM_LIT>)) <EOL>return nie_body.zfill(<NUM_LIT:8>) + self._calculate_control_doi(nie_body)<EOL> | https://es.wikipedia.org/wiki/N%C3%BAmero_de_identificaci%C3%B3n_fiscal
:return: NIF | f13855:c0:m2 |
def cif(self): | first_chr = random.choice('<STR_LIT>')<EOL>doi_body = str(random.randrange(<NUM_LIT:0>, <NUM_LIT>)).zfill(<NUM_LIT:7>)<EOL>cif = first_chr + doi_body<EOL>return cif + self._calculate_control_cif(cif)<EOL> | https://es.wikipedia.org/wiki/C%C3%B3digo_de_identificaci%C3%B3n_fiscal
:return: a random Spanish CIF | f13855:c0:m3 |
def doi(self): | return random.choice([self.cif, self.nie, self.nif])()<EOL> | https://es.wikipedia.org/wiki/Identificador_de_objeto_digital
:return: a random Spanish CIF or NIE or NIF | f13855:c0:m4 |
@staticmethod<EOL><INDENT>def _calculate_control_doi(doi):<DEDENT> | lookup = '<STR_LIT>'<EOL>return lookup[int(doi) % <NUM_LIT>]<EOL> | Calculate the letter that corresponds to the end of a DOI
:param doi: calculated value so far needing a control character
:return: DOI control character | f13855:c0:m5 |
@classmethod<EOL><INDENT>def _calculate_control_cif(cls, cif):<DEDENT> | sum_ = <NUM_LIT:0><EOL>first_chr, cif_value = cif[<NUM_LIT:0>], cif[<NUM_LIT:1>:]<EOL>for index, char in enumerate(cif_value):<EOL><INDENT>if index % <NUM_LIT:2>:<EOL><INDENT>sum_ += int(char)<EOL><DEDENT>else:<EOL><INDENT>sum_ += sum(map(int, str(int(char) * <NUM_LIT:2>)))<EOL><DEDENT><DEDENT>if sum_ > <NUM_LIT:10>:<EOL><INDENT>sum_ = int(str(sum_)[-<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>sum_ = sum_<EOL><DEDENT>sum_ = <NUM_LIT:10> - (sum_ % <NUM_LIT:10>)<EOL>if first_chr in ['<STR_LIT:F>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:N>', '<STR_LIT:P>', '<STR_LIT>', '<STR_LIT:R>', '<STR_LIT:S>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>return chr(<NUM_LIT:64> + sum_)<EOL><DEDENT>elif first_chr in ['<STR_LIT:A>', '<STR_LIT:B>', '<STR_LIT:C>', '<STR_LIT:D>', '<STR_LIT:E>', '<STR_LIT:F>', '<STR_LIT>', '<STR_LIT:H>', '<STR_LIT:L>', '<STR_LIT:M>']:<EOL><INDENT>if sum_ == <NUM_LIT:10>:<EOL><INDENT>sum_ = <NUM_LIT:0><EOL><DEDENT>return str(sum_)<EOL><DEDENT>else: <EOL><INDENT>return cls._calculate_control_doi(cif)<EOL><DEDENT> | Calculate the letter that corresponds to the end of a CIF
:param cif: calculated value so far needing a control character
:return: CIF control character
Code was converted from the minified js of: https://generadordni.es/ | f13855:c0:m6 |
def vat_id(self): | return self.bothify(self.random_element(self.vat_id_formats))<EOL> | http://ec.europa.eu/taxation_customs/vies/faq.html#item_11
:return: a random Slovenian VAT ID | f13857:c0:m0 |
def vat_id(self): | return self.bothify(self.random_element(self.vat_id_formats))<EOL> | http://ec.europa.eu/taxation_customs/vies/faq.html#item_11
:return: a random Austrian VAT ID | f13858:c0:m0 |
def ssn(self): | <EOL>def _checksum(digits):<EOL><INDENT>res = <NUM_LIT> - (digits % <NUM_LIT>)<EOL>return res<EOL><DEDENT>mydate = self.generator.date()<EOL>elms = mydate.split("<STR_LIT:->")<EOL>if elms[<NUM_LIT:0>][<NUM_LIT:0>] == '<STR_LIT:2>':<EOL><INDENT>above = True<EOL><DEDENT>else:<EOL><INDENT>above = False<EOL><DEDENT>elms[<NUM_LIT:0>] = elms[<NUM_LIT:0>][<NUM_LIT:2>:<NUM_LIT:4>]<EOL>seq = self.generator.random_int(<NUM_LIT:1>, <NUM_LIT>)<EOL>seq_str = "<STR_LIT>".format(seq)<EOL>elms.append(seq_str)<EOL>date_as_int = int("<STR_LIT>".join(elms))<EOL>if above:<EOL><INDENT>date_as_int += <NUM_LIT><EOL><DEDENT>s = _checksum(date_as_int)<EOL>s_rjust = "<STR_LIT>".format(s)<EOL>elms.append(s_rjust)<EOL>return "<STR_LIT>".join(elms)<EOL> | Returns a 11 digits Belgian SSN called "rijksregisternummer" as a string
The first 6 digits represent the birthdate with (in order) year, month and day.
The second group of 3 digits is represents a sequence number (order of birth).
It is even for women and odd for men.
For men the range starts at 1 and ends 997, for women 2 until 998.
The third group of 2 digits is a checksum based on the previous 9 digits (modulo 97).
Divide those 9 digits by 97, subtract the remainder from 97 and that's the result.
For persons born in or after 2000, the 9 digit number needs to be proceeded by a 2
(add 2000000000) before the division by 97. | f13860:c0:m0 |
def vat_id(self): | return self.bothify(self.random_element(self.vat_id_formats))<EOL> | http://ec.europa.eu/taxation_customs/vies/faq.html#item_11
:return: A random Belgian VAT ID | f13860:c0:m1 |
def checksum(digits): | remainder = <NUM_LIT:10><EOL>for digit in digits:<EOL><INDENT>remainder = (remainder + digit) % <NUM_LIT:10><EOL>if remainder == <NUM_LIT:0>:<EOL><INDENT>remainder = <NUM_LIT:10><EOL><DEDENT>remainder = (remainder * <NUM_LIT:2>) % <NUM_LIT:11><EOL><DEDENT>control_digit = <NUM_LIT:11> - remainder<EOL>if control_digit == <NUM_LIT:10>:<EOL><INDENT>control_digit = <NUM_LIT:0><EOL><DEDENT>return control_digit<EOL> | Calculate and return control digit for given list of digits based on
ISO7064, MOD 11,10 standard. | f13861:m0 |
def vat_id(self): | return self.bothify(self.random_element(self.vat_id_formats))<EOL> | http://ec.europa.eu/taxation_customs/vies/faq.html#item_11
:return: A random Croatian VAT ID | f13861:c0:m1 |
def checksum(digits, scale): | chk_nbr = <NUM_LIT:11> - (sum(map(operator.mul, digits, scale)) % <NUM_LIT:11>)<EOL>if chk_nbr == <NUM_LIT:11>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>return chk_nbr<EOL> | Calculate checksum of Norwegian personal identity code.
Checksum is calculated with "Module 11" method using a scale.
The digits of the personal code are multiplied by the corresponding
number in the scale and summed;
if remainder of module 11 of the sum is less than 10, checksum is the
remainder.
If remainder is 0, the checksum is 0.
https://no.wikipedia.org/wiki/F%C3%B8dselsnummer | f13862:m0 |
def ssn(self, dob=None, gender=None): | if dob:<EOL><INDENT>birthday = datetime.datetime.strptime(dob, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>age = datetime.timedelta(<EOL>days=self.generator.random.randrange(<NUM_LIT> * <NUM_LIT>, <NUM_LIT> * <NUM_LIT>))<EOL>birthday = datetime.datetime.now() - age<EOL><DEDENT>if not gender:<EOL><INDENT>gender = self.generator.random.choice(('<STR_LIT:F>', '<STR_LIT:M>'))<EOL><DEDENT>elif gender not in ('<STR_LIT:F>', '<STR_LIT:M>'):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>while True:<EOL><INDENT>if <NUM_LIT> <= birthday.year <= <NUM_LIT>:<EOL><INDENT>suffix = str(self.generator.random.randrange(<NUM_LIT:0>, <NUM_LIT>))<EOL><DEDENT>elif <NUM_LIT> <= birthday.year <= <NUM_LIT>:<EOL><INDENT>suffix = str(self.generator.random.randrange(<NUM_LIT:50>, <NUM_LIT>))<EOL><DEDENT>elif <NUM_LIT> <= birthday.year <= <NUM_LIT>:<EOL><INDENT>suffix = str(self.generator.random.randrange(<NUM_LIT:50>, <NUM_LIT>))<EOL><DEDENT>elif <NUM_LIT> <= birthday.year <= <NUM_LIT>:<EOL><INDENT>suffix = str(self.generator.random.randrange(<NUM_LIT>, <NUM_LIT>))<EOL><DEDENT>if gender == '<STR_LIT:F>':<EOL><INDENT>gender_num = self.generator.random.choice((<NUM_LIT:0>, <NUM_LIT:2>, <NUM_LIT:4>, <NUM_LIT:6>, <NUM_LIT:8>))<EOL><DEDENT>elif gender == '<STR_LIT:M>':<EOL><INDENT>gender_num = self.generator.random.choice((<NUM_LIT:1>, <NUM_LIT:3>, <NUM_LIT:5>, <NUM_LIT:7>, <NUM_LIT:9>))<EOL><DEDENT>pnr = birthday.strftime('<STR_LIT>') + suffix.zfill(<NUM_LIT:2>) + str(gender_num)<EOL>pnr_nums = [int(ch) for ch in pnr]<EOL>k1 = checksum(Provider.scale1, pnr_nums)<EOL>k2 = checksum(Provider.scale2, pnr_nums + [k1])<EOL>if k1 == <NUM_LIT:10> or k2 == <NUM_LIT:10>:<EOL><INDENT>continue<EOL><DEDENT>pnr += '<STR_LIT>'.format(k1, k2)<EOL>return pnr<EOL><DEDENT> | Returns 11 character Norwegian personal identity code (Fødselsnummer).
A Norwegian personal identity code consists of 11 digits, without any
whitespace or other delimiters. The form is DDMMYYIIICC, where III is
a serial number separating persons born oh the same date with different
intervals depending on the year they are born. CC is two checksums.
https://en.wikipedia.org/wiki/National_identification_number#Norway
:param dob: date of birth as a "YYYYMMDD" string
:type dob: str
:param gender: gender of the person - "F" for female, M for male.
:type gender: str
:return: Fødselsnummer in str format (11 digs)
:rtype: str | f13862:c0:m0 |
def vat_id(self): | return self.bothify(self.random_element(self.vat_id_formats))<EOL> | http://ec.europa.eu/taxation_customs/vies/faq.html#item_11
:return: A random Czech VAT ID | f13863:c0:m0 |
def checksum(sin): | <EOL>checksumCollection = list(sin.replace('<STR_LIT:U+0020>', '<STR_LIT>'))<EOL>checksumCollection = [int(i) for i in checksumCollection]<EOL>checksumCollection[-<NUM_LIT:1>] = <NUM_LIT:0><EOL>for i in range(<NUM_LIT:1>, len(checksumCollection), <NUM_LIT:2>):<EOL><INDENT>result = checksumCollection[i] * <NUM_LIT:2><EOL>if result < <NUM_LIT:10>:<EOL><INDENT>checksumCollection[i] = result<EOL><DEDENT>else:<EOL><INDENT>checksumCollection[i] = result - <NUM_LIT:10> + <NUM_LIT:1><EOL><DEDENT><DEDENT>check_digit = <NUM_LIT:10> - (sum(checksumCollection) % <NUM_LIT:10>)<EOL>check_digit = (<NUM_LIT:0> if check_digit == <NUM_LIT:10> else check_digit)<EOL>return check_digit<EOL> | Determine validity of a Canadian Social Insurance Number.
Validation is performed using a modified Luhn Algorithm. To check
the Every second digit of the SIN is doubled and the result is
summed. If the result is a multiple of ten, the Social Insurance
Number is considered valid.
https://en.wikipedia.org/wiki/Social_Insurance_Number | f13864:m0 |
def vat_id(self): | return self.bothify(self.random_element(self.vat_id_formats))<EOL> | http://ec.europa.eu/taxation_customs/vies/faq.html#item_11
:return: a random Slovakian VAT ID | f13865:c0:m0 |
def vat_id(self): | return self.bothify(self.random_element(self.vat_id_formats))<EOL> | http://ec.europa.eu/taxation_customs/vies/faq.html#item_11
:return: A random British VAT ID | f13866:c0:m1 |
def vat_id(self): | return self.bothify(self.random_element(self.vat_id_formats))<EOL> | http://ec.europa.eu/taxation_customs/vies/faq.html#item_11
:return: a random Luxembourgish VAT ID | f13868:c0:m0 |
def ssn(self, dob=None, gender=None): | <EOL>if dob:<EOL><INDENT>E = int(dob[<NUM_LIT:0>:<NUM_LIT:2>])<EOL>H = int(dob[<NUM_LIT:2>:<NUM_LIT:4>])<EOL>N = int(dob[<NUM_LIT:4>:<NUM_LIT:6>])<EOL>if E <= <NUM_LIT>:<EOL><INDENT>if gender:<EOL><INDENT>if gender.upper() == "<STR_LIT:F>":<EOL><INDENT>M = <NUM_LIT:4><EOL><DEDENT>elif gender.upper() == "<STR_LIT:M>":<EOL><INDENT>M = <NUM_LIT:3><EOL><DEDENT>else:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>M = self.generator.random_int(<NUM_LIT:3>, <NUM_LIT:4>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if gender:<EOL><INDENT>if gender.upper() == "<STR_LIT:F>":<EOL><INDENT>M = <NUM_LIT:2><EOL><DEDENT>elif gender.upper() == "<STR_LIT:M>":<EOL><INDENT>M = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>M = self.generator.random_int(<NUM_LIT:1>, <NUM_LIT:2>)<EOL><DEDENT><DEDENT><DEDENT>elif gender:<EOL><INDENT>E = self.generator.random_int(<NUM_LIT>, <NUM_LIT>)<EOL>H = self.generator.random_int(<NUM_LIT:1>, <NUM_LIT:12>)<EOL>N = self.generator.random_int(<NUM_LIT:1>, <NUM_LIT:30>)<EOL>if gender.upper() == "<STR_LIT:F>":<EOL><INDENT>M = <NUM_LIT:2><EOL><DEDENT>elif gender.upper() == "<STR_LIT:M>":<EOL><INDENT>M = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>M = self.generator.random_int(<NUM_LIT:1>, <NUM_LIT:2>)<EOL>E = self.generator.random_int(<NUM_LIT>, <NUM_LIT>)<EOL>H = self.generator.random_int(<NUM_LIT:1>, <NUM_LIT:12>)<EOL>N = self.generator.random_int(<NUM_LIT:1>, <NUM_LIT:30>)<EOL><DEDENT>H = zfix(H)<EOL>N = zfix(N)<EOL>S = "<STR_LIT>".format(self.generator.random_digit(<EOL>), self.generator.random_digit(), self.generator.random_digit())<EOL>vdig = "<STR_LIT>".format(M=M, E=E, H=H, N=N, S=S)<EOL>if <NUM_LIT> < E < <NUM_LIT>:<EOL><INDENT>cum = [(k + <NUM_LIT:1>) * int(v) for k, v in enumerate(vdig)]<EOL><DEDENT>else:<EOL><INDENT>cum = [(<NUM_LIT:10> - k) * int(v) for k, v in enumerate(vdig)]<EOL><DEDENT>K = fmod(reduce(lambda x, y: x + y, cum), <NUM_LIT:11>)<EOL>return vdig + str(int(K))<EOL> | Generates Hungarian SSN equivalent (személyazonosító szám or, colloquially, személyi szám)
:param dob: date of birth as a "YYMMDD" string - this determines the checksum regime and is also encoded
in the személyazonosító szám.
:type dob: str
:param gender: gender of the person - "F" for female, M for male.
:type gender: str
:return: személyazonosító szám in str format (11 digs)
:rtype: str | f13869:c0:m0 |
def vat_id(self): | return self.bothify(self.random_element(self.vat_id_formats))<EOL> | http://ec.europa.eu/taxation_customs/vies/faq.html#item_11
:return: A random Hungarian VAT ID | f13869:c0:m1 |
def vat_id(self): | return self.bothify(self.random_element(self.vat_id_formats))<EOL> | http://ec.europa.eu/taxation_customs/vies/faq.html#item_11
:return: A random German VAT ID | f13870:c0:m0 |
def vat_id(self): | return self.bothify(self.random_element(self.vat_id_formats))<EOL> | http://ec.europa.eu/taxation_customs/vies/faq.html#item_11
:return: a random Irish VAT ID | f13871:c0:m0 |
def checksum(digits): | s = <NUM_LIT:0><EOL>p = len(digits) + <NUM_LIT:1><EOL>for i in range(<NUM_LIT:0>, len(digits)):<EOL><INDENT>s += digits[i] * p<EOL>p -= <NUM_LIT:1><EOL><DEDENT>reminder = s % <NUM_LIT:11><EOL>if reminder == <NUM_LIT:0> or reminder == <NUM_LIT:1>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:11> - reminder<EOL><DEDENT> | Returns the checksum of CPF digits.
References to the algorithm:
https://pt.wikipedia.org/wiki/Cadastro_de_pessoas_f%C3%ADsicas#Algoritmo
https://metacpan.org/source/MAMAWE/Algorithm-CheckDigits-v1.3.0/lib/Algorithm/CheckDigits/M11_004.pm | f13872:m0 |
def rg(self): | digits = self.generator.random.sample(range(<NUM_LIT:0>, <NUM_LIT:9>), <NUM_LIT:8>)<EOL>checksum = sum(i * digits[i - <NUM_LIT:2>] for i in range(<NUM_LIT:2>, <NUM_LIT:10>))<EOL>last_digit = <NUM_LIT:11> - (checksum % <NUM_LIT:11>)<EOL>if last_digit == <NUM_LIT:10>:<EOL><INDENT>digits.append('<STR_LIT:X>')<EOL><DEDENT>elif last_digit == <NUM_LIT:11>:<EOL><INDENT>digits.append(<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>digits.append(last_digit)<EOL><DEDENT>return '<STR_LIT>'.join(map(str, digits))<EOL> | Brazilian RG, return plain numbers.
Check: https://www.ngmatematica.com/2014/02/como-determinar-o-digito-verificador-do.html | f13872:c0:m2 |
def vat_id(self): | return self.bothify(self.random_element(self.vat_id_formats))<EOL> | Returns a random generated Cypriot Tax ID | f13873:c0:m0 |
def checksum(digits): | sum_mod11 = sum(map(operator.mul, digits, Provider.scale1)) % <NUM_LIT:11><EOL>if sum_mod11 < <NUM_LIT:10>:<EOL><INDENT>return sum_mod11<EOL><DEDENT>sum_mod11 = sum(map(operator.mul, digits, Provider.scale2)) % <NUM_LIT:11><EOL>return <NUM_LIT:0> if sum_mod11 == <NUM_LIT:10> else sum_mod11<EOL> | Calculate checksum of Estonian personal identity code.
Checksum is calculated with "Modulo 11" method using level I or II scale:
Level I scale: 1 2 3 4 5 6 7 8 9 1
Level II scale: 3 4 5 6 7 8 9 1 2 3
The digits of the personal code are multiplied by level I scale and summed;
if remainder of modulo 11 of the sum is less than 10, checksum is the
remainder.
If remainder is 10, then level II scale is used; checksum is remainder if
remainder < 10 or 0 if remainder is 10.
See also https://et.wikipedia.org/wiki/Isikukood | f13874:m0 |
def ssn(self, min_age=<NUM_LIT:16>, max_age=<NUM_LIT>): | age = datetime.timedelta(<EOL>days=self.generator.random.randrange(<EOL>min_age * <NUM_LIT>, max_age * <NUM_LIT>))<EOL>birthday = datetime.date.today() - age<EOL>if birthday.year < <NUM_LIT>:<EOL><INDENT>ik = self.generator.random.choice(('<STR_LIT:3>', '<STR_LIT:4>'))<EOL><DEDENT>elif birthday.year < <NUM_LIT>:<EOL><INDENT>ik = self.generator.random.choice(('<STR_LIT:5>', '<STR_LIT>'))<EOL><DEDENT>else:<EOL><INDENT>ik = self.generator.random.choice(('<STR_LIT>', '<STR_LIT>'))<EOL><DEDENT>ik += "<STR_LIT>" % ((birthday.year % <NUM_LIT:100>), birthday.month,<EOL>birthday.day)<EOL>ik += str(self.generator.random.randrange(<NUM_LIT:0>, <NUM_LIT>)).zfill(<NUM_LIT:3>)<EOL>return ik + str(checksum([int(ch) for ch in ik]))<EOL> | Returns 11 character Estonian personal identity code (isikukood, IK).
Age of person is between 16 and 90 years, based on local computer date.
This function assigns random sex to person.
An Estonian Personal identification code consists of 11 digits,
generally given without any whitespace or other delimiters.
The form is GYYMMDDSSSC, where G shows sex and century of birth (odd
number male, even number female, 1-2 19th century, 3-4 20th century,
5-6 21st century), SSS is a serial number separating persons born on
the same date and C a checksum.
https://en.wikipedia.org/wiki/National_identification_number#Estonia | f13874:c0:m0 |
def vat_id(self): | return self.bothify(self.random_element(self.vat_id_formats))<EOL> | http://ec.europa.eu/taxation_customs/vies/faq.html#item_11
:return: A random Estonian VAT ID | f13874:c0:m1 |
def vat_id(self): | return self.bothify(self.random_element(self.vat_id_formats))<EOL> | http://ec.europa.eu/taxation_customs/vies/faq.html#item_11
:return: a random French VAT ID | f13875:c0:m0 |
def vat_id(self): | return self.bothify(self.random_element(self.vat_id_formats))<EOL> | Returns a random generated Danish Tax ID | f13878:c0:m0 |
def _body(self): | ean = self.random_element(RULES.keys())<EOL>reg_group = self.random_element(RULES[ean].keys())<EOL>reg_pub_len = ISBN.MAX_LENGTH - len(ean) - len(reg_group) - <NUM_LIT:1><EOL>reg_pub = self.numerify('<STR_LIT:#>' * reg_pub_len)<EOL>rules = RULES[ean][reg_group]<EOL>registrant, publication = self._registrant_publication(reg_pub, rules)<EOL>return [ean, reg_group, registrant, publication]<EOL> | Generate the information required to create an ISBN-10 or
ISBN-13. | f13881:c0:m0 |
@staticmethod<EOL><INDENT>def _registrant_publication(reg_pub, rules):<DEDENT> | for rule in rules:<EOL><INDENT>if rule.min <= reg_pub <= rule.max:<EOL><INDENT>reg_len = rule.registrant_length<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>registrant, publication = reg_pub[:reg_len], reg_pub[reg_len:]<EOL>return registrant, publication<EOL> | Separate the registration from the publication in a given
string.
:param reg_pub: A string of digits representing a registration
and publication.
:param rules: A list of RegistrantRules which designate where
to separate the values in the string.
:returns: A (registrant, publication) tuple of strings. | f13881:c0:m1 |
def _check_digit(self): | weights = (<NUM_LIT:1> if x % <NUM_LIT:2> == <NUM_LIT:0> else <NUM_LIT:3> for x in range(<NUM_LIT:12>))<EOL>body = '<STR_LIT>'.join([self.ean, self.group, self.registrant,<EOL>self.publication])<EOL>remainder = sum(int(b) * w for b, w in zip(body, weights)) % <NUM_LIT:10><EOL>diff = <NUM_LIT:10> - remainder<EOL>check_digit = <NUM_LIT:0> if diff == <NUM_LIT:10> else diff<EOL>return str(check_digit)<EOL> | Calculate the check digit for ISBN-13.
See https://en.wikipedia.org/wiki/International_Standard_Book_Number
for calculation. | f13882:c1:m1 |
def _check_digit(self): | weights = range(<NUM_LIT:1>, <NUM_LIT:10>)<EOL>body = '<STR_LIT>'.join([self.group, self.registrant, self.publication])<EOL>remainder = sum(int(b) * w for b, w in zip(body, weights)) % <NUM_LIT:11><EOL>check_digit = '<STR_LIT:X>' if remainder == <NUM_LIT:10> else str(remainder)<EOL>return str(check_digit)<EOL> | Calculate the check digit for ISBN-10.
See https://en.wikipedia.org/wiki/International_Standard_Book_Number
for calculation. | f13882:c2:m1 |
def mime_type(self, category=None): | category = category if category else self.random_element(<EOL>list(self.mime_types.keys()))<EOL>return self.random_element(self.mime_types[category])<EOL> | :param category: application|audio|image|message|model|multipart|text|video | f13884:c0:m0 |
def file_name(self, category=None, extension=None): | extension = extension if extension else self.file_extension(category)<EOL>filename = self.generator.word()<EOL>return '<STR_LIT>'.format(filename, extension)<EOL> | :param category: audio|image|office|text|video
:param extension: file extension | f13884:c0:m1 |
def file_extension(self, category=None): | category = category if category else self.random_element(<EOL>list(self.file_extensions.keys()))<EOL>return self.random_element(self.file_extensions[category])<EOL> | :param category: audio|image|office|text|video | f13884:c0:m2 |
def file_path(self, depth=<NUM_LIT:1>, category=None, extension=None): | file = self.file_name(category, extension)<EOL>path = "<STR_LIT>".format(file)<EOL>for _ in range(<NUM_LIT:0>, depth):<EOL><INDENT>path = "<STR_LIT>".format(self.generator.word(), path)<EOL><DEDENT>return path<EOL> | :param category: audio|image|office|text|video
:param extension: file extension
:param depth: depth of the file (depth >= 0) | f13884:c0:m3 |
def unix_device(self, prefix=None): | prefix = prefix or self.random_element(self.unix_device_prefixes)<EOL>suffix = self.random_element(string.ascii_lowercase)<EOL>path = '<STR_LIT>' % (prefix, suffix)<EOL>return path<EOL> | :param prefix: sd|vd|xvd | f13884:c0:m4 |
def unix_partition(self, prefix=None): | path = self.unix_device(prefix=prefix)<EOL>path += str(self.random_digit())<EOL>return path<EOL> | :param prefix: sd|vd|xvd | f13884:c0:m5 |
def simple_profile(self, sex=None): | SEX = ["<STR_LIT:F>", "<STR_LIT:M>"]<EOL>if sex not in SEX:<EOL><INDENT>sex = self.random_element(SEX)<EOL><DEDENT>if sex == '<STR_LIT:F>':<EOL><INDENT>name = self.generator.name_female()<EOL><DEDENT>elif sex == '<STR_LIT:M>':<EOL><INDENT>name = self.generator.name_male()<EOL><DEDENT>return {<EOL>"<STR_LIT:username>": self.generator.user_name(),<EOL>"<STR_LIT:name>": name,<EOL>"<STR_LIT>": sex,<EOL>"<STR_LIT:address>": self.generator.address(),<EOL>"<STR_LIT>": self.generator.free_email(),<EOL>"<STR_LIT>": self.generator.date_of_birth(),<EOL>}<EOL> | Generates a basic profile with personal informations | f13886:c0:m0 |
def profile(self, fields=None, sex=None): | if fields is None:<EOL><INDENT>fields = []<EOL><DEDENT>d = {<EOL>"<STR_LIT>": self.generator.job(),<EOL>"<STR_LIT>": self.generator.company(),<EOL>"<STR_LIT>": self.generator.ssn(),<EOL>"<STR_LIT>": self.generator.address(),<EOL>"<STR_LIT>": (self.generator.latitude(), self.generator.longitude()),<EOL>"<STR_LIT>": "<STR_LIT>".join(self.random_element(list(itertools.product(["<STR_LIT:A>", "<STR_LIT:B>", "<STR_LIT>", "<STR_LIT:O>"], ["<STR_LIT:+>", "<STR_LIT:->"])))),<EOL>"<STR_LIT>": [self.generator.url() for _ in range(<NUM_LIT:1>, self.random_int(<NUM_LIT:2>, <NUM_LIT:5>))],<EOL>}<EOL>d = dict(d, **self.generator.simple_profile(sex))<EOL>if len(fields) > <NUM_LIT:0>:<EOL><INDENT>d = {k: v for k, v in d.items() if k in fields}<EOL><DEDENT>return d<EOL> | Generates a complete profile.
If "fields" is not empty, only the fields in the list will be returned | f13886:c0:m1 |
def binary(self, length=(<NUM_LIT:1> * <NUM_LIT> * <NUM_LIT>)): | blob = [self.generator.random.randrange(<NUM_LIT>) for _ in range(length)]<EOL>return bytes(blob) if sys.version_info[<NUM_LIT:0>] >= <NUM_LIT:3> else bytearray(blob)<EOL> | Returns random binary blob.
Default blob size is 1 Mb. | f13902:c0:m2 |
def md5(self, raw_output=False): | res = hashlib.md5(str(self.generator.random.random()).encode('<STR_LIT:utf-8>'))<EOL>if raw_output:<EOL><INDENT>return res.digest()<EOL><DEDENT>return res.hexdigest()<EOL> | Calculates the md5 hash of a given string
:example 'cfcd208495d565ef66e7dff9f98764da' | f13902:c0:m3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.