Runner

The Runner orchestrates an avatarization workflow: data upload, parameter configuration, job submission, status polling, and result retrieval. It encapsulates a configuration object (avatar_yaml.Config) that mirrors the YAML structure used by batch operations.

Responsibilities

• Collect and upload source (and optional avatar) tables (add_table)

• Advise or customize parameters (advise_parameters / set_parameters)

• Create links between tables (only needed for multitable) (add_link), or let the server advise them from the primary and foreign keys of each table (advise_links)

• Launch jobs individually or end-to-end (run and specialized methods)

• Download results (get_all_results and specialized methods)

Design notes

The Runner is stateful: it remembers tables, generated parameters, created jobs and download results. You usually create one per anonymization project (“set”) via manager.create_runner(set_name=...). Internally it delegates network calls to the shared authenticated ApiClient.

Minimal flow

runner = manager.create_runner("demo")
runner.add_table("wbcd", "fixtures/wbcd.csv")
runner.advise_parameters()         # optional
runner.set_parameters("wbcd", k=15)
runner.run()                       # runs the full pipeline
runner.get_all_results()          # downloads all results

Multitable flow with advised links

runner.add_table("doctor", doctors, primary_key="id")
runner.add_table("visit", visits, primary_key="visit_id", foreign_keys=["doctor_id"])
advice = runner.advise_links()     # adds the advised links to the config
for key in advice.unlinked_foreign_keys:
    print(key.table, key.field, key.candidate_tables)  # link these with add_link
runner.advise_parameters()

Detailed reference

class avatars.runner.Runner(api_client: SdkClient, display_name: str, *, seed: int | None = None, max_distribution_plots: int | None = None, output_format: Literal['csv', 'parquet'] | None = None, compute_figures: bool | None = None, pia_data_recipient: DataRecipient = DataRecipient.UNKNOWN, pia_data_type: DataType = DataType.UNKNOWN, pia_data_subject: DataSubject = DataSubject.UNKNOWN, pia_sensitivity_level: SensitivityLevel = SensitivityLevel.UNDEFINED, report_language: ReportLanguage = ReportLanguage.EN)

Bases: object

add_annotations(annotations: dict[str, str]) → None

Add metadata annotations to the config.

Parameters:

annotations – A dictionary of annotations to add to the metadata.

add_table(table_name: str, data: str | DataFrame | InputFile, *, primary_key: str | None = None, foreign_keys: list[str] | None = None, time_series_time: str | None = None, types: dict[str, ColumnType] | None = None, columns_to_drop: list[str] | None = None, individual_level: bool | None = None, avatar_data: str | DataFrame | InputFile | None = None) → None

Add a table to the config and upload the data in the server.

Parameters:

• table_name – The name of the table.

• data – The data to add to the table. Can be a path to a file, a pandas DataFrame, or a file already in your storage, as manager.list_input_files() lists them. A stored file is not uploaded again: its name is checked against the listing of your storage, and a name that is not there raises a ValueError before anything is uploaded. An upload is stored under the table name, <table_name>.parquet for a DataFrame or the extension of the path, and overwrites a file of that name already in your storage.

• primary_key – The primary key of the table.

• foreign_keys – Foreign keys of the table.

• time_series_time – name of the time column in the table (time series case).

• types – A dictionary of column types with the column name as the key and the type as the value.

• columns_to_drop – A list of column names to drop from the table before avatarization. These columns will not be included in the avatarization process and will be removed from the output avatar table.

• individual_level – A boolean as true if the table is at individual level or not. An individual level table is a table where each row corresponds to an individual (ex: patient, customer, etc.). Default behavior is True.

• avatar_data – The avatar table if there is one. Can be a path to a file, a pandas DataFrame or a file already in your storage.

advise_parameters(table_name: str | None = None) → None

Fill the parameters set with the server recommendation.

Parameters:

table_name – The name of the table. If None, all tables will be used.

advise_links(*, apply: bool = True) → TablesLinksAdvice

Advise the links between the tables, from the identifiers of each table.

Declare the primary key and the foreign keys of each table with add_table first. The server advises one parent table for each foreign key that no link covers yet. It chooses the links from the names of the tables and of their identifiers only, not from their values; the advice job still reads and checks each table, as every advice does.

Parameters:

apply – Add each advised link to the config with add_link. Set it to False to review the advice first, then add the links you keep yourself.

