starlark: add APIs for Python resource data

We can now iterate resources in Python distributions and add
resources to PythonEmbeddedResources instances.

Author: indygreg

docs/config.rst

@@ -143,6 +143,12 @@ Examples:
 Returns a ``list`` of ``PythonSourceModule`` representing Python
 source modules present in this distribution.
 
+``PythonDistribution.resources_data()``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Returns a ``list`` of ``PythonResourceData`` representing resource files
+present in this distribution.
+
 ``default_python_distribution(build_target=None)``
 --------------------------------------------------
 
@@ -187,6 +193,21 @@ Each instance has the following attributes:
 ``is_package`` (bool)
    Whether the module is also a Python package (or sub-package).
 
+``PythonResourcesData``
+-----------------------
+
+This type represents Python resource data. Resource data is a named
+blob associated with a Python package. It is typically accessed using
+the ``importlib.resources`` API.
+
+Each instance has the following attributes:
+
+``package`` (string)
+   Python package this resource is associated with.
+
+``name`` (string)
+   Name of this resource.
+
 ``PythonEmbeddedResources()``
 -----------------------------
 
@@ -220,6 +241,16 @@ or ``2``.
 Only one level of bytecode can be registered per named module. If called
 multiple times for the same module, the last write wins.
 
+``PythonEmbeddedResources.add_resource_data(resource)``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+This method adds a ``PythonResourceData`` instance to the
+``PythonEmbeddedResources`` instance, making that resource available
+via in-memory access.
+
+If multiple resources sharing the same ``(package, name)`` pair are added,
+the last added one is used.
+
 .. _config_embedded_python_config:
 
 ``EmbeddedPythonConfig(...)```

pyoxidizer/src/starlark/python_distribution.rs

@@ -19,7 +19,7 @@ use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 
 use super::env::{optional_str_arg, required_str_arg};
-use super::python_resource::PythonSourceModule;
+use super::python_resource::{PythonResourceData, PythonSourceModule};
 use crate::app_packaging::environment::EnvironmentContext;
 use crate::py_packaging::distribution::{
     resolve_parsed_distribution, ParsedPythonDistribution, PythonDistributionLocation,
@@ -133,6 +133,20 @@ starlark_module! { python_distribution_module =>
         })))
     }
 
+    PythonDistribution.resources_data(env env, this) {
+        let context = env.get("CONTEXT").expect("CONTEXT not defined");
+
+        let logger = context.downcast_apply(|x: &EnvironmentContext| x.logger.clone());
+
+        Ok(Value::from(this.downcast_apply_mut(|dist: &mut PythonDistribution| {
+            dist.ensure_distribution_resolved(&logger);
+
+            dist.distribution.as_ref().unwrap().resources_data().iter().map(|data| {
+                Value::new(PythonResourceData { data: data.clone() })
+            }).collect_vec()
+        })))
+    }
+
     default_python_distribution(env env, build_target=None) {
         let build_target = match build_target.get_type() {
             "NoneType" => env.get("BUILD_TARGET").unwrap().to_string(),

pyoxidizer/src/starlark/python_resource.rs

@@ -17,7 +17,9 @@ use std::collections::HashMap;
 
 use super::env::required_type_arg;
 use crate::py_packaging::embedded_resource::EmbeddedPythonResourcesPrePackaged;
-use crate::py_packaging::resource::{BytecodeModule, BytecodeOptimizationLevel, SourceModule};
+use crate::py_packaging::resource::{
+    BytecodeModule, BytecodeOptimizationLevel, ResourceData, SourceModule,
+};
 
 #[derive(Debug, Clone)]
 pub struct PythonSourceModule {
@@ -150,6 +152,68 @@ impl TypedValue for PythonBytecodeModule {
     }
 }
 
+#[derive(Debug, Clone)]
+pub struct PythonResourceData {
+    pub data: ResourceData,
+}
+
+impl TypedValue for PythonResourceData {
+    immutable!();
+    any!();
+    not_supported!(
+        binop, dir_attr, function, get_hash, indexable, iterable, sequence, set_attr, to_int
+    );
+
+    fn to_str(&self) -> String {
+        format!(
+            "PythonResourceData<package={}, name={}>",
+            self.data.package, self.data.name
+        )
+    }
+
+    fn to_repr(&self) -> String {
+        self.to_str()
+    }
+
+    fn get_type(&self) -> &'static str {
+        "PythonResourceData"
+    }
+
+    fn to_bool(&self) -> bool {
+        true
+    }
+
+    fn compare(&self, other: &dyn TypedValue, _recursion: u32) -> Result<Ordering, ValueError> {
+        default_compare(self, other)
+    }
+
+    fn get_attr(&self, attribute: &str) -> ValueResult {
+        let v = match attribute {
+            "package" => Value::new(self.data.package.clone()),
+            "name" => Value::new(self.data.name.clone()),
+            // TODO expose raw data
+            attr => {
+                return Err(ValueError::OperationNotSupported {
+                    op: format!(".{}", attr),
+                    left: "PythonResourceData".to_string(),
+                    right: None,
+                })
+            }
+        };
+
+        Ok(v)
+    }
+
+    fn has_attr(&self, attribute: &str) -> Result<bool, ValueError> {
+        Ok(match attribute {
+            "package" => true,
+            "name" => true,
+            // TODO expose raw data
+            _ => false,
+        })
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct PythonEmbeddedResources {
     pub embedded: EmbeddedPythonResourcesPrePackaged,
@@ -236,4 +300,15 @@ starlark_module! { python_resource_env =>
 
         Ok(Value::new(None))
     }
+
+    PythonEmbeddedResources.add_resource_data(this, resource) {
+        required_type_arg("resource", "PythonResourceData", &resource)?;
+
+        this.downcast_apply_mut(|embedded: &mut PythonEmbeddedResources| {
+            let r = resource.downcast_apply(|r: &PythonResourceData| r.data.clone());
+            embedded.embedded.add_resource(&r);
+        });
+
+        Ok(Value::new(None))
+    }
 }