def get_cloudant_database(topic, source, doc_type):
account = cloudant.Account(USERNAME)
account.login(USERNAME, PASSWORD)
db = account.database('{}_{}_{}'.format(topic, source, doc_type))
# create db if non existant
db.put()
return db
def get_conn(self):
def _str(s):
# cloudant-python doesn't support unicode.
if isinstance(s, unicode):
_log.debug(('cloudant-python does not support unicode. '
'Encoding %s as ascii using "ignore".'), s)
return s.encode('ascii', 'ignore')
return s
conn = self.get_connection(self.cloudant_conn_id)
for conn_param in ['host', 'password', 'schema']:
if not hasattr(conn, conn_param) or not getattr(conn, conn_param):
raise AirflowException(
'missing connection parameter {0}'.format(conn_param))
# In the connection form:
# - 'host' is renamed to 'Account'
# - 'login' is renamed 'Username (or API Key)'
# - 'schema' is renamed to 'Database'
#
# So, use the 'host' attribute as the account name, and, if login is
# defined, use that as the username.
account = cloudant.Account(_str(conn.host))
username = _str(conn.login or conn.host)
account.login(username, _str(conn.password)).raise_for_status()
return account.database(_str(conn.schema))
def get_current_account(host=""):
global _acct
if _acct: return _acct
un, pw = populate_username_pw()
_acct = cloudant.Account(uri="http://%s" % host, async=True)
res = _acct.login(un, pw)
login = res.result()
if login.status_code != 200:
print "UN/Password incorrect"
_acct = None
return get_current_account(host)
def __init__(self,databases):
#Created for get_db method
self._databases = dict()
self._accounts = dict()
self._labels = list()
for db_label,db_info in databases.iteritems():
account = cloudant.Account(db_info.get('ACCOUNT_USERNAME'))
account.login(db_info.get('USERNAME'),db_info.get('PASSWORD'))
db = account.database(db_info.get('DATABASE'))
db.dbname = db_info.get('DATABASE')
self._databases[db_label] = db
self._labels.append(db_label)
self._accounts[db_label] = account
def setUp(self):
self.uri = 'http://localhost:5984'
names = cloudant.Account(self.uri).uuids(4).json()['uuids']
# database names must start with a letter
names = ['a' + name for name in names]
self.db_name = names[0]
self.otherdb_name = names[1]
self.doc_name = names[2]
self.otherdoc_name = names[3]
self.test_doc = {'herp': 'derp', 'name': 'Luke Skywalker'}
self.test_otherdoc = {
'derp': 'herp',
'name': 'Larry, the Incorrigible Miscreant'
}
def setupDB(services):
'''
Setup a cloudant DB object
'''
dbUser = services['cloudantNoSQLDB'][0]['credentials']['username']
dbPass = services['cloudantNoSQLDB'][0]['credentials']['password']
account = cloudant.Account(dbUser)
login = account.login(dbUser, dbPass)
assert login.status_code == 200
# Select the DB
db = account.database('skipr')
response = db.get().json()
# Ensure DB exists
if 'error' in response and response['error'] == 'not_found':
response = db.put().json()
assert login.status_code == 200
print('Successfully connected to database')
return db
def main():
account_name = 'cloudant_account'
username = '******'
password = '******'
account = cloudant.Account(account_name)
account.login(username, password)
database = account.database('timelapse')
design = database.design('picsInDateRange1')
pics = design.index('_view/picDateCreated?include_docs=true')
# newFile = urllib.URLopener()
i = 000
for pic in pics:
i = i + 1
file_name = '/Users/scottpecnik/Desktop/pictures/' + format(
i, '03d') + '.png'
print(file_name)
pic_URL = 'https://' + str(
account_name) + '.' + 'cloudant.com/timelapse/' + str(
pic['doc']['_id']) + '/picture'
r = design.attachment(pic_URL).get()
with open(file_name, 'wb') as f:
f.write(r.content)
vcap_config = os.environ.get('VCAP_SERVICES')
decoded_config = json.loads(vcap_config)
dbname = "fabulous-price-finder"
account = None
for key, value in decoded_config.iteritems():
if key.startswith('cloudant'):
cloudant_creds = decoded_config[key][0]['credentials']
cloudant_host = cloudant_creds['host']
cloudant_port = int(cloudant_creds['port'])
cloudant_username = cloudant_creds['username']
cloudant_password = cloudant_creds['password']
cloudant_url = str(cloudant_creds['url'])
account = cloudant.Account(cloudant_username)
login = account.login(cloudant_username, cloudant_password)
assert login.status_code == 200
db = account.database(dbname)
response = db.put()
print response.json
#Provide all the static css and js files under the static dir to browser
@route('/static/:filename#.*#')
def server_static(filename):
""" This is for JS files """
return static_file(filename, root='static')
def get_acct(self):
acct = cloudant.Account("http://raid.nedm1:5984")
requests.utils.add_dict_to_cookiejar(acct._session.cookies,
dict(AuthSession=""))
return acct
def testCloudant(self):
account = cloudant.Account('garbados')
assert account.uri == "https://garbados.cloudant.com"
def setUp(self):
super(AccountTest, self).setUp()
self.account = cloudant.Account(self.uri)
logging.basicConfig(level=logging.DEBUG)
USERNAME = '******'
KEY = os.environ.get('USERNAME')
SECRET = os.environ.get('PASSWORD')
DATABASE = sys.argv[1]
HEADINGS = ['h1', 'h2', 'h3']
print KEY
print SECRET
print "database" + DATABASE
if KEY and SECRET:
print "account with auth"
account = cloudant.Account(USERNAME, auth=(KEY, SECRET))
else:
print "account without auth"
account = cloudant.Account()
database = account.database(DATABASE)
def make_docs(headers, filename):
print "make_docs called with filename = " + filename
docs = dict()
for header in headers:
if not 'id' in header.attrs:
print 'header does not have an id attribute'
continue;
doc = dict(_id=filename + '-' + header['id'], title=header.get_text())
children = []
#logging
if app.debug is not True:
import logging
from logging.handlers import RotatingFileHandler
file_handler = RotatingFileHandler('ml-service.log',
maxBytes=1024 * 1024 * 100,
backupCount=20)
file_handler.setLevel(logging.WARNING)
formatter = logging.Formatter(
"%(asctime)s - %(name)s - %(levelname)s - %(message)s")
file_handler.setFormatter(formatter)
app.logger.setLevel(logging.WARNING)
app.logger.addHandler(file_handler)
#equip this app with Restful-API support
api = Api(app)
#connect to Cloudant database
db_account = cloudant.Account(app.config['CLOUDANT_USER'])
login = db_account.login(app.config['CLOUDANT_USER'],
app.config['CLOUDANT_PWD'])
#equip this app with login manager
lm = LoginManager()
lm.init_app(app)
lm.login_view = 'login'
app.permanent_session_lifetime = timedelta(
minutes=app.config['SESSION_TIMEOUT_MINUTES'])
from app import views, user, RESTful_APIs
import os
import json
import cloudant
keys = json.load(open('cloudant.json', 'rb'))
# connect to your account
USERNAME = keys['cloudant']["username"]
password = keys['cloudant']["password"]
# in this case, https://garbados.cloudant.com
account = cloudant.Account(USERNAME)
# login, so we can make changes
login = account.login(USERNAME, password)
assert login.status_code == 200
db = account.database('lycaeum_forums')
initial_drug_list = []
with open("drug_names", "r") as fid:
for line in fid:
drug = line[0:-1]
initial_drug_list.append(drug)
cleaned_drug_list = list(set(initial_drug_list)) #remake drug list
posts_with_no_drugs = 0
# traverse root directory, and list directories as dirs and files as files
for root, dirs, files in os.walk("forums"):
path = root.split('/')
app = Flask(__name__)
if 'VCAP_SERVICES' in os.environ:
cloudantInfo = json.loads(
os.environ['VCAP_SERVICES'])['cloudantNoSQLDB'][0]
#we are local
else:
with open('.env.vcap_services.json') as configFile:
cloudantInfo = json.load(
configFile)['VCAP_SERVICES']['cloudantNoSQLDB'][0]
username = cloudantInfo["credentials"]["username"]
password = cloudantInfo["credentials"]["password"]
account = cloudant.Account(username)
login = account.login(username, password)
assert login.status_code == 200
# os.chdir('birdland-frontend/dist/')
os.chdir('static')
print("current dir")
print(os.path.dirname(os.path.realpath(__file__)))
@app.route('/')
def test_html():
print("test html dir")
print(os.path.dirname(os.path.realpath(__file__)))
response = app.send_static_file("index.html")
DatabaseDeleteError
"""
for each_index in indexes:
index = {
"index": {"fields": each_index},
"type": "json"}
try_index = db.post(path='_index', params = index)
if try_index.status_code != 200:
#if storing index is not successful, raise an exception
raise IndexCreateError(msg="Create index for " + db_name + \
" failed.")
import cloudant
account = cloudant.Account(CLOUDANT_USER)
login = account.login(CLOUDANT_USER, CLOUDANT_PWD)
#raise an exception when connecting to database failed
if login.status_code != 200:
raise DatabaseConnectError("Connect to Cloudant failed with reason: " + login.text)
databases = ['user_db', 'model_info_db', 'model_history_db']
for db_name in databases:
if account.get(db_name).status_code != 404:
#if this database already exists, delete it.
try_delete = account.database(db_name).delete()
if try_delete.status_code != 200:
raise DatabaseDeleteError(msg="Delete database "+ db_name + \
" failed with reason: " + try_delete.text)
def login(self):
self.account = cloudant.Account(self.account)
self.account.login(self.username, self.password)
self.database = self.account.database('timelapse')
def connect_db():
"""Returns a new connection to the Cloudant database."""
app.logger.debug('Connecting to Cloudant database...')
account = cloudant.Account(app.config['ACCOUNT'])
return account.database(app.config['DATABASE'])
def __init__(self, uri, user=None, passwd=None):
assert passwd if user else True, 'Argument "passwd" is required'
self.credential = (user, passwd) if user else None
self.uri = uri
self.account = cloudant.Account(self.uri, auth=self.credential)
def __acct(self):
acct = cloudant.Account(uri=db_url)
acct.login(db_un, db_pw)
db = acct[db_name]
return acct, db
