code: def get(self,
              variable_path: str,
              default: t.Optional[t.Any] = None,
              coerce_type: t.Optional[t.Type] = None,
              coercer: t.Optional[t.Callable] = None,
              **kwargs):
          
  
          if self.scope:
              variable_path = '{0.scope}{0.path_separator}{1}'.format(self, variable_path)
  
          if self.key_prefix:
              variable_path = '{0.key_prefix}:{1}'.format(self, variable_path)
  
          val = self.client.get(variable_path)
  
          if val is None:
              return default
  
          if val.startswith(self.object_serialize_prefix):
              # since complex data types are yaml-serialized there's no need to coerce anything
              _val = val[len(self.object_serialize_prefix):]
              bundle = self.object_deserialize(_val)
              if bundle == '':  # check for reinforced empty flag
                  return self.coerce(bundle, coerce_type=coerce_type, coercer=coercer)
              return bundle
  
          if isinstance(val, bytes):
              val = val.decode()
  
          return self.coerce(val, coerce_type=coerce_type, coercer=coercer)
docs: :param variable_path: a delimiter-separated path to a nested value
          :param default: default value if there's no object by specified path
          :param coerce_type: cast a type of a value to a specified one
          :param coercer: perform a type casting with specified callback
          :param kwargs: additional arguments inherited parser may need
          :return: value or default