Check all the information of a plan for subscriptions associated with the merchant.

        Args:
            plan_code: Plan’s identification code for the merchant.

        Returns:
507130
def get_plan(self, plan_code):
        
        return self.client._get(self.url + 'plans/{}'.format(plan_code), headers=self.get_headers())
62604
def check_bitstamp_code(self, code):
        
        data = {'code': code}
        return self._post("check_code/", data=data, return_json=True,
                          version=1)
323385
def with_code(self, code):
        
        self.code = code if code != None else 'UNKNOWN'
        self.name = code
        return self
1065905
def reqScannerSubscription(self, tickerId, subscription, scannerSubscriptionOptions):
        """"""
        return _swigibpy.EClientSocketBase_reqScannerSubscription(self, tickerId, subscription, scannerSubscriptionOptions)
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
290509
def getConId(self, contract_identifier):
        
        details = self.contractDetails(contract_identifier)
        if len(details["contracts"]) > 1:
            return details["m_underConId"]
        return details["m_summary"]["m_conId"]
197650
def reqScannerSubscription(self, tickerId, subscription, scannerSubscriptionOptions):
        """"""
        return _swigibpy.EClient_reqScannerSubscription(self, tickerId, subscription, scannerSubscriptionOptions)
835728
def check_transaction(self, code):
        
        response = self.get(url=self.config.TRANSACTION_URL % code)
        return PagSeguroNotificationResponse(response.content, self.config)
830404
def checkout_code(repository, checkout_directory, branch)
      CodeCache.repo(repository).checkout(:head, checkout_directory, branch) or raise "Unable to checkout repository #{repository}"
    end
811762
def list_subscriptions(self, target_id=None, ids=None, query_flags=None):
        
        query_parameters = {}
        if target_id is not None:
            query_parameters['targetId'] = self._serialize.query('target_id', target_id, 'str')
        if ids is not None:
            ids = ",".join(ids)
            query_parameters['ids'] = self._serialize.query('ids', ids, 'str')
        if query_flags is not None:
            query_parameters['queryFlags'] = self._serialize.query('query_flags', query_flags, 'str')
        response = self._send(http_method='GET',
                              location_id='70f911d6-abac-488c-85b3-a206bf57e165',
                              version='5.0-preview.1',
                              query_parameters=query_parameters)
        return self._deserialize('[NotificationSubscription]', self._unwrap_collection(response))
1113483
def update_subscription(netid, action, subscription_code, data_field=None):
    
    url = '{0}/subscription.json'.format(url_version())
    action_list = []

    if isinstance(subscription_code, list):
        for code in subscription_code:
            action_list.append(_set_action(
                netid, action, code, data_field))
    else:
        action_list.append(_set_action(
            netid, action, subscription_code, data_field))

    body = {'actionList': action_list}
    response = post_resource(url, json.dumps(body))
    return _json_to_subscription_post_response(response)
1020408
def register_update(self, model_alias, code):
        
        model_alias = self.get_model_alias(model_alias)

        def wrapper(update_layout):
            for item in self.tabs[model_alias]:
                if item.code == code:
                    item.layout_updates.append(update_layout)
            return update_layout
        return wrapper
730046
def get_code(self, code):
        
        # code= [code] if isinstance(code,str) else
        return self.new(self.data.loc[(slice(None), code), :])
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
1097999
def subscribe(self, observer):
        
        sid = self._sn
        self.observers[sid] = observer
        self._sn += 1
        return SubscribeID(self, sid)
212417
def plan(self):
        
        import ns1.rest.account
        return ns1.rest.account.Plan(self.config)
1172837
public Subscriptions getAccountSubscriptions(final String accountCode) {
        return doGET(Account.ACCOUNT_RESOURCE
                     + "/" + accountCode
                     + Subscriptions.SUBSCRIPTIONS_RESOURCE,
                     Subscriptions.class,
                     new QueryParams());
    }