Exemplo n.º 1
0
def getDBDtls():
    if request.method == 'POST' and request.form['dbdtls'] == 'False':
        dbusername = request.form['username']
        dbpassword = request.form['password']
        dburl = request.form['url']
        global db_user
        global db_pass
        global db_url
        db_user = dbusername
        db_pass = dbpassword
        db_url = dburl
        client = Cloudant(db_user, db_pass, url=db_url)
        client.connect()
        try:
            myDatabase = client.create_database("user_db")
            global db_svc
            db_svc = {"dbsvc": myDatabase}
        except CloudantException as err:
            print err
            client = Cloudant(db_user, db_pass, url=db_url)
            client.connect()
            client.delete_database("user_db")
            myDatabase = client.create_database("user_db")
            global db_svc
            db_svc = {"dbsvc": myDatabase}
        return render_template('index.html', getUsrDtls=True)
def main(dict):
    user = dict.get("username", "<username from credentials>")
    passwd = dict.get("password", "<password from credentials>")
    host = dict.get("host", "<host from credentials>")
    db_name = "test_cloud_functions_python_3_ibm_runtime"

    client = Cloudant(user,
                      passwd,
                      url='https://{0}'.format(host),
                      connect=True)

    try:
        client.delete_database(db_name)
    except CloudantClientException as ex:
        if ex.status_code != 404:
            raise CloudantClientException(ex.status_code, db_name)

    my_database = client.create_database('my_database')
    if my_database.exists():
        print('SUCCESS DB exists!!')

    data = {"_id": "p3", "firstname": "Suzzy", "lastname": "Queue"}
    my_document = my_database.create_document(data)
    if my_document.exists():
        print('SUCCESS DOC exist!!')

    my_document_read = my_database['p3']

    return my_document_read
def main(dict):
    user = dict.get("username", "<username from credentials>")
    passwd = dict.get("password", "<password from credentials>")
    host = dict.get("host", "<host from credentials>")
    db_name = "test_cloud_functions_python_3_ibm_runtime"

    client = Cloudant(user,
                      passwd,
                      url='https://{0}'.format(host),
                      connect=True)

    try:
        client.delete_database(db_name)
    except CloudantClientException as ex:
        if ex.status_code != 404:
            raise CloudantClientException(ex.status_code, db_name)

    my_database = client.create_database(db_name)
    if my_database.exists():
        print('SUCCESS DB exists!!')
    """Sample document"""
    _id = str(uuid.uuid4())
    data = {"agentId": "Suzzy", "type": "User"}
    update_data = {"lastname": "Queue"}
    """Run tests"""
    test_create_doc(my_database, _id, data)
    test_update_doc(my_database, _id, update_data)
    test_get_doc_by_id(my_database, _id)
    doc = test_fetch_doc_by_id(my_database, _id)
    test_delete_doc_by_id(my_database, doc['_id'])

    return doc
Exemplo n.º 4
0
def looping():
    while True:
        time.sleep(5)
        ser = serial.Serial("/dev/ttyACM0", 9600)
        ser.baudrate = 9600
        temp1 = ser.readline()
        # temp1 = 20
        ser = serial.Serial("/dev/ttyACM1", 9600)
        ser.baudrate = 9600
        temp2 = ser.readline()
        # temp2 = 20
        print temp1, temp2
        if int(temp1[0:2]) < 35:
            # if temp1 < 35:

            l1['color'] = "#2ecc71"
            l1['Safe'] = "true"
        else:
            l1['color'] = "#c0392b"
            l1['Safe'] = "false"
        # if temp2 < 35:
        if int(temp2[0:2]) < 35:
            l2['color'] = "#2ecc71"
            l2['Safe'] = "true"
        else:
            l2['color'] = "#c0392b"
            l2['Safe'] = "false"
        serviceUsername = "******"
        servicePassword = "******"
        serviceURL = "https://*****:*****@ac99bfe8-c64e-48a5-9f62-e3b7c44ba586-bluemix.cloudant.com"
        client = Cloudant(serviceUsername, servicePassword, url=serviceURL)
        client.connect()
        databaseName = "sensordbs"
        try:
            client.delete_database(databaseName)
        except CloudantException:
            print "There was a problem deleting '{0}'.\n".format(databaseName)
        else:
            print "'{0}' successfully deleted.\n".format(databaseName)
        myDatabaseDemo = client.create_database(databaseName)
        if myDatabaseDemo.exists():
            print "'{0}' successfully created.\n".format(databaseName)
        newDocument = myDatabaseDemo.create_document(l1)
        newDocument = myDatabaseDemo.create_document(l2)

        # Check that the document exists in the database.
        if newDocument.exists():
            print "Document"
