Provide access to the notification origin.

        Returns:
            str: The notification origin.
516288
def origin(self):
        
        with self.selenium.context(self.selenium.CONTEXT_CHROME):
            return self.root.get_attribute("origin")
193356
def allow_origin(self, request):
        # type: (BaseHttpRequest) -> str
        
        origins = self.origins
        if origins is AnyOrigin:
            return '*'
        else:
            origin = request.origin
            return origin if origin in origins else ''
501947
def path_get_origin(p: tcod.path.AStar) -> Tuple[int, int]:
    
    x = ffi.new("int *")
    y = ffi.new("int *")
    lib.TCOD_path_get_origin(p._path_c, x, y)
    return x[0], y[0]
1165515
async def get_notifications(self) -> List[Notification]:
        
        notifications = []
        for serv in self.services:
            for notification in self.services[serv].notifications:
                notifications.append(notification)
        return notifications
738060
def _get_origin(event):
    
    if event.preferred_origin() is not None:
        origin = event.preferred_origin()
    elif len(event.origins) > 0:
        origin = event.origins[0]
    else:
        raise IndexError('No origin set, cannot constrain')
    return origin
142014
def notification_rules(self, **kwargs):
        """"""
        endpoint = '{0}/{1}/notification_rules'.format(
            self.endpoint,
            self['id'],
        )
        result = self.request('GET', endpoint=endpoint, query_params=kwargs)
        return result['notification_rules']
521321
def register(self, notification_cls=None):
        
        self.loaded = True
        display_names = [n.display_name for n in self.registry.values()]
        if (
            notification_cls.name not in self.registry
            and notification_cls.display_name not in display_names
        ):
            self.registry.update({notification_cls.name: notification_cls})

            models = getattr(notification_cls, "models", [])
            if not models and getattr(notification_cls, "model", None):
                models = [getattr(notification_cls, "model")]
            for model in models:
                try:
                    if notification_cls.name not in [
                        n.name for n in self.models[model]
                    ]:
                        self.models[model].append(notification_cls)
                except KeyError:
                    self.models.update({model: [notification_cls]})
        else:
            raise AlreadyRegistered(
                f"Notification {notification_cls.name}: "
                f"{notification_cls.display_name} is already registered."
            )
484209
def get_ip():
    
    try:
        r = requests.get(HTTPBIN_URL)
        ip, _ = r.json()['origin'].split(',')
        return ip if r.status_code == 200 else None
    except requests.exceptions.ConnectionError:
        return None
135736
def check_origin(self, origin):
        

        mod_opts = self.application.mod_opts

        if mod_opts.get('cors_origin'):
            return bool(_check_cors_origin(origin, mod_opts['cors_origin']))
        else:
            return super(AllEventsHandler, self).check_origin(origin)
326184
protected function proxy() {
        if (!$this->context) {
            $this->context = new NotificationContext(
                $this->version,
                $this->solution['accountSid'],
                $this->solution['callSid'],
                $this->solution['sid']
            );
        }

        return $this->context;
    }
835085
def notifications_get(input_params={}, always_retry=True, **kwargs):
    
    return DXHTTPRequest('/notifications/get', input_params, always_retry=always_retry, **kwargs)
1236061
def fetch(self, origination_number=values.unset):
        
        params = values.of({'OriginationNumber': origination_number, })

        payload = self._version.fetch(
            'GET',
            self._uri,
            params=params,
        )

        return NumberInstance(
            self._version,
            payload,
            destination_number=self._solution['destination_number'],
        )
496145
def get_notification(self, notification_id):
        
        log.debug("getting notification '{}'...".format(notification_id))
        cmd, url = DEVICE_URLS["get_notification"]
        return self._exec(cmd, url.replace(":id", notification_id))
24939
def on_origin(self, *args):
        """"""
        if self.origin is None:
            Clock.schedule_once(self.on_origin, 0)
            return
        self.origin.bind(
            pos=self._trigger_repoint,
            size=self._trigger_repoint
        )
975104
def origin(self):
        
        for item in os.popen('git remote -v'):
            split_item = item.strip().split()
            if split_item[0] == 'origin' and split_item[-1] == '(push)':
                return split_item[1]
1023723
def origination_urls(self):
        
        if self._origination_urls is None:
            self._origination_urls = OriginationUrlList(self._version, trunk_sid=self._solution['sid'], )
        return self._origination_urls
750218
def notifications(self):
        
        if self._notifications is None:
            self._notifications = NotificationList(self._version, account_sid=self._solution['sid'], )
        return self._notifications