Returns:

links: the advised links, each with a confidence (high, medium or low). unlinked_foreign_keys: the foreign keys that the server could not link, each with the tables that can be its parent. Link them with add_link.

Return type:

TablesLinksAdvice

reference_tables_report(table_name: str | None = None) → dict[str, dict[str, Any]]

What the run’s reference tables found, by reference table name.

A subject declared on the wrong key column succeeds: every person gets an identity of their own in each table, and nothing fails. The numbers are how to tell – how many subjects each source contributed, how many were seen in one source only, how many disagreed.

Parameters:

table_name – The table the report is filed against. Omit it: the engine files one report per run, against one of its tables, and this finds it.

Returns:

• Reference table name -> subjects, sources (table, rows,

• subjects each), in_one_source_only, conflicting_subjects,

• conflicting_attributes and unresolved_rows. Counts only – no

• subject key or value. Empty for a run that declared no subjects.

Examples

>>> for name, outcome in runner.reference_tables_report().items():
...     print(name, outcome["subjects"], outcome["in_one_source_only"])

proposed_plan(database: str | None = None) → SchemaPlan

The plan schema discovery proposes, ready to review.

Parameters:

database – Which copy, for a run covering several. Omit for a single database.

Returns:

• A SchemaPlan whose proposals are all unreviewed – read

• proposals(), then confirm/reject your way through it.

Raises:

NotImplementedError – While schema discovery is not yet a job you can launch. The engine discovers and classifies; nothing runs it as a step, so there is no proposal to fetch. Until then, build a plan yourself:: plan = SchemaPlan().for_tables(“customer”, “order”) plan.pseudonymize(“customer”).purge(“audit_log”)

discover_schema() → None

Read the declared source and propose what to do with each table.

The first phase of a database run: discovery proposes a treatment per table and an action per column, and stops. Nothing is copied and nothing is anonymized – a person reads the proposal, corrects it, and only then is there a run. See proposed_plan().

Runs once. Asking for the plan again returns the proposal already fetched rather than reading the source a second time.

add_database(source: str, target: str, tables: list[str] | None = None, plan: SchemaPlan | None = None, shared_entities: list[SharedEntity] | None = None) → None

Copy a database to another, anonymized.

Parameters:

• source – Named connections your deployment holds. Ask your administrator which are available. They must be different, and the same engine – except that the target may be a SQLite file whatever the source is: the copy builds its tables there from the discovered schema.

• target – Named connections your deployment holds. Ask your administrator which are available. They must be different, and the same engine – except that the target may be a SQLite file whatever the source is: the copy builds its tables there from the discovered schema.

• tables – Which tables to copy. Omit for every table discovered.

• plan – What happens to each table and column, from proposed_plan() and reviewed with SchemaPlan. Without one the run is a plain copy and nothing is anonymized.

• shared_entities – What several tables share – people, products, configuration data – declared with avatars.shared_entity(), so each gets one replacement everywhere.

Notes

The target must already have the schema and hold no rows – nothing here creates or empties a database. Restore a schema-only dump into it first.

add_databases(copies: dict[str, tuple[str, str]] | None = None, plans: dict[str, SchemaPlan] | None = None, shared_entities: list[SharedEntity] | None = None) → None

Copy several databases together, sharing one identity per person.

Worth using for exactly one reason: the same people appear in more than one database, and a test estate where they are different people in each is useless. A single database wants add_database().

Parameters:

• copies –

  Name -> (source connection, target connection). The name is how a subject refers to that database:

  copies={"crm": ("crm_prod", "crm_test"),
          "billing": ("billing_prod", "billing_test")}
  

• plans – Name -> the reviewed plan for that database.

• shared_entities – Declared with avatars.shared_entity() using its across form, so each is resolved once across every database.

Notes

Every target is validated before any is written: a half-written estate cannot be completed by retrying the missing half, because the identities of the half that landed cannot be reproduced from a subset.

upload_file(table_name: str, data: str | DataFrame | InputFile, avatar_data: str | DataFrame | InputFile | None = None) → tuple[str, str | None]

Upload the data of a table to the server, and return the stored file names.

Parameters:

• table_name – The name of the table, which names the uploaded file. A file of that name already in your storage is overwritten.

• data – The data to upload. Can be a path to a file or a pandas DataFrame. A file already in your storage (an InputFile) is not uploaded: its own name is returned once the listing of your storage confirms it is there.

