> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/nemo/datadesigner/llms.txt.
> For full documentation content, see https://docs.nvidia.com/nemo/datadesigner/llms-full.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/nemo/datadesigner/_mcp/server.

# data\_designer.config.sampler\_params

## Module Contents

### Classes

| Name                                                                                               | Description                                                                           |
| -------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------- |
| [`SamplerType`](#data_designerconfigsampler_paramssamplertype)                                     | str(object='') -> str str(bytes\_or\_buffer\[, encoding\[, errors]]) -> str           |
| [`CategorySamplerParams`](#data_designerconfigsampler_paramscategorysamplerparams)                 | Parameters for categorical sampling with optional probability weighting.              |
| [`DatetimeSamplerParams`](#data_designerconfigsampler_paramsdatetimesamplerparams)                 | Parameters for uniform datetime sampling within a specified range.                    |
| [`SubcategorySamplerParams`](#data_designerconfigsampler_paramssubcategorysamplerparams)           | Parameters for subcategory sampling conditioned on a parent category column.          |
| [`TimeDeltaSamplerParams`](#data_designerconfigsampler_paramstimedeltasamplerparams)               | Parameters for sampling time deltas relative to a reference datetime column.          |
| [`UUIDSamplerParams`](#data_designerconfigsampler_paramsuuidsamplerparams)                         | Parameters for generating UUID (Universally Unique Identifier) values.                |
| [`ScipySamplerParams`](#data_designerconfigsampler_paramsscipysamplerparams)                       | Parameters for sampling from any scipy.stats continuous or discrete distribution.     |
| [`BinomialSamplerParams`](#data_designerconfigsampler_paramsbinomialsamplerparams)                 | Parameters for sampling from a Binomial distribution.                                 |
| [`BernoulliSamplerParams`](#data_designerconfigsampler_paramsbernoullisamplerparams)               | Parameters for sampling from a Bernoulli distribution.                                |
| [`BernoulliMixtureSamplerParams`](#data_designerconfigsampler_paramsbernoullimixturesamplerparams) | Parameters for sampling from a Bernoulli mixture distribution.                        |
| [`GaussianSamplerParams`](#data_designerconfigsampler_paramsgaussiansamplerparams)                 | Parameters for sampling from a Gaussian (Normal) distribution.                        |
| [`PoissonSamplerParams`](#data_designerconfigsampler_paramspoissonsamplerparams)                   | Parameters for sampling from a Poisson distribution.                                  |
| [`UniformSamplerParams`](#data_designerconfigsampler_paramsuniformsamplerparams)                   | Parameters for sampling from a continuous Uniform distribution.                       |
| [`PersonSamplerParams`](#data_designerconfigsampler_paramspersonsamplerparams)                     | Parameters for sampling synthetic person data with demographic attributes.            |
| [`PersonFromFakerSamplerParams`](#data_designerconfigsampler_paramspersonfromfakersamplerparams)   | Parameters for sampling synthetic person data with demographic attributes from Faker. |

### Functions

| Name                                                                                       | Description |
| ------------------------------------------------------------------------------------------ | ----------- |
| [`is_numerical_sampler_type`](#data_designerconfigsampler_paramsis_numerical_sampler_type) | None        |

### Data

[`SexT`](#data_designerconfigsampler_paramssext)
[`SamplerParamsT`](#data_designerconfigsampler_paramssamplerparamst)

### API

```python
class data_designer.config.sampler_params.SamplerType
```

**Bases**: `str`, `enum.Enum`

```python
BERNOULLI = bernoulli
```

```python
BERNOULLI_MIXTURE = bernoulli_mixture
```

```python
BINOMIAL = binomial
```

```python
CATEGORY = category
```

```python
DATETIME = datetime
```

```python
GAUSSIAN = gaussian
```

```python
PERSON = person
```

```python
PERSON_FROM_FAKER = person_from_faker
```

```python
POISSON = poisson
```

```python
SCIPY = scipy
```

```python
SUBCATEGORY = subcategory
```

```python
TIMEDELTA = timedelta
```

```python
UNIFORM = uniform
```

```python
UUID = uuid
```

```python
class data_designer.config.sampler_params.CategorySamplerParams(
    /,
    **data: typing.Any
)
```

**Bases**: `data_designer.config.base.ConfigBase`

Parameters for categorical sampling with optional probability weighting.

Samples values from a discrete set of categories. When weights are provided, values are
sampled according to their assigned probabilities. Without weights, uniform sampling is used.

**Parameters:**

List of possible categorical values to sample from. Can contain strings, integers,
or floats. Must contain at least one value.

Optional unnormalized probability weights for each value. If provided, must be
the same length as `values`. Weights are automatically normalized to sum to 1.0.
Larger weights result in higher sampling probability for the corresponding value.

**Attributes:**

List of possible categorical values to sample from. Can contain strings, integers,
or floats. Must contain at least one value.

Optional unnormalized probability weights for each value. If provided, must be
the same length as `values`. Weights are automatically normalized to sum to 1.0.
Larger weights result in higher sampling probability for the corresponding value.

**Initialization:**

Create a new model by parsing and validating input data from keyword arguments.

Raises \[`ValidationError`]\[pydantic\_core.ValidationError] if the input data cannot be
validated to form a valid model.

`self` is explicitly positional-only to allow `self` as a field name.

```python
values: list[str | int | float] = Field(...)
```

```python
weights: list[float] | None = Field(...)
```

```python
sampler_type: typing.Literal[data_designer.config.sampler_params.SamplerType]
```

```python
_normalize_weights_if_needed() -> typing_extensions.Self
```

```python
_validate_equal_lengths() -> typing_extensions.Self
```

```python
class data_designer.config.sampler_params.DatetimeSamplerParams(
    /,
    **data: typing.Any
)
```

**Bases**: `data_designer.config.base.ConfigBase`

Parameters for uniform datetime sampling within a specified range.

Samples datetime values uniformly between a start and end date with a specified granularity.
The sampling unit determines the smallest possible time interval between consecutive samples.

**Parameters:**

Earliest possible datetime for the sampling range (inclusive). Must be a valid
datetime string parseable by pandas.to\_datetime().

Exclusive upper bound for the sampling range. Must be a valid
datetime string parseable by pandas.to\_datetime().

Time unit for sampling granularity. Options:

* "Y": Years
* "M": Months
* "D": Days (default)
* "h": Hours
* "m": Minutes
* "s": Seconds

**Attributes:**

Earliest possible datetime for the sampling range (inclusive). Must be a valid
datetime string parseable by pandas.to\_datetime().

Exclusive upper bound for the sampling range. Must be a valid
datetime string parseable by pandas.to\_datetime().

Time unit for sampling granularity. Options:

* "Y": Years
* "M": Months
* "D": Days (default)
* "h": Hours
* "m": Minutes
* "s": Seconds

**Initialization:**

Create a new model by parsing and validating input data from keyword arguments.

Raises \[`ValidationError`]\[pydantic\_core.ValidationError] if the input data cannot be
validated to form a valid model.

`self` is explicitly positional-only to allow `self` as a field name.

```python
start: str = Field(...)
```

```python
end: str = Field(...)
```

```python
unit: typing.Literal[Y, M, D, h, m, s] = Field(...)
```

```python
sampler_type: typing.Literal[data_designer.config.sampler_params.SamplerType]
```

```python
_validate_param_is_datetime(value: str) -> str
```

```python
class data_designer.config.sampler_params.SubcategorySamplerParams(
    /,
    **data: typing.Any
)
```

**Bases**: `data_designer.config.base.ConfigBase`

Parameters for subcategory sampling conditioned on a parent category column.

Samples subcategory values based on the value of a parent category column. Each parent
category value maps to its own list of possible subcategory values, enabling hierarchical
or conditional sampling patterns.

**Parameters:**

Name of the parent category column that this subcategory depends on.
The parent column must be generated before this subcategory column.

Mapping from each parent category value to a list of possible subcategory values.
Each key must correspond to a value that appears in the parent category column.

**Attributes:**

Name of the parent category column that this subcategory depends on.
The parent column must be generated before this subcategory column.

Mapping from each parent category value to a list of possible subcategory values.
Each key must correspond to a value that appears in the parent category column.

**Initialization:**

Create a new model by parsing and validating input data from keyword arguments.

Raises \[`ValidationError`]\[pydantic\_core.ValidationError] if the input data cannot be
validated to form a valid model.

`self` is explicitly positional-only to allow `self` as a field name.

```python
category: str = Field(...)
```

```python
values: dict[str, list[str | int | float]] = Field(...)
```

```python
sampler_type: typing.Literal[data_designer.config.sampler_params.SamplerType]
```

```python
class data_designer.config.sampler_params.TimeDeltaSamplerParams(
    /,
    **data: typing.Any
)
```

**Bases**: `data_designer.config.base.ConfigBase`

Parameters for sampling time deltas relative to a reference datetime column.

Samples time offsets within a specified range and adds them to values from a reference
datetime column. This is useful for generating related datetime columns like order dates
and delivery dates, or event start times and end times.

Years and months are not supported as timedelta units because they have variable lengths.
See: [pandas timedelta documentation](https://pandas.pydata.org/docs/user_guide/timedeltas.html)

**Parameters:**

Minimum time-delta value (inclusive). Must be non-negative and less than `dt_max`.
Specified in units defined by the `unit` parameter.

Maximum time-delta value (exclusive). Must be positive and greater than `dt_min`.
Specified in units defined by the `unit` parameter.

Name of an existing datetime column to add the time-delta to.
This column must be generated before the timedelta column.

Time unit for the delta values. Options:

* "D": Days (default)
* "h": Hours
* "m": Minutes
* "s": Seconds

**Attributes:**

Minimum time-delta value (inclusive). Must be non-negative and less than `dt_max`.
Specified in units defined by the `unit` parameter.

Maximum time-delta value (exclusive). Must be positive and greater than `dt_min`.
Specified in units defined by the `unit` parameter.

Name of an existing datetime column to add the time-delta to.
This column must be generated before the timedelta column.

Time unit for the delta values. Options:

* "D": Days (default)
* "h": Hours
* "m": Minutes
* "s": Seconds

**Initialization:**

Create a new model by parsing and validating input data from keyword arguments.

Raises \[`ValidationError`]\[pydantic\_core.ValidationError] if the input data cannot be
validated to form a valid model.

`self` is explicitly positional-only to allow `self` as a field name.

```python
dt_min: int = Field(...)
```

```python
dt_max: int = Field(...)
```

```python
reference_column_name: str = Field(...)
```

```python
unit: typing.Literal[D, h, m, s] = Field(...)
```

```python
sampler_type: typing.Literal[data_designer.config.sampler_params.SamplerType]
```

```python
_validate_min_less_than_max() -> typing_extensions.Self
```

```python
class data_designer.config.sampler_params.UUIDSamplerParams(
    /,
    **data: typing.Any
)
```

**Bases**: `data_designer.config.base.ConfigBase`

Parameters for generating UUID (Universally Unique Identifier) values.

Generates UUID4 (random) identifiers with optional formatting options. UUIDs are useful
for creating unique identifiers for records, entities, or transactions.

**Parameters:**

Optional string to prepend to each UUID. Useful for creating namespaced or
typed identifiers (e.g., "user-", "order-", "txn-").

If True, truncates UUIDs to 8 characters (first segment only). Default is False
for full 32-character UUIDs (excluding hyphens).

If True, converts all hexadecimal letters to uppercase. Default is False for
lowercase UUIDs.

**Attributes:**

Optional string to prepend to each UUID. Useful for creating namespaced or
typed identifiers (e.g., "user-", "order-", "txn-").

If True, truncates UUIDs to 8 characters (first segment only). Default is False
for full 32-character UUIDs (excluding hyphens).

If True, converts all hexadecimal letters to uppercase. Default is False for
lowercase UUIDs.

**Initialization:**

Create a new model by parsing and validating input data from keyword arguments.

Raises \[`ValidationError`]\[pydantic\_core.ValidationError] if the input data cannot be
validated to form a valid model.

`self` is explicitly positional-only to allow `self` as a field name.

```python
prefix: str | None = Field(...)
```

```python
short_form: bool = Field(...)
```

```python
uppercase: bool = Field(...)
```

```python
sampler_type: typing.Literal[data_designer.config.sampler_params.SamplerType]
```

```python
last_index: int
```

```python
class data_designer.config.sampler_params.ScipySamplerParams(
    /,
    **data: typing.Any
)
```

**Bases**: `data_designer.config.base.ConfigBase`

Parameters for sampling from any scipy.stats continuous or discrete distribution.

Provides a flexible interface to sample from the wide range of probability distributions
available in scipy.stats. This enables advanced statistical sampling beyond the built-in
distribution types (Gaussian, Uniform, etc.).

See: [scipy.stats documentation](https://docs.scipy.org/doc/scipy/reference/stats.html)

**Parameters:**

Name of the scipy.stats distribution to sample from (e.g., "beta", "gamma",
"lognorm", "expon"). Must be a valid distribution name from scipy.stats.

Dictionary of parameters for the specified distribution. Parameter names
and values must match the scipy.stats distribution specification (e.g., \{"a": 2, "b": 5}
for beta distribution, \{"scale": 1.5} for exponential).

Optional number of decimal places to round sampled values to. If None,
values are not rounded.

**Attributes:**

Name of the scipy.stats distribution to sample from (e.g., "beta", "gamma",
"lognorm", "expon"). Must be a valid distribution name from scipy.stats.

Dictionary of parameters for the specified distribution. Parameter names
and values must match the scipy.stats distribution specification (e.g., \{"a": 2, "b": 5}
for beta distribution, \{"scale": 1.5} for exponential).

Optional number of decimal places to round sampled values to. If None,
values are not rounded.

**Initialization:**

Create a new model by parsing and validating input data from keyword arguments.

Raises \[`ValidationError`]\[pydantic\_core.ValidationError] if the input data cannot be
validated to form a valid model.

`self` is explicitly positional-only to allow `self` as a field name.

```python
dist_name: str = Field(...)
```

```python
dist_params: dict = Field(...)
```

```python
decimal_places: int | None = Field(...)
```

```python
sampler_type: typing.Literal[data_designer.config.sampler_params.SamplerType]
```

```python
class data_designer.config.sampler_params.BinomialSamplerParams(
    /,
    **data: typing.Any
)
```

**Bases**: `data_designer.config.base.ConfigBase`

Parameters for sampling from a Binomial distribution.

Samples integer values representing the number of successes in a fixed number of independent
Bernoulli trials, each with the same probability of success. Commonly used to model the number
of successful outcomes in repeated experiments.

**Parameters:**

Number of independent trials. Must be a positive integer.

Probability of success on each trial. Must be between 0.0 and 1.0 (inclusive).

**Attributes:**

Number of independent trials. Must be a positive integer.

Probability of success on each trial. Must be between 0.0 and 1.0 (inclusive).

**Initialization:**

Create a new model by parsing and validating input data from keyword arguments.

Raises \[`ValidationError`]\[pydantic\_core.ValidationError] if the input data cannot be
validated to form a valid model.

`self` is explicitly positional-only to allow `self` as a field name.

```python
n: int = Field(...)
```

```python
p: float = Field(...)
```

```python
sampler_type: typing.Literal[data_designer.config.sampler_params.SamplerType]
```

```python
class data_designer.config.sampler_params.BernoulliSamplerParams(
    /,
    **data: typing.Any
)
```

**Bases**: `data_designer.config.base.ConfigBase`

Parameters for sampling from a Bernoulli distribution.

Samples binary values (0 or 1) representing the outcome of a single trial with a fixed
probability of success. This is the simplest discrete probability distribution, useful for
modeling binary outcomes like success/failure, yes/no, or true/false.

**Parameters:**

Probability of success (sampling 1). Must be between 0.0 and 1.0 (inclusive).
The probability of failure (sampling 0) is automatically 1 - p.

**Attributes:**

Probability of success (sampling 1). Must be between 0.0 and 1.0 (inclusive).
The probability of failure (sampling 0) is automatically 1 - p.

**Initialization:**

Create a new model by parsing and validating input data from keyword arguments.

Raises \[`ValidationError`]\[pydantic\_core.ValidationError] if the input data cannot be
validated to form a valid model.

`self` is explicitly positional-only to allow `self` as a field name.

```python
p: float = Field(...)
```

```python
sampler_type: typing.Literal[data_designer.config.sampler_params.SamplerType]
```

```python
class data_designer.config.sampler_params.BernoulliMixtureSamplerParams(
    /,
    **data: typing.Any
)
```

**Bases**: `data_designer.config.base.ConfigBase`

Parameters for sampling from a Bernoulli mixture distribution.

Combines a Bernoulli distribution with another continuous distribution, creating a mixture
where values are either 0 (with probability 1-p) or sampled from the specified distribution
(with probability p). This is useful for modeling scenarios with many zero values mixed with
a continuous distribution of non-zero values.

Common use cases include modeling sparse events, zero-inflated data, or situations where
an outcome either doesn't occur (0) or follows a specific distribution when it does occur.

**Parameters:**

Probability of sampling from the mixture distribution (non-zero outcome).
Must be between 0.0 and 1.0 (inclusive). With probability 1-p, the sample is 0.

Name of the scipy.stats distribution to sample from when outcome is non-zero.
Must be a valid scipy.stats distribution name (e.g., "norm", "gamma", "expon").

Parameters for the specified scipy.stats distribution.

**Attributes:**

Probability of sampling from the mixture distribution (non-zero outcome).
Must be between 0.0 and 1.0 (inclusive). With probability 1-p, the sample is 0.

Name of the scipy.stats distribution to sample from when outcome is non-zero.
Must be a valid scipy.stats distribution name (e.g., "norm", "gamma", "expon").

Parameters for the specified scipy.stats distribution.

**Initialization:**

Create a new model by parsing and validating input data from keyword arguments.

Raises \[`ValidationError`]\[pydantic\_core.ValidationError] if the input data cannot be
validated to form a valid model.

`self` is explicitly positional-only to allow `self` as a field name.

```python
p: float = Field(...)
```

```python
dist_name: str = Field(...)
```

```python
dist_params: dict = Field(...)
```

```python
sampler_type: typing.Literal[data_designer.config.sampler_params.SamplerType]
```

```python
class data_designer.config.sampler_params.GaussianSamplerParams(
    /,
    **data: typing.Any
)
```

**Bases**: `data_designer.config.base.ConfigBase`

Parameters for sampling from a Gaussian (Normal) distribution.

Samples continuous values from a normal distribution characterized by its mean and standard
deviation. The Gaussian distribution is one of the most commonly used probability distributions,
appearing naturally in many real-world phenomena due to the Central Limit Theorem.

**Parameters:**

Mean (center) of the Gaussian distribution. This is the expected value and the
location of the distribution's peak.

Standard deviation of the Gaussian distribution. Controls the spread or width
of the distribution. Must be positive.

Optional number of decimal places to round sampled values to. If None,
values are not rounded.

**Attributes:**

Mean (center) of the Gaussian distribution. This is the expected value and the
location of the distribution's peak.

Standard deviation of the Gaussian distribution. Controls the spread or width
of the distribution. Must be positive.

Optional number of decimal places to round sampled values to. If None,
values are not rounded.

**Initialization:**

Create a new model by parsing and validating input data from keyword arguments.

Raises \[`ValidationError`]\[pydantic\_core.ValidationError] if the input data cannot be
validated to form a valid model.

`self` is explicitly positional-only to allow `self` as a field name.

```python
mean: float = Field(...)
```

```python
stddev: float = Field(...)
```

```python
decimal_places: int | None = Field(...)
```

```python
sampler_type: typing.Literal[data_designer.config.sampler_params.SamplerType]
```

```python
class data_designer.config.sampler_params.PoissonSamplerParams(
    /,
    **data: typing.Any
)
```

**Bases**: `data_designer.config.base.ConfigBase`

Parameters for sampling from a Poisson distribution.

Samples non-negative integer values representing the number of events occurring in a fixed
interval of time or space. The Poisson distribution is commonly used to model count data
like the number of arrivals, occurrences, or events per time period.

The distribution is characterized by a single parameter (mean/rate), and both the mean and
variance equal this parameter value.

**Parameters:**

Mean number of events in the fixed interval (also called rate parameter λ).
Must be positive. This represents both the expected value and the variance of the
distribution.

**Attributes:**

Mean number of events in the fixed interval (also called rate parameter λ).
Must be positive. This represents both the expected value and the variance of the
distribution.

**Initialization:**

Create a new model by parsing and validating input data from keyword arguments.

Raises \[`ValidationError`]\[pydantic\_core.ValidationError] if the input data cannot be
validated to form a valid model.

`self` is explicitly positional-only to allow `self` as a field name.

```python
mean: float = Field(...)
```

```python
sampler_type: typing.Literal[data_designer.config.sampler_params.SamplerType]
```

```python
class data_designer.config.sampler_params.UniformSamplerParams(
    /,
    **data: typing.Any
)
```

**Bases**: `data_designer.config.base.ConfigBase`

Parameters for sampling from a continuous Uniform distribution.

Samples continuous values uniformly from a specified range, where every value in the range
has equal probability of being sampled. This is useful when all values within a range are
equally likely, such as random percentages, proportions, or unbiased measurements.

**Parameters:**

Lower bound of the uniform distribution (inclusive). Can be any real number.

Upper bound of the uniform distribution. Must be greater than `low`.

Optional number of decimal places to round sampled values to. If None,
values are not rounded and may have many decimal places.

**Attributes:**

Lower bound of the uniform distribution (inclusive). Can be any real number.

Upper bound of the uniform distribution. Must be greater than `low`.

Optional number of decimal places to round sampled values to. If None,
values are not rounded and may have many decimal places.

**Initialization:**

Create a new model by parsing and validating input data from keyword arguments.

Raises \[`ValidationError`]\[pydantic\_core.ValidationError] if the input data cannot be
validated to form a valid model.

`self` is explicitly positional-only to allow `self` as a field name.

```python
low: float = Field(...)
```

```python
high: float = Field(...)
```

```python
decimal_places: int | None = Field(...)
```

```python
sampler_type: typing.Literal[data_designer.config.sampler_params.SamplerType]
```

```python
class data_designer.config.sampler_params.PersonSamplerParams(
    /,
    **data: typing.Any
)
```

**Bases**: `data_designer.config.base.ConfigBase`

Parameters for sampling synthetic person data with demographic attributes.

Generates realistic synthetic person data including names, addresses, phone numbers, and other
demographic information from managed datasets. The sampler supports filtering by locale, sex, age,
geographic location, and selected managed-dataset fields, and can optionally include synthetic
persona descriptions. For Faker-generated person data, use PersonFromFakerSamplerParams.

**Parameters:**

Locale string determining the language and geographic region for synthetic people.
Must be a locale supported by a managed Nemotron Personas dataset. The dataset must
be downloaded and available in the managed assets directory.

If specified, filters to only sample people of the specified sex. Options: "Male" or
"Female". If None, samples both sexes.

If specified, filters to only sample people from the specified city or cities. Can be
a single city name (string) or a list of city names.

Two-element list \[min\_age, max\_age] specifying the age range to sample from
(inclusive). Defaults to a standard age range. Both values must be between minimum and
maximum allowed ages.

If True, appends additional synthetic persona columns including
personality traits, interests, and background descriptions. Only supported for certain
locales with managed datasets.

Optional field-value filters for managed datasets. Supported field
names are checked against the managed person data fields.

**Attributes:**

Locale string determining the language and geographic region for synthetic people.
Must be a locale supported by a managed Nemotron Personas dataset. The dataset must
be downloaded and available in the managed assets directory.

If specified, filters to only sample people of the specified sex. Options: "Male" or
"Female". If None, samples both sexes.

If specified, filters to only sample people from the specified city or cities. Can be
a single city name (string) or a list of city names.

Two-element list \[min\_age, max\_age] specifying the age range to sample from
(inclusive). Defaults to a standard age range. Both values must be between minimum and
maximum allowed ages.

If True, appends additional synthetic persona columns including
personality traits, interests, and background descriptions. Only supported for certain
locales with managed datasets.

Optional field-value filters for managed datasets. Supported field
names are checked against the managed person data fields.

**Initialization:**

Create a new model by parsing and validating input data from keyword arguments.

Raises \[`ValidationError`]\[pydantic\_core.ValidationError] if the input data cannot be
validated to form a valid model.

`self` is explicitly positional-only to allow `self` as a field name.

```python
locale: str = Field(...)
```

```python
sex: data_designer.config.sampler_params.SexT | None = Field(...)
```

```python
city: str | list[str] | None = Field(...)
```

```python
age_range: list[int] = Field(...)
```

```python
select_field_values: dict[str, list[str]] | None = Field(...)
```

```python
with_synthetic_personas: bool = Field(...)
```

```python
sampler_type: typing.Literal[data_designer.config.sampler_params.SamplerType]
```

```python
generator_kwargs: list[str]
```

Keyword arguments to pass to the person generator.

```python
people_gen_key: str
```

```python
_validate_age_range(value: list[int]) -> list[int]
```

```python
_validate_locale_with_managed_datasets() -> typing_extensions.Self
```

```python
class data_designer.config.sampler_params.PersonFromFakerSamplerParams(
    /,
    **data: typing.Any
)
```

**Bases**: `data_designer.config.base.ConfigBase`

Parameters for sampling synthetic person data with demographic attributes from Faker.

Uses the Faker library to generate random personal information. The data is basic and not demographically
accurate, but is useful for quick testing, prototyping, or when realistic demographic distributions are not
relevant for your use case. For demographically accurate person data, use the `PersonSamplerParams` sampler.

**Parameters:**

Locale string determining the language and geographic region for synthetic people.
Can be any locale supported by Faker.

If specified, filters to only sample people of the specified sex. Options: "Male" or
"Female". If None, samples both sexes.

If specified, filters to only sample people from the specified city or cities. Can be
a single city name (string) or a list of city names.

Two-element list \[min\_age, max\_age] specifying the age range to sample from
(inclusive). Defaults to a standard age range. Both values must be between the minimum and
maximum allowed ages.

Discriminator for the sampler type. Must be `SamplerType.PERSON_FROM_FAKER`.

**Attributes:**

Locale string determining the language and geographic region for synthetic people.
Can be any locale supported by Faker.

If specified, filters to only sample people of the specified sex. Options: "Male" or
"Female". If None, samples both sexes.

If specified, filters to only sample people from the specified city or cities. Can be
a single city name (string) or a list of city names.

Two-element list \[min\_age, max\_age] specifying the age range to sample from
(inclusive). Defaults to a standard age range. Both values must be between the minimum and
maximum allowed ages.

Discriminator for the sampler type. Must be `SamplerType.PERSON_FROM_FAKER`.

**Initialization:**

Create a new model by parsing and validating input data from keyword arguments.

Raises \[`ValidationError`]\[pydantic\_core.ValidationError] if the input data cannot be
validated to form a valid model.

`self` is explicitly positional-only to allow `self` as a field name.

```python
locale: str = Field(...)
```

```python
sex: data_designer.config.sampler_params.SexT | None = Field(...)
```

```python
city: str | list[str] | None = Field(...)
```

```python
age_range: list[int] = Field(...)
```

```python
sampler_type: typing.Literal[data_designer.config.sampler_params.SamplerType]
```

```python
generator_kwargs: list[str]
```

Keyword arguments to pass to the person generator.

```python
people_gen_key: str
```

```python
_validate_age_range(value: list[int]) -> list[int]
```

```python
_validate_locale(value: str) -> str
```

```python
data_designer.config.sampler_params.is_numerical_sampler_type(sampler_type: data_designer.config.sampler_params.SamplerType) -> bool
```