Exemplo n.º 5
0
class DBCloudant:
    def __init__(self):
        self.client = ""
        self.session = ""
        self.dataBase = ""
        self.document = ""
        self.query = ""

    def connect(self):
        self.client = Cloudant(conf.username,
                               conf.password,
                               url=conf.url,
                               connect=True)
        self.session = self.client.session()
        if self.session['userCtx']['name']:
            print("Coneccion realizada correctamente")
        else:
            print("Error al conectar con la BD")

    def disconnect(self):
        self.client.disconnect()

    def createDB(self, name):
        try:
            self.dataBase = self.client.create_database(name)
            if self.dataBase.exists():
                print("DB creada correctamente")
        except Exception as error:
            print("DB ya existente")

    def getDataBases(self):
        return self.client.all_dbs()

    def deleteDataBase(self, name):
        return self.client.delete_database(name)

    def openDB(self, name):
        self.dataBase = self.client[name]

    def createDocument(self, data):
        self.document = self.dataBase.create_document(data)
        if self.document.exists():
            print("Se creo el documento correctamente")

    def getDocument(self, name):
        self.document = self.dataBase[name]
        return self.document

    def getAllDocuments(self, name):
        return self.dataBase

    def getDocumentBySensor(self, sensor):
        self.query = cl.query.Query(self.dataBase)
        with self.query.custom_result(selector={"sensor": sensor}) as rst:
            return rst
Exemplo n.º 6
0
def add_signal(status, load):
    client = Cloudant(
        "39a4348e-3ce1-40cd-b016-1f85569d409e-bluemix",
        "48e26645f504209f85b4c44d74a4cb14bc0d059a22b361534b78f406a513f8ff",
        url=
        "https://*****:*****@39a4348e-3ce1-40cd-b016-1f85569d409e-bluemix.cloudant.com"
    )
    client.connect()

    databaseName = load
    myDatabase = client.create_database(databaseName)
    client.delete_database(databaseName)

    # if myDatabase.exists():
    #     print("'{0}' successfully created.\n".format(databaseName))
    #     client.delete_database(databaseName)
    myDatabase = client.create_database(databaseName)

    sampleData = [[status, "kitchen"]]

    # Create documents using the sample data.
    # Go through each row in the array
    for document in sampleData:
        # Retrieve the fields in each row.
        number = document[0]
        name = document[1]

        # Create a JSON document that represents
        # all the data in the row.
        jsonDocument = {"status": number, "circuit": name}

        # Create a document using the Database API.
        newDocument = myDatabase.create_document(jsonDocument)

        # Check that the document exists in the database.
        if newDocument.exists():
            print("Document '{0}' successfully created.".format(number))
        client.disconnect()
Exemplo n.º 7
0
    traceback.print_exc()

json.dumps(cred)

# クラウダントへの接続
client = Cloudant(cred['services'][label][i]['credentials']['username'], 
                  cred['services'][label][i]['credentials']['password'], 
                  url=cred['services'][label][i]['credentials']['url'])
client.connect()

# DBが存在していたら削除
print "既存データベース ", database_name ," の削除"
try:
    db = client[database_name]
    if db.exists():
        client.delete_database(database_name)
