Interface Reference

abstract type AbstractApplication

An abstract type representing an interface for a patent application.

abstract type AbstractApplicationReference

An abstract type representing a reference to a patent application. Implementations should be coupled with an implementation of AbstractDataSource to allow lookup of the referenced application in the data source, using the find_application function.

abstract type AbstractApplicationID <: AbstractApplicationReference

An abstract type representing an interface for an application reference by jurisdiction, document number, and (optionally) kind. This is the preferred reference type to allow cross-referencing of applications across different data sources and formats.

date_published(a::AbstractApplication)

Return the Date of publication of an application a.

date_published(f::AbstractFamily)

Return the Date of publication of the earliest-published application in a family f.

jurisdiction(a::AbstractApplication)
jurisdiction(a::AbstractApplicationID)

Return a String with the country code of the filing jurisdiction for the application a.

doc_number(a::AbstractApplication)
doc_number(a::AbstractApplicationID)

Return a String with the jurisdiction-specific document number of the application a.

kind(a::AbstractApplication)
kind(a::AbstractApplicationID)

Return a String with the kind code of the application a.

id(a::AbstractApplication)
id(a::AbstractApplicationID)

Return a String with the original application ID, consisting of country code, document number and kind identifier.

sourceid(a::AbstractApplication)
sourceid(a::AbstractApplicationID)

Return the id used in the data source, e.g. the lens_id for data obtained from Lens.org.

refers_to(ref::AbstractApplicationReference, app::AbstractApplication)

Return true if app is the application referenced by ref, and false otherwise. In cases where identity cannot be checked due to incompatible types, implementations should default to false. The abstract reference implementation always returns false.

Implementation advice: There is no need to implement this for every possible combination of application and reference type. Usually, it will be enough to provide implementations for the application and reference types used by the same implementation package, and a generic implementation for AbstractApplicationID references.

abstract type AbstractContent

An abstract type representing an interface for content fields of a patent application. There are five abstract content fields that are subtypes of this type: AbstractTitle, AbstractShortDescription, AbstractClaim, and AbstractFulltext.

abstract type AbstractTitle <: AbstractContent

An abstract type representing an interface for the title(s) of a patent application.

abstract type AbstractShortDescription <: AbstractContent

An abstract type representing an interface for the abstract or short description of a patent. The type is deliberately not named "AbstractAbstract" to avoid confusion.

abstract type AbstractClaim <: AbstractContent

An abstract type representing an interface for a single claim associated with a patent application.

abstract type AbstractFulltext <: AbstractContent

An abstract type representing an interface for the full text of a patent application.

languages(c::AbstractContent)

Returns a Vector{String} with all languages for which a version of the content field c is available.

text(c::AbstractContent, lang::String)

Returns a String with the localized version of the text of content field c for language lang. Concrete implementations should throw a Base.KeyError if there is no title for that locale.

title(a::AbstractApplication)

Return an AbstractTitle with information about the title of application a.

title(a::AbstractApplication, lang::String)

Return a String with the localized title of application a for language lang.

claims(a::AbstractApplication)

Return a Vector{<:AbstractClaim} with information on patent claims contained in application a.

abstract(a::AbstractApplication)

Return an AbstractShortDescription with the abstract of application a.

fulltext(a::AbstractApplication)

Return an AbstractFulltext with the full text of application a.

abstract type AbstractCitation

An abstract type representing an interface for a citation in a patent application.

abstract type AbstractPatentCitation <: AbstractCitation

An abstract type representing an interface for a citation of another patent document (NPL) in a patent application.

abstract type AbstractNPLCitation <: AbstractCitation

An abstract type representing an interface for a citation of non-patent literature (NPL) in a patent application.

abstract type AbstractCitationType

An abstract type representing a type of citation, e.g. patent or NPL.

struct PatentCitation <: AbstractCitationType

Dispatch type for selecting patent citations.

struct NPLCitation <: AbstractCitationType

Dispatch type for selecting NPL citations.

phase(c::AbstractCitation)

Return a String specifying the phase in the patent process during which the citation c occured.

reference(c::AbstractPatentCitation)

Return an AbstractApplicationReference for the application cited in c.

bibentry(c::AbstractNPLCitation)

Returns a String with the bibliography entry of the NPL citation c.

external_ids(c::AbstractNPLCitation)

Returns a Vector{String} with the external database IDs recorded for the NPL citation c.

doi(c::AbstractNPLCitation)

Returns a String with the Digital Object Identifier (DOI) for NPL citation c. If multiple IDs matching the DOI format are found, the first is returned. Returns nothing if no ID field matches the DOI format.

citations(a::AbstractApplication[, type::AbstractCitationType])
citations(f::AbstractFamily[, type::AbstractCitationType])

Return a Vector{<:AbstractCitation} with all citations of the given type from a patent application a or family f.

type can either be PatentCitation() (default) or NPLCitation().

forwardcitations(a::AbstractApplication)
forwardcitations(f::AbstractFamily)

Return a Vector{<:AbstractPatentCitation} with citations of all patent applications known to cite a patent application or patent family. Note that even though these are represented by the AbstractPatentCitation interface, they are conceptually not citations in a strict sense.