• avatar_data – The avatar table if there is one, of the same kinds.

Raises:

ValueError – A stored file named by data or avatar_data is not in your storage.

add_link(parent_table_name: str, parent_field: str, child_table_name: str, child_field: str, method: LinkMethod = LinkMethod.LINEAR_SUM_ASSIGNMENT) → None

Add a table link to the config.

Parameters:

• parent_table_name – The name of the parent table.

• child_table_name – The name of the child table.

• parent_field – The parent link key field (primary key) in the parent table.

• child_field – The child link key field (foreign key)in the child table.

• method – The method to use for linking the tables. Defaults to “linear_sum_assignment”.

set_parameters(table_name: str, *, k: int | None = None, ncp: int | None = None, use_categorical_reduction: bool | None = None, column_weights: dict[str, float] | None = None, exclude_variable_names: list[str] | None = None, exclude_replacement_strategy: ExcludeVariablesMethod | None = None, exclude_variable_method: ExcludeVariablesMethod | None = None, imputation_method: ImputeMethod | None = None, imputation_k: int | None = None, imputation_training_fraction: float | None = None, imputation_return_data_imputed: bool | None = None, open_dp_epsilon: float | None = None, fast_dp_epsilon: float | None = None, time_series_nf: int | None = None, time_series_projection_type: ProjectionType | None = None, time_series_nb_points: int | None = None, time_series_method: AlignmentMethod | None = None, time_series_unalignment: UnalignmentStrategy | None = None, known_variables: list[str] | None = None, target: str | None = None, quantile_threshold: int | None = None, data_augmentation_strategy: float | AugmentationStrategy | dict[str, float] | None = None, data_augmentation_target_column: str | None = None, data_augmentation_should_anonymize_original_table: bool | None = None, processors: list[AvatarizationProcessorParameters] | None = None, pseudonymized_columns: dict[str, FakeDataStrategy | HashSha256Strategy | Uuid4Strategy | ConstantStrategy | IntegerStrategy | SpecificIdStrategy] | None = None, use_excluded_variables_in_metrics: bool = False) → None

Set the parameters for a given table.

This will overwrite any existing parameters for the table, including parameters set using advise_parameter().

Parameters:

• table_name – The name of the table.

• k – Number of nearest neighbors to consider for KNN-based methods.

• ncp – Number of dimensions to consider for the KNN algorithm.

• use_categorical_reduction – Whether to transform categorical variables into a latent numerical space before projection.

• column_weights – Dictionary mapping column names to their respective weights, indicating the importance of each variable during the projection process.

• exclude_variable_names – List of variable names to exclude from the projection.

• exclude_replacement_strategy – DEPRECATED: use exclude_variable_method instead.

• exclude_variable_method – Strategy for replacing excluded variables. Options: ROW_ORDER, COORDINATE_SIMILARITY.

• imputation_method – Method for imputing missing values. Options: ImputeMethod.KNN, ImputeMethod.MODE, ImputeMethod.MEDIAN, ImputeMethod.MEAN, ImputeMethod.FAST_KNN.

• imputation_k – Number of neighbors to use for imputation if the method is KNN or FAST_KNN.

• imputation_training_fraction – Fraction of the dataset to use for training the imputation model when using KNN or FAST_KNN.

• imputation_return_data_imputed – Whether to return the data with imputed values.

• open_dp_epsilon – Epsilon value for differential privacy using OpenDP implementation.

• fast_dp_epsilon – Epsilon value for fastDP avatarization.

• time_series_nf – In time series context, number of degrees of freedom to retain in time series projections.

• time_series_projection_type – In time series context, type of projection for time series. Options: ProjectionType.FCPA (default) or ProjectionType.FLATTEN.

• time_series_method – In time series context, method for aligning series. Options: AlignmentMethod.SPECIFIED, AlignmentMethod.MAX, AlignmentMethod.MIN, AlignmentMethod.MEAN.

• time_series_nb_points – In time series context, number of points to generate for time series.

• time_series_unalignment – In time series context, how the avatar series come back from the aligned number of points. Options: UnalignmentStrategy.UNIFORM (default) gives each avatar series its own number of points, UnalignmentStrategy.SKIP keeps the aligned number of points for every avatar series.

• known_variables – List of known variables to be used for privacy metrics. These are variables that could be easily known by an attacker.

