Saravanan666/pypi-org huggingface dataset:
Package: rdf
A pure Python package providing the core RDF constructs.The packages is intended to provide the core RDF types and interfaces
that other packages can build on. The package defines a plugin
interface for parsers, stores, and serializers that other packages can
use to implement parsers, stores, and serializers that will plug into
the rdf package.Therdfpackage does not itself contain any plugin
implementation. So, you will want to install a library that builds
uponrdfand defines some plugin implementations. One such library
isrdflibversion 3.x.The primary interfacerdfexposes to work with RDF isrdf.graph.Graph.A tiny example:>>> from rdf.graph import Graph>>> g = Graph()
>>> result = g.parse("http://eikeon.com/foaf.rdf")>>> print "graph has %s statements." % len(g)
graph has 34 statements.
>>>
>>> for s, p, o in g:
...     if (s, p, o) not in g:
...         raise Exception("It better be!")>>> s = g.serialize(format='n3')
Package: rdf2html
ContextWork done during the course of in my Master's in Languages and Knowledge Representation at University of Minho.ProblemCreate a way to visualize ontologies in HTML using python as the base to the solutionSolutionA python script using several libraries including graphviz dot that outputs a simple HTML page that allows to explore the ontologie
content without the need to load it into a database engine or a ontologie editor like ProtegeThe input format must be in rdf and this solution was made directed to small/medium ontologies, otherwise the graphs will be confusingInstalationpip install rdf2htmlCurrent useimport rdf2htmlfrom rdf2html import translatortranslator.exec(["path_to_rdf/rdf_file.rdf"])ContributorTiago Baptista
Package: rdf2puml
rdf2pumlCreate plantuml documentation from rdf modelInstallationpipinstallrdf2pumlInstallation for development purposespip install -e .Usagerdf2puml --helpContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.Authors and acknowledgmentFor readme file I used format fromhttps://www.makeareadme.com/LicenseGNU GPLv3
Package: rdfa2rdf
RDFa2RDF Is a proxy for transforming RDFa to RDF using Fabien Gandon’s RDFa2RDFXML
stylesheet.
The latest version of RDFa2RDFXML.xsl is available athttp://ns.inria.fr/grddl/rdfa/2007/09/12/RDFa2RDFXML.xsl.
Package: rdf-expressionizer
rdf-expressionizerTranslates named classes to equivalent class expressions.The primary use case for this is rewiring ontologies that use upper ontologies such as BFO,
preserving semantic entailment, and hiding upper ontology classes in an orthogonal hierarchy.Installationpipxinstallrdf-expressionizer
rdf-expressionizer--helpExample WorkflowsRewiring an ontology that uses BFOrdf-expressionizerreplace-mbfo_xbfo_mappingsro.owl-oro-rewired.owlNote that the semantics of axioms are preserved, but structurally rewritten.For example, the following axiom:occurs inDomainoccurrent natureIs rewritten to:occurs inDomainhas characteristicsomeoccurrent natureTODO: decide on which ObjectProperty to use forbfo_xbfo_mappingsNote the resulting ontology has dangling flat label-less classes. These are semantically correct, but
to give them labels and hierarchy, merge withXBFO.robotmerge-iro-rewired.owl-isrc/rdf-expressionizer/xbfo.owl-oro-rewired-pretty.owlRewiring an ontology preserving COB subsetrdf-expressionizerreplace-xCOB-mbfo_xbfo_mappingsro.owl-oro-rewired.owlThis excludes (-xor--exclude-subset) the COB subset of BFO from the rewiring.Augmenting COB with equivalence axiomsrdf-expressionizeraugment-mbfo_xbfo_mappingscob.owl-ocob-augmented.owlTestinggitclone<thisrepo>
poetryinstall
maketestThis runs internal unit tests, and additional tests.One of the tests does the following:injects an invalid axiom into ROCell occurs-in some 'Multi-cellular organism'this axiom is designed to cause incoherency when combined with upper level BFO disjointness axiomscreates a rewired version of ROrunsrobot explainchecks the intended unsatisfiable axiom is detectedcellSubClassOfNothing##cellSubClassOfanatomical structureanatomical structureSubClassOfmaterial anatomical entitymaterial anatomical entitySubClassOfanatomical entityanatomical entitySubClassOfhas characteristicsomeindependent continuant natureindependent continuant natureSubClassOfcontinuant naturecellSubClassOfoccurs insomemulticellular anatomical structureoccurs inDomainhas characteristicsomeoccurrent naturehas characteristicsomecontinuant natureDisjointWithhas characteristicsomeoccurrent natureLimitationsOntology must be in RDF serializationTODO: add options for non RDF/XML serializations
Package: rdfextras
RDFExtras is a collection of packages providing extras based on RDFLib. These
include a tools package and several “non-core-rdflib” store implementations.RDFExtras includes:A pure-python SPARQL implementation for in-memory stores or other store
that do not provide their own SPARQL implementation.A set of commandline utilities: rdfpipe, rdf2dot, rdfs2dot, csv2rdfDependencies:RDFLib>=3.2.1For SPARQL: pyparsingFor more information see:RDFExtras:http://github.com/RDFLib/rdfextras/RDFExtras Docs:http://readthedocs.org/docs/rdfextras/RDFLib:http://github.com/RDFLib/rdflib/RDFLib Docs:http://readthedocs.org/docs/rdflibDiscussion group:http://groups.google.com/group/rdflib-dev
Package: rdf-fingerprinter
RDF fingerprinterUnderstandthe structure of your RDF data at a glance using automatically builtapplication profilesand spot differences between dataset structures.Anapplication profile, in this context, is the set ofdata shapesdesigned for a particular purpose acting as constraints on how the data are instantiated and so can be used to validate the data.Fingerprintingis the action of generating, or rather, guessing, the application profile applied to a particular dataset. This is an inductive process of reconstructing the data shape for each class instantiated in the dataset.ContentsAPI ReferenceInstallationRDF fingerprinter may be installed with pip as follows.pip install rdf-fingerprinterNote that Python version 3.8 or later is required.UsageThe easiest way to build a fingerprint of a SPARQL endpoint is by calling the fingeprinting CLI command and write the report in an output folder.fingerprint-ehttp://my.sparql.endpoint.com-omy/output/folderTo use the fingerprinter programmatically please refer to theAPI Reference.ContributingYou are more than welcome to help expand and mature this project. We adhere toApache code of conduct, please follow it in all your interactions on the project.When contributing to this repository, please first discuss the change you wish to make via issue, email, or any other method with the maintainers of this repository before making a change.LicenceThis project is licensed underApache License 2.0.
Package: rdfframework
# knowledgelinks.io RDF Framework for web applications[![Build Status](https://travis-ci.org/KnowledgeLinks/rdfframework.svg)](https://travis-ci.org/KnowledgeLinks/rdfframework)Development Documentation is available on the Knowledgelinks.io’s
[website](http://knowledgelinks.io/products/rdfframework/index.html).This application reads an RDF data file that describes a web application using the [knowledgelinks.io][KL] data-structures RDF Vocabulary.###RDF Namespaces
PREFIX kds:http://knowledgelinks.io/ns/data-structures/PREFIX kdr:http://knowledgelinks.io/ns/data-resources/## Introduction
The versitility of RDF allows a simple means for describing anything. Using our developed vocabulary for describing a web application we are building a framework for a highly customizable, secure and a fully RDF/bigdata integrated web application framework. Since RDF databases do not have an inherent forced data structures like SQL Databases (i.e. table defs, primary keys, etc) they have great flexibility, however they are left open to having a lot of junk data. To solve this problem the kds vocabulary completely integrates with the any other RDF vocabulary (i.e. schema, FOAF, etc.) by augmenting those vocabularies with how they are to be used in the specific application.## Installation
This is set to run as a python package but does not need to be installed as a package. Add this repository as a git submodule
Then add sys.path.append(os.path.realpath(‘./….path-to…./rdfframework’)) to your root init or application start-up### From source## Configuration## Usage[KL]:http://knowledgelinks.io/[FEDORA]:http://fedora-commons.org/[ISLANDORA_CA]:http://islandora.ca/[OPENBADGE]:http://openbadges.org/[PY3]:https://www.python.org/[VRTENV]:http://virtualenv.readthedocs.org/
Package: rdfhelpers
RDF HelpersUseful stuff when programming with RDFLib:Various ways to manipulate RDF graphs (shortcuts, really)Predefined graph transformations (e.g., containers --> repeated properties)Templated queries (substitution not limited to RDF terms like in RDFLib withinitBindings)Templated graph creation (based on SPARQLCONSTRUCT)Journaled graphsLabel cachingetc.Available to installfrom PyPI. Documentation can be foundhere.To Do:More test coverageMore predefined transformations (e.g., flat descriptions --> hierarchical descriptions)ContactAuthor: Ora Lassilaora@somanyaircraft.comCopyright (c) 2022 Ora Lassila andSo Many Aircraft
Package: rdfind2
rdfind2find duplicated files (in one fs) very fast.rdfind2 will filter files by size, head, tail and inode.Only hash full files content when it's necessary.Installwith pipx:pipxinstallrdfind2with pip:pipinstallrdfind2Usage:Usage: rdfind2 [OPTIONS] LOCATION...

Options:
  --hardlink               make hardlink between duplicate.
  --delete                 delete duplicated files, keep only one file.
  --delete-from PATH       when using --delete flags, only delete files in
                           specific directory.
  --delete-ignore-inode    when using --delete, ignore file's inode attribute.
                           This means rdfind2 will keep only 1 file of already
                           hardlink-ed files.
  --min-file-size INTEGER
  --unsafe INTEGER RANGE   unsafe partial fast checksum, check only 1/N
                           content of this file. If pass --unsafe=1, it will
                           behave like safe hash  [x>=1]
  --ext TEXT               included files by extensions
  --ignore-ext TEXT        exclude files by extensions
  -v, --verbose            increase output level
  --dry-run
  --help                   Show this message and exit.
Package: rdflib-appengine
This aim of this project is to allow rdflib, the Python RDF library, to be deployed on Google App Engine (GAE) with data be persisted in the NDB storage.All use is at your own risk.To use this project your application should run on GAE using Python 2.7.Assuming that you are familiar with rdflib (https://rdflib.readthedocs.org/en/latest/), to get started with this project, simply create a graph like this:fromrdflibimportGraphfromrdflib_appengine.ndbstoreimportNDBStoreg=Graph(store=NDBStore(identifier='my_first_store'))Seehttps://github.com/mr-niels-christensen/rdflib-appengineandhttps://semanticwebrecipes.wordpress.com/2015/01/09/triple-store-in-the-cloud/for further information.
Package: rdflib-django
A store implementation forrdflibthat uses Django as its backend.The current implementation is context-aware but not formula-aware.
Furthermore, performance has not yet been considered.The implementation assumes that contexts are used for named graphs.Quick startInstall rdflib-django with your package manager:pip install rdflib-djangoAddrdflib_djangoto yourINSTALLED_APPS:INSTALLED_APPS = (
    # other apps
    'rdflib_django'.
)You can now use the following examples to obtain a graph.Getting a graph using rdflib’s store API:from rdflib import Graph
graph = Graph('Django')
graph.open(create=True)This example will give you a graph identified by a blank node within the
default store.Getting a conjunctive graph using rdflib’s store API:from rdflib import ConjunctiveGraph
graph = ConjunctiveGraph('Django')This example will give you a conjunctive graph in the default store.Getting a named graph using rdflib-django’s API:from rdflib_django import utils
graph = utils.get_named_graph('http://example.com')Getting the conjunctive graph using rdflib-django’s API:from rdflib_django import utils
graph = utils.get_conjunctive_graph()Management commandsrdflib-djangoincludes two management commands to import and export
RDF:$ python manage.py import_rdf --context=http://example.com my_file.rdf
$ python manage.py export_rdf --context=http://example.comLicenserdflib-djangois licensed under theMIT license.
Package: rdflib-django3
rdflib-django3fork from rdflib-django with multi store architecture, python3 and recent rdflib
compatibility.A store implementation forrdflibthat uses Django as its backend.The current implementation is context-aware but not formula-aware.The implementation assumes that contexts are used for named graphs.Quick startInstall rdflib-django3 with your package manager:pipinstallrdflib-django3Addrdflib_djangoto yourINSTALLED_APPS:INSTALLED_APPS=(# other apps'rdflib_django'.)You can now use the following examples to obtain a graph.Getting a graph using rdflib's store API:fromrdflibimportGraphgraph=Graph('Django',identifier="fooo")graph.open(create=True)This example will give you a graph identified by a blank node within the
default store.Getting a conjunctive graph using rdflib's store API:fromrdflibimportConjunctiveGraphgraph=ConjunctiveGraph('Django')This example will give you a conjunctive graph in the default store.Getting a named graph using rdflib-django's API:fromrdflib_djangoimportutilsgraph=utils.get_named_graph('http://example.com')Getting the conjunctive graph using rdflib-django3's API:fromrdflib_djangoimportutilsgraph=utils.get_conjunctive_graph()Management commandsrdflib-django3includes two management commands to import and export
RDF:pythonmanage.pyimport_rdf--context=http://example.commy_file.rdf
pythonmanage.pyexport_rdf--context=http://example.comLicenserdflib-django3is licensed under theMIT license.Linksrdflib
Package: rdflib-jsonld
ARCHIVEDThis `rdflib <https://pypi.org/project/rdflib/>`_ plugin is deprecated
for, as of the 2021-09-17 release of rdflib 6.0.1, JSON-LD handing has been
integrated. All functionality in this package has been removed, as of release 0.6.2.This plugin is now ‘tombstoned’ meaning this - 0.6.2 - is a final release and
all users of Python > 3.6 are encouraged to move to rdflib > 6.0.1.If you are forced to keep using Python <= 3.6, you will need to keep using release <= 0.5.0 of this plugin with RDFlib 5.0.0.This is an implementation ofJSON-LDforRDFLib.
For more information about this technology, see theJSON-LD website.This implementation will:read in an JSON-LD formatted document and create an RDF graphserialize an RDF graph to JSON-LD formatted outputInstallationThe easiest way to install the RDFLib JSON-LD plugin is directly from PyPi using pip by running the command below:pipinstallrdflib-jsonldOtherwise you can download the source and install it directly by running:pythonsetup.pyinstallUsing the plug-in JSONLD serializer/parser with RDFLibThe plugin parser and serializer are automatically registered if installed by
setuptools.>>>fromrdflibimportGraph,plugin>>>fromrdflib.serializerimportSerializer>>>testrdf="""
... @prefix dcterms: <http://purl.org/dc/terms/> .
... <http://example.org/about>
...     dcterms:title "Someone's Homepage"@en .
... """>>>g=Graph().parse(data=testrdf,format='n3')>>>print(g.serialize(format='json-ld',indent=4)){"@id":"http://example.org/about","http://purl.org/dc/terms/title":[{"@language":"en","@value":"Someone's Homepage"}]}>>>context={"@vocab":"http://purl.org/dc/terms/","@language":"en"}>>>print(g.serialize(format='json-ld',context=context,indent=4)){"@context":{"@language":"en","@vocab":"http://purl.org/dc/terms/"},"@id":"http://example.org/about","title":"Someone's Homepage"}
Package: rdflib-jsonld-without-2to3
ARCHIVEDThe 0.7.0 release of this tool is a come back of rdflib-jsonld without use_2to3 usage. We needed this package to be published on pypi to provide a smooth migration path when upgrading cubicweb to rdflib 6.0.As of 2021-07-21, JSON-LD handling capability has been merged into the rdflib core `RDFLib <https://github.com/RDFLib/rdflib>`_ in its 6.0.0 release.Please stop using this plugin as soon as you can and migrate to rdflib >= 6.0.0.If you are forced to keep using Python <= 3.6, you will need to keep using this plugin with RDFlib 5.0.0.This is an implementation ofJSON-LDforRDFLib.
For more information about this technology, see theJSON-LD website.This implementation will:read in an JSON-LD formatted document and create an RDF graphserialize an RDF graph to JSON-LD formatted outputInstallationThe easiest way to install the RDFLib JSON-LD plugin is directly from PyPi using pip by running the command below:pipinstallrdflib-jsonldOtherwise you can download the source and install it directly by running:pythonsetup.pyinstallUsing the plug-in JSONLD serializer/parser with RDFLibThe plugin parser and serializer are automatically registered if installed by
setuptools.>>>fromrdflibimportGraph,plugin>>>fromrdflib.serializerimportSerializer>>>testrdf="""
... @prefix dcterms: <http://purl.org/dc/terms/> .
... <http://example.org/about>
...     dcterms:title "Someone's Homepage"@en .
... """>>>g=Graph().parse(data=testrdf,format='n3')>>>print(g.serialize(format='json-ld',indent=4)){"@id":"http://example.org/about","http://purl.org/dc/terms/title":[{"@language":"en","@value":"Someone's Homepage"}]}>>>context={"@vocab":"http://purl.org/dc/terms/","@language":"en"}>>>print(g.serialize(format='json-ld',context=context,indent=4)){"@context":{"@language":"en","@vocab":"http://purl.org/dc/terms/"},"@id":"http://example.org/about","title":"Someone's Homepage"}
Package: rdflib-pyld-compat
Support (some) data conversion betweenrdflibandpyldPython libraries.TherdflibandPyLDlibraries use different in-memory data structures so it
is not trivial to use the powerful RDF support of rdflib in conjuction with the JSON-LD processor
implementation of PyLD. This code is designed to provide a bridge between rdflib and PyLD in-memory
formats, avoiding the need to serialize and then re-parse the data.Requires Python 3.6 or higher because of dependencies.LimitationsThis code was developed to support a particular application and then pulled out as I needed it a
second time. I haven’t thought hard about the general case and am sure that are additional
limitations beyond those I know about. Known limitations:assumes the URIRefs in an rdflib graph do not need expansion with a NamespaceManagerHistoryLast version to work with Python 2.7 wasv0.0.2, install withpip install rdflib-pyld-compat==0.0.2ContributingI’d be happy to hear of other problems/limitations and/or suggestions for improvement.
Package: rdflib-pyldmod-compat
Support (some) data conversion betweenrdflibandpyldPython libraries.TherdflibandPyLDlibraries use different in-memory data structures so it
is not trivial to use the powerful RDF support of rdflib in conjuction with the JSON-LD processor
implementation of PyLD. This code is designed to provide a bridge between rdflib and PyLD in-memory
formats, avoiding the need to serialize and then re-parse the data.Requires Python 3.6 or higher because of dependencies.LimitationsThis code was developed to support a particular application and then pulled out as I needed it a
second time. I haven’t thought hard about the general case and am sure that are additional
limitations beyond those I know about. Known limitations:assumes the URIRefs in an rdflib graph do not need expansion with a NamespaceManagerHistoryLast version to work with Python 2.7 wasv0.0.2, install withpip install rdflib-pyld-compat==0.0.2ContributingI’d be happy to hear of other problems/limitations and/or suggestions for improvement.
Package: rdflib-sqlalchemy
SQLAlchemy store formula-aware implementation.
It stores its triples in the following partitions:Asserted non rdf:type statementsAsserted rdf:type statements (in a table which models Class membership).
The motivation for this partition is primarily improved query speed and
scalability as most graphs will always have more rdf:type statements than
others.All Quoted statementsIn addition it persists namespace mappings in a separate table
Package: rdflib-sqlalchemy-redux
SQLAlchemy store formula-aware implementation.  It stores its triples in
the following partitions:Asserted non rdf:type statementsAsserted rdf:type statements (in a table which models Class membership).
The motivation for this partition is primarily improved query speed and
scalability as most graphs will always have more rdf:type statements than
others.All Quoted statementsIn addition it persists namespace mappings in a separate table
Package: rdflib-sqlite
SQLite store formula-aware implementation.  It stores its triples in the following partitions:* Asserted non rdf:type statements- Asserted rdf:type statements (in a table which models Class membership).The motivation for this partition is primarily improved query speed andscalability as most graphs will always have more rdf:type statements thanothers.- All Quoted statementsIn addition it persists namespace mappings in a separate table
Package: rdflib-store-trigdump
rdflib-store-trigdumpThis is a thin wrapper aroundRDFLib'sMemory storeadding (unsafe) persistence:When opening the store, data is read from a TriG fileWhen closing the store, data is serialized to the TriG fileUsagefromrdflibimportGraphgraph=Graph("TriGDump")graph.open("/path/to/my/file.trig",create=True)# do somethinggraph.close()
Package: rdf-linkchecker
rdf_linkcheckerCheck URLs in Triple-Store files.Installationpython3-mpipinstallrdf-linkcheckerUsageRun with a list of files to checkrdf-linkcheckermyonefile.ttlmyotherfile.ttlConfigurationThe--config-filenameoption can be used to pass anINI-style file.[connection]
retries = 1
#seconds
timeout = 3
# first sleep in seconds between retries
# exponential backoff afterwards
sleep =1

[skip]
# any URL matching an entry in this comma separated list is not checked
domains = https://some.tld/path,http://someother.tld

# level: "all" | "only-failed" | "none"
# target: "console" | filename
"reporting": {"level": "all", "target": "console"}CreditsThis project was generated withpython-package-template
Package: rdfox
RDFox PyPI distributionRDFoxis a knowledge graph and semantic reasoning engine from Oxford Semantic Technologies. Thisrdfox-pypiPython package is an unofficial redistribution of the RDFox binaries so they can be used as a dependency of Python projects.UsageTo run RDFox from the command line, use:python-mrdfoxTo run RDFox from a Python program, usesys.executableto locate the Python binary to invoke. For example:importsys,subprocesssubprocess.call([sys.executable,"-m","rdfox"])LicenseRDFox requires a licence from Oxford Semantic Technologies.
Package: rdfpandas
RdfPandas is a module providing RDF support for Pandas. It consists of
two simple functions for Graph to DataFrame conversion and
DataFrame to Graph conversion.Getting StartedFor more information about Resource Description Framework (RDF) and Pandas see:RDF:https://www.w3.org/RDF/Pandas:https://pandas.pydata.org/PrerequisitesYou will need Python 3 to use Pandas and RdfPandas.Installationpip install rdfpandasUsageCreating RDF from DataFrameAs of version 1.1.0 NamespaceManager can be supplied tordflib.to_graphfor conversion to Graph.from rdfpandas.graph import to_graph
import pandas as pd
import rdflib

df = pd.read_csv('to_graph_test.csv', index_col = '@id', keep_default_na = False)
namespace_manager = NamespaceManager(Graph())
namespace_manager.bind('skos', SKOS)
namespace_manager.bind('rdfpandas', Namespace('http://github.com/cadmiumkitty/rdfpandas/'))
g = to_graph(df, namespace_manager)
s = g.serialize(format = 'turtle')Creating DataFrame from RDFfrom rdfpandas.graph import to_dataframe
import pandas as pd
import rdflib

g = rdflib.Graph()
g.parse('to_df_test.ttl', format = 'ttl')
df = to_dataframe(g)
df.to_csv('test.csv', index = True, index_label = "@id")GotchasNo special effort is made for dealing with types, so please be aware of Pandas
features such ashttps://pandas.pydata.org/pandas-docs/stable/user_guide/gotchas.html#support-for-integer-nathat may result in surprising RDF statements like"10.0"^^<xsd:integer>.