citationgraph(applications::Vector{<:AbstractApplication})
citationgraph(families::Vector{<:AbstractFamily})

Return a SimpleDiGraph representing the network of citations among families or applications.

Node numbers in the graph correspond to indices in the input array. An edge from node i to node j indicates that j cited i and will be included in the output graph if the publication date of j is after that of i.

abstract type AbstractParty

An abstract type representing an interface for a patent application party. The two types of parties are applicants and inventors, represented by the types AbstractApplicant and AbstractInventor, respectively.

abstract type AbstractInventor <: AbstractParty

An abstract type representing an interface for an inventor.

abstract type AbstractApplicant <: AbstractParty

An abstract type representing an interface for a patent applicant.

name(p::AbstractParty)

return the name of the party p.

known_names(a::AbstractParty)

return a Vector{String} of all names under which party p is known to appear.

country(p::AbstractParty)

return the country code of the country of residence of party p.

applicants(a::AbstractApplication)

return a Vector{<:AbstractApplicant} with information about the applicant(s) of application a.

applicants(f::AbstractFamily)

return a Vector{<:AbstractApplicant} with the unique set of applicants from all the applications in family f.

inventors(a::AbstractApplication)

return a Vector{<:AbstractInventor} with information about the inventor(s) of application a.

inventors(f::AbstractFamily)

return a Vector{<:AbstractInventor} with the unique set of inventors from all the applications in family f.

abstract type AbstractClassificationSystem

Abstract type representing a system for technology classification of patents.

abstract type IPCLikeSystem <: AbstractClassificationSystem

Abstract type representing a system for technology classification of patents that follows a structure similar to that of the International Patent Classification (IPC) or Cooperative Patent Classification (CPC).

struct CPC <: IPCLikeSystem

Dispatch type referring to the Cooperative Patent Classification (CPC) classification system.

struct IPC <: IPCLikeSystem

Dispatch type referring to the International Patent Classification (IPC) classification system.

abstract type AbstractClassificationSymbol

Abstract type representing a patent classification entry. Specific implementations should at least implement symbol.

abstract type IPCLikeSymbol <: AbstractClassificationSymbol

Abstract type representing a patent classification entry following an IPCLikeSystem. In addition to the interface for any AbstractClassificationSymbol, implementations should implement symbol(l, c) and title(l, c) for all levels of the classification.

struct CPCSymbol <: IPCLikeSymbol

CPCSymbol(symbol::String)

Struct representing a minimal technology classification entry according to the CPC.

struct IPCSymbol <: IPCLikeSymbol

IPCSymbol(symbol::String)

Struct representing a minimal technology classification entry according to the IPC.

abstract type AbstractClassificationLevel

Abstract type representing a level in a hierarchical technology classification system.

abstract type AbstractIPCLikeClassificationLevel <: AbstractClassificationLevel

Abstract type representing a level in an IPC-like technology classification system.

struct Section <: AbstractIPCLikeClassificationLevel

Dispatch type referring to the section level of an IPC-like technology classification.

struct Class <: AbstractIPCLikeClassificationLevel

Dispatch type referring to the class level of an IPC-like technology classification.

struct Subclass <: AbstractIPCLikeClassificationLevel

Dispatch type referring to the subclass level of an IPC-like technology classification.

struct Maingroup <: AbstractIPCLikeClassificationLevel

Dispatch type referring to the group level of an IPC-like technology classification.

struct Subgroup <: AbstractIPCLikeClassificationLevel

Dispatch type referring to the subgroup level of an IPC-like technology classification.

classification(a::AbstractApplication)
classification(f::AbstractFamily)
classification(c::AbstractClassificationSystem, a::AbstractApplication)
classification(c::AbstractClassificationSystem, f::AbstractFamily)

Obtain a Vector{<:AbstractClassificationSymbol} with all classifications for application a or family f according to classification system c. Defaults to CPC if no system is specified.

symbol(c::AbstractClassificationSymbol)
symbol(l::AbstractClassificationLevel, c::AbstractClassificationSymbol)

Return a String representation of a classification symbol c down to a specified level l. If no level is specified, the complete symbol is returned.

title(l::AbstractClassificationLevel, c::AbstractClassificationSymbol)

Return a String containing the full title of a classification c down to a specified level l.

abstract type AbstractFamily

An abstract type representing an interface for a patent family.

abstract type AbstractPortfolio

An abstract type representing an interface for a party's patent portfolio.

aggregate_families(apps::Vector{<:AbstractApplication})

Aggregate the applications apps into an array of patent families.

applications(f::AbstractFamily)

return a Vector{<:AbstractApplication} with all applications in family f.

applications(p::AbstractPortfolio)

return a Vector{<:AbstractApplication} with all applications in portfolio p.

families(p::AbstractPortfolio)

return a Vector{<:AbstractFamily} with all patent families in portfolio p.

portfolio(owner::Union{AbstractParty, String}, ds::Vector{<:AbstractApplication})
portfolio(owner::Union{AbstractParty, String}, ds::Vector{<:AbstractFamily})
portfolio(owner::Union{AbstractParty, String}, ds::AbstractDataSource)

