feagi-core 2.2.1__tar.gz → 2.2.3__tar.gz

{feagi_core-2.2.1 → feagi_core-2.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: feagi-core
-Version: 2.2.1
+Version: 2.2.3
 Summary: Core SDK for building FEAGI agents, controlling the neural engine, and creating marketplace packages (without Brain Visualizer)
 Author-email: "Neuraville Inc." <feagi@neuraville.com>
 License: Apache-2.0
@@ -25,14 +25,14 @@ Requires-Dist: numpy>=1.20.0
 Requires-Dist: aiohttp>=3.9.0
 Requires-Dist: toml>=0.10.2
 Requires-Dist: requests>=2.31.0
-Requires-Dist: feagi-rust-py-libs>=0.0.113
+Requires-Dist: feagi-rust-py-libs>=0.0.115
 Requires-Dist: pyserial>=3.5
 Provides-Extra: bv
-Requires-Dist: feagi-bv<3.0.0,>=2.5.0; extra == "bv"
-Requires-Dist: feagi-bv-linux<3.0.0,>=2.5.0; sys_platform == "linux" and extra == "bv"
-Requires-Dist: feagi-bv-macos-arm64<3.0.0,>=2.5.0; (sys_platform == "darwin" and platform_machine == "arm64") and extra == "bv"
-Requires-Dist: feagi-bv-macos-x86_64<3.0.0,>=2.5.0; (sys_platform == "darwin" and platform_machine == "x86_64") and extra == "bv"
-Requires-Dist: feagi-bv-windows<3.0.0,>=2.5.0; sys_platform == "win32" and extra == "bv"
+Requires-Dist: feagi-bv<3.0.0,>=2.6.2; extra == "bv"
+Requires-Dist: feagi-bv-linux<3.0.0,>=2.6.2; sys_platform == "linux" and extra == "bv"
+Requires-Dist: feagi-bv-macos-arm64<3.0.0,>=2.6.2; (sys_platform == "darwin" and platform_machine == "arm64") and extra == "bv"
+Requires-Dist: feagi-bv-macos-x86_64<3.0.0,>=2.6.2; (sys_platform == "darwin" and platform_machine == "x86_64") and extra == "bv"
+Requires-Dist: feagi-bv-windows<3.0.0,>=2.6.2; sys_platform == "win32" and extra == "bv"
 Provides-Extra: video
 Requires-Dist: opencv-python>=4.9.0; extra == "video"
 Provides-Extra: bluetooth
@@ -60,11 +60,11 @@ Requires-Dist: mkdocs-material>=9.0.0; extra == "docs"
 Requires-Dist: mkdocstrings>=0.20.0; extra == "docs"
 Requires-Dist: mkdocstrings-python>=1.0.0; extra == "docs"
 Provides-Extra: full
-Requires-Dist: feagi-bv<3.0.0,>=2.5.0; extra == "full"
-Requires-Dist: feagi-bv-linux<3.0.0,>=2.5.0; sys_platform == "linux" and extra == "full"
-Requires-Dist: feagi-bv-macos-arm64<3.0.0,>=2.5.0; (sys_platform == "darwin" and platform_machine == "arm64") and extra == "full"
-Requires-Dist: feagi-bv-macos-x86_64<3.0.0,>=2.5.0; (sys_platform == "darwin" and platform_machine == "x86_64") and extra == "full"
-Requires-Dist: feagi-bv-windows<3.0.0,>=2.5.0; sys_platform == "win32" and extra == "full"
+Requires-Dist: feagi-bv<3.0.0,>=2.6.2; extra == "full"
+Requires-Dist: feagi-bv-linux<3.0.0,>=2.6.2; sys_platform == "linux" and extra == "full"
+Requires-Dist: feagi-bv-macos-arm64<3.0.0,>=2.6.2; (sys_platform == "darwin" and platform_machine == "arm64") and extra == "full"
+Requires-Dist: feagi-bv-macos-x86_64<3.0.0,>=2.6.2; (sys_platform == "darwin" and platform_machine == "x86_64") and extra == "full"
+Requires-Dist: feagi-bv-windows<3.0.0,>=2.6.2; sys_platform == "win32" and extra == "full"
 Requires-Dist: opencv-python>=4.9.0; extra == "full"
 Requires-Dist: bleak>=0.21.0; extra == "full"
 Requires-Dist: websockets>=12.0; extra == "full"

{feagi_core-2.2.1 → feagi_core-2.2.3}/examples/video_streamer/example_rgbd_pair.py

@@ -98,16 +98,14 @@ def get_rgb_frame() -> np.ndarray:
     return frame
 
 
-def get_depth_volume() -> np.ndarray:
+def get_depth_plane() -> np.ndarray:
     """
     Replace with real depth frame conversion.
 
-    Expected shape: (H, W, Z), float32 where Z = depth bins and each pixel maps
-    to one or more bins according to your sensor semantics.
+    Expected shape: (H, W), float32 in [0, 1]. Each pixel's value is the
+    normalized depth FEAGI receives as potential; 0 means no return.
     """
-    depth = np.zeros((240, 320, 64), dtype=np.float32)
-    depth[:, :, 12] = 1.0
-    return depth
+    return np.full((240, 320), 0.2, dtype=np.float32)
 
 
 def main() -> None:
@@ -140,7 +138,7 @@ def main() -> None:
             rgb_group=0,
             depth_group=1,
             rgb_resolution_xy=(320, 240),
-            depth_dimensions_xyz=(320, 240, 64),
+            depth_resolution_xy=(320, 240),
             bundle_id="front_rgbd",
             bundle_type="rgbd_camera",
             frame_change_handling="absolute",
@@ -150,13 +148,13 @@ def main() -> None:
         print("RGBD streaming started. Press Ctrl+C to stop.")
         while True:
             rgb_frame = get_rgb_frame()
-            depth_volume = get_depth_volume()
+            depth_plane = get_depth_plane()
             brain_output.write_rgbd_tick(
                 rgb_group=groups["Vision"],
                 depth_group=groups["DepthMap"],
                 channel_index=0,
                 frame_rgb=rgb_frame,
-                depth_map_xyz=depth_volume,
+                depth_map_xy=depth_plane,
             )
             brain_output.flush_sensory_bytes()
             time.sleep(1.0 / 15.0)

{feagi_core-2.2.1 → feagi_core-2.2.3}/examples/video_streamer/example_rgbd_realsense.py

@@ -109,28 +109,26 @@ def _ensure_auth_token() -> str:
     return token
 
 
-def _depth_frame_to_one_hot_volume(
+def _depth_frame_to_level_plane(
     depth_mm_frame: np.ndarray,
     *,
     depth_scale: float,
-    depth_bins: int,
+    depth_levels: int,
     max_depth_m: float,
 ) -> np.ndarray:
-    """Project metric depth frame into one-hot depth-bin volume."""
+    """
+    Project a metric depth frame onto a quantized one-layer plane.
+
+    Each valid pixel becomes ``level / depth_levels`` with ``level`` in
+    ``1..=depth_levels``. RealSense reports 0 for no return; those stay 0 so
+    they do not fire.
+    """
     depth_meters = depth_mm_frame.astype(np.float32) * float(depth_scale)
     normalized = np.clip(depth_meters / float(max_depth_m), 0.0, 1.0)
-    max_bin = depth_bins - 1
-    depth_indices = np.clip(
-        np.rint(normalized * max_bin).astype(np.int32),
-        0,
-        max_bin,
-    )
-    height, width = depth_indices.shape
-    depth_volume = np.zeros((height, width, depth_bins), dtype=np.float32)
-    row_idx = np.arange(height)[:, None]
-    col_idx = np.arange(width)[None, :]
-    depth_volume[row_idx, col_idx, depth_indices] = 1.0
-    return depth_volume
+    level = np.rint(normalized * (depth_levels - 1)) + 1.0
+    plane = (level / float(depth_levels)).astype(np.float32)
+    plane[depth_mm_frame == 0] = 0.0
+    return plane
 
 
 def main() -> None:
@@ -142,7 +140,7 @@ def main() -> None:
             "Install it in your active virtual environment."
         ) from import_error
 
-    depth_bins = _required_env_int("FEAGI_DEPTH_BINS")
+    depth_levels = _required_env_int("FEAGI_DEPTH_LEVELS")
     max_depth_m = _required_env_float("FEAGI_RGBD_MAX_DEPTH_M")
 
     config_path = _config_path()
@@ -210,7 +208,7 @@ def main() -> None:
             rgb_group=0,
             depth_group=1,
             rgb_resolution_xy=(frame_width, frame_height),
-            depth_dimensions_xyz=(frame_width, frame_height, depth_bins),
+            depth_resolution_xy=(frame_width, frame_height),
             bundle_id=bundle_id,
             bundle_type="rgbd_camera",
             frame_change_handling="absolute",
@@ -233,10 +231,10 @@ def main() -> None:
                 depth_frame.get_data(),
                 dtype=np.uint16,
             )
