Module plume.rdf.utils#

Utilitaires.

plume.rdf.utils.CRS_NS = {'EPSG': 'http://www.opengis.net/def/crs/EPSG/0/', 'IGNF': 'https://registre.ign.fr/ign/IGNF/crs/IGNF/', 'OGC': 'http://www.opengis.net/def/crs/OGC/1.3/'}#: Espaces de nommage des référentiels de coordonnées.

class plume.rdf.utils.DatasetId(*uuids)#

Bases : URIRef

Identifiant de jeu de données.

Parameters:

*uuidsstr or UUID or rdflib.term.URIRef: UUID ou chaînes de caractères ou IRI présumés correspondre à un UUID. Le premier élément qui s’avère être réellement un UUID est conservé. Si aucun n’est valide ou si l’argument n’est pas fourni, un nouvel UUID est utilisé pour créer l’identifiant.

Examples

>>> DatasetId('4dc72616-7235-461f-95cf-94dfc3cfa629', 
...     'urn:uuid:2b4bb94a-c10b-4d99-a0e7-4ee28888e4f4')
DatasetId('urn:uuid:4dc72616-7235-461f-95cf-94dfc3cfa629')

>>> DatasetId('pas un UUID', 
...     'urn:uuid:2b4bb94a-c10b-4d99-a0e7-4ee28888e4f4')
DatasetId('urn:uuid:2b4bb94a-c10b-4d99-a0e7-4ee28888e4f4')

>>> DatasetId()
DatasetId('urn:uuid:...')

Attributes:

uuiduuid.UUID: Représentation de l’identifiant sous forme d’UUID.

Methods

