def mutation_create_itemlist( name: str, creator: str, itemlistorder: ItemListOrderType = ItemListOrderType.ItemListUnordered, description: str = None, contributor: str = None, additionaltype: List[str] = None): """Returns a mutation for creating an ItemList object. (https://schema.org/ItemList) Arguments: {itemlist_args} Returns: The string for the mutation for creating the ItemList. """ if not isinstance(itemlistorder, ItemListOrderType): raise trompace.exceptions.InvalidItemListOrderTypeException( itemlistorder) check_required_args(name=name, creator=creator) additionaltype = _verify_additional_type(additionaltype) args = { "creator": creator, "name": name, "contributor": contributor, "description": description, "additionalType": additionaltype } if itemlistorder: args["itemListOrder"] = StringConstant(itemlistorder) args = filter_none_args(args) return format_mutation("CreateItemList", args)
def update_defined_term_set(identifier: str, *, creator: str = None, name: str = None, additionaltype: List[str] = None, broader_url: str = None, broader_schema: annotation.AnnotationSchemaMotivation = None, image: str = None): """Return a mutation for updating a DefinedTermSet. Arguments: identifier: The identifier of the DefinedTermSet in the CE to be updated (:dcterms:`identifier`). {definedtermset_args} Returns: A GraphQL Mutation to update a DefinedTermSet in the Trompa CE """ additionaltype = _verify_additional_type(additionaltype) params = {"identifier": identifier, "creator": creator, "name": name, "additionalType": additionaltype, "broaderUrl": broader_url, "image": image} if broader_schema is not None: params["broaderMotivation"] = StringConstant(broader_schema.name) params = filter_none_args(params) return format_mutation(mutationname="UpdateDefinedTermSet", args=params)
def mutation_create_listitem(creator: str, name: str = None, contributor: str = None, description: str = None, itemurl: str = None, position: Optional[int] = None): """Returns a mutation for creating a ListItem object. (https://schema.org/ListItem) Arguments: {listitem_args} Returns: The string for the mutation for creating the ListItem. """ check_required_args(creator=creator) args = { "contributor": contributor, "name": name, "creator": creator, "description": description, "itemUrl": itemurl, "position": position, } args = filter_none_args(args) return format_mutation("CreateListItem", args)
def mutation_update_listitem(identifier: str, creator: str = None, name: str = None, contributor: str = None, description: str = None, itemurl: str = None, position: int = None): """Returns a mutation for updating a ListItem object. (https://schema.org/ListItem) Arguments: identifier: The identifier of the ListItem in the CE to be updated. {listitem_args} Returns: The string for the mutation for updating the ListItem. """ args = { "identifier": identifier, "creator": creator, "name": name, "contributor": contributor, "description": description, "itemUrl": itemurl, "position": position, } args = filter_none_args(args) return format_mutation("UpdateListItem", args)
def mutation_update_audioobject(identifier: str, *, name: str = None, title: str = None, description: str = None, date: str = None, creator: str = None, contributor: str = None, format_: str = None, encodingformat: str = None, source: str = None, license: str = None, subject: str = None, contenturl: str = None, language: str = None, inlanguage: str = None): """Returns a mutation for updating a AudioObject. Arguments: identifier: The identifier of the AudioObject in the CE to be updated. {audioobject_args} Returns: The string for the mutation for updating the AudioObject. Raises: Assertion error if the input language or inlanguage is not one of the supported languages. """ if format_ is not None and "/" not in format_: raise NotAMimeTypeException(format_) if encodingformat is not None and "/" not in encodingformat: raise NotAMimeTypeException(encodingformat) if language is not None and language not in SUPPORTED_LANGUAGES: raise UnsupportedLanguageException(language) args = { "identifier": identifier, "name": name, "title": title, "description": description, "creator": creator, "contributor": contributor, "format": format_, "encodingFormat": encodingformat, "source": source, "subject": subject, "contentUrl": contenturl, "license": license, "inLanguage": inlanguage, } if date: args["date"] = _Neo4jDate(date) if language: args["language"] = StringConstant(language.lower()) args = filter_none_args(args) return format_mutation("UpdateAudioObject", args)
def create_annotation(creator: str, motivation: AnnotationSchemaMotivation, target_url: str = None, body_url: List[str] = None): """Return a mutation for making a web Annotation (https://www.w3.org/TR/annotation-model) Arguments: creator: a URI to the identity of the user who created this Annotation motivation: a AnnotationSchemaMotivation value, or the ID of an AnnotationCEMotivation node target_url: if the target is the URL of an external object, the URL body_url: if the body is the URL of an external object, the URL Returns: A GraphQL Mutation to create an Annotation in the Trompa CE """ check_required_args(creator=creator, motivation=motivation) params = { "creator": creator, "motivation": StringConstant(motivation.name), "targetUrl": target_url, "bodyUrl": body_url, } params = filter_none_args(params) return format_mutation(mutationname="CreateAnnotation", args=params)
def create_rating_definition(*, creator: str, bestrating: int, worstrating: int, name: str = None): """Return a mutation for making a Rating definition. A Rating (https://schema.org/Rating) is an evaluation on a numeric scale. A Rating definition describes the structure that a rating can take. It is used so that an annotation tool can give a title and present an input according to the correct scale (e.g. 1-5 or 1-100). This is a helper method that requires a bestrating and worstrating value and automatically sets additionaltype to RATING_DEFINITION_ADDITIONAL_TYPE A name is recommended if multiple ratings are going to be shown on the same annotator, but isn't necessary. """ check_required_args(creator=creator, bestrating=bestrating, worstrating=worstrating) params = { "creator": creator, "name": name, "bestRating": bestrating, "worstRating": worstrating, "additionalType": RATING_DEFINITION_ADDITIONAL_TYPE } params = filter_none_args(params) return format_mutation(mutationname="CreateRating", args=params)
def create_annotation_motivation( creator: str, title: str, description: str, broader_schema: AnnotationSchemaMotivation = None, broader_url: str = None): """Return a mutation for making an Annotation motivation A custom motivation should be a special case of one of the standard 13 motivations in the web annotation vocabulary (https://www.w3.org/TR/annotation-vocab/#named-individuals), or a URL pointing to an external motivation Arguments: creator: a URI to the identity of the user who created this Motivation title: a descriptive name for the motivation description: a detailed description of the motivation broader_schema: a AnnotationSchemaMotivation value describing what this motivation is a special case of broader_url: a URL to an oa:Motivation describing what this motivation is a special case of """ params = { "creator": creator, "title": title, "description": description, "broaderUrl": broader_url, } if broader_schema: params["broaderMotivation"] = StringConstant(broader_schema.name) params = filter_none_args(params) return format_mutation(mutationname="CreateAnnotationCEMotivation", args=params)
def mutation_create_musicrecording(*, name: str = None, title: str, description: str, contributor: str, creator: str, source: str, format_: str, encodingformat: str = None, subject: str = None, language: str = None, date: str = None): """Returns a mutation for creating a MusicRecording object. https://schema.org/MusicRecording Arguments: {musicrecording_args} Returns: The string for the mutation for creating the MusicRecording. """ check_required_args(title=title, contributor=contributor, creator=creator, source=source, format_=format_) if "/" not in format_: raise NotAMimeTypeException(format_) if language is not None and language not in SUPPORTED_LANGUAGES: raise UnsupportedLanguageException(language) args = { "name": name, "title": title, "description": description, "contributor": contributor, "creator": creator, "source": source, "format": format_, "encodingFormat": encodingformat, "subject": subject } if language is not None: args["language"] = StringConstant(language.lower()) if date is not None: args["date"] = _Neo4jDate(date) args = filter_none_args(args) return format_mutation("CreateMusicRecording", args)
def mutation_create_music_composition(*, title: str, contributor: str, creator: str, source: str, format_: str, subject: str = None, language: str = None, inlanguage: str = None, name: str = None, description: str = None, position: int = None): """Returns a mutation for creating a music composition object Args: {musiccomposition_args} Returns: The string for the mutation for creating the music composition. Raises: UnsupportedLanguageException: if ``language`` is not one of the supported languages. NotAMimeTypeException: if ``format_`` is not a valid mimetype """ check_required_args(title=title, contributor=contributor, creator=creator, source=source, format_=format_) if language and language not in SUPPORTED_LANGUAGES: raise UnsupportedLanguageException(language) if "/" not in format_: raise NotAMimeTypeException(format_) args = { "title": title, "contributor": contributor, "creator": creator, "format": format_, "subject": subject, "source": source, "inLanguage": inlanguage, "name": name, "description": description, "position": position } if language is not None: args["language"] = StringConstant(language.lower()) args = filter_none_args(args) return format_mutation("CreateMusicComposition", args)
def mutation_update_music_composition(identifier: str, *, title: str = None, contributor: str = None, creator: str = None, source: str = None, format_: str = None, subject: str = None, language: str = None, inlanguage: str = None, name: str = None, description: str = None, position: int = None): """Returns a mutation for updating a MusicComposition object. Args: identifier: The identifier of the MusicComposition in the CE to be updated {musiccomposition_args} Returns: The string for the mutation for updating the music composition. Raises: UnsupportedLanguageException: if ``language`` is not one of the supported languages. NotAMimeTypeException: if ``format_`` is not a valid mimetype """ if language and language not in SUPPORTED_LANGUAGES: raise UnsupportedLanguageException(language) if format_ and "/" not in format_: raise NotAMimeTypeException(format_) args = { "identifier": identifier, "title": title, "contributor": contributor, "creator": creator, "subject": subject, "source": source, "inLanguage": inlanguage, "format": format_, "name": name, "description": description, "position": position } if language is not None: args["language"] = StringConstant(language.lower()) args = filter_none_args(args) return format_mutation("UpdateMusicComposition", args)
def mutation_update_musicrecording(identifier: str, *, title: str = None, contributor: str = None, creator: str = None, source: str = None, encodingformat: str = None, format_: str = None, name: str = None, language: str = None, description: str = None, date: str = None, subject: str = None): """Returns a mutation for updating a MusicRecording object. https://schema.org/MusicRecording Arguments: identifier: The identifier of the MusicRecording in the CE to be updated {musicrecording_args} Returns: The string for the mutation for updating the MusicRecording. """ if format_ is not None and "/" not in format_: raise NotAMimeTypeException(format_) if language is not None and language not in SUPPORTED_LANGUAGES: raise UnsupportedLanguageException(language) args = { "identifier": identifier, "title": title, "contributor": contributor, "creator": creator, "source": source, "format": format_, "name": name, "description": description, "encodingFormat": encodingformat, "subject": subject } if date is not None: args["date"] = _Neo4jDate(date) if language is not None: args["language"] = StringConstant(language.lower()) args = filter_none_args(args) return format_mutation("UpdateMusicRecording", args)
def query_itemlist(identifier: str): """Returns a query for querying the database for a ItemList object. Arguments: identifier: The identifier of the ItemList object in the CE. Returns: The string for the quereing the ItemList object. """ args = { "identifier_in": identifier, } args = filter_none_args(args) return format_itemlist_query("ItemList", args)
def mutation_create_digitaldocument(*, title: str, contributor: str, creator: str, source: str, format_: str, subject: str = None, language: str = None, description: str = None): """Returns a mutation for creating a digital document object. Arguments: {digitaldocument_args} Returns: The string for the mutation for creating the digital document. Raises: UnsupportedLanguageException if the input language is not one of the supported languages. NotAMimeTypeException: if ``format_`` is not a valid mimetype. """ check_required_args(title=title, contributor=contributor, creator=creator, source=source, format_=format_) if language not in SUPPORTED_LANGUAGES: raise UnsupportedLanguageException(language) if "/" not in format_: raise NotAMimeTypeException(format_) args = { "title": title, "contributor": contributor, "creator": creator, "source": source, "format": format_, "subject": subject, "description": description, } if language is not None: args["language"] = StringConstant(language.lower()) args = filter_none_args(args) return format_mutation("CreateDigitalDocument", args)
def query_listitems(identifiers: list = None, return_items_list: list = ["identifier"]): """Returns a query for querying the database for a ThingInterface object. Arguments: identifiers: The list of identifiers of the ThingInterfaces object in the CE. return_items_list: A list of item fields that the query must return. Returns: The string for the quereing the ThingInterface object. """ args = { "identifier_in": identifiers, } args = filter_none_args(args) return format_filter_query("ThingInterface", args, return_items_list)
def query_softwareapplication(identifier: str = None, title: str = None, contributor: str = None, creator: str = None, source: str = None, name: str = None, language: str = None, softwareversion: str = None, filter_: dict = None, return_items: list = None): """Returns a query for reading an SoftwareApplication from the CE. Arguments: identifier: return nodes with this identifier title: return nodes with this title contributor: return nodes with this contributor creator: return nodes with this creator source: return nodes with this source name: return nodes with this name language: return nodes with this language softwareversion: return nodes with this softwareversion filter_: return nodes with this custom filter return_items: return these items in the response Returns: The string for the querying the SoftwareApplication. """ if return_items is None: return_items = ["identifier", "creator", "title", "source"] args = { "identifier": identifier, "title": title, "contributor": contributor, "creator": creator, "source": source, "name": name, "language": language, "softwareVersion": softwareversion } if filter_: args["filter"] = make_filter(filter_) args = filter_none_args(args) return format_query("SoftwareApplication", args, return_items)
def mutation_update_musicgroup(identifier: str, *, title: str = None, contributor: str = None, creator: str = None, source: str = None, format_: str = None, language: str = None, name: str = None, founding_date: str = None, disolution_date: str = None, description: str = None, image: str = None, publisher: str = None): """Returns a mutation for updating a MusicGroup Args: identifier: The identifier of the musicgroup in the CE to be updated {musicgroup_args} Returns: The string for the mutation for updating the musicgroup. Raises: UnsupportedLanguageException: if ``language`` is not one of the supported languages. ValueError: if ``gender`` is not a value supported by the Ce NotAMimeTypeException: if ``format_`` is not a valid mimetype. """ if language and language.lower() not in SUPPORTED_LANGUAGES: raise UnsupportedLanguageException(language) if format_ and "/" not in format_: raise NotAMimeTypeException(format_) args = { "identifier": identifier, "title": title, "contributor": contributor, "creator": creator, "source": source, "format": format_, "name": name, "description": description, "image": image, "publisher": publisher, } if language is not None: args["language"] = StringConstant(language.lower()) if founding_date is not None: args["foundingDate"] = _Neo4jDate(founding_date) if disolution_date is not None: args["disolutionDate"] = _Neo4jDate(disolution_date) args = filter_none_args(args) return format_mutation("UpdateMusicGroup", args)
def query_mediaobject(identifier: str = None, creator: str = None, contributor: str = None, encodingformat: str = None, source: str = None, contenturl: str = None, inlanguage: str = None, filter_: dict = None, return_items: Union[list, str] = None): """Returns a query for querying the database for a media object. Arguments: identifier: The identifier of the media object in the CE. creator: The person, organization or service who created the thing the web resource is about. contributor: A person, an organization, or a service responsible for contributing\ the media object to the web resource. This can be either a name or a base URL. encodingformat: A MimeType of the format of object encoded by the media object. source: The URL of the web resource to be represented by the node. contenturl: The URL of the content encoded by the media object. inlanguage: The language of the media object. Currently supported languages are en,es,ca,nl,de,fr. filter_: return nodes with this custom filter return_items: return these items in the response Returns: The string for the quereing the media object. Raises: UnsupportedLanguageException if the input language is not one of the supported languages. """ if return_items is None: return_items = ["identifier", "name"] args = { "identifier": identifier, "creator": creator, "contributor": contributor, "encodingFormat": encodingformat, "source": source, "contentUrl": contenturl, "inLanguage": inlanguage } if filter_: args["filter"] = StringConstant(make_filter(filter_)) args = filter_none_args(args) return format_query("MediaObject", args, return_items)
def query_musiccomposition(identifier: str = None, title: str = None, contributor: str = None, creator: str = None, source: str = None, inlanguage: str = None, name: str = None, position: int = None, filter_: dict = None, return_items: Union[list, str] = None): """Returns a query for querying the database for a music composition. Arguments: identifier: The identifier of the music composition in the CE. title: The title of the resource indicated by `source` creator: The person, organization or service who created the thing the web resource is about. contributor: A person, an organization, or a service responsible for contributing\ the music composition to the web resource. This can be either a name or a base URL. source: The source URL that an item comes from inlanguage: The language of the music composition. Currently supported languages are en,es,ca,nl,de,fr name: The name of the music composition. position: In the case that this is a movement of a larger work (e.g. a Symphony), the position of this MusicComposition in the larger one. filter_: return nodes with this custom filter return_items: return these items in the response Returns: The string for the quereing the music composition. Raises: UnsupportedLanguageException if the input language is not one of the supported languages. """ if return_items is None: return_items = ["identifier", "title", "source"] if inlanguage and inlanguage not in SUPPORTED_LANGUAGES: raise UnsupportedLanguageException(inlanguage) args = { "identifier": identifier, "title": title, "source": source, "contributor": contributor, "creator": creator, "inLanguage": inlanguage, "name": name, "position": position } if filter_: args["filter"] = StringConstant(make_filter(filter_)) args = filter_none_args(args) return format_query("MusicComposition", args, return_items)
def mutation_create_musicgroup(*, title: str, contributor: str, creator: str, source: str, format_: str, language: str = None, name: str = None, founding_date: str = None, disolution_date: str = None, description: str = None, image: str = None, publisher: str = None): """Returns a mutation for creating a MusicGroup Args: {musicgroup_args} Returns: The string for the mutation for creating the musicgroup. Raises: UnsupportedLanguageException: if ``language`` is not one of the supported languages. NotAMimeTypeException: if ``format_`` is not a valid mimetype. """ check_required_args(title=title, contributor=contributor, creator=creator, source=source, format_=format_) if language and language.lower() not in SUPPORTED_LANGUAGES: raise UnsupportedLanguageException(language) if "/" not in format_: raise NotAMimeTypeException(format_) args = { "title": title, "contributor": contributor, "creator": creator, "source": source, "format": format_, "name": name, "description": description, "image": image, "publisher": publisher, } if language is not None: args["language"] = StringConstant(language.lower()) if founding_date is not None: args["foundingDate"] = _Neo4jDate(founding_date) if disolution_date is not None: args["disolutionDate"] = _Neo4jDate(disolution_date) args = filter_none_args(args) return format_mutation("CreateMusicGroup", args)
def query_person(identifier: str = None, contributor: str = None, creator: str = None, source: str = None, language: str = None, format_: str = None, name: str = None, family_name: str = None, given_name: str = None, return_items_list: list = ["identifier", "name"]): """Returns a query for retrieving a person or people. Arguments: identifier: The identifier of the person in the CE. contributor: The main URL of the site where the information about the Person was taken from creator: The person, organization or service who is creating this Person (e.g. URL of the software) source: The URL of the web resource where information about this Person is taken from language: The language the metadata is written in. format_: The mimetype of the resource indicated by `source` name: The name of the person family_name: The family name of the person given_name: The given name of the person return_items_list: A list of item fields that the query must return. Returns: The string for a person query. """ args = { "identifier": identifier, "contributor": contributor, "creator": creator, "source": source, "language": language, "format": format_, "name": name, "familyName": family_name, "givenName": given_name, } args = filter_none_args(args) return format_query("Person", args, return_items_list)
def mutation_create_application(*, name: str, contributor: str, creator: str, source: str, title: str = None, subject: str = None, language: str = None, description: str = None, format_: str = None, softwareversion: str = None): """Returns a mutation for creating a software application object Arguments: name: The name of the software application. title: the html title of the page at `source` contributor: A person, an organization, or a service responsible for adding the software application. This can be either a name or a base URL. creator: The person, organization or service responsible for adding the software application. source: The URL of the web resource to be represented by the node. subject: The subject associated with the application. description: An account of the software application. language: The language of the page at `source`. Currently supported languages are en,es,ca,nl,de,fr softwareversion: the version of the software Returns: The string for the mutation for creating the artist. Raises: UnsupportedLanguageException if the input language is not one of the supported languages. NotAMimeTypeException if format_ is not a valid mimetype. """ if language and language not in SUPPORTED_LANGUAGES: raise UnsupportedLanguageException(language) if format_ and "/" not in format_: raise NotAMimeTypeException(format_) args = { "name": name, "contributor": contributor, "creator": creator, "source": source, "title": title, "subject": subject, "description": description, "format": format_, "softwareVersion": softwareversion } if language: args["language"] = StringConstant(language.lower()) args = filter_none_args(args) return mutation_create(args, CREATE_APPLICATION)
def update_annotation_ce_target(identifier: str, target: str = None, field: str = None, fragment: str = None): """Return a mutation for updating an AnnotationCETarget. Returns: A GraphQL Mutation to update an AnnotationCETarget in the Trompa CE """ check_required_args(identifier=identifier) params = { "identifier": identifier, "target": target, "field": field, "fragment": fragment } params = filter_none_args(params) return format_mutation(mutationname="UpdateAnnotationCETarget", args=params)
def mutation_update_musicplaylist(identifier: str, *, title: str, contributor: str, creator: str, source: str, format_: str, name: str = None, language: str = None, num_tracks: int = None): """Returns a mutation for updating a MusicPlaylist object. Arguments: identifier: The identifier of the MusicPlaylist in the CE to be updated {musicplaylist_args} Returns: The string for the mutation for updating the MusicPlaylist. """ if format_ is not None and "/" not in format_: raise NotAMimeTypeException(format_) if language is not None and language not in SUPPORTED_LANGUAGES: raise UnsupportedLanguageException(language) args = { "identifier": identifier, "title": title, "contributor": contributor, "creator": creator, "source": source, "format": format_, "name": name, "numTracks": num_tracks } if language is not None: args["language"] = StringConstant(language.lower()) args = filter_none_args(args) return format_mutation("UpdateMusicPlaylist", args)
def update_rating(identifier: str, *, creator: str = None, ratingvalue: int = None, bestrating: int = None, worstrating: int = None, ratingexplanation: str = None, additionaltype: str = None): params = { "identifier": identifier, "creator": creator, "ratingValue": ratingvalue, "bestRating": bestrating, "worstRating": worstrating, "ratingExplanation": ratingexplanation, "additionalType": additionaltype } params = filter_none_args(params) return format_mutation(mutationname="UpdateRating", args=params)
def update_annotation_textual_body(identifier: str, value: str = None, format_: str = None, language: str = None): """Return a mutation for updating an AnnotationTextualBody. Returns: A GraphQL Mutation to update an AnnotationTextualBody in the Trompa CE """ check_required_args(identifier=identifier) if language and language.lower() not in SUPPORTED_LANGUAGES: raise UnsupportedLanguageException(language) params = {"identifier": identifier, "value": value, "format": format_} params = filter_none_args(params) if language is not None: params["language"] = StringConstant(language.lower()) return format_mutation(mutationname="UpdateAnnotationTextualBody", args=params)
def mutation_update_digitaldocument(identifier: str, *, title: str = None, contributor: str = None, creator: str = None, source: str = None, format_: str = None, subject: str = None, language: str = None, description: str = None): """Returns a mutation for updating a digital document object. Arguments: identifier: The identifier of the media object in the CE to be updated. {digitaldocument_args} Returns: The string for the mutation for creating the artist. Raises: Assertion error if the input language is not one of the supported languages. """ args = { "identifier": identifier, "title": title, "contributor": contributor, "creator": creator, "source": source, "format": format_, "subject": subject, "description": description } if language is not None: args["language"] = StringConstant(language.lower()) args = filter_none_args(args) return format_mutation("UpdateDigitalDocument", args)
def update_annotation(identifier: str, target: str = None, motivation: Union[AnnotationSchemaMotivation, str] = None, body: str = None, creator: str = None): """Return a mutation for updating an Annotation. Returns: A GraphQL Mutation to create an Annotation in the Trompa CE """ check_required_args(identifier=identifier) params = { "identifier": identifier, "target": target, "motivation": motivation, "body": body, "creator": creator } params = filter_none_args(params) return format_mutation(mutationname="UpdateAnnotation", args=params)
def update_defined_term(identifier: str, *, creator: str = None, termcode: str = None, additionaltype: List[str] = None, image: str = None): """Return a mutation for updating a DefinedTerm. Arguments: identifier: The identifier of the DefinedTerm in the CE to be updated (:dcterms:`identifier`). {definedterm_args} Returns: A GraphQL Mutation to update a DefinedTerm in the Trompa CE """ additionaltype = _verify_additional_type(additionaltype) params = {"identifier": identifier, "creator": creator, "termCode": termcode, "additionalType": additionaltype, "image": image} params = filter_none_args(params) return format_mutation(mutationname="UpdateDefinedTerm", args=params)
def create_defined_term(*, creator: str, termcode: str, additionaltype: List[str], image: str = None): """Return a mutation for making a DefinedTerm. A :schema:`DefinedTerm` is a word, name, acronym, phrase, etc. with a formal definition. It is part of a DefinedTermSet. Arguments: {definedterm_args} Returns: A GraphQL Mutation to create a DefinedTerm in the Trompa CE """ check_required_args(creator=creator, termcode=termcode, additionaltype=additionaltype) additionaltype = _verify_additional_type(additionaltype) params = {"additionalType": additionaltype, "creator": creator, "termCode": termcode, "image": image} params = filter_none_args(params) return format_mutation(mutationname="CreateDefinedTerm", args=params)