def main_debug(displaying): video_file = os.path.join(os.path.dirname(__file__), "video/staircase.mp4") vid_stream = VideoStream(video_file, interval=0.03) vid_stream.start() if debug: import ptvsd ptvsd.enable_attach(('0.0.0.0', 56781)) ptvsd.wait_for_attach() ptvsd.break_into_debugger() while True: _, frame = vid_stream.get_frame_with_id() detections = detector.detect(frame) #logging.info(detections) if not displaying: logging.info(detections) continue frame = display(frame, detections) # # check to see if the output frame should be displayed to our # # screen cv2.imshow("Frame", frame) key = cv2.waitKey(1) & 0xFF if key == ord('q') or key == 27: break cv2.destroyAllWindows()
def _bp(wait=True): if not ptvsd.is_attached(): if _attach(wait): ptvsd.break_into_debugger() else: if need_to_debug(): ptvsd.break_into_debugger()
def code_to_debug(): import backchannel from dbgimporter import import_and_enable_debugger import_and_enable_debugger() import ptvsd ptvsd.break_into_debugger() backchannel.write_json('done')
def code_to_debug(): # NOTE: These tests verify break_into_debugger for launch # and attach cases. For attach this is always after wait_for_attach from dbgimporter import import_and_enable_debugger import_and_enable_debugger() import ptvsd ptvsd.break_into_debugger() print('break here')
def code_to_debug(): from dbgimporter import import_and_enable_debugger import_and_enable_debugger() import ptvsd # Since Unicode variable name is a SyntaxError at parse time in Python 2, # this needs to do a roundabout way of setting it to avoid parse issues. globals()[u'\u16A0'] = 123 ptvsd.break_into_debugger() print('break')
def module_twin_callback(update_state, payload, user_context): global TEMPERATURE_THRESHOLD ptvsd.break_into_debugger() properties_obj = json.loads(payload) if DESIRED_PROPERTY_KEY in properties_obj: properties_obj = properties_obj[DESIRED_PROPERTY_KEY] if TEMP_THRESHOLD_PROPERTY_NAME in properties_obj: TEMPERATURE_THRESHOLD = properties_obj[TEMP_THRESHOLD_PROPERTY_NAME]
def main(): count = 0 while count < 50: print(count) time.sleep(0.1) if os.getenv('PTVSD_BREAK_INTO_DEBUGGER', None) is not None: ptvsd.break_into_debugger() count += 1 path = os.getenv('PTVSD_TARGET_FILE', None) if path is not None: with open(path, 'a') as f: print('HERE :)', file=f)
def start_app(): # set protocol to 1.1 so we keep the connection open WSGIRequestHandler.protocol_version = "HTTP/1.1" if debug: import ptvsd ptvsd.enable_attach(('0.0.0.0', 56781)) ptvsd.wait_for_attach() ptvsd.break_into_debugger() app.run(debug=False, host="detector", port=5010)
def main(): if loopy: count = 0 while count < 50: print('one') ptvsd.break_into_debugger() time.sleep(0.1) print('two') count += 1 else: print('one') ptvsd.break_into_debugger() print('two')
def code_to_debug(): import time import ptvsd import backchannel from dbgimporter import import_and_enable_debugger import_and_enable_debugger() ptvsd.break_into_debugger() print('first') backchannel.write_json('continued') for _ in range(0, 20): time.sleep(0.1) ptvsd.break_into_debugger() print('second')
def module_twin_callback(update_state, payload, user_context): ptvsd.break_into_debugger() global TWIN_CALLBACKS global TEMPERATURE_THRESHOLD print( "\nTwin callback called with:\nupdateStatus = %s\npayload = %s\ncontext = %s" % (update_state, payload, user_context)) data = json.loads(payload) if "desired" in data and "TemperatureThreshold" in data["desired"]: TEMPERATURE_THRESHOLD = data["desired"]["TemperatureThreshold"] if "TemperatureThreshold" in data: TEMPERATURE_THRESHOLD = data["TemperatureThreshold"] TWIN_CALLBACKS += 1 print("Total calls confirmed: %d\n" % TWIN_CALLBACKS)
def main(): count = 0 while count < 50: if os.getenv('PTVSD_WAIT_FOR_ATTACH', None) is not None: print('waiting for attach') ptvsd.wait_for_attach() elif os.getenv('PTVSD_IS_ATTACHED', None) is not None: print('checking is attached') while not ptvsd.is_attached(): time.sleep(0.1) else: pass print('one') ptvsd.break_into_debugger() time.sleep(0.5) print('two') count += 1
def SelectPair(self, algorithm, date): '''Selects the pair (two stocks) with the highest alpha''' dictionary = dict() ptvsd.break_into_debugger() benchmark = self._getReturns(algorithm, self.benchmark) ones = np.ones(len(benchmark)) for symbol in self.symbols: prices = self._getReturns(algorithm, symbol) if prices is None: continue A = np.vstack([prices, ones]).T # Calculate the Least-Square fitting to the returns of a given symbol and the benchmark ols = np.linalg.lstsq(A, benchmark)[0] dictionary[symbol] = ols[1] # Returns the top 2 highest alphas orderedDictionary = sorted(dictionary.items(), key= lambda x: x[1], reverse=True) return [x[0] for x in orderedDictionary[:2]]
def receive_message_callback(message, hubManager): ptvsd.break_into_debugger() global RECEIVE_CALLBACKS global TEMPERATURE_THRESHOLD message_buffer = message.get_bytearray() size = len(message_buffer) message_text = message_buffer[:size].decode('utf-8') print(" Data: <<<%s>>> & Size=%d" % (message_text, size)) map_properties = message.properties() key_value_pair = map_properties.get_internals() print(" Properties: %s" % key_value_pair) RECEIVE_CALLBACKS += 1 print(" Total calls received: %d" % RECEIVE_CALLBACKS) data = json.loads(message_text) if "machine" in data and "temperature" in data["machine"] and data[ "machine"]["temperature"] > TEMPERATURE_THRESHOLD: map_properties.add("MessageType", "Alert") print("Machine temperature %s exceeds threshold %s" % (data["machine"]["temperature"], TEMPERATURE_THRESHOLD)) hubManager.forward_event_to_output("output1", message, 0) return IoTHubMessageDispositionResult.ACCEPTED
def main(): """Run administrative tasks.""" os.environ.setdefault("DJANGO_SETTINGS_MODULE", "djangotest.settings") from django.conf import settings if settings.DEBUG: import ptvsd ptvsd.enable_attach(address=("0.0.0.0", 5678)) ptvsd.wait_for_attach() ptvsd.break_into_debugger() print("Debugger Attached!") try: from django.core.management import execute_from_command_line except ImportError as exc: raise ImportError( "Couldn't import Django. Are you sure it's installed and " "available on your PYTHONPATH environment variable? Did you " "forget to activate a virtual environment?") from exc execute_from_command_line(sys.argv)
def main(protocol): try: ptvsd.break_into_debugger() print("\nPython %s\n" % sys.version) print("IoT Hub Client for Python") hub_manager = HubManager(protocol) print("Starting the IoT Hub Python sample using protocol %s..." % hub_manager.client_protocol) print( "The sample is now waiting for messages and will indefinitely. Press Ctrl-C to exit. " ) while True: time.sleep(1) except IoTHubError as iothub_error: print("Unexpected error %s from IoTHub" % iothub_error) return except KeyboardInterrupt: print("IoTHubModuleClient sample stopped")
def main( videoPath ="", verbose = False, videoWidth = 0, videoHeight = 0, fontScale = 1.0, inference = True, confidenceLevel = 0.8 ): global hubManager global videoCapture try: print("\nPython %s\n" % sys.version ) print("Yolo Capture Azure IoT Edge Module. Press Ctrl-C to exit." ) with VideoCapture(videoPath, verbose, videoWidth, videoHeight, fontScale, inference, confidenceLevel) as videoCapture: if __myDebug__: ptvsd.break_into_debugger() try: hubManager = HubManager(10000, IoTHubTransportProvider.MQTT, False) AppState.init(hubManager) except IoTHubError as iothub_error: print("Unexpected error %s from IoTHub" % iothub_error ) return videoCapture.start() except KeyboardInterrupt: print("Camera capture module stopped" )
def init(*argv, **kwargs): """Initialize code_aster as `DEBUT`/`POURSUITE` command does + command line options. If the code_aster study is embedded under another Python program, the "--slave" option may be useful to catch exceptions (even *TimeLimitError*) and **try** not to exit the Python interpreter. Arguments: argv (list): List of command line arguments. kwargs (dict): Keywords arguments passed to 'DEBUT'/'POURSUITE' + 'debug' same as -g/--debug, 'noargv' to ignore previously passed arguments. """ if kwargs.get('noargv'): ExecutionParameter().set_argv([]) kwargs.pop('noargv', None) if not ExecutionStarter.init(argv): return if kwargs.get('debug'): ExecutionParameter().enable(Options.Debug) kwargs.pop('debug', None) if kwargs.get('ptvsd') and HAS_PTVSD: print('Waiting for debugger attach...'), ptvsd.enable_attach(address=('127.0.0.1', kwargs['ptvsd'])) ptvsd.wait_for_attach() ptvsd.break_into_debugger() # add 10 hours for debugging tpmax = ExecutionParameter().get_option("tpmax") ExecutionParameter().set_option("tpmax", tpmax + 36000) kwargs.pop('ptvsd', None) if ExecutionStarter.params.option & Options.Continue: Restarter.run_with_argv(**kwargs) else: Starter.run_with_argv(**kwargs)
def init_aggregator(): ''' debug_flask - when set to True we don't instantiate iot edge ''' try: if args.debug: logging.info("Please attach a debugger to port 5678") import ptvsd ptvsd.enable_attach(('0.0.0.0', 5678)) ptvsd.wait_for_attach() ptvsd.break_into_debugger() logging.info("Starting up Counting Aggregator...") aggreg = IoTCountAggregator(COUNT_AGG_QUEUE, check_every=args.interval, no_iotedge=args.flask_debug) return aggreg except IoTHubError as iothub_error: print("Unexpected error %s from IoTHub" % iothub_error) return
def deal_post_data(self): try: ctype, pdict = cgi.parse_header(self.headers['Content-Type']) pdict['boundary'] = bytes(pdict['boundary'], "utf-8") pdict['CONTENT-LENGTH'] = int(self.headers['Content-Length']) if ctype == 'multipart/form-data': form = cgi.FieldStorage( fp=self.rfile, headers=self.headers, environ={'REQUEST_METHOD':'POST', 'CONTENT_TYPE':self.headers['Content-Type'], }) #self.logger.debug(type(form)) try: if isinstance(form.list, list): for v in form.list: bio = io.BytesIO() bio.write( v.file.read() ) self.jpegUpload_call(bio) elif isinstance(form.file, list): for record in form.file: bio = io.BytesIO() bio.write( record.file.read() ) self.jpegUpload_call(bio) else: bio = io.BytesIO() bio.write( form.file.read() ) self.jpegUpload_call(bio) except IOError: self.logger.exception("Fehler beim download der daten!") return (False, "IOError") self.jpegUpload_call(None) return (True, "Files uploaded") except: self.logger.exception("Fehler beim verarbeiten der Lerndaten") try: import ptvsd ptvsd.break_into_debugger() except: pass return (False, "General Error")
class ActionModule(ActionBase): """ This is an Ansible Action, that combines the following modules: 1. template 2. script After script execution, it checks the returncode for the action status: RC=0 -> ok RC=-1 -> changed other -> failed Example: wd_script: src: scripttemplate.sh dest: ~/targetfile.sh """ import ptvsd ptvsd.enable_attach(address=('127.0.0.1', 3000)) ptvsd.wait_for_attach() ptvsd.break_into_debugger() # https://www.ansible.com/blog/how-to-extend-ansible-through-plugins # https://docs.ansible.com/ansible/latest/modules/shell_module.html#shell-module def run(self, tmp=None, task_vars=None): result = super(ActionModule, self).run(tmp, task_vars) dest = self._task.args['dest'] src = self._task.args['src'] args_template = dict() args_template["dest"] = dest args_template["src"] = src res_template = self._execute_module(module_name='template', module_args=args_template, task_vars=task_vars, tmp=tmp) return res_template
import os import ptvsd import json import regex import pprint from pyknp import KNP ptvsd.enable_attach(address=("0.0.0.0", 3000)) ptvsd.wait_for_attach() ptvsd.break_into_debugger() knp = KNP() # Default is JUMAN++. If you use JUMAN, use KNP(jumanpp=False) file_name = "feedbacksheet.json" if os.path.exists(file_name): os.remove(file_name) dependency_dic = {} for index in range(2, 22): index_json = {} feature_json = {} with open("data/{}.json".format(index), "r") as f: json_data = json.load(f) history = json_data.pop("history").strip("[]") history_list = regex.findall("{(?>[^{}]+|(?R))*}", history) comment_2d_list = [] for history_str in history_list:
def wait_and_break_deco(*args, **kwargs): ptvsd.enable_attach(self.secret, address=self.address) ptvsd.wait_for_attach() ptvsd.break_into_debugger() return function(*args, **kwargs)
def runInference(self, frame, frameW, frameH, confidenceLevel): try: countsByClassId = {} boxes = [] yoloDetections = [] frame_small = cv2.resize(frame, (416, 416)) detections = darknet.detect(darknet.netMain, darknet.metaMain, frame_small, confidenceLevel) boundingBoxes = np.array( list((item[2][0], item[2][1], item[2][0] + item[2][2], item[2][1] + item[2][3]) for item in detections[:])) idxs = self.__non_max_suppression_fast(boundingBoxes, 0.3) reducedDetections = [detections[idx] for idx in idxs] for detection in reducedDetections: classID = str(detection[0], encoding) confidence = detection[1] if confidence > confidenceLevel: if classID not in countsByClassId: countsByClassId[classID] = 1 else: countsByClassId[classID] = countsByClassId[classID] + 1 bounds = detection[2] * np.array([ frameW / 416, frameH / 416, frameW / 416, frameH / 416 ]) width = int(bounds[2]) height = int(bounds[3]) # Coordinates are around the center xCoord = int(bounds[0] - bounds[2] / 2) yCoord = int(bounds[1] - bounds[3] / 2) # std: obsolete, if working with tracker box = [xCoord, yCoord, xCoord + width, yCoord + height] boxes.append(box) yoloDetections.append( YoloDetection(box, classID, confidence)) # draw detection into frame tagged with class id an confidence #self.__draw_rect(frame, classID, confidence, xCoord, yCoord, xCoord + width, yCoord + height) if False and __myDebug__: if detections is not None and len(detections) > 1: ptvsd.break_into_debugger() else: return yoloDetections #if len(countsByClassId) > 0 and (datetime.now() - self.lastMessageSentTime).total_seconds() >= 1: # strMessage = json.dumps(countsByClassId) # message = IoTHubMessage(strMessage) # print(strMessage) # AppState.HubManager.send_event_to_output("output1", message, 0) # self.lastMessageSentTime = datetime.now() except Exception as e: print("Exception during AI Inference") print(e) return yoloDetections
def main(args): parser = argparse.ArgumentParser() if sys_name == "Linux": parser.add_argument("--device", help="BDF of tg3 PCI device", default=None) parser.add_argument("--devid", help="id of tg3 PCI device", default=None) parser.add_argument("-p", "--ptvsd", help="enable ptvsd server", action="store_true") parser.add_argument("--ptvsdpass", help="ptvsd server password", default=None) parser.add_argument("-t", "--tests", help="run tests", action="store_true") parser.add_argument("-s", "--shell", help="ipython cli", action="store_true") parser.add_argument("-b", "--backup", help="create eeprom backup", action="store_true", default=False) parser.add_argument("-d", "--driver", help="load userspace tap driver", action="store_true") parser.add_argument("-i", "--install", help="install thundergate firmware", action="store_true") parser.add_argument("--wait", help="wait for debugger attachment at startup", action="store_true") parser.add_argument("--cdpserver", help="launch VS Code debug protocol server", action="store_true") parser.add_argument("-g", "--gui", help="launch wxpython gui", action="store_true") args = parser.parse_args(args=args[1:]) if args.cdpserver: conout = sys.stdout conin = sys.stdin sys.stdin = open(os.devnull, "r") sys.stdout = open("cdp.%d.log" % os.getpid(), "w") banner() ima = "inspector" try: if args.driver: ima = "userspace driver" except: pass logger.info("tg3 %s initializing" % ima) logger.debug("process id is %d" % os.getpid()) if args.ptvsd: import ptvsd ptvsd.enable_attach(secret=args.ptvsdpass) if args.wait: logger.info("waiting for ptvsd client...") ptvsd.wait_for_attach() logger.info("ptvsd client attached!") ptvsd.break_into_debugger() else: logger.info("ptvsd server enabled") elif args.wait: print "[!] press 'enter' to continue..." raw_input() if sys_name == 'Linux': if args.device is None: devid = args.devid if devid is None: devid = "14e4:1682" dbdf = subprocess.check_output(["lspci", "-d %s" % devid, "-n"]).split(" ")[0].strip() if '' == dbdf: logger.error("tigon3 device not found") return 1 else: dbdf = args.device if len(dbdf.split(':')) == 2: dbdf = "0000:%s" % dbdf if not os.path.exists("/sys/bus/pci/devices/%s/" % dbdf): logger.error( "device resources at /sys/bus/pci/devices/%s/ not found; " + "is sysfs mounted?", dbdf) return 1 try: kmod = os.readlink("/sys/bus/pci/devices/%s/driver" % dbdf).split('/')[-1] except: kmod = '' if kmod == 'vfio-pci': dev_interface = VfioInterface(dbdf) elif kmod == 'uio_pci_generic': dev_interface = UioInterface(dbdf) else: dev_interface = SysfsInterface(dbdf) if kmod == 'tg3' and args.driver: logger.error("device is currently bound to tg3; this won't work") return 1 elif sys_name == 'Windows' or sys_name == 'cli': try: dev_interface = WinInterface() except: dev_interface = None if not args.backup: if not os.path.exists("eeprom.bak"): logger.warn("no backup image found") if not args.cdpserver: resp = raw_input( "\n\n" + "would you like to create a backup image (y/n): ") if resp[0] in "yY": args.backup = True with Device(dev_interface) as dev: if args.backup: dev.nvram.init() dev.nvram.dump_eeprom("eeprom.bak") logger.info("eeprom backup saved as 'eeprom.bak'") if args.install: from tginstall import TgInstaller with TgInstaller(dev) as i: return i.run() elif args.shell: from shelldrv import ShellDriver with ShellDriver(dev) as shell: if args.tests: from testdrv import TestDriver with TestDriver(dev) as test: test.run() return shell.run(loc=locals()) else: return shell.run(loc=locals()) elif args.cdpserver: from cdpserver import CDPServer with CDPServer(dev, conin, conout) as server: return server.run() elif args.gui: import gui dev.reset(cold=True) gui._run(dev) else: if args.driver: import tap return tap.run(dev) elif args.tests: from testdrv import TestDriver with TestDriver(dev) as test: return test.run()
def main(args): parser = argparse.ArgumentParser() if sys_name == "Linux": parser.add_argument("--device", help="BDF of tg3 PCI device", default=None) parser.add_argument("--devid", help="id of tg3 PCI device", default=None) parser.add_argument("-p", "--ptvsd", help="enable ptvsd server", action="store_true") parser.add_argument("--ptvsdpass", help="ptvsd server password", default=None) parser.add_argument("-t", "--tests", help="run tests", action="store_true") parser.add_argument("-s", "--shell", help="ipython cli", action="store_true") parser.add_argument("-b", "--backup", help="create eeprom backup", action="store_true", default=False) parser.add_argument("-d", "--driver", help="load userspace tap driver", action="store_true") parser.add_argument("-i", "--install", help="install thundergate firmware", action="store_true") parser.add_argument("--wait", help="wait for debugger attachment at startup", action="store_true") parser.add_argument("--cdpserver", help="launch VS Code debug protocol server", action="store_true") parser.add_argument("-g", "--gui", help="launch wxpython gui", action="store_true") args = parser.parse_args(args=args[1:]) if args.cdpserver: conout = sys.stdout conin = sys.stdin sys.stdin = open(os.devnull, "r") sys.stdout = open("cdp.%d.log" % os.getpid(), "w") banner() ima = "inspector" try: if args.driver: ima = "userspace driver" except: pass logger.info("tg3 %s initializing" % ima) logger.debug("process id is %d" % os.getpid()) if args.ptvsd: import ptvsd ptvsd.enable_attach(secret=args.ptvsdpass) if args.wait: logger.info("waiting for ptvsd client...") ptvsd.wait_for_attach() logger.info("ptvsd client attached!") ptvsd.break_into_debugger() else: logger.info("ptvsd server enabled") elif args.wait: print "[!] press 'enter' to continue..." raw_input() if sys_name == 'Linux': if args.device is None: devid = args.devid if devid is None: devid = "14e4:1682" dbdf = subprocess.check_output(["lspci", "-d %s" % devid, "-n"]).split(" ")[0].strip() if '' == dbdf: logger.error("tigon3 device not found") return 1 else: dbdf = args.device if len(dbdf.split(':')) == 2: dbdf = "0000:%s" % dbdf if not os.path.exists("/sys/bus/pci/devices/%s/" % dbdf): logger.error( "device resources at /sys/bus/pci/devices/%s/ not found; " + "is sysfs mounted?", dbdf) return 1 try: kmod = os.readlink("/sys/bus/pci/devices/%s/driver" % dbdf).split('/')[-1] except: kmod = '' if kmod == 'vfio-pci': dev_interface = VfioInterface(dbdf) elif kmod == 'uio_pci_generic': dev_interface = UioInterface(dbdf) else: dev_interface = SysfsInterface(dbdf) if kmod == 'tg3' and args.driver: logger.error("device is currently bound to tg3; this won't work") return 1 elif sys_name == 'Windows' or sys_name == 'cli': try: dev_interface = WinInterface() except: dev_interface = None if not args.backup: if not os.path.exists("eeprom.bak"): logger.warn("no backup image found") if not args.cdpserver: resp = raw_input("\n\n" + "would you like to create a backup image (y/n): ") if resp[0] in "yY": args.backup = True with Device(dev_interface) as dev: if args.backup: dev.nvram.init() dev.nvram.dump_eeprom("eeprom.bak") logger.info("eeprom backup saved as 'eeprom.bak'") if args.install: from tginstall import TgInstaller with TgInstaller(dev) as i: return i.run() elif args.shell: from shelldrv import ShellDriver with ShellDriver(dev) as shell: if args.tests: from testdrv import TestDriver with TestDriver(dev) as test: test.run() return shell.run(loc=locals()) else: return shell.run(loc=locals()) elif args.cdpserver: from cdpserver import CDPServer with CDPServer(dev, conin, conout) as server: return server.run() elif args.gui: import gui dev.reset(cold = True) gui._run(dev) else: if args.driver: import tap return tap.run(dev) elif args.tests: from testdrv import TestDriver with TestDriver(dev) as test: return test.run()
def ptvsd_breakpointhook(): ptvsd.break_into_debugger()
import sys import ptvsd if len(sys.argv) > 1: open(sys.argv[1], 'w').close() i = 0 while True: if ptvsd.is_attached(): ptvsd.break_into_debugger() if i is None: break i += 1
def ptvsd_breakpointhook(): ptvsd.break_into_debugger()
def Initialize(self): self.SetStartDate(2019, 4, 30) # Set Start Date self.SetEndDate(2019, 5, 1) # Set End Date self.SetCash(100000) # Set Strategy Cash #self.AddEquity("SPY") self.symbol = "BTCUSD" #self.AddEquity(self.symbol, Resolution.Minute).Symbol self.AddCrypto(self.symbol, Resolution.Minute, Market.Bitfinex).Symbol span = 500 longPeriod = 43200 ema = self.EMA(self.symbol, span) ptvsd.break_into_debugger() price = Identity(self.symbol) ptvsd.break_into_debugger() self.diff_pct_close_ema = IndicatorExtensions.Over( IndicatorExtensions.Minus(price, ema), ema) ptvsd.break_into_debugger() self.diff_pct_close_ema_mean = IndicatorExtensions.SMA( self.diff_pct_close_ema, longPeriod) ptvsd.break_into_debugger() std = self.STD(self.symbol, longPeriod) diff_pct_close_ema_std = IndicatorExtensions.Of( self.diff_pct_close_ema, std) self.negative_abnormal = IndicatorExtensions.Minus( self.diff_pct_close_ema_mean, IndicatorExtensions.Times(diff_pct_close_ema_std, 1.96)) self.positive_abnormal = IndicatorExtensions.Plus( self.diff_pct_close_ema_mean, IndicatorExtensions.Times(diff_pct_close_ema_std, 1.96)) self.RegisterIndicator(self.symbol, self.diff_pct_close_ema, Resolution.Minute) self.RegisterIndicator(self.symbol, diff_pct_close_ema_std, Resolution.Minute) self.RegisterIndicator(self.symbol, self.diff_pct_close_ema_mean, Resolution.Minute) self.RegisterIndicator(self.symbol, self.negative_abnormal, Resolution.Minute) self.RegisterIndicator(self.symbol, self.positive_abnormal, Resolution.Minute) self.SetWarmUp(longPeriod) #stockPlot = Chart("Trade Plot") # On the Trade Plotter Chart we want 2 series: trades : #stockPlot.AddSeries(Series("Buy", SeriesType.Scatter, 0)) #stockPlot.AddSeries(Series("Sell", SeriesType.Scatter, 0)) #stockPlot.AddSeries(Series("Close", SeriesType.Scatter, 0)) #self.AddChart(stockPlot) # On the Deviation Chart we want serie, diff_pct_close_vs_ema #deviation = Chart("Deviation Degree") #deviation.AddSeries(Series("Deviation Degree", SeriesType.Line, 0)) #self.AddChart(deviation) self.resamplePeriod = (self.EndDate - self.StartDate) / 4000 self.AddAlpha( EmaReversionAlphaModel(self.symbol, self.diff_pct_close_ema, self.negative_abnormal, self.positive_abnormal, self.diff_pct_close_ema_mean, self.resamplePeriod)) self.SetPortfolioConstruction( EqualWeightingPortfolioConstructionModel()) self.SetRiskManagement(MaximumDrawdownPercentPortfolio(0.1)) self.SetExecution(VolumeWeightedAveragePriceExecutionModel())
def Update(self, algorithm, data): insights = [] PositiveAbnormalIsOverDiff_pct_close_ema = False Diff_pct_close_emaIsOverNegativeAbnormal = False Diff_pct_close_emaIsOverMean = False MeanIsOverDiff_pct_close_ema = False #longPeriod_index = 0 if not data.ContainsKey(self.symbol): return #if not data.ContainsKey('SPY'): return #if self.ema.Current.Value == 0: return #diff_pct_close_ema = (algorithm.Securities[self.symbol].Price - self.ema.Current.Value) / self.ema.Current.Value #longPeriod_index += 1 #diff_pct_close_ema_sum += diff_pct_close_ema #diff_pct_close_ema_list.append(diff_pct_close_ema) #if longPeriod_index == longPeriod: # diff_pct_close_ema_mean = diff_pct_close_ema_sum / longPeriod_index # diff_pct_close_ema_std = statistics.stdev(diff_pct_close_ema_list) # negative_abnormal = diff_pct_close_ema_mean - 1.96 * diff_pct_close_ema_std #positive_abnormal = diff_pct_close_ema_mean + 1.96 * diff_pct_close_ema_std #longPeriod_index = 0 #diff_pct_close_ema_sum = 0 #diff_pct_close_ema_list = [] if not self.positive_abnormal.IsReady: return ptvsd.break_into_debugger() if not algorithm.Portfolio.Invested and PositiveAbnormalIsOverDiff_pct_close_ema and self.diff_pct_close_ema > self.positive_abnormal: insights.append( Insight.Price(self.symbol, Resolution.Minute, 1, InsightDirection.Down)) algorithm.Plot("Trade Plot", "Short", data[self.symbol].Price) elif not algorithm.Portfolio.Invested and Diff_pct_close_emaIsOverNegativeAbnormal and self.diff_pct_close_ema < self.negative_abnormal: insights.append( Insight.Price(self.symbol, Resolution.Minute, 1, InsightDirection.Up)) algorithm.Plot("Trade Plot", "Long", data[self.symbol].Price) elif algorithm.Portfolio[ self. symbol].IsShort and Diff_pct_close_emaIsOverMean and self.diff_pct_close_ema < self.diff_pct_close_ema_mean: insights.append( Insight.Price(self.symbol, Resolution.Minute, 1, InsightDirection.Flat)) algorithm.Plot("Trade Plot", "Close", data[self.symbol].Price) elif algorithm.Portfolio[ self. symbol].IsLong and MeanIsOverDiff_pct_close_ema and self.diff_pct_close_ema > self.diff_pct_close_ema_mean: insights.append( Insight.Price(self.symbol, Resolution.Minute, 1, InsightDirection.Flat)) algorithm.Plot("Trade Plot", "Close", data[self.symbol].Price) PositiveAbnormalIsOverDiff_pct_close_ema = self.positive_abnormal > self.diff_pct_close_ema ptvsd.break_into_debugger() Diff_pct_close_emaIsOverNegativeAbnormal = self.diff_pct_close_ema > self.negative_abnormal Diff_pct_close_emaIsOverMean = self.diff_pct_close_ema > self.diff_pct_close_ema_mean ptvsd.break_into_debugger() MeanIsOverDiff_pct_close_ema = not Diff_pct_close_emaIsOverMean if algorithm.Time > self.resample: self.resample = algorithm.Time + self.resamplePeriod algorithm.PlotIndicator("Deviation Degree", self.diff_pct_close_ema) #if (diff_pct_close_ema > positive_abnormal) or (diff_pct_close_ema < negative_abnormal): # self.Plot('Deviation', 'BTCUSD', data[self.symbol].Price) # self.Plot('Deviation', 'EMA', ema.Current.Value) # self.Plot('Deviation Degree', 'diff_pct_close_vs_ema', diff_pct_close_ema) return insights
def main(): print('one') ptvsd.break_into_debugger() print('two')
def code_to_debug(): from debug_me import ptvsd ptvsd.break_into_debugger() print()