Python Client

The Client constructor.

Raise connection InterfaceError if not connected Defaults to check if a db is connected

Pack the specified commit info into a dict format expected by the server.

>>> client = Client("http://127.0.0.1:6363/")
>>> client._generate_commit("<message>", "<author>")
{'author': '<author>', 'message': '<message>'}

Get the prefixes for a given database

Add a new role

>>> client = Client("http://127.0.0.1:6363")
>>> client.connect(key="root", team="admin", user="admin", db="example_db")
>>> role = {
    "name": "Grand Pubah",
    "action": [
        "branch",
        "class_frame",
        "clone",
        "commit_read_access",
        "commit_write_access",
        "create_database",
        "delete_database",
        "fetch",
        "instance_read_access",
        "instance_write_access",
        "manage_capabilities",
        "meta_read_access",
        "meta_write_access",
        "push",
        "rebase",
        "schema_read_access",
        "schema_write_access"
      ]
  }
>>> client.add_role(role)

Add a new user

Diff two different commits and apply changes on branch

Change the capabilities of a certain user

Change role actions for a particular role

>>> client = Client("http://127.0.0.1:6363")
>>> client.connect(key="root", team="admin", user="admin", db="example_db")
>>> role = {
    "name": "Grand Pubah",
    "action": [
        "branch",
        "class_frame",
        "clone",
        "commit_read_access",
        "commit_write_access",
        "create_database",
        "delete_database",
        "fetch",
        "instance_read_access",
        "instance_write_access",
        "manage_capabilities",
        "meta_read_access",
        "meta_write_access",
        "push",
        "rebase",
        "schema_read_access",
        "schema_write_access"
      ]
  }
>>> client.change_role(role)

Change user's password

Clone a remote repository and create a local copy.

>>> client = Client("http://127.0.0.1:6363/")
>>> client.clonedb("http://terminusdb.com/some_user/test_db", "my_test_db")

Undo connect and close the connection.

Not implementated: open transactions currently not suportted. Please check back later.

Connect to a Terminus server at the given URI with an API key.

>>> client = Client("http://127.0.0.1:6363")
>>> client.connect(key="root", team="admin", user="admin", db="example_db")

Create a deep copy of this client.

>>> client = Client("http://127.0.0.1:6363/")
>>> clone = client.copy()
>>> assert client is not clone

Create a branch starting from the current branch.

Create a TerminusDB database by posting a terminus:Database document to the Terminus Server.

>>> client = Client("http://127.0.0.1:6363/")
>>> client.create_database("someDB", "admin", "Database Label", "My Description")

Add a new organization

Delete a branch

Delete a TerminusDB database.

>>> client = Client("http://127.0.0.1:6363/")
>>> client.delete_database("<database>", "<team>")

Delete the specified document(s)

Deletes a specific organization

Delete a user

DEPRECATED

>>> client = Client("http://127.0.0.1:6363/")
>>> client.connect(user="admin", key="root", team="admin", db="some_db")
>>> result = client.diff({ "@id" : "Person/Jane", "@type" : "Person", "name" : "Jane"}, { "@id" : "Person/Jane", "@type" : "Person", "name" : "Janine"})
>>> result.to_json = '{ "name" : { "@op" : "SwapValue", "@before" : "Jane", "@after": "Janine" }}'

Diff two different objects.

Diff two different versions. Can either be a branch or a commit

Fetch the branch from a remote repo

Get all the branches available in the database.

Retrieves all avalibale the documents

Get the available roles for the current authenticated user

Get the frame of the class of class_name. Provide information about all the avaliable properties of that class.

Get the whole commit history. Commit history - Commit id, author of the commit, commit message and the commit time, in the current branch from the current commit, ordered backwards in time, will be returned in a dictionary in the follow format: ``` { "commit_id": { "author": "commit_author", "message": "commit_message", "timestamp: <datetime object of the timestamp>" } } ```

Returns metadata (id, organization, label, comment) about the requested database Parameters ---------- dbid : str The id of the database team : str The organization of the database (default self.team)

Returns a list of database metadata records for all databases the user has access to

