def fetchTimes(dbname): with couchdb('admin', 'isthisroomoccupied', url='http://127.0.0.1:5984/') as client: db = client[dbname] docs = [] for document in db: docs.append(document['date']) return docs
def add_function(map_function_source, reduce_function_source, db_config, language, benchmark): with couchdb(db_config['user'], db_config['password'], url=db_config['url']) as couch: db = couch[db_config['name']] design_doc = db.get_design_document(db_config['design_doc']) logger.info('Working with design document {} from DB {}.'.format( design_doc['_id'], db.database_name)) design_doc['language'] = language view = design_doc.get_view(db_config['view']) if view is None: logger.info('View {} does not exist, creating a new one.'.format( db_config['view'])) design_doc.add_view(db_config['view'], map_function_source, reduce_function_source) else: logger.info('View {} exists, updating.'.format(view.view_name)) design_doc.update_view(db_config['view'], map_function_source, reduce_function_source) logger.debug(design_doc.json()) design_doc.save() logger.info('Design doc successfully saved.') logger.debug(design_doc.info()) if benchmark: view = design_doc.get_view(db_config['view']) do_benchmark(couch, view)
def check_user_email(user_email: str): with couchdb(USER_U, PASSWORD_U, url=COUCHDB_URL_U) as client: users = client['users'] selector = {'email': {'$eq': user_email}} docs = users.get_query_result(selector) if len(docs[0]): return User_inDB(**docs[0][0])
def listDatabases(self): with couchdb(self._user, self._pass, url=self._url) as client: print(f"Documents Database") print(f"========= =====================") for db in client.all_dbs(): print(f"{client[db].doc_count():9} {db}") print(f"========= =====================")
def fetchAll(dbname): with couchdb('admin', 'isthisroomoccupied', url='http://127.0.0.1:5984/') as client: my_database = client[dbname] docs = json.loads('{"docs": []}') for document in my_database: docs['docs'].append(document) return docs
def getDatabaseDesigns(self, dbname): with couchdb(self._user, self._pass, url=self._url) as client: db = client[dbname] docs = db.design_documents() for item in docs: doc = item['doc'] for k, v in doc.items(): print(f"{k}\n {v}")
def update_user(user_id: str, update_dict: dict): with couchdb(USER_U, PASSWORD_U, url=COUCHDB_URL_U) as client: users = client['users'] user = users[user_id] for key, value in update_dict.items(): user[key] = value user.save() return user
def __init__(self, password, user='******', url='http://localhost:5984'): self._user = user self._pass = password self._url = url self._user_db = "_users" self._metadata = {} with couchdb(self._user, self._pass, url=self._url) as client: self._metadata = client.metadata()
def update_site(site_id: str, update_dict: dict): with couchdb(USER_S, PASSWORD_S, url=COUCHDB_URL_S) as client: sites = client['sites'] site = sites[site_id] for key, value in update_dict.items(): site[key] = value site.save() return site
def create_site(site: Site_in, slug: str, owner: str): site_dict = site.dict() site_dict.update([('_id', slug), ('owner_id', owner), ('created_on_utc', datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S.%f'))]) with couchdb(USER_S, PASSWORD_S, url=COUCHDB_URL_S) as client: sites = client['sites'] new_site = sites.create_document(site_dict) return new_site
def test_couchdb_context_helper(self): """ Test that the couchdb context helper works as expected. """ try: with couchdb(self.user, self.pwd, url=self.url) as c: self.assertIsInstance(c, CouchDB) self.assertIsInstance(c.r_session, requests.Session) except Exception as err: self.fail('Exception {0} was raised.'.format(str(err)))
def create_user(user: User_in): user_dict = user.dict() hash_password = get_password_hash(user_dict['password']) user_dict.pop('password') user_dict.update([('password_hash', hash_password), ('registered_on_utc', datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S.%f')), ('role', 'standard')]) with couchdb(USER_U, PASSWORD_U, url=COUCHDB_URL_U) as client: users = client['users'] new_user = users.create_document(user_dict) return new_user
def getDatabaseUsers(self, dbname): with couchdb(self._user, self._pass, url=self._url) as client: db = client[dbname] print(f"Admin party:\n{db.admin_party}") creds = db.creds print("Database credentials document:") pprint(creds) print("Security documents:") counter = 0 with cloudant.security_document.SecurityDocument(db) as secdoc: print(f"[{counter}] {secdoc.json()}") counter += 1
def test_end_to_end(self): """ End to end database and document crud tests """ with couchdb(self.user, self.passwd, url='http://127.0.0.1:5984') as c: session = c.session() self.assertEqual(session['userCtx']['name'], self.user) db = c.create_database(self.dbname) try: self.assertTrue(self.dbname in c) self.assertTrue(db.exists()) # creating docs doc1 = db.new_document() doc2 = db.create_document({'_id': 'womp', "testing": "document2"}) doc3 = db.create_document({"testing": "document3"}) self.assertTrue('_id' in doc1) self.assertTrue('_rev' in doc1) self.assertTrue('_id' in doc2) self.assertTrue('_rev' in doc2) self.assertTrue('_id' in doc3) self.assertTrue('_rev' in doc3) # verifying access via dict api self.assertTrue(doc1['_id'] in db) self.assertTrue(doc2['_id'] in db) self.assertTrue(doc3['_id'] in db) self.assertTrue(db[doc1['_id']] == doc1) self.assertTrue(db[doc2['_id']] == doc2) self.assertTrue(db[doc3['_id']] == doc3) # test working context for updating docs with doc2 as working_doc: working_doc['field1'] = [1, 2, 3] working_doc['field2'] = {'a': 'b'} self.assertEqual( c[self.dbname]['womp']['field2'], {'a': 'b'} ) finally: # remove test database c.delete_database(self.dbname)
def test_end_to_end(self): """ End to end database and document crud tests """ with couchdb(self.user, self.passwd, url='http://127.0.0.1:5984') as c: session = c.session() self.assertEqual(session['userCtx']['name'], self.user) db = c.create_database(self.dbname) try: self.assertIn(self.dbname, c) self.assertTrue(db.exists()) # creating docs doc1 = db.new_document() doc2 = db.create_document({'_id': 'womp', "testing": "document2"}) doc3 = db.create_document({"testing": "document3"}) self.assertIn('_id', doc1) self.assertIn('_rev', doc1) self.assertIn('_id', doc2) self.assertIn('_rev', doc2) self.assertIn('_id', doc3) self.assertIn('_rev', doc3) # verifying access via dict api self.assertIn(doc1['_id'], db) self.assertIn(doc2['_id'], db) self.assertIn(doc3['_id'], db) self.assertEqual(db[doc1['_id']], doc1) self.assertEqual(db[doc2['_id']], doc2) self.assertEqual(db[doc3['_id']], doc3) # test working context for updating docs with doc2 as working_doc: working_doc['field1'] = [1, 2, 3] working_doc['field2'] = {'a': 'b'} self.assertEqual( c[self.dbname]['womp']['field2'], {'a': 'b'} ) finally: # remove test database c.delete_database(self.dbname)
def listUsers(self): """ List all users known to CouchDB instance. Returns: """ with couchdb(self._user, self._pass, url=self._url) as client: db = client["_users"] alldocs = db.all_docs(include_docs=True) for doc in alldocs['rows']: if doc['doc']['_id'].startswith("org.couchdb.user"): print(f"{doc['doc']['_id']}") print(f" username: {doc['doc']['name']}") print(f" roles: {','.join(doc['doc']['roles'])}")
def compactDatabase(self, dbname): """ https://docs.couchdb.org/en/stable/maintenance/compaction.html Args: dbname: Returns: """ with couchdb(self._user, self._pass, url=self._url) as client: url = "/".join((self._url, dbname, "_compact")) logging.debug("Compacting %s", dbname) response = client.r_session.post( url, headers={'Content-Type': 'application/json'}) logging.debug(response) logging.debug(response.text)
def import_batch(docs, db_config): """Bulk import a batch of ElasticSearch-like documents into CouchDB""" t1 = process_time() docs_objects = [] for d in docs: if d: doc_object = json.loads(d) source = doc_object['_source']['nacp_orig'] source.update({'_id': doc_object['_id']}) docs_objects.append(preprocess_doc(source)) with couchdb(db_config['user'], db_config['password'], url=db_config['url']) as couch: db = couch[db_config['name']] db.bulk_docs(docs_objects) t2 = process_time() return len(docs_objects), t2 - t1
def addUser(self, username, password, roles: []): """ Adds a user to the CouchDB instance. A user can then be added to a database. Args: username: password: roles: Returns: """ credentials = { "_id": f"org.couchdb.user:{username}", "name": username, "type": "user", "roles": roles, "password": password } with couchdb(self._user, self._pass, url=self._url) as client: user_db = client["_users"] user_db.create_document(credentials, throw_on_exists=True)
def del_site(site_id: str): with couchdb(USER_S, PASSWORD_S, url=COUCHDB_URL_S) as client: sites = client['sites'] site = sites[site_id] site.delete()
def get_site(site_id: str): with couchdb(USER_S, PASSWORD_S, url=COUCHDB_URL_S) as client: sites = client['sites'] if (site_id in sites): return sites[site_id]
def get_sites(skip: int = 0, limit: int = 100): with couchdb(USER_S, PASSWORD_S, url=COUCHDB_URL_S) as client: sitesdb = client['sites'] sites = [site for site in sitesdb] return sites
def __init__(db_user, db_pass, db_url, db_name, id_pattern=None): self.db_client_context = cloudant.couchdb(db_user, db_pass, url=db_url) self.id_pattern = id_pattern self.db_name = db_name
def couchdb_admin_session(): return couchdb(settings.COUCH_DB_ADMIN_USER, settings.COUCH_DB_ADMIN_PWD, url=settings.COUCH_DB_URL)
def get_local_db(): with couchdb(settings.COUCH_DB_USER, settings.COUCH_DB_PWD, url=settings.COUCH_DB_URL) as session: db = session["tellme"] yield db
'--purge', help='Purge the DB before importing', action='store_true', default=False) args = parser.parse_args() db_config = { 'user': args.username, 'password': args.password, 'url': args.endpoint, 'name': args.dbname } # Ensure our DB exists before actually importing with couchdb(db_config['user'], db_config['password'], url=db_config['url']) as couch: try: db = couch[args.dbname] if args.purge: db.delete() logger.info('Database {} purged.'.format(args.dbname)) except KeyError: pass db = couch.create_database(args.dbname, throw_on_exists=False) if db.exists(): logger.info('Database {} created or already exists'.format( args.dbname)) import_all(args.docs_file, db_config, args.concurrency, args.chunks)
def get_users(skip: int = 0, limit: int = 100): with couchdb(USER_U, PASSWORD_U, url=COUCHDB_URL_U) as client: usersdb = client['users'] users = [user for user in usersdb] return users
def get_user(user_id: str): with couchdb(USER_U, PASSWORD_U, url=COUCHDB_URL_U) as client: users = client['users'] if (user_id in users): return users[user_id]
def openCouchSession(): with couchdb('admin', 'isthisroomoccupied', url='http://127.0.0.1:5984/') as client: # Context handles connect() and disconnect() for you. # Perform library operations within this context. Such as: print(client.all_dbs())
def del_user(user_id: str): with couchdb(USER_U, PASSWORD_U, url=COUCHDB_URL_U) as client: users = client['users'] user = users[user_id] user.delete()
database = sys.argv[3] host = "http://localhost:5984" #view document _doc = { "_id": "_design/gene_target", "views": { "counts": { "map": "function(doc) { emit(doc.primary_target,1); }", "reduce": "function(k,v) {return sum(v);}", } } } with couchdb(username, password, url=host) as client: db = client[database] view = Document(db, "_design/gene_target") if view.exists(): print "Exists" else: try: view = db.create_document(_doc) except: print "Error" result = db.get_view_result("_design/most_severe_consequences", "counts", group=True) for item in result: print res