def inner(fn: Callable[..., Any]) -> AssetsDefinition:
op_name = name or fn.__name__
asset_ins = build_asset_ins(fn, None, ins or {}, non_argument_deps)
asset_outs = build_asset_outs(op_name, outs, asset_ins,
internal_asset_deps or {})
op = _Op(
name=op_name,
description=description,
ins=asset_ins,
out=asset_outs,
required_resource_keys=required_resource_keys,
tags={"kind": compute_kind} if compute_kind else None,
)(fn)
return AssetsDefinition(
input_names_by_asset_key={
in_def.asset_key: input_name
for input_name, in_def in asset_ins.items()
},
output_names_by_asset_key={
out_def.asset_key: output_name
for output_name, out_def in asset_outs.items() # type: ignore
},
op=op,
)
def inner(fn: Callable[..., Any]) -> AssetsDefinition:
asset_name = name or fn.__name__
ins_by_input_names: Mapping[str, In] = build_asset_ins(
fn, None, ins or {}, non_argument_deps)
op = _Op(
name=asset_name,
description=description,
ins={
input_name: in_def
for input_name, in_def in ins_by_input_names.items()
}, # convert Mapping object to dict
out=outs,
required_resource_keys=required_resource_keys,
tags={"kind": compute_kind} if compute_kind else None,
)(fn)
return AssetsDefinition(
input_names_by_asset_key={
in_def.asset_key: input_name
for input_name, in_def in ins_by_input_names.items()
},
output_names_by_asset_key={
out.asset_key if isinstance(out.asset_key, AssetKey) else
AssetKey([name]): name
for name, out in outs.items()
},
op=op,
)
def __call__(self, fn: Callable) -> AssetsDefinition:
asset_name = self.name or fn.__name__
ins_by_input_names: Mapping[str, In] = build_asset_ins(
fn, self.namespace, self.ins or {}, self.non_argument_deps)
partition_fn: Optional[Callable] = None
if self.partitions_def:
def partition_fn(context): # pylint: disable=function-redefined
return [context.partition_key]
out_asset_key = AssetKey(
list(filter(None, [*(self.namespace or []), asset_name])))
out = Out(
asset_key=out_asset_key,
metadata=self.metadata or {},
io_manager_key=self.io_manager_key,
dagster_type=self.dagster_type,
asset_partitions_def=self.partitions_def,
asset_partitions=partition_fn,
)
op = _Op(
name=asset_name,
description=self.description,
ins={
input_name: in_def
for input_name, in_def in ins_by_input_names.items()
}, # convert Mapping object to dict
out=out,
required_resource_keys=self.required_resource_keys,
tags={"kind": self.compute_kind} if self.compute_kind else None,
config_schema={
"assets": {
"input_partitions": Field(dict, is_required=False),
"output_partitions": Field(dict, is_required=False),
}
},
)(fn)
return AssetsDefinition(
input_names_by_asset_key={
in_def.asset_key: input_name
for input_name, in_def in ins_by_input_names.items()
},
output_names_by_asset_key={out_asset_key: "result"},
op=op,
partitions_def=self.partitions_def,
partition_mappings={
ins_by_input_names[input_name].asset_key: partition_mapping
for input_name, partition_mapping in
self.partition_mappings.items()
} if self.partition_mappings else None,
)
def asset(fn):
asset_name = fn.__name__
ins: Dict[str, In] = {}
for input_param in get_function_params(fn):
input_param_name = input_param.name
asset_key = AssetKey(input_param_name)
ins[input_param_name] = In(asset_key=asset_key)
out = Out(asset_key=AssetKey(asset_name))
return _Op(
name=asset_name,
ins=ins,
out=out,
)(fn)