except:
    pass


# DBを新規作成
print "新規データベース ", database_name ," の作成"
try: 
    db = client.create_database(database_name)
    print "データベース作成成功"
except:
    print "データベース作成失敗"
    sys.exit()


Exemplo n.º 8
0
cred = json.load(f)
f.close()

print "クラウダントへの接続"
client = Cloudant(
    cred['services']['cloudantNoSQLDB'][0]['credentials']['username'],
    cred['services']['cloudantNoSQLDB'][0]['credentials']['password'],
    url=cred['services']['cloudantNoSQLDB'][0]['credentials']['url'])
client.connect()

# DBが存在していたら削除
print "既存データベース ", output_db, " の作成"
try:
    db = client[output_db]
    if db.exists():
        client.delete_database(output_db)
except:
    pass

# DBを新規作成
print "新規データベース ", output_db, " の作成"
try:
    db = client.create_database(output_db)
    print "データベース作成成功"
except:
    print "データベース作成失敗"
    sys.exit()

# 文字コード変換など前処理結果を中間ファイルへ出力
fin = codecs.open(input_file, "r", "shift_jis")
fout = codecs.open(output_file, "w", "utf-8")
Exemplo n.º 9
0
        "descriptionField": description,
        "temperatureField": temperature
    }

    # Create a document using the Database API.
    newDocument = myDatabase.create_document(jsonDocument)

    # Check that the document exists in the database.
    if newDocument.exists():
        print("Document '{0}' successfully created.".format(number))

result_collection = Result(myDatabase.all_docs)

print("Retrieved minimal document:\n{0}\n".format(result_collection[0]))

result_collection = Result(myDatabase.all_docs, include_docs=True)
print("Retrieved full document:\n{0}\n".format(result_collection[0]))

end_point = '{0}/{1}'.format("<url>", databaseName + "/_all_docs")
params = {'include_docs': 'true'}
response = client.r_session.get(end_point, params=params)
print("{0}\n".format(response.json()))

try:
    client.delete_database(databaseName)
except CloudantException:
    print("There was a problem deleting '{0}'.\n".format(databaseName))
else:
    print("'{0}' successfully deleted.\n".format(databaseName))

