Access the Notify Twilio Domain

        :returns: Notify Twilio Domain
        :rtype: twilio.rest.notify.Notify
174454
def notify(self):
        
        if self._notify is None:
            from twilio.rest.notify import Notify
            self._notify = Notify(self)
        return self._notify
578710
def send_notification(self, title, message, typ=1, url=None, sender=None):
        
        self.user.send_notification(title=title, message=message, typ=typ, url=url,
                                    sender=sender)
814668
def get_domain(self):
        
        if hasattr(self, 'domain'):
            return Domain(self.rest_client.make_request(self.domain), self.rest_client)
1152171
def notify(title,
           message,
           auth_token,
           source=None,
           url=None,
           url_title=None,
           image=None,
           ttl=None,
           important=False,
           silent=False,
           retcode=None):
    

    data = {
        'Title': title,
        'Body': message,
        'AuthorizationToken': auth_token,
    }

    if source:
        data['Source'] = source
    if url:
        data['Link'] = url
    if url and url_title:
        data['LinkTitle'] = url_title
    if image:
        data['Image'] = image
    if ttl:
        data['TimeToLive'] = int(ttl)
    if important:
        data['IsImportant'] = 'True'
    if silent:
        data['IsSilent'] = 'True'

    headers = {'User-Agent': USER_AGENT}
    response = requests.post(PUSHALOT_API_URL, data=data, headers=headers)
    response.raise_for_status()
835085
def notifications_get(input_params={}, always_retry=True, **kwargs):
    
    return DXHTTPRequest('/notifications/get', input_params, always_retry=always_retry, **kwargs)
1113387
def notify(message, message_opts = {})
      if _client?
        return unless enabled?
      else
        return unless active?
      end

      @detected.available.each do |notifier|
        notifier.notify(message, message_opts.dup)
      end
    end
244128
def _Notify(username, notification_type, message, object_reference):
  """"""

  # Do not try to notify system users (e.g. Cron).
  if username in aff4_users.GRRUser.SYSTEM_USERS:
    return

  if object_reference:
    uc = object_reference.UnionCast()
    if hasattr(uc, "client_id"):
      message = _HostPrefix(uc.client_id) + message

  n = rdf_objects.UserNotification(
      username=username,
      notification_type=notification_type,
      state=rdf_objects.UserNotification.State.STATE_PENDING,
      message=message,
      reference=object_reference)
  data_store.REL_DB.WriteUserNotification(n)
937104
async def notify(self, *args):
        
        from .filters import check_filters, FilterNotPassed

        results = []

        data = {}
        ctx_data.set(data)

        if self.middleware_key:
            try:
                await self.dispatcher.middleware.trigger(f"pre_process_{self.middleware_key}", args + (data,))
            except CancelHandler:  # Allow to cancel current event
                return results

        try:
            for handler_obj in self.handlers:
                try:
                    data.update(await check_filters(handler_obj.filters, args))
                except FilterNotPassed:
                    continue
                else:
                    ctx_token = current_handler.set(handler_obj.handler)
                    try:
                        if self.middleware_key:
                            await self.dispatcher.middleware.trigger(f"process_{self.middleware_key}", args + (data,))
                        partial_data = _check_spec(handler_obj.spec, data)
                        response = await handler_obj.handler(*args, **partial_data)
                        if response is not None:
                            results.append(response)
                        if self.once:
                            break
                    except SkipHandler:
                        continue
                    except CancelHandler:
                        break
                    finally:
                        current_handler.reset(ctx_token)
        finally:
            if self.middleware_key:
                await self.dispatcher.middleware.trigger(f"post_process_{self.middleware_key}",
                                                         args + (results, data,))

        return results
498099
def notifications(factory_id, opts = {})
      data, _status_code, _headers = notifications_with_http_info(factory_id, opts)
      return data
    end
129790
def tokenizer(self):
        
        domain = 0
        if domain not in self.domains:
            self.register_domain(domain=domain)
        return self.domains[domain].tokenizer
1080463
def get_new_messages(self, domain):
        
        if domain not in self.domains:
            raise ValueError('Invalid domain: {0}'.format(domain))

        if domain not in self.messages or 'new' not in self.messages[domain]:
            self._process_domain(domain)

        return self.messages[domain]['new']
1000834
def notify(title, message, **kwargs):
    
    for os in ['linux', 'win32', 'darwin']:
        if platform.startswith(os):
            module = import_module('ntfy.backends.{}'.format(os))
            try:
                module.notify(title=title, message=message, **kwargs)
            except Exception as e:
                raise DefaultNotifierError(e, module)
            break
1057017
def notify(request, info):
    '''
    '''
    t = time()
    actor = request.actor
    remote_actor = request.caller
    if isinstance(remote_actor, ActorProxyMonitor):
        remote_actor.mailbox = request.connection
        info['last_notified'] = t
        remote_actor.info = info
        callback = remote_actor.callback
        # if a callback is still available, this is the first
        # time we got notified
        if callback:
            remote_actor.callback = None
            callback.set_result(remote_actor)
            if actor.cfg.debug:
                actor.logger.debug('Got first notification from %s',
                                   remote_actor)
        elif actor.cfg.debug:
            actor.logger.debug('Got notification from %s', remote_actor)
    else:
        actor.logger.warning('notify got a bad actor')
    return t
622092
def notify(self, resource, root=None):
        
        ret = []
        if root is not None:
            resource_list = root.with_prefix_resource(resource.path)
        else:
            resource_list = [resource]
        for key in list(self._relations.keys()):
            if self._relations[key].transaction.resource in resource_list:
                if self._relations[key].non_counter > defines.MAX_NON_NOTIFICATIONS \
                        or self._relations[key].transaction.request.type == defines.Types["CON"]:
                    self._relations[key].transaction.response.type = defines.Types["CON"]
                    self._relations[key].non_counter = 0
                elif self._relations[key].transaction.request.type == defines.Types["NON"]:
                    self._relations[key].non_counter += 1
                    self._relations[key].transaction.response.type = defines.Types["NON"]
                self._relations[key].transaction.resource = resource
                del self._relations[key].transaction.response.mid
                del self._relations[key].transaction.response.token
                ret.append(self._relations[key].transaction)
        return ret
655922
def get_current_notification(self):
        
        log.debug("getting visible notification...")
        cmd, url = DEVICE_URLS["get_current_notification"]
        return self._exec(cmd, url)
643642
def auth(self):
        
        if self._auth is None:
            self._auth = AuthTypesList(
                self._version,
                account_sid=self._solution['account_sid'],
                domain_sid=self._solution['sid'],
            )
        return self._auth
394622
def notify(class_):
		
		# TODO: Implement Microsoft UIPI (User Interface Privilege Isolation) to
		#  elevate privilege to system level so the system gets this notification
		# for now, this must be run as admin to work as expected
		return_val = ctypes.wintypes.DWORD()
		res = message.SendMessageTimeout(
			message.HWND_BROADCAST,
			message.WM_SETTINGCHANGE,
			0,  # wparam must be null
			'Environment',
			message.SMTO_ABORTIFHUNG,
			5000,  # timeout in ms
			return_val,
		)
		error.handle_nonzero_success(res)