signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def street_prefix(self): | return self.random_element(self.street_prefixes)<EOL> | :example 'rue' | f14016:c0:m0 |
def city_prefix(self): | return self.random_element(self.city_prefixes)<EOL> | :example 'rue' | f14016:c0:m1 |
def region(self): | return self.random_element(self.regions)<EOL> | :example 'Guadeloupe' | f14016:c0:m2 |
def department(self): | return self.random_element(self.departments)<EOL> | Randomly returns a french department ('departmentNumber' , 'departmentName').
:example ('2B' . 'Haute-Corse') | f14016:c0:m3 |
def department_name(self): | return self.department()[<NUM_LIT:1>]<EOL> | Randomly returns a french department name.
:example 'Ardèche' | f14016:c0:m4 |
def department_number(self): | return self.department()[<NUM_LIT:0>]<EOL> | Randomly returns a french department number.
:example '59' | f14016:c0:m5 |
def land_number(self): | return self.bothify(self.random_element(self.land_numbers))<EOL> | :example 507 | f14018:c0:m0 |
def land_address(self): | pattern = self.random_element(self.land_address_formats)<EOL>return self.generator.parse(pattern)<EOL> | :example 세종특별자치시 어진동 507 | f14018:c0:m1 |
def road_number(self): | return self.bothify(self.random_element(self.road_numbers))<EOL> | :example 24 | f14018:c0:m2 |
def road_address(self): | pattern = self.random_element(self.road_address_formats)<EOL>return self.generator.parse(pattern)<EOL> | :example 세종특별자치시 도움5로 19 (어진동) | f14018:c0:m3 |
def address_detail(self): | pattern = self.bothify(self.random_element(<EOL>self.address_detail_formats))<EOL>return self.generator.parse(pattern)<EOL> | :example 가나아파트 가동 102호 | f14018:c0:m4 |
def road(self): | pattern = self.random_element(self.road_formats)<EOL>return self.generator.parse(pattern)<EOL> | :example 도움5로 | f14018:c0:m5 |
def road_name(self): | return self.random_element(self.road_names)<EOL> | :example 압구정 | f14018:c0:m6 |
def road_suffix(self): | return self.random_element(self.road_suffixes)<EOL> | :example 길 | f14018:c0:m7 |
def metropolitan_city(self): | return self.random_element(self.metropolitan_cities)<EOL> | :example 서울특별시 | f14018:c0:m8 |
def province(self): | return self.random_element(self.provinces)<EOL> | :example 경기도 | f14018:c0:m9 |
def city(self): | pattern = self.random_element(self.cities)<EOL>return self.generator.parse(pattern)<EOL> | :example 고양시 | f14018:c0:m10 |
def borough(self): | return self.random_element(self.boroughs)<EOL> | :example 중구 | f14018:c0:m11 |
def town(self): | pattern = self.random_element(self.town_formats)<EOL>return self.generator.parse(pattern)<EOL> | :example 가나동 | f14018:c0:m12 |
def town_suffix(self): | return self.random_element(self.town_suffixes)<EOL> | :example 동 | f14018:c0:m13 |
def building_name(self): | pattern = self.random_element(self.building_name_formats)<EOL>return self.generator.parse(pattern)<EOL> | :example 김구아파트 | f14018:c0:m14 |
def building_suffix(self): | return self.random_element(self.building_suffixes)<EOL> | :example 아파트 | f14018:c0:m15 |
def building_dong(self): | return self.bothify(self.random_element(self.building_dongs))<EOL> | :example 가 | f14018:c0:m16 |
def old_postal_code(self): | return self.bothify(self.random_element(self.postcode_formats))<EOL> | :example 123-456 | f14018:c0:m17 |
def postcode(self): | return self.bothify(self.random_element(self.new_postal_code_formats))<EOL> | :example 12345 | f14018:c0:m18 |
def postal_code(self): | return self.postcode()<EOL> | :example 12345 | f14018:c0:m19 |
def district(self): | return self.random_element(self.districts)<EOL> | :example अछाम | f14019:c0:m0 |
def city(self): | return self.random_element(self.cities)<EOL> | :example कावासोत | f14019:c0:m1 |
def building_prefix(self): | return self.random_element(self.building_prefixes)<EOL> | :example वडा | f14019:c0:m2 |
def random_int(self, min=<NUM_LIT:0>, max=<NUM_LIT>, step=<NUM_LIT:1>): | return self.generator.random.randrange(min, max + <NUM_LIT:1>, step)<EOL> | Returns a random integer between two values.
:param min: lower bound value (inclusive; default=0)
:param max: upper bound value (inclusive; default=9999)
:param step: range step (default=1)
:returns: random integer between min and max | f14020:c0:m3 |
def random_digit(self): | return self.generator.random.randint(<NUM_LIT:0>, <NUM_LIT:9>)<EOL> | Returns a random digit/number
between 0 and 9. | f14020:c0:m4 |
def random_digit_not_null(self): | return self.generator.random.randint(<NUM_LIT:1>, <NUM_LIT:9>)<EOL> | Returns a random non-zero digit/number
between 1 and 9. | f14020:c0:m5 |
def random_digit_or_empty(self): | if self.generator.random.randint(<NUM_LIT:0>, <NUM_LIT:1>):<EOL><INDENT>return self.generator.random.randint(<NUM_LIT:0>, <NUM_LIT:9>)<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT> | Returns a random digit/number
between 0 and 9 or an empty string. | f14020:c0:m6 |
def random_digit_not_null_or_empty(self): | if self.generator.random.randint(<NUM_LIT:0>, <NUM_LIT:1>):<EOL><INDENT>return self.generator.random.randint(<NUM_LIT:1>, <NUM_LIT:9>)<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT> | Returns a random non-zero digit/number
between 1 and 9 or and empty string. | f14020:c0:m7 |
def random_number(self, digits=None, fix_len=False): | if digits is None:<EOL><INDENT>digits = self.random_digit()<EOL><DEDENT>if fix_len:<EOL><INDENT>return self.generator.random.randint(<EOL>pow(<NUM_LIT:10>, digits - <NUM_LIT:1>), pow(<NUM_LIT:10>, digits) - <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>return self.generator.random.randint(<NUM_LIT:0>, pow(<NUM_LIT:10>, digits) - <NUM_LIT:1>)<EOL><DEDENT> | Returns a random number with 1 digit (default, when digits==None),
a random number with 0 to given number of digits, or a random number
with given number to given number of digits (when ``fix_len==True``).
:param digits: maximum number of digits
:param fix_len: should the number have fixed length?
:returns: random number with 0 to given number of digits or
fixed length number | f14020:c0:m8 |
def random_letter(self): | return self.generator.random.choice(<EOL>getattr(string, '<STR_LIT>', string.ascii_letters))<EOL> | Returns a random letter (between a-z and A-Z). | f14020:c0:m9 |
def random_letters(self, length=<NUM_LIT:16>): | return self.random_choices(<EOL>getattr(string, '<STR_LIT>', string.ascii_letters),<EOL>length=length,<EOL>)<EOL> | Returns a random letter (between a-z and A-Z). | f14020:c0:m10 |
def random_lowercase_letter(self): | return self.generator.random.choice(string.ascii_lowercase)<EOL> | Returns a random lowercase letter (between a-z). | f14020:c0:m11 |
def random_uppercase_letter(self): | return self.generator.random.choice(string.ascii_uppercase)<EOL> | Returns a random letter (between A-Z). | f14020:c0:m12 |
def random_choices(self, elements=('<STR_LIT:a>', '<STR_LIT:b>', '<STR_LIT:c>'), length=None): | return self.random_elements(elements, length, unique=False)<EOL> | Returns a list of random, non-unique elements from a passed object.
If `elements` is a dictionary, the value will be used as
a weighting element. For example::
random_element({"{{variable_1}}": 0.5, "{{variable_2}}": 0.2, "{{variable_3}}": 0.2, "{{variable_4}}": 0.1})
will have the following distribution:
* `variable_1`: 50% probability
* `variable_2`: 20% probability
* `variable_3`: 20% probability
* `variable_4`: 10% probability | f14020:c0:m14 |
def random_element(self, elements=('<STR_LIT:a>', '<STR_LIT:b>', '<STR_LIT:c>')): | return self.random_elements(elements, length=<NUM_LIT:1>)[<NUM_LIT:0>]<EOL> | Returns a random element from a passed object.
If `elements` is a dictionary, the value will be used as
a weighting element. For example::
random_element({"{{variable_1}}": 0.5, "{{variable_2}}": 0.2, "{{variable_3}}": 0.2, "{{variable_4}}": 0.1})
will have the following distribution:
* `variable_1`: 50% probability
* `variable_2`: 20% probability
* `variable_3`: 20% probability
* `variable_4`: 10% probability | f14020:c0:m15 |
def random_sample(self, elements=('<STR_LIT:a>', '<STR_LIT:b>', '<STR_LIT:c>'), length=None): | return self.random_elements(elements, length, unique=True)<EOL> | Returns a list of random unique elements for the specified length.
Multiple occurrences of the same value increase its probability to be in the output. | f14020:c0:m16 |
def randomize_nb_elements(<EOL>self,<EOL>number=<NUM_LIT:10>,<EOL>le=False,<EOL>ge=False,<EOL>min=None,<EOL>max=None): | if le and ge:<EOL><INDENT>return number<EOL><DEDENT>_min = <NUM_LIT:100> if ge else <NUM_LIT><EOL>_max = <NUM_LIT:100> if le else <NUM_LIT><EOL>nb = int(number * self.generator.random.randint(_min, _max) / <NUM_LIT:100>)<EOL>if min is not None and nb < min:<EOL><INDENT>nb = min<EOL><DEDENT>if max is not None and nb > min:<EOL><INDENT>nb = max<EOL><DEDENT>return nb<EOL> | Returns a random value near number.
:param number: value to which the result must be near
:param le: result must be lower or equal to number
:param ge: result must be greater or equal to number
:returns: a random int near number | f14020:c0:m17 |
def numerify(self, text='<STR_LIT>'): | text = _re_hash.sub(<EOL>lambda x: str(self.random_digit()),<EOL>text)<EOL>text = _re_perc.sub(<EOL>lambda x: str(self.random_digit_not_null()),<EOL>text)<EOL>text = _re_excl.sub(<EOL>lambda x: str(self.random_digit_or_empty()),<EOL>text)<EOL>text = _re_at.sub(<EOL>lambda x: str(self.random_digit_not_null_or_empty()),<EOL>text)<EOL>return text<EOL> | Replaces all placeholders in given text with randomized values,
replacing: all hash sign ('#') occurrences with a random digit
(from 0 to 9); all percentage sign ('%') occurrences with a
random non-zero digit (from 1 to 9); all exclamation mark ('!')
occurrences with a random digit (from 0 to 9) or an empty string;
and all at symbol ('@') occurrences with a random non-zero digit
(from 1 to 9) or an empty string.
:param text: string to be parsed
:returns: string with all numerical placeholders filled in | f14020:c0:m18 |
def lexify(self, text='<STR_LIT>', letters=string.ascii_letters): | return _re_qm.sub(lambda x: self.random_element(letters), text)<EOL> | Replaces all question mark ('?') occurrences with a random letter.
:param text: string to be parsed
:param letters: a set of letters to choose from.
:returns: string with all letter placeholders filled in | f14020:c0:m19 |
def bothify(self, text='<STR_LIT>', letters=string.ascii_letters): | return self.lexify(self.numerify(text), letters=letters)<EOL> | Replaces all placeholders with random numbers and letters.
:param text: string to be parsed
:returns: string with all numerical and letter placeholders filled in | f14020:c0:m20 |
def hexify(self, text='<STR_LIT>', upper=False): | letters = string.hexdigits[:-<NUM_LIT:6>]<EOL>if upper:<EOL><INDENT>letters = letters.upper()<EOL><DEDENT>return _re_cir.sub(lambda x: self.random_element(letters), text)<EOL> | Replaces all circumflex ('^') occurrences with a random
hexadecimal character.
:param text: string to be parsed
:param upper: Format as uppercase hexadecimal
:returns: string with all letter placeholders filled in | f14020:c0:m21 |
def coordinate(self, center=None, radius=<NUM_LIT>): | if center is None:<EOL><INDENT>return Decimal(str(self.generator.random.randint(-<NUM_LIT>, <NUM_LIT>) / <NUM_LIT>)).quantize(<EOL>Decimal("<STR_LIT>"),<EOL>)<EOL><DEDENT>else:<EOL><INDENT>center = float(center)<EOL>radius = float(radius)<EOL>geo = self.generator.random.uniform(center - radius, center + radius)<EOL>return Decimal(str(geo)).quantize(Decimal("<STR_LIT>"))<EOL><DEDENT> | Optionally center the coord and pick a point within radius. | f14042:c0:m0 |
def local_latlng(self, country_code='<STR_LIT>', coords_only=False): | results = [loc for loc in self.land_coords if loc[<NUM_LIT:3>] == country_code]<EOL>if results:<EOL><INDENT>place = self.random_element(results)<EOL>return (place[<NUM_LIT:0>], place[<NUM_LIT:1>]) if coords_only else place<EOL><DEDENT> | Returns a location known to exist on land in a country specified by `country_code`.
Defaults to 'en_US'. See the `land_coords` list for available locations/countries. | f14042:c0:m4 |
def location_on_land(self, coords_only=False): | place = self.random_element(self.land_coords)<EOL>return (place[<NUM_LIT:0>], place[<NUM_LIT:1>]) if coords_only else place<EOL> | Returns a random tuple specifying a coordinate set guaranteed to exist on land.
Format is `(latitude, longitude, place name, two-letter country code, timezone)`
Pass `coords_only` to return coordinates without metadata. | f14042:c0:m5 |
def ide(self): | def _checksum(digits):<EOL><INDENT>factors = (<NUM_LIT:5>, <NUM_LIT:4>, <NUM_LIT:3>, <NUM_LIT:2>, <NUM_LIT:7>, <NUM_LIT:6>, <NUM_LIT:5>, <NUM_LIT:4>)<EOL>sum_ = <NUM_LIT:0><EOL>for i in range(len(digits)):<EOL><INDENT>sum_ += digits[i] * factors[i]<EOL><DEDENT>return sum_ % <NUM_LIT:11><EOL><DEDENT>while True:<EOL><INDENT>digits = self.generator.random.sample(range(<NUM_LIT:10>), <NUM_LIT:8>)<EOL>sum_ = _checksum(digits)<EOL>control_number = <NUM_LIT:11> - sum_<EOL>if control_number != <NUM_LIT:10>:<EOL><INDENT>digits.append(control_number)<EOL>break<EOL><DEDENT><DEDENT>digits = '<STR_LIT>'.join([str(digit) for digit in digits])<EOL>return '<STR_LIT>' + digits[<NUM_LIT:0>:<NUM_LIT:3>] + '<STR_LIT:.>'+ digits[<NUM_LIT:3>:<NUM_LIT:6>] + '<STR_LIT:.>'+ digits[<NUM_LIT:6>:<NUM_LIT:9>]<EOL> | Generates a IDE number (9 digits).
http://www.bfs.admin.ch/bfs/portal/fr/index/themen/00/05/blank/03/02.html | f14055:c0:m0 |
def large_company(self): | return self.random_element(self.large_companies)<EOL> | :example: 'Bol.com' | f14057:c0:m0 |
def company_prefix(self): | return self.random_element(self.company_prefixes)<EOL> | :example 'Stichting' | f14057:c0:m1 |
def regon_checksum(digits): | weights_for_check_digit = [<NUM_LIT:8>, <NUM_LIT:9>, <NUM_LIT:2>, <NUM_LIT:3>, <NUM_LIT:4>, <NUM_LIT:5>, <NUM_LIT:6>, <NUM_LIT:7>]<EOL>check_digit = <NUM_LIT:0><EOL>for i in range(<NUM_LIT:0>, <NUM_LIT:8>):<EOL><INDENT>check_digit += weights_for_check_digit[i] * digits[i]<EOL><DEDENT>check_digit %= <NUM_LIT:11><EOL>if check_digit == <NUM_LIT:10>:<EOL><INDENT>check_digit = <NUM_LIT:0><EOL><DEDENT>return check_digit<EOL> | Calculates and returns a control digit for given list of digits basing on REGON standard. | f14061:m0 |
def local_regon_checksum(digits): | weights_for_check_digit = [<NUM_LIT:2>, <NUM_LIT:4>, <NUM_LIT:8>, <NUM_LIT:5>, <NUM_LIT:0>, <NUM_LIT:9>, <NUM_LIT:7>, <NUM_LIT:3>, <NUM_LIT:6>, <NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:4>, <NUM_LIT:8>]<EOL>check_digit = <NUM_LIT:0><EOL>for i in range(<NUM_LIT:0>, <NUM_LIT>):<EOL><INDENT>check_digit += weights_for_check_digit[i] * digits[i]<EOL><DEDENT>check_digit %= <NUM_LIT:11><EOL>if check_digit == <NUM_LIT:10>:<EOL><INDENT>check_digit = <NUM_LIT:0><EOL><DEDENT>return check_digit<EOL> | Calculates and returns a control digit for given list of digits basing on local REGON standard. | f14061:m1 |
def company_vat_checksum(digits): | weights_for_check_digit = [<NUM_LIT:6>, <NUM_LIT:5>, <NUM_LIT:7>, <NUM_LIT:2>, <NUM_LIT:3>, <NUM_LIT:4>, <NUM_LIT:5>, <NUM_LIT:6>, <NUM_LIT:7>]<EOL>check_digit = <NUM_LIT:0><EOL>for i in range(<NUM_LIT:0>, <NUM_LIT:9>):<EOL><INDENT>check_digit += weights_for_check_digit[i] * digits[i]<EOL><DEDENT>check_digit %= <NUM_LIT:11><EOL>return check_digit<EOL> | Calculates and returns a control digit for given list of digits basing on NIP standard. | f14061:m2 |
def company_prefix(self): | return self.random_element(self.company_prefixes)<EOL> | :example 'Grupa' | f14061:c0:m0 |
def regon(self): | voivodeship_number = self.random_int(<NUM_LIT:0>, <NUM_LIT>) * <NUM_LIT:2> + <NUM_LIT:1><EOL>regon_digits = [int(voivodeship_number / <NUM_LIT:10>), voivodeship_number % <NUM_LIT:10>]<EOL>for _ in range(<NUM_LIT:6>):<EOL><INDENT>regon_digits.append(self.random_digit())<EOL><DEDENT>regon_digits.append(regon_checksum(regon_digits))<EOL>return '<STR_LIT>'.join(str(digit) for digit in regon_digits)<EOL> | Returns 9 character Polish National Business Registry Number,
Polish: Rejestr Gospodarki Narodowej - REGON.
https://pl.wikipedia.org/wiki/REGON | f14061:c0:m1 |
def local_regon(self): | regon_digits = [int(digit) for digit in list(self.regon())]<EOL>for _ in range(<NUM_LIT:4>):<EOL><INDENT>regon_digits.append(self.random_digit())<EOL><DEDENT>regon_digits.append(local_regon_checksum(regon_digits))<EOL>return '<STR_LIT>'.join(str(digit) for digit in regon_digits)<EOL> | Returns 14 character Polish National Business Registry Number,
local entity number.
https://pl.wikipedia.org/wiki/REGON | f14061:c0:m2 |
def company_vat(self): | vat_digits = []<EOL>for _ in range(<NUM_LIT:3>):<EOL><INDENT>vat_digits.append(self.random_digit_not_null())<EOL><DEDENT>for _ in range(<NUM_LIT:6>):<EOL><INDENT>vat_digits.append(self.random_digit())<EOL><DEDENT>check_digit = company_vat_checksum(vat_digits)<EOL>if check_digit == <NUM_LIT:10>:<EOL><INDENT>return self.company_vat()<EOL><DEDENT>vat_digits.append(check_digit)<EOL>return '<STR_LIT>'.join(str(digit) for digit in vat_digits)<EOL> | Returns 10 character tax identification number,
Polish: Numer identyfikacji podatkowej.
https://pl.wikipedia.org/wiki/NIP | f14061:c0:m3 |
def company_business_id(self): | def calculate_checksum(number):<EOL><INDENT>"""<STR_LIT>"""<EOL>factors = [<NUM_LIT:7>, <NUM_LIT:9>, <NUM_LIT:10>, <NUM_LIT:5>, <NUM_LIT:8>, <NUM_LIT:4>, <NUM_LIT:2>]<EOL>sum_ = <NUM_LIT:0><EOL>for x, y in zip(number, factors):<EOL><INDENT>sum_ = sum_ + int(x) * y<EOL><DEDENT>if sum_ % <NUM_LIT:11> == <NUM_LIT:0>:<EOL><INDENT>return '<STR_LIT:0>'<EOL><DEDENT>else:<EOL><INDENT>return str(<NUM_LIT:11> - sum_ % <NUM_LIT:11>)<EOL><DEDENT><DEDENT>first_digit = str(self.random_digit_not_null())<EOL>body = first_digit + self.bothify('<STR_LIT>')<EOL>cs = calculate_checksum(body)<EOL>return body + '<STR_LIT:->' + str(cs)<EOL> | Returns Finnish company Business Identity Code (y-tunnus).
Format is 8 digits - e.g. FI99999999,[8] last digit is a check
digit utilizing MOD 11-2. The first digit is zero for some old
organizations. This function provides current codes starting with
non-zero. | f14062:c0:m0 |
def company_vat(self): | def convert_to_vat(business_id):<EOL><INDENT>"""<STR_LIT>"""<EOL>return '<STR_LIT>' + business_id.replace('<STR_LIT:->', '<STR_LIT>')<EOL><DEDENT>return convert_to_vat(self.company_business_id())<EOL> | Returns Finnish VAT identification number (Arvonlisaveronumero).
This can be calculated from company business identity code by
adding prefix "FI" and removing dash before checksum. | f14062:c0:m1 |
def catch_phrase(self): | result = []<EOL>for word_list in self.catch_phrase_words:<EOL><INDENT>result.append(self.random_element(word_list))<EOL><DEDENT>return "<STR_LIT:U+0020>".join(result)<EOL> | :example 'Robust full-range hub' | f14063:c0:m0 |
def bs(self): | result = []<EOL>for word_list in self.bsWords:<EOL><INDENT>result.append(self.random_element(word_list))<EOL><DEDENT>return "<STR_LIT:U+0020>".join(result)<EOL> | :example 'integrate extensible convergence' | f14063:c0:m1 |
def company_prefix(self): | return self.random_element(self.company_preffixes)<EOL> | Ejemplo: Grupo | f14073:c0:m0 |
def catch_phrase(self): | result = []<EOL>for word_list in self.catch_phrase_words:<EOL><INDENT>result.append(self.random_element(word_list))<EOL><DEDENT>return "<STR_LIT:U+0020>".join(result)<EOL> | :example 'Robust full-range hub' | f14073:c0:m1 |
def bs(self): | result = []<EOL>for word_list in self.bsWords:<EOL><INDENT>result.append(self.random_element(word_list))<EOL><DEDENT>return "<STR_LIT:U+0020>".join(result)<EOL> | :example 'integrate extensible convergence' | f14073:c0:m2 |
def company(self): | pattern = self.random_element(self.formats)<EOL>return self.generator.parse(pattern)<EOL> | :example 'Acme Ltd' | f14074:c0:m0 |
def company_suffix(self): | return self.random_element(self.company_suffixes)<EOL> | :example 'Ltd' | f14074:c0:m1 |
def catch_phrase(self): | result = []<EOL>for word_list in self.catch_phrase_words:<EOL><INDENT>result.append(self.random_element(word_list))<EOL><DEDENT>return "<STR_LIT:U+0020>".join(result)<EOL> | :example 'Robust full-range hub' | f14074:c0:m2 |
def bs(self): | result = []<EOL>for word_list in self.bsWords:<EOL><INDENT>result.append(self.random_element(word_list))<EOL><DEDENT>return "<STR_LIT:U+0020>".join(result)<EOL> | :example 'integrate extensible convergence' | f14074:c0:m3 |
def catch_phrase_noun(self): | return self.random_element(self.nouns)<EOL> | Returns a random catch phrase noun. | f14077:c0:m0 |
def catch_phrase_attribute(self): | return self.random_element(self.attributes)<EOL> | Returns a random catch phrase attribute. | f14077:c0:m1 |
def catch_phrase_verb(self): | return self.random_element(self.verbs)<EOL> | Returns a random catch phrase verb. | f14077:c0:m2 |
def catch_phrase(self): | pattern = self.random_element(self.catch_phrase_formats)<EOL>catch_phrase = self.generator.parse(pattern)<EOL>catch_phrase = catch_phrase[<NUM_LIT:0>].upper() + catch_phrase[<NUM_LIT:1>:]<EOL>return catch_phrase<EOL> | :example 'a segurança de evoluir sem preocupação' | f14077:c0:m3 |
def catch_phrase_noun(self): | return self.random_element(self.nouns)<EOL> | Returns a random catch phrase noun. | f14080:c0:m0 |
def catch_phrase_attribute(self): | return self.random_element(self.attributes)<EOL> | Returns a random catch phrase attribute. | f14080:c0:m1 |
def catch_phrase_verb(self): | return self.random_element(self.verbs)<EOL> | Returns a random catch phrase verb. | f14080:c0:m2 |
def catch_phrase(self): | catch_phrase = "<STR_LIT>"<EOL>while True:<EOL><INDENT>pattern = self.random_element(self.catch_phrase_formats)<EOL>catch_phrase = self.generator.parse(pattern)<EOL>catch_phrase = catch_phrase[<NUM_LIT:0>].upper() + catch_phrase[<NUM_LIT:1>:]<EOL>if self._is_catch_phrase_valid(catch_phrase):<EOL><INDENT>break<EOL><DEDENT><DEDENT>return catch_phrase<EOL> | :example 'integrate extensible convergence' | f14080:c0:m3 |
def _is_catch_phrase_valid(self, catch_phrase): | for word in self.words_which_should_not_appear_twice:<EOL><INDENT>begin_pos = catch_phrase.find(word)<EOL>end_pos = catch_phrase.find(word, begin_pos + <NUM_LIT:1>)<EOL>if begin_pos != -<NUM_LIT:1> and begin_pos != end_pos:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL> | Validates a french catch phrase.
:param catch_phrase: The catch phrase to validate. | f14080:c0:m4 |
def siren(self): | return self.numerify(self.siren_format)<EOL> | Generates a siren number (9 digits). | f14080:c0:m5 |
def siret(self, max_sequential_digits=<NUM_LIT:2>): | if max_sequential_digits > <NUM_LIT:4> or max_sequential_digits <= <NUM_LIT:0>:<EOL><INDENT>max_sequential_digits = <NUM_LIT:2><EOL><DEDENT>sequential_number = str(self.random_number(<EOL>max_sequential_digits)).zfill(<NUM_LIT:4>)<EOL>return self.numerify(self.siren() + '<STR_LIT:U+0020>' + sequential_number + '<STR_LIT:#>')<EOL> | Generates a siret number (14 digits).
It is in fact the result of the concatenation of a siren number (9 digits),
a sequential number (4 digits) and a control number (1 digit) concatenation.
If $max_sequential_digits is invalid, it is set to 2.
:param max_sequential_digits The maximum number of digits for the sequential number (> 0 && <= 4). | f14080:c0:m6 |
def catch_phrase(self): | result = []<EOL>for word_list in self.catch_phrase_words:<EOL><INDENT>result.append(self.random_element(word_list))<EOL><DEDENT>return "<STR_LIT:U+0020>".join(result)<EOL> | :example 'Robust full-range hub' | f14082:c0:m0 |
def bs(self): | result = []<EOL>for word_list in self.bsWords:<EOL><INDENT>result.append(self.random_element(word_list))<EOL><DEDENT>return "<STR_LIT:U+0020>".join(result)<EOL> | :example 'integrate extensible convergence' | f14082:c0:m1 |
def words(self, nb=<NUM_LIT:3>, ext_word_list=None, unique=False): | word_list = ext_word_list if ext_word_list else self.word_list<EOL>if unique:<EOL><INDENT>return self.random_sample(word_list, length=nb)<EOL><DEDENT>return self.random_choices(word_list, length=nb)<EOL> | :returns: An array of random words. for example: ['Lorem', 'ipsum', 'dolor']
Keyword arguments:
:param nb: how many words to return
:param ext_word_list: a list of words you would like to have instead of
'Lorem ipsum'
:param unique: If True, the returned word list will contain unique words
:rtype: list | f14092:c0:m0 |
def word(self, ext_word_list=None): | return self.words(<NUM_LIT:1>, ext_word_list)[<NUM_LIT:0>]<EOL> | :returns: A random word, eg: 'lorem'
:param ext_word_list: a list of words you would like to have instead of
'Lorem ipsum'
:rtype: str | f14092:c0:m1 |
def sentence(self, nb_words=<NUM_LIT:6>, variable_nb_words=True, ext_word_list=None): | if nb_words <= <NUM_LIT:0>:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if variable_nb_words:<EOL><INDENT>nb_words = self.randomize_nb_elements(nb_words, min=<NUM_LIT:1>)<EOL><DEDENT>words = self.words(nb=nb_words, ext_word_list=ext_word_list)<EOL>words[<NUM_LIT:0>] = words[<NUM_LIT:0>].title()<EOL>return self.word_connector.join(words) + self.sentence_punctuation<EOL> | Generate a random sentence
:example 'Lorem ipsum dolor sit amet.'
:param nb_words: around how many words the sentence should contain
:param variable_nb_words: set to false if you want exactly ``nb``
words returned, otherwise the result may include a number of words
of ``nb`` +/-40% (with a minimum of 1)
:param ext_word_list: a list of words you would like to have instead of
'Lorem ipsum'.
:rtype: str | f14092:c0:m2 |
def sentences(self, nb=<NUM_LIT:3>, ext_word_list=None): | return [self.sentence(ext_word_list=ext_word_list)<EOL>for _ in range(<NUM_LIT:0>, nb)]<EOL> | Generate an array of sentences
:example ['Lorem ipsum dolor sit amet.', 'Consectetur adipisicing eli.']
Keyword arguments:
:param nb: how many sentences to return
:param ext_word_list: a list of words you would like to have instead of
'Lorem ipsum'.
:rtype: list | f14092:c0:m3 |
def paragraph(<EOL>self,<EOL>nb_sentences=<NUM_LIT:3>,<EOL>variable_nb_sentences=True,<EOL>ext_word_list=None): | if nb_sentences <= <NUM_LIT:0>:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if variable_nb_sentences:<EOL><INDENT>nb_sentences = self.randomize_nb_elements(nb_sentences, min=<NUM_LIT:1>)<EOL><DEDENT>para = self.word_connector.join(self.sentences(<EOL>nb_sentences, ext_word_list=ext_word_list,<EOL>))<EOL>return para<EOL> | :returns: A single paragraph. For example: 'Sapiente sunt omnis. Ut
pariatur ad autem ducimus et. Voluptas rem voluptas sint modi dolorem amet.'
Keyword arguments:
:param nb_sentences: around how many sentences the paragraph should contain
:param variable_nb_sentences: set to false if you want exactly ``nb``
sentences returned, otherwise the result may include a number of
sentences of ``nb`` +/-40% (with a minimum of 1)
:param ext_word_list: a list of words you would like to have instead of
'Lorem ipsum'.
:rtype: str | f14092:c0:m4 |
def paragraphs(self, nb=<NUM_LIT:3>, ext_word_list=None): | return [self.paragraph(ext_word_list=ext_word_list)<EOL>for _ in range(<NUM_LIT:0>, nb)]<EOL> | Generate an array of paragraphs
:example [paragraph1, paragraph2, paragraph3]
:param nb: how many paragraphs to return
:param ext_word_list: a list of words you would like to have instead of
'Lorem ipsum'.
:rtype: list | f14092:c0:m5 |
def text(self, max_nb_chars=<NUM_LIT:200>, ext_word_list=None): | text = []<EOL>if max_nb_chars < <NUM_LIT:5>:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>')<EOL><DEDENT>if max_nb_chars < <NUM_LIT>:<EOL><INDENT>while not text:<EOL><INDENT>size = <NUM_LIT:0><EOL>while size < max_nb_chars:<EOL><INDENT>word = (self.word_connector if size else '<STR_LIT>') +self.word(ext_word_list=ext_word_list)<EOL>text.append(word)<EOL>size += len(word)<EOL><DEDENT>text.pop()<EOL><DEDENT>text[<NUM_LIT:0>] = text[<NUM_LIT:0>][<NUM_LIT:0>].upper() + text[<NUM_LIT:0>][<NUM_LIT:1>:]<EOL>last_index = len(text) - <NUM_LIT:1><EOL>text[last_index] += self.sentence_punctuation<EOL><DEDENT>elif max_nb_chars < <NUM_LIT:100>:<EOL><INDENT>while not text:<EOL><INDENT>size = <NUM_LIT:0><EOL>while size < max_nb_chars:<EOL><INDENT>sentence = (self.word_connector if size else '<STR_LIT>') +self.sentence(ext_word_list=ext_word_list)<EOL>text.append(sentence)<EOL>size += len(sentence)<EOL><DEDENT>text.pop()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>while not text:<EOL><INDENT>size = <NUM_LIT:0><EOL>while size < max_nb_chars:<EOL><INDENT>paragraph = ('<STR_LIT:\n>' if size else '<STR_LIT>') +self.paragraph(ext_word_list=ext_word_list)<EOL>text.append(paragraph)<EOL>size += len(paragraph)<EOL><DEDENT>text.pop()<EOL><DEDENT><DEDENT>return "<STR_LIT>".join(text)<EOL> | Generate a text string.
Depending on the ``max_nb_chars, returns a string made of words, sentences, or paragraphs.
:example 'Sapiente sunt omnis. Ut pariatur ad autem ducimus et. Voluptas rem voluptas sint modi dolorem amet.'
Keyword arguments:
:param max_nb_chars: Maximum number of characters the text should contain (minimum 5)
:param ext_word_list: a list of words you would like to have instead of 'Lorem ipsum'.
:rtype str | f14092:c0:m6 |
def is_packet_trace(path): | path = os.path.abspath(path)<EOL>if not os.path.isfile(path):<EOL><INDENT>return False<EOL><DEDENT>try:<EOL><INDENT>f = open(path, '<STR_LIT:rb>')<EOL><DEDENT>except:<EOL><INDENT>return False<EOL><DEDENT>magic = f.read(<NUM_LIT:4>)<EOL>f.close()<EOL>return magic in FILE_TYPE_HANDLER<EOL> | Determine if a file is a packet trace that is supported by this module.
Args:
path (str): path to the trace file.
Returns:
bool: True if the file is a valid packet trace. | f14101:m0 |
def load_trace(path, *args, **kwargs): | with open(path, '<STR_LIT:rb>') as f:<EOL><INDENT>magic = f.read(MAGIC_LEN)<EOL><DEDENT>if magic not in FILE_TYPE_HANDLER:<EOL><INDENT>raise Exception('<STR_LIT>' % (binascii.hexlify(magic)))<EOL><DEDENT>return FILE_TYPE_HANDLER[magic](path, *args, **kwargs)<EOL> | Read a packet trace file, return a :class:`wltrace.common.WlTrace` object.
This function first reads the file's magic
(first ``FILE_TYPE_HANDLER`` bytes), and automatically determine the
file type, and call appropriate handler to process the file.
Args:
path (str): the file's path to be loaded.
Returns:
``WlTrace`` object. | f14101:m1 |
@abc.abstractmethod<EOL><INDENT>def _next(self, n=<NUM_LIT:100>):<DEDENT> | pass<EOL> | Get next n packets.
Subclass must implement this method.
Args:
n (int): number of packets to read
Returns:
list: a list of :class:`pyparser.capture.dot11.Dot11Packet` object. | f14103:c2:m3 |
def next(self): | try:<EOL><INDENT>self._fetch()<EOL>pkt = self.pkt_queue.popleft()<EOL>try:<EOL><INDENT>self._infer_acked(pkt)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>self._infer_retry(pkt)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>return pkt<EOL><DEDENT>except IndexError:<EOL><INDENT>raise StopIteration()<EOL><DEDENT> | Iteration function.
Note that it is possible to yield dangling ack packets as well, so user
can detect if the sniffer missed the previous packet. | f14103:c2:m7 |
def peek(self): | try:<EOL><INDENT>self._fetch()<EOL>pkt = self.pkt_queue[<NUM_LIT:0>]<EOL>return pkt<EOL><DEDENT>except IndexError:<EOL><INDENT>raise StopIteration()<EOL><DEDENT> | Get the current packet without consuming it. | f14103:c2:m8 |
def to_phy(self): | kwargs = {}<EOL>for attr in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>kwargs[attr] = getattr(self, attr, None)<EOL><DEDENT>kwargs['<STR_LIT>'] = True<EOL>return PhyInfo(**kwargs)<EOL> | Convert this to the standard :class:`pyparser.capture.common.PhyInfo`
class. | f14104:c2:m1 |
def mcs_to_rate(mcs, bw=<NUM_LIT:20>, long_gi=True): | if bw not in [<NUM_LIT:20>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>]:<EOL><INDENT>raise Exception("<STR_LIT>" % (bw))<EOL><DEDENT>if mcs not in MCS_TABLE:<EOL><INDENT>raise Exception("<STR_LIT>" % (mcs))<EOL><DEDENT>idx = int((math.log(bw/<NUM_LIT:10>, <NUM_LIT:2>)-<NUM_LIT:1>)*<NUM_LIT:2>)<EOL>if not long_gi:<EOL><INDENT>idx += <NUM_LIT:1><EOL><DEDENT>return MCS_TABLE[mcs][idx]<EOL> | Convert MCS index to rate in Mbps.
See http://mcsindex.com/
Args:
mcs (int): MCS index
bw (int): bandwidth, 20, 40, 80, ...
long_gi(bool): True if long GI is used.
Returns:
rate (float): bitrate in Mbps
>>> mcs_to_rate(5, bw=20, long_gi=False)
57.8
>>> mcs_to_rate(4, bw=40, long_gi=True)
81
>>> mcs_to_rate(3, bw=80, long_gi=False)
130
>>> mcs_to_rate(13, bw=160, long_gi=True)
936 | f14105:m0 |
def rate_to_mcs(rate, bw=<NUM_LIT:20>, long_gi=True): | if bw not in [<NUM_LIT:20>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>]:<EOL><INDENT>raise Exception("<STR_LIT>" % (bw))<EOL><DEDENT>idx = int((math.log(bw/<NUM_LIT:10>, <NUM_LIT:2>)-<NUM_LIT:1>)*<NUM_LIT:2>)<EOL>if not long_gi:<EOL><INDENT>idx += <NUM_LIT:1><EOL><DEDENT>for mcs, rates in MCS_TABLE.items():<EOL><INDENT>if abs(rates[idx] - rate) < <NUM_LIT>:<EOL><INDENT>return mcs<EOL><DEDENT><DEDENT>for idx, r in enumerate(DOT11A_RATES):<EOL><INDENT>if abs(r-rate) < <NUM_LIT>:<EOL><INDENT>return idx<EOL><DEDENT><DEDENT>raise Exception("<STR_LIT>" %<EOL>(rate, bw, long_gi))<EOL> | Convert bit rate to MCS index.
Args:
rate (float): bit rate in Mbps
bw (int): bandwidth, 20, 40, 80, ...
long_gi (bool): True if long GI is used.
Returns:
mcs (int): MCS index
>>> rate_to_mcs(120, bw=40, long_gi=False)
5 | f14105:m1 |
def is_broadcast(mac): | return mac.lower() == '<STR_LIT>'<EOL> | Whether or not a mac is broadcast MAC address.
Args:
mac (str): MAC address in string format (``xx:xx:xx:xx:xx:xx``). Case
insensitive.
Returns:
bool. | f14105:m2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.