faker.providers.color
¶
Subpackages¶
faker.providers.color.ar_PS
faker.providers.color.az_AZ
faker.providers.color.bg_BG
faker.providers.color.bn_BD
faker.providers.color.da_DK
faker.providers.color.el_GR
faker.providers.color.en_US
faker.providers.color.es
faker.providers.color.es_CL
faker.providers.color.es_ES
faker.providers.color.fa_IR
faker.providers.color.fr_FR
faker.providers.color.he_IL
faker.providers.color.hr_HR
faker.providers.color.hu_HU
faker.providers.color.hy_AM
faker.providers.color.id_ID
faker.providers.color.pt_BR
faker.providers.color.ru_RU
faker.providers.color.sk_SK
faker.providers.color.th_TH
faker.providers.color.uk_UA
Submodules¶
Package Contents¶
Classes¶
Implement random color generation in a human-friendly way. |
|
Implement default color provider for Faker. |
Attributes¶
- faker.providers.color.HueType¶
- class faker.providers.color.BaseProvider(generator: Any)¶
- __provider__ = 'base'¶
- __use_weighting__ = False¶
- language_locale_codes¶
- random_int(min: int = 0, max: int = 9999, step: int = 1) int ¶
Generate a random integer between two integers
min
andmax
inclusive while observing the providedstep
value.This method is functionally equivalent to randomly sampling an integer from the sequence
range(min, max + 1, step)
.- Sample
min=0, max=15
- Sample
min=0, max=15, step=3
- random_digit_or_empty() Union[int, str] ¶
Generate a random digit (0 to 9) or an empty string.
This method will return an empty string 50% of the time, and each digit has a 1/20 chance of being generated.
- random_digit_not_null_or_empty() Union[int, str] ¶
Generate a random non-zero digit (1 to 9) or an empty string.
This method will return an empty string 50% of the time, and each digit has a 1/18 chance of being generated.
- random_number(digits: Optional[int] = None, fix_len: bool = False) int ¶
Generate a random integer according to the following rules:
If
digits
isNone
(default), its value will be set to a random integer from 1 to 9.If
fix_len
isFalse
(default), all integers that do not exceed the number ofdigits
can be generated.If
fix_len
isTrue
, only integers with the exact number ofdigits
can be generated.
- Sample
fix_len=False
- Sample
fix_len=True
- Sample
digits=3
- Sample
digits=3, fix_len=False
- Sample
digits=3, fix_len=True
- random_letters(length: int = 16) Sequence[str] ¶
Generate a list of random ASCII letters (a-z and A-Z) of the specified
length
.- Sample
length=10
- random_elements(elements: ElementsType[T] = ('a', 'b', 'c'), length: Optional[int] = None, unique: bool = False, use_weighting: Optional[bool] = None) Sequence[T] ¶
Generate a list of randomly sampled objects from
elements
.Set
unique
toFalse
for random sampling with replacement, and setunique
toTrue
for random sampling without replacement.If
length
is set toNone
or is omitted,length
will be set to a random integer from 1 to the size ofelements
.The value of
length
cannot be greater than the number of objects inelements
ifunique
is set toTrue
.The value of
elements
can be any sequence type (list
,tuple
,set
,string
, etc) or anOrderedDict
type. If it is the latter, the keys will be used as the objects for sampling, and the values will be used as weighted probabilities ifunique
is set toFalse
. For example:# Random sampling with replacement fake.random_elements( elements=OrderedDict([ ("variable_1", 0.5), # Generates "variable_1" 50% of the time ("variable_2", 0.2), # Generates "variable_2" 20% of the time ("variable_3", 0.2), # Generates "variable_3" 20% of the time ("variable_4": 0.1), # Generates "variable_4" 10% of the time ]), unique=False ) # Random sampling without replacement (defaults to uniform distribution) fake.random_elements( elements=OrderedDict([ ("variable_1", 0.5), ("variable_2", 0.2), ("variable_3", 0.2), ("variable_4": 0.1), ]), unique=True )
- Sample
elements=(‘a’, ‘b’, ‘c’, ‘d’), unique=False
- Sample
elements=(‘a’, ‘b’, ‘c’, ‘d’), unique=True
- Sample
elements=(‘a’, ‘b’, ‘c’, ‘d’), length=10, unique=False
- Sample
elements=(‘a’, ‘b’, ‘c’, ‘d’), length=4, unique=True
- Sample
- elements=OrderedDict([
(“a”, 0.45), (“b”, 0.35),
(“c”, 0.15), (“d”, 0.05),
]), length=20, unique=False
- Sample
- elements=OrderedDict([
(“a”, 0.45), (“b”, 0.35), (“c”, 0.15), (“d”, 0.05),
]), unique=True
- random_choices(elements: ElementsType[T] = ('a', 'b', 'c'), length: Optional[int] = None) Sequence[T] ¶
Generate a list of objects randomly sampled from
elements
with replacement.For information on the
elements
andlength
arguments, please refer torandom_elements()
which is used under the hood with theunique
argument explicitly set toFalse
.- Sample
elements=(‘a’, ‘b’, ‘c’, ‘d’)
- Sample
elements=(‘a’, ‘b’, ‘c’, ‘d’), length=10
- Sample
- elements=OrderedDict([
(“a”, 0.45), (“b”, 0.35), (“c”, 0.15), (“d”, 0.05),
])
- Sample
- elements=OrderedDict([
(“a”, 0.45), (“b”, 0.35), (“c”, 0.15), (“d”, 0.05),
]), length=20
- random_element(elements: ElementsType[T] = ('a', 'b', 'c')) T ¶
Generate a randomly sampled object from
elements
.For information on the
elements
argument, please refer torandom_elements()
which is used under the hood with theunique
argument set toFalse
and thelength
argument set to1
.- Sample
elements=(‘a’, ‘b’, ‘c’, ‘d’)
- Sample size=10
- elements=OrderedDict([
(“a”, 0.45), (“b”, 0.35), (“c”, 0.15), (“d”, 0.05),
])
- random_sample(elements: ElementsType[T] = ('a', 'b', 'c'), length: Optional[int] = None) Sequence[T] ¶
Generate a list of objects randomly sampled from
elements
without replacement.For information on the
elements
andlength
arguments, please refer torandom_elements()
which is used under the hood with theunique
argument explicitly set toTrue
.- Sample
elements=(‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’)
- Sample
elements=(‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’), length=3
- randomize_nb_elements(number: int = 10, le: bool = False, ge: bool = False, min: Optional[int] = None, max: Optional[int] = None) int ¶
Generate a random integer near
number
according to the following rules:If
le
isFalse
(default), allow generation up to 140% ofnumber
. IfTrue
, upper bound generation is capped at 100%.If
ge
isFalse
(default), allow generation down to 60% ofnumber
. IfTrue
, lower bound generation is capped at 100%.If a numerical value for
min
is provided, generated values less thanmin
will be clamped atmin
.If a numerical value for
max
is provided, generated values greater thanmax
will be clamped atmax
.If both
le
andge
areTrue
, the value ofnumber
will automatically be returned, regardless of the values supplied formin
andmax
.
- Sample
number=100
- Sample
number=100, ge=True
- Sample
number=100, ge=True, min=120
- Sample
number=100, le=True
- Sample
number=100, le=True, max=80
- Sample
number=79, le=True, ge=True, min=80
- numerify(text: str = '###') str ¶
Generate a string with each placeholder in
text
replaced according to the following rules:Number signs (‘#’) are replaced with a random digit (0 to 9).
Percent signs (‘%’) are replaced with a random non-zero digit (1 to 9).
Dollar signs (‘$’) are replaced with a random digit above two (2 to 9).
Exclamation marks (‘!’) are replaced with a random digit or an empty string.
At symbols (‘@’) are replaced with a random non-zero digit or an empty string.
Under the hood, this method uses
random_digit()
,random_digit_not_null()
,random_digit_or_empty()
, andrandom_digit_not_null_or_empty()
to generate the random values.- Sample
text=’Intel Core i%-%%##K vs AMD Ryzen % %%##X’
- Sample
text=’!!! !!@ !@! !@@ @!! @!@ @@! @@@’
- lexify(text: str = '????', letters: str = string.ascii_letters) str ¶
Generate a string with each question mark (‘?’) in
text
replaced with a random character fromletters
.By default,
letters
contains all ASCII letters, uppercase and lowercase.- Sample
text=’Random Identifier: ??????????’
- Sample
text=’Random Identifier: ??????????’, letters=’ABCDE’
- bothify(text: str = '## ??', letters: str = string.ascii_letters) str ¶
Generate a string with each placeholder in
text
replaced according to the following rules:Number signs (‘#’) are replaced with a random digit (0 to 9).
Question marks (‘?’) are replaced with a random character from
letters
.
By default,
letters
contains all ASCII letters, uppercase and lowercase.Under the hood, this method uses
numerify()
and andlexify()
to generate random values for number signs and question marks respectively.- Sample
letters=’ABCDE’
- Sample
text=’Product Number: ????-########’
- Sample
text=’Product Number: ????-########’, letters=’ABCDE’
- hexify(text: str = '^^^^', upper: bool = False) str ¶
Generate a string with each circumflex (‘^’) in
text
replaced with a random hexadecimal character.By default,
upper
is set to False. If set toTrue
, output will be formatted using uppercase hexadecimal characters.- Sample
text=’MAC Address: ^^:^^:^^:^^:^^:^^’
- Sample
text=’MAC Address: ^^:^^:^^:^^:^^:^^’, upper=True
- faker.providers.color.ElementsType¶
- class faker.providers.color.RandomColor(generator: Optional[faker.factory.Generator] = None, seed: Optional[Hashable] = None)¶
Implement random color generation in a human-friendly way.
This helper class encapsulates the internal implementation and logic of the
color()
method.- generate(hue: Optional[faker.typing.HueType] = None, luminosity: Optional[str] = None, color_format: ColorFormat = 'hex') str ¶
Generate and format a color.
Whenever
color()
is called, the arguments used are simply passed into this method, and this method handles the rest.
- generate_hsv(hue: Optional[faker.typing.HueType] = None, luminosity: Optional[str] = None) Tuple[int, int, int] ¶
Generate a HSV color tuple.
- generate_rgb(hue: Optional[faker.typing.HueType] = None, luminosity: Optional[str] = None) Tuple[int, int, int] ¶
Generate a RGB color tuple of integers.
- generate_rgb_float(hue: Optional[faker.typing.HueType] = None, luminosity: Optional[str] = None) Tuple[float, float, float] ¶
Generate a RGB color tuple of floats.
- generate_hsl(hue: Optional[faker.typing.HueType] = None, luminosity: Optional[str] = None) Tuple[int, int, int] ¶
Generate a HSL color tuple.
- pick_saturation(hue: int, hue_name: Optional[faker.typing.HueType], luminosity: Optional[str]) int ¶
Return a numerical saturation value.
- pick_brightness(h: int, s: int, luminosity: Optional[str]) int ¶
Return a numerical brightness value.
- set_format(hsv: Tuple[int, int, int], color_format: ColorFormat) str ¶
Handle conversion of HSV values into desired format.
- get_hue_range(color_input: Optional[faker.typing.HueType]) Tuple[int, int] ¶
Return the hue range for a given
color_input
.
- get_saturation_range(hue: int) Tuple[int, int] ¶
Return the saturation range for a given numerical
hue
value.
- get_color_info(hue: int) Dict[str, Sequence[Tuple[int, int]]] ¶
Return the color info for a given numerical
hue
value.
- classmethod hsv_to_rgb_float(hsv: Tuple[int, int, int]) Tuple[float, float, float] ¶
Convert HSV to RGB.
This method expects
hsv
to be a 3-tuple of H, S, and V values, and it will return a 3-tuple of the equivalent R, G, and B float values.
- faker.providers.color.localized = True¶
- class faker.providers.color.Provider(generator: Any)¶
Bases:
faker.providers.BaseProvider
Implement default color provider for Faker.
- safe_colors: faker.providers.ElementsType[str] = ('black', 'maroon', 'green', 'navy', 'olive', 'purple', 'teal', 'lime', 'blue', 'silver',...¶
- _random_color()¶
- color(hue: Optional[faker.typing.HueType] = None, luminosity: Optional[str] = None, color_format: str = 'hex') str ¶
Generate a color in a human-friendly way.
Under the hood, this method first creates a color represented in the HSV color model and then converts it to the desired
color_format
. The argumenthue
controls the H value according to the following rules:If the value is a number from
0
to360
, it will serve as the H value of the generated color.If the value is a tuple/list of 2 numbers from 0 to 360, the color’s H value will be randomly selected from that range.
If the value is a valid string, the color’s H value will be randomly selected from the H range corresponding to the supplied string. Valid values are
'monochrome'
,'red'
,'orange'
,'yellow'
,'green'
,'blue'
,'purple'
, and'pink'
.
The argument
luminosity
influences both S and V values and is partially affected byhue
as well. The finer details of this relationship are somewhat involved, so please refer to the source code instead if you wish to dig deeper. To keep the interface simple, this argument either can be omitted or can accept the following string values:'bright'
,'dark'
,'light'
, or'random'
.The argument
color_format
controls in which color model the color is represented. Valid values are'hsv'
,'hsl'
,'rgb'
, or'hex'
(default).- Sample
hue=’red’
- Sample
luminosity=’light’
- Sample
hue=(100, 200), color_format=’rgb’
- Sample
hue=’orange’, luminosity=’bright’
- Sample
hue=135, luminosity=’dark’, color_format=’hsv’
- Sample
hue=(300, 20), luminosity=’random’, color_format=’hsl’
- color_rgb(hue: Optional[faker.typing.HueType] = None, luminosity: Optional[str] = None) Tuple[int, int, int] ¶
Generate a RGB color tuple of integers in a human-friendly way.
- color_rgb_float(hue: Optional[faker.typing.HueType] = None, luminosity: Optional[str] = None) Tuple[float, float, float] ¶
Generate a RGB color tuple of floats in a human-friendly way.