-            depth_volume = _depth_frame_to_one_hot_volume(
+            depth_plane = _depth_frame_to_level_plane(
                 depth_mm_frame,
                 depth_scale=depth_scale,
-                depth_bins=depth_bins,
+                depth_levels=depth_levels,
                 max_depth_m=max_depth_m,
             )
 
@@ -245,7 +243,7 @@ def main() -> None:
                 depth_group=groups["DepthMap"],
                 channel_index=0,
                 frame_rgb=rgb_frame,
-                depth_map_xyz=depth_volume,
+                depth_map_xy=depth_plane,
             )
             brain_output.flush_sensory_bytes()
     except KeyboardInterrupt:

{feagi_core-2.2.1 → feagi_core-2.2.3}/feagi/__init__.py

@@ -18,7 +18,7 @@ Main modules:
 - feagi.cli: Command-line tools
 """
 
-__version__ = "2.2.1"
+__version__ = "2.2.3"
 
 # Import key classes for convenience, but keep optional dependencies lazy so
 # `import feagi` does not require platform-specific extras (e.g., pyserial).

{feagi_core-2.2.1 → feagi_core-2.2.3}/feagi/pns/brain_input.py

@@ -39,6 +39,7 @@ _SUBTYPE_TO_SENSOR_REGISTER_CANDIDATES = {
     b"dpt": ["sensor_depth_map_register", "sensor_DepthMap_register"],
     b"rim": ["sensor_raw_i_m_u_register", "sensor_RawIMU_register"],
     b"sim": ["sensor_smart_i_m_u_register", "sensor_SmartIMU_register"],
+    b"aud": ["sensor_audio_input_register", "sensor_AudioInput_register"],
 }
 
 
@@ -164,6 +165,21 @@ def register_cortical_areas_with_cache(cache: Any, cortical_area_ids: List[str])
                 frame_change_handling=frame,
                 misc_data_dimensions=dims,
             )
+        elif subtype == b"aud":
+            audio_properties = cc_data_types.AudioSpectrumProperties.new_linear(
+                16000,
+                1024,
+                512,
+                16,
+                -80,
+                0,
+            )
+            register_method(
+                group=group_id,
+                number_channels=1,
+                frame_change_handling=frame,
+                audio_properties=audio_properties,
+            )
         elif subtype in (b"rim", b"sim"):
             # IMU registration mirrors the SignedPercentage_3D / 4D arm
             # signature: (group, number_channels, frame_change_handling,

{feagi_core-2.2.1 → feagi_core-2.2.3}/feagi/pns/brain_output.py

@@ -28,6 +28,9 @@ if not logger.handlers:
 
 # @ruff-skip: module has >100 E501 line-length violations - cleanup task: sdk-lint-cleanup-brain-output
 
+# The DepthMap sensory area is one layer; depth rides on each pixel's potential.
+DEPTH_MAP_LAYERS = 1
+
 
 class BrainOutput:
     """