• target – Target variable to predict, used for signal metrics.

• quantile_threshold – Quantile threshold for privacy metrics calculations.

• data_augmentation_strategy – Strategy for data augmentation. Can be a float representing the augmentation ratio, an AugmentationStrategy enum, or a dictionary mapping modality to their respective augmentation ratios.

• data_augmentation_target_column – Target column for data augmentation when using a dictionary strategy or AugmentationStrategy.

• data_augmentation_should_anonymize_original_table – SENSITIVE: Whether to anonymize the original table during data augmentation. Default is True.

• processors –

  List of processor parameter objects (subclasses of AvatarizationProcessorParameters). Supports InterRecordRangeDifferenceParameters and RelativeDifferenceParameters. The order of the list determines the order in which processors are applied during preprocessing (and reversed during postprocessing).

  The transformations are transparent to the user - input and output have the same column structure at the end.

• pseudonymized_columns –

  A mapping of column name to a pseudonymization strategy object describing how to replace PII values in each column. Available strategy classes (importable from avatar_yaml):

  • FakeDataStrategy(pii_type=PiiType.EMAIL) — replace with realistic fake data of the specified PiiType (EMAIL, FIRST_NAME, LAST_NAME, FULL_NAME, PHONE, SSN, ADDRESS, FREE_TEXT). Pass consistent=False to generate a fresh value per row instead of mapping the same source value to the same fake value. Leave high_variability=False (default) to sample from a pre-generated pool for faster processing, or set high_variability=True to generate a unique value per row (slower but collision-free).

  • HashSha256Strategy() — replace with the SHA-256 hex digest (deterministic, irreversible).

  • Uuid4Strategy() — replace each unique value with a UUID v4. Pass consistent=False to generate a new UUID per row.

  • ConstantStrategy(value="REDACTED") — replace every value with a fixed string.

  • IntegerStrategy() — map each unique value to a unique pseudonymous integer. Pass consistent=False for an independent integer per row.

  • SpecificIdStrategy(pattern="EMP-####") — generate structured IDs from a pattern. Placeholders: # (digit), ? (letter), ^ (alphanumeric), {{col}} (value of another column). Control letter case with letter_case=SpecificIdLetterCase.UPPER/LOWER/BOTH.

  Only columns that should be pseudonymized need to be listed. Foreign key columns in child tables automatically inherit the pseudonymization mapping of the referenced parent primary key — no explicit configuration is needed on child FK columns.

• use_excluded_variables_in_metrics – When True, excluded variables are NOT passed to metrics parameters, allowing privacy and signal metrics to include them in calculations. When False (default), excluded variables are also excluded from metrics calculations.

update_parameters(table_name: str, **kwargs: Any) → None

Update specific parameters for the table while preserving other existing parameters. Only updates the parameters that are provided, keeping existing values for others.

Parameters:

• table_name – The name of the table.

• **kwargs – The parameters to update. Only parameters that are provided will be updated. See set_parameters for the full list of available parameters.

delete_parameters(table_name: str, parameters_names: list[str] | None = None) → None

Delete parameters from the config.

Parameters:

• table_name – The name of the table.

• parameters_names – The names of the parameters to delete. If None, all parameters will be deleted.

delete_link(parent_table_name: str, child_table_name: str) → None

Delete a link from the config.

Parameters:

• parent_table_name – The name of the parent table.

• child_table_name – The name of the child table.

delete_table(table_name: str) → None

Delete a table from the config.

Parameters:

table_name – The name of the table.

get_yaml(path: str | None = None) → str

Get the yaml config.

Parameters:

path – The path to the yaml file. If None, the default config will be returned.

Raises:

ValueError – When this run is several document sets – a database whose tables fall into more than one group of related tables. There is no single configuration to return; see cluster_yamls().

cluster_yamls(directory: str | None = None) → dict[str, str]

One complete configuration per group of related tables.

Each is an ordinary multi-table configuration – the same documents under the same names a multi-table run has always emitted – because the fan-out is one set per group rather than one set holding several schemas. Nothing about the shape today’s multi-table jobs rely on changes, and every job kind keeps working per group.

Empty for a run that is a single job, where get_yaml() is the answer.

Parameters:

directory – Write each one to <directory>/<group>.yaml as well as returning it.

run(jobs_to_run: list[JobKind] = [JobKind.standard, JobKind.signal_metrics, JobKind.privacy_metrics, JobKind.report], ignore_warnings: bool = False) → None

