viam.services.slam.slam
=======================

.. py:module:: viam.services.slam.slam


Classes
-------

.. autoapisummary::

   viam.services.slam.slam.SLAM


Module Contents
---------------

.. py:class:: SLAM(name: str, *, logger: Optional[logging.Logger] = None)

   Bases: :py:obj:`viam.services.service_base.ServiceBase`


   SLAM represents a SLAM service.

   This acts as an abstract base class for any drivers representing specific
   arm implementations. This cannot be used on its own. If the ``__init__()`` function is
   overridden, it must call the ``super().__init__()`` function.

   For more information, see `SLAM service <https://docs.viam.com/dev/reference/apis/services/slam/>`_.


   .. py:attribute:: API
      :type:  Final

      The API of the Resource


   .. py:attribute:: Properties
      :type:  TypeAlias
      :value: GetPropertiesResponse



   .. py:method:: get_internal_state(*, timeout: Optional[float]) -> List[bytes]
      :abstractmethod:

      :async:


      Get the internal state of the SLAM algorithm required to continue mapping/localization.

      ::

          slam = SLAMClient.from_robot(robot=machine, name="my_slam_service")

          # Get the internal state of the SLAM algorithm required to continue mapping/localization.
          internal_state = await slam.get_internal_state()

      :returns: Chunks of the internal state of the SLAM algorithm
      :rtype: List[GetInternalStateResponse]

      For more information, see `SLAM service <https://docs.viam.com/dev/reference/apis/services/slam/#getinternalstate>`_.



   .. py:method:: get_point_cloud_map(return_edited_map: bool = False, *, timeout: Optional[float]) -> List[bytes]
      :abstractmethod:

      :async:


      Get the point cloud map.

      ::

          slam_svc = SLAMClient.from_robot(robot=machine, name="my_slam_service")

          # Get the point cloud map in standard PCD format.
          pcd_map = await slam_svc.get_point_cloud_map()

      :param return_edited_map: signal to the SLAM service to return an edited map, if the map package contains one and if
                                the SLAM service supports the feature
      :type return_edited_map: bool

      :returns: Complete pointcloud in standard PCD format. Chunks of the PointCloud, concatenating all
                GetPointCloudMapResponse.point_cloud_pcd_chunk values.
      :rtype: List[GetPointCloudMapResponse]

      For more information, see `SLAM service <https://docs.viam.com/dev/reference/apis/services/slam/#getpointcloudmap>`_.



   .. py:method:: get_position(*, timeout: Optional[float]) -> viam.services.slam.Pose
      :abstractmethod:

      :async:


      Get current position of the specified component in the SLAM Map.

      ::

          slam_svc = SLAMClient.from_robot(robot=machine, name="my_slam_service")

          # Get the current position of the specified source component in the SLAM map as a Pose.
          pose = await slam.get_position()

      :returns: The current position of the specified component
      :rtype: Pose

      For more information, see `SLAM service <https://docs.viam.com/dev/reference/apis/services/slam/#getposition>`_.



   .. py:method:: get_properties(*, timeout: Optional[float]) -> Properties
      :abstractmethod:

      :async:


      Get information regarding the current SLAM session.

      ::

          slam_svc = SLAMClient.from_robot(robot=machine, name="my_slam_service")

          # Get the properties of your current SLAM session.
          slam_properties = await slam_svc.get_properties()

      :returns: The properties of SLAM
      :rtype: Properties

      For more information, see `SLAM service <https://docs.viam.com/dev/reference/apis/services/slam/#getproperties>`_.



   .. py:method:: from_robot(robot: viam.robot.client.RobotClient, name: str) -> typing_extensions.Self
      :classmethod:


      Get the service named ``name`` from the provided robot.

      ::

          async def connect() -> RobotClient:
              # Replace "<API-KEY>" (including brackets) with your API key and "<API-KEY-ID>" with your API key ID
              options = RobotClient.Options.with_api_key("<API-KEY>", "<API-KEY-ID>")
              # Replace "<MACHINE-URL>" (included brackets) with your machine's connection URL or FQDN
              return await RobotClient.at_address("<MACHINE-URL>", options)

          async def main():
              robot = await connect()

              # Can be used with any resource, using the motion service as an example
              motion = MotionClient.from_robot(robot=machine, name="builtin")

              robot.close()

      :param robot: The robot
      :type robot: RobotClient
      :param name: The name of the service
      :type name: str

      :returns: The service, if it exists on the robot
      :rtype: Self



   .. py:method:: do_command(command: Mapping[str, viam.utils.ValueTypes], *, timeout: Optional[float] = None, **kwargs) -> Mapping[str, viam.utils.ValueTypes]
      :abstractmethod:

      :async:


      Send/receive arbitrary commands.

      ::

          service = SERVICE.from_robot(robot=machine, "builtin")  # replace SERVICE with the appropriate class

          my_command = {
            "cmnd": "dosomething",
            "someparameter": 52
          }

          # Can be used with any resource, using the motion service as an example
          await service.do_command(command=my_command)

      :param command: The command to execute
      :type command: Dict[str, ValueTypes]

      :returns: Result of the executed command
      :rtype: Dict[str, ValueTypes]



   .. py:method:: get_resource_name(name: str) -> viam.proto.common.ResourceName
      :classmethod:


      Get the ResourceName for this Resource with the given name

      ::

          # Can be used with any resource, using an arm as an example
          my_arm_name = Arm.get_resource_name("my_arm")

      :param name: The name of the Resource
      :type name: str

      :returns: The ResourceName of this Resource
      :rtype: ResourceName



   .. py:method:: get_operation(kwargs: Mapping[str, Any]) -> viam.operations.Operation

      Get the ``Operation`` associated with the currently running function.

      When writing custom resources, you should get the ``Operation`` by calling this function and check to see if it's cancelled.
      If the ``Operation`` is cancelled, then you can perform any necessary (terminating long running tasks, cleaning up connections, etc.
      ).

      :param kwargs: The kwargs object containing the operation
      :type kwargs: Mapping[str, Any]

      :returns: The operation associated with this function
      :rtype: viam.operations.Operation



   .. py:method:: close()
      :async:


      Safely shut down the resource and prevent further use.

      Close must be idempotent. Later configuration may allow a resource to be "open" again.
      If a resource does not want or need a close function, it is assumed that the resource does not need to return errors when future
      non-Close methods are called.

      ::

          await component.close()