rook.director package

Submodules

rook.director.alignment module

class rook.director.alignment.SubsetAlignmentChecker(input_files, inputs)

Bases: object

rook.director.director module

rook.director.director.execute_planned_request(collection, inputs, runner)

Plan a request, execute it when needed, and translate WPS errors.

rook.director.director.wrap_director(collection, inputs, runner)

Compatibility alias for callers not yet moved to planner naming.

rook.director.execution module

Execute request plans and adapt their outputs.

class rook.director.execution.RequestResult(plan: object, output_uris: list[str])

Bases: object

Result values produced by planning and executing a request.

property dataset_sources

Return the dataset sources prepared for operation execution.

property original_file_urls

Return original files selected by the request plan.

output_uris: list[str]

plan: object

property project

Return the project resolved for the request.

property search_result

Return the catalog search result, when catalog lookup was used.

property use_original_files

Return whether processing was skipped.

rook.director.execution.collect_original_file_uris(original_file_urls)

Return original file URIs in the same shape as operation outputs.

rook.director.execution.execute_plan(plan, inputs, runner)

Return output URIs for a planned request.

rook.director.execution.execute_request(collection, inputs, runner)

Plan and execute a request.

rook.director.execution.prepare_operation_inputs(plan, inputs)

Return cleaned operation inputs without mutating caller inputs.

rook.director.execution.run_operation(plan, inputs, runner)

Run an operation with inputs prepared from a request plan.

rook.director.planning module

Plan requests before operation execution.

class rook.director.planning.CatalogCollection(collection: list[str], project: str)

Bases: object

A request source that should be resolved through a project catalog.

collection: list[str]

project: str

class rook.director.planning.DirectDataset(collection: list[str], project: str)

Bases: object

A request source that should be processed directly without catalog lookup.

collection: list[str]

project: str

class rook.director.planning.InvalidRequest(message: str)

Bases: object

Decision value reserved for explicit invalid-request outcomes.

message: str

class rook.director.planning.ReturnOriginalFiles(project: str, search_result: object | None = None, original_file_urls: OrderedDict | None = None)

Bases: object

Decision to return catalog file URLs without running an operation.

property dataset_sources

Return no prepared operation sources for original-file responses.

original_file_urls: OrderedDict | None = None

project: str

property returns_original_files

Return whether this request should bypass processing.

search_result: object | None = None

class rook.director.planning.RunOperation(project: str, search_result: object | None = None, dataset_sources: tuple[DatasetSource, ...] = ())

Bases: object

Decision to run an operation on the requested or prepared sources.

dataset_sources: tuple[DatasetSource, ...] = ()

property original_file_urls

Return no original file URLs for operation responses.

project: str

property returns_original_files

Return whether this request should bypass processing.

search_result: object | None = None

class rook.director.planning.WorkflowFiles(files: list[str])

Bases: object

Files produced by an earlier workflow step.

files: list[str]

rook.director.planning.aligned_original_file_urls(search_result, inputs)

Return aligned original file URLs, or None when processing is required.

rook.director.planning.aligned_subset_plan(project, search_result, inputs)

Return an original-file plan when subset bounds align with files.

rook.director.planning.catalog_for(project)

Return the project catalog or raise an invalid-collection error.

rook.director.planning.classify_request_source(collection)

Return the request source represented by a collection argument.

rook.director.planning.dataset_sources_from_search(search_result)

Return normalized sources for catalog-resolved operation inputs.

rook.director.planning.has_processing_required_input(inputs)

Return whether current request parameters imply changed output data.

This preserves the existing operation detection rule while keeping the hard-coded parameter names out of the main planning flow.

rook.director.planning.may_return_original_files(project, inputs)

Return whether catalog data may be returned without processing.

rook.director.planning.operation_plan(project, search_result)

Return a plan that runs operation execution.

rook.director.planning.original_files_plan(project, search_result, original_file_urls=None)

Return a plan that bypasses operation execution.

rook.director.planning.plan_catalog_collection(source, inputs)

Return the decision for a catalog collection request.

rook.director.planning.plan_request(collection, inputs)

Return the decision for a request.

rook.director.planning.project_returns_original_files(project)

Return whether a project currently bypasses processing by policy.

rook.director.planning.requests_original_files(inputs)

Return whether the caller explicitly requested original files.

rook.director.planning.requires_processing(inputs)

Return whether the requested operation changes data and must run.

rook.director.planning.resolve_catalog_search(project, collection, inputs)

Resolve a catalog search result and validate all requested collections.

rook.director.planning.resolve_project(collection)

Return the project for the first collection entry.

rook.director.planning.uses_catalog(project)

Return whether requests for a project should use catalog lookup.

rook.director.planning.validate_search_result(search_result, collection)

Raise when the catalog did not match every requested collection.