Run avatarization jobs.

This method creates resources and launches the specified jobs in the correct order. If this runner has existing results from a previous run, a UserWarning is emitted with the old set_name so you can recover previous results if needed. Local state is then cleared and a new run starts.

Parameters:

• jobs_to_run (list[JobKind]) – List of job types to run. Defaults to all jobs in execution order.

• ignore_warnings (bool) – Whether to ignore warnings about existing results when re-running a runner. Defaults to False.

Examples

>>> runner = manager.create_runner("my_dataset")
>>> runner.add_table("customers", data=df)
>>> runner.run()
>>>
>>> # Running again emits a UserWarning with the old set_name, then proceeds
>>> runner.run()

cluster_sets() → dict[str, str]

Group of related tables -> the resource set its run created.

Each group is its own set, so its results are read the way any other run’s are:

for cluster, set_name in runner.cluster_sets().items():
    manager.create_runner_from_id(set_name).get_all_results()

Empty until run() has been called, and for a run that is a single job – where runner.set_name is the answer.

clusters() → dict[str, list[str]]

The groups of related tables this run works on, one job per group.

Empty unless the run fanned out. A database whose tables all reference each other is one job, like any other run, and a plan reviewed down to one group is too.

The names identify the runs, and say what is in them: discovery names a group after the table the most links touch, so group-customer has its own document set (cluster_sets()) and its own jobs, reported by statuses() as group-customer/standard and so on.

statuses() → dict[str, JobStatus]

Where every job this runner launched has got to.

A run is several jobs – the anonymization, the metrics, the report, and for a document run the extraction and the write-back as well – and until now there was no way to ask about more than one at a time. So “did my run work?” meant calling get_status() once per kind and knowing which kinds to expect, and a job that failed while its siblings finished was easy to miss entirely.

Ordered the way the work happens rather than the way the jobs were registered: the dependent jobs are all created at once, so registration order says nothing, and a reader scanning for the first failure wants the sequence.

A database run covering several groups of related tables is several runs, one per group, and every one of their jobs is reported here – prefixed by the group, since each group has a job of each kind. See clusters() and cluster_sets().

Examples

>>> runner.statuses()
{'standard': 'finished', 'signal_metrics': 'error'}
>>> runner.statuses()  # a database with two groups of related tables
{'group-customer/standard': 'finished', 'group-audit_log/standard': 'pending'}

get_status(job_kind: JobKind | str | None = None, *, job_name: JobKind | str | None = None) → str

Get the status of a job.

Parameters:

• job_kind – The job to query. Accepts a JobKind enum value (e.g. JobKind.standard) or the equivalent string (e.g. "standard").

• job_name – Deprecated. Use job_kind instead.

Returns:

The job status string as returned by the server (e.g. "finished", "pending", "error").

Return type:

str

Examples

>>> runner.get_status(JobKind.standard)
'finished'
>>> runner.get_status("privacy_metrics")
'finished'

delete(job_names: JobKind | str | list[JobKind | str] | None = None) → BulkDeleteResponse

Delete one or more jobs launched by this runner.

When called without arguments, every job launched by this runner is deleted.

Parameters:

job_names – A single job kind/name, a list of job kinds/names, or None to delete all launched jobs.

Returns:

Response containing deleted and failed jobs.

Return type:

BulkDeleteResponse

Examples

>>> runner.delete()                                              # all jobs
>>> runner.delete(JobKind.standard)                             # single job
>>> runner.delete([JobKind.standard, JobKind.privacy_metrics])  # multiple jobs

cancel(job_names: JobKind | str | list[JobKind | str] | None = None) → list[JobResponse]

Stop one or more jobs launched by this runner.

When called without arguments, every job of this runner that is still going is cancelled. A job that has not started stops at once; a running one is asked to stop and does so at its next safe point – between stages, batches, tables or documents – so it comes back with its phase set to "cancelling" and turns "cancelled" shortly after. The jobs that were waiting on a cancelled job are cancelled with it.

A job that is already over is left alone rather than refused, so cancelling a whole run does not fail on the parts that finished – or on the dependents the first cancel already took with it.

Warning

A database copy cancelled while writing keeps the tables it had already written in the target: writes cannot be rolled back across tables. The cancelled job’s exception names them.

Parameters:

job_names – A single job kind/name, a list of job kinds/names, or None for every job this runner launched.

Returns:

The jobs a cancel was sent for, as the server answered.

Return type:

list[JobResponse]

Examples

>>> runner.cancel()                     # the whole run
>>> runner.cancel(JobKind.standard)     # one job, and what waits on it

get_specific_result_urls(job_name: str, result: Results = Results.SHUFFLED) → list[str]

get_specific_result(table_name: str, job_name: JobKind | str, result: Results = Results.SHUFFLED) → TypeResults

get_all_results() → ResultsOrganizer

Get all results.

Returns:

• dict – A dictionary with the results of each job on every table.

• Each job is a dictionary with the table name as key and the results as value.

• The results are a dictionary with the result name as key and the data as value.

• The data can be a pandas DataFrame or a dictionary depending on the result type.

download_report(path: str | None = None, report_type: ReportType = ReportType.BASIC) → None

Download the report.

Parameters:

path – The path to save the report. For a single report this is used as-is. When multiple PIA reports are returned (one per table), an index prefix is added to the filename only: dir/0_report.pdf, dir/1_report.pdf, etc.

print_parameters(table_name: str | None = None) → None

Print the parameters for a table.

Parameters:

table_name – The name of the table. If None, all parameters will be printed.

kill() → None

Method not implemented yet.

shuffled(table_name: str) → DataFrame

Get the shuffled data.

Parameters:

table_name – The name of the table to get the shuffled data from.

Returns:

The shuffled data as a pandas DataFrame.

Return type:

pd.DataFrame

sensitive_unshuffled(table_name: str) → DataFrame

Get the unshuffled data. This is sensitive data and should be used with caution.

Parameters:

table_name – The name of the table to get the unshuffled data from.

Returns:

The unshuffled data as a pandas DataFrame.

Return type:

pd.DataFrame

privacy_metrics(table_name: str) → list[dict[str, Any]]

Get the privacy metrics.

Parameters:

table_name – The name of the table to get the privacy metrics from.

Returns:

The privacy metrics as a list of dictionary.

Return type:

dict

signal_metrics(table_name: str) → list[dict[str, Any]]

Get the signal metrics.

Parameters:

table_name – The name of the table to get the signal metrics from.

Returns:

The signal metrics as a list of dictionary.

Return type:

dict

render_privacy_metrics_summary(open_in_browser: bool = False) → dict[str, Any]

Get the aggregated privacy metrics summary across tables.

Only available for multi-table jobs.

Parameters:

open_in_browser – Whether to save the summary to a file and open it in a browser. deprecated and will be removed in the future, as the summary is now returned as a dict instead of an HTML file

Returns:

A nested dict {table_name: {reference: meta_metric}}.

Return type:

dict

render_signal_metrics_summary() → dict[str, Any]

Get the aggregated signal metrics summary across tables.

Only available for multi-table jobs.

Returns:

A nested dict {table_name: {reference: meta_metric}}.

Return type:

dict

metrics_summary() → DataFrame

Get the combined privacy and signal metrics summary across tables as a DataFrame.

Only available for multi-table jobs.

Returns:

A DataFrame indexed by table_name with MultiIndex columns (reference, metric) where reference is the top level and metric is privacy or signal, combining both meta-metrics for each table/reference pair.

Return type:

pd.DataFrame

render_plot(table_name: str, plot_kind: PlotKind, open_in_browser: bool = False) → None

Render a plot for a given table. The different plot kinds are defined in the PlotKind enum.

Parameters:

• table_name – The name of the table to get the plot from.

• plot_kind – The kind of plot to render.

• open_in_browser – Whether to save the plot to a file and open it in a browser.

projections(table_name: str) → tuple[DataFrame, DataFrame]

Get the projections.

Parameters:

table_name – The name of the table to get the projections from.

Returns:

The projections as a pandas DataFrame.

Return type:

pd.DataFrame

table_summary(table_name: str) → DataFrame

Get the table summary.

Parameters:

table_name – The name of the table to get the summary from.

Returns:

The table summary as a dataframe.

Return type:

pd.DataFrame

from_yaml(yaml_path: str) → None

Load configuration from a YAML file.

This replaces the current runner’s configuration with the one from the file.

Note: Table data files are not automatically loaded. Use upload_file() to provide data before running jobs.

Parameters:

yaml_path (str) – The path to the YAML configuration file.