@@ -1221,6 +1224,12 @@ class BrainOutput:
         image_resolution_xy: tuple[int, int] = (32, 32),
         misc_dimensions_xyz: tuple[int, int, int] = (1, 1, 1),
         frame_change_handling: Literal["absolute", "incremental"] = "absolute",
+        audio_sample_rate_hz: int = 16000,
+        audio_window_size: int = 1024,
+        audio_hop_size: int = 512,
+        audio_phase_steps: int = 16,
+        audio_magnitude_floor_db: int = -80,
+        audio_magnitude_ceiling_db: int = 0,
     ) -> Dict[str, int]:
         """
         Register sensory units in ConnectorAgent cache using SDK-owned Rust bindings.
@@ -1231,7 +1240,13 @@ class BrainOutput:
         Args:
             unit_channel_counts: Mapping of FEAGI unit key -> channel count.
                 Supported keys: ``Vision``, ``RawIMU``, ``SmartIMU``, ``Proximity``,
-                ``Servo``, ``Shock``, ``MiscData``, ``DepthMap``, ``CartesianPosition``.
+                ``Servo``, ``Shock``, ``MiscData``, ``DepthMap``, ``CartesianPosition``,
+                ``AudioInput``.
+
+                Notes on ``AudioInput``:
+                  * Absolute-only. Registers one spectrum area per channel using
+                    linear ``AudioSpectrumProperties`` from the ``audio_*`` kwargs
+                    (default 16 kHz, 1024-sample window, hop 512, 16 phase steps).
 
                 Notes on IMU keys:
                   * ``RawIMU`` registers ONE cortical unit with three sub-areas
@@ -1300,6 +1315,18 @@ class BrainOutput:
             int(misc_dimensions_xyz[1]),
             int(misc_dimensions_xyz[2]),
         )
+        if "AudioInput" in unit_channel_counts and frame_mode_value != "absolute":
+            raise ValueError("AudioInput only supports frame_change_handling='absolute'.")
+        audio_properties = None
+        if "AudioInput" in unit_channel_counts:
+            audio_properties = frpl.connector_core.data_types.AudioSpectrumProperties.new_linear(
+                int(audio_sample_rate_hz),
+                int(audio_window_size),
+                int(audio_hop_size),
+                int(audio_phase_steps),
+                int(audio_magnitude_floor_db),
+                int(audio_magnitude_ceiling_db),
+            )
 
         sensory_registers = {
             "Vision": lambda group, count: self._cache.sensor_Vision_register(
@@ -1372,6 +1399,12 @@ class BrainOutput:
                 z_neuron_resolution,
                 positioning,
             ),
+            "AudioInput": lambda group, count: self._cache.sensor_AudioInput_register(
+                group,
+                count,
+                frame_mode,
+                audio_properties,
+            ),
         }
 
         unit_groups: Dict[str, int] = {}
@@ -1398,7 +1431,7 @@ class BrainOutput:
         rgb_group: int,
         depth_group: int,
         rgb_resolution_xy: tuple[int, int],
-        depth_dimensions_xyz: tuple[int, int, int],
+        depth_resolution_xy: tuple[int, int],
         bundle_id: str,
         bundle_type: str = "rgbd_camera",
         frame_change_handling: Literal["absolute", "incremental"] = "absolute",
@@ -1407,7 +1440,8 @@ class BrainOutput:
         Register one RGBD camera as sibling Vision + DepthMap sensory units.
 
         This keeps registration deterministic and explicitly paired so FEAGI can
-        treat both streams as one physical camera rig.
+        treat both streams as one physical camera rig. The DepthMap is one layer
+        (``W x H x 1``); depth rides on each pixel's potential.
         """
         self._init_cache()
         if self._cache is None:
@@ -1449,9 +1483,9 @@ class BrainOutput:
             descriptors.ColorChannelLayout.RGB,
         )
         depth_dims = descriptors.MiscDataDimensions(
-            int(depth_dimensions_xyz[0]),
-            int(depth_dimensions_xyz[1]),
-            int(depth_dimensions_xyz[2]),
+            int(depth_resolution_xy[0]),
+            int(depth_resolution_xy[1]),
+            DEPTH_MAP_LAYERS,
         )
         self._cache.sensor_Vision_register(
             int(rgb_group),
@@ -1687,6 +1721,172 @@ class BrainOutput:
             int(window_ms) if window_ms is not None else None,
         )
 
+    def register_motor_audio_output(
+        self,
+        *,
+        group: int,
+        number_channels: int = 1,
+        sample_rate_hz: int = 16000,
+        window_size: int = 1024,
+        hop_size: int = 512,
+        phase_steps: int = 16,
+        magnitude_floor_db: int = -80,
+        magnitude_ceiling_db: int = 0,
+    ) -> None:
+        """Register an AudioOutput motor area (linear spectrum, absolute)."""
+        self._init_cache()
+        if self._cache is None:
+            raise RuntimeError("ConnectorAgent cache is not initialized.")
+        if int(number_channels) <= 0:
+            raise ValueError("AudioOutput number_channels must be > 0.")
+
+        import feagi_rust_py_libs as frpl
+
+        frame_mode = (
+            frpl.data_structures.genomic.cortical_area.FrameChangeHandling.Absolute()
+        )
+        audio_properties = frpl.connector_core.data_types.AudioSpectrumProperties.new_linear(
+            int(sample_rate_hz),
+            int(window_size),
+            int(hop_size),
+            int(phase_steps),
+            int(magnitude_floor_db),
+            int(magnitude_ceiling_db),
+        )
+        self._cache.motor_AudioOutput_register(
+            int(group),
+            int(number_channels),
+            frame_mode,
+            audio_properties,
+        )
+
+    def register_motor_simple_vision_output(
+        self,
+        *,
+        group: int,
+        width: int,
+        height: int,
+        number_channels: int = 1,
+    ) -> None:
+        """Register a SimpleVisionOutput motor area as one RGB image frame."""
+        self._init_cache()
+        if self._cache is None:
+            raise RuntimeError("ConnectorAgent cache is not initialized.")
+        if int(width) <= 0 or int(height) <= 0:
+            raise ValueError("SimpleVisionOutput dimensions must be positive integers.")
+        if int(number_channels) <= 0:
+            raise ValueError("SimpleVisionOutput number_channels must be > 0.")
+
+        import feagi_rust_py_libs as frpl
+
+        frame_mode = (
+            frpl.data_structures.genomic.cortical_area.FrameChangeHandling.Absolute()
+        )
+        descriptors = frpl.connector_core.data_types.descriptors
+        image_properties = descriptors.ImageFrameProperties(
+            descriptors.ImageXYResolution(int(width), int(height)),
+            descriptors.ColorSpace.Gamma,
+            descriptors.ColorChannelLayout.RGB,
+        )
+        self._cache.motor_SimpleVisionOutput_register(
+            int(group),
+            int(number_channels),
+            frame_mode,
+            image_properties,
+        )
+
+    def register_motor_pose_estimation(
+        self,
+        *,
+        group: int,
+        width: int,
+        height: int,
+        depth: int,
+        pose_schema: str = "HumanBody",
+        number_channels: int = 1,
+    ) -> None:
+        """Register a PoseEstimation motor area.
+
+        ``pose_schema`` is one of HumanBody, HumanHand, HumanFace, Quadruped,
+        Avian, Arthropod, Object6DoF, or Custom.
+        """
+        self._init_cache()
+        if self._cache is None:
+            raise RuntimeError("ConnectorAgent cache is not initialized.")
+        if int(width) <= 0 or int(height) <= 0 or int(depth) <= 0:
+            raise ValueError("PoseEstimation dimensions must be positive integers.")
+        if int(number_channels) <= 0:
+            raise ValueError("PoseEstimation number_channels must be > 0.")
+
+        import feagi_rust_py_libs as frpl
+
+        schema_name = str(pose_schema).strip()
+        schema_factory = getattr(
+            frpl.data_structures.genomic.cortical_area.PoseSchema,
+            schema_name,
+            None,
+        )
+        if schema_factory is None:
+            raise ValueError(f"Unknown pose schema '{schema_name}'.")
+        frame_mode = (
+            frpl.data_structures.genomic.cortical_area.FrameChangeHandling.Absolute()
+        )
+        pose_properties = frpl.connector_core.data_types.PoseEstimationProperties(
+            int(width),
+            int(height),
+            int(depth),
+        )
+        self._cache.motor_PoseEstimation_register(
+            int(group),
+            int(number_channels),
+            frame_mode,
+            schema_factory(),
+            pose_properties,
+        )
+
+    def write_sensor_audio_spectrum(
+        self,
+        *,
+        group: int,
+        channel_index: int,
+        frame,
+    ) -> None:
+        """Write one ``AudioSpectrumFrame`` into a registered AudioInput channel."""
+        if self._cache is None:
+            raise RuntimeError("ConnectorAgent cache is not initialized.")
+        self._cache.sensor_audio_input_write(
+            group=int(group),
+            channel_index=int(channel_index),
+            data=frame,
+        )
+
+    def read_motor_audio_spectrum(self, *, group: int, channel_index: int):
+        """Read the latest decoded AudioOutput spectrum frame."""
+        if self._cache is None:
+            raise RuntimeError("ConnectorAgent cache is not initialized.")
+        return self._cache.motor_audio_output_read_postprocessed_cache_value(
+            int(group),
+            int(channel_index),
+        )
+
+    def read_motor_simple_vision_output(self, *, group: int, channel_index: int):
+        """Read the latest decoded SimpleVisionOutput image frame."""
+        if self._cache is None:
+            raise RuntimeError("ConnectorAgent cache is not initialized.")
+        return self._cache.motor_simple_vision_output_read_postprocessed_cache_value(
+            int(group),
+            int(channel_index),
+        )
+
+    def read_motor_pose_estimation(self, *, group: int, channel_index: int):
+        """Read the latest decoded PoseEstimation joint frame."""
+        if self._cache is None:
+            raise RuntimeError("ConnectorAgent cache is not initialized.")
+        return self._cache.motor_pose_estimation_read_postprocessed_cache_value(
+            int(group),
+            int(channel_index),
+        )
+
     def _init_sensory_write_helpers(self) -> None:
         """Lazy-init write helper factories for sensory cache writes."""
         if (
@@ -2027,20 +2227,19 @@ class BrainOutput:
         *,
         group: int,
         channel_index: int,
-        depth_map_xyz,
+        depth_map_xy,
     ) -> None:
-        """Write one depth volume into DepthMap sensory cache."""
+        """
+        Write one depth plane into the DepthMap sensory cache.
+
+        ``depth_map_xy`` is ``(H, W)`` or ``(H, W, 1)`` with values in ``[0, 1]``;
+        each pixel's value is the potential FEAGI receives. Zero means no return.
+        """
         if self._cache is None:
             raise RuntimeError("ConnectorAgent cache is not initialized.")
         self._init_sensory_write_helpers()
 
-        import numpy as np
-
-        depth_array = np.asarray(depth_map_xyz, dtype=np.float32)
-        if depth_array.ndim != 3:
-            raise ValueError(
-                f"Depth map must be a 3D ndarray (H, W, Z), got {depth_array.shape}"
-            )
+        depth_array = BrainOutput._depth_plane(depth_map_xy)
         depth_data = self._sensory_misc_factory.new_from_array(depth_array)
         self._cache.sensor_depth_map_write(
             group=int(group),
@@ -2049,15 +2248,33 @@ class BrainOutput:
         )
 
     @staticmethod
-    def rgb_frame_to_depth_map_bins(frame_rgb, depth_bins: int):
+    def _depth_plane(depth_map_xy):
+        """Validate a depth plane and return it as ``(H, W, 1)`` float32."""
+        import numpy as np
+
+        depth_array = np.asarray(depth_map_xy, dtype=np.float32)
+        if depth_array.ndim == 2:
+            depth_array = depth_array[:, :, None]
+        if depth_array.ndim != 3 or depth_array.shape[2] != DEPTH_MAP_LAYERS:
+            raise ValueError(
+                "Depth map must be (H, W) or (H, W, 1); depth rides on potential, "
+                f"got {depth_array.shape}"
+            )
+        if np.any(depth_array < 0.0) or np.any(depth_array > 1.0):
+            raise ValueError("Depth map values must be in [0, 1].")
+        return depth_array
+
+    @staticmethod
+    def rgb_frame_to_depth_map_levels(frame_rgb, depth_levels: int):
         """
-        Convert RGB frame to one-hot depth bins using luminance.
+        Convert an RGB frame to a quantized one-layer depth plane using luminance.
 
-        This mirrors the deterministic desktop fallback path:
-        brightness is projected to one z-bin per pixel.
+        Mirrors the desktop depth path: luminance maps to ``level`` in
+        ``1..=depth_levels`` and the pixel potential is ``level / depth_levels``,
+        so every pixel is in ``(0, 1]``. Returns ``(H, W, 1)`` float32.
         """
