How to have required_resource_keys for new Pythonic resources?

[vladidobro]

Using the legacy resource system, you could specify required resource keys as arguments:
@resource(required_resource_keys=...

How to accomplish the similar thing using Pythonic resources? If i follow the guide
class MyResource(ConfigurableResource): a: SomeOtherResource
I have to specify the resource when instantiating the class, i would like to have it automatically loaded by the resource key.
Is there any way to do this?

[jamiedemaria]

Can you explain "automatically loaded by the resource key"? What behavior where you seeing before? In the old resource system, you still needed to instantiate the depended resource, so I want to make sure I'm correctly addressing your issue.

If you have a resource that needs to be a top-level resource and used as a resource dependency for another resource, you would do something like this:

from dagster import Definitions, ConfigurableResource

class CredentialsResource(ConfigurableResource):
    username: str
    password: str

class FileStoreBucket(ConfigurableResource):
    credentials: CredentialsResource
    region: str

    def write(self, data: str):
        get_filestore_client(
            username=self.credentials.username,
            password=self.credentials.password,
            region=self.region,
        ).write(data)

credentials_resource = CredentialsResource(username="my_user", password="my_password")
            

defs = Definitions(
    assets=[my_asset],
    resources={
        "bucket": FileStoreBucket(
            credentials=credentials_resource
            region="us-east-1",
        ),
      "credentials": credentails_resource
    },
)

[DruidNx]

Hi @jamiedemaria , I guess OP's question (and also mine) is how do I access the already instantiated e.g. credentails_resource resource in an @op or an @asset pythonically. Could you please complete the example above with an example ?

[vladidobro]

Hi, I apologize for the late reply.

My question was about the difference in how the resource dependencies are specified. In the legacy resource system, you were specifying resource keys, i.e. 'unresolved' resources. The resolved resource is known only after plugging my resource into Definitions, dagster then searches the other resources in the Definitions object to find the one with the correct key, and then injects it as a dependency to my resource.
This means that one instantiated resource could be used in multiple Definitions objects, with the dependency supplied by each of them. Ultimately, it means that the resource can be instantiated in a separate module, like this

# resources.py
@resource(required_resource_keys={'credential'})
def connection(): ...

# repo1.py
defs = Definitions(resources={'credential': Credential(user='user1'), 'connection': connection})

# repo2.py
defs = Definitions(resources={'credential': Credential(user='user2'), 'connection': connection})

I believe this is not possible in the new system, because when the pythonic resources are instantiated, they must be already provided the 'resolved' resource dependencies, not mere resource keys.

In any case, this was a pattern that I was using, but abandoned since asking the question, so feel free to disregard it.

Thank you.

As for @DruidNx 's question, I believe the answer is written here https://docs.dagster.io/concepts/resources#with-asset-definitions

[DruidNx]

Thanks! Thats exactly what I was looking for. BTW, are you using the same pattern or something else?

[vladidobro]

We decided it is not really needed since moving to pythonic resources, so we just use the standard way that jamiedemaria is describing.