def setup_module(module):
"Read the settings file only once."
global server
try:
settings = couchdb2.read_settings("test_settings.json")
server = couchdb2.Server(username=settings["USERNAME"],
password=settings["PASSWORD"])
except IOError:
server = couchdb2.Server()
def couchdb_conex():
server = couchdb2.Server(href='http://couchdb:5984/',
username='******',
password='******',
use_session=True,
ca_file=None)
db = server.create('test')
doc1 = {'_id': 'myid', 'name': 'mydoc', 'level': 4}
db.put(doc1)
doc = db['myid']
assert doc == doc1
doc2 = {'name': 'another', 'level': 0}
db.put(doc2)
print(doc2)
db.put_design(
'mydesign',
{"views": {
"name": {
"map": "function (doc) {emit(doc.name, null);}"
}
}})
result = db.view('mydesign', 'name', key='another', include_docs=True)
assert len(result) == 1
print(result[0].doc)
def get_dbserver(app=None):
"Get the connection to the CouchDB database server."
if app is None:
app = flask.current_app
return couchdb2.Server(href=app.config["COUCHDB_URL"],
username=app.config["COUCHDB_USERNAME"],
password=app.config["COUCHDB_PASSWORD"])
def test_server():
global server
data = server()
assert "version" in data
assert "vendor" in data
assert server.version
if server.version >= "2.0":
assert server.up()
# Cannot connect to nonsense address
with pytest.raises(IOError):
couchdb2.Server("http://localhost:123456/").version
if server.version >= "2.0":
data = server.get_config()
assert "vendor" in data
assert "log" in data
data = server.get_cluster_setup()
assert "state" in data
data = server.get_membership()
assert "all_nodes" in data
assert "cluster_nodes" in data
data = server.get_scheduler_jobs()
assert "jobs" in data
data = server.get_node_stats()
assert "couchdb" in data
assert "httpd" in data["couchdb"]
data = server.get_node_system()
assert "uptime" in data
assert "memory" in data
data = server.get_active_tasks()
assert isinstance(data, type([]))
def heatMapOrigin(request):
if request.method == "GET":
list = []
try:
server1 = couchdb2.Server(address)
db = server1['tweets']
result = db.view('/abc',
'testView2',
group=True,
group_level=2,
reduce=True)
sum = 0
for row in result:
item = {'location': row.key, 'count': row.value}
sum += row.value
list.append(item)
cache = open('backend/cache/heatMapOrigin.json', 'w')
json.dump(list, cache)
cache.close()
except BaseException:
print("error in connecting to the database")
cache = open('backend/cache/heatMapOrigin.json', 'r')
list = json.load(cache)
cache.close()
finally:
return render(request, 'test.html', {'data': list})
def get_dbserver():
"Return the CouchDB2 handle for the CouchDB server."
kwargs = dict(href=settings["DATABASE_SERVER"])
if settings.get("DATABASE_ACCOUNT") and settings.get("DATABASE_PASSWORD"):
kwargs["username"] = settings["DATABASE_ACCOUNT"]
kwargs["password"] = settings["DATABASE_PASSWORD"]
return couchdb2.Server(**kwargs)
def get_db(app=None):
"Get a connection to the database."
if app is None:
app = flask.current_app
server = couchdb2.Server(
href=app.config["COUCHDB_URL"],
username=app.config["COUCHDB_USERNAME"],
password=app.config["COUCHDB_PASSWORD"],
)
return server[app.config["COUCHDB_DBNAME"]]
def heatByState(request):
if request.method == "GET":
stateCount = {
'vic': 0,
'nsw': 0,
'sa': 0,
'qsl': 0,
'wa': 0,
'tas': 0,
'nt': 0,
'act': 0
}
try:
statLocation = StateLocation()
server1 = couchdb2.Server(address)
db = server1['tweets']
result = db.view('/abc',
'testView2',
group=True,
group_level=2,
reduce=True)
for row in result:
item = {'location': row.key, 'count': row.value}
if statLocation.inVIC(item['location']):
stateCount['vic'] += item['count']
elif statLocation.inNSW(item['location']):
stateCount['nsw'] += item['count']
elif statLocation.inSA(item['location']):
stateCount['sa'] += item['count']
elif statLocation.inQSL(item['location']):
stateCount['qsl'] += item['count']
elif statLocation.inWA(item['location']):
stateCount['wa'] += item['count']
elif statLocation.inTas(item['location']):
stateCount['tas'] += item['count']
elif statLocation.inNT(item['location']):
stateCount['nt'] += item['count']
elif statLocation.inCT(item['location']):
stateCount['ct'] += item['count']
for key in stateCount:
stateCount[key] = stateCount[key] / 1000
cache = open('backend/cache/stateCountCache.json', 'w')
json.dump(stateCount, cache)
cache.close()
except BaseException:
print("error in connecting to the database")
cache = open('backend/cache/stateCountCache.json', 'r')
stateCount = json.load(cache)
cache.close()
finally:
return render(request, 'heatMapByState.html', {
'data': stateCount,
'aurin': readPopulation()
})
def language(request):
if request.method == 'GET':
languageState = {}
languageOrigin = []
try:
server1 = couchdb2.Server(address)
db = server1['tweets']
result = db.view('/abc',
'language',
group=True,
group_level=2,
reduce=True)
en = {}
languageOrigin = []
for row in result:
if row.key[0] == "en":
en[tuple(row.key[1])] = row.value
else:
if tuple(row.key[1]) in en:
enCount = en.get(tuple(row.key[1]))
item = {
'location': row.key[1],
'count': row.value / (row.value + enCount)
}
languageOrigin.append(item)
else:
item = {'location': row.key[1], 'count': 1}
languageOrigin.append(item)
for item in languageOrigin:
item['count'] = round(item['count'], 4)
languageState = languageByState(result)
cache1 = open('backend/cache/languageOrigin.json', 'w')
json.dump(languageOrigin, cache1)
cache1.close()
cache2 = open('backend/cache/languageState.json', 'w')
json.dump(languageState, cache2)
cache2.close()
except BaseException:
print("error in connecting to the database")
cache1 = open('backend/cache/languageOrigin.json', 'r')
languageOrigin = json.load(cache1)
cache1.close()
cache2 = open('backend/cache/languageState.json', 'r')
languageState = json.load(cache2)
cache2.close()
finally:
return render(
request, 'language.html', {
'data': languageOrigin,
"aurin": heatByStateAurin(),
'rate': readLanguageByState(),
'languageStateRate': languageState
})
def setUp(self):
self.settings = {
"SERVER": "http://localhost:5984",
"DATABASE": "test",
"USERNAME": None,
"PASSWORD": None,
}
try:
self.settings = couchdb2.read_settings("test_settings.json",
self.settings)
except IOError:
pass
self.server = couchdb2.Server(username=self.settings["USERNAME"],
password=self.settings["PASSWORD"])
def pong(request):
if request.method == "GET":
server1 = couchdb2.Server(address)
db = server1['tweets']
list = []
result = db.view('/abc',
'testView2',
group=True,
group_level=2,
reduce=True)
sum = 0
for row in result:
item = {'location': row.key, 'count': row.value}
sum += row.value
list.append(item)
return JsonResponse({"message": list})
def dayAndTime(request):
if request.method == 'GET':
day = []
time = []
try:
server1 = couchdb2.Server(address)
db = server1['tweets']
result = db.view('/abc',
'day',
group=True,
group_level=1,
reduce=True)
for row in result:
item = {'day': row.key, 'frequency': row.value}
day.append(item)
result = db.view('/abc',
'time',
group=True,
group_level=1,
reduce=True)
for row in result:
item = {'time': row.key, 'frequency': row.value}
time.append(item)
cache1 = open('backend/cache/day.json', 'w')
json.dump(day, cache1)
cache1.close()
cache2 = open('backend/cache/time.json', 'w')
json.dump(time, cache2)
cache2.close()
except BaseException:
print("error in connecting to database")
cache1 = open('backend/cache/day.json', 'r')
day = json.load(cache1)
cache1.close()
cache2 = open('backend/cache/time.json', 'r')
time = json.load(cache2)
cache2.close()
finally:
return render(request, 'daytime.html', {'day': day, 'time': time})
import couchdb2
server = couchdb2.Server(href='http://127.0.0.1:5985/',
username='******',
password='******',
use_session=True,
ca_file=None)
db = server.create('test')
doc1 = {'_id': 'myid', 'name': 'mydoc', 'level': 4}
db.put(doc1)
doc = db['myid']
assert doc == doc1
doc2 = {'name': 'another', 'level': 0}
db.put(doc2)
print(doc2)
db.put_design(
'mydesign',
{"views": {
"name": {
"map": "function (doc) {emit(doc.name, null);}"
}
}})
result = db.view('mydesign', 'name', key='another', include_docs=True)
assert len(result) == 1
print(result[0].doc)
volumen()
def test_00_no_such_server(self):
"Check the error when trying to use a non-existent server."
with self.assertRaises(IOError):
couchdb2.Server("http://localhost:123456/").version
from flask import Flask, jsonify
from flask_restful import Api, Resource, reqparse, abort, fields, marshal_with
from flask_sqlalchemy import SQLAlchemy
import couchdb2, json, config
import pandas as pd
from datetime import datetime
from multiprocessing.pool import ThreadPool
app = Flask(__name__)
api = Api(app)
server = couchdb2.Server("http://%s:%s@%s:%s" % (config.db_user, config.db_pass, config.db_host, config.db_port))
if server.up(): # if server is up and ready
x, y = 'CouchDB ('+str(server.version)+') up and running with ('+str(len(server))+') user defined databases. Databases include:', ''
for dbname in server:
y = y + ' ' + str(dbname)
x = x + y
else:
x = 'CouchDB not reachable'
print('status:', x)
# Check the couchdb server atatus if up and running.
class Home(Resource):
def get(self):
return jsonify({"message": "CyVID API Running"})
# Check the couchdb server atatus if up and running.
class CyVID(Resource):
def get(self):
return jsonify({"message": x})
class Authenticate(Resource):
default='inkdrop',
help='CouchDB2 database to use, default: inkdrop')
args = parser.parse_args()
if not args.quiver:
print('Need a Quiver library to import from!')
sys.exit(1)
if not os.path.isdir(args.quiver):
print('%s is not a directory to import from!' % args.quiver)
sys.exit(1)
if args.user:
server = couchdb2.Server(href=args.server,
username=args.user,
password=args.password,
use_session=True)
else:
server = couchdb2.Server(href=args.server, use_session=True)
# make things for which we don't have a timestamp "created" 3y ago and updated today
now_ts = datetime.datetime.now().timestamp()
default_ts = now_ts - 94608000
db = couchdb2.Database(server, args.database, check=True)
# read data from Quiver
tags = []
ctags = get_couch_tags(db)
cbooks = get_couch_books(db)