def __init__(self, parent=None, id=-1, title='Title', pos=wx.DefaultPosition, size=wx.DefaultSize, style=wx.DEFAULT_FRAME_STYLE | wx.CLIP_CHILDREN): """Create a Frame instance. """ # Create the actual window (a wx Frame) self._wx = wx.Frame(parent, id, title, pos, size, style) self._keys = keys.Keys() self._keys.attach(self) # Set up the wx main menu bar self._menu_id_manager = idmanager.IDManager(10) menubar = wx.MenuBar() self._wx.SetMenuBar(menubar) self._menu = None self.CreateStatusBar() wx.EVT_LEFT_DOWN(self, self.onLeftDown) wx.EVT_LEFT_UP(self, self.onLeftUp) wx.EVT_MIDDLE_DOWN(self, self.onMiddleDown) wx.EVT_MIDDLE_UP(self, self.onMiddleUp) wx.EVT_RIGHT_DOWN(self, self.onRightDown) wx.EVT_RIGHT_UP(self, self.onRightUp)
def __init__( self, dataDir, fmt = "mp3" ): self.dataDir = dataDir self.rid = "%07i" %( time.time() % 10000000 ) self.keys = keys.Keys( self.dataDir, PROTOCOL_VERSION ) if not self.keys.loadKeys(): raise PandoraError("Unable to load keys") self.curFormat = fmt
def __init__(self, ui): self.ui = ui self.textwin = self.ui.textwin #typed commands self.commands = { 'add': self.add, 'delpl': self.delpl, 'export': self.export, 'export-all': self.export_all, 'find': self.find, 'newpl': self.newpl, 'playmode': self.playmode, 'renamepl': self.renamepl, 'sort': self.sort, 'update': self.update, 'update-single': self.update_single } self.err = Error_msg(self.ui, 2, self.ui.frame_time, self.textwin.print_blank, (1, )) self.find_list = None #handles input for typed commands self.keys = keys.Keys() #flag to decide if command is getting entered self.inp = False self.command_event = threading.Event() self.command_event.set()
def perform_actions(): key = keys.Keys() key.directKey("w") utils.press_key("x", key) while INDEX < len(points): utils.run_bot(CURRENT_POSITION, CURRENT_POINT, key) perform_additional_actions(game_data=CURRENT_POSITION, key=key) time.sleep(0.016) key.directKey("w", key.key_release)
def __init__(self): self.vnfid_timestamps = {} #rl_module = module() self.keys = keys.Keys() self.scale_up_message = { self.keys.flavor: "single", self.keys.volume: "small", self.keys.ns_id: "3ef4dfc2-ac73-4171-938f-4fddcce3fec3", self.keys.vnf_id: "34ae306c-2fba-45ef-97ed-bbf77ca5528e", self.keys.vnf_index: "2", self.keys.sampling_time: 5, self.keys.scale_decision: "scale_up" } self.start()
def main(try_count): # Initialize address generator k = keys.Keys() conn = sqlite3.connect('address.db') batch_size = 60 n = 0 while n < try_count: print('\nAttempt #{0} (Checked: {1})'.format(n + 1, batch_size * (n + 1))) try: address_search(k, conn, batch_size) except Exception as e: print('Encountered error: {}'.format(e)) n += 1
def __init__(self, charts, start_date="2018-10-13", stop_date='1958-01-01', backtrack=False, es=False, max_records=20, max_threads=3): """ :param charts: :param start_date: :param stop_date: :param backtrack: :param es: :param max_records: """ self.start_date = start_date self.stop_date = stop_date self.backtrack = backtrack self.use_es = es self.charts = charts self.max_records = max_records self.max_threads = max_threads self.chart_partition = [] for thread in range(self.max_threads): self.chart_partition.append([]) for num in range(len(self.charts)): self.chart_partition[num%self.max_threads].\ append(self.charts[num]) print("Chart Partitions", self.chart_partition) api_keys = keys.Keys() self.AZ = azlyrics.AZLyricsScraper() self.GS = genius.GeniusScraper( token=api_keys.genius_token ) self.SS = spotify.SpotifyScraper( client_id=api_keys.spotify_client_id, client_secret=api_keys.spotify_client_secret ) self.BB = billboards.BillboardScraper() self.WS = wikia.WikiaScraper() self.Proc = processing.LyricAnalyst() if self.use_es: self.ES = elasticsearchdb.ElasticSearch("song_data") self.records_processed = 0
def __init__(self, base_url, sdm_ip, sdm_port): self.monitoringtime = datetime.datetime.now() self.TAG = "VnfManager" self.load_balancer_docker_id = "haproxy" # it's the docker name of the load balancer self.haproxy_cfg_name = "haproxy.cfg" #its the configuration filename self.sdm_port = sdm_port # port of the scale decision module self.sdm_ip = sdm_ip # port of the scale decision module ip self.vnf_scale_module = VnfScaleModule() self.cadvisor_url = base_url.replace( "https", "http") + ":8080/api/v1.3/subcontainers/docker" self.osm_helper = OsmHelper(base_url + ":9999/osm/") self.keys = keys.Keys() self.vnf_message = {} self.custom_print("init") self.custom_print("load balancer docker id: {}, cfg name: {}".format( self.load_balancer_docker_id, self.haproxy_cfg_name)) asyncio.ensure_future(self.start(sdm_ip, base_url)) #main loop pending = asyncio.Task.all_tasks() loop = asyncio.get_event_loop() loop.run_until_complete(asyncio.gather(*pending)) loop.run_forever()
def custom_vision_endpoint(user_image_url): payload = { # "Url": user_image_url "Url": user_image_url } headers = { "Content-Type": "application/json", "Prediction-Key": "66aaad81eed9481bba65df01dfe09420" } url = "https://southcentralus.api.cognitive.microsoft.com/customvision/v1.0/Prediction/91f2d2f7-5c8d-4eb3-a741-a9c75ab6fc41/url" response = requests.post(url, data=json.dumps(payload), headers=headers) response = response.json() # if custom model has high probability rate, return recommendations if response['Predictions'][0]['Probability'] > 0.75: val = response['Predictions'][0]['Tag'] return json.dumps(semantics.get_recommendations(val)) # call clarifai api otherwise else: k = keys.Keys() app = ClarifaiApp(api_key=k.get_clarifai_key()) # Use apparel model model = app.models.get('apparel') image = ClImage(url=user_image_url) result = model.predict([image]) concepts = result['outputs'][0]['data']['concepts'] # check for high confidence if concepts[0]['value'] >= 0.9: val = concepts[0]['name'] return json.dumps(semantics.get_recommendations(val)) # otherwise provide the user with choice output = [] for i in range(3): output.append(semantics.get_recommendations(concepts[i]['name'])) return json.dumps(output) #custom_vision_endpoint("http://viliflik.files.wordpress.com/2010/10/glasses-best.jpg")
def get_recommendations(name, brand=None): k = keys.Keys() # categories = Categories( # api_key = k.get_semantics_api_key(), # api_secret = k.get_semantics_secret_key() # ) products = Products(api_key=k.get_semantics_api_key(), api_secret=k.get_semantics_secret_key()) products.products_field("search", name) if brand != None: products.products_field("brand", brand) products.products_field("variation_includeall", 0) products.products_field("limit", 10) results = products.get() output = [] for r in results["results"]: data = {} try: data['image'] = r["images"][0] except: pass data['url'] = r['sitedetails'][0]["url"] try: data['price'] = r['sitedetails'][0]["latestoffers"][0]["price"] except: pass try: data['brand'] = r['brand'] except: pass data['title'] = r['name'] data['status'] = True output.append(data) return {"results": output}
# coding: utf-8 # # Object Detection Demo # License: Apache License 2.0 (https://github.com/tensorflow/models/blob/master/LICENSE) # source: https://github.com/tensorflow/models import numpy as np import os import six.moves.urllib as urllib import sys import tarfile import tensorflow as tf import zipfile import keys as k import time keys = k.Keys({}) X1 = 0 Y1 = 60 X2 = 1600 Y2 = 1200 from collections import defaultdict from io import StringIO from matplotlib import pyplot as plt from PIL import Image from grabscreen import grab_screen import cv2 # This is needed since the notebook is stored in the object_detection folder. sys.path.append("..")
import cv2 import time import random import imutils import keyboard import keys as k import numpy as np from PIL import ImageGrab import pydirectinput as pdi from PIL import Image, ImageOps os.chdir('dataset') np.set_printoptions(threshold=sys.maxsize) keys = k.Keys() say = 0 global soltara soltara = 127 global sagtara sagtara = 128 global tarayukseklik tarayukseklik = 70 def tara(): ''' global sagtara sagtara = 128 global soltara
import numpy as np import cv2 import math, time import framegrabber, getkeys, keys keyboard = keys.Keys() def preview_img(screen): w = "nfs-minimap" cv2.namedWindow(w) cv2.moveWindow(w, 4000, 800) cv2.imshow(w, screen) cv2.waitKey(1) def process_minimap(screen): half_image = int(screen.shape[0] / 2) distance = 30 yellowLowerBoundary = np.array([20, 100, 100]) yellowUpperBoundary = np.array([40, 255, 255]) mask = cv2.cvtColor(screen, cv2.COLOR_BGR2HSV) mask = cv2.inRange(mask, yellowLowerBoundary, yellowUpperBoundary) mask = cv2.dilate(mask, np.ones((2, 2), np.uint8)) mask = cv2.erode(mask, np.ones((5, 5), np.uint8))
def generate_address(): k = keys.Keys() return k.generate()
import time import json import pymem import keys import keyboard import mouse from pymem import Pymem from math import acos, pi, sin, sqrt, isclose """попытка сделать идеальный лифт""" if __name__ == "__main__": pm = Pymem("XR_3DA.exe") keys = keys.Keys() module_offset = None for i in list(pm.list_modules()): if(i.name == "xrGame.dll"): module_offset = i.lpBaseOfDll plahka = False points = None with open("dataclean", mode="r") as file: points = json.loads(file.read()) index = 0 for i in range(2): print(i) time.sleep(1) keys.directKey("lctrl") time.sleep(0.016) keys.directKey("lshift") time.sleep(0.016)
import requests import time from ObserverPattern.vnf_observer_pattern import VnfCpuSubject as CpuSubject import collections import asyncio, maya, math import keys as keys from utils.colors import bcolors ki = keys.Keys() DockerInstance = collections.namedtuple( 'DockerInstance', (ki.docker_name, ki.docker_id, ki.vnf_id, ki.ns_id, ki.vnf_index, ki.sampling_time, ki.volume, ki.flavor)) #TODO hacer refactor con las constantes en unas sola clase. #TODO hacer una maquina de estado class DockerSupervisor(CpuSubject): _observers = None _state = None def __init__(self, cadvisor_url, ns_id, vnf_id, index, sampling_time, volume, flavor): docker_name = self.get_docker_name(ns_id, vnf_id, flavor, volume) #docker_name = "py_serv" self.cadvisor_url = cadvisor_url self.cadvisor_url_cpu = cadvisor_url.replace( "v1.3/subcontainers/docker", "v1.0/containers/docker") self.nano_secs = math.pow(10, 9) self.cpu_load = None self.rx_usage = None self.tx_usage = None
import os import six.moves.urllib as urllib import sys import tarfile import tensorflow as tf import zipfile from collections import defaultdict from io import StringIO ## mss is supposed to be v'fast. I have no complaints with it either. from mss import mss import cv2 import keys as k import time keys = k.Keys() ## HELPS WITH MOUSE INPUT ETC. THIS IS A DIRECT INPUT # This is needed since the notebook is stored in the object_detection folder. sys.path.append("..") # ## Object detection imports # Here are the imports from the object detection module. from utils import label_map_util from utils import visualization_utils as vis_util # What model to download. MODEL_NAME = 'ssd_mobilenet_v1_coco_11_06_2017' MODEL_FILE = MODEL_NAME + '.tar.gz' DOWNLOAD_BASE = 'http://download.tensorflow.org/models/object_detection/'