feat: multi-input multi-resource type operators

[michael-johnston]

This PR introduces multi-input multi-resource type operators. It also enforces passing of operator parameters by instances of the operator parameter model (answers #647) e.g.

def operator_function(my_param_one: OperatorInputType, 
                 another_resource_param: OperatorInputType, 
                 operationInfo: FunctionOperationInfo=None, 
                 parameters:GenericOperatorParameters= GenericOperatorParameters())
  ...

Note: Here we use OperatorInputType to denote the allowed input types e.g. DiscoverySpace (see more below) and GenericOperatorParameters as a placeholder for the specific parameter model of the operator

Prior to this PR operators could only work on a single input resource, which had to be of type DiscoverySpace and named discoverySpace. Further the parameters for the operator were passed as keyword args i.e.

operator_fn(discoverySpace:DiscoverySpace, operationInfo:FunctionOperationInfo=None, **kwargs)

Operator Input Types

ADO resources that can be operated on are now associated with a "rich" type that will be passed to the operator. In the PR we have two resources that can be operated on

• DiscoverySpaceResource -> DiscoverySpace (rich type) <- As it is now
• DataContainerResource -> DataContainerResource (rich type) <- New resource type and associated rich type

Note: Its a particular property of DataContainerResource that it can be its own rich type.

Setting inputs in operation.yaml

The PR removes the DiscoveryOperationConfiguration spaces field and introduce the more general input field.

before

spaces:  # A list of resource ids
    - space_id_one
    - space_id_two # Note: technically you could have more than one id, but nothing could use it

now, for an operator with two DiscoverySpace input params called space_one and space_two

inputs: 
    space_one: 
          identifier: space_id_one
          kind: DiscoverySpace
    space_two:
          identifier: space_id_two
           kind: DiscoverySpace

In practice kind can be inferred when the YAML is read so users can omit it

Non-breaking changes

• The spaces field is kept as a computed field, so any code relying on querying it in metastore does not need to be changed
• All older operation resources are updated to have the new input field if read. Not breaking
• All existing operators resource parameters i.e. discoverySpace: DiscoverySpace, is supported out-of-box. No change needed

Breaking changes

• The parameters field of all operators has been updated to be an instance of the operator class not keyword args. Old operators (pre this change) cannot be used with this change. Scripts or operators calling operator functions directly also must be updated.

Code Changes

The code changes fall into three groups:

1. Updates to allow operators to have multiple resource inputs of multiple types and for operations to store them (new input field, models for that field, validators are parsers for operator signature etc.)
2. Updates in orchestration flow to handle multiple inputs (instead of just looking for spaces[0[), including storing relationships, and handling cases where rich type does provide access to the metastore
3. Updates due to change to use Operators parameter class and introduction of GenerericOperatorConfiguration (changing signatures, changing plugin versions etc).