return an AbstractPortfolio of the owner, containing all families or applications filed in that owner's name from a data source ds. If owner is given as a String, it is assumed to be the name of an AbstractApplicant.

siblings(a::AbstractApplicationReference)

return a Vector{<:AbstractApplicationReference} with references to all applications that are in the same family as a.

siblings(a::AbstractApplication, ds::AbstractDataSource)

return a Vector{<:AbstractApplication} with all applications from the data source ds that are in the same family as a.

owner(p::AbstractPortfolio)

return an AbstractParty representing the owner of portfolio p.

abstract type AbstractDataSource

An abstract type representing an interface for a patent data source. Data sources can be in-memory data structures, wrappers around databases or API consumers.

abstract type DataLevel

Abstract type representing the level of a patent analysis (e.g. patent families, individual applications etc.)

struct ApplicationLevel <: DataLevel

Dispatch type indicating an analysis at the level of individual patent applications.

struct FamilyLevel <: DataLevel

Dispatch type indicating an analysis at the level of patent families.

applications(ds::AbstractDataSource[, filter::AbstractFilter], kwargs...)

Return a Vector{<:AbstractApplication} with all applications contained in ds. May take a long time and/or cause memory overflow for large out-of-memory data sources. If a filter is specified, only applications matching the filter are returned.

Optional keyword arguments:

• ignore_fulltext: If true, full text information will not be retrieved. This may be used to improve runtime and memory footprint for large datasets.

families(ds::AbstractDataSource[, filter::AbstractFilter], kwargs...)

Return a Vector{<:AbstractFamily} with all patent families contained in ds. May take a long time and/or cause memory overflow for large out-of-memory data sources. If a filter is specified, only families matching the filter are returned.

Optional keyword arguments:

• ignore_fulltext: If true, full text information will not be retrieved. This may be used to improve runtime and memory footprint for large datasets.

find_application(ref::AbstractApplicationReference, ds::AbstractDataSource)

Return the application referenced by ref if it is contained in the data source ds, otherwise return nothing.

find_application(c::AbstractPatentCitation, ds::AbstractDataSource)

Attempt to retrieve the patent application referenced by the citation c from the data source ds and return it, or return nothing if it cannot be found.

abstract type AbstractFilter

Abstract type representing a filter that can be applied to an AbstractDataSource. In principle, any predicate that can apply to an application or patent family can be a filter. However, some filter options may not be implemented for all data sources. Filters are composable using the UnionFilter and IntersectionFilter structs and the corresponding | and & infix operators.

struct AllFilter <: AbstractFilter

Pseudo-filter that matches all applications or families in a database.

struct IntersectionFilter <: AbstractFilter

IntersectionFilter(a::AbstractFilter, b::AbstractFilter)

Struct representing the intersection or conjunction of two AbstractFilters. As a shorthand syntax for this composition, the '&' operator may be used:

filter3 = filter1 & filter2 # intersection of filter1 and filter2

struct UnionFilter <: AbstractFilter

UnionFilter(a::AbstractFilter, b::AbstractFilter)

Struct representing the union or disjunction of two AbstractFilters. As a shorthand syntax for this composition, the '|' operator may be used:

filter3 = filter1 | filter2 # union of filter1 and filter2

struct ClassificationFilter <: AbstractFilter

ClassificationFilter(
    system::IPCLikeSystem,
    level::AbstractIPCLikeClassificationLevel,
    symbols::Vector{<:IPCLikeSymbol}
)

Struct representing a database filter by IPC-like classification.

Parameters:

• system: The IPCLikeSystem system used, such as IPC or CPC.
• level: The AbstractIPCLikeClassificationLevel at which to filter (Section, Class, Subclass etc.)
• symbols: A Vector{<:IPCLikeSymbol} of all classifications included. The filter will match any application classified by at least one of these.

struct ContentFilter <: AbstractFilter

ContentFilter(
    search_query::String,
    field::Union{SearchableContentField, Vector{<:SearchableContentField}},
    [languages::Vector{String}]
)

Struct representing a database filter using full-text search on various content fields.

Parameters:

• search_query: The keyword(s), phrase(s) or complex query to be used for the search. Query syntax may vary across data sources, but should be broadly similar to https://www.sqlite.org/fts5.html#fulltextquery_syntax.

• field: Specifies which SearchableContentField(s) is/are used for the search. Possible values are TitleSearch(), AbstractSearch(), ClaimsSearch(), or FulltextSearch(). A vector can be passed, in which case the constructor actually creates a UnionFilter.

• languages: Optional. A vector of two-character language codes specifying the languages for which matches are included. If an empty vector is passed (as by default), all available languages are included.

abstract type SearchableContentField

Abstract type representing a fulltext-searchable application content field.

struct TitleSearch <: SearchableContentField

Dispatch type referring to a search in the titles of documents.

struct AbstractSearch <: SearchableContentField

Dispatch type referring to a search in the abstract descriptions of documents.

struct ClaimsSearch <: SearchableContentField

Dispatch type referring to a search in the claims section of documents.

struct FulltextSearch <: SearchableContentField

Dispatch type referring to a search in the full text of documents.