-        if int(depth_bins) <= 0:
-            raise ValueError("depth_bins must be > 0.")
+        if int(depth_levels) <= 0:
+            raise ValueError("depth_levels must be > 0.")
         import numpy as np
 
         frame_array = np.asarray(frame_rgb, dtype=np.uint8)
@@ -2071,18 +2288,9 @@ class BrainOutput:
             + 0.587 * frame_array[:, :, 1].astype(np.float32)
             + 0.114 * frame_array[:, :, 2].astype(np.float32)
         ) / 255.0
-        max_bin = int(depth_bins) - 1
-        indices = np.clip(
-            (luminance * max_bin).round().astype(np.int32),
-            0,
-            max_bin,
-        )
-        height, width = indices.shape
-        depth_map = np.zeros((height, width, int(depth_bins)), dtype=np.float32)
-        row_idx = np.arange(height)[:, None]
-        col_idx = np.arange(width)[None, :]
-        depth_map[row_idx, col_idx, indices] = 1.0
-        return depth_map
+        levels = int(depth_levels)
+        level = np.clip(np.round(luminance * (levels - 1)), 0, levels - 1) + 1.0
+        return (level / float(levels)).astype(np.float32)[:, :, None]
 
     def write_rgbd_tick(
         self,
@@ -2091,14 +2299,14 @@ class BrainOutput:
         depth_group: int,
         channel_index: int,
         frame_rgb,
-        depth_map_xyz=None,
-        depth_bins: Optional[int] = None,
+        depth_map_xy=None,
+        depth_levels: Optional[int] = None,
     ) -> None:
         """
         Write paired RGB + DepthMap data for one tick.
 
-        If ``depth_map_xyz`` is omitted, this derives depth bins from RGB
-        luminance deterministically.
+        If ``depth_map_xy`` is omitted, this derives a quantized depth plane from
+        RGB luminance deterministically.
         """
         self.write_sensor_vision_frame(
             group=rgb_group,
@@ -2106,20 +2314,20 @@ class BrainOutput:
             frame_rgb=frame_rgb,
         )
 
