import json import time import cql from cassandra.cluster import Cluster from cassandra.auth import PlainTextAuthProvider from uuid import uuid4 import os from kafka import KafkaProducer import requests GCP_PROJECT_ID = 'bigdata220-final-project' TOPIC = "meetup_rsvp" SUBSCRIPTION = "out_meetup_rsvp" CASS_PASS = os.environ['CASS_PASS'] auth_provider = PlainTextAuthProvider(username='******', password=CASS_PASS) cluster = Cluster(['10.138.0.2'], auth_provider=auth_provider) KAFKA_TOPIC = "rsvps2" kafka_producer = KafkaProducer(bootstrap_servers='10.128.0.8:9092') def join_with_category(message): message = json.loads(message) try: group_urlname = message['group']['group_urlname'] except Exception as e: print(e) print("Joining on %s" % group_urlname) response = requests.get("https://api.meetup.com/{group_urlname}".format(
from cassandra.cluster import Cluster from cassandra.auth import PlainTextAuthProvider import csv import os import sys import pandas as pd os_path = os.path sys_exit = sys.exit if __name__ == '__main__': auth_provider = PlainTextAuthProvider( username='******', password='******') cluster = Cluster(auth_provider=auth_provider) session = cluster.connect('reviews') file_path = input('Input path to .tsv file: ') if not os_path.isfile(file_path) or not file_path.endswith('.tsv'): print('You must input path to .tsv file for filling db.') sys_exit() skipped_rows = 0 # preparing and executing my INSERT statement strCQL_1 = "INSERT INTO reviews.reviews_by_product_id (product_id, review_id)" \ " VALUES (?,?);" pStatement_1 = session.prepare(strCQL_1) strCQL_2 = "INSERT INTO reviews.reviews_by_star_rating_and_product_id (product_id, star_rating, review_id)" \
from cassandra.auth import PlainTextAuthProvider from cassandra.cluster import Cluster from cassandra.query import BatchStatement cluster = Cluster(auth_provider=PlainTextAuthProvider(username='******', password='******')) connection = cluster.connect('test') batch_list = [ ''' UPDATE user SET data = { phone: 'test', email: 'test' }, repo_count = 3 WHERE user_id = 1 IF EXISTS; ''', ''' UPDATE repo SET related_link = 'asfsaf1' WHERE repo_id = 1 AND user_id = 1 IF EXISTS; ''' ] def execute_batch(statement_list): batch = BatchStatement() for q in statement_list: batch.add(q) connection.execute(batch)
def createSession(): cloud_config = {'secure_connect_bundle': './secure-connect-uottahack.zip'} auth_provider = PlainTextAuthProvider('uottahack', 'c975SKEuyvXW!pU') cluster = Cluster(cloud=cloud_config, auth_provider=auth_provider) session = cluster.connect('uottahack') return session
#for row in rows: #process_row(row) if self.future.has_more_pages: self.future.start_fetching_next_page() else: self.finished_event.set() def handle_error(self, exc): self.error = exc self.finished_event.set() def process_row(user_row): print user_row.channel, user_row.timestamp, user_row.value channel = sys.argv[1] auth_provider = PlainTextAuthProvider( username='******', password='******') cluster = Cluster(['10.150.1.69'],auth_provider=auth_provider) session = cluster.connect() start = time.time() query = "SELECT * FROM production.data where channel='{}'".format(channel) statement = SimpleStatement(query, fetch_size=10000) future = session.execute_async(statement) handler = PagedResultHandler(future) handler.finished_event.wait() if handler.error: raise handler.error end = time.time() print ( end - start)
def main(): logging.basicConfig(stream=sys.stdout, level=logging.INFO) FORMAT = '%(asctime) %(message)s' logging.basicConfig(format=FORMAT) ca_file_uri = "./cacert.pem" #Check if the blob storage access credentials have been loaded as a secret volume use them if os.path.exists('/tmp/secrets/db/db-account'): db_account_name = open('/tmp/secrets/db/db-account').read() db_account_key = open('/tmp/secrets/db/db-key').read() eh_url = open().read() eh_offset_url = open().read() eh_account = open().read() eh = open().read() #Otherwise assume it is being run locally and load from environment variables else: db_account = os.environ['COSMOS_DB_ACCOUNT'] db_key = os.environ['COSMOS_DB_KEY'] eh_url = os.environ['EVENT_HUB_URL'] eh_offset_url = os.environ['EVENT_HUB_OFFSET_URL'] eh_account = os.environ['EVENT_HUB_ACCOUNT'] eh_key = os.environ['EVENT_HUB_KEY'] #If the test container is not loaded as an environment variable, assume a local run #and use the configuration information in the deployment config if 'DB_PERSONA_EDGE_TABLE' in os.environ: db_config = None else: merged_config = yaml.safe_load_all(open("../cluster-deployment.yml")) for config in merged_config: if config['metadata']['name'] == 'azmlsi-db-config': db_config = config['data'] #If no db config file is passed, look for the container environment variables if db_config is None: keyspace = os.environ['DB_KEYSPACE'] #Otherwise load db config else: keyspace = db_config['db-keyspace'] #Connect to the database ssl_opts = { 'ca_certs': ca_file_uri, 'ssl_version': PROTOCOL_TLSv1_2, 'cert_reqs': CERT_REQUIRED # Certificates are required and validated } auth_provider = PlainTextAuthProvider(username=db_account, password=db_key) endpoint_uri = db_account + '.cassandra.cosmosdb.azure.com' cluster = Cluster([endpoint_uri], port=10350, auth_provider=auth_provider, ssl_options=ssl_opts) session = cluster.connect(keyspace) #Workspace.get("azmlsiws", subscription_id="0b753943-9062-4ec0-9739-db8fb455aeba", resource_group="CommercialCyberAzure") if isNewLabeledData(eh_url, eh_offset_url, eh_account, eh_key): model = retrainClassifier(session, db_config) repredictImages(session, model, db_config)
def PrintTable(rows): t = PrettyTable(['UserID', 'Name', 'City']) for r in rows: t.add_row([r.user_id, r.user_name, r.user_bcity]) print t ssl_opts = { 'ca_certs': DEFAULT_CA_BUNDLE_PATH, 'ssl_version': PROTOCOL_TLSv1_2, } if 'certpath' in cfg.config: ssl_opts['ca_certs'] = cfg.config['certpath'] auth_provider = PlainTextAuthProvider(username=cfg.config['username'], password=cfg.config['password']) cluster = Cluster([cfg.config['contactPoint']], port=cfg.config['port'], auth_provider=auth_provider, ssl_options=ssl_opts) session = cluster.connect() print "\nCreating Keyspace" session.execute( 'CREATE KEYSPACE IF NOT EXISTS uprofile WITH replication = {\'class\': \'NetworkTopologyStrategy\', \'datacenter\' : \'1\' }' ) print "\nCreating Table" session.execute( 'CREATE TABLE IF NOT EXISTS uprofile.user (user_id int PRIMARY KEY, user_name text, user_bcity text)' )
## Simple example for studying big data platforms from cassandra import ConsistencyLevel from cassandra.cluster import Cluster from cassandra.query import SimpleStatement from cassandra.auth import PlainTextAuthProvider from time import time import argparse parser = argparse.ArgumentParser() parser.add_argument('--hosts', help='cassandra host "host1,host2,host3"') parser.add_argument('--u',help='user name') parser.add_argument('--p',help='password') parser.add_argument('--q',help='input query') args = parser.parse_args() hosts=args.hosts.split(',') auth_provider = PlainTextAuthProvider( username=args.u, password=args.p) if __name__ == "__main__": #you can add some fake ips into cluster: '10.166.0.14','192.168.1.1' cluster = Cluster(hosts,port=9042,auth_provider=auth_provider) session = cluster.connect() ## Change the consistency level to see input= args.q #copy a line of the bird song in csv file here start=time() ## enable only 1 option consistency_level =ConsistencyLevel.ONE #consistency_level =ConsistencyLevel.QUORUM #consistency_level =ConsistencyLevel.ALL query = SimpleStatement(input, consistency_level=consistency_level)
from cassandra.cluster import Cluster from cassandra.auth import PlainTextAuthProvider cloud_config= { 'secure_connect_bundle': '<<secure-connect-Exercisewithfriends.zip' } auth_provider = PlainTextAuthProvider('<username>', '<password>') cluster = Cluster(cloud=cloud_config, auth_provider=auth_provider) session = cluster.connect() row = session.execute("select release_version from system.local").one() if row: print(row[0]) else: print("An error occurred.")
writer.writerow(data) def load_geo_data(session, geopath): geo_prepared = session.prepare(GEO_INSERT_STATEMENT) with open(geopath, 'rb') as f: reader = csv.reader(f) for row in reader: geo_bound = geo_prepared.bind(map(uuid.UUID, row[0:2]) + row[2:]) session.execute(geo_bound) if __name__ == '__main__': meta_path = 'metadata.json' geo_path = 'geodata.csv' auth_provider = PlainTextAuthProvider(username='******', password='******') cluster = Cluster(['dc0vm0', 'dc0vm1', 'dc0vm2'], auth_provider=auth_provider) session = cluster.connect() session.execute(META_CF_DROP_STATEMENT) session.execute(RANK_CF_DROP_STATEMENT) session.execute(GEO_CF_DROP_STATEMENT) session.execute(KS_CREATION_STATEMENT) session.execute(GEO_CF_CREATION_STATEMENT) session.execute(META_CF_CREATION_STATEMENT) session.execute(RANK_CF_CREATION_STATEMENT) meta_prepared = session.prepare(META_INSERT_STATEMENT) rank_prepared = session.prepare(RANK_INSERT_STATEMENT) print('Loading into Keyspace', sys.argv[1]) print('loading geo')
def createsession(self): ap = PlainTextAuthProvider(username='******', password='******') self.cluster = Cluster(['127.0.0.1'], port=9042, auth_provider=ap) self.session = self.cluster.connect(self.keyspace) return self.session
import uuid import json from ssl import SSLContext, PROTOCOL_TLSv1, CERT_REQUIRED from cassandra.auth import PlainTextAuthProvider from cassandra.cluster import Cluster, ExecutionProfile, EXEC_PROFILE_DEFAULT, ConsistencyLevel CASSANDRA_CREDS = os.environ['CASSANDRA_CREDS'] AWS_DEFAULT_REGION = os.environ['AWS_DEFAULT_REGION'] secret_client = boto3.client('secretsmanager') secret_response = secret_client.get_secret_value(SecretId=CASSANDRA_CREDS) secret = json.loads(secret_response.get('SecretString')) cassandra_user = secret['ServiceSpecificCredential']['ServiceUserName'] cassandra_password = secret['ServiceSpecificCredential']['ServicePassword'] auth_provider = PlainTextAuthProvider(username=cassandra_user, password=cassandra_password) ssl_context = SSLContext(PROTOCOL_TLSv1) ssl_context.load_verify_locations('AmazonRootCA1.pem') ssl_context.verify_mode = CERT_REQUIRED cluster = Cluster(['cassandra.{}.amazonaws.com'.format(AWS_DEFAULT_REGION)], port=9142, ssl_context=ssl_context, auth_provider=auth_provider) session = cluster.connect() def handler(event, context): response = {'statusCode': 405} if event['httpMethod'] in ['PUT', 'POST']: do_upsert(json.loads(event['body']))
import dash import psycopg2 from cassandra.cluster import Cluster from cassandra.auth import PlainTextAuthProvider import datetime app = dash.Dash(__name__) server = app.server app.title = 'SmartSquare MotionPathDashboard' app.config.suppress_callback_exceptions = True # API keys and datasets app.mapbox_access_token = 'pk.eyJ1Ijoic25vb3B0aGVub29iIiwiYSI6ImNqdm1qdTd2cDFkdWg0YXJ1YXZwNTFtdmcifQ.7ABtAp_1NyyHFFBbfAeIwQ' app.connection = psycopg2.connect(database="gisdb", user="******", host="localhost", port="5432", password="******") app.connection.set_session(autocommit=True) app.cursor = app.connection.cursor() auth_provider = PlainTextAuthProvider( username='******', password='') app.cluster = Cluster([''], auth_provider=auth_provider) app.session = app.cluster.connect('master_dataset') # Boostrap CSS. app.css.append_css({'external_url': 'https://codepen.io/amyoshino/pen/jzXypZ.css'}) app.last_update_time = datetime.datetime.now()
#!/usr/bin/env python3 from cassandra import ConsistencyLevel from cassandra.cluster import Cluster from cassandra.query import BatchType, SimpleStatement from ssl import SSLContext, PROTOCOL_TLSv1, CERT_REQUIRED from cassandra.auth import PlainTextAuthProvider import sys, os ssl_context = SSLContext(PROTOCOL_TLSv1) ssl_context.load_verify_locations('./AmazonRootCA1.pem') ssl_context.verify_mode = CERT_REQUIRED auth_provider = PlainTextAuthProvider(username=os.getenv('USER'), password=os.getenv('PASS')) cluster = Cluster(['cassandra.us-west-2.amazonaws.com'], ssl_context=ssl_context, auth_provider=auth_provider, port=9142) session = cluster.connect('user') pstmt = session.prepare("INSERT INTO password (shaone,count) VALUES (?,?)") pstmt.consistency_level = ConsistencyLevel.LOCAL_QUORUM f = open(sys.argv[1],'r') line = f.readline() while line: (shaone,count) = line.split(':') session.execute(pstmt, (shaone, int(count))) line = f.readline() f.close()
#!/usr/bin/env python3 from cassandra.cluster import Cluster from cassandra.auth import PlainTextAuthProvider auth_provider = PlainTextAuthProvider(username='******', password='******') cluster = Cluster(['YOURADDRESS'], auth_provider=auth_provider) session = cluster.connect() session.exicute( CREATE KEYSPACE test WITH REPLICATION = { 'class' : 'NetworkTopologyStrategy', 'dc1' : 3 }) session.exicute( CREATE TABLE test.users (username text, name text, age int, PRIMARY KEY(username));) session.exicute(INSERT INTO users(username,name,age) VALUES ('EricZ','Eric Zietlow',67);) cluster.shutdown()
# Make the request to the resources api # response = requests.get('https://scheduler.monroe-system.eu/v1/resources', cert=('/home/dimitris/monroe/certificate.pem', '/home/dimitris/monroe/privateKeyClear.pem')) response = requests.get('https://scheduler.monroe-system.eu/v1/resources', cert=(args.certificate, args.privateKey)) # In case of error print the error and exit if response.status_code != 200: # This means something went wrong. print('GET /v1/resources {}'.format(response.status_code)) print('Response Headers: {}'.format(response.headers)) sys.exit() # Make the connection to the database authProvider = PlainTextAuthProvider(username='******', password='******') cluster = Cluster(['127.0.0.1'], 9042, auth_provider=authProvider, connect_timeout=15) session = cluster.connect('monroe') # Start the combining algorithm at the immediately higher multiple of 5 step = args.interval initialTime = step * (args.startTimeStamp / step + 1) # Iterate over the nodes (each resource is a node) for resource in response.json(): # print('{} {}'.format(resource['id'], resource['project'])) # Skip nodes that do not belong to the selected product and nodes that are not in the deployed or testing state
from cassandra.auth import PlainTextAuthProvider from cassandra.cluster import Cluster from datetime import timedelta, datetime import config """ Find the travel time for station Foster NB for 5-minute intervals for Sept 22, 2011 """ ap = PlainTextAuthProvider(username=config.username, password=config.password) node_ips = config.hosts cluster = Cluster(node_ips, protocol_version=4, auth_provider=ap, port=config.port) session = cluster.connect('part_3_version_0') results = session.execute( """ SELECT detectorid, length FROM detectors_by_highway WHERE locationtext = %s """, ["Foster NB"]) length = results[0].length temp = '' for row in results: temp += str(row.detectorid) + ', ' idList = temp[0:-2] intervals = [] first = datetime(2011, 9, 22, tzinfo=None) increment = timedelta(minutes=5) last = datetime(2011, 9, 23, tzinfo=None)
#!/usr/bin/python import time import sys from cassandra.cluster import Cluster from cassandra.auth import PlainTextAuthProvider from cassandra.policies import DCAwareRoundRobinPolicy from cassandra import ConsistencyLevel from random import randint #Configuration contactpoints = ['172.31.14.14', '172.31.11.194'] auth_provider = PlainTextAuthProvider(username='******', password='******') keyspace = "poctest" localDC = "dc1" delay = 1 CL = ConsistencyLevel.LOCAL_QUORUM #CL = ConsistencyLevel.LOCAL_ONE print "Connecting to cluster" cluster = Cluster(contact_points=contactpoints, load_balancing_policy=DCAwareRoundRobinPolicy( local_dc=localDC, used_hosts_per_remote_dc=3), auth_provider=auth_provider) session = cluster.connect() session.default_consistency_level = CL session.execute(
def import_schema(schema, srv_options, options, restriction_type, restricts): if ISDEBUG: logger.log( u"import schema {0} requiested with options {1}; restriction type: {2}; restrictions: {3}" .format(schema, options, restriction_type, restricts)) if "hosts" not in srv_options: logger.log("The hosts parameter is needed, setting to localhost.", WARNING) hosts = srv_options.get("hosts", "localhost").split(",") if "port" not in srv_options: logger.log("The port parameter is needed, setting to 9042.", WARNING) port = srv_options.get("port", "9042") username = srv_options.get("username", None) password = srv_options.get("password", None) with_row_id = options.get('with_row_id', 'True') == 'True' names_mapping = options.get('mapping', '').split(';') mapping_dict = {} mapping_dict_backward = {} for s in names_mapping: kp = s.split('=') if len(kp) != 2: continue key = kp[0].strip() value = kp[1].strip() mapping_dict[key] = value mapping_dict_backward[value] = key cluster = Cluster(hosts) if (username is not None): cluster.auth_provider = PlainTextAuthProvider(username=username, password=password) # Cassandra connection init session = cluster.connect() keyspace = cluster.metadata.keyspaces[schema] cassandra_tables = [] tables = keyspace.tables views = keyspace.views if restriction_type is None: for t in tables: if t in tables: cassandra_tables.append(tables[t]) else: cassandra_tables.append(views[t]) elif restriction_type == 'limit': for r in restricts: t_name = r if t_name in mapping_dict_backward: t_name = mapping_dict_backward[t_name] if t_name in tables: cassandra_tables.append(tables[t_name]) else: cassandra_tables.append(views[t_name]) elif restriction_type == 'except': for t in tables: if t not in restricts: if t in tables: cassandra_tables.append(tables[t]) else: cassandra_tables.append(views[t]) pg_tables = [] for c_table in cassandra_tables: if ISDEBUG: logger.log("Importing table {0}...".format(c_table.name)) pg_table_name = c_table.name if pg_table_name in mapping_dict: if ISDEBUG: logger.log( "Cassandra table name '{0}' maps to PostgreSQL table name '{1}'" .format(pg_table_name, mapping_dict[pg_table_name])) pg_table_name = mapping_dict[pg_table_name] pg_table = TableDefinition(pg_table_name) pg_table.options['keyspace'] = schema pg_table.options['columnfamily'] = c_table.name for c_column_name in c_table.columns: cql_type = c_table.columns[c_column_name].cql_type pg_type = types_mapper.get_pg_type(cql_type) if ISDEBUG: logger.log( "Adding column {0} with PostgreSQL type {2} (CQL type {1})" .format(c_column_name, cql_type, pg_type)) pg_table.columns.append( ColumnDefinition(c_column_name, type_name=pg_type)) if with_row_id: pg_table.columns.append( ColumnDefinition('__rowid__', type_name='text')) pg_tables.append(pg_table) if ISDEBUG: logger.log("Table imported: {0}".format(c_table.name)) session.shutdown() return pg_tables
# Create flag strings flags = [] for env in ENVIRONMENTS: for req_cat in REQUEST_CATEGORIES: for id in SERVICE_TYPE_IDS: flags.append([env, req_cat, id, 0, random.randint(0, 2)]) flags.append([env, req_cat, id, 1, random.randint(0, 2)]) # Cassandra Connection cass_address = 'dev-cassandra.ksg.int' cass_port = 9042 cass_username = '******' cass_password = '******' cass_namespace = 'CassandraPractice' authentication = PlainTextAuthProvider(username=cass_username, password=cass_password) cluster = Cluster([cass_address], port=cass_port, auth_provider=authentication) session = cluster.connect(cass_namespace) cass_query_prefix = "INSERT INTO \"Flags\" (\"Environment\", \"Request Category\", \"Service Type ID\", \"WFE\", \"Value\") VALUES (" print(cass_query_prefix) # Insert flags to cassandra table for flag in flags: session.execute(cass_query_prefix + "'" + flag[0] + "'," + "'" + flag[1] + "'," + str(flag[2]) + ',' + str(flag[3]) + ',' + str(flag[4]) + ');') session.shutdown() flipt_url = 'http://flipt-demo.devops-sandbox.k1d.k8.cin.kore.korewireless.com/api/v1/flags'
from pprint import pprint import json import os import datetime import operator import sys import getopt import cassandra from cassandra.cluster import Cluster from cassandra.auth import PlainTextAuthProvider cloud_config = { 'secure_connect_bundle': 'secure-connect-teaminferno.zip' } auth_provider = PlainTextAuthProvider('PKulaMpxCDcyZsxHoLeorxdE', 'R1KL7l1u,awPgafa0-G3Xjt5QAjk,gTtz.qgmQSrsstUIdQnOoq_jgI,77nPA9upDOOYj2+ZefBMXudz+dFfF7IYPMGo56gz7xD337Nrcaufv3KKh,kzaS,0_xuCflNI') cluster = Cluster(cloud=cloud_config, auth_provider=auth_provider) cqlsession = cluster.connect('yvideos') def reverse(lst): return[ele for ele in reversed(lst)] def valueswap(str): if str == "00": return "12:00am" if str == "01": return "1:00am" if str == "02": return "2:00am"
def get_auth_provider(user, password): return PlainTextAuthProvider(username=user, password=password)
from cassandra.auth import PlainTextAuthProvider from cassandra.cluster import Cluster contact_points = ['92.53.78.60'] keyspace_name = 'ems' port = 9042 username = '******' password = '******' auth = PlainTextAuthProvider(username=username, password=password) cluster = Cluster(contact_points, auth_provider=auth, port=port) session = cluster.connect(keyspace_name) rows = session.execute( "DELETE FROM ems.data WHERE device_id=00000000-0000-0000-0000-000000000000 and data_source_id=2 IF EXISTS" ) for row in rows: print(row)
-------------------------- 連接遠程數據庫 # -*- encoding: utf-8 -*- from cassandra import ConsistencyLevel # 引入Cluster模塊 from cassandra.cluster import Cluster # 引入DCAwareRoundRobinPolicy模塊,可用來自定義驅動程序的行為 # from cassandra.policies import DCAwareRoundRobinPolicy from cassandra.auth import PlainTextAuthProvider from cassandra.query import SimpleStatement import pandas as pd # 配置Cassandra集群的IP contact_points = [‘1.1.1.1‘, ‘2.2.2.2‘, ‘3.3.3.3‘] # 配置登陸Cassandra集群的賬號和密碼 auth_provider = PlainTextAuthProvider(username=‘XXX‘, password=‘XXX‘) # 創建一個Cassandra的cluster cluster = Cluster(contact_points=contact_points, auth_provider=auth_provider) # 連接並創建一個會話 session = cluster.connect() # 定義一條cql查詢語句 cql_str = ‘select * from keyspace.table limit 5;‘ simple_statement = SimpleStatement(cql_str,consistency_level=ConsistencyLevel.ONE) # 對語句的執行設置超時時間為None execute_result = session.execute(simple_statement, timeout=None) # 獲取執行結果中的原始數據 result = execute_result._current_rows # 把結果轉成DataFrame格式 result = pd.DataFrame(result) # 把查詢結果寫入csv result.to_csv(‘連接遠程數據庫.csv‘, mode=‘a‘, header=True)
def processEntityImages(choice_blobs, db_account_name, db_account_key, ca_file_uri, db_config, cs_account, cs_key, eh_url, eh_account, eh_key): ''' Tests entity images for the presence of a face using Azure Cognitive Services, extracts the face based on the provided bounding box, applies the facial classifier if available and then writes the raw image, face to CosmosDB ''' #Initialize the cognitive services account to perform facial detection BASE_CS_URL = 'https://virginia.api.cognitive.microsoft.us/face/v1.0/' # Replace with your regional Base URL CF.Key.set(cs_key) CF.BaseUrl.set(BASE_CS_URL) def extractFace(image_bytes): ''' ''' face_list = CF.face.detect(image_bytes) if len(face_list) == 1: face_rectangle = face_list[0]['faceRectangle'] nparr = np.fromstring(image_bytes, np.uint8) img_byte = Image.open(io.BytesIO(image_bytes)) face_iso_image = img_byte.crop( (face_rectangle['left'], face_rectangle['top'], face_rectangle['left'] + face_rectangle['width'], face_rectangle['top'] + face_rectangle['height'])) return face_iso_image else: return None #Convert the base image to PIL object, then detect and extract the face component of the image blob_image_faces = list( map( lambda blob_tuple: (blob_tuple[0], Image.open(io.BytesIO(blob_tuple[1])), extractFace(blob_tuple[1])), choice_blobs)) logging.debug("Face detection run on {0} images".format( len(blob_image_faces))) #Connect to the database ssl_opts = { 'ca_certs': ca_file_uri, 'ssl_version': PROTOCOL_TLSv1_2, 'cert_reqs': CERT_REQUIRED # Certificates are required and validated } auth_provider = PlainTextAuthProvider(username=db_account_name, password=db_account_key) endpoint_uri = db_account_name + '.cassandra.cosmosdb.azure.com' cluster = Cluster([endpoint_uri], port=10350, auth_provider=auth_provider, ssl_options=ssl_opts) #If no db config file is passed, look for the container environment variables if db_config is None: keyspace = os.environ['DB_KEYSPACE'] personaTableName = os.environ['DB_PERSONA_TABLE'] subPersonaTableName = os.environ['DB_SUB_PERSONA_TABLE'] subPersonaFaceEdgeTableName = os.environ['DB_SUB_PERSONA_EDGE_TABLE'] faceSubPersonaEdgeTableName = os.environ['DB_SUB_PERSONA_EDGE_TABLE'] rawImageTableName = os.environ['DB_RAW_IMAGE_TABLE'] faceTableName = os.environ['DB_REFINED_IMAGE_TABLE'] #Otherwise load db config else: keyspace = db_config['db-keyspace'] personaTableName = db_config['db-persona-table'] subPersonaTableName = db_config['db-sub-persona-table'] subPersonaFaceEdgeTableName = db_config[ 'db-sub-persona-face-edge-table'] faceSubPersonaEdgeTableName = db_config[ 'db-face-sub-persona-edge-table'] rawImageTableName = db_config['db-raw-image-table'] faceTableName = db_config['db-face-image-table'] #Prepare Cosmos DB session and insertion queries session = cluster.connect(keyspace) personaInsertQuery = session.prepare("INSERT INTO " + personaTableName + " (persona_name) VALUES (?)") subPersonaInsertQuery = session.prepare( "INSERT INTO " + subPersonaTableName + " (sub_persona_name, persona_name) VALUES (?, ?)") subPersonaFaceEdgeInsertQuery = session.prepare( "INSERT INTO " + subPersonaFaceEdgeTableName + " (sub_persona_name, assoc_face_id, label_v_predict_assoc_flag) VALUES (?,?,?)" ) faceSubPersonaEdgeInsertQuery = session.prepare( "INSERT INTO " + faceSubPersonaEdgeTableName + " (sub_persona_name, assoc_face_id, label_v_predict_assoc_flag) VALUES (?,?,?)" ) rawInsertQuery = session.prepare( "INSERT INTO " + rawImageTableName + " (image_id, file_uri, image_bytes) VALUES (?,?,?)") refinedInsertQuery = session.prepare( "INSERT INTO " + faceTableName + " (face_id, raw_image_edge_id, face_bytes, feature_bytes) VALUES (?,?,?,?)" ) client = EventHubClient(eh_url, debug=False, username=eh_account, password=eh_key) sender = client.add_sender(partition="0") client.run() face_write_count = 0 face_label_write_count = 0 face_unlabeled_write_count = 0 for (blob, image_bytes, face_bytes) in blob_image_faces: if face_bytes is not None: file_name = blob.name (entity, usage, number) = file_name.split('-') #Generate the face classifier features from the face using VGG-face on Keras if face_bytes.mode != "RGB": face_bytes = face_bytes.convert("RGB") face_bytes = face_bytes.resize((img_width, img_height)) image = img_to_array(face_bytes) image = np.expand_dims(image, axis=0) image = imagenet_utils.preprocess_input(image) stuff = vgg_face_feature_gen.predict(image, batch_size=1).flatten() writer = avro.io.DatumWriter(schema) bytes_writer = io.BytesIO() encoder = avro.io.BinaryEncoder(bytes_writer) writer.write({"features": stuff.tolist()}, encoder) face_feature_bytes = bytes_writer.getvalue() #For each image extract the label and use to generate a persona, redundant writes will cancel out #Writes the entity label to the persona table #For the time being also write the entity label to the subpersona table and associate with the persona table session.execute(personaInsertQuery, (entity, )) session.execute(subPersonaInsertQuery, (entity, entity)) logging.info( "Writing persona, sub-persona {0} to DB table {1}".format( entity, subPersonaTableName)) #Resizes the image to ensure the write query does not exceed maximum size width, height = image_bytes.size if width > height: transform_factor = 256 / width else: transform_factor = 256 / height compact_image_bytes = image_bytes.resize( (round(height * transform_factor), round(width * transform_factor))) #Writes the raw image to its table imgByteArr = io.BytesIO() compact_image_bytes.save(imgByteArr, format='PNG') compact_image_bytes = imgByteArr.getvalue() hashed_bytes = hashlib.md5(compact_image_bytes).digest() hashed_bytes_int = int.from_bytes( hashed_bytes, byteorder='big') #Good identifier, sadly un image_hash = str( hashed_bytes_int ) #Stupid workaround to Python high precision int incompatability session.execute(rawInsertQuery, (image_hash, file_name, compact_image_bytes)) logging.info("Writing raw image to DB {0}".format(image_hash)) #Resizes the image to ensure the write query does not exceed maximum size width, height = face_bytes.size if width > height: transform_factor = 256 / width else: transform_factor = 256 / height compact_face_bytes = face_bytes.resize( (round(height * transform_factor), round(width * transform_factor))) #Write each face extracted from the image to the DB as a refined image imgByteArr = io.BytesIO() compact_face_bytes.save(imgByteArr, format='PNG') compact_face_bytes = imgByteArr.getvalue() face_hash_bytes = hashlib.md5(compact_face_bytes).digest() face_hashed_bytes_int = int.from_bytes( face_hash_bytes, byteorder='big') #Good identifier, sadly un face_hash = str( face_hashed_bytes_int ) #Stupid workaround to Python high precision int incompatability session.execute(refinedInsertQuery, (face_hash, image_hash, compact_face_bytes, face_feature_bytes)) logging.info("Writing face image to DB {0}".format(face_hash)) face_write_count += 1 #If the data is part of the training set, write edges between the sub-personas, face images if usage == "Train": session.execute(subPersonaFaceEdgeInsertQuery, (entity, face_hash, True)) session.execute(faceSubPersonaEdgeInsertQuery, (entity, face_hash, True)) sender.send( EventData( json.dumps({ "EVENT_TYPE": "LABEL_WRITE", "LABEL_INDEX": face_hash, "WRITE_TIMESTAMP": datetime.datetime.now().timestamp() }))) logging.info("Writing face label to DB {0}".format(face_hash)) face_label_write_count += 1 else: #Silly engineering workaround to make it easier to find the unlabeled images later for re-prediction session.execute(subPersonaFaceEdgeInsertQuery, ("TEMPORARY", face_hash, False)) session.execute(faceSubPersonaEdgeInsertQuery, ("TEMPORARY", face_hash, False)) logging.info( "Writing unlabeled face {0} to DB".format(face_hash)) face_unlabeled_write_count += 1 #Otherwise do not write an edge, these will be predicted later by the training service #session.close() client.stop() logging.info("Wrote {0} faces to DB".format(face_write_count)) logging.info("Wrote {0} face labels to DB".format(face_label_write_count))
from os import environ from cassandra.cqlengine import connection from cassandra.auth import PlainTextAuthProvider from stream_framework import settings auth_provider = PlainTextAuthProvider(username=environ['CASSANDRA_USERNAME'], password=environ['CASSANDRA_PASSWORD']) def setup_connection(): connection.setup(hosts=[environ['CASSANDRA_HOST']], consistency=settings.STREAM_CASSANDRA_CONSISTENCY_LEVEL, default_keyspace=settings.STREAM_DEFAULT_KEYSPACE, auth_provider=auth_provider, **settings.CASSANDRA_DRIVER_KWARGS)
from cassandra.cluster import Cluster from cassandra.auth import PlainTextAuthProvider cloud_config = {'secure_connect_bundle': 'secure-connect-pokemon.zip'} auth_provider = PlainTextAuthProvider('<<CLIENT ID>>', '<<CLIENT SECRET>>') cluster = Cluster(cloud=cloud_config, auth_provider=auth_provider) session = cluster.connect() row = session.execute("select release_version from system.local").one() if row: print(row[0]) else: print("An error occurred.")
def main(): arg_spec = { 'keyspace': { 'type': 'str', 'required': True, }, 'replication_strategy': { 'type': 'dict', 'required': True, }, 'durable_writes': { 'type': 'bool', 'required': True, }, 'login_user': { 'type': 'str', 'required': True, }, 'login_password': { 'type': 'str', 'required': True, 'no_log': True }, 'login_hosts': { 'type': 'list', 'required': True, }, 'login_port': { 'type': 'int', 'default': 9042, 'required': False, }, 'protocol': { 'type': 'int', 'default': 3, 'required': False, }, } module = AnsibleModule(argument_spec=arg_spec) keyspace = module.params['keyspace'] replication_strategy = module.params['replication_strategy'] durable_writes = module.params['durable_writes'] login_hosts = module.params['login_hosts'] login_port = module.params['login_port'] login_user = module.params['login_user'] login_password = module.params['login_password'] protocol = module.params['protocol'] if not cassandra_dep_found: module.fail_json(msg="the python cassandra-driver module is required") if not json_dep_found: module.fail_json( msg="the python json or simplejson module is required") try: if not login_user: cluster = Cluster(login_hosts, port=login_port) else: auth_provider = PlainTextAuthProvider(username=login_user, password=login_password) cluster = Cluster(login_hosts, auth_provider=auth_provider, protocol_version=protocol, port=login_port) session = cluster.connect() session.row_factory = dict_factory except Exception, e: module.fail_json( msg="unable to connect to cassandra, check login_user and " + "login_password are correct. Exception message: %s" % e)
def _connect( contact_points=None, port=None, cql_user=None, cql_pass=None, protocol_version=None ): """ Connect to a Cassandra cluster. :param contact_points: The Cassandra cluster addresses, can either be a string or a list of IPs. :type contact_points: str or list of str :param cql_user: The Cassandra user if authentication is turned on. :type cql_user: str :param cql_pass: The Cassandra user password if authentication is turned on. :type cql_pass: str :param port: The Cassandra cluster port, defaults to None. :type port: int :param protocol_version: Cassandra protocol version to use. :type port: int :return: The session and cluster objects. :rtype: cluster object, session object """ # Lazy load the Cassandra cluster and session for this module by creating a # cluster and session when cql_query is called the first time. Get the # Cassandra cluster and session from this module's __context__ after it is # loaded the first time cql_query is called. # # TODO: Call cluster.shutdown() when the module is unloaded on # master/minion shutdown. Currently, Master.shutdown() and Minion.shutdown() # do nothing to allow loaded modules to gracefully handle resources stored # in __context__ (i.e. connection pools). This means that the connection # pool is orphaned and Salt relies on Cassandra to reclaim connections. # Perhaps if Master/Minion daemons could be enhanced to call an "__unload__" # function, or something similar for each loaded module, connection pools # and the like can be gracefully reclaimed/shutdown. if ( __context__ and "cassandra_cql_returner_cluster" in __context__ and "cassandra_cql_returner_session" in __context__ ): return ( __context__["cassandra_cql_returner_cluster"], __context__["cassandra_cql_returner_session"], ) else: contact_points = _load_properties( property_name=contact_points, config_option="cluster" ) contact_points = ( contact_points if isinstance(contact_points, list) else contact_points.split(",") ) port = _load_properties( property_name=port, config_option="port", set_default=True, default=9042 ) cql_user = _load_properties( property_name=cql_user, config_option="username", set_default=True, default="cassandra", ) cql_pass = _load_properties( property_name=cql_pass, config_option="password", set_default=True, default="cassandra", ) protocol_version = _load_properties( property_name=protocol_version, config_option="protocol_version", set_default=True, default=4, ) try: auth_provider = PlainTextAuthProvider(username=cql_user, password=cql_pass) ssl_opts = _get_ssl_opts() if ssl_opts: cluster = Cluster( contact_points, port=port, auth_provider=auth_provider, ssl_options=ssl_opts, protocol_version=protocol_version, compression=True, ) else: cluster = Cluster( contact_points, port=port, auth_provider=auth_provider, protocol_version=protocol_version, compression=True, ) for recontimes in range(1, 4): try: session = cluster.connect() break except OperationTimedOut: log.warning( "Cassandra cluster.connect timed out, try %s", recontimes ) if recontimes >= 3: raise # TODO: Call cluster.shutdown() when the module is unloaded on shutdown. __context__["cassandra_cql_returner_cluster"] = cluster __context__["cassandra_cql_returner_session"] = session __context__["cassandra_cql_prepared"] = {} log.debug( "Successfully connected to Cassandra cluster at %s", contact_points ) return cluster, session except TypeError: pass except (ConnectionException, ConnectionShutdown, NoHostAvailable): log.error("Could not connect to Cassandra cluster at %s", contact_points) raise CommandExecutionError( "ERROR: Could not connect to Cassandra cluster." )
def init_cluster(self): ap = PlainTextAuthProvider(username=os.environ['DB_USER'], password=os.environ['DB_PASS']) self.cluster = Cluster([os.environ['DB_ADDR']], auth_provider=ap, idle_heartbeat_interval=DB_IDLE)