client.disconnect()
Exemplo n.º 10
0
class UnitTestDbBase(unittest.TestCase):
    """
    The base class for all unit tests targeting a database
    """

    @classmethod
    def setUpClass(cls):
        """
        If targeting CouchDB, Set up a CouchDB instance otherwise do nothing.
        """
        if os.environ.get('RUN_CLOUDANT_TESTS') is None:
            if os.environ.get('DB_URL') is None:
                os.environ['DB_URL'] = 'http://127.0.0.1:5984'

            if (os.environ.get('ADMIN_PARTY') and
                os.environ.get('ADMIN_PARTY') == 'true'):
                if os.environ.get('DB_USER'):
                    del os.environ['DB_USER']
                if os.environ.get('DB_PASSWORD'):
                    del os.environ['DB_PASSWORD']
                return

            if os.environ.get('DB_USER') is None:
                # Get couchdb docker node name
                if os.environ.get('COUCHDB_VERSION') == '2.1.1':
                    os.environ['NODENAME'] = requests.get(
                        '{0}/_membership'.format(os.environ['DB_URL'])).json()['all_nodes'][0]
                os.environ['DB_USER_CREATED'] = '1'
                os.environ['DB_USER'] = '******'.format(
                    unicode_(uuid.uuid4())
                    )
                os.environ['DB_PASSWORD'] = '******'
                if os.environ.get('COUCHDB_VERSION') == '2.1.1':
                    resp = requests.put(
                        '{0}/_node/{1}/_config/admins/{2}'.format(
                            os.environ['DB_URL'],
                            os.environ['NODENAME'],
                            os.environ['DB_USER']
                            ),
                        data='"{0}"'.format(os.environ['DB_PASSWORD'])
                        )
                else:
                    resp = requests.put(
                        '{0}/_config/admins/{1}'.format(
                            os.environ['DB_URL'],
                            os.environ['DB_USER']
                        ),
                        data='"{0}"'.format(os.environ['DB_PASSWORD'])
                    )
                resp.raise_for_status()

    @classmethod
    def tearDownClass(cls):
        """
        If necessary, clean up CouchDB instance once all tests are complete.
        """
        if (os.environ.get('RUN_CLOUDANT_TESTS') is None and
            os.environ.get('DB_USER_CREATED') is not None):
            if os.environ.get('COUCHDB_VERSION') == '2.1.1':
                resp = requests.delete(
                    '{0}://{1}:{2}@{3}/_node/{4}/_config/admins/{5}'.format(
                        os.environ['DB_URL'].split('://', 1)[0],
                        os.environ['DB_USER'],
                        os.environ['DB_PASSWORD'],
                        os.environ['DB_URL'].split('://', 1)[1],
                        os.environ['NODENAME'],
                        os.environ['DB_USER']
                        )
                    )
            else:
                resp = requests.delete(
                    '{0}://{1}:{2}@{3}/_config/admins/{4}'.format(
                        os.environ['DB_URL'].split('://', 1)[0],
                        os.environ['DB_USER'],
                        os.environ['DB_PASSWORD'],
                        os.environ['DB_URL'].split('://', 1)[1],
                        os.environ['DB_USER']
                    )
                )
            del os.environ['DB_USER_CREATED']
            del os.environ['DB_USER']
            resp.raise_for_status()

    def setUp(self):
        """
        Set up test attributes for unit tests targeting a database
        """
        self.set_up_client()

    def set_up_client(self, auto_connect=False, auto_renew=False, encoder=None,
                      timeout=(30,300)):
        self.user = os.environ.get('DB_USER', None)
        self.pwd = os.environ.get('DB_PASSWORD', None)
        self.use_cookie_auth = True
        self.iam_api_key = os.environ.get('IAM_API_KEY', None)

        if os.environ.get('RUN_CLOUDANT_TESTS') is None:
            self.url = os.environ['DB_URL']

            admin_party = False
            if os.environ.get('ADMIN_PARTY') == 'true':
                admin_party = True

            self.use_cookie_auth = False
            # construct Cloudant client (using admin party mode)
            self.client = CouchDB(
                self.user,
                self.pwd,
                admin_party,
                url=self.url,
                connect=auto_connect,
                auto_renew=auto_renew,
                encoder=encoder,
                timeout=timeout
            )
        else:
            self.account = os.environ.get('CLOUDANT_ACCOUNT')
            self.url = os.environ.get(
                'DB_URL',
                'https://{0}.cloudant.com'.format(self.account))

            if os.environ.get('RUN_BASIC_AUTH_TESTS'):
                self.use_cookie_auth = False
                # construct Cloudant client (using basic access authentication)
                self.client = Cloudant(
                    self.user,
                    self.pwd,
                    url=self.url,
                    x_cloudant_user=self.account,
                    connect=auto_connect,
                    auto_renew=auto_renew,
                    encoder=encoder,
                    timeout=timeout,
                    use_basic_auth=True,
                )
            elif self.iam_api_key:
                self.use_cookie_auth = False
                # construct Cloudant client (using IAM authentication)
                self.client = Cloudant(
                    None,  # username is not required
                    self.iam_api_key,
                    url=self.url,
                    x_cloudant_user=self.account,
                    connect=auto_connect,
                    auto_renew=auto_renew,
                    encoder=encoder,
                    timeout=timeout,
                    use_iam=True,
                )
            else:
                # construct Cloudant client (using cookie authentication)
                self.client = Cloudant(
                    self.user,
                    self.pwd,
                    url=self.url,
                    x_cloudant_user=self.account,
                    connect=auto_connect,
                    auto_renew=auto_renew,
                    encoder=encoder,
                    timeout=timeout
                )

    def tearDown(self):
        """
        Ensure the client is new for each test
        """
        del self.client

    def db_set_up(self):
        """
        Set up test attributes for Database tests
        """
        self.client.connect()
        self.test_dbname = self.dbname()
        self.db = self.client._DATABASE_CLASS(self.client, self.test_dbname)
        self.db.create()

    def db_tear_down(self):
        """
        Reset test attributes for each test
        """
        self.db.delete()
        self.client.disconnect()
        del self.test_dbname
        del self.db

    def dbname(self, database_name='db'):
        return '{0}-{1}-{2}'.format(database_name, self._testMethodName, unicode_(uuid.uuid4()))

    def populate_db_with_documents(self, doc_count=100, **kwargs):
        off_set = kwargs.get('off_set', 0)
        docs = [
            {'_id': 'julia{0:03d}'.format(i), 'name': 'julia', 'age': i}
            for i in range(off_set, off_set + doc_count)
        ]
        return self.db.bulk_docs(docs)

    def create_views(self):
        """
        Create a design document with views for use with tests.
        """
        self.ddoc = DesignDocument(self.db, 'ddoc001')
        self.ddoc.add_view(
            'view001',
            'function (doc) {\n emit(doc._id, 1);\n}'
        )
        self.ddoc.add_view(
            'view002',
            'function (doc) {\n emit(doc._id, 1);\n}',
            '_count'
        )
        self.ddoc.add_view(
            'view003',
            'function (doc) {\n emit(Math.floor(doc.age / 2), 1);\n}'
        )
        self.ddoc.add_view(
            'view004',
            'function (doc) {\n emit(Math.floor(doc.age / 2), 1);\n}',
            '_count'
        )
        self.ddoc.add_view(
            'view005',
            'function (doc) {\n emit([doc.name, doc.age], 1);\n}'
        )
        self.ddoc.add_view(
            'view006',
            'function (doc) {\n emit([doc.name, doc.age], 1);\n}',
            '_count'
        )
        self.ddoc.add_view(
            'view007',
            'function (doc) {\n emit(1, doc.name);\n}'
        )
        self.ddoc.save()
        self.view001 = self.ddoc.get_view('view001')
        self.view002 = self.ddoc.get_view('view002')
        self.view003 = self.ddoc.get_view('view003')
        self.view004 = self.ddoc.get_view('view004')
        self.view005 = self.ddoc.get_view('view005')
        self.view006 = self.ddoc.get_view('view006')
        self.view007 = self.ddoc.get_view('view007')

    def create_search_index(self):
        """
        Create a design document with search indexes for use
        with search query tests.
        """
        self.search_ddoc = DesignDocument(self.db, 'searchddoc001')
        self.search_ddoc['indexes'] = {'searchindex001': {
                'index': 'function (doc) {\n  index("default", doc._id); \n '
                'if (doc.name) {\n index("name", doc.name, {"store": true}); \n} '
                'if (doc.age) {\n index("age", doc.age, {"facet": true}); \n} \n} '
            }
        }
        self.search_ddoc.save()

    def load_security_document_data(self):
        """
        Create a security document in the specified database and assign
        attributes to be used during unit tests
        """
        self.sdoc = {
            'admins': {'names': ['foo'], 'roles': ['admins']},
            'members': {'names': ['foo1', 'foo2'], 'roles': ['developers']}
        }
        self.mod_sdoc = {
            'admins': {'names': ['bar'], 'roles': ['admins']},
            'members': {'names': ['bar1', 'bar2'], 'roles': ['developers']}
        }
        if os.environ.get('RUN_CLOUDANT_TESTS') is not None:
            self.sdoc = {
                'cloudant': {
                    'foo1': ['_reader', '_writer'],
                    'foo2': ['_reader']
                }
            }
            self.mod_sdoc = {
                'cloudant': {
                    'bar1': ['_reader', '_writer'],
                    'bar2': ['_reader']
                }
            }
        resp = self.client.r_session.put(
            '/'.join([self.db.database_url, '_security']),
            data=json.dumps(self.sdoc),
            headers={'Content-Type': 'application/json'}
        )
        self.assertEqual(resp.status_code, 200)

    def create_db_updates(self):
        """
        Create '_global_changes' system database required for testing against _db_updates
        """
        self.DB_UPDATES = '_global_changes'
        try:
            self.client.create_database(self.DB_UPDATES, throw_on_exists=True)
        except CloudantClientException:
            self.delete_db_updates()
            self.create_db_updates()

    def delete_db_updates(self):
        """
        Delete '_global_changes' system database used for _db_updates testing
        """
        try:
            self.client.delete_database(self.DB_UPDATES)
        except CloudantClientException:
            pass

    def is_couchdb_1x_version(self):
        if os.environ.get('COUCHDB_VERSION') and os.environ.get('COUCHDB_VERSION').startswith('1'):
            return True
        else:
            # Get version from server info
            couchdb_info = json.loads(self.client.r_session.get(self.client.server_url).text)
            if couchdb_info and couchdb_info['version'].startswith('1'):
                return True
            else:
                return False
