I have an asset that makes multiple assets. I have to make it a graph?

i think you can do asset one separately, so that it serves as an input to the downstream ones

@asset
def my_upstream_asset():
    return [1,2,3]

@multi_asset(...) # however that works
def my_multi_downstream_asset(my_upstream_asset):
    downstream_one = my_upstream_asset + [3,4,5]
    downstream_two = my_upstream_asset + [6,7,8]
    return downstream_one, downstream_two

oh gotcha! ok thanks

i'd say that, in the "old world" that focused on building DAGs, the "graph" is a useful way to make highly reusable jobs. (step 1 then step 2 then step 3.) in the assets world, graphs are probably a bit unnecessary from a user perspective, and perhaps even an anti-pattern, because it makes you think about the process rather than the product of the process. (although dagster uses graphs under the hood to chain assets together.)

One reason why you would use a graph-backed asset is to reuse existing ops. Another reason would be that you want to use intermediate outputs from ops without having to bind those outputs to assets.

Thanks for the explanation. How does a graph-backed asset let you reuse an existing op, though? You just mean if you wrote it as an op before already?

@Yang Yes, that's right--if you have an existing op that does some complex computation, you can include that op as part of a graph-backed asset

oh ok gotcha, thanks

Yes, that's right. Dagster will assume that the parameter name is the asset key of the upstream asset. If you want to be more explicit about this, you could also define an explicit dependency: https://docs.dagster.io/concepts/assets/software-defined-assets#defining-explicit-dependencies

ok great I'm a bit confused by this example, though

# If it has multiple segments, you can provide a list:
@asset(ins={"upstream": AssetIn(key=["some_db_schema", "upstream_asset"])})
def another_downstream_asset(upstream):
    return upstream + [10]

what does the upstream asset look like in this case?

@asset(???)
def upstream_asset():
    return [1, 2, 3]

thanks

In this case, the upstream asset would contain a key prefix:

@asset(key_prefix=['some_db_schema'])
def upstream_asset():
    return [1, 2, 3]


@asset(ins={"upstream": AssetIn(key=["some_db_schema", "upstream_asset"])})
def another_downstream_asset(upstream):
    return upstream + [10]