def del_source_trace(self, val):
     """I break the link between this trace and one of its source traces
     """
     source_uri = coerce_to_uri(val)
     # do not trust edit, as there are many verifications to make
     with self.edit() as editable:
         editable.remove((self.uri, KTBS.hasSource, source_uri))

 def add_origin(self, origin):
     """
     I add an obsel type to this attribute.
     """
     origin_uri = coerce_to_uri(origin)
     with self.edit(_trust=True) as editable:
         editable.add((self.uri, _HAS_REL_ORIGIN, origin_uri))

 def remove_parent(self, model):
     """
     I remove model as a parent model to this model.
     """
     with self.edit(_trust=True) as graph:
         graph.remove((self.uri, KTBS.hasParentModel,
                       coerce_to_uri(model, self.uri)))

    def create_obsel_type(self, id=None, supertypes=(), label=None):
        """
        I create a new obsel type in this model.

        :param id: see :ref:`ktbs-resource-creation`
        :param supertypes: explain.
        :param label: explain.

        :rtype: `ObselTypeMixin`:class:
        """
        # redefining built-in 'id' #pylint: disable=W0622
        if id is None  and  label is None:
            raise ValueError("id or label must be supplied")
        uri = mint_uri_from_label(label, self, id)
        with self.edit(_trust=True) as graph:
            base_uri = self.uri
            graph_add = graph.add
            graph_add((uri, RDF.type, KTBS.ObselType))
            if label is not None:
                graph_add((uri, SKOS.prefLabel, Literal(label)))
            for i in supertypes:
                graph_add((uri, KTBS.hasSuperObselType,
                           coerce_to_uri(i, base_uri)))
        ret = self.factory(uri, [KTBS.ObselType])
        assert isinstance(ret, ObselTypeMixin)
        return ret

 def add_source_trace(self, val):
     """I add a source trace to this trace
     """
     source_uri = coerce_to_uri(val)
     # do not trust edit, as there are many verifications to make
     with self.edit() as editable:
         editable.add((self.uri, KTBS.hasSource, source_uri))

 def add_obsel_type(self, obsel_type):
     """
     I add an obsel type to this attribute.
     """
     obsel_type_uri = coerce_to_uri(obsel_type)
     with self.edit(_trust=True) as editable:
         editable.add((self.uri, _HAS_ATT_OBSELTYPE, obsel_type_uri))

def serialize_json_method(graph, method, bindings=None):

    valconv = ValueConverter(method.uri)
    valconv_uri = valconv.uri

    yield u"""{
    "@context": "%s",
    "@id": "%s",
    "@type": "Method",
    "hasParentMethod": "%s",
    "parameter": [""" % (
        CONTEXT_URI, method.uri, valconv_uri(coerce_to_uri(method.parent))
    )

    own_params = method.iter_parameters_with_values(False)
    yield u",".join(
        u"\n        %s" % dumps("%s=%s" % item)
        for item in own_params
    ) + "]"

    used_by = list(method.state.subjects(KTBS.hasMethod, method.uri))
    if used_by:
        yield  u""",\n        "isMethodOf": %s""" \
          % dumps([ valconv_uri(i) for i in used_by ])

    children = list(method.state.subjects(KTBS.hasParentMethod, method.uri))
    if children:
        yield  u""",\n        "isParentMethodOf": %s""" \
          % dumps([ valconv_uri(i) for i in children])

    for i in iter_other_arcs(graph, method.uri, valconv):
        yield i

    yield u""",\n    "inBase": "%s"\n}\n""" % valconv_uri(method.base.uri)

 def add_destination(self, destination):
     """
     I add an obsel type to this attribute.
     """
     destination_uri = coerce_to_uri(destination)
     with self.edit(_trust=True) as editable:
         editable.add((self.uri, _HAS_REL_DESTINATION, destination_uri))

 def remove_destination(self, destination):
     """
     I remove an obsel type from this attribute.
     """
     destination_uri = coerce_to_uri(destination)
     with self.edit(_trust=True) as editable:
         editable.remove((self.uri, _HAS_REL_DESTINATION, destination_uri))

 def remove_obsel_type(self, obsel_type):
     """
     I remove an obsel type from this attribute.
     """
     obsel_type_uri = coerce_to_uri(obsel_type)
     with self.edit(_trust=True) as editable:
         editable.remove((self.uri, _HAS_ATT_OBSELTYPE, obsel_type_uri))

 def remove_origin(self, origin):
     """
     I remove an obsel type from this attribute.
     """
     origin_uri = coerce_to_uri(origin)
     with self.edit(_trust=True) as editable:
         editable.remove((self.uri, _HAS_REL_ORIGIN, origin_uri))

 def remove_data_type(self, data_type):
     """
     I remove the data type from this attribute.
     """
     data_type_uri = coerce_to_uri(data_type)
     with self.edit(_trust=True) as editable:
         editable.remove((self.uri, _HAS_ATT_DATATYPE, data_type_uri))

