Cancel market data subscription.

        https://interactivebrokers.github.io/tws-api/market_scanners.html

        Args:
            dataList: The scan data list that was obtained from
                :meth:`.reqScannerSubscription`.
511223
def cancelScannerSubscription(self, dataList: ScanDataList):
        
        self.client.cancelScannerSubscription(dataList.reqId)
        self.wrapper.endSubscription(dataList)
344479
boolean removeFilteredPolicy(String sec, String ptype, int fieldIndex, String... fieldValues) {
        boolean ruleRemoved = model.removeFilteredPolicy(sec, ptype, fieldIndex, fieldValues);
        if (!ruleRemoved) {
            return false;
        }

        if (adapter != null && autoSave) {
            try {
                adapter.removeFilteredPolicy(sec, ptype, fieldIndex, fieldValues);
            } catch (Error e) {
                if (!e.getMessage().equals("not implemented")) {
                    throw e;
                }
            }

            if (watcher != null) {
                // error intentionally ignored
                watcher.update();
            }
        }

        return true;
    }
1044312
function(s, args, ef) {

        this.log(this.type + "->" + "sub: " +  s.id);

        var ret;

        ret = s.notify(args, this);

        if (false === ret || this.stopped > 1) {
            this.log(this.type + " cancelled by subscriber");
            return false;
        }

        return true;
    }
221548
def cancel_subscription(self, sid):
        
        url = urljoin(self._url_base, self._event_sub_url)
        headers = dict(
            HOST=urlparse(url).netloc,
            SID=sid
        )
        resp = requests.request('UNSUBSCRIBE', url, headers=headers, auth=self.device.http_auth)
        resp.raise_for_status()
593014
function DataList ( element, store, template ) {
	this.callback    = null;
	this.element     = element;
	this.emptyMsg    = "Nothing to display";
	this.filter      = null;
	this.filtered    = [];
	this.id          = utility.genId();
	this.pageIndex   = 1;
	this.pageSize    = null;
	this.pageRange   = 5;
	this.pagination  = "bottom"; // "top" or "bottom|top" are also valid
	this.placeholder = "";
	this.order       = "";
	this.records     = [];
	this.current     = [];
	this.template    = template;
	this.total       = 0;
	this.store       = store;
	this.where       = null;
}
776945
private boolean cancelRequestInternal(
    AORequestedTick requestedTick,
    boolean expiry)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(
        tc,
        "cancelRequestInternal",
        new Object[] { requestedTick, Boolean.valueOf(expiry)});

    // cancel the timer only if !expiry, since expiry implies timer has already occured.
    boolean transitionOccured = requestedTick.expire(!expiry);
    if (transitionOccured)
    { // successfully expired
      listOfRequests.remove(requestedTick);
      tableOfRequests.remove(requestedTick.objTick);

      // start the idle timer if no element left in listOfRequests
      // and set isready to false
      if (listOfRequests.isEmpty())
      {
        if (idleTimeout > 0)
          this.idleHandler = am.create(idleTimeout, this);
        if (isready)
        {
          isready = false;
          ck.notReady();
        }
      }
    } // end if (transitionOccured)

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "cancelRequestInternal", Boolean.valueOf(transitionOccured));

    return transitionOccured;
  }
1374288
def UninstallTrump(RemoveDataTables=True, RemoveOverrides=True, RemoveFailsafes=True):
    
    
    ts = ['_symbols', '_symbol_validity', '_symbol_tags', '_symbol_aliases', 
          '_feeds', '_feed_munging', '_feed_munging_args', '_feed_sourcing', 
          '_feed_validity', '_feed_meta', '_feed_tags', '_feed_handle', 
          '_index_kwargs', '_indicies', '_symbol_handle', '_symboldatadef']
    
    if RemoveOverrides:
        ts.append('_overrides')
        
    if RemoveFailsafes:
        ts.append('_failsafes')

    engine = create_engine(ENGINE_STR)
       
    if RemoveDataTables:
        results = engine.execute("SELECT name FROM _symbols;")
        datatables = [row['name'] for row in results]
        ts = ts + datatables
    
    drops = "".join(['DROP TABLE IF EXISTS "{}" CASCADE;'.format(t) for t in ts])
    
    engine.execute(drops)
17721
public void unsubscribe(Class<? extends Subscriber> subscriberType) {
        for (ArrayList<Class<? extends Subscriber>> list : subscriptionMap.values()) {
            list.remove(subscriberType);
        }
    }
134248
def unsubscribe_list(self, list_id):
        
        return List(tweepy_list_to_json(self._client.unsubscribe_list(list_id=list_id)))
