signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def sha1(self, raw_output=False): | res = hashlib.sha1(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 sha1 hash of a given string
:example 'b5d86317c2a144cd04d0d7c03b2b02666fafadf2' | f13902:c0:m4 |
def sha256(self, raw_output=False): | res = hashlib.sha256(<EOL>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 sha256 hash of a given string
:example '85086017559ccc40638fcde2fecaf295e0de7ca51b7517b6aebeaaf75b4d4654' | f13902:c0:m5 |
def uuid4(self, cast_to=str): | <EOL>return cast_to(uuid.UUID(int=self.generator.random.getrandbits(<NUM_LIT>), version=<NUM_LIT:4>))<EOL> | Generates a random UUID4 string.
:param cast_to: Specify what type the UUID should be cast to. Default is `str`
:type cast_to: callable | f13902:c0:m6 |
def password(<EOL>self,<EOL>length=<NUM_LIT:10>,<EOL>special_chars=True,<EOL>digits=True,<EOL>upper_case=True,<EOL>lower_case=True): | choices = "<STR_LIT>"<EOL>required_tokens = []<EOL>if special_chars:<EOL><INDENT>required_tokens.append(<EOL>self.generator.random.choice("<STR_LIT>"))<EOL>choices += "<STR_LIT>"<EOL><DEDENT>if digits:<EOL><INDENT>required_tokens.append(self.generator.random.choice(string.digits))<EOL>choices += string.digits<EOL><DEDENT>if upper_case:<EOL><INDENT>required_tokens.append(<EOL>self.generator.random.choice(string.ascii_uppercase))<EOL>choices += string.ascii_uppercase<EOL><DEDENT>if lower_case:<EOL><INDENT>required_tokens.append(<EOL>self.generator.random.choice(string.ascii_lowercase))<EOL>choices += string.ascii_lowercase<EOL><DEDENT>assert len(<EOL>required_tokens) <= length, "<STR_LIT>"<EOL>chars = self.random_choices(choices, length=length)<EOL>random_indexes = set()<EOL>while len(random_indexes) < len(required_tokens):<EOL><INDENT>random_indexes.add(<EOL>self.generator.random.randint(<NUM_LIT:0>, len(chars) - <NUM_LIT:1>))<EOL><DEDENT>for i, index in enumerate(random_indexes):<EOL><INDENT>chars[index] = required_tokens[i]<EOL><DEDENT>return '<STR_LIT>'.join(chars)<EOL> | Generates a random password.
@param length: Integer. Length of a password
@param special_chars: Boolean. Whether to use special characters !@#$%^&*()_+
@param digits: Boolean. Whether to use digits
@param upper_case: Boolean. Whether to use upper letters
@param lower_case: Boolean. Whether to use lower letters
@return: String. Random password | f13902:c0:m7 |
def msisdn(self): | return self.numerify(self.random_element(self.msisdn_formats))<EOL> | https://en.wikipedia.org/wiki/MSISDN | f13936:c0:m1 |
def pystr(self, min_chars=None, max_chars=<NUM_LIT:20>): | if min_chars is None:<EOL><INDENT>return "<STR_LIT>".join(self.random_letters(length=max_chars))<EOL><DEDENT>else:<EOL><INDENT>assert (<EOL>max_chars >= min_chars), "<STR_LIT>"<EOL>return "<STR_LIT>".join(<EOL>self.random_letters(<EOL>length=self.generator.random.randint(min_chars, max_chars),<EOL>),<EOL>)<EOL><DEDENT> | Generates a random string of upper and lowercase letters.
:type min_chars: int
:type max_chars: int
:return: String. Random of random length between min and max characters. | f13952:c0:m1 |
def pydict(self, nb_elements=<NUM_LIT:10>, variable_nb_elements=True, *value_types): | if variable_nb_elements:<EOL><INDENT>nb_elements = self.randomize_nb_elements(nb_elements, min=<NUM_LIT:1>)<EOL><DEDENT>return dict(zip(<EOL>self.generator.words(nb_elements),<EOL>self._pyiterable(nb_elements, False, *value_types),<EOL>))<EOL> | Returns a dictionary.
:nb_elements: number of elements for dictionary
:variable_nb_elements: is use variable number of elements for dictionary
:value_types: type of dictionary values | f13952:c0:m11 |
def unix_time(self, end_datetime=None, start_datetime=None): | start_datetime = self._parse_start_datetime(start_datetime)<EOL>end_datetime = self._parse_end_datetime(end_datetime)<EOL>return self.generator.random.randint(start_datetime, end_datetime)<EOL> | Get a timestamp between January 1, 1970 and now, unless passed
explicit start_datetime or end_datetime values.
:example 1061306726 | f13969:c1:m0 |
def time_delta(self, end_datetime=None): | start_datetime = self._parse_start_datetime('<STR_LIT>')<EOL>end_datetime = self._parse_end_datetime(end_datetime)<EOL>seconds = end_datetime - start_datetime<EOL>ts = self.generator.random.randint(*sorted([<NUM_LIT:0>, seconds]))<EOL>return timedelta(seconds=ts)<EOL> | Get a timedelta object | f13969:c1:m1 |
def date_time(self, tzinfo=None, end_datetime=None): | <EOL>return datetime(<NUM_LIT>, <NUM_LIT:1>, <NUM_LIT:1>, tzinfo=tzinfo) +timedelta(seconds=self.unix_time(end_datetime=end_datetime))<EOL> | Get a datetime object for a date between January 1, 1970 and now
:param tzinfo: timezone, instance of datetime.tzinfo subclass
:example DateTime('2005-08-16 20:39:21')
:return datetime | f13969:c1:m2 |
def date_time_ad(self, tzinfo=None, end_datetime=None, start_datetime=None): | <EOL>start_time = -<NUM_LIT> if start_datetime is None else self._parse_start_datetime(start_datetime)<EOL>end_datetime = self._parse_end_datetime(end_datetime)<EOL>ts = self.generator.random.randint(start_time, end_datetime)<EOL>return datetime(<NUM_LIT>, <NUM_LIT:1>, <NUM_LIT:1>, tzinfo=tzinfo) + timedelta(seconds=ts)<EOL> | Get a datetime object for a date between January 1, 001 and now
:param tzinfo: timezone, instance of datetime.tzinfo subclass
:example DateTime('1265-03-22 21:15:52')
:return datetime | f13969:c1:m3 |
def iso8601(self, tzinfo=None, end_datetime=None): | return self.date_time(tzinfo, end_datetime=end_datetime).isoformat()<EOL> | :param tzinfo: timezone, instance of datetime.tzinfo subclass
:example '2003-10-21T16:05:52+0000' | f13969:c1:m4 |
def date(self, pattern='<STR_LIT>', end_datetime=None): | return self.date_time(end_datetime=end_datetime).strftime(pattern)<EOL> | Get a date string between January 1, 1970 and now
:param pattern format
:example '2008-11-27' | f13969:c1:m5 |
def date_object(self, end_datetime=None): | return self.date_time(end_datetime=end_datetime).date()<EOL> | Get a date object between January 1, 1970 and now
:example datetime.date(2016, 9, 20) | f13969:c1:m6 |
def time(self, pattern='<STR_LIT>', end_datetime=None): | return self.date_time(<EOL>end_datetime=end_datetime).time().strftime(pattern)<EOL> | Get a time string (24h format by default)
:param pattern format
:example '15:02:34' | f13969:c1:m7 |
def time_object(self, end_datetime=None): | return self.date_time(end_datetime=end_datetime).time()<EOL> | Get a time object
:example datetime.time(15, 56, 56, 772876) | f13969:c1:m8 |
def date_time_between(self, start_date='<STR_LIT>', end_date='<STR_LIT>', tzinfo=None): | start_date = self._parse_date_time(start_date, tzinfo=tzinfo)<EOL>end_date = self._parse_date_time(end_date, tzinfo=tzinfo)<EOL>if end_date - start_date <= <NUM_LIT:1>:<EOL><INDENT>ts = start_date + self.generator.random.random()<EOL><DEDENT>else:<EOL><INDENT>ts = self.generator.random.randint(start_date, end_date)<EOL><DEDENT>if tzinfo is None:<EOL><INDENT>return datetime(<NUM_LIT>, <NUM_LIT:1>, <NUM_LIT:1>, tzinfo=tzinfo) + timedelta(seconds=ts)<EOL><DEDENT>else:<EOL><INDENT>return (<EOL>datetime(<NUM_LIT>, <NUM_LIT:1>, <NUM_LIT:1>, tzinfo=tzutc()) + timedelta(seconds=ts)<EOL>).astimezone(tzinfo)<EOL><DEDENT> | Get a DateTime object based on a random date between two given dates.
Accepts date strings that can be recognized by strtotime().
:param start_date Defaults to 30 years ago
:param end_date Defaults to "now"
:param tzinfo: timezone, instance of datetime.tzinfo subclass
:example DateTime('1999-02-02 11:42:52')
:return DateTime | f13969:c1:m15 |
def date_between(self, start_date='<STR_LIT>', end_date='<STR_LIT>'): | start_date = self._parse_date(start_date)<EOL>end_date = self._parse_date(end_date)<EOL>return self.date_between_dates(date_start=start_date, date_end=end_date)<EOL> | Get a Date object based on a random date between two given dates.
Accepts date strings that can be recognized by strtotime().
:param start_date Defaults to 30 years ago
:param end_date Defaults to "today"
:example Date('1999-02-02')
:return Date | f13969:c1:m16 |
def future_datetime(self, end_date='<STR_LIT>', tzinfo=None): | return self.date_time_between(<EOL>start_date='<STR_LIT>', end_date=end_date, tzinfo=tzinfo,<EOL>)<EOL> | Get a DateTime object based on a random date between 1 second form now
and a given date.
Accepts date strings that can be recognized by strtotime().
:param end_date Defaults to "+30d"
:param tzinfo: timezone, instance of datetime.tzinfo subclass
:example DateTime('1999-02-02 11:42:52')
:return DateTime | f13969:c1:m17 |
def future_date(self, end_date='<STR_LIT>', tzinfo=None): | return self.date_between(start_date='<STR_LIT>', end_date=end_date)<EOL> | Get a Date object based on a random date between 1 day from now and a
given date.
Accepts date strings that can be recognized by strtotime().
:param end_date Defaults to "+30d"
:param tzinfo: timezone, instance of datetime.tzinfo subclass
:example DateTime('1999-02-02 11:42:52')
:return DateTime | f13969:c1:m18 |
def past_datetime(self, start_date='<STR_LIT>', tzinfo=None): | return self.date_time_between(<EOL>start_date=start_date, end_date='<STR_LIT>', tzinfo=tzinfo,<EOL>)<EOL> | Get a DateTime object based on a random date between a given date and 1
second ago.
Accepts date strings that can be recognized by strtotime().
:param start_date Defaults to "-30d"
:param tzinfo: timezone, instance of datetime.tzinfo subclass
:example DateTime('1999-02-02 11:42:52')
:return DateTime | f13969:c1:m19 |
def past_date(self, start_date='<STR_LIT>', tzinfo=None): | return self.date_between(start_date=start_date, end_date='<STR_LIT>')<EOL> | Get a Date object based on a random date between a given date and 1 day
ago.
Accepts date strings that can be recognized by strtotime().
:param start_date Defaults to "-30d"
:param tzinfo: timezone, instance of datetime.tzinfo subclass
:example DateTime('1999-02-02 11:42:52')
:return DateTime | f13969:c1:m20 |
def date_time_between_dates(<EOL>self,<EOL>datetime_start=None,<EOL>datetime_end=None,<EOL>tzinfo=None): | if datetime_start is None:<EOL><INDENT>datetime_start = datetime.now(tzinfo)<EOL><DEDENT>if datetime_end is None:<EOL><INDENT>datetime_end = datetime.now(tzinfo)<EOL><DEDENT>timestamp = self.generator.random.randint(<EOL>datetime_to_timestamp(datetime_start),<EOL>datetime_to_timestamp(datetime_end),<EOL>)<EOL>try:<EOL><INDENT>if tzinfo is None:<EOL><INDENT>pick = datetime.fromtimestamp(timestamp, tzlocal())<EOL>pick = pick.astimezone(tzutc()).replace(tzinfo=None)<EOL><DEDENT>else:<EOL><INDENT>pick = datetime.fromtimestamp(timestamp, tzinfo)<EOL><DEDENT><DEDENT>except OverflowError:<EOL><INDENT>raise OverflowError(<EOL>"<STR_LIT>"<EOL>"<STR_LIT>",<EOL>)<EOL><DEDENT>return pick<EOL> | Takes two DateTime objects and returns a random datetime between the two
given datetimes.
Accepts DateTime objects.
:param datetime_start: DateTime
:param datetime_end: DateTime
:param tzinfo: timezone, instance of datetime.tzinfo subclass
:example DateTime('1999-02-02 11:42:52')
:return DateTime | f13969:c1:m21 |
def date_between_dates(self, date_start=None, date_end=None): | return self.date_time_between_dates(date_start, date_end).date()<EOL> | Takes two Date objects and returns a random date between the two given dates.
Accepts Date or Datetime objects
:param date_start: Date
:param date_end: Date
:return Date | f13969:c1:m22 |
def date_time_this_century(<EOL>self,<EOL>before_now=True,<EOL>after_now=False,<EOL>tzinfo=None): | now = datetime.now(tzinfo)<EOL>this_century_start = datetime(<EOL>now.year - (now.year % <NUM_LIT:100>), <NUM_LIT:1>, <NUM_LIT:1>, tzinfo=tzinfo)<EOL>next_century_start = datetime(<EOL>min(this_century_start.year + <NUM_LIT:100>, MAXYEAR), <NUM_LIT:1>, <NUM_LIT:1>, tzinfo=tzinfo)<EOL>if before_now and after_now:<EOL><INDENT>return self.date_time_between_dates(<EOL>this_century_start, next_century_start, tzinfo)<EOL><DEDENT>elif not before_now and after_now:<EOL><INDENT>return self.date_time_between_dates(now, next_century_start, tzinfo)<EOL><DEDENT>elif not after_now and before_now:<EOL><INDENT>return self.date_time_between_dates(this_century_start, now, tzinfo)<EOL><DEDENT>else:<EOL><INDENT>return now<EOL><DEDENT> | Gets a DateTime object for the current century.
:param before_now: include days in current century before today
:param after_now: include days in current century after today
:param tzinfo: timezone, instance of datetime.tzinfo subclass
:example DateTime('2012-04-04 11:02:02')
:return DateTime | f13969:c1:m23 |
def date_time_this_decade(<EOL>self,<EOL>before_now=True,<EOL>after_now=False,<EOL>tzinfo=None): | now = datetime.now(tzinfo)<EOL>this_decade_start = datetime(<EOL>now.year - (now.year % <NUM_LIT:10>), <NUM_LIT:1>, <NUM_LIT:1>, tzinfo=tzinfo)<EOL>next_decade_start = datetime(<EOL>min(this_decade_start.year + <NUM_LIT:10>, MAXYEAR), <NUM_LIT:1>, <NUM_LIT:1>, tzinfo=tzinfo)<EOL>if before_now and after_now:<EOL><INDENT>return self.date_time_between_dates(<EOL>this_decade_start, next_decade_start, tzinfo)<EOL><DEDENT>elif not before_now and after_now:<EOL><INDENT>return self.date_time_between_dates(now, next_decade_start, tzinfo)<EOL><DEDENT>elif not after_now and before_now:<EOL><INDENT>return self.date_time_between_dates(this_decade_start, now, tzinfo)<EOL><DEDENT>else:<EOL><INDENT>return now<EOL><DEDENT> | Gets a DateTime object for the decade year.
:param before_now: include days in current decade before today
:param after_now: include days in current decade after today
:param tzinfo: timezone, instance of datetime.tzinfo subclass
:example DateTime('2012-04-04 11:02:02')
:return DateTime | f13969:c1:m24 |
def date_time_this_year(<EOL>self,<EOL>before_now=True,<EOL>after_now=False,<EOL>tzinfo=None): | now = datetime.now(tzinfo)<EOL>this_year_start = now.replace(<EOL>month=<NUM_LIT:1>, day=<NUM_LIT:1>, hour=<NUM_LIT:0>, minute=<NUM_LIT:0>, second=<NUM_LIT:0>, microsecond=<NUM_LIT:0>)<EOL>next_year_start = datetime(now.year + <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, tzinfo=tzinfo)<EOL>if before_now and after_now:<EOL><INDENT>return self.date_time_between_dates(<EOL>this_year_start, next_year_start, tzinfo)<EOL><DEDENT>elif not before_now and after_now:<EOL><INDENT>return self.date_time_between_dates(now, next_year_start, tzinfo)<EOL><DEDENT>elif not after_now and before_now:<EOL><INDENT>return self.date_time_between_dates(this_year_start, now, tzinfo)<EOL><DEDENT>else:<EOL><INDENT>return now<EOL><DEDENT> | Gets a DateTime object for the current year.
:param before_now: include days in current year before today
:param after_now: include days in current year after today
:param tzinfo: timezone, instance of datetime.tzinfo subclass
:example DateTime('2012-04-04 11:02:02')
:return DateTime | f13969:c1:m25 |
def date_time_this_month(<EOL>self,<EOL>before_now=True,<EOL>after_now=False,<EOL>tzinfo=None): | now = datetime.now(tzinfo)<EOL>this_month_start = now.replace(<EOL>day=<NUM_LIT:1>, hour=<NUM_LIT:0>, minute=<NUM_LIT:0>, second=<NUM_LIT:0>, microsecond=<NUM_LIT:0>)<EOL>next_month_start = this_month_start +relativedelta.relativedelta(months=<NUM_LIT:1>)<EOL>if before_now and after_now:<EOL><INDENT>return self.date_time_between_dates(<EOL>this_month_start, next_month_start, tzinfo)<EOL><DEDENT>elif not before_now and after_now:<EOL><INDENT>return self.date_time_between_dates(now, next_month_start, tzinfo)<EOL><DEDENT>elif not after_now and before_now:<EOL><INDENT>return self.date_time_between_dates(this_month_start, now, tzinfo)<EOL><DEDENT>else:<EOL><INDENT>return now<EOL><DEDENT> | Gets a DateTime object for the current month.
:param before_now: include days in current month before today
:param after_now: include days in current month after today
:param tzinfo: timezone, instance of datetime.tzinfo subclass
:example DateTime('2012-04-04 11:02:02')
:return DateTime | f13969:c1:m26 |
def date_this_century(self, before_today=True, after_today=False): | today = date.today()<EOL>this_century_start = date(today.year - (today.year % <NUM_LIT:100>), <NUM_LIT:1>, <NUM_LIT:1>)<EOL>next_century_start = date(this_century_start.year + <NUM_LIT:100>, <NUM_LIT:1>, <NUM_LIT:1>)<EOL>if before_today and after_today:<EOL><INDENT>return self.date_between_dates(<EOL>this_century_start, next_century_start)<EOL><DEDENT>elif not before_today and after_today:<EOL><INDENT>return self.date_between_dates(today, next_century_start)<EOL><DEDENT>elif not after_today and before_today:<EOL><INDENT>return self.date_between_dates(this_century_start, today)<EOL><DEDENT>else:<EOL><INDENT>return today<EOL><DEDENT> | Gets a Date object for the current century.
:param before_today: include days in current century before today
:param after_today: include days in current century after today
:example Date('2012-04-04')
:return Date | f13969:c1:m27 |
def date_this_decade(self, before_today=True, after_today=False): | today = date.today()<EOL>this_decade_start = date(today.year - (today.year % <NUM_LIT:10>), <NUM_LIT:1>, <NUM_LIT:1>)<EOL>next_decade_start = date(this_decade_start.year + <NUM_LIT:10>, <NUM_LIT:1>, <NUM_LIT:1>)<EOL>if before_today and after_today:<EOL><INDENT>return self.date_between_dates(this_decade_start, next_decade_start)<EOL><DEDENT>elif not before_today and after_today:<EOL><INDENT>return self.date_between_dates(today, next_decade_start)<EOL><DEDENT>elif not after_today and before_today:<EOL><INDENT>return self.date_between_dates(this_decade_start, today)<EOL><DEDENT>else:<EOL><INDENT>return today<EOL><DEDENT> | Gets a Date object for the decade year.
:param before_today: include days in current decade before today
:param after_today: include days in current decade after today
:example Date('2012-04-04')
:return Date | f13969:c1:m28 |
def date_this_year(self, before_today=True, after_today=False): | today = date.today()<EOL>this_year_start = today.replace(month=<NUM_LIT:1>, day=<NUM_LIT:1>)<EOL>next_year_start = date(today.year + <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>)<EOL>if before_today and after_today:<EOL><INDENT>return self.date_between_dates(this_year_start, next_year_start)<EOL><DEDENT>elif not before_today and after_today:<EOL><INDENT>return self.date_between_dates(today, next_year_start)<EOL><DEDENT>elif not after_today and before_today:<EOL><INDENT>return self.date_between_dates(this_year_start, today)<EOL><DEDENT>else:<EOL><INDENT>return today<EOL><DEDENT> | Gets a Date object for the current year.
:param before_today: include days in current year before today
:param after_today: include days in current year after today
:example Date('2012-04-04')
:return Date | f13969:c1:m29 |
def date_this_month(self, before_today=True, after_today=False): | today = date.today()<EOL>this_month_start = today.replace(day=<NUM_LIT:1>)<EOL>next_month_start = this_month_start +relativedelta.relativedelta(months=<NUM_LIT:1>)<EOL>if before_today and after_today:<EOL><INDENT>return self.date_between_dates(this_month_start, next_month_start)<EOL><DEDENT>elif not before_today and after_today:<EOL><INDENT>return self.date_between_dates(today, next_month_start)<EOL><DEDENT>elif not after_today and before_today:<EOL><INDENT>return self.date_between_dates(this_month_start, today)<EOL><DEDENT>else:<EOL><INDENT>return today<EOL><DEDENT> | Gets a Date object for the current month.
:param before_today: include days in current month before today
:param after_today: include days in current month after today
:param tzinfo: timezone, instance of datetime.tzinfo subclass
:example DateTime('2012-04-04 11:02:02')
:return DateTime | f13969:c1:m30 |
def time_series(<EOL>self,<EOL>start_date='<STR_LIT>',<EOL>end_date='<STR_LIT>',<EOL>precision=None,<EOL>distrib=None,<EOL>tzinfo=None): | start_date = self._parse_date_time(start_date, tzinfo=tzinfo)<EOL>end_date = self._parse_date_time(end_date, tzinfo=tzinfo)<EOL>if end_date < start_date:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>if precision is None:<EOL><INDENT>precision = (end_date - start_date) / <NUM_LIT:30><EOL><DEDENT>precision = self._parse_timedelta(precision)<EOL>if distrib is None:<EOL><INDENT>def distrib(dt): return self.generator.random.uniform(<NUM_LIT:0>, precision) <EOL><DEDENT>if not callable(distrib):<EOL><INDENT>raise ValueError(<EOL>"<STR_LIT>".format(distrib))<EOL><DEDENT>datapoint = start_date<EOL>while datapoint < end_date:<EOL><INDENT>dt = timestamp_to_datetime(datapoint, tzinfo)<EOL>datapoint += precision<EOL>yield (dt, distrib(dt))<EOL><DEDENT> | Returns a generator yielding tuples of ``(<datetime>, <value>)``.
The data points will start at ``start_date``, and be at every time interval specified by
``precision``.
``distrib`` is a callable that accepts ``<datetime>`` and returns ``<value>`` | f13969:c1:m31 |
def century(self): | return self.random_element(self.centuries)<EOL> | :example 'XVII' | f13969:c1:m38 |
def date_of_birth(self, tzinfo=None, minimum_age=<NUM_LIT:0>, maximum_age=<NUM_LIT>): | if not isinstance(minimum_age, int):<EOL><INDENT>raise TypeError("<STR_LIT>")<EOL><DEDENT>if not isinstance(maximum_age, int):<EOL><INDENT>raise TypeError("<STR_LIT>")<EOL><DEDENT>if (maximum_age < <NUM_LIT:0>):<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>if (minimum_age < <NUM_LIT:0>):<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>if (minimum_age > maximum_age):<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>now = datetime.now(tzinfo).date()<EOL>start_date = now.replace(year=now.year - (maximum_age+<NUM_LIT:1>))<EOL>end_date = now.replace(year=now.year - minimum_age)<EOL>dob = self.date_time_ad(tzinfo=tzinfo, start_datetime=start_date, end_datetime=end_date).date()<EOL>return dob if dob != start_date else dob + timedelta(days=<NUM_LIT:1>)<EOL> | Generate a random date of birth represented as a Date object,
constrained by optional miminimum_age and maximum_age
parameters.
:param tzinfo Defaults to None.
:param minimum_age Defaults to 0.
:param maximum_age Defaults to 115.
:example Date('1979-02-02')
:return Date | f13969:c1:m40 |
def credit_card_provider(self, card_type=None): | if card_type is None:<EOL><INDENT>card_type = self.random_element(self.credit_card_types.keys())<EOL><DEDENT>return self._credit_card_type(card_type).name<EOL> | Returns the provider's name of the credit card. | f13976:c1:m0 |
def credit_card_number(self, card_type=None): | card = self._credit_card_type(card_type)<EOL>prefix = self.random_element(card.prefixes)<EOL>number = self._generate_number(self.numerify(prefix), card.length)<EOL>return number<EOL> | Returns a valid credit card number. | f13976:c1:m1 |
def credit_card_security_code(self, card_type=None): | sec_len = self._credit_card_type(card_type).security_code_length<EOL>return self.numerify('<STR_LIT:#>' * sec_len)<EOL> | Returns a security code string. | f13976:c1:m4 |
def _credit_card_type(self, card_type=None): | if card_type is None:<EOL><INDENT>card_type = self.random_element(self.credit_card_types.keys())<EOL><DEDENT>elif isinstance(card_type, CreditCard):<EOL><INDENT>return card_type<EOL><DEDENT>return self.credit_card_types[card_type]<EOL> | Returns a random credit card type instance. | f13976:c1:m5 |
def _generate_number(self, prefix, length): | number = prefix<EOL>number += '<STR_LIT:#>' * (length - len(prefix) - <NUM_LIT:1>)<EOL>number = self.numerify(number)<EOL>reverse = number[::-<NUM_LIT:1>]<EOL>tot = <NUM_LIT:0><EOL>pos = <NUM_LIT:0><EOL>while pos < length - <NUM_LIT:1>:<EOL><INDENT>tot += Provider.luhn_lookup[reverse[pos]]<EOL>if pos != (length - <NUM_LIT:2>):<EOL><INDENT>tot += int(reverse[pos + <NUM_LIT:1>])<EOL><DEDENT>pos += <NUM_LIT:2><EOL><DEDENT>check_digit = (<NUM_LIT:10> - (tot % <NUM_LIT:10>)) % <NUM_LIT:10><EOL>number += str(check_digit)<EOL>return number<EOL> | 'prefix' is the start of the CC number as a string, any number of digits.
'length' is the length of the CC number to generate. Typically 13 or 16 | f13976:c1:m6 |
def street_prefix(self): | return self.random_element(self.street_prefixes)<EOL> | :example 'rue' | f13977:c0:m0 |
def city_prefix(self): | return self.random_element(self.city_prefixes)<EOL> | :example 'rue' | f13977:c0:m1 |
def canton(self): | return self.random_element(self.cantons)<EOL> | Randomly returns a swiss canton ('Abbreviated' , 'Name').
:example ('VD' . 'Vaud') | f13977:c0:m2 |
def canton_name(self): | return self.canton()[<NUM_LIT:1>]<EOL> | Randomly returns a Swiss canton name.
:example 'Vaud' | f13977:c0:m3 |
def canton_code(self): | return self.canton()[<NUM_LIT:0>]<EOL> | Randomly returns a Swiss canton code.
:example 'VD' | f13977:c0:m4 |
def street_prefix(self): | return self.random_element(self.street_prefixes)<EOL> | Randomly returns a street prefix
:example 'aleja' | f13985:c0:m0 |
def street_prefix_short(self): | return self.random_element(self.street_prefixes)[:<NUM_LIT:2>] + '<STR_LIT:.>'<EOL> | Randomly returns an abbreviation of the street prefix.
:example 'al.' | f13985:c0:m1 |
def street_name(self): | return self.random_element(self.streets)<EOL> | Randomly returns a street name
:example 'Wróblewskiego' | f13985:c0:m2 |
def city(self): | return self.random_element(self.cities)<EOL> | Randomly returns a street name
:example 'Konin' | f13985:c0:m3 |
def region(self): | return self.random_element(self.regions)<EOL> | :example 'Wielkopolskie' | f13985:c0:m4 |
def postcode(self): | return '<STR_LIT>'.format(<EOL>self.generator.random.randint(<EOL><NUM_LIT:0>, <NUM_LIT:10>), self.generator.random.randint(<EOL><NUM_LIT:1000>, <NUM_LIT>))<EOL> | The code consists of five digits (01000-99999) | f13986:c0:m1 |
def state_abbr(self, include_territories=True): | if include_territories:<EOL><INDENT>self.random_element(self.states_and_territories_abbr)<EOL><DEDENT>return self.random_element(self.states_abbr)<EOL> | :returns: A random state or territory abbreviation.
:param include_territories: If True, territories will be included.
If False, only states will be returned. | f13992:c0:m3 |
def postcode_in_state(self, state_abbr=None): | if state_abbr is None:<EOL><INDENT>state_abbr = self.random_element(self.states_abbr)<EOL><DEDENT>if state_abbr in self.states_abbr:<EOL><INDENT>postcode = "<STR_LIT>" % (self.generator.random.randint(<EOL>self.states_postcode[state_abbr][<NUM_LIT:0>],<EOL>self.states_postcode[state_abbr][<NUM_LIT:1>]))<EOL>if len(postcode) == <NUM_LIT:4>:<EOL><INDENT>postcode = "<STR_LIT>" % postcode<EOL><DEDENT>return postcode<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT> | :returns: A random postcode within the provided state abbreviation
:param state_abbr: A state abbreviation | f13992:c0:m6 |
def military_ship(self): | return self.random_element(self.military_ship_prefix)<EOL> | :example 'USS' | f13992:c0:m7 |
def military_state(self): | return self.random_element(self.military_state_abbr)<EOL> | :example 'APO' | f13992:c0:m8 |
def military_apo(self): | return self.numerify(self.military_apo_format)<EOL> | :example 'PSC 5394 Box 3492 | f13992:c0:m9 |
def military_dpo(self): | return self.numerify(self.military_dpo_format)<EOL> | :example 'Unit 3333 Box 9342' | f13992:c0:m10 |
def street_prefix(self): | return self.random_element(self.street_prefixes)<EOL> | :example 'Rua' | f13994:c0:m0 |
def city_name(self): | return self.random_element(self.cities)<EOL> | :example 'Amora' | f13994:c0:m1 |
def distrito(self): | return self.random_element(self.distritos)<EOL> | :example 'Bragança' | f13994:c0:m2 |
def freguesia(self): | return self.random_element(self.freguesias)<EOL> | :example 'Miranda do Douro' | f13994:c0:m3 |
def postal_code_letter(self): | return self.random_element(self.postal_code_letters)<EOL> | Returns a random letter from the list of allowable
letters in a canadian postal code | f14003:c0:m4 |
def postcode(self): | temp = re.sub(r'<STR_LIT>',<EOL>lambda x: self.postal_code_letter(),<EOL>self.random_element(self.postal_code_formats))<EOL>return self.numerify(temp)<EOL> | Replaces all question mark ('?') occurrences with a random letter
from postal_code_formats then passes result to
numerify to insert numbers | f14003:c0:m5 |
def postcode(self): | postcode = '<STR_LIT>'<EOL>pattern = self.random_element(self.postcode_formats)<EOL>for placeholder in pattern:<EOL><INDENT>postcode += self.random_element(self._postcode_sets[placeholder])<EOL><DEDENT>return postcode<EOL> | See
http://web.archive.org/web/20090930140939/http://www.govtalk.gov.uk/gdsc/html/noframes/PostCode-2-1-Release.htm | f14005:c0:m0 |
def street_prefix(self): | return self.random_element(self.street_prefixes)<EOL> | :example 'Avenida' | f14006:c0:m3 |
def secondary_address(self): | return self.numerify(<EOL>self.random_element(<EOL>self.secondary_address_formats))<EOL> | :example '020 Interior 999' | f14006:c0:m4 |
def state(self): | return self.random_element(self.states)[<NUM_LIT:1>]<EOL> | example: u'Guerrero' | f14006:c0:m5 |
def state_abbr(self): | return self.random_element(self.states)[<NUM_LIT:0>]<EOL> | example: u'GRO' | f14006:c0:m6 |
def city_suffix(self): | return self.random_element(self.city_suffixes)<EOL> | :example 'town' | f14007:c0:m0 |
def street_suffix(self): | return self.random_element(self.street_suffixes)<EOL> | :example 'Avenue' | f14007:c0:m1 |
def building_number(self): | return self.numerify(self.random_element(self.building_number_formats))<EOL> | :example '791' | f14007:c0:m2 |
def city(self): | pattern = self.random_element(self.city_formats)<EOL>return self.generator.parse(pattern)<EOL> | :example 'Sashabury' | f14007:c0:m3 |
def street_name(self): | pattern = self.random_element(self.street_name_formats)<EOL>return self.generator.parse(pattern)<EOL> | :example 'Crist Parks' | f14007:c0:m4 |
def street_address(self): | pattern = self.random_element(self.street_address_formats)<EOL>return self.generator.parse(pattern)<EOL> | :example '791 Crist Parks' | f14007:c0:m5 |
def postcode(self): | return self.bothify(self.random_element(self.postcode_formats)).upper()<EOL> | :example 86039-9874 | f14007:c0:m6 |
def address(self): | pattern = self.random_element(self.address_formats)<EOL>return self.generator.parse(pattern)<EOL> | :example '791 Crist Parks, Sashabury, IL 86039-9874' | f14007:c0:m7 |
def street_prefix(self): | return self.random_element(self.street_prefixes)<EOL> | :example 'rua' | f14013:c0:m0 |
def estado(self): | return self.random_element(self.estados)<EOL> | Randomly returns a Brazilian State ('sigla' , 'nome').
:example ('MG' . 'Minas Gerais') | f14013:c0:m1 |
def estado_nome(self): | return self.estado()[<NUM_LIT:1>]<EOL> | Randomly returns a Brazilian State Name
:example 'Minas Gerais' | f14013:c0:m2 |
def estado_sigla(self): | return self.estado()[<NUM_LIT:0>]<EOL> | Randomly returns the abbreviation of a Brazilian State
:example 'MG' | f14013:c0:m3 |
def bairro(self): | return self.random_element(self.bairros)<EOL> | Randomly returns a bairro (neighborhood) name.
The names were taken from the city of Belo Horizonte - Minas Gerais
:example 'Serra' | f14013:c0:m4 |
def city(self): | return self.random_element(self.cities)<EOL> | :example 'Բյուրեղավան' | f14014:c0:m0 |
def city_prefix(self): | return self.random_element(self.city_prefixes)<EOL> | :example 'ք.' | f14014:c0:m1 |
def postcode(self): | return "<STR_LIT>" % self.generator.random.randint(<NUM_LIT:200>, <NUM_LIT>)<EOL> | :example '3159' | f14014:c0:m2 |
def postcode_in_state(self, state_abbr=None): | if state_abbr is None:<EOL><INDENT>state_abbr = self.random_element(self.states_abbr)<EOL><DEDENT>if state_abbr in self.states_abbr:<EOL><INDENT>postcode = "<STR_LIT>" % (self.generator.random.randint(<EOL>self.states_postcode[state_abbr][<NUM_LIT:0>],<EOL>self.states_postcode[state_abbr][<NUM_LIT:1>]))<EOL>if len(postcode) == <NUM_LIT:3>:<EOL><INDENT>postcode = "<STR_LIT>" % postcode<EOL><DEDENT>return postcode<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT> | :example '4703' | f14014:c0:m3 |
def secondary_address(self): | return self.numerify(self.random_element(self.secondary_address_formats))<EOL> | :example 'բն. 49' | f14014:c0:m4 |
def state(self): | return self.random_element(self.states)<EOL> | :example 'Կոտայք' | f14014:c0:m5 |
def state_abbr(self): | return self.random_element(self.states_abbr)<EOL> | :example 'ՎՁ' | f14014:c0:m6 |
def street(self): | return self.random_element(self.streets)<EOL> | :example 'Ոսկերիչների' | f14014:c0:m7 |
def street_prefix(self): | return self.random_element(self.street_prefixes)<EOL> | :example 'փողոց' | f14014:c0:m8 |
def village(self): | return self.random_element(self.villages)<EOL> | :example 'Ոսկեվազ' | f14014:c0:m9 |
def village_prefix(self): | return self.random_element(self.village_prefixes)<EOL> | :example 'գ.' | f14014:c0:m10 |
def prefecture(self): | return self.random_element(self.prefectures)<EOL> | :example '東京都' | f14015:c0:m0 |
def city(self): | return self.random_element(self.cities)<EOL> | :example '台東区' | f14015:c0:m1 |
def town(self): | return self.random_element(self.towns)<EOL> | :example '浅草' | f14015:c0:m2 |
def chome(self): | return "<STR_LIT>" % self.generator.random.randint(<NUM_LIT:1>, <NUM_LIT>)<EOL> | :example '1丁目' | f14015:c0:m3 |
def ban(self): | return "<STR_LIT>" % self.generator.random.randint(<NUM_LIT:1>, <NUM_LIT>)<EOL> | :example '3番' | f14015:c0:m4 |
def gou(self): | return "<STR_LIT>" % self.generator.random.randint(<NUM_LIT:1>, <NUM_LIT:20>)<EOL> | :example '10号' | f14015:c0:m5 |
def building_name(self): | return self.random_element(self.building_names)<EOL> | :example 'コーポ芝浦' | f14015:c0:m6 |
def postcode(self): | return "<STR_LIT>" % (self.generator.random.randint(<NUM_LIT:0>, <NUM_LIT>),<EOL>self.generator.random.randint(<NUM_LIT:0>, <NUM_LIT>))<EOL> | :example '101-1212' | f14015:c0:m7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.