def Execute(self, opt, args): gitc_client = gitc_utils.parse_clientdir(os.getcwd()) if not gitc_client or (opt.gitc_client and gitc_client != opt.gitc_client): print( 'fatal: Please update your repo command. See go/gitc for instructions.', file=sys.stderr) sys.exit(1) self.client_dir = os.path.join(gitc_utils.get_gitc_manifest_dir(), gitc_client) super().Execute(opt, args) manifest_file = self.manifest.manifestFile if opt.manifest_file: if not os.path.exists(opt.manifest_file): print('fatal: Specified manifest file %s does not exist.' % opt.manifest_file) sys.exit(1) manifest_file = opt.manifest_file manifest = GitcManifest(self.repodir, gitc_client) manifest.Override(manifest_file) gitc_utils.generate_gitc_manifest(None, manifest) print('Please run `cd %s` to view your GITC client.' % os.path.join(wrapper.Wrapper().GITC_FS_ROOT_DIR, gitc_client))
def shared_wrapper_with_loaded_log(tmpdir_factory): """wrapper with file filly loaded with logs""" fn = tmpdir_factory.mktemp("data_test").join("log") file = open(str(fn), 'w') file.write(sample) file.close() nxing_config = '$remote_addr - $user [$timestamp] "$request" $response_code $response_size "$referer" "$user_agent"' # Possible alternative but would slow benchmark : dataPlane=dataplane.DataPlane(nxing_config, str(fn), 5000 ,str(fn)+'.db') dataPlane = dataplane.DataPlane(nxing_config, str(fn), 5000, ':memory:') dataWrapper = wrapper.Wrapper(dataPlane, 500) logfile = dataWrapper.dataplane.logfile # feeding a log buffer = '' section = ["work", "Test", "log%3f", "ca_st"] single_line = '''10.10.14.5 - - [$time] "GET /$section/info.php HTTP/1.1" 404 153 "-" "Mozilla/5.0 (X11; Linux x86_64; rv:69.0) Gecko/20100101 Firefox/69.0" ''' log_time = datetime.datetime.now() - datetime.timedelta(0, 110) formatted_time = log_time.strftime("%d/%b/%Y:%H:%M:%S %z") for line in range(50000): buffer += single_line.replace("$time", formatted_time).replace( "$section", section[random.randint(0, 3)]) f_file = open(logfile, 'w+') f_file.write(buffer) f_file.close() instance = dataWrapper yield instance
def setUpClass(cls): # Create a repo to operate on, but do it once per-class. cls.GIT_DIR = tempfile.mkdtemp(prefix='repo-rev-tests') run_git = wrapper.Wrapper().run_git remote = os.path.join(cls.GIT_DIR, 'remote') os.mkdir(remote) # Tests need to assume, that main is default branch at init, # which is not supported in config until 2.28. if git_command.git_require((2, 28, 0)): initstr = '--initial-branch=main' else: # Use template dir for init. templatedir = tempfile.mkdtemp(prefix='.test-template') with open(os.path.join(templatedir, 'HEAD'), 'w') as fp: fp.write('ref: refs/heads/main\n') initstr = '--template=' + templatedir run_git('init', initstr, cwd=remote) run_git('commit', '--allow-empty', '-minit', cwd=remote) run_git('branch', 'stable', cwd=remote) run_git('tag', 'v1.0', cwd=remote) run_git('commit', '--allow-empty', '-m2nd commit', cwd=remote) cls.REV_LIST = run_git('rev-list', 'HEAD', cwd=remote).stdout.splitlines() run_git('init', cwd=cls.GIT_DIR) run_git('fetch', remote, '+refs/heads/*:refs/remotes/origin/*', cwd=cls.GIT_DIR)
def setUp(self): """Load the wrapper module every time.""" wrapper._wrapper_module = None self.wrapper = wrapper.Wrapper() if not is_python3(): self.assertRegex = self.assertRegexpMatches
def main(): # handler signal(SIGINT, handler) # Sys arg parsing parser = argparse.ArgumentParser( description="Log processor for Nginx Access") parser.add_argument('logfile', nargs='?', default='/tmp/log') parser.add_argument("-b", "--batch", default=5000, type=int, help="Batch size for inserts") parser.add_argument( "-a", "--alert", default=10, type=int, help="number of connection per seconds over 2 min raising the alert") parser.add_argument("-d", "--db", default=":memory:" if debug == 0 else "debug.db", help="Path to sqlite3 database") parser.add_argument('-n', '--nginx', dest='nginx', action='store_true') parser.set_defaults(nginx=False) args = parser.parse_args() # log config if args.nginx: config = '$remote_addr - $user [$timestamp] "$request" $response_code' +\ ' $response_size "$referer" "$user_agent"' else: config = '$remote_addr - $user [$timestamp] "$request" $response_code' +\ ' $response_size' # Dataplane initialisation dataPlane = dataplane.DataPlane(config, args.logfile, args.batch, args.db) dataPlane.load() dataWrapper = wrapper.Wrapper(dataPlane, args.alert * 120) # Start Orchestration def orchestration(dataWrapper): dataWrapper.update() thread = threading.Timer(10, orchestration, [dataWrapper]) thread.daemon = True # exit if main is stoped thread.start() orchestration(dataWrapper) # init console with Live(render_visual(dataWrapper), refresh_per_second=1) as live: while 1: time.sleep(0.5) live.update(render_visual(dataWrapper))
def __init__(self, baseDir, projDir, batchSize = 32, winSize = 20, imSize = 228, modelInputW = 640, modelInputH = 360): self.baseDir = baseDir self.targetDir = projDir + "/results/kitti/fcn_lstm" self.batchSize = batchSize self.winSize = winSize self.imSize = imSize self.modelInW = modelInputW self.modelInH = modelInputH self.wrapper = wrapper.Wrapper("discrete_fcn_lstm", projDir + "/data/discrete_fcn_lstm/model.ckpt-315001.bestmodel", self.winSize, self.batchSize)
def shared_wrapper(tmpdir_factory): """simple wrapper, no file loaded""" fn = tmpdir_factory.mktemp("data_test").join("log") file = open(str(fn), 'w') file.write(sample) file.close() nxing_config = '$remote_addr - $user [$timestamp] "$request" $response_code $response_size "$referer" "$user_agent"' dataPlane = dataplane.DataPlane(nxing_config, str(fn), 100, str(fn)+'.db') dataWrapper = wrapper.Wrapper(dataPlane, 500) instance = dataWrapper yield instance
def setUpClass(cls): # Create a repo to operate on, but do it once per-class. cls.GIT_DIR = tempfile.mkdtemp(prefix="repo-rev-tests") run_git = wrapper.Wrapper().run_git remote = os.path.join(cls.GIT_DIR, "remote") os.mkdir(remote) run_git("init", cwd=remote) run_git("commit", "--allow-empty", "-minit", cwd=remote) run_git("branch", "stable", cwd=remote) run_git("tag", "v1.0", cwd=remote) run_git("commit", "--allow-empty", "-m2nd commit", cwd=remote) cls.REV_LIST = run_git("rev-list", "HEAD", cwd=remote).stdout.splitlines() run_git("init", cwd=cls.GIT_DIR) run_git("fetch", remote, "+refs/heads/*:refs/remotes/origin/*", cwd=cls.GIT_DIR)
def setUpClass(cls): # Create a repo to operate on, but do it once per-class. cls.GIT_DIR = tempfile.mkdtemp(prefix='repo-rev-tests') run_git = wrapper.Wrapper().run_git remote = os.path.join(cls.GIT_DIR, 'remote') os.mkdir(remote) run_git('init', cwd=remote) run_git('commit', '--allow-empty', '-minit', cwd=remote) run_git('branch', 'stable', cwd=remote) run_git('tag', 'v1.0', cwd=remote) run_git('commit', '--allow-empty', '-m2nd commit', cwd=remote) cls.REV_LIST = run_git('rev-list', 'HEAD', cwd=remote).stdout.splitlines() run_git('init', cwd=cls.GIT_DIR) run_git('fetch', remote, '+refs/heads/*:refs/remotes/origin/*', cwd=cls.GIT_DIR)
def main(self): if os.path.isfile(self.uri_file): if len(sys.argv) == 2 and sys.argv[1] == "--force": print "Server already running? Forcing new instance! Check for garbage!" current_pid = open(self.pid_file, "r").read() print "Killing pid is", current_pid try: os.kill(int(current_pid), signal.SIGTERM) os.remove(self.uri_file) os.remove(self.pid_file) except: pass else: print "Server already running?" return 1; Pyro.core.initServer() daemon = Pyro.core.Daemon() uri = daemon.connect(wrapper.Wrapper(), "wrapper") print "The daemon runs on port:", daemon.port print "The object's uri is:", uri print "URI stored to file:", self.uri_file uri_file = open(self.uri_file, "w") uri_file.write(str(uri)) uri_file.close() pid_file = open(self.pid_file, "w") pid_file.write(str(os.getpid())) pid_file.close() self.try_to_clean = True daemon.requestLoop() return 0
def setUp(self): self._temp_path = tempfile.mkdtemp() # write handler to temp path self._handler_path = self._write_handler(self._temp_path) # set PYTHONPATH to include temp path sys.path.append(self._temp_path) # generate socket path self._socket_path = os.path.join(self._temp_path, 'nuclio.sock') # create transport self._unix_stream_server = self._create_unix_stream_server( self._socket_path) # create logger self._logger = nuclio_sdk.Logger(logging.DEBUG) self._logger.set_handler('default', sys.stdout, nuclio_sdk.logger.HumanReadableFormatter()) # create a wrapper self._wrapper = wrapper.Wrapper(self._logger, 'reverser:handler', self._socket_path, 'test')
import wrapper from discord.ext import commands import asyncio app = wrapper.Wrapper(token=) async def test(): z = await app.fox print(await z.get_discord_file()) loop = asyncio.get_event_loop() loop.run_until_complete(test()) """ # discord.py cog example import wrapper import discord from discord.ext import commands class fun(commands.Cog): def __init__(self, bot): self.bot = bot self.app = wrapper.Wrapper(token="token") @commands.command() async def my_nice_command(self, ctx, member: discord.Member=None): member = ctx.author or member f = await app.blurple(str(member.avatar_url)) return await ctx.send(file=f)
sys.path.append('ospi') import subprocess import time #from ospi import viewer_utils as vw import wrapper as wr import motion_parser as mtp # The path to the model meshes mesh_path = '/local/gmaldona/devel/Models/data/whole_body/obj' # The path to the model and the filename filename = '/local/gmaldona/devel/Models/data/whole_body/wholebody.osim' # Create a wrapper specific to the whole-body model # The wrapper parse the OpenSim model and builds pinocchio model and data wb_model = wr.Wrapper(filename, mesh_path, name='whole-body_model1') # call the gepetto viewer server gvs = subprocess.Popen(["./gepetto-viewer.sh", "&"]) print 'Loading the viewer ...' time.sleep(2) # Init the viewer and add the model to it viewer = vw.Viewer('viewer', wb_model) viewer.setVisibility(wb_model.name + "/floor", "OFF") viewer.display(wb_model.q0, wb_model.name) # See kinematic ranges of motion # See markers
def setUp(self): """Load the wrapper module every time """ wrapper._wrapper_module = None self.wrapper = wrapper.Wrapper()
import wrapper import sys if sys.argv[1] is not None: wrap = wrapper.Wrapper(sys.argv[1]) wrap.iterate_folder()
cvfont = cv2.FONT_HERSHEY_SIMPLEX cvfont_size = 0.5 cvfont_thickness = 1 batch_size = 32 win_size = 20 IMSZ = 228 noFrames = dataset.__len__() iter_cam2 = iter(dataset.cam2) iter_oxts = iter(dataset.oxts) model_input_w = 640 model_input_h = 360 a = wrapper.Wrapper( "discrete_fcn_lstm", "/media/radu/data/python/bdd_driving/data/discrete_fcn_lstm/model.ckpt-315001.bestmodel", win_size, batch_size) print("found {:04d} files".format(noFrames)) action_map = { -1: 'not_sure', 0: 'straight', 1: 'slow_or_stop', 2: 'turn_left', 3: 'turn_right', 4: 'turn_left_slight', 5: 'turn_right_slight' } fid = open(targetDir + "/" + date + "_drive_" + drive + "_sync_full.csv", 'wb')
help='Apply Mixup to inputs') parser.add_argument('--alpha', default=1., type=float, help='mixup interpolation coefficient (default: 1)') parser.add_argument( '--debug', action='store_true', help='Track the testing accuracy, only for debugging purposes') if __name__ == '__main__': # parse arguments args = parser.parse_args() # create wrapper and prepare datasets wrapper = super_glue.Wrapper(args) wrapper.prepare_datasets() # create model, set hyperparameters and set optimizer (SGD or Adam) wrapper.create_network() wrapper.set_model_hyperparameters() wrapper.set_model_optimizer() ## uncomment to print the model # print (wrapper.model) # curriculum learning calls | train/evaluate # train cl wrapper.train_cl() # evaluate cl wrapper.eval_cl()
def parse_clientdir(gitc_fs_path): return wrapper.Wrapper().gitc_parse_clientdir(gitc_fs_path)
def get_gitc_manifest_dir(): return wrapper.Wrapper().get_gitc_manifest_dir()
class Gui: """ Interfaz de la aplicación legada de tareas en un mainframe. Esta se conecta al mainframe y mediante un wrapper permite mostrar tareas y añadir otras nuevas """ wr = wrapper.Wrapper() NUM_COLS = 3 NUM_ROWS = 10 HEADINGS = ['Fecha', 'Nombre', 'Descripcion'] HEADINGS_WIDTHS = [10, 24, 32] FONT = 'Helvetica 14' def init(self): """ Pone en funcionamiento la aplicación. Conecta con el mainframe y muestra la nueva interfaz """ # Iniciar wrapper e interfaz self.wr.iniciar() # Inicio de sesion login_win = self.__get_login_win() login_correcto = False while True: event, values = login_win.read() if event == sg.WIN_CLOSED: break elif event == 'Iniciar sesion': user, password = values['-USUARIO-'], values['-CONTRASEÑA-'] if comprobar_campos_login(user, password): if self.__login(user, password): login_correcto = True break else: login_win['-USUARIO-'].update('') login_win['-CONTRASEÑA-'].update('') sg.popup('ERROR: Usuario y/o contraseña incorrectos') else: sg.popup('ERROR: Los campos no pueden ser vacios') login_win.close() if login_correcto: main_win = self.__get__main_win() # Lectura de eventos en la app while True: event, values = main_win.read() if event == sg.WIN_CLOSED or event == 'Salir': break elif event == 'Nueva tarea': add_task_main_win = self.__new_task_win() while True: event2, values2 = add_task_main_win.read() if event2 == sg.WIN_CLOSED: break elif event2 == event2 == '-NOMBRE-' and len( values2['-NOMBRE-']) > 4: add_task_main_win['-NOMBRE-'].update( values2['-NOMBRE-'][0:4]) elif event2 == '-DESCRIPCION-' and len( values2['-DESCRIPCION-']) > 12: add_task_main_win['-DESCRIPCION-'].update( values2['-DESCRIPCION-'][0:12]) elif event2 == '-FECHA-': if len(values2['-FECHA-']) > 10: add_task_main_win['-FECHA-'].update( values2['-FECHA-'][0:10]) elif event2 == 'Añadir': fecha, nombre, descripcion = values2[ '-FECHA-'], values2['-NOMBRE-'], values2[ '-DESCRIPCION-'] # Comprobar campos vacios y correctos if len(descripcion) == 0 or len( fecha) < 10 or not fecha_correcta(fecha): sg.popup( "Introduce correctamente la fecha dd/mm/yyyy y descripcion" ) continue nombre = unidecode.unidecode(nombre) descripcion = unidecode.unidecode(descripcion) # Escribir en mainframe self.__write_task(fecha, nombre, descripcion) # Mostrar cambios self.__reload_table(main_win) break add_task_main_win.close() # Fin de nueva tarea main_win.close() self.wr.exitMainFrame() def __login(self, user, password): return self.wr.login(user, password) def __write_task(self, fecha, nombre, descripcion): """ Escribir tarea en mainframe """ if len(nombre) == 0: self.wr.generalTask(fecha, descripcion) else: self.wr.specificTask(fecha, nombre, descripcion) def __get_tasks(self): """ Obtener el conjunto de tareas del mainframe """ general_tasks = self.wr.viewGeneralTask() specific_tasks = self.wr.viewSpecificTask() tasks = general_tasks + specific_tasks if len(tasks) == 0: tasks = [['', '', '']] # Se necesita un campo mínimo else: tasks.sort(key=lambda x: x[0]) # Ordenar por número de tarea tasks = list(map(lambda x: x[1:], tasks)) # Eliminar numero de tarea return tasks def __get_login_win(self): login_layout = [[ sg.Column([[sg.Text('Usuario')], [sg.Text('Contraseña')]]), sg.Column([ [sg.Input(key='-USUARIO-')], [sg.Input(key='-CONTRASEÑA-', password_char='*')], ]) ], [sg.Button('Iniciar sesion')]] return sg.Window('Inicio de sesión', login_layout, font=self.FONT) def __get__main_win(self): """ Devuelve el layout general para crear la interfaz """ data = self.__get_tasks() col1 = [ [sg.Text('Mis tareas')], [ sg.Table(values=data, key='-TABLE-', auto_size_columns=False, col_widths=self.HEADINGS_WIDTHS, headings=self.HEADINGS, num_rows=10, pad=(20, 20), row_height=30) ], ] col2 = [[sg.Button('Nueva tarea')], [sg.Exit('Salir')]] layout = [[sg.Col(col1, ), sg.Col(col2)]] return sg.Window('UnizarTasks', layout, font=self.FONT) def __new_task_win(self): """ Devuelve Window correspondiente a la pantalla de creación de tareas""" tarea_layout = [ [sg.Text("Introduce una nueva tarea")], [ sg.Column([[sg.Text('Fecha')], [sg.Text('Nombre')], [sg.Text('Descripcion')]]), sg.Column([[sg.Input(key='-FECHA-', enable_events=True)], [sg.Input(key='-NOMBRE-', enable_events=True)], [sg.Input(key='-DESCRIPCION-', enable_events=True)]]) ], [sg.Button('Añadir')] ] return sg.Window('Nueva tarea', tarea_layout, font=self.FONT) def __reload_table(self, window): # Obtener tareas data = self.__get_tasks() window['-TABLE-'].update(data)
from kivy.uix.gridlayout import GridLayout from kivy.animation import Animation import wrapper import sms from datetime import datetime from threading import Timer import smtplib import pigpio import sys import time import random db = wrapper.Wrapper() Window.clearcolor = get_color_from_hex("0066BA") # root class ServoControl: def servo_rotate(self, g): pi = pigpio.pi() pi.set_servo_pulsewidth(g[0], 950 if g[0] == 26 else 1100) time.sleep(g[1]) pi.set_servo_pulsewidth(g[0], 0) pi.stop() class MainScreen(BoxLayout):