{ "info": { "author": "Grakn Labs", "author_email": "community@grakn.ai", "bugtrack_url": null, "classifiers": [], "description": "---\ntitle: Grakn Python Client\nkeywords: setup, getting started, download, driver\ntags: [getting-started]\nsidebar: documentation_sidebar\npermalink: /docs/language-drivers/client-python\nfolder: docs\nsymlink: true\n---\n\n# Grakn Python Client\n\nA Python client for [Grakn](https://grakn.ai)\n\nWorks with Grakn >=1.3.0 up to this driver version, and Python >= 3.6\n\n# Installation\n\n```\npip3 install grakn\n```\n\nTo obtain the Grakn database itself, head [here](https://grakn.ai/pages/documentation/get-started/setup-guide.html) for the setup guide.\n\n# Quickstart\n\n## Grakn client, sessions, and transactions\n\nIn the interpreter or in your source, import `grakn`:\n\n```\nimport grakn\n```\n\nYou can then instantiate a client, open a session, and create transactions. \n_NOTE_: Grakn's default gRPC port is 48555 for versions >=1.3. Port 4567 (the old default REST endpoint) is deprecated for clients.\n\n```\nclient = grakn.Grakn(uri=\"localhost:48555\")\nsession = client.session(keyspace=\"mykeyspace\")\ntx = session.transaction(grakn.TxType.WRITE)\n```\n\nAlternatively, you can also use `with` statements, which automatically closes sessions and transactions:\n```\nclient = grakn.Grakn(uri=\"localhost:48555\")\nwith client.session(keyspace=\"mykeyspace\") as session:\n with session.transaction(grakn.TxType.READ) as tx:\n ...\n```\n\nCredentials can be passed into the initial constructor as a dictionary, if you are a KGMS user:\n```\nclient = grakn.Grakn(uri='localhost:48555', credentials={'username': 'xxxx', 'password': 'yyyy'})\n```\n\nIf a transaction fails (throws exception), it automatically gets closed.\nAlso note that closing a transaction means that _all concept objects retrieved from that transaction are no longer queryable via internal getters/setters_.\n\nFor example\n```\n# obtain a tx\ntx = session.transaction(grakn.TxType.READ)\nperson_type = tx.get_schema_concept(\"person\") # creates a local Concept object with the `tx` bound internally\nprint(\"Label of person type: {0}\".format(person_type.label()) # uses interal `tx` to retrieve label from server\ntx.close()\n# the following will raise an exception, internally bound transaction is closed\nprint(\"Label of person type: {0}\".format(person_type.label())\n```\n\n## Basic retrievals and insertions \n\nYou can execute Graql queries and iterate through the answers as follows:\n```\n# Perform a query that returns an iterator of ConceptMap answers\nanswer_iterator = tx.query(\"match $x isa person; limit 10; get;\") \n# Request first response\na_concept_map_answer = next(answer_iterator) \n# Get the dictionary of variables : concepts, retrieve variable 'x'\nperson = a_concept_map_answer.map()['x'] \n\n# we can also iterate using a `for` loop\nsome_people = []\nfor concept_map in answer_iterator: \n # Get 'x' again, without going through .map()\n some_people.append(concept_map.get('x')) \n break \n\n# skip the iteration and .get('x') and extract all the concepts in one go\nremaining_people = answer_iterator.collect_concepts() \n\n# explicit close if not using `with` statements\ntx.close()\n```\n\n_NOTE_: queries will return almost immediately -- this is because Grakn lazily evaluates the request on the server when\nthe local iterator is consumed, not when the request is created. Each time `next(iter)` is called, the client executes a fast RPC request \nto the server to obtain the next concrete result.\n\nYou might also want to make some insertions using `.query()`\n```\n# Perform insert query that returns an iterator of ConceptMap of inserted concepts\ninsert_iterator = tx.query(\"insert $x isa person, has birth-date 2018-08-06;\") \nconcepts = insert_iterator.collect_concepts()\nprint(\"Inserted a person with ID: {0}\".format(concepts[0].id))\n# Don't forget to commit() to persist changes\ntx.commit()\n```\n\nOr you can use the methods available on Concept objects, known as the Concept API:\n```\nperson_type = tx.get_schema_concept(\"person\") # retrieve the \"person\" schema type \nperson = person_type.create() # instantiate a person\nbirth_date_type = tx.get_schema_concept(\"birth-date\") \" retrieve the \"birth-date\" schema type\ndate = datetime.datetime(year=2018, month=8, day=6) # requires `import datetime`\nbirth_date = birth_date_type.create(date) # instantiate a date with a python datetime object\nperson.has(birth_date) # attach the birth_date concept to the person concept \ntx.commit() # write changes to Grakn \n```\n\n\n# API reference\n\n\nFirst create a new Grakn object/client with\n\n```\n// URI must be a string containing host address and gRPC port of a running Grakn instance, e.g. \"localhost:48555\"\nclient = grakn.Grakn(URI)\n```\n\non the Grakn object the following methods are available:\n\n**Grakn**\n\n| Method | Return type | Description |\n| ---------------------------------------- | ----------------- | ---------------------------------------------------- |\n| `session(String keyspace)` | *Session* | Return a new Session bound to the specified keyspace |\n| `keyspaces().delete(String keyspace)` | *None* | Deletes the specified keyspace |\n| `keyspaces().retrieve()` | List of *String* | Retrieves all available keyspaces |\n\n\n\non the Session the following methods are available:\n\n**Session**\n\n| Method | Return type | Description |\n| --------------------------------- | ------------- | ------------------------------------------------------------------------------------- |\n| `transaction(grakn.TxType)` | *Transaction* | Return a new Transaction bound to the keyspace of this session |\n| `close()` | *None* | This must be used to correctly terminate session and close communication with server. |\n\n\nOnce obtained a `Transaction` you will be able to:\n\n **Transaction**\n\n| Method | Return type | Description |\n| ------------------------------------------------------------ | ------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `query(String graql_query, infer=True)` | Iterator of *Answer* | Executes a Graql query on the session keyspace. It's possible to specify whether to enable inference, which is ON by default. |\n| `commit()` | *None* | Commit current Transaction, persisting changes in the graph. After committing, the transaction will be closed and you will need to get a new one from the session |\n| `close()` | *None* | Closes current Transaction without committing. This makes the transaction unusable. |\n| `get_concept(String concept_id)` | *Concept* or *None* | Retrieves a Concept by ConceptId |\n| `get_schema_concept(String label)` | *SchemaConcept* or *None* | Retrieves a SchemaConcept by label |\n| `get_attributes_by_value(attribute_value, grakn.DataType)` | Iterator of *Attribute* | Get all Attributes holding the value provided, if any exist |\n| `put_entity_type(String label)` | *EntityType* | Create a new EntityType with super-type entity, or return a pre-existing EntityType with the specified label |\n| `put_relationship_type(String label)` | *RelationshipType* | Create a new RelationshipType with super-type relation, or return a pre-existing RelationshipType with the specified label |\n| `put_attribute_type(String label, grakn.DataType)` | *AttributeType* | Create a new AttributeType with super-type attribute, or return a pre-existing AttributeType with the specified label and DataType |\n| `put_role(String label)` | *Role* | Create a Role, or return a pre-existing Role, with the specified label. |\n| `put_rule(String label, String when, String then)` | *Rule* | Create a Rule, or return a pre-existing Rule, with the specified label |\n\n**Iterator**\n\nSome of the following Concept methods return a python iterator, which can be converted into a list using standard constructs such as `list(iterator)`. The iterator will either return *Answer* or *Concept* objects.\n\n| Method | Return type | Description |\n| ------------------------- | --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `collect_concepts()` | List of *Concept* | Consumes the iterator and return list of Concepts. **This helper is useful on Iterator that return ConceptMap answer types**. It is useful when one wants to work directly on Concepts without the need to traverse the result map or access the explanation. |\n\n_NOTE_: these iterators represent a lazy evaluation of a query or method on the Grakn server, and will be created very quickly. The actual work\nis performed when the iterator is consumed, creating an RPC to the server to obtain the next concrete `Answer` or `Concept`.\n\n\n**Answer**\n\nThis object represents a query answer and it is contained in the Iterator returned by `transaction.query()` method. \nThere are **different types of Answer**, based on the type of query executed a different type of Answer will be returned: \n\n| Query Type | Answer Type |\n|--------------------------------------|-------------------|\n| `define` | ConceptMap |\n| `undefine` | ConceptMap |\n| `get` | ConceptMap |\n| `insert` | ConceptMap |\n| `delete` | ConceptMap |\n| `aggregate count/min/max/sum/mean/std` | Value |\n| `aggregate group` | AnswerGroup |\n| `compute count/min/max/sum/mean/std` | Value |\n| `compute path` | ConceptList |\n| `compute cluster` | ConceptSet |\n| `compute centrality` | ConceptSetMeasure |\n\n**ConceptMap**\n\n| Method | Return type | Description |\n| --------------- | ------------------------ | ----------------------------------------------------------------------------------------------- |\n| `map()` | Dict of *str* to *Concept* | Returns result dictionary in which every variable name (key) is linked to a Concept. |\n| `explanation()` | *Explanation* or *null* | Returns an Explanation object if the current Answer contains inferred Concepts, null otherwise. |\n\n**Value**\n\n| Method | Return type | Description |\n| --------------- | ------------------------ | ----------------------------------------------------------------------------------------------- |\n| `number()` | int or float | Returns numeric value of the Answer. |\n| `explanation()` | *Explanation* or *null* | Returns an Explanation object if the current Answer contains inferred Concepts, null otherwise. |\n\n**ConceptList**\n\n| Method | Return type | Description |\n| --------------- | ------------------------ | ----------------------------------------------------------------------------------------------- |\n| `list()` | Array of *String* | Returns list of Concept IDs. |\n| `explanation()` | *Explanation* or *null* | Returns an Explanation object if the current Answer contains inferred Concepts, null otherwise. |\n\n**ConceptSet**\n\n| Method | Return type | Description |\n| --------------- | ------------------------ | ----------------------------------------------------------------------------------------------- |\n| `set()` | Set of *String* | Returns a set containing Concept IDs. |\n| `explanation()` | *Explanation* or *null* | Returns an Explanation object if the current Answer contains inferred Concepts, null otherwise. |\n\n**ConceptSetMeasure**\n\n| Method | Return type | Description |\n| --------------- | ------------------------ | ----------------------------------------------------------------------------------------------- |\n| `measurement()` | int or float | Returns numeric value that is associated to the set of Concepts contained in the current Answer.|\n| `set()` | Set of *String* | Returns a set containing Concept IDs. |\n| `explanation()` | *Explanation* or *null* | Returns an Explanation object if the current Answer contains inferred Concepts, null otherwise. |\n\n**AnswerGroup**\n\n| Method | Return type | Description |\n| --------------- | ------------------------ | ----------------------------------------------------------------------------------------------- |\n| `owner()` | *Concept* | Returns the Concepts which is the group owner. |\n| `answers()` | List of *Answer* | Returns list of Answers that belongs to this group. |\n| `explanation()` | *Explanation* or *null* | Returns an Explanation object if the current Answer contains inferred Concepts, null otherwise. |\n\n**Explanation**\n\n| Method | Return type | Description |\n| ---------------- | ----------------- | ------------------------------------------------------------------------------------------- |\n| `query_pattern()`| String | Returns a query pattern that describes how the owning answer was retrieved. |\n| `answers()` | List of *Answer* | Set of deducted/factual answers that allowed us to determine that the owning answer is true |\n\n\n**Concepts hierarchy**\n\nGrakn is composed of different types of Concepts, that have a specific hierarchy\n\n```\n Concept\n / \\\n / \\\n / \\\n / \\\n SchemaConcept Thing\n / | \\ / | \\\n / | \\ / | \\\n / | \\ / | \\\n Type Rule Role Entity Attribute Relationship\n / | \\\n / | \\\n / | \\\n EntityType AttributeType RelationshipType\n```\n---\n\nAll Concepts are bound to the transaction that has been used to retrieve them.\nIf for any reason a trasaction gets closed all the concepts bound to it won't be able to\ncommunicate with the database anymore, so all the methods won't work and the user will have to re-query\nfor the needed concepts.\n\nAll setters return the same concept object (`self`) to facilitate chaining setters (e.g. `person.has(name).has(age)`).\n\n---\n\n**Concept**\n\nThese fields are accessible in every `Concept`:\n\n| Field | Type | Description |\n| ---------------------- | ----------- | ------------------------------------------------ |\n| `id` | *String* | Delete concept |\n\nThese methods are available on every type of `Concept`\n\n| Method | Return type | Description |\n| ---------------------- | ----------- | ------------------------------------------------ |\n| `delete()` | *None* | Delete concept |\n| `is_schema_concept()` | *Boolean* | Check whether this Concept is a SchemaConcept |\n| `is_type() ` | *Boolean* | Check whether this Concept is a Type |\n| `is_thing() ` | *Boolean* | Check whether this Concept is a Thing |\n| `is_attribute_type()` | *Boolean* | Check whether this Concept is an AttributeType |\n| `is_entity_type() ` | *Boolean* | Check whether this Concept is an EntityType |\n| `is_relationship_type()`| *Boolean* | Check whether this Concept is a RelationshipType |\n| `is_role()` | *Boolean* | Check whether this Concept is a Role |\n| `is_rule()` | *Boolean* | Check whether this Concept is a Rule |\n| `is_attribute()` | *Boolean* | Check whether this Concept is an Attribute |\n| `is_entity()` | *Boolean* | Check whether this Concept is a Entity |\n| `is_relationship()` | *Boolean* | Check whether this Concept is a Relationship |\n\n **Schema concept**\n\nA `SchemaConcept` concept has all the `Concept` methods plus the following:\n\n| Method | Return type | Description |\n| --------------------------- | --------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `label()` | *String* | Get label of this SchemaConcept |\n| `label(String value)` | *None* | Set label of this SchemaConcept |\n| `is_implicit()` | *Boolean* | Returns `True` when the SchemaConcept is implicit, i.e. when it's been created by Grakn and not explicitly by the user, `False` when explicitly created by the user. |\n| `sup(Type)` | *None* | Set direct super SchemaConcept of this SchemaConcept |\n| `sup()` | *SchemaConcept* or *None* | Get direct super SchemaConcept of this SchemaConcept |\n| `subs()` | Iterator of *SchemaConcept* | Get all indirect subs of this SchemaConcept. |\n| `sups()` | Iterator of *SchemaConcept* | Get all indirect sups of this SchemaConcept. |\n\n **Thing**\n\n A `Thing` concept has all the `Concept` methods plus the following:\n\n | Method | Return type | Description |\n | ------------------------------------ | -------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n | `is_inferred()` | *Boolean* | Returns `True` if this Thing is inferred by Reasoner, `False` otherwise |\n | `type()` | *Type* | Returns a Type which is the type of this Thing. This Thing is an instance of that type. |\n | `relationships(*Role)` | Iterator of *Relationship* | Returns Relationships which this Thing takes part in, which may **optionally** be narrowed to a particular set according to the Roles you are interested in |\n | `attributes(*AttributeType)` | Iterator of *Attribute* | Returns Attributes attached to this Thing, which may **optionally** be narrowed to a particular set according to the AttributeTypes you are interested in |\n | `roles()` | Iterator of *Role* | Returns the Roles that this Thing is currently playing |\n | `keys(*AttributeType)` | Iterator of *Attribute* | Returns a collection of Attribute attached to this Thing as a key, which may **optionally** be narrowed to a particular set according to the AttributeTypes you are interested in |\n | `has(Attribute)` | *None* | Attaches the provided Attribute to this Thing |\n | `unhas(Attribute)` | *None* | Removes the provided Attribute from this Thing |\n\n **Attribute**\n\n An `Attribute` concept has all the `Thing` methods plus the following:\n\n\n | Method | Return type | Description |\n | ------------------ | ------------------- | --------------------------------------------------------- |\n | `value()` | *String* | Get value of this Attribute |\n | `owners()` | Iterator of *Thing* | Returns the set of all Things that possess this Attribute |\n\n **Relationship**\n\nA `Relationship` concept has all the `Thing` methods plus the following:\n\n\n| Method | Return type | Description |\n| ----------------------------- | ------------------------- | -------------------------------------------------------------------------------------------------------- |\n| `role_players_map()` | Dict[*Role*, set[*Thing*]]| Returns a dictionary that links all the Roles of this Relationship to all the Things that are playing each Role |\n| `role_players(*Role)` | Iterator of *Thing* | Returns a list of every Thing involved in this Relationship, optionally filtered by Roles played |\n| `assign(Role, Thing)` | *None* | Expands this Relationship to include a new role player (Thing) which is playing a specific Role |\n| `unassign(Role, Thing)` | *None* | Removes the Thing which is playing a Role in this Relationship. | |\n\n NB: There are no specific methods for `Entity` concept.\n\n **Type**\n\nA `Type` concept has all the `SchemaConcept` methods plus the following:\n\n\n| Method | Return type | Description |\n| ---------------------------- | --------------------------- | ------------------------------------------------------------------------------------------------------------------------------ |\n| `is_abstract(Boolean)` | *None* | Sets the Type to be abstract - which prevents it from having any instances |\n| `is_abstract()` | *Boolean* | Returns `True` if the type is set to abstract, `False` otherwise |\n| `playing()` | Iterator of *Role* | Returns all the Roles which instances of this Type can indirectly play |\n| `plays(Role)` | *None* | Add a new Role to the ones that the instances of this Type are allowed to play |\n| `attributes()` | Iterator of *AttributeType* | The AttributeTypes which this Type is linked with. |\n| `instances()` | Iterator of *Thing* | Get all indirect instances of this Type |\n| `keys()` | Iterator of *AttributeType* | The AttributeTypes which this Type is linked with as a key |\n| `key(AttributeType)` | *None* | Creates an implicit RelationshipType which allows this Type and a AttributeType to be linked in a strictly one-to-one mapping. |\n| `has(AttributeType)` | *None* | Add a new AttributeType which the instances of this Type are allowed to have attached to themselves |\n| `unplay(Role)` | *None* | Delete a Role from the ones that the instances of this Type are allowed to play |\n| `unhas(AttributeType)` | *None* | Delete AttributeType from the ones that the instances of this Type are allowed to have attached to themselves |\n| `unkey(AttributeType)` | *None* | Delete AttributeType from available keys |\n\n **AttributeType**\n\n An `AttributeType` concept has all the `Type` methods plus the following:\n\n\n | Method | Return type | Description |\n | --------------------------- | --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- |\n | `create(value)` | *Attribute* | Create new Attribute of this type with the provided value. The value provided must conform to the DataType specified for this AttributeType |\n | `attribute(value)` | *Attribute* or *None* | Retrieve the Attribute with the provided value if it exists |\n | `data_type()` | *Enum of Grakn.DataType* | Get the data type to which instances of the AttributeType must have |\n | `regex()` | *String* or *None* | Retrieve the regular expression to which instances of this AttributeType must conform to, or `None` if no regular expression is set |\n | `regex(String regex)` | *None* | Set the regular expression that instances of the AttributeType must conform to |\n\n **RelationshipType**\n\n A `RelationshipType` concept has all the `Type` methods plus the following:\n\n | Method | Return type | Description |\n | ---------------------- | ------------------ | ------------------------------------------------------------------------------------ |\n | `create()` | *Relationship* | Creates and returns a new Relationship instance, whose direct type will be this type |\n | `roles()` | Iterator of *Role* | Returns a list of the RoleTypes which make up this RelationshipType |\n | `relates(Role)` | *None* | Sets a new Role for this RelationshipType |\n | `unrelate(Role)` | *None* | Delete a Role from this RelationshipType |\n\n **EntityType**\n\n An `EntityType` concept has all the `Type` methods plus the following:\n\n | Method | Return type | Description |\n | ---------------- | ----------- | ------------------------------------------------------------------------------ |\n | `create()` | *Entity* | Creates and returns a new Entity instance, whose direct type will be this type |\n\n\n **Role**\n\n A `Role` concept has all the `SchemaConcept` methods plus the following:\n\n| Method | Return type | Description |\n| ----------------------- | ------------------------------ | ----------------------------------------------------------- |\n| `relationships()` | Iterator of *RelationshipType* | Returns the RelationshipTypes that this Role takes part in. |\n| `players()` | Iterator of *Type* | Returns a collection of the Types that can play this Role |\n\n **Rule**\n\nA `Rule` concept has all the `SchemaConcept` methods plus the following:\n\n| Method | Return type | Description |\n| ----------------- | ----------- | ---------------------------------------------------------------------------------------------------------- |\n| `get_when()` | *String* | Retrieves the when part of this Rule. When this query is satisfied the \"then\" part of the rule is executed |\n| `get_then()` | *String* | Retrieves the then part of this Rule. This query is executed when the \"when\" part of the rule is satisfied |\n\n\n", "description_content_type": "text/markdown", "docs_url": null, "download_url": "", "downloads": { "last_day": -1, "last_month": -1, "last_week": -1 }, "home_page": "https://github.com/graknlabs/grakn/tree/master/client-python", "keywords": "grakn,database,graph,knowledgebase,knowledge-engineering", "license": "Apache-2.0", "maintainer": "", "maintainer_email": "", "name": "grakn", "package_url": "https://pypi.org/project/grakn/", "platform": "", "project_url": "https://pypi.org/project/grakn/", "project_urls": { "Homepage": "https://github.com/graknlabs/grakn/tree/master/client-python" }, "release_url": "https://pypi.org/project/grakn/1.4.2/", "requires_dist": [ "grpcio", "protobuf" ], "requires_python": ">=3.6.0", "summary": "A Python client for Grakn", "version": "1.4.2" }, "last_serial": 5003512, "releases": { "0.1": [ { "comment_text": "", "digests": { "md5": "821b07aa356733923d65af44258fc6b7", "sha256": "caa46952ff23d83ec7ba2826f6054a038052f555556e90ed7e5c1d7b10fcf926" }, "downloads": -1, "filename": "grakn-0.1.tar.gz", "has_sig": false, "md5_digest": "821b07aa356733923d65af44258fc6b7", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1886, "upload_time": "2017-06-22T10:51:47", "url": "https://files.pythonhosted.org/packages/0b/13/c52b3ada1d1e8605bbef81c205e1ee7d23bf3e7fc020a7f953044613fc58/grakn-0.1.tar.gz" } ], "0.2": [], "0.3": [ { "comment_text": "", "digests": { "md5": "5d7b69e702d30696dd1144fa3c1b14c0", "sha256": "14d4148b6c0911b0c9476fb42f8a22adacb00198d67c3556665d60d1ecc7e68a" }, "downloads": -1, "filename": "grakn-0.3.tar.gz", "has_sig": false, "md5_digest": "5d7b69e702d30696dd1144fa3c1b14c0", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 2047, "upload_time": "2017-06-22T14:22:46", "url": "https://files.pythonhosted.org/packages/61/25/2ceede50222768977bbe187d9eef43414dc83a628e898e23f21e7ed356f4/grakn-0.3.tar.gz" } ], "0.4": [ { "comment_text": "", "digests": { "md5": "6ee86b132fbdf16faeb5403e4f7eec1d", "sha256": "73b4bac9627635bda3445eb6cc161546d226a660da91e1dd7315105464b971a2" }, "downloads": -1, "filename": "grakn-0.4.tar.gz", "has_sig": false, "md5_digest": "6ee86b132fbdf16faeb5403e4f7eec1d", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 2047, "upload_time": "2017-06-22T14:50:00", "url": "https://files.pythonhosted.org/packages/1c/39/c30744e63861b2bc4b7663812cf39afbbbf5a1c05b17ba5a7e630266881b/grakn-0.4.tar.gz" } ], "0.5": [ { "comment_text": "", "digests": { "md5": "05407c210c3c101db1225d0e4c6bddce", "sha256": "f5fb8725f81bc1c319790aa263efcfd7a03d650dd589a92e1b350009d07a5a56" }, "downloads": -1, "filename": "grakn-0.5.tar.gz", "has_sig": false, "md5_digest": "05407c210c3c101db1225d0e4c6bddce", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1930, "upload_time": "2017-07-24T15:16:54", "url": "https://files.pythonhosted.org/packages/87/f2/15a5771d19434deb695649c622064275ab10f1125d1c92a3902d06b9111f/grakn-0.5.tar.gz" } ], "0.6": [ { "comment_text": "", "digests": { "md5": "5bda38f47b6c4ab7d88a8247d410022c", "sha256": "4c612c57e84162d05c9c709f8403838b39b01a0a9dacd5ea17501e5807bcd4d2" }, "downloads": -1, "filename": "grakn-0.6.tar.gz", "has_sig": false, "md5_digest": "5bda38f47b6c4ab7d88a8247d410022c", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1979, "upload_time": "2017-08-24T08:59:51", "url": "https://files.pythonhosted.org/packages/69/27/dd53e88f87bae455358f88c6ef5c040d773dc744b02be3f87b99c19dbd48/grakn-0.6.tar.gz" } ], "0.7": [ { "comment_text": "", "digests": { "md5": "52f0af4188579a97bd7d933ec29bcb13", "sha256": "985b02b7e7815475aab9ea98b24bdf13a0757dd6dbc167f9b8b954587e06c6c1" }, "downloads": -1, "filename": "grakn-0.7.tar.gz", "has_sig": false, "md5_digest": "52f0af4188579a97bd7d933ec29bcb13", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 2045, "upload_time": "2017-11-07T15:48:34", "url": "https://files.pythonhosted.org/packages/ff/8a/db8a548c3c70513219cd220f8e3e393482429cd4086a5cdfbad713303d30/grakn-0.7.tar.gz" } ], "0.8": [ { "comment_text": "", "digests": { "md5": "b6a0cbc98c1651d547ab7defbc852dc3", "sha256": "d8d2d4201a16ddc5a368b912de76655f379acd497a209123e87257da1ea905ab" }, "downloads": -1, "filename": "grakn-0.8.tar.gz", "has_sig": false, "md5_digest": "b6a0cbc98c1651d547ab7defbc852dc3", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 2102, "upload_time": "2017-12-08T13:06:01", "url": "https://files.pythonhosted.org/packages/dc/2f/865c1b0c657c3fb180ac1ce97efa4f025d87a18bdb4e47d9fe5c4df25337/grakn-0.8.tar.gz" } ], "0.8.1": [ { "comment_text": "", "digests": { "md5": "145ef78211fe835418a2d2e9705dc394", "sha256": "6e02f83db9c643c4d0a8d7f383a037c7f60ab0c31a759dca584706d6699a6052" }, "downloads": -1, "filename": "grakn-0.8.1.tar.gz", "has_sig": false, "md5_digest": "145ef78211fe835418a2d2e9705dc394", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 2128, "upload_time": "2017-12-13T16:42:32", "url": "https://files.pythonhosted.org/packages/c7/dd/7c9849eeebfb3b3deb9b53e8beec22ae7e5ff78d6aed5b15e35485112d7f/grakn-0.8.1.tar.gz" } ], "0.9.0": [ { "comment_text": "", "digests": { "md5": "eaf29e14d92e5ef674e3df74dabff02a", "sha256": "1dc0ad64c181a856df8732ea3c67ac53f6d3cebd5d8043190adfc81034a6f575" }, "downloads": -1, "filename": "grakn-0.9.0.tar.gz", "has_sig": false, "md5_digest": "eaf29e14d92e5ef674e3df74dabff02a", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 2220, "upload_time": "2017-12-15T13:24:29", "url": "https://files.pythonhosted.org/packages/c5/3b/85691ab6c1b5b03489ada168550d3c919b18ec027851a25ff837deb9f089/grakn-0.9.0.tar.gz" } ], "1.3.0": [ { "comment_text": "", "digests": { "md5": "0f4de96f71540152a33303b7ad72ec81", "sha256": "707ed900285b90ceb1c8c154b8c33eb9f3a82aacfe43ac45c3ea9a8b81b02a7c" }, "downloads": -1, "filename": "grakn-1.3.0-py3-none-any.whl", "has_sig": false, "md5_digest": "0f4de96f71540152a33303b7ad72ec81", "packagetype": "bdist_wheel", "python_version": "py3", "requires_python": ">=3.6.0", "size": 60204, "upload_time": "2018-08-07T17:27:40", "url": "https://files.pythonhosted.org/packages/90/59/fad8acedbaba39ea466334791bd8b10463bb103142c2cba954c6669adea9/grakn-1.3.0-py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "8b30d5573b7811df0bbb3b55fc2d7b9f", "sha256": "ff25752326d15fa13962aa91f865ae3de277a6a26a4064d26852a67cad40eeda" }, "downloads": -1, "filename": "grakn-1.3.0.tar.gz", "has_sig": false, "md5_digest": "8b30d5573b7811df0bbb3b55fc2d7b9f", "packagetype": "sdist", "python_version": "source", "requires_python": ">=3.6.0", "size": 54553, "upload_time": "2018-08-07T17:27:41", "url": "https://files.pythonhosted.org/packages/5d/c7/55912096cdf807c9ca8dbb32886c547bcb9005992cb6bc07f89a4ff96d7c/grakn-1.3.0.tar.gz" } ], "1.3.1": [ { "comment_text": "", "digests": { "md5": "7c76b428d544d199894554e23ea0832f", "sha256": "4848e8423155a5d4b956b63aab1c40df2ab266f792c3604408773d856823e35c" }, "downloads": -1, "filename": "grakn-1.3.1-py3-none-any.whl", "has_sig": false, "md5_digest": "7c76b428d544d199894554e23ea0832f", "packagetype": "bdist_wheel", "python_version": "py3", "requires_python": ">=3.6.0", "size": 68628, "upload_time": "2018-08-09T10:56:08", "url": "https://files.pythonhosted.org/packages/ce/43/e105a3584cc4b7df1c4e7b992f03a04bff38b18527e54cc6ba871ede5ec6/grakn-1.3.1-py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "fc3e94e77d1a0f57186e1b9e250111e5", "sha256": "2a665e2d361764e135276e616c4a68a3cb14c70779379db0e7ea7f6574ce4334" }, "downloads": -1, "filename": "grakn-1.3.1.tar.gz", "has_sig": false, "md5_digest": "fc3e94e77d1a0f57186e1b9e250111e5", "packagetype": "sdist", "python_version": "source", "requires_python": ">=3.6.0", "size": 54752, "upload_time": "2018-08-09T10:56:10", "url": "https://files.pythonhosted.org/packages/09/bc/eafc14d98190e039dbbf868747c46d0f2dc9ffccc5481ff0b83efe117ae8/grakn-1.3.1.tar.gz" } ], "1.3.2": [ { "comment_text": "", "digests": { "md5": "5dab238afde6a3fce04592e22bf7f90a", "sha256": "3302ff8e7aac0838f246b46f71f102b52fdafc0da9ced7273c6b26de17a162d2" }, "downloads": -1, "filename": "grakn-1.3.2-py3-none-any.whl", "has_sig": false, "md5_digest": "5dab238afde6a3fce04592e22bf7f90a", "packagetype": "bdist_wheel", "python_version": "py3", "requires_python": ">=3.6.0", "size": 59662, "upload_time": "2018-08-16T09:44:45", "url": "https://files.pythonhosted.org/packages/4d/a8/199af417758c1e0ddcd1883e2537fac25023d505f2aaac30f6e3139ba714/grakn-1.3.2-py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "2aa395fcd7ac87bdd23f6a2499839096", "sha256": "5abc56d634a76c591b139294789a5d16b61a07366bdc5e9451d480e406398bd1" }, "downloads": -1, "filename": "grakn-1.3.2.tar.gz", "has_sig": false, "md5_digest": "2aa395fcd7ac87bdd23f6a2499839096", "packagetype": "sdist", "python_version": "source", "requires_python": ">=3.6.0", "size": 62082, "upload_time": "2018-08-16T09:44:46", "url": "https://files.pythonhosted.org/packages/27/b1/e9fafbb070061d8b6b2d3d4463e366d15ac78530f813c4afc8081268c292/grakn-1.3.2.tar.gz" } ], "1.4.2": [ { "comment_text": "", "digests": { "md5": "0a64dc25de4fce4ad16e1e4c32224dd0", "sha256": "178683b2edfc0bb4ee53a6c4273be087634f5a2ba41b04bd1b00f58255b6094e" }, "downloads": -1, "filename": "grakn-1.4.2-py3-none-any.whl", "has_sig": false, "md5_digest": "0a64dc25de4fce4ad16e1e4c32224dd0", "packagetype": "bdist_wheel", "python_version": "py3", "requires_python": ">=3.6.0", "size": 59977, "upload_time": "2018-10-12T14:17:38", "url": "https://files.pythonhosted.org/packages/20/3a/9b495bcd2dce5eff6de4f3e6b1708dccc6b7f4c500adddadd1c510628844/grakn-1.4.2-py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "45dd4c6cf0dcd1ecdb628e3e6b925fab", "sha256": "7ce8291a11d3fb5a8741f3568a8b3ed2e6296e9494b797d2a0759f982830ca2b" }, "downloads": -1, "filename": "grakn-1.4.2.tar.gz", "has_sig": false, "md5_digest": "45dd4c6cf0dcd1ecdb628e3e6b925fab", "packagetype": "sdist", "python_version": "source", "requires_python": ">=3.6.0", "size": 63163, "upload_time": "2018-10-12T14:17:40", "url": "https://files.pythonhosted.org/packages/fb/4b/c5bcb375276f29bf3cca93ac8067b4340999548764354b01c0548a77521d/grakn-1.4.2.tar.gz" } ] }, "urls": [ { "comment_text": "", "digests": { "md5": "0a64dc25de4fce4ad16e1e4c32224dd0", "sha256": "178683b2edfc0bb4ee53a6c4273be087634f5a2ba41b04bd1b00f58255b6094e" }, "downloads": -1, "filename": "grakn-1.4.2-py3-none-any.whl", "has_sig": false, "md5_digest": "0a64dc25de4fce4ad16e1e4c32224dd0", "packagetype": "bdist_wheel", "python_version": "py3", "requires_python": ">=3.6.0", "size": 59977, "upload_time": "2018-10-12T14:17:38", "url": "https://files.pythonhosted.org/packages/20/3a/9b495bcd2dce5eff6de4f3e6b1708dccc6b7f4c500adddadd1c510628844/grakn-1.4.2-py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "45dd4c6cf0dcd1ecdb628e3e6b925fab", "sha256": "7ce8291a11d3fb5a8741f3568a8b3ed2e6296e9494b797d2a0759f982830ca2b" }, "downloads": -1, "filename": "grakn-1.4.2.tar.gz", "has_sig": false, "md5_digest": "45dd4c6cf0dcd1ecdb628e3e6b925fab", "packagetype": "sdist", "python_version": "source", "requires_python": ">=3.6.0", "size": 63163, "upload_time": "2018-10-12T14:17:40", "url": "https://files.pythonhosted.org/packages/fb/4b/c5bcb375276f29bf3cca93ac8067b4340999548764354b01c0548a77521d/grakn-1.4.2.tar.gz" } ] }