Shortcut to rdflib add function
        :param subj:
        :param pred:
        :param obj:
        :return: self for chaining
777139
def add(self, subj: Node, pred: URIRef, obj: Node) -> "FHIRResource":
        
        self._g.add((subj, pred, obj))
        return self
663951
def _add_command(parser, subparser_fn, handler, cell_required=False,
                 cell_prohibited=False):
  
  sub_parser = subparser_fn(parser)
  sub_parser.set_defaults(func=lambda args, cell: _dispatch_handler(
      args, cell, sub_parser, handler, cell_required=cell_required,
      cell_prohibited=cell_prohibited))
43494
def qs_add(self, *args, **kwargs):
        ''''''
        query = self.query.copy()
        if args:
            mdict = MultiDict(args[0])
            for k, v in mdict.items():
                query.add(k, v)
        for k, v in kwargs.items():
            query.add(k, v)
        return self._copy(query=query)
343534
function createSubscription (state, fn, options, context) {
    return {
      id: state.id(),
      fn: typeof fn === 'function' ? fn : noop,
      suspended: false,
      priority: +options.priority || 0,
      context: context || null
    };
  }
1143814
function injectSubClasses (_object) {
  var object = _object
  for (var key in object) {
    if (~key.indexOf('__')) {
      var keySplit = key.split('__')
      var parentkey = keySplit[0]
      var newKey = keySplit.slice(1).join('__')

      object[parentkey] = object[parentkey] || {}
      object[parentkey][newKey] = object[key]

      if (~newKey.indexOf('__')) {
        // do it recursively
        object[parentkey] = injectSubClasses(object[parentkey])
      }

      delete object[key]
    }
  }
  return object
}
800115
def add_wf(self,wf_obj):
        
        if self.text_layer is None:
            self.text_layer = Ctext(type=self.type)
            self.root.append(self.text_layer.get_node())
        self.text_layer.add_wf(wf_obj)
1136661
def _add_public_adder(self):
        
        def add_child(obj):
            private_add_method = getattr(obj, self._add_method_name)
            child = private_add_method()
            return child

        add_child.__doc__ = (
            'Add a new ``<%s>`` child element unconditionally, inserted in t'
            'he correct sequence.' % self._nsptagname
        )
        self._add_to_class(self._public_add_method_name, add_child)
981541
def add_object(self, obj):
        

        # delegate to SchemaType object
        schema_generator = self._get_generator_for_object(obj)
        schema_generator.add_object(obj)

        # return self for easy method chaining
        return self
1167667
def add_statement(key, obj)
      if obj.is_a?(RDF::Statement)
        @source[normalize_key(key)] = obj 
        local_repository << obj
      end
    end
65136
def add_callback(obj, callback, args=()):
    """"""
    callbacks = obj._callbacks
    node = Node(callback, args)
    # Store a single callback directly in _callbacks
    if callbacks is None:
        obj._callbacks = node
        return node
    # Otherwise use a dllist.
    if not isinstance(callbacks, dllist):
        obj._callbacks = dllist()
        obj._callbacks.insert(callbacks)
        callbacks = obj._callbacks
    callbacks.insert(node)
    return node
49297
def add_object(self, obj):
        """"""
        if _debug: Application._debug("add_object %r", obj)

        # extract the object name and identifier
        object_name = obj.objectName
        if not object_name:
            raise RuntimeError("object name required")
        object_identifier = obj.objectIdentifier
        if not object_identifier:
            raise RuntimeError("object identifier required")

        # assuming the object identifier is well formed, check the instance number
        if (object_identifier[1] >= ObjectIdentifier.maximum_instance_number):
            raise RuntimeError("invalid object identifier")

        # make sure it hasn't already been defined
        if object_name in self.objectName:
            raise RuntimeError("already an object with name %r" % (object_name,))
        if object_identifier in self.objectIdentifier:
            raise RuntimeError("already an object with identifier %r" % (object_identifier,))

        # now put it in local dictionaries
        self.objectName[object_name] = obj
        self.objectIdentifier[object_identifier] = obj

        # append the new object's identifier to the local device's object list
        # if there is one and it has an object list property
        if self.localDevice and self.localDevice.objectList:
            self.localDevice.objectList.append(object_identifier)

        # let the object know which application stack it belongs to
        obj._app = self
1080499
def add(self, callback=None, name=None, shortcut=None, alias=None,
            docstring=None, menu=None, verbose=True):
        """"""
        if callback is None:
            # Allow to use either add(func) or @add or @add(...).
            return partial(self.add, name=name, shortcut=shortcut,
                           alias=alias, menu=menu)
        assert callback

        # Get the name from the callback function if needed.
        name = name or callback.__name__
        alias = alias or _alias(name)
        name = name.replace('&', '')
        shortcut = shortcut or self._default_shortcuts.get(name, None)

        # Skip existing action.
        if name in self._actions_dict:
            return

        # Set the status tip from the function's docstring.
        docstring = docstring or callback.__doc__ or name
        docstring = re.sub(r'[ \t\r\f\v]{2,}', ' ', docstring.strip())

        # Create and register the action.
        action = _create_qaction(self.gui, name, callback,
                                 shortcut,
                                 docstring=docstring,
                                 alias=alias,
                                 )
        action_obj = Bunch(qaction=action, name=name, alias=alias,
                           shortcut=shortcut, callback=callback, menu=menu)
        if verbose and not name.startswith('_'):
            logger.log(5, "Add action `%s` (%s).", name,
                       _get_shortcut_string(action.shortcut()))
        self.gui.addAction(action)
        # Add the action to the menu.
        menu = menu or self.menu
        # Do not show private actions in the menu.
        if menu and not name.startswith('_'):
            self.gui.get_menu(menu).addAction(action)
        self._actions_dict[name] = action_obj
        # Register the alias -> name mapping.
        self._aliases[alias] = name

        # Set the callback method.
        if callback:
            setattr(self, name, callback)
407542
def _add_reference(self, obj, ident=0):
        
        log_debug(
            "## New reference handle 0x{0:X}: {1} -> {2}".format(
                len(self.references) + self.BASE_REFERENCE_IDX,
                type(obj).__name__,
                repr(obj),
            ),
            ident,
        )
        self.references.append(obj)
450865
def make_triple(sub, pred, obj):
    
    return "{s} {p} {o} .".format(s=sub, p=pred, o=obj)
1083771
def __sub_add_reference(self, key):
        """"""
        new_subs = self.__new_subs
        with new_subs:
            # don't allow multiple subscription requests to overwrite internal reference
            if key in new_subs:
                raise ValueError('subscription for given args pending: %s' % str(key))
            new_subs[key] = None
        try:
            yield
        except:
            # don't preserve reference if request creation failed
            with new_subs:
                new_subs.pop(key, None)
            raise
827090
def _add_junction(item):
    '''
    
    '''
    type_, channels = _expand_one_key_dictionary(item)
    junction = UnnamedStatement(type='junction')
    for item in channels:
        type_, value = _expand_one_key_dictionary(item)
        channel = UnnamedStatement(type='channel')
        for val in value:
            if _is_reference(val):
                _add_reference(val, channel)
            elif _is_inline_definition(val):
                _add_inline_definition(val, channel)
        junction.add_child(channel)
    _current_statement.add_child(junction)
339874
function addReturnNode(ast: Object): Object {
  const statements = ast.program.body;
  const lastStatement = statements[statements.length - 1];
  return statements
    .slice(0, -1)
    .concat(t.returnStatement(lastStatement.expression));
}