def account_sas(self): table_name = self._create_table() entity = { 'PartitionKey': 'test', 'RowKey': 'test1', 'text': 'hello world', } self.service.insert_entity(table_name, entity) # Access to all entities in all the tables # Expires in an hour token = self.service.generate_account_shared_access_signature( ResourceTypes.OBJECT, AccountPermissions.READ, datetime.utcnow() + timedelta(hours=1), ) # Create a service and use the SAS sas_service = TableService( account_name=self.account.account_name, sas_token=token, ) entities = list(sas_service.query_entities(table_name)) for entity in entities: print(entity.text) # hello world self.service.delete_table(table_name)
def sas_with_signed_identifiers(self): table_name = self._create_table() entity = { 'PartitionKey': 'test', 'RowKey': 'test1', 'text': 'hello world', } self.service.insert_entity(table_name, entity) # Set access policy on table access_policy = AccessPolicy(permission=TablePermissions.QUERY, expiry=datetime.utcnow() + timedelta(hours=1)) identifiers = {'id': access_policy} acl = self.service.set_table_acl(table_name, identifiers) # Wait 30 seconds for acl to propagate time.sleep(30) # Indicates to use the access policy set on the table token = self.service.generate_table_shared_access_signature( table_name, id='id' ) # Create a service and use the SAS sas_service = TableService( account_name=self.account.account_name, sas_token=token, ) entities = list(sas_service.query_entities(table_name)) for entity in entities: print(entity.text) # hello world self.service.delete_table(table_name)
def test_sas_upper_case_table_name(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recording_file(self.test_mode): return # Arrange entity = self._insert_random_entity() # Table names are case insensitive, so simply upper case our existing table name to test token = self.ts.generate_table_shared_access_signature( self.table_name.upper(), TablePermissions.QUERY, datetime.utcnow() + timedelta(hours=1), datetime.utcnow() - timedelta(minutes=1), ) # Act service = TableService( account_name=self.settings.STORAGE_ACCOUNT_NAME, sas_token=token, ) self._set_service_options(service, self.settings) entities = list(service.query_entities(self.table_name, filter="PartitionKey eq '{}'".format(entity['PartitionKey']))) # Assert self.assertEqual(len(entities), 1) self._assert_default_entity(entities[0])
def test_account_sas(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recording_file(self.test_mode): return # Arrange table_name = self._create_table() entity = {"PartitionKey": "test", "RowKey": "test1", "text": "hello"} self.ts.insert_entity(table_name, entity) entity["RowKey"] = "test2" self.ts.insert_entity(table_name, entity) token = self.ts.generate_account_shared_access_signature( ResourceTypes.OBJECT, AccountPermissions.READ, datetime.utcnow() + timedelta(hours=1), datetime.utcnow() - timedelta(minutes=1), ) # Act service = TableService(account_name=self.settings.STORAGE_ACCOUNT_NAME, sas_token=token) self._set_service_options(service, self.settings) entities = list(service.query_entities(table_name)) # Assert self.assertEqual(len(entities), 2) self.assertEqual(entities[0].text, "hello") self.assertEqual(entities[1].text, "hello")
def table_sas(self): table_name = self._create_table() entity = { 'PartitionKey': 'test', 'RowKey': 'test1', 'text': 'hello world', } self.service.insert_entity(table_name, entity) # Access only to the entities in the given table # Query permissions to access entities # Expires in an hour token = self.service.generate_table_shared_access_signature( table_name, TablePermissions.QUERY, datetime.utcnow() + timedelta(hours=1), ) # Create a service and use the SAS sas_service = TableService( account_name=self.account.account_name, sas_token=token, ) entities = sas_service.query_entities(table_name) for entity in entities: print(entity.text) # hello world self.service.delete_table(table_name)
def get_last_run_id(): table_service = TableService(account_name=STORAGE_ACCOUNT_NAME, account_key=STORAGE_ACCOUNT_KEY) databricks_cluster_details_entries = table_service.query_entities( 'databricks', filter="PartitionKey eq 'pdm'") databricks_cluster_details = list(databricks_cluster_details_entries) if databricks_cluster_details: return databricks_cluster_details[0]['run_id'] return None
def get_keywords(): # get table service reference account_name = getenv('STORAGE_ACCOUNT') account_key = getenv('STORAGE_KEY') keyword_table = getenv('KEYWORD_TABLE_NAME') site_name = getenv('SITE_NAME') table_service = TableService(account_name=account_name, account_key=account_key) filter_str = "PartitionKey eq '%s'" % (site_name) # query all keyword entities keywords = table_service.query_entities(keyword_table, filter=filter_str) # TODO: automate the language detection # separate each keyword by language deKeywords = {} urKeywords = {} arKeywords = {} enKeywords = {} idKeywords = {} for keyword in keywords: canonicalKeyword = keyword.name.encode('UTF-8').lower() if hasattr(keyword, 'name_de'): # pre-compile regex for each keyword deKeywordRegex = create_keyword_regex( keyword.name_de.encode('UTF-8')) deKeywords[canonicalKeyword] = deKeywordRegex if hasattr(keyword, 'name_ur'): # pre-compile regex for each keyword urKeywordRegex = create_keyword_regex( keyword.name_ur.encode('UTF-8')) urKeywords[canonicalKeyword] = urKeywordRegex if hasattr(keyword, 'name_ar'): # pre-compile regex for each keyword arKeywordRegex = create_keyword_regex( keyword.name_ar.encode('UTF-8')) arKeywords[canonicalKeyword] = arKeywordRegex if hasattr(keyword, 'name_id'): # pre-compile regex for each keyword idKeywordRegex = create_keyword_regex( keyword.name_id.encode('UTF-8')) idKeywords[canonicalKeyword] = idKeywordRegex if hasattr(keyword, 'name_en'): # pre-compile regex for each keyword enKeywordRegex = create_keyword_regex( keyword.name_en.encode('UTF-8')) enKeywords[canonicalKeyword] = enKeywordRegex return { 'de': deKeywords, 'en': enKeywords, 'id': idKeywords, 'ur': urKeywords, 'ar': arKeywords }
class SummaryTable: def __init__(self, account_name, account_key, table_name="summary"): """Initialiaze a table to store summary data. Values must be provided for 'account_name' and 'account_key' which are values associated with the Azure Storage account. 'table_name' is optional and is the name of the table used (and created if necessary) in the storage account. """ self.log = Log() self.account_name = account_name self.account_key = account_key self.table_name = table_name self.createAzureTable() def createAzureTable(self): """ Create an Azure Table in which to store the summary results. """ self.table_service = TableService(self.account_name, self.account_key) self.table_service.create_table(self.table_name) def deleteTable(self, name): """ Delete a table in which summary results have been stored. """ self.table_service.delete_table(name, False) def writeCount(self, count_type, count): entry = {'PartitionKey': "count", "RowKey": count_type, 'total_count' : count} self.table_service.insert_entity(self.table_name, entry) def updateCount(self, count_type, count): entry = {'total_count' : count} self.table_service.update_entity(self.table_name, "count", count_type, entry) def getCount(self, event_type): """ Get the total number of events of a given type. """ count = 0 entries = self.table_service.query_entities(self.table_name, "PartitionKey eq 'count' and RowKey eq '" + event_type + "'") if len(entries) == 0: self.writeCount(event_type, 0) elif len(entries) > 1: raise Exception('We have more than one summary entry for ' + event_type) else: count = entries[0].total_count return count
def get_video_ids_by_term(search_term): table_service = TableService(account_name=storage_acc_name, account_key=storage_acc_key) vid_ids = table_service.query_entities(table_name='CorpusInvertedIndex', filter='PartitionKey eq \'' + search_term + '\'', select='RowKey') if not vid_ids.items or len(vid_ids.items) == 0: return [] video_ids = {record['RowKey'] for record in vid_ids.items} return video_ids
def test_add_mileage(empty_tables: TableService): db = DBHelper(empty_tables) db.add_mileage_record("123", 124302) test_moment_key = db.get_new_key("123") entities = empty_tables.query_entities( Tables.MILEAGE, filter= f"PartitionKey eq '{Categories.MILEAGE}' and RowKey gt '{test_moment_key}' and RowKey lt '123:20000000000'" ) result = [e for e in entities] assert len(result) == 1 assert result[0]['mileage'] == 124302.0
def test_add_gas_spending(empty_tables: TableService): db = DBHelper(empty_tables) db.add_gas_record("123", 30, CCY.BYN) test_moment_key = db.get_new_key("123") entities = empty_tables.query_entities( Tables.SPENDINGS, filter= f"PartitionKey eq '{Categories.GAS}' and RowKey gt '{test_moment_key}' and RowKey lt '123:20000000000'" ) result = [e for e in entities] assert len(result) == 1 assert db.get_float_value(result[0]['amount']) == 30.0
def get_keyword_filters(): # get table service reference account_name = getenv('STORAGE_ACCOUNT') account_key = getenv('STORAGE_KEY') filter_table = getenv('FILTER_TABLE_NAME') table_service = TableService(account_name=account_name, account_key=account_key) # query all entities rows = table_service.query_entities(filter_table) # create a list of conjunct regexes return [[ create_keyword_regex(term) for term in json.loads(row.filteredTerms) ] for row in rows]
def test_add_car_goods_float(empty_tables: TableService): db = DBHelper(empty_tables) db.add_car_goods_record(123, 10.05, CCY.BYN, "огнетушитель") test_moment_key = db.get_new_key("123") entities = empty_tables.query_entities( Tables.SPENDINGS, filter= f"PartitionKey eq '{Categories.CAR_GOODS}' and RowKey gt '{test_moment_key}' and RowKey lt '123:20000000000'" ) result = [e for e in entities] assert len(result) == 1 assert result[0]['amount'] == 10.05 assert result[0]['ccy'] == CCY.BYN
def get_table_details(creds, resource_group_name, account_name, table_name, next_partition_key=None, next_row_key=None): keys = _get_storage_account_keys(creds, resource_group_name, account_name) table_service = TableService(account_name, keys.key1) model = StorageAccountTableDetails() model.table_name = table_name model.entities = table_service.query_entities( table_name, top=3, # small to demonstrate continuations next_partition_key=next_partition_key, next_row_key=next_row_key, ) model.custom_fields = _get_entities_custom_fields(model.entities) return model
def connection(tasks, query, types): table_service = TableService(account_name=acc_name, account_key=acc_key) table_service.create_table('customer') if types == "insert": print(tasks) table_service.insert_entity('customer', tasks) return "added Successfully!!!!" elif types == "reterive": #print(query) tasks = table_service.query_entities('customer', filter=query) #print(tasks) df = pd.DataFrame(df_con(tasks)) data1 = df.to_json(orient='records') #print(data1) return data1
class Repository(object): """Azure Table storage repository for UOTD.""" def __init__(self, settings): """Initialise UOTD repository with the given settings dict. Required settings: STORAGE_NAME -- the Azure Storage account name STORAGE_KEY -- an access key for the Storage account STORAGE_TABLE_UOTD -- the name of the table """ self.service = TableService(settings["STORAGE_NAME"], settings["STORAGE_KEY"]) self.uotd_table = settings["STORAGE_TABLE_UOTD"] self.service.create_table(self.uotd_table) self.partition_key_format = "%Y%m" self.row_key_format = "%d" def get_uotd(self): """Get the UUID for the current day. If the UUID does not yet exist then it will be created. """ partition_key = date.today().strftime(self.partition_key_format) row_key = date.today().strftime(self.row_key_format) try: uotd_entity = self.service.get_entity(self.uotd_table, partition_key, row_key) uuid = uotd_entity.uuid except AzureMissingResourceHttpError: uuid = str(uuid4()) uotd_entity = { "PartitionKey": partition_key, "RowKey": row_key, "uuid": uuid } self.service.insert_entity(self.uotd_table, uotd_entity) return uuid def get_uuids(self, partition_key): """Get all the UUIDs in a given partition.""" filter = "PartitionKey eq '{0}'".format(partition_key) entities = self.service.query_entities(self.uotd_table, filter=filter) return entities
def get_data(block_id, sas_url): table_service = TableService(azure_storage_account_name, azure_storage_account_key) tasks = table_service.query_entities('Parking1hour1BlockAverage', filter="PartitionKey eq '%d' and RowKey gt '2019-01-01 00:00:00'" % (1001), select='RowKey,PercentOccupied') pct_occupieds = [] hours = [] for task in tasks: pct_occupieds.append(task.PercentOccupied) hours.append(datetime.strptime(task.RowKey, "%Y-%m-%d %H:%M:%S").hour) time_chunks_per_day = np.max(hours) - np.min(hours) + 1 run_arima( np.array(pct_occupieds), time_chunks_per_day )
def main(req: func.HttpRequest) -> func.HttpResponse: try: logging.info("Trigger started") ret = {} if "code" not in req.params: logging.info("Invalid code") ret["message"] = "The parameter code is no present in the request." ret["status"] = False return func.HttpResponse(json.dumps(ret), headers=headers) else: code = req.params.get('code') logging.info("Processing " + str(code) + "...") table_service = TableService(account_name=ACCOUNT_NAME, account_key=ACCOUNT_KEY) records = table_service.query_entities( TABLE_NAME_TRACKING, filter="PartitionKey eq 'tracking-analysis' and RowKey eq '" + code + "'") if len(records.items) == 0: ret["message"] = "Meeting coding not found" ret["status"] = False logging.info("Code not found.") else: ret["message"] = "Code has been found" ret["status"] = True logging.info("Code has been found.") return func.HttpResponse(json.dumps(ret), headers=headers) except Exception as error: logging.error(error) return func.HttpResponse(error, status_code=400, headers=headers)
def busca_heroe(nombre): account_name = os.environ['AZURE_STORAGE_ACCOUNT'] account_key = os.environ['AZURE_STORAGE_ACCESS_KEY'] table_service = TableService(account_name, account_key) filter = "PartitionKey eq " + "\'" + nombre + "\'" consulta = table_service.query_entities('heroes', filter) salida = {} for heroe in consulta: for key in heroe.__dict__.keys(): salida[key] = str(heroe.__dict__[key]) salida['Nombre'] = salida['PartitionKey'] salida['Grupo'] = salida['RowKey'] del salida['etag'] del salida['PartitionKey'] del salida['RowKey'] del salida['Timestamp'] return salida
def test_account_sas(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recording_file(self.test_mode): return # Arrange table_name = self._create_table() entity = { 'PartitionKey': 'test', 'RowKey': 'test1', 'text': 'hello', } self.ts.insert_entity(table_name, entity) entity['RowKey'] = 'test2' self.ts.insert_entity(table_name, entity) token = self.ts.generate_account_shared_access_signature( ResourceTypes.OBJECT, AccountPermissions.READ, datetime.utcnow() + timedelta(hours=1), datetime.utcnow() - timedelta(minutes=1), ) # Act service = TableService( account_name=self.settings.STORAGE_ACCOUNT_NAME, sas_token=token, ) self._set_test_proxy(service, self.settings) entities = list(service.query_entities(table_name)) # Assert self.assertEqual(len(entities), 2) self.assertEqual(entities[0].text, 'hello') self.assertEqual(entities[1].text, 'hello')
table_service.insert_entity('itemstable', coffee) print('Created entry for CoffeeBean...\n') time.sleep(1) ### # Use the Azure Storage Storage SDK for Python to query for entities in our Table ### print( 'With some data in our Azure Storage Table, we can query the data.\nLet\'s see what the pizza menu looks like.' ) raw_input('Press Enter to continue...') # In this query, you define the partition key to search within, and then which properties to retrieve # Structuring queries like this improves performance as your application scales up and keeps the queries efficient items = table_service.query_entities('itemstable', filter="PartitionKey eq 'Cargallery'", select='make,model,year,color,price') for item in items: print('Make: ' + item.make) print('Model: ' + item.model) print('Year: ' + item.year) print('Color: ' + item.color) print('Price: ' + str(item.price) + '\n') items = table_service.query_entities('itemstable', filter="PartitionKey eq 'Coffeemenu'", select='brand,flavor,cupsize,price') for item in items: print('Brand: ' + item.brand) print('Flavor: ' + item.flavor) print('Cupsize: ' + item.cupsize)
class TableStorageHandlerTest(_TestCase): def _divide_key(self, key): divided = [] hostname = gethostname() if key.find(hostname) >= 0: preceding, hostname, remaining = key.rpartition(hostname) preceding = preceding[:-1] if preceding.endswith('-') else preceding divided.extend(preceding.split('-')) divided.append(hostname) remaining = remaining[1:] if remaining.startswith('-') else remaining divided.extend(remaining.split('-')) else: divided.extend(key.split('-')) return iter(divided) def _get_formatter_name(self, handler_name, formatter_type): name = _get_handler_config_value(handler_name, formatter_type) if name: if name.startswith('cfg://formatters.'): name = name.split('.')[1] return name def _get_partition_key_formatter_name(self, handler_name): return self._get_formatter_name(handler_name, 'partition_key_formatter') def _get_row_key_formatter_name(self, handler_name): return self._get_formatter_name(handler_name, 'row_key_formatter') def setUp(self): self.service = TableService(account_name=ACCOUNT_NAME, account_key=ACCOUNT_KEY, is_emulated=_EMULATED) # ensure that there's no entity in the table before each test tables = set() for cfg in LOGGING['handlers'].values(): if 'table' in cfg: tables.add(cfg['table']) for table in self.service.list_tables(): if table.name in tables: for entity in self.service.query_entities(table.name): self.service.delete_entity(table.name, entity.PartitionKey, entity.RowKey) def test_logging(self): # get the logger for the test logger_name = 'table' logger = logging.getLogger(logger_name) handler_name = _get_handler_name(logger_name) # perform logging log_text = 'logging test' logging_started = datetime.now() logger.info(log_text) logging_finished = datetime.now() # confirm that the entity has correct log text table = _get_handler_config_value(handler_name, 'table') entities = iter(self.service.query_entities(table)) entity = next(entities) self.assertEqual(entity.message, 'INFO %s' % log_text) # confirm that the entity has the default partitiok key fmt = '%Y%m%d%H%M' try: self.assertEqual(entity.PartitionKey, logging_started.strftime(fmt)) except AssertionError: if logging_started == logging_finished: raise self.assertEqual(entity.PartitionKey, logging_finished.strftime(fmt)) # confirm that the entity has the default row key divided = self._divide_key(entity.RowKey) timestamp = next(divided) fmt = '%Y%m%d%H%M%S' self.assertGreaterEqual(timestamp[:-3], logging_started.strftime(fmt)) self.assertLessEqual(timestamp[:-3], logging_finished.strftime(fmt)) self.assertRegex(timestamp[-3:], '^[0-9]{3}$') self.assertEqual(next(divided), gethostname()) self.assertEqual(int(next(divided)), os.getpid()) self.assertEqual(next(divided), '00') with self.assertRaises(StopIteration): next(divided) # confirm that there's no more entity in the table with self.assertRaises(StopIteration): next(entities) @unittest.skipIf(_EMULATED, "Azure Storage Emulator doesn't support batch operation.") def test_batch(self): # get the logger for the test logger_name = 'batch' logger = logging.getLogger(logger_name) handler_name = _get_handler_name(logger_name) # perform logging and execute the first batch batch_size = _get_handler_config_value(handler_name, 'batch_size') log_text = 'batch logging test' for i in range(batch_size + int(batch_size/2)): logger.info('%s#%02d' % (log_text, i)) # confirm that only batch_size entities are committed at this point table = _get_handler_config_value(handler_name, 'table') entities = list(iter(self.service.query_entities(table))) self.assertEqual(len(entities), batch_size) rowno_found = set() seq_found = set() for entity in entities: # partition key self.assertEqual(entity.PartitionKey, 'batch-%s' % gethostname()) # row key rowno = entity.RowKey.split('-')[-1] self.assertLess(int(rowno), batch_size) self.assertNotIn(rowno, rowno_found) rowno_found.add(rowno) # message message, seq = entity.message.split('#') self.assertEqual(message, 'INFO %s' % log_text) self.assertLess(int(seq), batch_size) self.assertNotIn(seq, seq_found) seq_found.add(seq) # remove currently created entities before the next batch for entity in entities: self.service.delete_entity(table, entity.PartitionKey, entity.RowKey) # perform logging again and execute the next batch for j in range(i+1, int(batch_size/2)+i+1): logger.info('%s#%02d' % (log_text, j)) # confirm that the remaining entities are committed in the next batch entities = list(iter(self.service.query_entities(table))) self.assertEqual(len(entities), batch_size) rowno_found.clear() for entity in entities: # partition key self.assertEqual(entity.PartitionKey, 'batch-%s' % gethostname()) # row key rowno = entity.RowKey.split('-')[-1] self.assertLess(int(rowno), batch_size) self.assertNotIn(rowno, rowno_found) rowno_found.add(rowno) # message message, seq = entity.message.split('#') self.assertEqual(message, 'INFO %s' % log_text) self.assertGreaterEqual(int(seq), batch_size) self.assertLess(int(seq), batch_size*2) self.assertNotIn(seq, seq_found) seq_found.add(seq) def test_extra_properties(self): # get the logger for the test logger_name = 'extra_properties' logger = logging.getLogger(logger_name) handler_name = _get_handler_name(logger_name) # perform logging log_text = 'extra properties test' logger.info(log_text) # confirm that the entity has correct log text table = _get_handler_config_value(handler_name, 'table') entities = iter(self.service.query_entities(table)) entity = next(entities) self.assertEqual(entity.message, 'INFO %s' % log_text) # confirm that the extra properties have correct values entity = next(iter(self.service.query_entities(table))) self.assertEqual(entity.hostname, gethostname()) self.assertEqual(entity.levelname, 'INFO') self.assertEqual(int(entity.levelno), logging.INFO) self.assertEqual(entity.module, os.path.basename(__file__).rpartition('.')[0]) self.assertEqual(entity.name, logger_name) self.assertEqual(int(entity.process), os.getpid()) self.assertEqual(int(entity.thread), current_thread().ident) # confirm that there's no more entity in the table with self.assertRaises(StopIteration): next(entities) def test_custom_key_formatters(self): # get the logger for the test logger_name = 'custom_keys' logger = logging.getLogger(logger_name) handler_name = _get_handler_name(logger_name) # perform logging log_text = 'custom key formatters test' logging_started = datetime.now() logger.info(log_text) logging_finished = datetime.now() # confirm that the entity correct log text table = _get_handler_config_value(handler_name, 'table') entities = iter(self.service.query_entities(table)) entity = next(entities) self.assertEqual(entity.message, 'INFO %s' % log_text) # confirm that the entity has a custom partitiok key divided = self._divide_key(entity.PartitionKey) self.assertEqual(next(divided), 'mycustompartitionkey') self.assertEqual(next(divided), gethostname()) formatter_name = self._get_partition_key_formatter_name(handler_name) fmt = _get_formatter_config_value(formatter_name, 'datefmt') asctime = next(divided) try: self.assertEqual(asctime, logging_started.strftime(fmt)) except AssertionError: if logging_started == logging_finished: raise self.assertEqual(asctime, logging_finished.strftime(fmt)) with self.assertRaises(StopIteration): next(divided) # confirm that the entity has a custom row key divided = self._divide_key(entity.RowKey) self.assertEqual(next(divided), 'mycustomrowkey') self.assertEqual(next(divided), gethostname()) formatter_name = self._get_row_key_formatter_name(handler_name) fmt = _get_formatter_config_value(formatter_name, 'datefmt') asctime = next(divided) try: self.assertEqual(asctime, logging_started.strftime(fmt)) except AssertionError: if logging_started == logging_finished: raise self.assertEqual(asctime, logging_finished.strftime(fmt)) with self.assertRaises(StopIteration): next(divided) # confirm that there's no more entity in the table with self.assertRaises(StopIteration): next(entities)
class StorageTableContext(): """Initializes the repository with the specified settings dict. Required settings in config dict are: - AZURE_STORAGE_NAME - STORAGE_KEY """ _models = [] _encryptproperties = False _encrypted_properties = [] _tableservice = None _storage_key = '' _storage_name = '' def __init__(self, **kwargs): self._storage_name = kwargs.get('AZURE_STORAGE_NAME', '') self._storage_key = kwargs.get('AZURE_STORAGE_KEY', '') """ service init """ self._models = [] if self._storage_key != '' and self._storage_name != '': self._tableservice = TableService(account_name = self._storage_name, account_key = self._storage_key, protocol='https') """ encrypt queue service """ if kwargs.get('AZURE_REQUIRE_ENCRYPTION', False): # Create the KEK used for encryption. # KeyWrapper is the provided sample implementation, but the user may use their own object as long as it implements the interface above. kek = KeyWrapper(kwargs.get('AZURE_KEY_IDENTIFIER', 'otrrentapi'), kwargs.get('SECRET_KEY', 'super-duper-secret')) # Key identifier # Create the key resolver used for decryption. # KeyResolver is the provided sample implementation, but the user may use whatever implementation they choose so long as the function set on the service object behaves appropriately. key_resolver = KeyResolver() key_resolver.put_key(kek) # Set the require Encryption, KEK and key resolver on the service object. self._encryptproperties = True self._tableservice.key_encryption_key = kek self._tableservice.key_resolver_funcion = key_resolver.resolve_key self._tableservice.encryption_resolver_function = self.__encryptionresolver__ pass def __createtable__(self, tablename) -> bool: if (not self._tableservice is None): try: self._tableservice.create_table(tablename) return True except AzureException as e: log.error('failed to create {} with error {}'.format(tablename, e)) return False else: return True pass # Define the encryption resolver_function. def __encryptionresolver__(self, pk, rk, property_name): if property_name in self._encrypted_properties: return True #log.debug('encrypt field {}'.format(property_name)) #log.debug('dont encrypt field {}'.format(property_name)) return False def register_model(self, storagemodel:object): modelname = storagemodel.__class__.__name__ if isinstance(storagemodel, StorageTableModel): if (not modelname in self._models): self.__createtable__(storagemodel._tablename) self._models.append(modelname) """ set properties to be encrypted client side """ if self._encryptproperties: self._encrypted_properties += storagemodel._encryptedproperties log.info('model {} registered successfully. Models are {!s}. Encrypted fields are {!s} '.format(modelname, self._models, self._encrypted_properties)) pass def table_isempty(self, tablename, PartitionKey='', RowKey = '') -> bool: if (not self._tableservice is None): filter = "PartitionKey eq '{}'".format(PartitionKey) if PartitionKey != '' else '' if filter == '': filter = "RowKey eq '{}'".format(RowKey) if RowKey != '' else '' else: filter = filter + ("and RowKey eq '{}'".format(RowKey) if RowKey != '' else '') try: entities = list(self._tableservice.query_entities(tablename, filter = filter, select='PartitionKey', num_results=1)) if len(entities) == 1: return False else: return True except AzureMissingResourceHttpError as e: log.debug('failed to query {} with error {}'.format(tablename, e)) return True else: return True pass def exists(self, storagemodel) -> bool: exists = False if isinstance(storagemodel, StorageTableModel): modelname = storagemodel.__class__.__name__ if (modelname in self._models): if storagemodel._exists is None: try: entity = self._tableservice.get_entity(storagemodel._tablename, storagemodel.PartitionKey, storagemodel.RowKey) storagemodel._exists = True exists = True except AzureMissingResourceHttpError: storagemodel._exists = False else: exists = storagemodel._exists else: log.debug('please register model {} first'.format(modelname)) return exists def get(self, storagemodel) -> StorageTableModel: """ load entity data from storage to vars in self """ if isinstance(storagemodel, StorageTableModel): modelname = storagemodel.__class__.__name__ if (modelname in self._models): try: entity = self._tableservice.get_entity(storagemodel._tablename, storagemodel.PartitionKey, storagemodel.RowKey) storagemodel._exists = True """ sync with entity values """ for key, default in vars(storagemodel).items(): if not key.startswith('_') and key not in ['','PartitionKey','RowKey']: value = getattr(entity, key, None) if not value is None: setattr(storagemodel, key, value) except AzureMissingResourceHttpError as e: log.debug('can not get table entity: Table {}, PartitionKey {}, RowKey {} because {!s}'.format(storagemodel._tablename, storagemodel.PartitionKey, storagemodel.RowKey, e)) storagemodel._exists = False except Exception as e: log.debug('can not get table entity: Table {}, PartitionKey {}, RowKey {} because {!s}'.format(storagemodel._tablename, storagemodel.PartitionKey, storagemodel.RowKey, e)) storagemodel._exists = False else: log.debug('please register model {} first to {!s}'.format(modelname, self._models)) return storagemodel else: return None def insert(self, storagemodel) -> StorageTableModel: """ insert model into storage """ if isinstance(storagemodel, StorageTableModel): modelname = storagemodel.__class__.__name__ if (modelname in self._models): try: self._tableservice.insert_or_replace_entity(storagemodel._tablename, storagemodel.entity()) storagemodel._exists = True except AzureMissingResourceHttpError as e: log.debug('can not insert or replace table entity: Table {}, PartitionKey {}, RowKey {} because {!s}'.format(storagemodel._tablename, storagemodel.PartitionKey, storagemodel.RowKey, e)) else: log.debug('please register model {} first'.format(modelname)) return storagemodel else: return None def merge(self, storagemodel) -> StorageTableModel: """ try to merge entry """ if isinstance(storagemodel, StorageTableModel): modelname = storagemodel.__class__.__name__ if (modelname in self._models): try: self._tableservice.insert_or_merge_entity(storagemodel._tablename, storagemodel.entity()) storagemodel._exists = True except AzureMissingResourceHttpError as e: log.debug('can not insert or merge table entity: Table {}, PartitionKey {}, RowKey {} because {!s}'.format(storagemodel._tablename, storagemodel.PartitionKey, storagemodel.RowKey, e)) else: log.debug('please register model {} first'.format(modelname)) return storagemodel else: return None def delete(self,storagemodel): """ delete existing Entity """ if isinstance(storagemodel, StorageTableModel): modelname = storagemodel.__class__.__name__ if (modelname in self._models): try: self._tableservice.delete_entity(storagemodel._tablename, storagemodel.PartitionKey, storagemodel.RowKey) storagemodel._exists = False except AzureMissingResourceHttpError as e: log.debug('can not delete table entity: Table {}, PartitionKey {}, RowKey {} because {!s}'.format(storagemodel._tablename, storagemodel.PartitionKey, storagemodel.RowKey, e)) else: log.debug('please register model {} first'.format(modelname)) return storagemodel else: return None def __changeprimarykeys__(self, PartitionKey = '', RowKey = ''): """ Change Entity Primary Keys into new instance: - PartitionKey and/or - RowKey """ PartitionKey = PartitionKey if PartitionKey != '' else self._PartitionKey RowKey = RowKey if RowKey != '' else self._RowKey """ change Primary Keys if different to existing ones """ if (PartitionKey != self._PartitionKey) or (RowKey != self._RowKey): return True, PartitionKey, RowKey else: return False, PartitionKey, RowKey pass def moveto(self, PartitionKey = '', RowKey = ''): """ Change Entity Primary Keys and move in Storage: - PartitionKey and/or - RowKey """ changed, PartitionKey, RowKey = self.__changeprimarykeys__(PartitionKey, RowKey) if changed: """ sync self """ new = self.copyto(PartitionKey, RowKey) new.save() """ delete Entity if exists in Storage """ self.delete() def copyto(self, PartitionKey = '', RowKey = '') -> object: """ Change Entity Primary Keys and copy to new Instance: - PartitionKey and/or - RowKey """ changed, PartitionKey, RowKey = self.__changeprimarykeys__(PartitionKey, RowKey) self.load() new = self new._PartitionKey = PartitionKey new._RowKey = RowKey new.load() return new def query(self, storagecollection) -> StorageTableCollection: if isinstance(storagecollection, StorageTableCollection): try: storagecollection.extend(self._tableservice.query_entities(storagecollection._tablename,storagecollection._filter)) except AzureMissingResourceHttpError as e: log.debug('can not query table {} with filters {} because {!s}'.format(storagecollection._tablename, storagecollection._filter, e)) return storagecollection else: return None
j=1 while True: # wait time in sec's time.sleep(90) #import table from storage as csv file import azure from azure.storage.table import TableService, Entity from azure.storage.table.models import EntityProperty import csv key ='******************************d/Xg8j1ITmmGg==' table_service = TableService(account_name='intelligentappstorage01', account_key=key) rows = table_service.query_entities('transcriptiontable') with open('chunks'+meetingID+'.csv', 'w') as f: w = None for a_row in rows: if w == None: w = csv.writer(f, lineterminator='\n') w.writerow(a_row.keys()) row = [] for key, value in a_row.items(): actual_value = value if isinstance(value, EntityProperty): actual_value = value.value
clothing.sku = 'BLK203143' clothing.item = 'jeans' clothing.cost = 55.99 table_service.insert_entity('itemstable', clothing) print('Created entry for Jeans...\n') time.sleep(1) ### # Use the Azure Storage Storage SDK for Python to query for entities in our Table ### print('With some data in our Azure Storage Table, we can query the data.\nLet\'s see what the pizza menu looks like.') raw_input('Press Enter to continue...') # In this query, you define the partition key to search within, and then which properties to retrieve # Structuring queries like this improves performance as your application scales up and keeps the queries efficient items = table_service.query_entities('itemstable', filter="PartitionKey eq 'pizzamenu'", select='description,cost') for item in items: print('Name: ' + item.description) print('Cost: ' + str(item.cost) + '\n') items = table_service.query_entities('itemstable', filter="PartitionKey eq 'clothingstore'", select='description,price') for item in items: print('Name: ' + item.description) print('Price: ' + str(item.price) + '\n') time.sleep(1) ### # This was a quick demo to see Tables in action. # Although the actual cost is minimal (fractions of a cent per month) for the three entities we created, it's good to clean up resources when you're done
table_service.insert_entity('itemstable', coffee) print('Created entry for a StarBucks Vanilla...\n') time.sleep(1) ### # Use the Azure Storage Storage SDK for Python to query for entities in our Table ### print('With some data in our Azure Storage Table, we can query the data.\nLet\'s see what the Car Info looks like.') raw_input('Press Enter to continue...') # In this query, you define the partition key to search within, and then which properties to retrieve # Structuring queries like this improves performance as your application scales up and keeps the queries efficient items = table_service.query_entities('itemstable', filter="PartitionKey eq 'carinfo'", select='make,model') for item in items: print('Make: ' + item.make) print('Model: ' + str(item.model) + '\n') items = table_service.query_entities('itemstable', filter="PartitionKey eq 'coffeeinv'", select='brand,flavor') for item in items: print('Brand: ' + item.brand) print('Flavor: ' + str(item.flavor) + '\n') time.sleep(1) ### # This was a quick demo to see Tables in action. # Although the actual cost is minimal (fractions of a cent per month) for the three entities we created, it's good to clean up resources when you're done
class Repository(object): """Azure Table Storage repository.""" def __init__(self, settings): """Initializes the repository with the specified settings dict. Required settings are: - STORAGE_NAME - STORAGE_KEY - STORAGE_TABLE_POLL - STORAGE_TABLE_CHOICE """ self.name = 'Azure Table Storage' self.storage_name = settings['STORAGE_NAME'] self.storage_key = settings['STORAGE_KEY'] self.poll_table = settings['STORAGE_TABLE_POLL'] self.choice_table = settings['STORAGE_TABLE_CHOICE'] self.svc = TableService(self.storage_name, self.storage_key) self.svc.create_table(self.poll_table) self.svc.create_table(self.choice_table) def get_polls(self): """Returns all the polls from the repository.""" poll_entities = self.svc.query_entities(self.poll_table) polls = [_poll_from_entity(entity) for entity in poll_entities] return polls def get_poll(self, poll_key): """Returns a poll from the repository.""" try: partition, row = _key_to_partition_and_row(poll_key) poll_entity = self.svc.get_entity(self.poll_table, partition, row) choice_entities = self.svc.query_entities( self.choice_table, "PollPartitionKey eq '{0}' and PollRowKey eq '{1}'" \ .format(partition, row) ) poll = _poll_from_entity(poll_entity) poll.choices = [_choice_from_entity(choice_entity) for choice_entity in choice_entities] return poll except AzureMissingResourceHttpError: raise PollNotFound() def increment_vote(self, poll_key, choice_key): """Increment the choice vote count for the specified poll.""" try: partition, row = _key_to_partition_and_row(choice_key) entity = self.svc.get_entity(self.choice_table, partition, row) entity.Votes += 1 self.svc.update_entity(self.choice_table, entity) except AzureMissingResourceHttpError: raise PollNotFound() def add_sample_polls(self): """Adds a set of polls from data stored in a samples.json file.""" poll_partition = '2014' poll_row = 0 choice_partition = '2014' choice_row = 0 for sample_poll in _load_samples_json(): poll_entity = { 'PartitionKey': poll_partition, 'RowKey': str(poll_row), 'Text': sample_poll['text'], } self.svc.insert_entity(self.poll_table, poll_entity) for sample_choice in sample_poll['choices']: choice_entity = { 'PartitionKey': choice_partition, 'RowKey': str(choice_row), 'Text': sample_choice, 'Votes': 0, 'PollPartitionKey': poll_partition, 'PollRowKey': str(poll_row), } self.svc.insert_entity(self.choice_table, choice_entity) choice_row += 1 poll_row += 1
table_service.insert_entity('itemstable', coffee) print('Created entry for Costacoffee...\n') time.sleep(1) ### # Use the Azure Storage Storage SDK for Python to query for entities in our Table ### print( 'With some data in our Azure Storage Table, we can query the data.\nLet\'s see what the car menu looks like.' ) raw_input('Press Enter to continue...') # In this query, you define the partition key to search within, and then which properties to retrieve # Structuring queries like this improves performance as your application scales up and keeps the queries efficient items = table_service.query_entities('itemstable', filter="PartitionKey eq 'pizzamenu'", select='description,cost') for item in items: print('Name: ' + item.description) print('Cost: ' + str(item.cost) + '\n') items = table_service.query_entities('itemstable', filter="PartitionKey eq 'cardealer'", select='make,cost') for item in items: print('Name: ' + item.make) print('Price: ' + str(item.cost) + '\n') items = table_service.query_entities('itemstable', filter="PartitionKey eq 'clothingstore'", select='item,cost')
coffee.sizeofcup = 'Grande' coffee.price = 5.50 table_service.insert_entity('itemstable', coffee) print('Created entry for a cafe Latte...\n') time.sleep(1) ### # Use the Azure Storage Storage SDK for Python to query for entities in our Table ### print('With some data in our Azure Storage Table, we can query the data.\nLet\'s see what the car delaership looks like.') raw_input('Press Enter to continue...') # In this query, you define the partition key to search within, and then which properties to retrieve # Structuring queries like this improves performance as your application scales up and keeps the queries efficient items = table_service.query_entities('itemstable', filter="PartitionKey eq 'Cardealership'", select='make,model,year,color,price') for item in items: print('Make: ' + item.make) print('Model: ' + item.model) print('Year: ' + item.year) print('Color: ' + item.color) print('Price: ' + str(item.price) + '\n') items = table_service.query_entities('itemstable', filter="PartitionKey eq 'coffeeshop'", select='brand,flavor,sizeofcup,price') for item in items: print('Brand: ' + item.brand) print('flavor: ' + item.flavor) print('sizeofcup: ' + item.sizeofcup) print('PricePerCup: ' + str(item.price) + '\n') time.sleep(1)
table_service.update_entity('tasktable', 'tasksSeattle', '1', task) # task = {'description' : 'Take out the garbage again', 'priority' : 250} table_service.insert_or_replace_entity('tasktable', 'tasksSeattle', '1', task) task = {'description' : 'Buy detergent', 'priority' : 300} table_service.insert_or_replace_entity('tasktable', 'tasksSeattle', '3', task) task10 = {'PartitionKey': 'tasksSeattle', 'RowKey': '10', 'description' : 'Go grocery shopping', 'priority' : 400} task11 = {'PartitionKey': 'tasksSeattle', 'RowKey': '11', 'description' : 'Clean the bathroom', 'priority' : 100} table_service.begin_batch() table_service.insert_entity('tasktable', task10) table_service.insert_entity('tasktable', task11) table_service.commit_batch() task = table_service.get_entity('tasktable', 'tasksSeattle', '1') print(task.description) print(task.priority) tasks = table_service.query_entities('tasktable', "PartitionKey eq 'tasksSeattle'") for task in tasks: print(task.description) print(task.priority) tasks = table_service.query_entities('tasktable', "PartitionKey eq 'tasksSeattle'", 'description') for task in tasks: print(task.description) table_service.delete_entity('tasktable', 'tasksSeattle', '1') table_service.delete_table('tasktable')
sender = '*****@*****.**' #receiver = '*****@*****.**' receiver = '*****@*****.**' msg = email.message.Message() msg['From'] = sender msg['To'] = receiver msg.add_header('Content-Type','text/html') past_time = 0 while True: test = "finishtransmissiontime gt %d" % past_time #print test tasks = table_service.query_entities('StreamOutputTable1', filter=test) if len(tasks)<1: continue print 'length of records found:', str(len(tasks)) send_mails = [] for record in tasks: device_temparature = float(record.temp) device_check = check_device_status(record) if device_check: send_mails.append(device_check) past_time = record.finishtransmissiontime if len(send_mails)<1: print 'looking for another batch of emails' continue print 'trying to login' #mail = getmail_data(sender) print 'successfully logged in'
coffee.brand = 'Folgers' coffee.flavor = 'Hazelnut' coffee.cupsize = '30OZ' coffee.cost = 5.99 table_service.insert_entity('itemstable', coffee) print('Created entry for Hazelnut...\n') time.sleep(1) ### # Use the Azure Storage Storage SDK for Python to query for entities in our Table ### print('With some data in our Azure Storage Table, we can query the data.\n’ print(‘Let\'s see what the cars menu looks like.') raw_input('Press Enter to continue...') # In this query, you define the partition key to search within, and then which properties to retrieve # Structuring queries like this improves performance as your application scales up and keeps the queries efficient items = table_service.query_entities('itemstable', filter="PartitionKey eq 'carsmenu'", select='make,model,year,color,price') for item in items: print('Name: ' + item.description) print('Cost: ' + str(item.cost) + '\n') items = table_service.query_entities('itemstable', filter="PartitionKey eq 'coffeestore'", select='flavor,cupsize,cost') for item in items: print('Name: ' + item.description) print('Price: ' + str(item.price) + '\n') time.sleep(1) ## This was a quick demo to see Tables in action. # Although the actual cost is minimal (fractions of a cent per month) for the three entities we created, # it's good to clean up resources when you're done ### print('\nWe should clean up the Azure Storage resources we created.') raw_input('Press Enter to continue...') response = table_service.delete_table('itemstable')
coffee.RowKey = '1001' coffee.brand = 'Regular' coffee.flavor = 'Hazelnut' coffee.size = 'Small' coffee.price = 5 table_service.insert_entity('itemstable', coffee) print('Created entry for Regular Hazelnut...') ### # Use the Azure Storage Storage SDK for Python to query for entities in our Table ### print('With some data in our Azure Storage Table, we can query the data.\nLet\'s see what the car menu looks like.') raw_input('Press Enter to continue...') # In this query, you define the partition key to search within, and then which properties to retrieve # Structuring queries like this improves performance as your application scales up and keeps the queries efficient items = table_service.query_entities('itemstable', filter="PartitionKey eq 'carmenu'", select='make,model,year,price') for item in items: print(' Make: ' + item.make) print(' Model: ' + item.model) print(' Year: ' + item.year) print(' Price: ' + str(item.price) + '\n') items = table_service.query_entities('itemstable', filter="PartitionKey eq 'coffeemenu'", select='brand,price') for item in items: print(' Brand: ' + item.brand) print('Price: ' + str(item.price) + '\n') time.sleep(1) ###
coffee.brand = 'dunkin' coffee.flavor = 'fruity' coffee.size = '20oz' coffee.price = 4.50 table_service.insert_entity('itemstable', coffee) print('Created entry for dunkin...\n') ### # Use the Azure Storage Storage SDK for Python to query for entities in our Table ### print('With some data in our Azure Storage Table, we can query the data.\nLet\'s see what the pizza menu looks like.') raw_input('Press Enter to continue...') # In this query, you define the partition key to search within, and then which properties to retrieve # Structuring queries like this improves performance as your application scales up and keeps the queries efficient items = table_service.query_entities('itemstable', filter="PartitionKey eq 'pizzamenu'", select='description,cost') for item in items: print('Name: ' + item.description) print('Cost: ' + str(item.cost) + '\n') items = table_service.query_entities('itemstable', filter="PartitionKey eq 'clothingstore'", select='sku,item,cost') print('Here are clothing items.') for item in items: print('SKU: ' + item.sku) print('Item: ' + item.item) print('Price: ' + str(item.cost) + '\n') items = table_service.query_entities('itemstable', filter="PartitionKey eq 'cardealership'", select='make,model,year,color,price') print('And here are some cars.') for item in items: print('Make: ' + item.make)
table_service.insert_entity('itemstable', clothing) print('Created entry for Jeans...\n') time.sleep(1) ### # Use the Azure Storage Storage SDK for Python to query for entities in our Table ### print( 'With some data in our Azure Storage Table, we can query the data.\nLet\'s see what the carstype looks like.' ) raw_input('Press Enter to continue...') # In this query, you define the partition key to search within, and then which properties to retrieve # Structuring queries like this improves performance as your application scales up and keeps the queries efficient items = table_service.query_entities('itemstable', filter="PartitionKey eq 'carstype'", select='make,model,year,color,price') for item in items: print('make: ' + item.make) print('model: ' + item.model) print('year: ' + str(item.year)) print('color: ' + item.color) print('price: ' + str(item.price) + '\n') # items = table_service.query_entities('itemstable', filter="PartitionKey eq 'clothingstore'", select='description,price') # for item in items: # print('Name: ' + item.description) # print('Price: ' + str(item.price) + '\n') # time.sleep(1)
return a, likedByOtherCountList table_service = TableService(account_name='seva', account_key='SgbxLwWkBH4XuGebxECoXfNVG3mVM5YjOs+SWTDUSacc+3YgUmcafYXrXdz5k0HtlZQ3AuEJ1IcFtZYeGVR9Hw==') batch =TableBatch() #table_service.delete_table('MyVkApp') #table_service.create_table('MyVkApp') login = input("Введите имя пользователя: ") password = input("Введите пароль: ") session = vk.AuthSession(app_id='5889724', user_login=login, user_password=password) api = vk.API(session) #Вычисление количества друзей текущего пользователя friends =api.friends.get(count='') friends_list =table_service.query_entities('MyVkApp', filter="PartitionKey eq 'my_friends1'") k =1 for friend in friends_list: try: friends =api.friends.get(user_id=friend.user_id, count='') friends_count =len(friends) except: friends_count =0 try: groups =api.groups.get(user_id=friend.user_id, count='') groups_count =len(groups) except: groups_count =0
coffee.flavor = 'Dirt' coffee.sizecup = 'Large' coffee.pricecup = 1000.00 table_service.insert_entity('itemstable', coffee) print('Created entry for Large Dirt Flavored Starbucks...\n') time.sleep(1) ### # Use the Azure Storage Storage SDK for Python to query for entities in our Table ### print('With some data in our Azure Storage Table, we can query the data.\nLet\'s see what the car menu looks like.') raw_input('Press Enter to continue...') # In this query, you define the partition key to search within, and then which properties to retrieve # Structuring queries like this improves performance as your application scales up and keeps the queries efficient items = table_service.query_entities('itemstable', filter="PartitionKey eq 'cars'", select='description,cost') for item in items: print('Name: ' + item.description) print('Cost: ' + str(item.cost) + '\n') items = table_service.query_entities('itemstable', filter="PartitionKey eq 'coffeeshop'", select='description,price') for item in items: print('Name: ' + item.description) print('Price: ' + str(item.price) + '\n') time.sleep(1) ### # This was a quick demo to see Tables in action. # Although the actual cost is minimal (fractions of a cent per month) for the three entities we created, it's good to clean up resources when you're done
table_service.insert_entity('htangitemstable', coffee) print('Created entry for Nescafe...\n') time.sleep(1) ### # Use the Azure Storage Storage SDK for Python to query for entities in our Table ### print( 'With some data in our Azure Storage Table, we can query the data.\nLet\'s see what the car selection looks like.' ) input('Press Enter to continue...') # In this query, you define the partition key to search within, and then which properties to retrieve # Structuring queries like this improves performance as your application scales up and keeps the queries efficient items = table_service.query_entities('htangitemstable', filter="PartitionKey eq 'car_selections'", select='make,model,year,color,price') for item in items: print('Make: ' + item.make) print('Model: ' + item.model) print('Year: ' + str(item.year) + '\n') print('Color: ' + item.color) print('Price: ' + str(item.price) + '\n') items = table_service.query_entities('htangitemstable', filter="PartitionKey eq 'coffeemenu'", select='brand,flavor,size,price') for item in items: print('Brand: ' + item.brand) print('Flavor: ' + item.flavor) print('Size: ' + item.size)
table_service.insert_entity('itemstable', coffee) print('Created entry for Columbia...\n') time.sleep(1) ### # Use the Azure Storage Storage SDK for Python to query for entities in our Table ### print( 'With some data in our Azure Storage Table, we can query the data.\nLet\'s see what the car list looks like.' ) raw_input('Press Enter to continue...') # In this query, you define the partition key to search within, and then which properties to retrieve # Structuring queries like this improves performance as your application scales up and keeps the queries efficient items = table_service.query_entities('itemstable', filter="PartitionKey eq 'carlist'", select='make,model,year,color,price') for item in items: print('Make: ' + item.make) print('Model: ' + item.model) print('Year: ' + item.year) print('Color: ' + item.color) print('Price: ' + str(item.price) + '\n') items = table_service.query_entities('itemstable', filter="PartitionKey eq 'coffeeinv'", select='brand,flavor,size,price') for item in items: print('Brand: ' + item.brand) print('Flavor: ' + item.flavor) print('Size: ' + item.size)
class ReadAzureTable(object): def __init__(self): self.table_service = TableService(account_name=tc.account_name, account_key=tc.account_key, endpoint_suffix=tc.endpoint_suffix) self.PT_azuretable = 5 # self.station = pd.read_csv('station.csv') # self.deviceType = pd.read_csv('deviceType.csv') # self.deviceMode = pd.read_csv('deviceMode.csv') def readData(self, deviceCode, deviceModeCode, startTime, endTime): ''' deviceCode='350M202M4M2' #需要访问的设备编号 ''' sTime = parser.parse(startTime) eTime = parser.parse(endTime) # print (startTime) # print (endTime) print(type(eTime)) print((sTime)) sRowKey = mathtool.TimetoStamp(sTime) #用来把时间转换为TimeStamp eRowKey = mathtool.TimetoStamp(eTime) # print (sRowKey) # print (eRowKey) if sTime.month == eTime.month: azureTableNameSuffix = 'T' + sTime.strftime('%Y%m') + 'PT' + str( self.PT_azuretable) + 'S' filter_string = 'PartitionKey eq ' + '\'' + str( deviceCode) + '\'' + ' and RowKey ge ' + '\'' + str( sRowKey) + '\'' + ' and RowKey le ' + '\'' + str( eRowKey) + '\'' tableName = 'S' + str(deviceModeCode) + azureTableNameSuffix distinguish_hlx = deviceModeCode.split('M')[1] selectStr = 'HL101,HL102,HL107,s' print(tableName) try: if distinguish_hlx == '202': tasks = self.table_service.query_entities(tableName, filter_string, select=selectStr) else: tasks = self.table_service.query_entities( tableName, filter_string) rows_list = [] for item in tasks: rows_list.append(item) df = pd.DataFrame(rows_list) return df except: print('cannot find the specific table:%s' % tableName) return None else: azureTableNameSuffix1 = 'T' + sTime.strftime('%Y%m') + 'PT' + str( self.PT_azuretable) + 'S' azureTableNameSuffix2 = 'T' + eTime.strftime('%Y%m') + 'PT' + str( self.PT_azuretable) + 'S' filter_string = 'PartitionKey eq ' + '\'' + str( deviceCode) + '\'' + ' and RowKey ge ' + '\'' + str( sRowKey) + '\'' + ' and RowKey le ' + '\'' + str( eRowKey) + '\'' tableName1 = 'S' + str(deviceModeCode) + azureTableNameSuffix1 tableName2 = 'S' + str(deviceModeCode) + azureTableNameSuffix2 distinguish_hlx = deviceModeCode.split('M')[1] selectStr = 'HL101,HL102,HL107,s' try: if distinguish_hlx == '202': tasks1 = self.table_service.query_entities( tableName1, filter_string, select=selectStr) tasks2 = self.table_service.query_entities( tableName2, filter_string, select=selectStr) else: tasks1 = self.table_service.query_entities( tableName1, filter_string) tasks2 = self.table_service.query_entities( tableName2, filter_string) rows_list = [] for item1 in tasks1: rows_list.append(item1) for item2 in tasks2: rows_list.append(item2) df = pd.DataFrame(rows_list) return df except: print('cannot find the specific table:%s or %s' % (tableName1, tableName2)) return None def BaseInformation(self): pass
# DEVICE_COUNT = int(os.environ['IotDeviceCount']) IOT_HUB_NAME = 'iothub-w74e5yvuyvfs2' IOT_HUB_OWNER_KEY = 'Pl839QpYfaiBMbbOt8RxbrLk2RvOpuy+z+aSsecr+28=' IOT_HUB_DEVICE_KEY = '1n7jyr+tccLWN1FYgOBh9PAhEiZ0RDg1EGmpxo50o4w=' ACCOUNT_NAME = "stgw74e5yvuyvfs2" ACCOUNT_KEY = "CKXt/8SpgY6JHfVwBQUkwBCDeBKyJzQV10sgut3L4dS/bjKlSxQsPedHkrI7td8I0NBWJoQOSkcChGo1MIf9Cw==" table_service = TableService(account_name=ACCOUNT_NAME, account_key=ACCOUNT_KEY) connectionString = 'HostName=%s.azure-devices.net;SharedAccessKeyName=iothubowner;SharedAccessKey=%s' % ( IOT_HUB_NAME, IOT_HUB_OWNER_KEY) assets = table_service.query_entities('equipment') dm = DeviceManager(connectionString) for asset in assets: deviceId = asset.RowKey dm.createDeviceId(deviceId) print(dm.retrieveDeviceId(deviceId)) print(dm.listDeviceIds()) connectionString = 'HostName=%s.azure-devices.net;SharedAccessKeyName=device;SharedAccessKey=%s' % ( IOT_HUB_NAME, IOT_HUB_DEVICE_KEY) sender = D2CMessageSender(connectionString)