https://developers.coinbase.com/api/v2#list-notifications
485193
def get_notifications(self, **params):
        """"""
        response = self._get('v2', 'notifications', params=params)
        return self._make_api_object(response, Notification)
6448
def list_forwarding_addresses(api_key, offset=None, coin_symbol='btc'):
    '''
    
    '''

    assert is_valid_coin_symbol(coin_symbol)
    assert api_key

    url = make_url(coin_symbol, 'payments')

    params = {'token': api_key}

    if offset:
        params['start'] = offset

    r = requests.get(url, params=params, verify=True, timeout=TIMEOUT_IN_SECONDS)
    return get_valid_json(r)
513513
def get_notifications(user):
    ''''''
    notifications = []

    for name, func in _providers.items():
        notifications.extend([{
            'type': name,
            'created_on': dt,
            'details': details
        } for dt, details in func(user)])

    return notifications
1010321
async function getNotifications(config) {
  try {
    const options = {
      method: "GET",
      uri: `${config.obServer}:${config.obPort}/ob/notifications`,
      json: true, // Automatically stringifies the body to JSON
      headers: {
        Authorization: config.apiCredentials,
      },
      // resolveWithFullResponse: true
    };

    return rp(options);
  } catch (err) {
    console.error(`Error in openbazaar.js/getNotifications(): ${err}`);
    console.error(`Error stringified: ${JSON.stringify(err, null, 2)}`);
    throw err;
  }
}
36251
def _adopt_notifications(self, state):
        ''''''

        def iterator():
            it = state.descriptor.pending_notifications.iteritems()
            for _, nots in it:
                for x in nots:
                    yield x

        to_adopt = list(iterator())
        self.info("Will adopt %d pending notifications.", len(to_adopt))
        return state.sender.notify(to_adopt)
673448
public static function setup_notifications() {
		$notifications       = apply_filters( 'themeisle_sdk_registered_notifications', [] );
		$notifications       = array_filter(
			$notifications,
			function ( $value ) {
				if ( ! isset( $value['id'] ) ) {
					return false;
				}
				if ( get_option( $value['id'], '' ) !== '' ) {
					return false;
				}

				return apply_filters( $value['id'] . '_should_show', true );
			}
		);
		self::$notifications = $notifications;
	}
296854
def apps_notify_create(self, data, **kwargs):
        ""
        api_path = "/api/v2/apps/notify.json"
        return self.call(api_path, method="POST", data=data, **kwargs)
131927
def api_notifications():
    """"""
    event_type = request.values['Event.1.EventType']
    assignment_id = request.values['Event.1.AssignmentId']

    # Add the notification to the queue.
    db.logger.debug('rq: Queueing %s with id: %s for worker_function',
                    event_type, assignment_id)
    q.enqueue(worker_function, event_type, assignment_id, None)
    db.logger.debug('rq: Submitted Queue Length: %d (%s)', len(q),
                    ', '.join(q.job_ids))

    return success_response(request_type="notification")
1274093
public ListNotificationsResponse listNotifications() {
        ListNotificationsRequest request = new ListNotificationsRequest();
        InternalRequest internalRequest = createRequest(HttpMethodName.GET, request, LIVE_NOTIFICATION);
        return invokeHttpClient(internalRequest, ListNotificationsResponse.class);
    }
1161031
def notifications_view(request):
    
    page_name = "Your Notifications"
    # Copy the notifications so that they are still unread when we render the page
    notifications = list(request.user.notifications.all())
    request.user.notifications.mark_all_as_read()
    return render_to_response("list_notifications.html", {
        "page_name": page_name,
        "notifications": notifications,
        }, context_instance=RequestContext(request))
498099
def notifications(factory_id, opts = {})
      data, _status_code, _headers = notifications_with_http_info(factory_id, opts)
      return data
    end
968143
function checkForNotification(versionInfoUrl) {
        var result = new $.Deferred();

        _getNotificationInformation(versionInfoUrl)
            .done(function (notificationInfo) {
                // Get all available notifications
                var notifications = notificationInfo.notifications;
                if (notifications && notifications.length > 0) {
                    // Iterate through notifications and act only on the most recent
                    // applicable notification
                    notifications.every(function(notificationObj) {
                        // Only show the notification overlay if the user hasn't been
                        // alerted of this notification
                        if (_checkNotificationValidity(notificationObj)) {
                            if (notificationObj.silent) {
                                // silent notifications, to gather user validity based on filters
                                HealthLogger.sendAnalyticsData("notification", notificationObj.sequence, "handled");
                            } else {
                                showNotification(notificationObj);
                            }
                            // Break, we have acted on one notification already
                            return false;
                        }
                        // Continue, we haven't yet got a notification to act on
                        return true;
                    });
                }
                result.resolve();
            })
            .fail(function () {
                // Error fetching the update data. If this is a forced check, alert the user
                result.reject();
            });

        return result.promise();
    }
168070
async def listen_all_notifications(self, callback):
        
        everything = [noti.asdict() for noti in self.notifications]
        if len(everything) > 0:
            await self._methods["switchNotifications"](
                {"enabled": everything}, _consumer=callback
            )
        else:
            _LOGGER.debug("No notifications available for %s", self.name)
533430
def get_notifications(self, login=None, **kwargs):
        

        _login = kwargs.get(
            'login',
            login or self._login
        )
        _notif_url = NOTIF_URL.format(login=_login)
        return self._request_api(url=_notif_url).json()
18746
def get_notifications(self, start=None, stop=None, *args, **kwargs):
        
        filter_kwargs = {}
        # Todo: Also support sequencing by 'position' if items are sequenced by timestamp?
        if start is not None:
            filter_kwargs['%s__gte' % self.notification_id_name] = start + 1
        if stop is not None:
            filter_kwargs['%s__lt' % self.notification_id_name] = stop + 1
        objects = self.record_class.objects.filter(**filter_kwargs)

        if hasattr(self.record_class, 'application_name'):
            objects = objects.filter(application_name=self.application_name)
        if hasattr(self.record_class, 'pipeline_id'):
            objects = objects.filter(pipeline_id=self.pipeline_id)

        objects = objects.order_by('%s' % self.notification_id_name)
        return objects.all()
358422
public function listNotifications(bool $all = false, bool $participating = false, string $since = 'now',
                                      string $before = null): array
    {
        return $this->getApi()->request($this->getApi()->sprintf('/notifications?:args', http_build_query([
            'all'           => $all,
            'participating' => $participating,
            'since'         => (new DateTime($since))->format(DateTime::ATOM),
            'before'        => (new DateTime($before))->format(DateTime::ATOM)
        ])));
    }
212782
public void getNotifications(Patient patient, Collection<Notification> result) {
        List<String> lst = null;
        result.clear();

        if (patient == null) {
            lst = broker.callRPCList("RGCWXQ ALRLIST", null);
        } else if (patient != null) {
            lst = broker.callRPCList("RGCWXQ ALRLIST", null, patient.getIdElement().getIdPart());
        }

        if (lst != null) {
            for (String item : lst) {
                result.add(new Notification(item));
            }
        }
    }