docs: def find(self, **filter_args):
          """
          Find exactly one resource in scope of this manager, by matching
          resource properties against the specified filter arguments, and return
          its Python resource object (e.g. for a CPC, a :class:`~zhmcclient.Cpc`
          object is returned).
  
          Any resource property may be specified in a filter argument. For
          details about filter arguments, see :ref:`Filtering`.
  
          The zhmcclient implementation handles the specified properties in an
          optimized way: Properties that can be filtered on the HMC are actually
          filtered there (this varies by resource type), and the remaining
          properties are filtered on the client side.
  
          If the "name" property is specified as the only filter argument, an
          optimized lookup is performed that uses a name-to-URI cache in this
          manager object. This this optimized lookup uses the specified match
          value for exact matching and is not interpreted as a regular
          expression.
  
          Authorization requirements:
  
          * see the `list()` method in the derived classes.
  
          Parameters:
  
            \\**filter_args:
              All keyword arguments are used as filter arguments. Specifying no
              keyword arguments causes no filtering to happen. See the examples
              for usage details.
  
          Returns:
  
            Resource object in scope of this manager object that matches the
            filter arguments. This resource object has a minimal set of
            properties.
  
          Raises:
  
            :exc:`~zhmcclient.NotFound`: No matching resource found.
            :exc:`~zhmcclient.NoUniqueMatch`: More than one matching resource
              found.
            : Exceptions raised by the `list()` methods in derived resource
              manager classes (see :ref:`Resources`).
  
          Examples:
  
          * The following example finds a CPC by its name. Because the 'name'
            resource property is also a valid Python variable name, there are
            two ways for the caller to specify the filter arguments for this
            method:
  
            As named parameters::
  
                cpc = client.cpcs.find(name='CPC001')
  
            As a parameter dictionary::
  
                filter_args = {'name': 'CPC0001'}
                cpc = client.cpcs.find(**filter_args)
  
          * The following example finds a CPC by its object ID. Because the
            'object-id' resource property is not a valid Python variable name,
            the caller can specify the filter argument only as a parameter
            dictionary::
  
                filter_args = {'object-id': '12345-abc...de-12345'}
                cpc = client.cpcs.find(**filter_args)
          """
          obj_list = self.findall(**filter_args)
          num_objs = len(obj_list)
          if num_objs == 0:
              raise NotFound(filter_args, self)
          elif num_objs > 1:
              raise NoUniqueMatch(filter_args, self, obj_list)
          else:
              return obj_list[0]