Call term in module.
    ``term``: a Term or term handle
497920
def call(*terms, **kwargs):
    
    for kwarg in kwargs:
        if kwarg not in ["module"]:
            raise KeyError

    module = kwargs.get("module", None)

    t = terms[0]
    for tx in terms[1:]:
        t = _comma(t, tx)

    return PL_call(t.handle, module)
312341
def or_call(self, _callable, *args, **kwargs):
        
        if self._exception:
            _callable(*args, **kwargs)
54266
function Handler(tagman,prefix) {
	if (!prefix) {
		prefix='';
	} else {
		prefix=prefix.replace(/^\/+|\/+$/gm,'');
	}
	this.prefix=prefix;
	this.tagman=tagman.q;
}
629916
def add_term(set_id, term, access_token):
    
    api_call('post', 'sets/{}/terms'.format(set_id), term.to_dict(), access_token=access_token)
954716
def on_term(term_node)
      if defined? @separate_by_comma
        remove_instance_variable(:@separate_by_comma)
      end
      process(term_node.function)
      bel_string << '('
      term_node.arguments.each { |arg| process(arg) }
      bel_string << ')'
    end
663790
def call(self, tag_name: str, *args, **kwargs):
        """"""
        if hasattr(self, tag_name):
            getattr(self, tag_name)(*args, **kwargs)
1359529
def setterm(self, term):
        ""
        log.debug("Setting termtype to %s" % (term, ))
        curses.setupterm(term) # This will raise if the termtype is not supported
        self.TERM = term
        self.ESCSEQ = {}
        for k in self.KEYS.keys():
            str = curses.tigetstr(curses.has_key._capability_names[k])
            if str:
                self.ESCSEQ[str] = k
        # Create a copy to prevent altering the class
        self.CODES = self.CODES.copy()
        self.CODES['DEOL'] = curses.tigetstr('el')
        self.CODES['DEL'] = curses.tigetstr('dch1')
        self.CODES['INS'] = curses.tigetstr('ich1')
        self.CODES['CSRLEFT'] = curses.tigetstr('cub1')
        self.CODES['CSRRIGHT'] = curses.tigetstr('cuf1')
222907
def visit_Call(self, node):
        """"""
        self.generic_visit(node)

        # Setup() is a keywords-only function.
        if node.args:
            return

        keywords = set()
        for k in node.keywords:
            if k.arg is not None:
                keywords.add(k.arg)
            # Simple case for dictionary expansion for Python >= 3.5.
            if k.arg is None and isinstance(k.value, ast.Dict):
                keywords.update(x.s for x in k.value.keys)
        # Simple case for dictionary expansion for Python <= 3.4.
        if getattr(node, 'kwargs', ()) and isinstance(node.kwargs, ast.Dict):
            keywords.update(x.s for x in node.kwargs.keys)

        # The bare minimum number of arguments seems to be around five, which
        # includes author, name, version, module/package and something extra.
        if len(keywords) < 5:
            return

        score = sum(
            self.attributes.get(x, 0)
            for x in keywords
        ) / len(keywords)

        if score < 0.5:
            LOG.debug(
                "Scoring for setup%r below 0.5: %.2f",
                tuple(keywords),
                score)
            return

        # Redirect call to our setup() tap function.
        node.func = ast.Name(id='__f8r_setup', ctx=node.func.ctx)
        self.redirected = True
665084
function _term_link(in_args){

	if( ! in_args ){ in_args = {}; }
	var default_args =
	    {
		acc: ''
	    };
	var final_args = bbop.core.fold(default_args, in_args);
	
	var acc = final_args['acc'];
	//return 'term_details?term=' + acc;
	return 'amigo?mode=golr_term_details&term=' + acc;
    }
638640
function toFunction(term){
    return eval(transmogrify(
      function(varName, body){ return "(function("+varName+"){return "+body+"})"; },
      function(fun, arg){ return fun+"("+arg+")"; })
      (term));
  }
648294
def project(self, term, **kwargs):
        
        params = kwargs
        baseuri = self._BASE_URI + 'projects/' + term
        res = self.session.get(baseuri, params=params)
        self.handle_http_error(res)
        return res
1359428
def _handle_dl_term(self):
        """"""
        self._context ^= contexts.DL_TERM
        if self._read() == ":":
            self._handle_list_marker()
        else:
            self._emit_text("\n")
1348682
def _args(self, term, d):
        

        # Get the term value name, the property name that should be assigned to the term value.
        tvm = self.doc.decl_terms.get(term, {}).get('termvaluename', '@value')

        # Convert the keys to lower case

        lower_d = {k.lower(): v for k, v in d.items()}

        args = []
        for n in [tvm] + self.property_names:
            args.append(lower_d.get(n.lower(), ''))

            try:
                del lower_d[n.lower()]
            except KeyError:
                pass

        return term, args, lower_d
1327365
def load_terms(self, terms):
        """"""

        #if self.root and len(self.root.children) > 0:
        #    raise MetatabError("Can't run after adding terms to document.")

        for t in terms:

            t.doc = self

            if t.term_is('root.root'):
                if not self.root:
                    self.root = t
                    self.add_section(t)

                continue

            if t.term_is('root.section'):
                self.add_section(t)

            elif t.parent_term_lc == 'root':
                self.add_term(t)

            else:
                # These terms aren't added to the doc because they are attached to a
                # parent term that is added to the doc.
                assert t.parent is not None


        try:
            dd = terms.declare_dict

            self.decl_terms.update(dd['terms'])
            self.decl_sections.update(dd['sections'])

            self.super_terms.update(terms.super_terms())

            kf = lambda e: e[1]  # Sort on the value
            self.derived_terms ={ k:set( e[0] for e in g)
                                  for k, g in groupby(sorted(self.super_terms.items(), key=kf), kf)}

        except AttributeError as e:
            pass

        try:
            self.errors = terms.errors_as_dict()
        except AttributeError:
            self.errors = {}

        return self
415652
def resolve_name(name):
    

    parts = name.split('.')
    cursor = len(parts) - 1
    module_name = parts[:cursor]
    attr_name = parts[-1]

    while cursor > 0:
        try:
            ret = __import__('.'.join(module_name), fromlist=[attr_name])
            break
        except ImportError:
            if cursor == 0:
                raise
            cursor -= 1
            module_name = parts[:cursor]
            attr_name = parts[cursor]
            ret = ''

    for part in parts[cursor:]:
        try:
            ret = getattr(ret, part)
        except AttributeError:
            raise ImportError(name)

    return ret
936716
def callwith(context_manager):
    
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwds):
            with context_manager:
                return func(*args, **kwds)
        return wrapper
    return decorator
881336
def p_term_string(self, p):
        '''  
        '''
        _LOGGER.debug("term -> STRING")
        
        p[0] = TypedClass(p[1], TypedClass.STRING)