def db(self):
conn = Connection(username=self.config.user,
password=self.config.password)
name = self.config.database
if not conn.hasDatabase(name):
return conn.createDatabase(name)
return conn[name]
def __init__(
self,
user='******',
password='******',
url='http://127.0.0.1:8529',
db_name='py2store',
collection_name='test',
key_fields=('key', ) # _id, _key and _rev are reserved by db
):
self._connection = Connection(arangoURL=url,
username=user,
password=password)
self._db_name = db_name
self._collection_name = collection_name
# if db not created
if not self._connection.hasDatabase(self._db_name):
self._connection.createDatabase(self._db_name)
self._adb = self._connection[self._db_name]
# if collection not created
if not self._adb.hasCollection(self._collection_name):
self._collection = self._adb.createCollection(
name=self._collection_name)
self._collection = self._adb[self._collection_name]
if isinstance(key_fields, str):
key_fields = (key_fields, )
self._key_fields = key_fields
def __init__(self):
conn = Connection(arangoURL=f"http://{DBConfig.host}:{DBConfig.port}",
username=DBConfig.User.name,
password=DBConfig.User.password)
try:
self.database = conn.createDatabase(name=DBConfig.database)
except CreationError:
self.database = conn[DBConfig.database]
class pythonTests(unittest.TestCase):
def setUp(self):
ARANGODB_ROOT_USERNAME = os.getenv('ARANGODB_ROOT_USERNAME', 'root')
ARANGODB_ROOT_PASSWORD = os.getenv('ARANGODB_ROOT_PASSWORD', 'root')
self.conn = Connection(username=ARANGODB_ROOT_USERNAME, password=ARANGODB_ROOT_PASSWORD)
def tearDown(self):
# TODO: disconnect session and delete db
pass
def test_create_database(self):
self.conn.createDatabase(name = "test_db")
self.db = self.conn["test_db"]
class pythonTests(unittest.TestCase):
def setUp(self):
ARANGODB_ROOT_USERNAME = os.getenv('ARANGODB_ROOT_USERNAME', 'root')
ARANGODB_ROOT_PASSWORD = os.getenv('ARANGODB_ROOT_PASSWORD', 'root')
self.conn = Connection(username=ARANGODB_ROOT_USERNAME,
password=ARANGODB_ROOT_PASSWORD)
def tearDown(self):
# TODO: disconnect session and delete db
pass
def test_create_database(self):
self.conn.createDatabase(name="test_db")
self.db = self.conn["test_db"]
def init_db():
"""
Initialize a connection instance to a running Arango database.
Optional environment variables that are used here:
DB_USERNAME
DB_PASSWORD
DB_NAME
DB_URL
All of the above have fallback values for a local test setup.
"""
username = os.environ.get('DB_USERNAME', 'root')
password = os.environ.get('DB_PASSWORD', 'password')
db_name = os.environ.get('DB_NAME', '_system')
db_url = os.environ.get('DB_URL', 'http://localhost:8529')
# Connect to the database
try:
conn = Connection(username=username,
password=password,
arangoURL=db_url)
except Exception as err:
sys.stderr.write(str(err) + '\n')
exit(1)
finally:
print('database connection established.')
return conn[db_name]
def __init__(self):
conn = Connection(username=USERNAME, password=PASSWORD)
self.db = conn[DB_NAME]
self.nodes = self.db[self.NODES_COLL]
self.edges_nodes = self.db[self.EDGENODE_COLL]
self.meta_relations = self.db[self.METAREL_COLL]
def _init_db_connection():
__arango_config = __CONFIG['ArangoDB']
__arango_conn = Connection(arangoURL=__arango_config['url'],
username=__arango_config['user'],
password=__arango_config['password'])
global arango_service
arango_service = ArangoService(__arango_conn, __arango_config['db'])
def main():
""" main function - contains high level program logic"""
print("[info] Connecting to Arango")
arango_connection = Connection()
_, onto_collection, relationships_collection = initialise_database(
arango_connection)
# Create documents
if len(sys.argv) != 2:
print("[error] You need to supply the name of the .owl file")
sys.exit(-1)
print("[info] Loading ontology from {0}".format(sys.argv[1]))
ontology = pronto.Ontology(sys.argv[1])
print("[info] Successfully loaded ontology")
print("[info] Starting to index terms")
last_percent = 0
total_terms = len(ontology)
for index, term in enumerate(ontology):
# insert that term into arango's document collection
# insert the term's relationships into arango's graph collection
to_insert = make_term_entry(term)
doc = onto_collection.createDocument(to_insert)
doc['_key'] = term.id
doc.save()
make_graph_relations(term, relationships_collection)
percent = int((index / total_terms) * 100)
if (percent - last_percent) >= 5:
print("[info] indexed {0}% of terms".format(percent))
last_percent = percent
# Now that we've done that, let's make actually make the graph
print("[info] Finished indexing terms")
print("[info] Creating graph: \"{0}\"".format(ONTOLOGY_GRAPH_NAME))
payload = {
"name":
ONTOLOGY_GRAPH_NAME,
"edgeDefinitions": [{
"collection": ONTOLOGY_RELATIONSHIPS,
"from": [ONTOLOGY_COLLECTION],
"to": [ONTOLOGY_COLLECTION],
}]
}
request_data = bytes(json.dumps(payload), 'UTF-8')
request = urllib.request.Request(
url="http://localhost:8529/_db/{0}/_api/gharial".format(DB_NAME),
data=request_data,
)
urllib.request.urlopen(request)
print("[info] All done!")
def get_db() -> Database:
"""
Returns database instance
"""
return Connection(
username=os.environ["ARANGO_USER"],
password=os.environ["ARANGO_ROOT_PASSWORD"],
arangoURL=f"http://{os.environ['ARANGO_HOST']}:{os.environ['ARANGO_PORT']}",
)[DB_NAME]
def main():
assert ES_INDEX
assert ES_HOST
assert ARANGO_URL
assert ARANGO_ROOT_PASSWORD
assert ARANGO_COLLECTION
assert ARANGO_USERNAME
# ES connection
es = Elasticsearch([ES_HOST])
# Arango connection
conn = Connection(arangoURL=ARANGO_URL, username=ARANGO_USERNAME, password=ARANGO_ROOT_PASSWORD)
if ES_INDEX not in conn.databases:
conn.createDatabase(name=ES_INDEX)
db = conn[ES_INDEX]
if not db.hasCollection(ARANGO_COLLECTION):
db.createCollection(name=ARANGO_COLLECTION)
# Build queries
existed_patents_total = db.AQLQuery("RETURN LENGTH(Patents)").response['result'][0] or 1000
existed_patents = db.AQLQuery(
f"FOR doc IN {ARANGO_COLLECTION} RETURN doc._file",
batchSize=existed_patents_total
).response['result']
es_query_exclude_existed = {"query": {"bool": {"must_not": [{"ids": {"values": existed_patents}}]}}}
aql_query_insert = f"INSERT @doc INTO {ARANGO_COLLECTION} LET newDoc = NEW RETURN newDoc"
# Handle ES pagination
patents = es.search(index=ES_INDEX, body=es_query_exclude_existed, scroll='1m', size=100)
scroll_id = patents['_scroll_id']
scroll_size = len(patents['hits']['hits'])
while scroll_size > 0:
# Add patents to Arango
for hit in patents['hits']['hits']:
hit['_file'] = hit['_id']
db.AQLQuery(aql_query_insert, bindVars={'doc': hit})
logging.info(f"Added: {hit['_file']}")
# Scroll next batch
patents = es.scroll(scroll_id=scroll_id, scroll='1m')
scroll_id = patents['_scroll_id'],
scroll_size = len(patents['hits']['hits'])
def get_connection(self, collection):
try:
conn = Connection(arangoURL=self.host,
username=self.username,
password=self.password)
db = conn[self.databaseName]
return db.collections[collection]
except ConnectionError:
print("Unable to create connection to the database")
return None
def __init__(self,
db_name,
auth=False,
password='',
user='******',
arangoURL='http://127.0.0.1:8529'):
"""Init the database conection and set atributes db atribute."""
if auth:
self.conn = Connection(username=user,
password=password,
arangoURL=arangoURL)
else:
self.conn = Connection(username=user, arangoURL=arangoURL)
if self.conn.hasDatabase(db_name):
# conectartla
self.db = pyArango.database.Database(self.conn, db_name)
pass
else:
self.db = self.conn.createDatabase(name=db_name)
def _get_db():
"""Return DB & collection
Returns:
(db, collection)
"""
conn = Connection(arangoURL='http://localhost:8529',
username='******',
password='******')
if not conn.hasDatabase(DB):
db = conn.createDatabase(DB)
else:
db = conn[DB]
if not db.hasCollection(COLLECTION):
collection = db.createCollection(name=COLLECTION)
else:
collection = db.collections[COLLECTION]
return db, collection
def __init__(self) -> None:
self.conn = Connection(arangoURL=config.db_host,
username=config.db_username,
password=config.db_password)
self.db = self._get_db(config.db_name)
self.groups: Chats = self._get_collection('Chats')
self.ab_bio_blacklist: AutobahnBioBlacklist = self._get_collection(
'AutobahnBioBlacklist')
self.ab_string_blacklist: AutobahnStringBlacklist = self._get_collection(
'AutobahnStringBlacklist')
self.ab_filename_blacklist: AutobahnFilenameBlacklist = self._get_collection(
'AutobahnFilenameBlacklist')
self.ab_channel_blacklist: AutobahnChannelBlacklist = self._get_collection(
'AutobahnChannelBlacklist')
self.ab_domain_blacklist: AutobahnDomainBlacklist = self._get_collection(
'AutobahnDomainBlacklist')
self.ab_collection_map = {
'0x0': self.ab_bio_blacklist,
'0x1': self.ab_string_blacklist,
'0x2': self.ab_filename_blacklist,
'0x3': self.ab_channel_blacklist,
'0x4': self.ab_domain_blacklist
}
self.banlist: BanList = self._get_collection('BanList')
def start(uname, passwd):
conn = Connection(username=uname, password=passwd)
db = conn["mydrives"]
filesCollection = db["files"]
students = [('Oscar', 'Wilde', 3.5), ('Thomas', 'Hobbes', 3.2),
('Mark', 'Twain', 3.0), ('Kate', 'Chopin', 3.8),
('Fyodor', 'Dostoevsky', 3.1), ('Jane', 'Austen', 3.4),
('Mary', 'Wollstonecraft', 3.7), ('Percy', 'Shelley', 3.5),
('William', 'Faulkner', 3.8), ('Charlotte', 'Bronte', 3.0)]
for (first, last, gpa) in students:
doc = filesCollection.createDocument()
doc['name'] = "%s %s" % (first, last)
doc['gpa'] = gpa
doc['year'] = 2017
doc._key = ''.join([first, last]).lower()
try:
doc.save()
except CreationError:
pass
def benchmark(start_block, end_block, block_interval, compared_times):
'''
usage - benchmark for mysqldb and arangodb comparison
@start_block - block height start
@end_block - block height end
@block_interval - block query range
@compared_times - query times
@return - {"mysql":[], "arango": [], "pyarango":[]}
'''
assert isinstance(start_block, int)
assert isinstance(end_block, int)
assert isinstance(block_interval, int)
assert isinstance(compared_times, int)
mysql_db = MySQLdb.connect(
'localhost', dbuser, dbpass, dbname, charset='utf8')
conn = Connection(username=dbuser, password=dbpass)
pyarango_db = conn[dbname]
ret = {"mysql": [], "arango": [], "pyarango": []}
ret["param"] = {
"start_block": start_block,
"end_block": end_block,
"block_interval": block_interval
}
while compared_times > 0:
s = start_block + random.random() * (
end_block - start_block - block_interval)
e = s + block_interval
s = int(s)
e = int(e)
ret["mysql"].append(select_mysql(mysql_db, s, e))
ret["arango"].append(select_arango(database, s, e))
ret["pyarango"].append(select_pyarango(pyarango_db, s, e))
compared_times = compared_times - 1
return ret
import requests
import os
from datetime import datetime
from datetime import timedelta
import re
import logging
from time import sleep
import multiprocessing
import threading
import time
import os
from pyArango.connection import Connection
_db = Connection(arangoURL='http://35.198.104.86:8529',
username='******',
password='******')
news_db = _db['news']
_COLLECTION_content = news_db['content']
GLOBAL_BASE_URL = 'https://www.dawn.com/archive/'
GLOBAL_HEADERS = [(
'User-Agent',
'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/36.0.1941.0 Safari/537.36'
)]
class SleepTimer:
def __init__(self):
self.fail = 0
self.success = 0
def setUp(self):
ARANGODB_ROOT_USERNAME = os.getenv('ARANGODB_ROOT_USERNAME', 'root')
ARANGODB_ROOT_PASSWORD = os.getenv('ARANGODB_ROOT_PASSWORD', 'root')
self.conn = Connection(username=ARANGODB_ROOT_USERNAME,
password=ARANGODB_ROOT_PASSWORD)
def connect(self):
self._connection: Connection = Connection(
arangoURL=f'http://{self.config.host}:{self.config.port}',
username=self.config.username,
password=self.config.password)
self.db: Database = self._connection[self.config.db]
def setUp(self):
ARANGODB_ROOT_USERNAME = os.getenv('ARANGODB_ROOT_USERNAME', 'root')
ARANGODB_ROOT_PASSWORD = os.getenv('ARANGODB_ROOT_PASSWORD', 'root')
self.conn = Connection(username=ARANGODB_ROOT_USERNAME, password=ARANGODB_ROOT_PASSWORD)
class ArangoDbPersister(Persister):
"""
A basic ArangoDB persister.
>>> from py2store.persisters.arangodb_w_pyarango import ArangoDbPersister
>>> s = ArangoDbPersister()
>>> k = {'key': '777'} # Each collection will happily accept user-defined _key values.
>>> v = {'val': 'bar'}
>>> for _key in s:
... del s[_key]
...
>>> k in s
False
>>> len(s)
0
>>> s[k] = v
>>> len(s)
1
>>> s[k]
{'val': 'bar'}
>>> s.get(k)
{'val': 'bar'}
>>> s.get({'not': 'a key'}, {'default': 'val'}) # testing s.get with default
{'default': 'val'}
>>> list(s.values())
[{'val': 'bar'}]
>>> k in s # testing __contains__ again
True
>>> del s[k]
>>> len(s)
0
>>> s = ArangoDbPersister(db_name='py2store', key_fields=('name',))
>>> for _key in s:
... del s[_key]
...
>>> s[{'name': 'guido'}] = {'yob': 1956, 'proj': 'python', 'bdfl': False}
>>> s[{'name': 'guido'}]
{'yob': 1956, 'proj': 'python', 'bdfl': False}
>>> s[{'name': 'vitalik'}] = {'yob': 1994, 'proj': 'ethereum', 'bdfl': True}
>>> s[{'name': 'vitalik'}]
{'yob': 1994, 'proj': 'ethereum', 'bdfl': True}
>>> for key, val in s.items():
... print(f"{key}: {val}")
{'name': 'guido'}: {'yob': 1956, 'proj': 'python', 'bdfl': False}
{'name': 'vitalik'}: {'yob': 1994, 'proj': 'ethereum', 'bdfl': True}
"""
# reserved by the database fields
_reserved = {"_key", "_id", "_rev"}
def __init__(
self,
user='******',
password='******',
url='http://127.0.0.1:8529',
db_name='py2store',
collection_name='test',
key_fields=('key', ), # _id, _key and _rev are reserved by db
key_fields_separator='::',
):
self._connection = Connection(
arangoURL=url,
username=user,
password=password,
)
self._db_name = db_name
self._collection_name = collection_name
# If DB not created:
if not self._connection.hasDatabase(self._db_name):
self._connection.createDatabase(self._db_name)
self._adb = self._connection[self._db_name]
# If collection not created:
if not self._adb.hasCollection(self._collection_name):
self._collection = self._adb.createCollection(
name=self._collection_name)
self._collection = self._adb[self._collection_name]
if isinstance(key_fields, str):
key_fields = (key_fields, )
self._key_fields = key_fields
self._key_fields_separator = key_fields_separator
def _make_key(self, keys_dict):
"""
Convert a dict of keys into a real key-string by joining dict values in a predefined order.
DB requirements for the key:
The key must be a string value.
Keys are case-sensitive.
Numeric keys are not allowed.
The key must be from 1 byte to 254 bytes long.
It must consist of:
- letters a-z (lower or upper case),
- digits 0-9
- any of the following characters: _ - : . @ ( ) + , = ; $ ! * ' %
Any other characters cannot be used inside key values.
"""
key_values = [keys_dict[key_label] for key_label in self._key_fields]
key_str = self._key_fields_separator.join(key_values)
return key_str
def _split_key(self, joined_key_str):
"""
Convert a key-string used by DB internally
into a user-friendly dict of key labels and values.
"""
key_values = joined_key_str.split(self._key_fields_separator)
keys_dict = dict(zip(self._key_fields, key_values))
return keys_dict
def __fetchitem__(self, keys_dict):
key = self._make_key(keys_dict)
try:
return self._collection[key]
except DocumentNotFoundError:
raise KeyError(f"No document found for query: {keys_dict}")
def __getitem__(self, keys_dict):
item = self.__fetchitem__(keys_dict)
doc = item.getStore()
# todo (Mike): maybe move this cleanup to a base Arango Store?
# exclude reserved keys and corresponded values
data = {
key: doc[key]
for key in doc
if key not in self._reserved and key not in self._key_fields
}
return data
def __setitem__(self, keys_dict, values_dict):
try:
doc = self.__fetchitem__(keys_dict)
except KeyError:
doc = self._collection.createDocument()
doc._key = self._make_key(keys_dict)
for k, v in values_dict.items():
doc[k] = v
doc.save()
def __delitem__(self, keys_dict):
doc = self.__fetchitem__(keys_dict)
doc.delete()
def __iter__(self):
docs = self._collection.fetchAll()
yield from ({key_name: doc[key_name]
for key_name in self._key_fields} for doc in docs)
def __len__(self):
return self._collection.count()
with open(f'{DIR_PATH}/config.json', 'r') as f:
CONFIG = json.load(f)
SCOPE = [
'https://spreadsheets.google.com/feeds',
'https://www.googleapis.com/auth/drive'
]
CREDENTIALS = ServiceAccountCredentials.from_json_keyfile_name(
f'{DIR_PATH}/credentials.json', SCOPE)
CLIENT = gspread.authorize(CREDENTIALS)
SHEET = CLIENT.open_by_key(CONFIG['google_sheet']['key'])
REVIEW_FIRST_DAY = date(2018, 5, 3)
CONN = Connection(username=CONFIG['db']['username'],
password=CONFIG['db']['password'])
if not CONN.hasDatabase('utopian'):
CONN.createDatabase('utopian')
DB = CONN['utopian']
POSTS_COLLECTION = 'posts'
def connect_collection(db, col_name):
if not db.hasCollection(name=col_name):
db.createCollection(name=col_name)
return db[col_name]
postCol = connect_collection(DB, POSTS_COLLECTION)
class dbConnector:
"""Connects with ONLY ONE db and perform operation on it."""
def __init__(self,
db_name,
auth=False,
password='',
user='******',
arangoURL='http://127.0.0.1:8529'):
"""Init the database conection and set atributes db atribute."""
if auth:
self.conn = Connection(username=user,
password=password,
arangoURL=arangoURL)
else:
self.conn = Connection(username=user, arangoURL=arangoURL)
if self.conn.hasDatabase(db_name):
# conectartla
self.db = pyArango.database.Database(self.conn, db_name)
pass
else:
self.db = self.conn.createDatabase(name=db_name)
# Crearla
def retrieve_collection(self, coll_name): # doc, bd, coll?
# Posiblemente innecesario
"""Return the collection in a list form."""
self.db.reload()
coll = self.db.collections[coll_name]
document_list = []
for document in coll.fetchAll():
document_list.append(document._store)
return document_list
def save_document(self, doc, coll_name): # doc, bd, coll?
"""
Save the document in the database.
It is saved in the collection with the name specified.
Doc, is in a python dic form.
"""
self.db.reload()
if self.db.hasCollection(coll_name):
coll = self.db.collections[coll_name]
document = coll.createDocument()
document._store = doc
document.save()
else:
print('There is no collection with that name')
def retrieve_document(self, coll_name, doc_name): # doc, bd, coll?
"""Return the document in a python dic form."""
self.db.reload()
# FIXME: Modo cutre de encontrar documentos sin clave
# Usar AQL quizas
document_list = self.retrieve_collection(coll_name)
for doc in document_list:
if doc[doc_name]:
return doc
# doc._store
pass
def create_collection(self, coll_name): # doc, bd, coll?
"""Create and return the collection."""
self.db.reload()
if self.db.hasCollection(coll_name):
print('The database already has a collection with that name')
else:
self.db.createCollection(name=coll_name)
#!/usr/bin/env python
from pyArango.connection import Connection
# connect to the db, the db has been setup via docker with no root password
conn = Connection(username='******')
db = conn['eegleio']
# try creating a 'Users' collection if it doesn't exist
try:
userCollection = db.createCollection(name='Users')
except Exception as e:
userCollection = db['Users']
# get name and key for the users that have [email protected] as an email
GET_USER_QUERY = """
FOR u in Users
FILTER u.email == "*****@*****.**"
RETURN {name: u.name, key: u._key}
"""
# create document
document = userCollection.createDocument()
document['name'] = 'titouan'
document['email'] = '*****@*****.**'
document.save()
# execute query
result = db.AQLQuery(GET_USER_QUERY, rawResults=True)
def connection(self): # pylint: disable=no-self-use
ctx = _app_ctx_stack.top
if ctx is not None:
if not hasattr(ctx, 'arango'):
ctx.arango = Connection(self.app.config['ARANGO_URL'])
return ctx.arango
from fuzzywuzzy import fuzz
from xpinyin import Pinyin
from pymongo import MongoClient
from datetime import datetime
from pyArango.connection import Connection
from collections import OrderedDict
import redis
from ConfigError import config, clients
config.dev_address = 102
pinyin = Pinyin()
conR = redis.Redis(host=config.redis_ip,
port=config.redis_port,
db=config.redis_db_error)
conn = Connection(config.arrangoPath, username='******', password=123456)
db_arango = conn[config.arrangoName]
conMongo = MongoClient(host=config.mongo_path, port=config.mongo_port)
db_mongo = conMongo[config.mongoDB]
correct_db = db_mongo.error_logging
wrong_db = db_mongo.error_fail
class ProofCheck:
# def __init__(self,thresholds,confusingRedis,stopWord):
# self.thresholds=thresholds
# self.confusingRedis=confusingRedis
# self.stopWord=stopWord
"""
Manage models in ArangoDB from a common interface.
"""
import os
from pyArango.connection import Connection
from pyArango.theExceptions import DocumentNotFoundError
from flask import current_app as app
AURL = os.getenv('ARANGO_URL', 'http://single-server-int:8529')
CONN = Connection(AURL, 'root', '', verify=False)
def get_database():
"""
Get the database object
:return: The database
"""
if not CONN.hasDatabase('sce'):
database = CONN.createDatabase('sce')
else:
database = CONN['sce']
return database
def get_connection():
"""
Get a connection and list of models.
:return:
"""
if not CONN.hasDatabase('sce'):
from pyArango.connection import Connection, CreationError
import csv
import os
import logging
import sys
logging.basicConfig(format='%(asctime)s %(message)s')
logger = logging.getLogger('KurasutaArangoCreationEnrichment')
logger.setLevel(logging.DEBUG if 'DEBUG' in os.environ and os.environ['DEBUG'] else logging.INFO)
logger.debug('Connecting to arango database...')
arango_connection = Connection(
arangoURL=os.environ['ARANGODB_URL'],
username=os.environ['ARANGODB_USERNAME'],
password=os.environ['ARANGODB_PASSWORD']
)
arango_database = arango_connection['kurasuta']
update_count = 0
tasking_count = 0
tasking_skipped = 0
logger.info('Starting...')
with open(sys.argv[1], 'r') as fp:
for row in csv.reader(fp):
sha256, completed_at, created_at = row
if completed_at:
completed_at = '%s UTC' % completed_at[:19]
if created_at:
created_at = '%s UTC' % created_at[:19]
if completed_at:
sample = arango_database['sample'][sha256]
"""Create Connection to database."""
from pyArango.connection import Connection
from . import settings
CONNECTION = Connection(username=settings.USERNAME,
password=settings.PASSWORD,
arangoURL=settings.CONNECTION_URLS)
class ArangoDbPersister(Persister):
"""
A basic ArangoDB persister.
>>> from py2store.persisters._arangodb_in_progress import ArangoDbPersister
>>> s = ArangoDbPersister()
>>> k = {'key': '777'} # Each collection will happily accept user-defined _key values.
>>> v = {'val': 'bar'}
>>> for _key in s:
... del s[_key]
...
>>> k in s
False
>>> len(s)
0
>>> s[k] = v
>>> len(s)
1
>>> s[k]
{'val': 'bar'}
>>> s.get(k)
{'val': 'bar'}
>>> s.get({'not': 'a key'}, {'default': 'val'}) # testing s.get with default
{'default': 'val'}
>>> list(s.values())
[{'val': 'bar'}]
>>> k in s # testing __contains__ again
True
>>> del s[k]
>>> len(s)
0
>>> s = ArangoDbPersister(db_name='py2store', key_fields=('name',))
>>> for _key in s:
... del s[_key]
...
>>> s[{'name': 'guido'}] = {'yob': 1956, 'proj': 'python', 'bdfl': False}
>>> s[{'name': 'guido'}]
{'yob': 1956, 'proj': 'python', 'bdfl': False}
>>> s[{'name': 'vitalik'}] = {'yob': 1994, 'proj': 'ethereum', 'bdfl': True}
>>> s[{'name': 'vitalik'}]
{'yob': 1994, 'proj': 'ethereum', 'bdfl': True}
>>> for key, val in s.items():
... print(f"{key}: {val}")
{'name': 'guido'}: {'yob': 1956, 'proj': 'python', 'bdfl': False}
{'name': 'vitalik'}: {'yob': 1994, 'proj': 'ethereum', 'bdfl': True}
"""
# reserved by the database fields
_reserved = {"_key", "_id", "_rev"}
def __init__(
self,
user='******',
password='******',
url='http://127.0.0.1:8529',
db_name='py2store',
collection_name='test',
key_fields=('key', ) # _id, _key and _rev are reserved by db
):
self._connection = Connection(arangoURL=url,
username=user,
password=password)
self._db_name = db_name
self._collection_name = collection_name
# if db not created
if not self._connection.hasDatabase(self._db_name):
self._connection.createDatabase(self._db_name)
self._adb = self._connection[self._db_name]
# if collection not created
if not self._adb.hasCollection(self._collection_name):
self._collection = self._adb.createCollection(
name=self._collection_name)
self._collection = self._adb[self._collection_name]
if isinstance(key_fields, str):
key_fields = (key_fields, )
self._key_fields = key_fields
def __fetchitem__(self, k):
f = self._collection.fetchFirstExample(k)
if f is not None and len(f) == 1:
return f[0]
return None
def __getitem__(self, k):
f = self.__fetchitem__(k)
if f is not None:
d = f.getStore()
# exclude reserved keys and corresponded values
d = {
x: d[x]
for x in d
if x not in self._reserved and x not in self._key_fields
}
return d
else:
raise KeyError(f"No document found for query: {k}")
def __setitem__(self, k, v):
doc = self._collection.createDocument(dict(k, **v))
doc.save()
def __delitem__(self, k):
if len(k) > 0:
f = self.__fetchitem__(k)
if f is not None:
return f.delete()
raise KeyError(f"You can't removed that key: {k}")
def __iter__(self):
docs = self._collection.fetchAll()
yield from [{x: d[x]
for x in d.getStore() if x in self._key_fields}
for d in docs]
def __len__(self):
return self._collection.count()
from pyArango.connection import Connection
conn = Connection(username="******", password="******")
db_name = "logistics"
if not conn.databases.get(db_name, None):
db = conn.createDatabase(name="logistics")
db_conn = conn[db_name]
if not db_conn.hasCollection("provider"):
db_conn.createCollection(name="provider")
# pc = db_conn.createDocument()
"""
Name, Email, Phone Number, Language, Currency
# name, email, mobile, language, currency
"""
if not db_conn.hasCollection("service_area"):
db_conn.createCollection(name="service_area")
"""
provider id, geojson polygons, polygon name, price
"""