def mint_uri_from_label(label, target, uri=None, suffix=""):
    """
    Mint a URI for a resource posted to `target` based on `label`.

    :param label:  the label for the resource to create
    :param target: the resource "containing" the resource to create
    :param uri:    if provided, will be used instead (must be fresh)
    :param suffix: if provided, will be added to the end of the URI

    :return: a URI not present in `target.state`
    :rtype: rdflib.URIRef
    :raise: InvalidDataError if `uri` is provided and not acceptable
    """
    if uri is not None:
        uri = coerce_to_uri(uri, target.uri)
        if not check_new(target.state, uri):
            raise InvalidDataError("URI already in use <%s>" % uri)
        if not uri.startswith(target.uri):
            raise InvalidDataError(
                "URI is wrong <%s> (did you forget a leading '#'?)" % uri)
    else:
        label = label.lower()
        prefix = target.uri
        if prefix[-1] != "/":
            prefix = "%s#" % prefix
        prefix = "%s%s" % (prefix, _NON_ALPHA.sub("-", label))
        uri = URIRef("%s%s" % (prefix, suffix))
        if not check_new(target.state, uri):
            prefix = "%s-" % prefix
            uri = make_fresh_uri(target.state, prefix, suffix)
    return uri

 def __init__(self, uri, collection, host_graph, host_parameters):
     # not calling parents __init__ #pylint: disable=W0231
     self.uri = coerce_to_uri(uri, collection.uri)
     self.collection = collection
     self.host_graph = host_graph
     self.host_parameters = host_parameters
     if __debug__:
         self._readonly_graph = ReadOnlyGraph(host_graph)

 def set_model(self, model):
     """I set the model of this trace.
     model can be a Model or a URI; relative URIs are resolved against this
     trace's URI.
     """
     model_uri = coerce_to_uri(model, self.uri)
     with self.edit(_trust=True) as graph:
         graph.set((self.uri, KTBS.hasModel, model_uri))

    def create_attribute_type(self, id=None, obsel_types=None, data_types=None,
                              value_is_list=False, label=None):
        """
        I create a new obsel type in this model.

        :param id: see :ref:`ktbs-resource-creation`
        :param obsel_types: explain.
        :param data_types: explain.
        :param value_is_list: explain.
        :param label: explain.

        :rtype: `AttributeTypeMixin`:class:
        """
        # redefining built-in 'id' #pylint: disable=W0622
        if id is None  and  label is None:
            raise ValueError("id or label must be supplied")
        uri = mint_uri_from_label(label, self, id)
        with self.edit(_trust=True) as graph:
            base_uri = self.uri
            graph_add = graph.add
            graph_add((uri, RDF.type, KTBS.AttributeType))
            if label is not None:
                graph_add((uri, SKOS.prefLabel, Literal(label)))
            if obsel_types is not None:
                # TODO remove test below when enough time has passed (2016-03-18)
                if isinstance(obsel_types, basestring) or isinstance(obsel_types, ObselTypeMixin):
                    warn("Model abstract API has changed: you should provide an *iterable* of obsel_types")
                    obsel_types = [obsel_types]
                for obsel_type in obsel_types:
                    obsel_type_uri = coerce_to_uri(obsel_type, base_uri)
                    graph_add ((uri, _HAS_ATT_OBSELTYPE, obsel_type_uri))
            if data_types is not None:
                # TODO remove test below when enough time has passed (2016-03-18)
                if isinstance(data_types, basestring):
                    warn("Model abstract API has changed: you should provide an *iterable* of data_types")
                    data_types = [data_types]
                for data_type in data_types:
                    data_type_uri = coerce_to_uri(data_type, base_uri)
                    graph_add ((uri, _HAS_ATT_DATATYPE, data_type_uri))
            # TODO SOON make use of value_is_list
            # ... in the meantime, we lure pylint into ignoring it:
            _ = value_is_list
        ret = self.factory(uri, [KTBS.AttributeType])
        assert isinstance(ret, AttributeTypeMixin)
        return ret

    def create_relation_type(self, id=None, origins=None, destinations=None,
                                supertypes=(), label=None):
        """
        I create a new relation type in this model.

        :param id: see :ref:`ktbs-resource-creation`
        :param origins: explain.
        :param destinations: explain.
        :param supertypes: explain.
        :param label: explain.

        :rtype: `RelationTypeMixin`:class:
        """
        # redefining built-in 'id' #pylint: disable=W0622
        if id is None  and  label is None:
            raise ValueError("id or label must be supplied")
        uri = mint_uri_from_label(label, self, id)
        with self.edit(_trust=True) as graph:
            base_uri = self.uri
            graph_add = graph.add
            graph_add((uri, RDF.type, KTBS.RelationType))
            if label is not None:
                graph_add((uri, SKOS.prefLabel, Literal(label)))
            if origins is not None:
                # TODO remove test below when enough time has passed (2016-03-18)
                if isinstance(origins, basestring) or isinstance(origins, ObselTypeMixin):
                    warn("Model abstract API has changed: you should provide an *iterable* of origins")
                    origins = [origins]
                for origin in origins:
                    origin_uri = coerce_to_uri(origin, self.uri)
                    graph_add((uri, _HAS_REL_ORIGIN, origin_uri))
            if destinations is not None:
                # TODO remove test below when enough time has passed (2016-03-18)
                if isinstance(destinations, basestring) or isinstance(destinations, ObselTypeMixin):
                    warn("Model abstract API has changed: you should provide an *iterable* of destinations")
                    destinations = [destinations]
                for destination in destinations:
                    destination_uri = coerce_to_uri(destination, self.uri)
                    graph_add((uri, _HAS_REL_DESTINATION, destination_uri))
            for i in supertypes:
                graph_add((uri, KTBS.hasSuperRelationType,
                     coerce_to_uri(i, base_uri)))
        ret = self.factory(uri, [KTBS.RelationType])
        assert isinstance(ret, RelationTypeMixin)
        return ret

 def set_method(self, val):
     """I set the method that this computed trace will use
     """
     method_uri = coerce_to_uri(val)
     # do not trust edit, as there is many verifications to make
     with self.edit() as editable:
         editable.set((self.uri, KTBS.hasMethod, method_uri))
     self.force_state_refresh()
     self.obsel_collection.force_state_refresh()

    def get_base(self, id):
        """
        I return the base corresponding to the given URI.

        :rtype: `~.base.BaseMixin`:class:
        """
        # redefining built-in 'id' #pylint: disable-msg=W0622
        base_uri = coerce_to_uri(id, self.uri)
        return self.factory(base_uri, [KTBS.Base])

 def add_data_type(self, data_type):
     """
     I add the data type to this attribute.
     """
     # TODO LATER check data_type?
     # what kind of datatype do we accept? see ktbs.namespace
     data_type_uri = coerce_to_uri(data_type)
     with self.edit(_trust=True) as editable:
         editable.add((self.uri, _HAS_ATT_DATATYPE, data_type_uri))