def main(): securities = [ Security(30, "$", RiskLevel.LOW, Trend.UP, 0, "Ukraine", "I"), Equity(20, "$", RiskLevel.MEDIUM, Trend.DOWN, 0, "Russia", "I", "Roshen", 0.5), Debt(10, "$", RiskLevel.HIGH, Trend.UP, 0, "Belarus", "I"), Derivative(0, "$", RiskLevel.DANGER, Trend.UP, 0, "Moldova", "I", "house"), Security(0, "$", RiskLevel.LOW, Trend.DOWN, 10, "Ukraine", "I") ] manager = SecuritiesManager(*securities) filteredList = manager.filterByPrice(0) for s in filteredList: print(s) print() sortedList = SecuritiesManager.sortByPriceAscending(securities) for s in sortedList: print(s) print() sortedFilteredList = SecuritiesManager.sortByDurationDescending( filteredList) for s in sortedFilteredList: print(s)
def main(): #setup my_ib = MyIb() Security.set_trading_exchange_information( exchange_info.trading_exchange_timezone, exchange_info.exchange_opening_time, exchange_info.exchange_normal_close_time, exchange_info.exchange_early_close_time, exchange_info.trading_holidays) #create security object my_security = Security(my_ib, symbol='GOOG', secType='STK', exchange='SMART') #Register callbacks my_ib.conn.register(error_handler, 'Error') my_ib.conn.register(my_security.save_historical_data, 'HistoricalData') my_ib.connect_to_ib_servers() #get SMA sma = my_security.get_historical_sma(length=150, barSizeSetting='1 day', ohlc='CLOSE', whatToShow='MIDPOINT', endDateTime='now') print("My SMA: {}".format(sma)) print(sma) my_ib.conn.disconnect()
def showSalePane(self, event): name = self.login.nameText.GetValue() user = Security(name, self.login.passText.GetValue()) connect = DatabaseConn() connect.cur().execute("UPDATE security SET state = 'off'") data = connect.cur().execute( "select name,password,status from security") if user.checkpass(data): if (user.getStatus() == 'admin'): connect.cur().execute( "UPDATE security SET state = 'on' WHERE name = '{name}'". format(name=name)) connect.commit() self.login.nameText.SetValue("") self.login.passText.SetValue("") self.window.Show(True) self.Hide() self.Layout() else: connect.cur().execute( "UPDATE security SET state = 'on' WHERE name = '{name}'". format(name=name)) connect.commit() self.login.nameText.SetValue("") self.login.passText.SetValue("") self.sales.Show() self.Hide() self.Layout() else: self.login.status.SetLabel("Incorrect Username or Password") connect.close()
def __init__(self, *args): import string apply(self._pre_init, args) Security.__init__(self) self._wf.flush() self._post_init()
def printme(self): Security.printme(self) try: print('K=%f, T=%s, t=%s, life=%d' % (self.strikeprice, self.expirydate.strftime('%Y-%m-%d'), self.listeddate.strftime('%Y-%m-%d'), self.lifedays)) except: print('--------------------error here--------------------')
def __init__(self, enabled: bool, expirationSeconds: int, blockAfterFailures: int): self.database = {} self.enabled = enabled self.expirationSeconds = expirationSeconds self.blockAfterFailures = blockAfterFailures self.logs = Logs(self.__class__.__name__) self.security = Security()
def __init__(self, _next_partition_name, _public_key=None, _debug=True): self.debug = _debug self.next_partition_name = _next_partition_name self.public_key = _public_key self.security = Security() self.uuid_project = '' self.version = 0 self.date_expiration = '' self.type = '' self.new = {}
def __init__(self, objectName): self.level = 'INFO' if "LOG_LEVEL" in environ: self.level = environ["LOG_LEVEL"] self.format = 'TEXT' if "LOG_FORMAT" in environ: self.format = environ["LOG_FORMAT"] self.objectName = objectName self.security = Security()
def __init__(self, *args): self._pre_init(*args) Security.__init__(self) self._wf.flush() line = self._rf.readline() challenge = int(line.strip()) response = self._encode_challenge(challenge) line = repr(int(response)) if line[-1] in 'Ll': line = line[:-1] self._wf.write(line + '\n') self._wf.flush() self._post_init()
def __init__(self, *args): import string apply(self._pre_init, args) Security.__init__(self) self._wf.flush() line = self._rf.readline() challenge = string.atoi(string.strip(line)) response = self._encode_challenge(challenge) line = repr(long(response)) if line[-1] in 'Ll': line = line[:-1] self._wf.write(line + '\n') self._wf.flush() self._post_init()
def update_securities(self, force_full_output=False, max_tries=6): priority = ['ALWAYS', 'FILL'] if len(self._watchlist.keys()) > 500: logger.warning( "Too many securities for API Request. Truncating to 500 oldest-updated reports" ) updated = [] for symbol in self._watchlist.keys(): if os.path.exists( os.path.join(Security.STOCK_DIR, f'{symbol}.json')): with open( os.path.join(Security.STOCK_DIR, f'{symbol}.json')) as f: updated.append({ "symbol": symbol, "updated_at": json.load(f)[-1]['date'], 'priority': self._watchlist[symbol]['update_priority'] }) else: updated.append({ "symbol": symbol, "updated_at": '1970-01-01', 'priority': self._watchlist[symbol]['update_priority'] }) updated = sorted(updated, key=lambda x: (priority.index(x['priority']), x['updated_at'])) securities = [u['symbol'] for u in updated][:500] logger.info(f"Collected securities list: {', '.join(securities)}") for symbol in securities: s = Security(symbol) failed = 0 request = 0 while request == 0 and failed < max_tries: if failed != 0: logger.warning( f"Failed {failed} out of {max_tries} times for {symbol}" ) request = s.update(force_full_output) failed += 1 if request == 0: logger.info("Waiting 12 seconds...") time.sleep(12)
def __init__(self, _uuid_project, _id_device, _version, _host_broker, \ _callback_on_receive_update, _private_key=None, _public_key=None, _delivery_type='Push', _debug=True): self.host_broker = _host_broker self.debug = _debug self.delivery_type = _delivery_type self.id_device = _id_device self.private_key = _private_key self.public_key = _public_key self.security = Security() self.message_incoming = bytes() self.do_decrypt = False self.aes_random_key = '' _id_on_broker = "FotaSuit-" + _uuid_project + "-" + self.id_device self.mqtt_client = MQTTClient(_id_on_broker, self.host_broker) self.mqtt_client.DEBUG = self.debug self.mqtt_client.set_callback(self.publish_received) self.update_file_size = 0 self.update_file_index = 0 self.update_file_handle = 0 self.memory = Memory(self.debug) _next_partition = self.memory.get_next_partition_name() self.callback_on_receive_update = _callback_on_receive_update if not (self.delivery_type == 'Push' or self.delivery_type == 'Pull'): raise ValueError("'type' variable not supported. Try 'Pull' or 'Push'.") while not self.connect_on_broker(True): self.print_debug("trying connection with broker...") time.sleep(3) self.manifest = Manifest(_next_partition, _public_key) self.manifest.load(_uuid_project, _version) files = os.listdir() if '_updated.iota' in files: #have an update ? # notify the upgrade _version = str(self.manifest.version) _msg = '{"idDevice":"'+self.id_device+'", "uuidProject":"'+_uuid_project+'"' _msg += ', "version":'+_version+', "date": ""}' #TODO: insert other informations in message like date self.publish_on_topic(_version, "updated", _msg) os.remove('_updated.iota') self.subscribe_task = "manifest" # waiting for manifest file self.print_debug("initialized.")
def getIndicador(): """ Endpoint that is to get data to render reports on platform """ authOk = True response = exception_response # Allow skipping authentication checks only if in debug mode if app.debug: sec = Security() authOk = sec.validate_access(request.authorization) else: print('\n Authentication checks skipped') if authOk: #return True try: response = [] reportfilter = request.json print("\n *************************") obj = MeuDesconto() ret_audiencia = obj.getIndicadores() resp = make_response(jsonify(ret_audiencia), 200) new_resp = json.loads(resp.data) response.append(new_resp) response = make_response(json.dumps(response)) response.headers[ 'Content-Type'] = 'application/json; charset=utf-8' except Exception as e: now = datetime.now() try: f = open("Logchamadas.log", "a") f.write("\n{0} - Erro: {1} - Parametros : {2}".format( now.strftime("%d/%m/%Y %H:%M:%S"), str(e), str(reportfilter))) f.close() except: pass exception_response['Razao'] = str(e) return make_response(jsonify(exception_response), 400) else: print("\n UNAUTHORIZED ACCESS") raise ValueError return response
def update_page(cell, content): """ update method """ cipher = Security('ec2cli') server, user, passwd, parent_id, page_id, title, response, region, product = config( cell) confluence = Confluence(url=server, username=user, password=cipher.decrypt(passwd)) confluence.update_page(parent_id=parent_id, page_id=page_id, title=title, body=content) return response
def post(cls): username = request.form['username'] password = request.form['password'] user = Security.authenticate(username, password) if user: login_user(user) jsonUser = cls.__getUser(user) if user.Role == 'Stud': if jsonUser['grade'] == 1: return make_response( render_template('StudentView.html', userInfo={'user': user.FName})) if jsonUser['grade'] == 4: return make_response( render_template('StudentViewGrade4.html', userInfo={'user': user.FName})) elif user.Role == "Prof": if jsonUser['grade'] == 1: return make_response( render_template('TeacherViewGrade1.html', userInfo={'user': user.FName})) if jsonUser['grade'] == 4: return make_response( render_template('professor4.html', userInfo={'user': user.FName})) elif user.Role == "Admin": return make_response( render_template('AdminView.html', userInfo=jsonify({'user': jsonUser}))) return make_response(render_template('login.html'))
def handler(event, context): # Get info on the cms' resources from the constants file with open("constants.json", "r") as resources_file: resources = json.loads(resources_file.read()) # Extract the request body request_body = event["body"] # Check that a request is included if "request" in request_body: request = request_body["request"] else: Error.send_error("noRequest") # Check that the request is supported if not supported_request(request): Error.send_error("unsupportedRequest", data={"request": request}) if "token" in event: user_token = remove_prefix(event["token"]) else: user_token = None """ Authenticate the request unless it is login, as login requires no authentication """ if request != "loginUser": # Check that a token is provided with the request if user_token == None: Error.send_error("noToken") # Check that the user has the necessary permissions to make the request user_info = Security.authenticate_and_authorize( user_token, request, resources["TOKEN_TABLE"], resources["USER_TABLE"], resources["ROLE_TABLE"] ) print user_info # Strip dynamo type identifiers from user info user_info = strip_dynamo_types(user_info) # Check if authentication or authorization returned an error if "error" in user_info: Error.send_error(authorized["error"], data=authorized["data"]) else: user_info = None # Process the request if not user_info == None: response = process_request(request_body, resources, request, user_info=user_info, token=user_token) else: response = process_request(request_body, resources, request) # Check if response returned an error if "error" in response: Error.send_error(response["error"], data=response["data"]) return strip_dynamo_types(response)
def __init__(self, login_name, password=None): super(XmlRpcLogin,self).__init__() self.set_app_server("xmlrpc") # If the tag <force_lowercase_login> is set to "true" # in the TACTIC config file, # then force the login string argument to be lowercase. # This tag is false by default. self.login_name = login_name if Config.get_value("security","force_lowercase_login") == "true": self.login_name = self.login_name.lower() self.password = password # clear the main container #Container.clear() Environment.set_env_object( self ) # set up the security object security = Security() Environment.set_security(security) self._do_login()
def tsla(self): tsla = Security('TSLA') price = tsla.get_price() self.prices.put(price) volume = tsla.security.get_volume() # if volume != self.volume: # print(volume) # self.volume = volume # else: # return # do things necessary for avg and stddev calc # self.price_sum = self.prices.sum() # self.price_sum_sq = self.prices.sum_sq() # self.count = len(self.prices) avg = self.prices.average() var = self.prices.variance() if price < avg * (1 - self.boundary): # low price, want to buy while portfolio.buy(tsla, 1): pass self.holding = True elif price > avg * (1 + self.boundary): # high price, want to sell_all portfolio.sell_all(tsla) self.holding = False print( f'Price: {price:.2f}\tAvg: {avg:.2f}\tvar: {var:.2f} <{time.asctime()}', end='\r')
def rsi_bollinger_report(self): df = pd.DataFrame() for w in self.list(): df_signals = Security(w).signals_rsi_bollinger() if df_signals is None: continue row = { 'security': w, 'last_date_overbought': df_signals[df_signals['signal'] == 'OVER-BOUGHT']['date'].max(), 'last_date_underbought': df_signals[df_signals['signal'] == 'UNDER-BOUGHT']['date'].max(), 'current_sma_price': df_signals[df_signals['date'].max() == df_signals['date']]['sma_price_20dy'].tolist()[0], 'current_price': df_signals[df_signals['date'].max() == df_signals['date']] ['close'].tolist()[0], 'last_updated': df_signals['date'].max() } df_new = pd.DataFrame.from_dict([row]) df = pd.concat([df, df_new]) return df.reset_index(drop=True)
def __init__(self, ticket, site=None): super(XmlRpcInit,self).__init__() if not site: # if not explicitly set, keep the current site site = Site.get_site() self.set_app_server("xmlrpc") self.ticket = ticket # clear the main container #Container.clear() Environment.set_env_object( self ) # set up the security object security = Security() Environment.set_security(security) if site: Site.set_site(site) self._do_login()
def add_security(*args): try: name, ticker, country, ir_website, currency = args except ValueError: print(f"{SYNTAX_INPUT_ERROR} Example: {Security.example_input()}") return db.insert_security(Security(" ".join(name.split("-")), ticker, country, ir_website, currency))
def dzh2DivRec(dzh_rec): """convert function""" stamp2date = datetime.datetime.fromtimestamp sec = Security(dzh_rec[0]) return [DivRec(sec, stamp2date(rec[0]).date(), rec[1], rec[4], rec[2], rec[3] ) for rec in dzh_rec[1]]
class XMLProcessorNotifier(smtpInterface): # adding encryption switch. emailed sensitive data must be encrypted. def __init__(self, docName, docs=[], encrypt=False): # turn on encryption switch if encrypt: self.encrypt = encrypt self.security = Security() self.mailSystem = smtpInterface(settings) if docName <> '': folderName = os.path.split(docName)[0] self.mailSystem.setRecipients(inputConfiguration.SMTPRECIPIENTS[folderName]) self.docName = docName else: if len(docs) > 0: # first file dictates where this is going, mostly files will be in the output location. try: folderName = os.path.split(docs[0])[0] self.mailSystem.setRecipients(inputConfiguration.SMTPRECIPIENTS[folderName]) except KeyError: raise def sendDocumentAttachment(self, Subject='Your Message Subject', Message='Message Body goes here.', attachment=None): self.mailSystem.setMessageSubject(Subject) self.mailSystem.setMessage(Message) self.mailSystem.formatMessage() for f in attachment: if self.encrypt: attachment = 'encryptdAttachment.enc' # FIXME encrypt the file before attaching. self.security.encryptFile(f, attachment) else: attachment = f print 'file: %s' % f self.mailSystem.setAttachmentText(attachment) try: self.sendMessage() except Exception, detail: if settings.DEBUG: print "problem sending notification", str(detail) return
def __init__(self, line): elts = map(elt_parser, line.rstrip().split("\t")) self.raw = raw = self.Raw(*elts) self.security = Security(raw.StockID, account2market(raw.Account), raw.StockName) self.fee = sum( (float(getattr(raw, 'Fee' + str(i))) for i in (1, 2, 3, 4))) self.quantity = float(raw.Quantity) self.date = dt.datetime.strptime(raw.Date[0:8], "%Y%m%d").date() self.amount = float(self.raw.Amount)
def __init__(self, project_code=None, login_code=None, site=None): self.set_app_server("batch") if not site: # if not explicitly set, keep the current site site = Site.get_site() plugin_dir = Environment.get_plugin_dir() if plugin_dir not in sys.path: sys.path.insert(0, plugin_dir) super(Batch,self).__init__() self.login_code = login_code # clear the main container Container.create() if site: Site.set_site(site) # set this as the environment if not project_code: self.context = self.get_default_context() else: self.context = project_code Environment.set_env_object( self ) # set up the security object security = Security() Environment.set_security(security) self._do_login() site_dir = Environment.get_site_dir() if site_dir not in sys.path: sys.path.insert(0, site_dir) # set the project from pyasm.biz import Project if self.context == "batch": Project.set_project("admin") else: Project.set_project(self.context) self.initialize_python_path() # start workflow engine #from pyasm.command import Workflow #Workflow().init() DbContainer.commit_thread_sql()
class Logs: def __init__(self, objectName): self.level = 'INFO' if "LOG_LEVEL" in environ: self.level = environ["LOG_LEVEL"] self.format = 'TEXT' if "LOG_FORMAT" in environ: self.format = environ["LOG_FORMAT"] self.objectName = objectName self.security = Security() def __print__(self, level, extraFields): fields = { 'date': datetime.now().strftime("%Y-%m-%d %H:%M:%S"), 'level': level, 'objectName': self.objectName, 'ip': self.security.getUserIP(), 'referrer': self.security.getUserReferrer() } # Include extra fields custom by the user fields.update(extraFields) if self.format == 'JSON': print(json.dumps(fields)) else: print(' - '.join(map(str, fields.values()))) def error(self, extraFields): if self.level in ['INFO', 'WARNING', 'ERROR']: self.__print__('ERROR', extraFields) def warning(self, extraFields): if self.level in ['INFO', 'WARNING']: self.__print__('WARNING', extraFields) def info(self, extraFields): if self.level in ['INFO']: self.__print__('INFO', extraFields)
def login(self): security = Security() security.decrypt_cred() # credentials = self.getCredential() scopes = [ 'https://www.googleapis.com/auth/spreadsheets', 'https://www.googleapis.com/auth/drive.file' ] global SERVICE_ACCOUNT if SERVICE_ACCOUNT: logging.info( f"SERVICE_ACCOUNT.auth.expired {SERVICE_ACCOUNT.auth.expired}") if SERVICE_ACCOUNT.auth.expired: SERVICE_ACCOUNT = gspread.service_account('./credentials.json', scopes=scopes) logging.info('Service Account successfully refreshed') return SERVICE_ACCOUNT else: SERVICE_ACCOUNT = gspread.service_account('./credentials.json', scopes=scopes) return SERVICE_ACCOUNT
def __init__(self, ticket=None): super(TacticInit,self).__init__() self.ticket = ticket # create the main container Container.create() Environment.set_env_object( self ) # set up the security object security = Security() Environment.set_security(security)
def __init__(self, pricePerUnit=0, currency="$", riskLevel=RiskLevel.LOW, trend=Trend.UP, duration=0, emitent="NoEmitent", owner="NoOwner", asset="NoAsset", security=Security()): super(Debt, self).__init__(pricePerUnit, currency, riskLevel, trend, duration, emitent, owner) self.asset = asset self.security = Security
def __init__(my, ticket): super(XmlRpcInit, my).__init__() my.set_app_server("xmlrpc") my.ticket = ticket # clear the main container #Container.clear() Environment.set_env_object(my) # set up the security object security = Security() Environment.set_security(security) my._do_login()
def onConnect(self, request): """ Called whenever a new client connects to our websocket. Is used for authenticating newly connected clients. """ # check if the user sent valid authentication attributes authenticated = Security.auth_status( request.headers, Config.get_user(), Config.get_password() ) if not authenticated: # deny connection raise HttpException(401, "Invalid authentication data.") else: print("Authenticated: {0}".format(request.peer)) self.factory.add_client(self)
def __init__(my, project_code=None, login_code=None, site=None): my.set_app_server("batch") plugin_dir = Environment.get_plugin_dir() if plugin_dir not in sys.path: sys.path.insert(0, plugin_dir) super(Batch, my).__init__() my.login_code = login_code # clear the main container Container.create() if site: Site.set_site(site) # set this as the environment if not project_code: my.context = my.get_default_context() else: my.context = project_code Environment.set_env_object(my) # set up the security object security = Security() Environment.set_security(security) my._do_login() site_dir = Environment.get_site_dir() if site_dir not in sys.path: sys.path.insert(0, site_dir) # set the project from pyasm.biz import Project if my.context == "batch": Project.set_project("admin") else: Project.set_project(my.context) my.initialize_python_path() DbContainer.commit_thread_sql()
def __init__(self, docName, docs=[], encrypt=False): # turn on encryption switch if encrypt: self.encrypt = encrypt self.security = Security() self.mailSystem = smtpInterface(settings) if docName <> '': folderName = os.path.split(docName)[0] self.mailSystem.setRecipients(inputConfiguration.SMTPRECIPIENTS[folderName]) self.docName = docName else: if len(docs) > 0: # first file dictates where this is going, mostly files will be in the output location. try: folderName = os.path.split(docs[0])[0] self.mailSystem.setRecipients(inputConfiguration.SMTPRECIPIENTS[folderName]) except KeyError: raise
def makeTrade(self, security, amount): if amount is 0: print("Entered trading amount of 0") return print("Trading " + str(amount) + " of " + security.securityName + " at price of " + str(security.price)) foundFlag = False if self.positions: for p in self.positions: if p.security.securityName == security.securityName: foundFlag = True newAveragePrice = self.calculateNewPositionAveragePrice(p.security, p.amount, security, amount) p.amount += amount p.security.price = newAveragePrice if p.amount is 0: self.positions.remove(p) if foundFlag == False: newSecurity = Security(security.securityName, security.securityType, security.price) self.positions.append(Position(newSecurity, amount)) self.cash -= (security.price * amount) self.calculatePortfolioValue() self.calculateTotalValue()
def __init__(self, *args): Server.__init__(self, *args) Security.__init__(self)
"""RPC Client module."""
def __init__(self, *args): apply(Server.__init__, (self,) + args) Security.__init__(self)
def printme(self): Security.printme(self) try: print('K=%f, T=%s, t=%s, life=%d' %(self.strikeprice, self.expirydate.strftime('%Y-%m-%d'), self.listeddate.strftime('%Y-%m-%d'),self.lifedays)) except: print('--------------------error here--------------------')
"""RPC Server module."""
ob_operations = Operations() print "Computing: Fibonacci" ob_operations.computeFibonacci(10) print "computing: Power of 2" ob_operations.computePower(128) except IOError: print "Exception: Too Many Files Open" except MemoryError: print "Exception: Memory Usage" except: print "Exception: ", sys.exc_info()[0] print "\nLoading Exploit Program\n" try: ob_security = Security() parser = argparse.ArgumentParser() parser.add_argument('--file', '-f') args = parser.parse_args() if args.file: if ob_security.filepath(args.file): print "check: file path: pass" if ob_security.fileSize(args.file): print "check: file size: pass" if ob_security.code(args.file): print "check: source code: pass" print "\nExploit Code Execution & Output" if ob_security.execute(args.file): print "\ncheck: code execute: pass"
from security import Security class MockML(object): def check_model(self, model): pass def check_input_params(self, model, input_params): pass def check_model_params(self, model, model_params): pass def check_components(self, model, components): pass def check_interm_params(self, model, interm_params, hidden_params): pass ml = MockML() s = Security(ml, 'foo', 'logger', 'out') inp = {'error_control': 'False'} print(s.team_arguments(inp))