:calls: `GET /user/subscriptions/:owner/:repo <http://developer.github.com/v3/activity/watching>`_
        :param subscription: :class:`github.Repository.Repository`
        :rtype: bool
975882
def has_in_subscriptions(self, subscription):
        
        assert isinstance(subscription, github.Repository.Repository), subscription
        status, headers, data = self._requester.requestJson(
            "GET",
            "/user/subscriptions/" + subscription._identity
        )
        return status == 204
1027755
def subscribe(self, subscription_channel, **observer_params):
        
        return self.get_channel(subscription_channel, **observer_params).ensure_started().observer
1211166
def subscribe(self, py3_module, trigger_action, subsystem):
        
        if self.pyudev_available:
            # lazy load the udev monitor
            if self.udev_observer is None:
                self._setup_pyudev_monitoring()
            if trigger_action not in ON_TRIGGER_ACTIONS:
                self.py3_wrapper.log(
                    "module %s: invalid action %s on udev events subscription"
                    % (py3_module.module_full_name, trigger_action)
                )
                return False
            self.udev_consumers[subsystem].append((py3_module, trigger_action))
            self.py3_wrapper.log(
                "module %s subscribed to udev events on %s"
                % (py3_module.module_full_name, subsystem)
            )
            return True
        else:
            self.py3_wrapper.log(
                "pyudev module not installed: module %s not subscribed to events on %s"
                % (py3_module.module_full_name, subsystem)
            )
            return False
1074922
def getLoader(user, repo, sha=None, prov=None):
    """"""
    if user is None and repo is None:
        loader = LocalLoader()
    else:
        loader = GithubLoader(user, repo, sha, prov)
    return loader
225403
function (object, property, id) {
  this.subscription.subscribe(object, property, id);
  return this._get(object, property);
}
189757
def subscribe(self, user, verbose=None):
        
        if not self.email_enabled:
            raise EmailNotEnabledError("See settings.EMAIL_ENABLED")
        if not user.email:
            raise UserEmailError(f"User {user}'s email address is not defined.")
        response = requests.post(
            f"{self.api_url}/{self.address}/members",
            auth=("api", self.api_key),
            data={
                "subscribed": True,
                "address": user.email,
                "name": f"{user.first_name} {user.last_name}",
                "description": f'{user.userprofile.job_title or ""}',
                "upsert": "yes",
            },
        )
        if verbose:
            sys.stdout.write(
                f"Subscribing {user.email} to {self.address}. "
                f"Got response={response.status_code}.\n"
            )
        return response
1319281
def user_organization_subscriptions(self, user_id, **kwargs):
        ""
        api_path = "/api/v2/users/{user_id}/organization_subscriptions.json"
        api_path = api_path.format(user_id=user_id)
        return self.call(api_path, **kwargs)
515782
def select_subscription(subs_code, subscriptions):
    
    if subs_code and subscriptions:
        for subs in subscriptions:
            if (subs.subscription_code == subs_code):
                return subs
    return None
253633
def _get_subscriptions_endpoint(self):
        

        s = self.settings()

        params = {
            'access_token': self.app_access_token,
        }

        return (
            GRAPH_ENDPOINT.format(f'{s["app_id"]}/subscriptions'),
            params,
        )
1083570
def organization_subscription_show(self, id, **kwargs):
        ""
        api_path = "/api/v2/organization_subscriptions/{id}.json"
        api_path = api_path.format(id=id)
        return self.call(api_path, **kwargs)
1279211
def is_subscribed(self):
		""""""

		subscribed = next(
			(
				config_item['value'] == 'true'
				for config_item in self.config()
				if config_item['key'] == 'isNautilusUser'
			),
			None
		)

		if subscribed:
			self.tier = 'aa'
		else:
			self.tier = 'fr'

		return subscribed
1161206
def get_recurring_bill_by_subscription(self, subscription_id):
        
        params = {
            "subscriptionId": subscription_id,
        }
        return self.client._get(self.url + 'recurringBill', params=params, headers=self.get_headers())
1265345
public function watchRepository(): bool
    {
        $this->getApi()->request($this->getApi()
                                      ->sprintf('/user/subscriptions/:owner/:repo', $this->getActivity()->getOwner(),
                                          $this->getActivity()->getRepo()), Request::METHOD_PUT);

        if ($this->getApi()->getHeaders()['Status'] == '204 No Content') {
            return true;
        }

        return false;
    }
755745
def find_subscription(self, identifier):
        
        for subscription in self.subscriptions.values():
            if subscription.identifier == identifier:
                return subscription
584308
async def _get_subscriptions(self) -> Tuple[Set[Text], Text]:
        

        url, params = self._get_subscriptions_endpoint()

        get = self.session.get(url, params=params)

        async with get as r:
            await self._handle_fb_response(r)
            data = await r.json()

            for scope in data['data']:
                if scope['object'] == 'page':
                    return (
                        set(x['name'] for x in scope['fields']),
                        scope['callback_url'],
                    )

        return set(), ''
544870
def _get_repos(url):
        
        current_page = 1
        there_is_something_left = True
        repos_list = []

        while there_is_something_left:
            api_driver = GithubRawApi(
                url,
                url_params={"page": current_page},
                get_api_content_now=True
            )  # driver to parse API content

            for repo in api_driver.api_content:  # list of raw repository
                repo_name = repo["name"]
                repo_user = repo["owner"]["login"]
                repos_list.append(
                    GithubUserRepository(repo_user, repo_name))

            there_is_something_left = bool(api_driver.api_content)
            current_page += 1

        return repos_list
1237690
public function stopWatchingRepository(): bool
    {
        $this->getApi()->request($this->getApi()
                                      ->sprintf('/user/subscriptions/:owner/:repo', $this->getActivity()->getOwner(),
                                          $this->getActivity()->getRepo()), Request::METHOD_DELETE);

        if ($this->getApi()->getHeaders()['Status'] == '204 No Content') {
            return true;
        }

        return false;
    }