21895
def cancel_lines(self, data=None):
        
        from ..resources.order_lines import OrderLines

        if data is None:
            data = {'lines': []}
        canceled = OrderLines(self.client).on(self).delete(data)
        return canceled
756081
private void rechecksqlistpl()
    {
    	if(data != null)
    	{
    		Node[] childrens = ((SimpleNode)data).getChildren();
    		if(childrens != null && childrens.length > 0)
    		{
    			boolean switchcase = true;
    			for(Node node:childrens)
    			{
    				if(!(node instanceof ASTText))
    				{
    					switchcase = false;
    					break;
    				}
    			}
    			if(switchcase)
    			{
    				this.esInfo.setTpl(false);
    				 
    			}
    			else
    			{
    				this.esInfo.setTpl(true);
    			}
    		}
    		
    	}
    }
882310
@Override
  public final void cancel(final Map<String, Object> pRqVs,
    final CustOrder pCuOr, final EOrdStat pStat) throws Exception {
    Set<String> ndFl = new HashSet<String>();
    String tbn = CustOrderGdLn.class.getSimpleName();
    ndFl.add("itsId");
    ndFl.add("quant");
    ndFl.add("good");
    pRqVs.put(tbn + "neededFields", ndFl);
    pRqVs.put(tbn + "gooddeepLevel", 1);
    List<CustOrderGdLn> gds = this.srvOrm.retrieveListWithConditions(
      pRqVs, CustOrderGdLn.class, "where ITSOWNER=" + pCuOr.getItsId());
    pRqVs.remove(tbn + "neededFields");
    pRqVs.remove(tbn + "gooddeepLevel");
    ColumnsValues cvsIil = new ColumnsValues();
    cvsIil.getFormula().add("availableQuantity");
    for (CustOrderGdLn gl : gds) {
      List<GoodsPlace> gps = getSrvOrm().retrieveListWithConditions(pRqVs,
        GoodsPlace.class, "where ISALWAYS=0 and ITEM="
          + gl.getGood().getItsId());
      if (gps.size() > 0) {
        gps.get(0)
          .setItsQuantity(gps.get(0).getItsQuantity().add(gl.getQuant()));
        getSrvOrm().updateEntity(pRqVs, gps.get(0));
        cvsIil.put("itsVersion", new Date().getTime());
        cvsIil.put("availableQuantity", "AVAILABLEQUANTITY+" + gl.getQuant());
        this.srvDb.executeUpdate("ITEMINLIST", cvsIil,
          "ITSTYPE=0 and ITEMID=" + gps.get(0).getItem().getItsId());
      }
    }
    tbn = CustOrderSrvLn.class.getSimpleName();
    ndFl.remove("good");
    ndFl.add("service");
    ndFl.add("dt1");
    ndFl.add("dt2");
    pRqVs.put(tbn + "neededFields", ndFl);
    pRqVs.put(tbn + "gooddeepLevel", 1);
    List<CustOrderSrvLn> sls = this.srvOrm.retrieveListWithConditions(
      pRqVs, CustOrderSrvLn.class, "where ITSOWNER=" + pCuOr.getItsId());
    pRqVs.remove(tbn + "neededFields");
    pRqVs.remove(tbn + "gooddeepLevel");
    for (CustOrderSrvLn sl : sls) {
      if (sl.getDt1() == null) { //non-bookable:
        List<ServicePlace> sps = getSrvOrm().retrieveListWithConditions(pRqVs,
          ServicePlace.class, "where ISALWAYS=0 and ITEM=" + sl.getService()
            .getItsId());
        if (sps.size() > 0) {
          sps.get(0)
            .setItsQuantity(sps.get(0).getItsQuantity().add(sl.getQuant()));
          getSrvOrm().updateEntity(pRqVs, sps.get(0));
          cvsIil.put("itsVersion", new Date().getTime());
          cvsIil.put("availableQuantity", "AVAILABLEQUANTITY+" + sl.getQuant());
          this.srvDb.executeUpdate("ITEMINLIST", cvsIil,
            "ITSTYPE=1 and ITEMID=" + sps.get(0).getItem().getItsId());
        }
      } else { //bookable:
        List<SerBus> sebs = getSrvOrm().retrieveListWithConditions(pRqVs,
      SerBus.class, "where FRE=0 and SERV=" + sl.getService().getItsId()
+ " and FRTM=" + sl.getDt1().getTime() + " and TITM=" + sl.getDt1().getTime());
        if (sebs.size() == 1) {
          sebs.get(0).setFre(true);
          getSrvOrm().updateEntity(pRqVs, sebs.get(0));
        } else if (sebs.size() > 1) {
          this.log.error(pRqVs, CncOrd.class,
        "Several SERBUS for booked service: " + sl.getService().getItsId()
      + "/"  + sl.getDt1().getTime() + "/" + sl.getDt1().getTime());
          for (SerBus seb : sebs) {
            seb.setFre(true);
            getSrvOrm().updateEntity(pRqVs, seb);
          }
        } else {
          this.log.error(pRqVs, CncOrd.class,
        "There is no SERBUS for booked service: " + sl.getService().getItsId()
      + "/"  + sl.getDt1().getTime() + "/" + sl.getDt1().getTime());
        }
      }
    }
    String[] fieldsNames = new String[] {"itsId", "itsVersion", "stat"};
    pRqVs.put("fieldsNames", fieldsNames);
    pCuOr.setStat(pStat);
    getSrvOrm().updateEntity(pRqVs, pCuOr);
    pRqVs.remove("fieldsNames");
  }