Exemplo n.º 11
0
if my_document.exists():
    print('SUCCESS!!')

# In[38]:

my_document = my_database['12345']

# Update the document content
# This can be done as you would any other dictionary
my_document['name'] = "G D Abhishek"
my_document['age'] = 23

# You must save the document in order to update it on the database
my_document.save()

# In[39]:

my_document = my_database['12345']

# Display the document
print(my_document)

# In[40]:

# Delete a database using an initialized client
client.delete_database('my_database')

# In[41]:

1 + 2
Exemplo n.º 12
0
# データベース名の取得
f = open('database_name.json', 'r')
dbn = json.load(f)
f.close()
print dbn['name']

client = Cloudant(cred['credentials']['username'], 
                  cred['credentials']['password'], 
                  url=cred['credentials']['url'])

# Connect to the server
client.connect()

# DB選択
db = client[dbn['name']]

# Create a database using an initialized client
# The result is a new CloudantDatabase or CouchDatabase based on the client
client.delete_database(dbn['name'])


# You can check that the database exists
if db.exists():
    print 'FAILED(^_^;;'        
else:
    print 'SUCCESS!!'        

# Disconnect from the server
client.disconnect()
Exemplo n.º 13
0
def getURLs(userIn):

    #replaced by server #userIn = input('Enter Search Parameter:')

    f = open('/Users/[email protected]/Desktop/output.txt', 'w')

    #From Lynda
    n = 0
    url = 'https://www.lynda.com/search?q=' + userIn
    req = urllib2.Request(url, headers={'User-Agent': "Magic Browser"})
    url = urllib2.urlopen(req).read()
    soup = BeautifulSoup(url, "html.parser")
    for line in soup.find_all('a'):
        if line.get('href').startswith('https://www.lynda.com/'):
            if n > 0:
                f.write(line.get('href'))
                f.write('\n')
            n = n + 1
            #print(line.get('href'))

    p = 0
    url = 'https://www.ted.com/search?q=' + userIn
    req = urllib2.Request(url, headers={'User-Agent': "Magic Browser"})
    url = urllib2.urlopen(req).read()
    soup = BeautifulSoup(url, "html.parser")
    for line in soup.find_all('a'):
        if line.get('href').startswith('/read/') or line.get(
                'href').startswith('/talks/') or line.get('href').startswith(
                    '/read/'):
            if p > 0:
                f.write('https://www.ted.com' + line.get('href'))
                f.write('\n')
            p = p + 1
            #print(line.get('href'))

    url = 'https://www.coursera.org/courses?languages=en&query=' + userIn + "&userQuery=" + userIn
    req = urllib2.Request(url, headers={'User-Agent': "Magic Browser"})
    url = urllib2.urlopen(req).read()
    soup = BeautifulSoup(url, "html.parser")
    for line in soup.find_all('a'):
        if line.get('href').startswith('/learn/'):
            #if p > 0:
            f.write('https://www.coursera.org' + line.get('href'))
            f.write('\n')
            #print(line.get('href'))
            #p = p + 1
            #print(line.get('href'))
    f.close()

    ##DB STUFF

    from cloudant.client import Cloudant
    from cloudant.error import CloudantException
    from cloudant.result import Result, ResultByKey

    client = Cloudant(
        "ae11f357-074c-42ec-88c0-d46fd1dbc8c8-bluemix",
        "1d9351f791650b12e456f49ed45005b03944e40e4be6066057450e616cb8382c",
        url=
        "https://*****:*****@ae11f357-074c-42ec-88c0-d46fd1dbc8c8-bluemix.cloudant.com"
    )
    client.connect()

    databaseName = "urls"

    try:
        client.delete_database(databaseName)
    except CloudantException:
        print "There was a problem deleting '{0}'.\n".format(databaseName)
    else:
        print "'{0}' successfully deleted.\n".format(databaseName)

    databaseName = "urls"

    myDatabase = client.create_database(databaseName)

    if myDatabase.exists():
        print "'{0}' successfully created.\n".format(databaseName)

    #Read file and put into sample data
    with open("/Users/[email protected]/Desktop/output.txt", "r") as ins:
        sampleData = []
        for line in ins:
            sampleData.append(line)

    #sampleData = [
    #    [1, "one", "boiling", 100],
    #    [2, "two", "hot", 40],
    #    [3, "three", "warm", 20],
    #    [4, "four", "cold", 10],
    #    [5, "five", "freezing", 0]
    #]

    # Create documents using the sample data.
    # Go through each row in the array
    for document in sampleData:
        # Retrieve the fields in each row.
        url = document

        # Create a JSON document that represents
        # all the data in the row.
        jsonDocument = {
            "url": url,
            #"name" : website,
        }

        # Create a document using the Database API.
        newDocument = myDatabase.create_document(jsonDocument)

        # Check that the document exists in the database.
        if newDocument.exists():
            print "Document '{0}' successfully created.".format(url)

    f = open('/Users/[email protected]/Desktop/output.json', 'w')

    result_collection = Result(myDatabase.all_docs, include_docs=True)

    # "Retrieved full document:\n{0}\n".format(result_collection[0])

    f.write("[")

    for result in result_collection:
        f.write('"' + str(result) + '"')
        f.write(",\n")
    f.write('""')
    f.write("]")

    #end_point = '{0}/{1}'.format("<url>", databaseName + "/_all_docs")
    #params = {'include_docs': 'true'}
    #response = client.r_session.get(end_point, params=params)
    #print "{0}\n".format(response.json())

    f.close()
    f = open('/Users/[email protected]/Desktop/output.json', 'r')
    jsonURLs = f.read()
    f.close()

    try:
        client.delete_database(databaseName)
    except CloudantException:
        print "There was a problem deleting '{0}'.\n".format(databaseName)
    else:
        print "'{0}' successfully deleted.\n".format(databaseName)

    client.disconnect()

    return jsonURLs
f.close()

print "クラウダントへの接続"
dbname = cnf['database']
print dbname
client = Cloudant(cred['credentials']['username'], 
                  cred['credentials']['password'], 
                  url=cred['credentials']['url'])
client.connect()

# DBが存在していたら削除
print "既存データベースの削除"
try:
    db = client[dbname]
    if db.exists():
        client.delete_database(dbname)
except:
    print "新規データベースの作成"

# DBを新規作成
db = client.create_database(dbname)

# 失敗したら終了
if db.exists():
    print 'SUCCESS!!  Database creation on cloudant'
else:
    sys.exit()


# エクセルシートからのCSVデータを読んで
# NLCトレーニングデータを作成する