[question] How to get conanfile (conanfile-attributes) from dependencies

[dp-fun]

What is your question?

We are using:
deps = conanfile.dependencies.filter({"build": False, "visible": True,"direct": True})
for key in deps.values():

for the resulting key there are different members:
key.ref , key.options

but there is no possibility to access other attributes from the conanfile like:
dep_version_in_name = getattr(key.ref, "version_in_packagename", False)

is there any way to achieve this?
or is there any way to get the complete conanfile from a dependency?

I know that I could put the Information into the options of the dependency but as we migrated from conan1 it would be nice to get an other way to get the complete conanfile of the dependency (in conan1 this was possible)

Have you read the CONTRIBUTING guide?

• I've read the CONTRIBUTING guide

[memsharded]

Hi @dp-fun

Thanks for your question.

but there is no possibility to access other attributes from the conanfile like:
dep_version_in_name = getattr(key.ref, "version_in_packagename", False)

is there any way to achieve this?
or is there any way to get the complete conanfile from a dependency?

No, there is no way to access arbitrary attributes from dependencies recipes. There is a specific interface to isolate the dependencies and not allowing that.
This is done because such direct access to dependencies would be an uncontrolled, unbounded information mechanism that in our experience creates tangled code, difficult to understand, debug and maintain.

Conan has several information mechanisms to propagated information depending on what is your use case, like the conf mechanism, the cpp_info properties, the environment information, etc.

If you can clarify what problem you are trying to solve, that would help to understand the use case and what could be the recommended way to approach it.

[dp-fun]

Thank you for your response.
Our use case is the following:

We are using a hook to create debian-packages out of the information of conan-packages.
In the conanfile we hold information such:
.
minver_tagprefix = 'v'
minver_prerelease = ''
debianize_options = {"version_in_packagename": True }
debianize_output_path = "deploy"

BaseClass

python_requires = "conanbase/[>=0.1 <2]"
python_requires_extend = "conanbase.Base"
.

In our hook we use the following:
.
default_output_path=""
output_path=getattr(conanfile, "debianize_output_path",default_output_path)
package_options=getattr(conanfile, "debianize_options", {})
if "create_dev_package" not in package_options:
package_options["create_dev_package"] = False
if "version_in_packagename" not in package_options:
package_options["version_in_packagename"] = False
.
def find_dependencies(conanfile, package_prefix="conan-"):
dep_list = []
deps = conanfile.dependencies.filter({"build": False, "visible": True,"direct": True})
for key in deps.values():
key.ref.name # example
key.options.shared # example

and at this point we cannot get the "package_options" which are defined in the conanfile of the dependencies.

What would be the conan way to achieve this?

[memsharded]

I am afraid the context is not fully clear

• What hook are you using? Hooks are pre/post recipe methods. They don't look a good approach to create debian installers, that would be more the work of a deployer?
• How is the python-requires base class connected? It seems not relevant to the use case we are checking
• Why not putting structured information in the conandata.yml, which has access, is automatically serialized (like the --format=json) etc?

Quick hint:

• If you put your code within triple backticks, and in the first line you include the language, such "```python", then the code will be rendered properly in the Github comments

[dp-fun]

Here now the question more precise for our needs:

Question: Accessing Dependency Configuration in find_dependencies()

Context

In the find_dependencies() method, we need to determine whether a dependency should have its version appended to the package name in the generated Debian package.

Current working Implementation

dep_version_in_name = key.options.get_safe("version_in_packagename", default=False)
if dep_version_in_name:
    name = name + "-" + version

### Alternatives :
# a) Certain packages always get version in name
if name in ["boost", "qt"]:
    dep_version_in_name = True

# b) Dependency must define this as a conan option
class MyConan(ConanFile):
    options = {"version_in_packagename": [True, False]}

# c) Use conandata.yml 
if hasattr(key, 'conan_data') and key.conan_data["version_in_packagename"] == True:
    dep_version_in_name = True

As you mentioned the preferred way would be to use conandata.yml?

[memsharded]

As you mentioned the preferred way would be to use conandata.yml?

Not sure, why would you be reading the conan_data that way to define a python variable?
Where is that python variable, is that recipe code or hooks code?

It is still not very clear the usage of hooks here, what hooks and how they work.
In general to create a Debian package it is necessary to extract the artifacts, so a custom deployer like the one in https://docs.conan.io/2/examples/extensions/deployers/sources/custom_deployer_sources.html is better.

Then, if the information you want is in the conandata, the deployer can directly read it:

def deploy(graph, output_folder, **kwargs):
      conanfile = graph.root.conanfile
      for r, d in conanfile.dependencies.items():
            d.conan_data["myinfo"]  # do whatever you want with it

No need for the recipe code to even be aware of it or use it at all.
Plus the deployer already takes charge of copying the necessary artifacts to the place where the .deb will be created.

[memsharded]

Hi @dp-fun

Any question or issue about the last comment? Thanks for the feedback!