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):
