Python Components now implement the ComponentBatchLike interface (rer…

…un-io#6543)

### What
New blueprint APIs focus on overriding components rather than requiring
that things be Archetypes.

However, using mono components directly was somewhat inconvenient. This
lets you now pass in a component instance anywhere you would expect to
pass in a ComponentBatchLike.

This component knows it's own batch type and uses it to construct the
correct wrapper for a mono batch type.

This had the side effect that you can also do things now like:
```
rr.log("points", rr.Points3D(positions))
rr.log("points", [rr.components.Color([255, 0, 0])])
```

### Checklist
* [x] I have read and agree to [Contributor
Guide](https://github.com/rerun-io/rerun/blob/main/CONTRIBUTING.md) and
the [Code of
Conduct](https://github.com/rerun-io/rerun/blob/main/CODE_OF_CONDUCT.md)
* [x] I've included a screenshot or gif (if applicable)
* [x] I have tested the web demo (if applicable):
* Using examples from latest `main` build:
[rerun.io/viewer](https://rerun.io/viewer/pr/6543?manifest_url=https://app.rerun.io/version/main/examples_manifest.json)
* Using full set of examples from `nightly` build:
[rerun.io/viewer](https://rerun.io/viewer/pr/6543?manifest_url=https://app.rerun.io/version/nightly/examples_manifest.json)
* [x] The PR title and labels are set such as to maximize their
usefulness for the next release's CHANGELOG
* [x] If applicable, add a new check to the [release
checklist](https://github.com/rerun-io/rerun/blob/main/tests/python/release_checklist)!

- [PR Build Summary](https://build.rerun.io/pr/6543)
- [Recent benchmark results](https://build.rerun.io/graphs/crates.html)
- [Wasm size tracking](https://build.rerun.io/graphs/sizes.html)

To run all checks from `main`, comment on the PR with `@rerun-bot
full-check`.

crates/re_types_builder/src/codegen/python/mod.rs

@@ -390,7 +390,8 @@ impl PythonCodeGenerator {
                 Archetype,
                 BaseExtensionType,
                 BaseBatch,
-                ComponentBatchMixin
+                ComponentBatchMixin,
+                ComponentMixin,
             )
             from {rerun_path}_converters import (
                 int_or_none,
@@ -612,6 +613,10 @@ fn code_for_struct(
         ));
     }
 
+    if *kind == ObjectKind::Component {
+        superclasses.push("ComponentMixin".to_owned());
+    }
+
     if let Some(deprecation_notice) = obj.deprecation_notice() {
         code.push_unindented(format!(r#"@deprecated("""{deprecation_notice}""")"#), 1);
     }
@@ -634,6 +639,10 @@ fn code_for_struct(
 
     code.push_indented(1, quote_obj_docs(obj), 0);
 
+    if *kind == ObjectKind::Component {
+        code.push_indented(1, "_BATCH_TYPE = None", 1);
+    }
+
     if ext_class.has_init {
         code.push_indented(
             1,
@@ -775,7 +784,23 @@ fn code_for_struct(
 
     match kind {
         ObjectKind::Archetype => (),
-        ObjectKind::Datatype | ObjectKind::Component => {
+        ObjectKind::Component => {
+            code.push_indented(
+                0,
+                quote_arrow_support_from_obj(reporter, arrow_registry, ext_class, objects, obj),
+                1,
+            );
+
+            code.push_indented(
+                0,
+                format!(
+                    "# This is patched in late to avoid circular dependencies.
+{name}._BATCH_TYPE = {name}Batch  # type: ignore[assignment]"
+                ),
+                1,
+            );
+        }
+        ObjectKind::Datatype => {
             code.push_indented(
                 0,
                 quote_arrow_support_from_obj(reporter, arrow_registry, ext_class, objects, obj),

rerun_py/rerun_sdk/rerun/_baseclasses.py

@@ -275,6 +275,32 @@ def component_name(self) -> str:
         return self._ARROW_TYPE._TYPE_NAME  # type: ignore[attr-defined, no-any-return]
 
 
+class ComponentMixin(ComponentBatchLike):
+    """
+    Makes components adhere to the ComponentBatchLike interface.
+
+    A single component will always map to a batch of size 1.
+
+    The class using the mixin must define the `_BATCH_TYPE` field, which should be a subclass of `BaseBatch`.
+    """
+
+    def component_name(self) -> str:
+        """
+        The name of the component.
+
+        Part of the `ComponentBatchLike` logging interface.
+        """
+        return self._BATCH_TYPE._ARROW_TYPE._TYPE_NAME  # type: ignore[attr-defined, no-any-return]
+
+    def as_arrow_array(self) -> pa.Array:
+        """
+        The component as an arrow batch.
+
+        Part of the `ComponentBatchLike` logging interface.
+        """
+        return self._BATCH_TYPE([self]).as_arrow_array()  # type: ignore[attr-defined, no-any-return]
+
+
 @catch_and_log_exceptions(context="creating empty array")
 def _empty_pa_array(type: pa.DataType) -> pa.Array:
     if type == pa.null():