13952
def unlist(ctx, unlist_account, account):
    
    account = Account(account, blockchain_instance=ctx.blockchain)
    print_tx(account.nolist(unlist_account))
157552
def unsubscribe(self, code_list, subtype_list):
        

        ret, msg, code_list, subtype_list = self._check_subscribe_param(code_list, subtype_list)
        if ret != RET_OK:
            return ret, msg

        query_processor = self._get_sync_query_processor(SubscriptionQuery.pack_unsubscribe_req,
                                                         SubscriptionQuery.unpack_unsubscribe_rsp)

        kargs = {
            'code_list': code_list,
            'subtype_list': subtype_list,
            "conn_id": self.get_sync_conn_id()
        }

        for subtype in subtype_list:
            if subtype not in self._ctx_subscribe:
                continue
            code_set = self._ctx_subscribe[subtype]
            for code in code_list:
                if code not in code_set:
                    continue
                code_set.remove(code)

        ret_code, msg, _ = query_processor(**kargs)

        if ret_code != RET_OK:
            return RET_ERROR, msg

        ret_code, msg, unpush_req_str = SubscriptionQuery.pack_unpush_req(code_list, subtype_list, self.get_async_conn_id())
        if ret_code != RET_OK:
            return RET_ERROR, msg

        ret_code, msg = self._send_async_req(unpush_req_str)
        if ret_code != RET_OK:
            return RET_ERROR, msg

        return RET_OK, None
130947
def removeAboveValue(requestContext, seriesList, n):
    
    for s in seriesList:
        s.name = 'removeAboveValue(%s, %g)' % (s.name, n)
        s.pathExpression = s.name
        for (index, val) in enumerate(s):
            if val is None:
                continue
            if val > n:
                s[index] = None

    return seriesList
356846
@Override
    public void removeReadyConsumer(JSConsumerKey consumerKey, boolean bSelector)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "removeReadyConsumer",
                        new Object[] { consumerKey, Boolean.valueOf(bSelector) });

        if (consumerKey == null)
        {
            SIErrorException e =
                            new SIErrorException(
                                            nls.getFormattedMessage(
                                                                    "INTERNAL_MESSAGING_ERROR_CWSIP0001",
                                                                    new Object[] {
                                                                                  "com.ibm.ws.sib.processor.impl.ConsumerDispatcher",
                                                                                  "1:1684:1.280.5.25" },
                                                                    null));

            FFDCFilter.processException(
                                        e,
                                        "com.ibm.ws.sib.processor.impl.ConsumerDispatcher.removeReadyConsumer",
                                        "1:1690:1.280.5.25",
                                        this);

            SibTr.exception(tc, e);

            SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0001",
                        new Object[] {
                                      "com.ibm.ws.sib.processor.impl.ConsumerDispatcher",
                                      "1:1698:1.280.5.25" });

            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                SibTr.exit(tc, "removeReadyConsumer", e);

            throw e;
        }

        if (consumerKey.getForwardScanning())
        {
            //remove the consumer point from the FS ready list
            ((SimpleEntry) consumerKey).remove();
        }
        else
        {
            if (bSelector)
            {
                //decrement the specific ready consumer counter
                specificReadyConsumerCount--;

                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                    SibTr.debug(tc, "sepcificReadyConsumerCount:" + specificReadyConsumerCount);
            }
            else
            {
                //remove the consumer point from the ready list
                ((SimpleEntry) consumerKey).remove();
            }
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "removeReadyConsumer");
    }
874053
def cancelPnL(self, account, modelCode: str = ''):
        
        key = (account, modelCode)
        reqId = self.wrapper.pnlKey2ReqId.pop(key, None)
        if reqId:
            self.client.cancelPnL(reqId)
            self.wrapper.pnls.pop(reqId, None)
        else:
            self._logger.error(
                'cancelPnL: No subscription for '
                f'account {account}, modelCode {modelCode}')