Retrieves the document of the iri_id

Retrieves the documents by type

Get all the existing classes (only ids) in a database.

Returns a specific organization

Returns user info related to an organization.

Returns the databases available to a user which are inside an organization

Returns a list of users in an organization.

Returns a list of organizations in the database.

Retrieves the contents of the specified graph as triples encoded in turtle format

Get a user

Get all users

Check whether a database exists

Check if a certain document exist in a database

Get info of a TerminusDB database server

Inserts the specified document(s)

Inserts into the specified graph with the triples encoded in turtle format.

Returns a list of database ids for all databases the user has access to

Get commit history of a database Parameters ---------- team : str, optional The team from which the database is. Defaults to the class property. db : str, optional The database. Defaults to the class property. start : int, optional Commit index to start from. Defaults to 0. count : int, optional Amount of commits to get. Defaults to -1 which gets all.

Check whether the TerminusDB server is still OK. Status is not OK when this function returns false or throws an exception (mostly ConnectTimeout)

Optimize the specified path.

>>> client = Client("http://127.0.0.1:6363/")
>>> client.optimize('admin/database') # optimise database branch (here main)
>>> client.optimize('admin/database/_meta') # optimise the repository graph (actually creates a squashed flat layer)
>>> client.optimize('admin/database/local/_commits') # commit graph is optimised

Apply the patch object to the before object and return an after object. Note that this change does not commit changes to the graph.

>>> client = Client("http://127.0.0.1:6363/")
>>> client.connect(user="admin", key="root", team="admin", db="some_db")
>>> patch_obj = Patch(json='{"name" : { "@op" : "ValueSwap", "@before" : "Jane", "@after": "Janine" }}')
>>> result = client.patch({ "@id" : "Person/Jane", "@type" : Person", "name" : "Jane"}, patch_obj)
>>> print(result)
'{ "@id" : "Person/Jane", "@type" : Person", "name" : "Janine"}'

Apply the patch object to the given resource

>>> client = Client("http://127.0.0.1:6363/")
>>> client.connect(user="admin", key="root", team="admin", db="some_db")
>>> patch_obj = Patch(json='{"name" : { "@op" : "ValueSwap", "@before" : "Jane", "@after": "Janine" }}')
>>> result = client.patch_resource(patch_obj,branch="main")
>>> print(result)
'["Person/Jane"]'

Pull updates from a remote repository to the current database.

>>> client = Client("http://127.0.0.1:6363/")
>>> client.pull()

Push changes from a branch to a remote repo

>>> Client(server="http://localhost:6363").push(remote="origin", remote_branch = "main", author = "admin", message = "commit message"})

Updates the contents of the specified graph with the triples encoded in turtle format Replaces the entire graph contents

>>> Client(server="http://localhost:6363").query(woql, "updating graph")

Retrieves all documents that match a given document template

Rebase the current branch onto the specified remote branch. Need to specify one of 'branch','commit' or the 'rebase_source'.

>>> client = Client("http://127.0.0.1:6363/")
>>> client.rebase("the_branch")

Updates the specified document(s)

Reset the current branch HEAD to the specified commit path. If `soft` is not True, it will be a hard reset, meaning reset to that commit in the backend and newer commit will be wipped out. If `soft` is True, the client will only reference to that commit and can be reset to the newest commit when done.

>>> client = Client("http://127.0.0.1:6363/")
>>> client.reset('234980523ffaf93')
>>> client.reset('admin/database/local/commit/234980523ffaf93', use_path=True)

Curently not implementated. Please check back later.

Set the connection to another database. This will reset the connection.

>>> client = Client("http://127.0.0.1:6363")
>>> client.set_db("database1")
'database1'

Squash the current branch HEAD into a commit

>>> client = Client("http://127.0.0.1:6363/")
>>> client.connect(user="admin", key="root", team="admin", db="some_db")
>>> client.squash('This is a squash commit message!')

Updates the specified document(s). Add the document if not existed.

Updates the contents of the specified graph with the triples encoded in turtle format. Replaces the entire graph contents