-        resolved_depth_map = depth_map_xyz
+        resolved_depth_map = depth_map_xy
         if resolved_depth_map is None:
-            if depth_bins is None:
+            if depth_levels is None:
                 raise ValueError(
-                    "depth_bins must be provided when depth_map_xyz is None."
+                    "depth_levels must be provided when depth_map_xy is None."
                 )
-            resolved_depth_map = BrainOutput.rgb_frame_to_depth_map_bins(
+            resolved_depth_map = BrainOutput.rgb_frame_to_depth_map_levels(
                 frame_rgb,
-                int(depth_bins),
+                int(depth_levels),
             )
         self.write_sensor_depth_map(
             group=depth_group,
             channel_index=channel_index,
-            depth_map_xyz=resolved_depth_map,
+            depth_map_xy=resolved_depth_map,
         )
 
     def write_sensor_scalar(

{feagi_core-2.2.1 → feagi_core-2.2.3}/feagi/pns/connector_utils.py

@@ -74,7 +74,7 @@ def load_capabilities_from_file(agent: 'PyConnectorAgent', filepath: Union[str,
                     f"     --input {filepath} \\\n"
                     f"     --output {filepath.parent / 'capabilities_new.json'}\n"
                 )
-        except:
+        except Exception:
             pass
         
         raise
@@ -139,6 +139,6 @@ def _is_old_format(data: dict) -> bool:
                     return True
                     
         return False
-    except:
+    except Exception:
         return False