@deprecated

        :param message:
        :return:
186746
def log(self, message: str):
        
        dset_log_id = '_%s_log' % self.iid

        if dset_log_id not in self.parent.data.keys():
            dset = self.parent.data.create_dataset(
                dset_log_id, shape=(1,),
                dtype=np.dtype([
                    ('dt_log', '<i8'),
                    ('message', 'S250')
                ])
            )
        else:
            dset = self.parent.data[dset_log_id]

        timestamp = np.array(
            datetime.now().strftime("%s")
        ).astype('<i8').view('<M8[s]')

        dset['dt_log'] = timestamp.view('<i8')
        dset['message'] = message
        self.parent.data.flush()
901283
def deprecation(self, message, *args, **kws):
    """"""
    self._log(DEPRECATION, message, args, **kws)
914619
@Deprecated
  public void error(String message, Throwable t)
  {
    log.error(message, t);
  }
1052644
def gut_message(message: Message) -> Message:
    
    wrapper = Message()
    wrapper.add_header('Content-Type', 'message/external-body',
                       access_type='x-spam-deleted',
                       expiration=time.strftime("%a, %d %b %Y %H:%M:%S %z"),
                       size=str(len(message.get_payload())))

    message.set_payload('')
    wrapper.set_payload([message])

    return wrapper
21697
def _message_to_string(message, data=None):
    
    if data is None:
        data = _json_from_message(message)

    return "Message {} from {} to {}: {}".format(
        message.namespace, message.source_id, message.destination_id, data)
111323
def from_message(cls, message='> '):
        
        assert isinstance(message, text_type)

        def get_message_tokens(cli):
            return [(Token.Prompt, message)]
        return cls(get_message_tokens)
1284235
def from_raw_message(cls, rawmessage):
        """"""
        if (rawmessage[5] &
                MESSAGE_FLAG_EXTENDED_0X10) == MESSAGE_FLAG_EXTENDED_0X10:
            if len(rawmessage) >= ExtendedSend.receivedSize:
                msg = ExtendedSend.from_raw_message(rawmessage)
            else:
                msg = None
        else:
            msg = StandardSend(rawmessage[2:5],
                               {'cmd1': rawmessage[6],
                                'cmd2': rawmessage[7]},
                               flags=rawmessage[5],
                               acknak=rawmessage[8:9])
        return msg
441858
def pending_deprecate(
    message: str = "This function may be deprecated in the future."
    " Consider raising an issue on GitHub if you need this feature.",
    category: Any = PendingDeprecationWarning,
    stacklevel: int = 0,
) -> Callable[[F], F]:
    """"""
    return deprecate(message, category, stacklevel)
483917
def _clean_message(message):
    ''''''
    message = message.replace('zonecfg: ', '')
    message = message.splitlines()
    for line in message:
        if line.startswith('On line'):
            message.remove(line)
    return "\n".join(message)
308967
def deprecated(message=None):
    """"""
    def _decorator(func, message=message):
        if message is None:
            message = '%s is deprecated' % func.__name__

        def newfunc(*args, **kwds):
            warnings.warn(message, DeprecationWarning, stacklevel=2)
            return func(*args, **kwds)
        return newfunc
    return _decorator
686561
def _json_from_message(message):
    
    try:
        return json.loads(message.payload_utf8)
    except ValueError:
        logger = logging.getLogger(__name__)
        logger.warning("Ignoring invalid json in namespace %s: %s",
                       message.namespace, message.payload_utf8)
        return {}
932780
def indent(self, message):
        
        indent = self.indent_char * self.indent_size
        return indent + message
416041
def deprecated(method_name, options = {})

      deprecation_msg = options[:message] || begin
        msg = "DEPRECATION WARNING: called deprecated method `#{method_name}' "
        msg << "of an #{self}"
        msg << ", use #{options[:use]} instead" if options[:use]
        msg
      end

      alias_method(:"deprecated_#{method_name}", method_name)

      warned = false # we only want to issue this warning once

      define_method(method_name) do |*args,&block|
        unless warned
          warned = true
          warn(deprecation_msg + "\n" + caller.join("\n"))
        end
        send("deprecated_#{method_name}", *args, &block)
      end
    end
229733
def format_message(self, message):
        
        look = Look(message)
        return look.pretty(display=False)
244337
function convert (message) {
  const obj = {}
  const lines = message.toString().trim().split('\r\n')
  if (lines && lines[0]) {
    obj.status = lines[0]
    for (const line of lines) {
      const fields = line.split(': ')
      if (fields.length === 2) {
        obj[fields[0].toLowerCase()] = fields[1]
      }
    }
  }
  return obj
}
537623
def message_to_objects(
        message: Dict, sender: str, sender_key_fetcher: Callable[[str], str] = None, user: UserType = None,
) -> List:
    
    # We only really expect one element here for ActivityPub.
    return element_to_objects(message)
807627
def deprecated(message=DEPRECATION_MESSAGE, logger=None):
    
    if logger is None:
        logger = default_logger
    def _deprecated(f):
        def _wrapper(*args, **kwargs):
            f_name = f.__name__
            logger.warning(message.format(name=f_name))
            result = f(*args, **kwargs)
            return result
        return _wrapper
    return _deprecated