`capitalize`(/)	Return a capitalized version of the string.
`casefold`(/)	Return a version of the string suitable for caseless comparisons.
`center`(width[, fillchar])	Return a centered string of length width.
`count`(sub[, start[, end]])	Return the number of non-overlapping occurrences of substring sub in string S[start:end].
`de_skolemize`()	Create a Blank Node from a skolem URI, in accordance with http://www.w3.org/TR/rdf11-concepts/#section-skolemization.
`encode`(/[, encoding, errors])	Encode the string using the codec registered for encoding.
`endswith`(suffix[, start[, end]])	Return True if S ends with the specified suffix, False otherwise.
`eq`(other)	A "semantic"/interpreted equality function, by default, same as __eq__
`expandtabs`(/[, tabsize])	Return a copy where all tab characters are expanded using spaces.
`find`(sub[, start[, end]])	Return the lowest index in S where substring sub is found, such that sub is contained within S[start:end].
`format`(args, *kwargs)	Return a formatted version of S, using substitutions from args and kwargs.
`format_map`(mapping)	Return a formatted version of S, using substitutions from mapping.
`index`(sub[, start[, end]])	Return the lowest index in S where substring sub is found, such that sub is contained within S[start:end].
`isalnum`(/)	Return True if the string is an alpha-numeric string, False otherwise.
`isalpha`(/)	Return True if the string is an alphabetic string, False otherwise.
`isascii`(/)	Return True if all characters in the string are ASCII, False otherwise.
`isdecimal`(/)	Return True if the string is a decimal string, False otherwise.
`isdigit`(/)	Return True if the string is a digit string, False otherwise.
`isidentifier`(/)	Return True if the string is a valid Python identifier, False otherwise.
`islower`(/)	Return True if the string is a lowercase string, False otherwise.
`isnumeric`(/)	Return True if the string is a numeric string, False otherwise.
`isprintable`(/)	Return True if the string is printable, False otherwise.
`isspace`(/)	Return True if the string is a whitespace string, False otherwise.
`istitle`(/)	Return True if the string is a title-cased string, False otherwise.
`isupper`(/)	Return True if the string is an uppercase string, False otherwise.
`join`(iterable, /)	Concatenate any number of strings.
`ljust`(width[, fillchar])	Return a left-justified string of length width.
`lower`(/)	Return a copy of the string converted to lowercase.
`lstrip`([chars])	Return a copy of the string with leading whitespace removed.
`maketrans`(x[, y, z])	Return a translation table usable for str.translate().
`n3`([namespace_manager])	This will do a limited check for valid URIs, essentially just making sure that the string includes no illegal characters (<, >, ", {, }, \|, \, `, ^)
`neq`(other)	A "semantic"/interpreted not equal function, by default, same as __ne__
`partition`(sep, /)	Partition the string into three parts using the given separator.
`removeprefix`(prefix, /)	Return a str with the given prefix string removed if present.
`removesuffix`(suffix, /)	Return a str with the given suffix string removed if present.
`replace`(old, new[, count])	Return a copy with all occurrences of substring old replaced by new.
`rfind`(sub[, start[, end]])	Return the highest index in S where substring sub is found, such that sub is contained within S[start:end].
`rindex`(sub[, start[, end]])	Return the highest index in S where substring sub is found, such that sub is contained within S[start:end].
`rjust`(width[, fillchar])	Return a right-justified string of length width.
`rpartition`(sep, /)	Partition the string into three parts using the given separator.
`rsplit`(/[, sep, maxsplit])	Return a list of the substrings in the string, using sep as the separator string.
`rstrip`([chars])	Return a copy of the string with trailing whitespace removed.
`split`(/[, sep, maxsplit])	Return a list of the substrings in the string, using sep as the separator string.
`splitlines`(/[, keepends])	Return a list of the lines in the string, breaking at line boundaries.
`startswith`(prefix[, start[, end]])	Return True if S starts with the specified prefix, False otherwise.
`strip`([chars])	Return a copy of the string with leading and trailing whitespace removed.
`swapcase`(/)	Convert uppercase characters to lowercase and lowercase characters to uppercase.
`title`(/)	Return a version of the string where each word is titlecased.
`translate`(table, /)	Replace each character in the string using the given translation table.
`upper`(/)	Return a copy of the string converted to uppercase.
`zfill`(width, /)	Pad a numeric string with zeros on the left, to fill a field of the given width.

defrag
toPython

plume.rdf.utils.FRA_URI = rdflib.term.URIRef('http://publications.europa.eu/resource/authority/language/FRA')#: URI de référence pour représenter la langue française.

plume.rdf.utils.LANGUAGE_REG = re.compile('^[a-zA-Z]+(?:-[a-zA-Z0-9]+)*$')#: Expression régulière servant à contrôler la validité des tags de langue.

class plume.rdf.utils.MetaCollection(*args, **kwargs)#

Bases : type

Méta-classe gérant l’accès à une collection d’objets.

Pour les classes créées avec cette méta-classe, les objets sont à la fois créés et rappelés via cls[key], où cls est le nom de la classe et key une clé identifiant l’objet. Celle-ci doit être pouvoir être utilisée pour générer un nouvel objet. S’il s’agit d’un tuple, *key est passé au constructeur, sinon key est passé tel quel.

À noter que les objets ne sont pas répertoriés automatiquement lorsque le constructeur de la classe est appelé directement, ce qui est donc déconseillé.

Methods

`__call__`(args, *kwargs)	Call self as a function.
`mro`(/)	Return a type's method resolution order.

plume.rdf.utils.RDFLIB_FORMATS = {'json-ld': {'export default': True, 'extensions': ['.jsonld', '.json'], 'import': True}, 'n3': {'export default': True, 'extensions': ['.n3'], 'import': True}, 'nt': {'export default': True, 'extensions': ['.nt'], 'import': True}, 'pretty-xml': {'export default': True, 'extensions': ['.rdf', '.xml'], 'import': False}, 'trig': {'export default': True, 'extensions': ['.trig'], 'import': True}, 'turtle': {'export default': True, 'extensions': ['.ttl'], 'import': True}, 'xml': {'export default': False, 'extensions': ['.rdf', '.xml'], 'import': True}}#

Formats reconnus par les fonctions de RDFLib.

Si la clé import vaut False, le format n’est pas reconnu à l’import. Si export default vaut True, il s’agit du format d’export privilégié pour les extensions listées par la clé extension.

plume.rdf.utils.abspath(relpath)#

Déduit un chemin absolu d’un chemin relatif au package.

Parameters:

relpath (str):: Chemin relatif au package. Il n’est ni nécessaire ni judicieux d’utiliser la syntaxe Windows à base d’antislashs.

Returns:

pathlib.Path

Examples

>>> abspath('rdf/data/vocabulary.ttl')
WindowsPath('C:/Users/Alhyss/Documents/GitHub/metadata-postgresql/plume/rdf/data/vocabulary.ttl')

plume.rdf.utils.all_words_included(included, including)#

Détermine si tous les mots d’une chaîne de caractères sont inclus dans une autre.

La fonction renvoie toujours 'False' si l’un des arguments est une chaîne de caractères vides ou 'None', ou ne contient aucun caractère alpha-numérique.

Parameters:

includedstr: La chaîne de caractères dont on veut tester l’inclusion.
includingstr: La chaîne de caractères dans laquelle on veut tester l’inclusion.

Returns:

bool

plume.rdf.utils.almost_included(included, including)#

Détermine si une chaîne de caractères est incluse dans une autre, en ignorant les caractères non alpha-numériques et la casse.

La fonction renvoie toujours 'False' si l’un des arguments est une chaîne de caractères vides ou 'None', ou ne contient aucun caractère alpha-numérique.

Parameters:

includedstr: La chaîne de caractères dont on veut tester l’inclusion.
includingstr: La chaîne de caractères dans laquelle on veut tester l’inclusion.

Returns:

bool

plume.rdf.utils.data_from_file(filepath)#

Renvoie le contenu d’un fichier.

Le fichier sera présumé être encodé en UTF-8 et mieux vaudrait qu’il le soit.

On pourra utiliser conjointement abspath() pour l’import de données du modèle:

>>> data_from_file(abspath('pg/tests/samples/pg_description_1.txt'))

Parameters:

filepathstr: Chemin complet du fichier source.

Returns:

str

Voir aussi

graph_from_file: Import de données RDF.

plume.rdf.utils.date_from_str(value)#

Renvoie la représentation RDF d’une date exprimée comme chaîne de caractères.

Parameters:

valuestr: La date, sous la forme “jj/mm/aaaa”, sans quoi la fonction renverra None.

Returns:

rdflib.term.Literal: Un littéral de type xsd:date.

Notes

La fonction tolère des informations excédentaires après la date (par exemple une heure). Elle tronque alors la valeur pour ne conserver que la date.

Examples

>>> date_from_str('13/02/2022')
rdflib.term.Literal('2022-02-13', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#date'))

plume.rdf.utils.datetime_from_str(value)#

Renvoie la représentation RDF d’une date exprimée comme chaîne de caractères.

Parameters:

valuestr: La date, sous la forme “jj/mm/aaaa hh:mm:ss”, sans quoi la fonction renverra None.

Returns:

rdflib.term.Literal: Un littéral de type xsd:dateTime.

Notes

La fonction tolère qu’on ne lui fournisse qu’une date (informations relatives à l’heure manquantes). Il est alors considéré que l’heure était '00:00:00'.

La fonction tolère des informations excédentaires après la valeur des secondes (ou après la date sans heure), mais elles seront silencieusement effacées.

Examples

>>> datetime_from_str('13/02/2022 15:30:14')
rdflib.term.Literal('2022-02-13T15:30:14', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#dateTime'))

plume.rdf.utils.decimal_from_str(value)#

Renvoie la représentation RDF d’un nombre décimal exprimé comme chaîne de caractères.

Parameters:

valuestr: Le nombre décimal. La virgule et le point sont tous deux acceptés comme séparateurs entre la partie entière et la partie décimale.

Returns:

rdflib.term.Literal: Un littéral de type xsd:decimal.

Notes

La fonction renvoie None pour une valeur mal formée.

Examples

>>> decimal_from_str('-1,25')
rdflib.term.Literal('-1.25', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#decimal'))

plume.rdf.utils.duration_from_int(value, unit)#

Renvoie la représentation RDF d’une durée exprimée sous la forme d’une valeur entière et d’une unité.

Parameters:

valueint or str: La valeur de la durée. Elle peut être de type int ou str, tant qu’il s’agit bien d’un nombre. Les durées négative sont prises en charge.
unit{“ans”, “mois”, “jours”, “heures”, “min.”, “sec.”}: L’unité de la durée. La fonction renverra None si la valeur renseignée n’est pas dans la liste des unités prises en charge.

Returns:

rdflib.term.Literal: Un littéral de type xsd:duration.

Examples

>>> duration_from_int(2, 'ans')
rdflib.term.Literal('P2Y', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#duration'))

plume.rdf.utils.email_from_owlthing(thing_iri)#

Renvoie la transcription sous forme de chaîne de caractères d’un IRI représentant une adresse mél.

Cette fonction très basique se contente de retirer le préfixe « mailto: » s’il était présent.

Parameters:

thing_irirdflib.term.URIRef: IRI supposé correspondre à une adresse mél (classe RDF owl:Thing).

Returns:

str

Examples

>>> email_from_owlthing(URIRef('mailto:jon.snow@the-wall.we'))
'jon.snow@the-wall.we'

plume.rdf.utils.export_extension_from_format(format)#

Renvoie l’extension utilisée pour les exports dans le format considéré.

Parameters:

formatstr: Un format d’export présumé inclus dans la liste des formats reconnus par les fonctions de RDFLib (RDFLIB_FORMATS).

Returns:

str: L’extension à utiliser pour le format considéré, avec le point.

Examples

>>> rdf_utils.export_extension('pretty-xml')
'.rdf'

plume.rdf.utils.export_format_from_extension(extension, default_format=None)#

Renvoie le format d’export correspondant à l’extension.

Parameters:

extensionstr: Une extension (avec point).
default_formatstr, optional: Un format d’export présumé inclus dans la liste des formats reconnus par les fonctions de RDFLib (RDFLIB_FORMATS). Si renseigné, le format par défaut est utilisé lorsqu’il n’est pas possible de déduire un format de l’extension ou lorsque plusieurs formats sont possibles pour l’extension (le format par défaut est alors privilégié s’il fait partie des formats en question).

Returns:

str: Un nom de format. La fonction renvoie None si l’extension n’est pas reconnue.

plume.rdf.utils.export_formats(no_duplicate=False, format=None)#

Renvoie la liste de tous les formats disponibles pour l’export.

Parameters:

no_duplicatebool, default False: Si True, lorsque plusieurs formats disponibles utilise la même extension (cas notamment de 'xml' et 'pretty-xml'), la fonction n’en renvoie qu’un.
formatstr, optional: Un format d’export à prioriser. format ne sera jamais éliminé par la suppression de pseudo-doublons effectuée lorsque no_duplicate vaut True. Il s’agira toujours de la première valeur de la liste renvoyée, sauf s’il ne s’agissait pas d’un format d’export disponible (auquel cas il ne sera pas du tout dans la liste renvoyée).

Returns:

list of str: La liste des formats reconnus par RDFLib à l’export.

plume.rdf.utils.flatten_values(values)#

Renvoie une copie de la liste en encodant en JSON les valeurs de type dictionnaire.

Parameters:

valueslist: Une liste de valeurs de types arbitraires.

Returns:

list

plume.rdf.utils.forbidden_char(anystr)#

Le cas échéant, renvoie le premier caractère de la chaîne qui ne soit pas autorisé dans un IRI.

Parameters:

anystrstr: La chaîne de caractères à tester.

Returns:

str: Si la chaîne contient au moins un caractère interdit, l’un de ces caractères.

Examples

>>> forbidden_char('avec des espaces')
' '

plume.rdf.utils.get_datasetid(anygraph)#

Renvoie l’identifiant du jeu de données éventuellement contenu dans le graphe.

Parameters:

anygraphrdflib.graph.Graph: Un graphe quelconque, présumé contenir la description d’un jeu de données (dcat:Dataset).

Returns:

URIRef: L’identifiant du jeu de données. None si le graphe ne contenait pas de jeu de données.

plume.rdf.utils.graph_from_file(filepath, format=None)#

Désérialise le contenu d’un fichier sous forme de graphe.

Le fichier sera présumé être encodé en UTF-8 et mieux vaudrait qu’il le soit.

Parameters:

filepathstr: Chemin complet du fichier source, supposé contenir des métadonnées dans un format RDF, sans quoi l’import échouera.
formatstr, optional: Le format des métadonnées. Si non renseigné, il est autant que possible déduit de l’extension du fichier, qui devra donc être cohérente avec son contenu. Pour connaître la liste des valeurs acceptées, on exécutera import_formats().

Returns:

rdflib.graph.Graph: Un graphe.

Voir aussi

plume.rdf.metagraph.metagraph_from_file: Désérialise le contenu d’un fichier sous forme de graphe de métadonnées.

plume.rdf.utils.import_extensions_from_format(format=None)#

Renvoie la liste des extensions associées à un format d’import.

Parameters:

formatstr, optional: Un format d’import présumé inclus dans la liste des formats reconnus par les fonctions de RDFLib (RDFLIB_FORMATS avec import valant True).

Returns:

list of str: La liste de toutes les extensions associées au format considéré, avec le point. Si format n’est pas renseigné, la fonction renvoie la liste de toutes les extensions reconnues pour l’import.

Examples

>>> import_extensions_from_format('xml')
['.rdf', '.xml']

plume.rdf.utils.import_format_from_extension(extension)#

Renvoie le format d’import correspondant à l’extension.

Parameters:

extensionstr: Une extension (avec point).

Returns:

str: Un nom de format. La fonction renvoie None si l’extension n’est pas reconnue.

plume.rdf.utils.import_formats()#

Renvoie la liste de tous les formats disponibles pour l’import.

Returns:

list of str: La liste des formats reconnus par RDFLib à l’import.

plume.rdf.utils.int_from_duration(duration)#

Extrait un nombre entier et son unité d’un littéral représentant une durée.

Cette fonction renvoie (None, None) si la valeur fournie en argument n’était pas un littéral de type xsd:duration ou si, parce qu’il n’était pas correctement formé, il n’a pas été possible d’en extaire une valeur.

Les durées complexes faisant appel à plusieurs unités sont tronquées. La fonction conserve l’entier associé à l’unité la plus grande.

Parameters:

durationrdflib.term.Literal: Un littéral de type xsd:duration.

Returns:

tuple(int, {“ans”, “mois”, “jours”, “heures”, “min.”, “sec.”}): Un tuple dont le premier élément est l’entier correspondant à la valeur de la durée et le second l’unité de cette durée.

Examples

>>> int_from_duration(Literal('P2Y', datatype=XSD.duration))
(2, 'ans')

plume.rdf.utils.langstring_from_str(value, value_language)#

Transforme une chaîne de caractères avec une langue associée en valeur littérale RDF.

Parameters:

valuestr: La valeur textuelle.
value_languagestr: Le code correspondant à langue de la valeur.

Returns:

rdflib.term.Literal or None: La fonction renvoie None si value_language n’est pas un code de langue valide.

plume.rdf.utils.main_datatype(values)#

Renvoie le type de littéral pré-dominant d’une liste de valeurs.

Parameters:

valueslist(rdflib.term.Literal or rdflib.term.URIRef or rdflib.term.BNode): Une liste de valeurs.

Returns:

rdflib.term.URIRef: Un type de valeur littérale, sous la forme d’un IRI RDF.

Notes

La fonction renvoie None si la liste ne contenait aucune valeur littérale (y compris pour une liste vide). Sinon, le type sera :

rdf:langString si la liste contient au moins une valeur littérale dont la langue est déclarée.

Si toutes les valeurs sont littérales et de même type, ledit type.

xsd:decimal si toutes les valeurs sont littérales et de type xsd:decimal ou xsd:integer.

xsd:dateTime si toutes les valeurs sont littérales et de type xsd:date ou xsd:dateTime.

xsd:string dans tous les autres cas.

plume.rdf.utils.no_logging(level=50)#

Gestionnaire de contexte qui désactive temporairement la journalisation des erreurs.

Parameters:

levelint, default logging.CRITICAL: Niveau de sévérité jusqu’auquel l’émission des messages doit être inhibée.

plume.rdf.utils.owlthing_from_email(email_str)#

Construit un IRI valide à partir d’une chaîne de caractères représentant une adresse mél.

La fonction ne fait aucun contrôle de validité sur l’adresse si ce n’est vérifier qu’elle ne contient aucun caractère interdit pour un IRI.

Parameters:

email_strstr: Une chaîne de caractère supposée correspondre à une adresse mél.

Returns:

rdflib.term.URIRef: Un IRI respectant grosso modo le schéma officiel des URI pour les adresses mél : mailto:<email>.

Examples

>>> owlthing_from_email('jon.snow@the-wall.we')
rdflib.term.URIRef('mailto:jon.snow@the-wall.we')

plume.rdf.utils.owlthing_from_tel(tel_str, add_fr_prefix=True)#

Construit un IRI valide à partir d’une chaîne de caractères représentant un numéro de téléphone.

Si le numéro semble être un numéro de téléphone français valide, il est standardisé sous la forme <tel:+33-x-xx-xx-xx-xx>.

Parameters:

tel_strstr: Une chaîne de caractère supposée correspondre à un numéro de téléphone.
add_fr_prefixbool, default True: True si la fonction doit tenter de transformer les numéros de téléphone français locaux ou présumés comme tels (un zéro suivi de neuf chiffres) en numéros globaux ('+33' suivi des neuf chiffres). True par défaut.

Returns:

rdflib.term.URIRef: Un IRI respectant grosso modo le schéma officiel des URI pour les numéros de téléphone : tel:<phonenumber>.

Examples

>>> owlthing_from_tel('0123456789')
rdflib.term.URIRef('tel:+33-1-23-45-67-89')

plume.rdf.utils.path_from_n3(path_n3, nsm)#

Renvoie un chemin d’IRI reconstruit à partir de sa représentation N3.

Parameters:

path_n3str: Représentation N3 d’un chemin d’IRI. Les préfixes utilisés doivent impérativement être ceux du gestionnaire d’espaces de nommage, et a fortiori de Plume (plume.rdf.namespaces.namespaces).
nsmplume.rdf.namespaces.PlumeNamespaceManager: Un gestionnaire d’espaces de nommage.

Returns:

URIRef or rdflib.paths.Path: Le chemin d’IRI. None si la reconstruction a échoué, soit parce que path_n3 n’était pas vraiment la représentation N3 d’un chemin d’IRI, soit parce que tous les préfixes utilisés n’ont pas été reconnus.

plume.rdf.utils.path_n3(path, nsm)#

Renvoie la représentation N3 d’un chemin d’IRI.

Parameters:

pathrdflib.term.URIRef or rdflib.paths.Path: Un chemin d’IRI.
nsmplume.rdf.namespaces.PlumeNamespaceManager: Un gestionnaire d’espaces de nommage.

Returns:

str

Notes

RDFLib propose bien une méthode rdflib.paths.Path.n3() pour transformer les chemins d’IRI… mais elle ne prend pas d’espace de nommage en argument à ce stade (v 6.0.1). Son autre défaut est d’écrire les chemins sans espaces avant et après les slashs.

plume.rdf.utils.pick_translation(litlist, langlist)#

Renvoie l’élément de la liste dont la langue est la mieux adaptée.

Parameters:

litlistlist(rdflib.term.Literal): Une liste de valeurs litérales, présumées de type xsd:string ou rdf:langString.
langlistlist(str) or tuple(str) or str: Une langue ou une liste de langues triées par priorité décroissante.

Returns:

rdflib.term.Literal

Un des éléments de litlist, qui peut être :

le premier dont la langue est la première valeur de langlist ;
le premier dont la langue est la deuxième valeur de langlist ;
et ainsi de suite jusqu’à épuisement de langlist ;
à défaut, le premier élément de litlist.

Notes

Cette fonction peut ne pas renvoyer un objet de classe rdflib.term.Literal si litlist ne contenait que des valeurs non litérales.

plume.rdf.utils.sort_by_language(litlist, langlist)#

Trie une liste selon les langues de ses valeurs.

Parameters:

litlistlist(rdflib.term.Literal): Une liste de valeurs litérales, présumées de type xsd:string ou rdf:langString.
langlistlist(str) or tuple(str): Une liste de langues, triées par priorité décroissante.

plume.rdf.utils.split_rdf_wkt(rdf_wkt)#

Extrait le référentiel et la géométrie d’un littéral WKT.

Parameters:

rdf_wktstr or rdflib.term.Literal: Une représentation WKT de la géométrie avec le référentiel explicitement déclaré, comme attendu en RDF pour le type gsp:wktLiteral. Par défaut, le référentiel sera supposé être 'OGC:CRS84'.

Returns:

tuple(str, str): Un tuple dont le premier élément est la géométrie, toujours encodée en WKT mais sans référentiel, et le second élément est le référentiel, sous la forme 'Autorité:Code'.

Notes

La fonction renvoie None si l’autorité n’a pas été reconnue, mais ne fait qu’un contrôle de forme superficiel sur l’identifiant du référentiel (qui pourrait donc ne pas être une valeur référencée). La validité de la géométrie n’est pas vérifiée.

Examples

>>> split_rdf_wkt('<http://www.opengis.net/def/crs/EPSG/0/2154> '     ...     'POINT(651796.32814998598769307 6862298.58582336455583572)')
('POINT(651796.32814998598769307 6862298.58582336455583572)', 'EPSG:2154')

>>> split_rdf_wkt('POINT(651796.32814998598769307 6862298.58582336455583572)')
('POINT(651796.32814998598769307 6862298.58582336455583572)', 'OGC:CRS84')

plume.rdf.utils.str_from_date(datelit)#

Représentation d’une date sous forme de chaîne de caractères.

Parameters:

datelitrdflib.term.Literal: Un littéral de type xsd:date. Les valeurs de type xsd::dateTime sont tolérées (et seront tronquées).

Returns:

str

Notes

La fonction renvoie None pour une valeur mal formée ou qui n’est pas un littéral de type xsd:date.

Examples

>>> str_from_date(Literal('2022-02-12', datatype=XSD.date))
'12/02/2022'

plume.rdf.utils.str_from_datetime(datetimelit)#

Représentation d’une date avec heure sous forme de chaîne de caractères.

Parameters:

datetimelitrdflib.term.Literal: Un littéral de type xsd:dateTime. Les valeurs de type xsd::date sont tolérées.

Returns:

str

Notes

La fonction renvoie None pour une valeur mal formée ou qui n’est pas un littéral de type xsd:dateTime ou xsd:date.

À ce stade, les heures sont tronquées à la seconde et les fuseaux horaires effacés.

Examples

>>> str_from_datetime(Literal('2022-02-12T00:00:00', datatype=XSD.dateTime))
'12/02/2022 00:00:00'

plume.rdf.utils.str_from_decimal(decimal)#

Représentation d’un nombre décimal sous forme de chaîne de caractères.

Parameters:

decimalrdflib.term.Literal: Un littéral de type xsd:decimal. Les valeurs de type xsd:integer sont tolérées.

Returns:

str

Notes

La fonction renvoie None pour une valeur mal formée ou qui n’est pas un littéral de type xsd:decimal.

Elle prend en compte les paramètres de localisation système pour choisir le séparateur (virgule ou point) à utiliser.

Examples

>>> str_from_decimal(Literal('1.25', datatype=XSD.decimal))
'1,25'

plume.rdf.utils.str_from_duration(duration)#

Représentation d’une durée sous forme de chaîne de caractères.

Parameters:

durationrdflib.term.Literal: Un littéral de type xsd:duration.

Returns:

str

Notes

Cette fonction produit des valeurs pour un affichage en lecture seule. Il n’existe pas de fonction retour pour reconstruire un littéral de type xsd:duration à partir d’une représentation de cette forme.

Examples

>>> str_from_duration(Literal('P2Y', datatype=XSD.duration))
'2 ans'

plume.rdf.utils.str_from_time(timelit)#

Représentation d’une heure sous forme de chaîne de caractères.

Parameters:

timelitrdflib.term.Literal: Un littéral de type xsd:time.

Returns:

str

Notes

La fonction renvoie None pour une valeur mal formée ou qui n’est pas un littéral de type xsd:time.

À ce stade, les heures sont tronquées à la seconde et les fuseaux horaires effacés.

Examples

>>> str_from_time(Literal('15:30:14', datatype=XSD.time))
'15:30:14'

plume.rdf.utils.tel_from_owlthing(thing_iri)#

Renvoie la transcription sous forme de chaîne de caractères d’un IRI représentant un numéro de téléphone.

Contrairement à owlthing_from_tel(), cette fonction très basique ne standardise pas la forme du numéro de téléphone. Elle se contente de retirer le préfixe 'tel:' s’il était présent.

Parameters:

thing_irirdflib.term.URIRef: IRI supposé correspondre à un numéro de téléphone (classe RDF owl:Thing).

Returns:

str

Examples

>>> tel_from_owlthing(URIRef('tel:+33-1-23-45-67-89'))
'+33-1-23-45-67-89'

plume.rdf.utils.text_with_link(anystr, anyiri)#

Génère un fragment HTML définissant un lien.

Parameters:

anystrstr: La chaîne de caractères porteuse du lien.
anyirirdflib.term.URIRef: Un IRI quelconque correspondant à la cible du lien.

Returns:

str: Une chaîne de caractère correspondant à un élément A, qui sera interprétée par les widgets comme du texte riche. Si anyiri n’est pas défini, anystr est renvoyé tel quel.

Examples

>>> text_with_link(
...     "Documentation de PostgreSQL 10",
...     URIRef("https://www.postgresql.org/docs/10/index.html")
...     )
'<A href="https://www.postgresql.org/docs/10/index.html">Documentation de PostgreSQL 10</A>'

plume.rdf.utils.time_from_str(value)#

Renvoie la représentation RDF d’une heure exprimée comme chaîne de caractères.

Parameters:

valuestr: L’heure, sous la forme “hh:mm:ss”, sans quoi la fonction renverra None.

Returns:

rdflib.term.Literal: Un littéral de type xsd:time.

Notes

La fonction tolère des informations excédentaires après la valeur des secondes, mais elles ne seront pas prises en compte.

Examples

>>> time_from_str('15:30:14')
rdflib.term.Literal('15:30:14', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#time'))

plume.rdf.utils.wkt_with_srid(wkt, srid)#

Ajoute un référentiel de coordonnées à la représentation WKT d’une géométrie.

Parameters:

wktstr: Représentation WKT (Well Known Text) d’une géométrie. La validité de ladite représentation n’est pas vérifiée par la fonction.
sridstr: L’identifiant du référentiel de coordonnées utilisé pour la représentation WKT, sous la forme 'Autorité:Code'. À ce stade, ne sont reconnus que les codes EPSG (ex : 'EPSG:2154'), les identifiants OGC (ex : 'OGC:CRS84') et les identifiants du registre IGN (ex : 'IGNF:WGS84G').

Returns:

str: La représentation WKT de la géométrie avec le référentiel explicitement déclaré, comme attendu en RDF.

Notes

La fonction renvoie None si l’autorité n’a pas été reconnue.

Examples

>>> wkt_with_srid(
...     'POINT(651796.32814998598769307 6862298.58582336455583572)',
...     'EPSG:2154'
...      )
'<http://www.opengis.net/def/crs/EPSG/0/2154> POINT(651796.32814998598769307 6862298.58582336455583572)'