def run(self):
# parameters
Sim.scheduler.reset()
Sim.set_debug('AppHandler')
Sim.set_debug('TCP')
# setup network
net = Network('../networks/setup.txt')
net.loss(self.loss)
# setup routes
n1 = net.get_node('n1')
n2 = net.get_node('n2')
n1.add_forwarding_entry(address=n2.get_address('n1'), link=n1.links[0])
n2.add_forwarding_entry(address=n1.get_address('n2'), link=n2.links[0])
# setup transport
t1 = Transport(n1)
t2 = Transport(n2)
# setup application
a = AppHandler(self.filename, self.out_directory)
# setup connection
c1 = TCP(t1,
n1.get_address('n2'),
1,
n2.get_address('n1'),
1,
a,
window=self.window)
c2 = TCP(t2,
n2.get_address('n1'),
1,
n1.get_address('n2'),
1,
a,
window=self.window)
# send a file
with open(self.in_directory + '/' + self.filename, 'r') as f:
while True:
data = f.read(10000)
if not data:
break
Sim.scheduler.add(delay=0, event=data, handler=c1.send)
# run the simulation
Sim.scheduler.run()
# print str(self.window) + " & " + \
# str(Sim.scheduler.current_time()) + " & " + \
# str(4116160.0 / float(Sim.scheduler.current_time())) + " & " + \
# str(c2.totalQueueingDelay / float(c1.totalPacketsSent)) + " \\\\"
# print str(self.window) + "," + str(4116160.0 / float(Sim.scheduler.current_time()))
print str(self.window) + "," + str(
c2.totalQueueingDelay / float(c1.totalPacketsSent))
def main():
transport = Transport()
print("""
[*] Choose your option :
1) Change state
2) List vehicles in current state
3) Select next vehicle in current state
4) Quit (or Ctrl+C)
""")
while (True):
try:
i = int(input(">>> "))
if i == 1:
transport.toggle_wheels()
elif i == 2:
transport.listVehicles()
elif i == 3:
transport.selectNextVehicle()
elif i == 4:
print("[-] Exiting ...")
break
else:
print("[-] Invalid option")
except KeyboardInterrupt:
print("\n[-] Exiting ...")
break
def main():
random.seed(0)
d = Driver()
t = Transport(d, isServer=False)
services = Services(t)
s = services.getService(TEST_ADDRESS)
for i in itertools.count(1):
#totalFrags = random.randrange(1, 2**16 - 1)
totalFrags = random.randrange(1, 500)
#totalFrags = 1000
requestBuffer = Buffer(
['a' * t.dataPerFragment() for j in range(totalFrags)])
responseBuffer = Buffer()
start = gettime()
r = t.clientSend(s, requestBuffer, responseBuffer)
r.getReply()
elapsedNs = gettime() - start
resp = responseBuffer.getRange(0, responseBuffer.getTotalLength())
req = requestBuffer.getRange(0, requestBuffer.getTotalLength())
assert len(req) == len(resp), (len(req), len(resp), req[:10],
resp[:10], req[-10:], resp[-10:])
assert req == resp, (req, resp)
print
print "Message %d with %d frags OK in %dms" % (i, totalFrags,
elapsedNs / 1000000)
d.stat()
def __init__(self, gb):
self.gb = gb
# -- flow -- #
self.discr_flow = Flow(gb)
shape = self.discr_flow.shape()
self.flux_pressure = np.zeros(shape)
# -- temperature -- #
self.discr_temperature = Heat(gb)
# -- solute and precipitate -- #
self.discr_solute_advection_diffusion = Transport(gb)
self.discr_solute_precipitate_reaction = Reaction(gb)
# -- porosity -- #
self.discr_porosity = Porosity(gb)
# -- fracture aperture -- #
self.discr_fracture_aperture = FractureAperture(
gb, "fracture_aperture")
# -- layer porosity and aperture -- #
self.discr_layer_porosity = Porosity(gb, "layer_porosity")
self.discr_layer_aperture = LayerAperture(gb, "layer_aperture")
# the actual time of the simulation
self.time = 0
def __init__(self, tracks=None, devices=None, transport=None,
view_scale=None, units=None, patch_bay=None):
Model.__init__(self)
# the file path to save to
self.path = None
# transport
if (transport is None):
transport = Transport()
self.transport = transport
# time scale
if (view_scale is None):
view_scale = ViewScale()
self.view_scale = view_scale
# devices
if (devices is None):
devices = DeviceAdapterList()
self.devices = devices
# a list of units on the workspace
if (units is None):
units = UnitList()
self.units = units
self.units.add_observer(self.on_change)
self.units.add_observer(self.update_transport_duration)
self.update_transport_duration()
# a list of connections between units
if (patch_bay is None):
patch_bay = PatchBay()
self.patch_bay = patch_bay
self.patch_bay.add_observer(self.on_change)
def __init__(self, url, user=None, password=None, token=None):
"""
Use 'user/password' for access to auth.token and auth.token2,
otherwise use 'token'.
Args:
url: Url
user: User
password: Password
token: Token
"""
self.transport = Transport(url, user, password, token)
self.allowed_ports = AllowedPortsClient(self)
self.auth = AuthClient(self)
self.domains = DomainsClient(self)
self.images = ImagesClient(self)
self.ippool = IPPoolClient(self)
self.nodes = NodesClient(self)
self.pstorage = PStorageClient(self)
self.pods = PodsClient(self)
self.predefined_apps = PredefinedAppsClient(self)
self.pricing = PricingClient(self)
self.restricted_ports = RestrictedPortsClient(self)
self.system_settings = SystemSettingsClient(self)
self.users = UsersClient(self)
def main():
d = Driver(TEST_ADDRESS)
t = Transport(d, isServer=True)
while True:
r = t.serverRecv()
r.replyPayload.extend(r.recvPayload)
r.sendReply()
d.stat()
def main() -> None:
master = MasterServer()
transport = Transport(master)
try:
transport.loop.run_forever()
except KeyboardInterrupt:
pass
def __init__(self, target_descriptor, signed=True,
flush_trigger=1):
''' target_descriptor must be an ESDescriptor'''
self.transport = Transport(signed)
self.target_descriptor = target_descriptor
self.flush_trigger = flush_trigger
self.buffer = ESLineBuffer(target_descriptor.es_index,
target_descriptor.es_type)
def buildTransports(self):
self.transports = [
Transport(str(i), self, self.env, DELAY_BETWEEN_TR * i,
self.transport_info['capacity'],
self.transport_info['stop_time'])
for i in range(1, self.transport_info['count'] + 1)
]
del self.transport_info
def __init__(self, organisation, username, password, verbose=False):
ServerProxy.__init__(self,
"https://%s.%s:%[email protected]/api/xmlrpc" %
(organisation, username, password),
transport=Transport(use_datetime=True),
encoding="UTF-8",
allow_none=True,
verbose=verbose)
pass
def main():
protocols = Protocols()
storage = Storage()
master = MasterServer(storage, protocols)
transport = Transport(master)
try:
transport.loop.run_forever()
except KeyboardInterrupt:
pass
def __init__(self, udpc, logger: Logger, name="Ana", parent=None):
super().__init__(logger=logger, parent=parent)
self.udpc = udpc
self.addr = QHostAddress(udpc.addr)
self.port = udpc.port
self.transport = Transport()
self.socket = QUdpSocket(self)
self.socket.bind(QHostAddress(udpc.local_addr), udpc.local_port)
self.rid = udpc.rid
self.add_rid(udpc.rid)
self.name = name
def __enter__(self):
# Start transport layer
self.socket = Transport()
self.socket.connect((self.server_name, self.port))
# Start SSH connection
self.version_exchange()
self.key_exchange()
self.init_authentication()
return self
def initialize(self):
if not self.__configured:
raise RuntimeError('robot has not been configured.')
try:
self.__transport = Transport(self.__port, self.__baudrate)
except:
print("serial initialization failed")
raise RuntimeError("Robot init failed. Check configuration.")
self.__proc = threading.Thread(name='robot process', target=self.__run)
self.__proc.setDaemon(True)
self.robot_status = RobotStatus(self.__num_joints)
self.__initialized = True
def __init__(self):
self.command_map = {
'login': self.login,
'create': self.create,
'join': self.join,
'leave': self.leave,
'raise': self.raise_bet,
'fold': self.fold,
'call': self.call,
}
self.card_suit_map = {
1: SPADES,
2: HEARTS,
3: DIAMONDS,
4: CLUBS,
}
self.card_value_map = {
2: '2',
3: '3',
4: '4',
5: '5',
6: '6',
7: '7',
8: '8',
9: '9',
10: '10',
11: 'J',
12: 'Q',
13: 'K',
14: 'A',
}
self.round_status_map = {
0: 'Unknown',
1: 'Begining',
2: 'Preflop',
3: 'Flop',
4: 'Turn',
5: 'River',
6: 'End',
}
self.table_status_map = {
0: 'Unknown',
1: 'Waiting for players',
2: 'Game in progress',
3: 'Game ended',
}
self.transport = Transport(HOST, PORT)
self.working_flag = False
def Gillespie(
V, F, U, AP
): # aggiungi la variabile sector, i pesi della rete da passare a omega
C = V
Pop = norm(V[:-1], 1)
t = C[-1]
RHO = F
N, D = F.shape
omega_ngb = Transport(
V[:-1], F[:, :-1],
U) # di F rimuovo l'ultima colonna, il tempo dei nodi
omega_cnt = -np.sum(omega_ngb, 0)
w1 = beta * C[0] * C[1] / Pop
w2 = gamma * C[1]
w3 = norm(omega_cnt, 1)
W = w1 + w2 + w3
dt = -math.log(random.uniform(0.0, 1.0)) / W
t += dt
C[-1] = t
RHO[:, -1] = t
r = random.uniform(0.0, 1.0)
if r < w1 / W:
C[0] -= 1 # S -> S-1
C[1] += 1 # I -> I-1
return C, RHO
if r >= w1 / W and r < (w1 + w2) / W:
C[1] -= 1 # I -> I-1
C[2] += 1 # R -> R-1
return C, RHO
if r >= (w1 + w2) / W and r < 1:
C[:-1] += omega_cnt
RHO[:, :-1] += omega_ngb
if (C >= 0).all() and (RHO >= 0).all():
return C, RHO
else:
V[-1] = t
F[:, -1] = t
return V, F
def initialize(self):
if not self.__configured:
print('[Error] Robot has not been configured.')
return False
try:
self.__transport = Transport(self.__port, self.__baudrate)
except:
print("[Error] Serial initialization failed. \n ***** Check serial settings.")
return False
self.__proc = threading.Thread(name='robot process', target=self.__run)
self.__proc.setDaemon(True)
self.robot_status = RobotStatus(self.__num_joints)
self.__initialized = True
return True
def __init__(self, gb, models_trans, model_react, tol):
self.gb = gb
self.tol = tol
# set up the transport models
self.models_trans = np.atleast_1d(models_trans)
self.discr_trans = {
m: Transport(self.gb, m, self.tol)
for m in self.models_trans
}
# set up the reaction models
# we assume only one reaction model
self.model_react = model_react
self.discr_react = Reaction(self.tol)
def __init__(self, gb):
self.gb = gb
# -- flow -- #
self.discr_flow = Flow(gb)
shape = self.discr_flow.shape()
self.flux_pressure = np.zeros(shape)
# -- temperature -- #
self.discr_temperature = Heat(gb)
shape = self.discr_temperature.shape()
self.temperature = np.zeros(shape)
self.temperature_old = np.zeros(shape)
# -- solute and precipitate -- #
self.discr_solute_advection_diffusion = Transport(gb)
self.discr_solute_precipitate_reaction = Reaction(gb)
shape = self.discr_solute_advection_diffusion.shape()
self.solute = np.zeros(shape)
self.precipitate = np.zeros(shape)
self.solute_old = np.zeros(shape)
self.precipitate_old = np.zeros(shape)
# -- porosity -- #
self.discr_porosity = Porosity(gb)
shape = self.discr_porosity.shape()
self.porosity = np.zeros(shape)
self.porosity_old = np.zeros(shape)
self.porosity_star = np.zeros(shape)
# -- aperture -- #
self.discr_aperture = Aperture(gb)
shape = self.discr_aperture.shape()
self.aperture = np.zeros(shape)
self.aperture_old = np.zeros(shape)
self.aperture_star = np.zeros(shape)
# -- composite variables -- #
self.porosity_aperture_times_solute = np.zeros(shape)
self.porosity_aperture_times_precipitate = np.zeros(shape)
def __init__(self, intf):
self._intf = intf
self._transport = Transport()
self._id = None
self._version = None
self._polling = False
self._connected = False
self._type2 = False
self._type4 = False
self._p2p = False
self._initiator = False
self._ndefPresent = False
self._ndefRecords = None
self._ndefRead = False
self._ndefReadable = False
self._ndefWriteable = False
self._ndefBusy = False
self._ndefSuccess = False
def connect(self):
self.t = Transport(self.host, self.port, timeout=None, verbose=False, enable_ssl=(self.port==443), ipv4=self.ipv4)
if not self.upgrade_connection():
raise ServerError('Unable to upgrade connection')
self.log("Connected to {0}:{1}.".format(self.host, self.port))
response = self.send_init_request()
if response.responseCode != 200:
error_text = 'Wrong response from server, status_code={0}'.format(
response.responseCode)
if response.HasField("message"):
error_text += ', message is "{0}"'.format(response.message)
raise ServerError(error_text)
self.session_id = response.sessionId
self.log("session_id={0}".format(self.session_id))
return self.session_id
def add_material(self, form):
"""
Adds a material
"""
name = None
level = None
try:
name, level = form['type'].split(' ')
except ValueError:
name = form['type']
level = form['classlvl']
level = int(level)
material = None
if level == 1:
material = Utility(
material_type=name,
price=form["price"],
)
elif level == 2:
material = Transport(
material_type=name,
price=form["price"],
)
elif level == 3:
material = Weapon(
material_type=name,
price=form["price"],
)
# material = Materials(
# material_type=form["type"],
# price=form["price"],
# classlvl=form["classlvl"]
# )
self.session.add(material)
self.session.commit()
def list_speakers(server=DEFAULT_SERVER_VALUE,
port=DEFAULT_PORT_VALUE,
key=DEFAULT_KEY_VALUE,
uuid=DEFAULT_UUID_VALUE,
ipv4=False,
**kwars):
logger = logging.getLogger('asrclient')
with Transport(server,
port,
timeout=None,
verbose=False,
enable_ssl=(port == 443),
ipv4=ipv4) as t:
if not upgradeToProtobuf(t, server, port):
logger.info("Wrong response on upgrade request. Exiting.")
sys.exit(1)
logger.info("Upgraded to protobuf, sending connect request.")
t.sendProtobuf(
ConnectionRequest(serviceName="tts",
speechkitVersion="ttsclient",
uuid=uuid,
apiKey=key))
connectionResponse = t.recvProtobuf(ConnectionResponse)
if connectionResponse.responseCode != 200:
logger.info(
"Bad response code %s: %s" %
(connectionResponse.responseCode, connectionResponse.message))
sys.exit(1)
logger.info("Connected, getting speakers list.")
t.sendProtobuf(ParamsRequest(listVoices=True))
res = t.recvProtobuf(ParamsResponse)
print(", ".join([v.name for v in res.voiceList if v.coreVoice]))
def __init__(self, addr):
self.tr = Transport(addr)
self.lids = 0
self.left_x = self.left_y = self.left_lids = self.left_offset = 0
self.right_x = self.right_y = self.right_lids = self.right_offset = 0
def connect(self):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((self.host, self.port))
print dir(sock)
self.transport = Transport(sock, (self.host, self.port))
def setUp(self):
#print('setUp')
self.transport = Transport(speed=120)
import os.path
import numpy as np
from transport import Transport
from plot import plot
households = 5 if len(sys.argv) < 2 else int(sys.argv[1])
output_folder = '/output' if len(sys.argv) < 3 else sys.argv[2]
input_folder = '/input' if len(sys.argv) < 4 else sys.argv[3]
def km_to_world(km):
return km / 40000
co2_kg = households * 3000
transport = Transport(co2_kg)
# 1. Print traveling kilometers per transport type.
print(
"For {} households, Nerdalize reduces CO2 emissions by {:,d} kg per year.".
format(households, co2_kg))
print("")
print("This is equivalent to (per person):")
tmpl = "{} {:,.0f} Kilometers by {}, or {:.1f} times around the world �"
print(tmpl.format("🚗", transport.car(), "car",
km_to_world(transport.car())))
print(
tmpl.format("🚆", transport.train(), "train",
km_to_world(transport.train())))
print(
tmpl.format("✈� ", transport.airplane(), "airplane",
############################################
# MAIN PROGRAM STARTS HERE
############################################
if __name__ == "__main__":
root = Tk()
root.title('BVHPlay')
mymenu = Menubar(root)
mymenu.filemenu.entryconfig(0, command=open_file)
root.bind('<Control-Key-o>', open_file2)
mymenu.settingsmenu.entryconfig(0, command=toggle_grid)
mymenu.settingsmenu.entryconfig(1, command=toggle_axes)
mymenu.settingsmenu.entryconfig(2, command=toggle_readout)
mytransport = Transport() # Create and pack a frame of transport buttons
mytransport.btn_begin.config(command=onBegin)
mytransport.btn_end.config(command=onEnd)
mytransport.btn_stop.config(command=onStop)
mytransport.btn_play.config(command=onPlay)
mytransport.btn_stepback.config(command=onStepback)
mytransport.btn_stepfd.config(command=onStepfd)
myplaybar = Playbar()
slidert = IntVar() # Special magic integer that allows me to tie it
# to a Tk widget "variable" option, in this case
# for our slider
myplaybar.scale.config(variable=slidert)
slidert.set(1) # DO NOT use "slidert = __"
myplaybar.scale.config(command=onSlider)
def setUp(self):
self.transport = Transport(speed=120)
