def test_with_fake(self):
validator: FakeValidator = FakeValidator()
subject: Service = Service(validator)
subject.dowork()
self.assertEquals(1, subject.work_count)
def __start__(self):
function = self.function
name = self.name
inbox = self.inbox
outbox = self.outbox
copies = self.copies
verbose = self.verbose
# report
if verbose:
print '%s: Starting %i Copies' % (name, copies)
sys.stdout.flush()
# initialize services
nodes = []
for i in range(copies):
this_name = '%s - Node %i' % (name, i)
service = Service(function, inbox, outbox, this_name, verbose)
service.start()
nodes.append(service)
#: for each node
# store
self.nodes = nodes
def __init__(self):
self._service = Service()
self._sleepTime = 0.5
pygame.init()
logo = pygame.image.load("Resources/logo32x32.png")
pygame.display.set_icon(logo)
pygame.display.set_caption("GA")
screen = pygame.display.set_mode(
(SQUARE_WIDTH * WIDTH, SQUARE_HEIGHT * HEIGHT))
screen.fill(WHITE)
running = True
path = []
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
if event.type == pygame.KEYDOWN:
if pygame.key.get_pressed()[pygame.K_SPACE]:
start = time.time()
path = self._service.solver()
print(time.time() - start)
print(len(path))
print(len(set(path)))
image = self._service.mapWithPath(path)
image = self._service.mapWithDrone(image)
image = self._service.mapWithSensors(image)
screen.blit(image, (0, 0))
pygame.display.flip()
pygame.quit()
def emptyServices(self, drivers, vehicles):
"""Creates an accessory ServicesList to be used in the first working period,
after attribution of vehicles to the available drivers.
Requires: drivers and vehicles are collections of drivers and vehicles, respectively.
Ensures: A ServicesList regarding the working period prior to the first of the day (ie 0709).
This will be useful if one considers the first working period of the day (0911),
where vehicles are not attributed to drivers and no service List is available.
Thus, vehicles, lexicographic sorted by plate, are attributed to drivers
according to their entry hour (and name, in case of tie). All the service-related information is
set as a "no service" (_no_client_, _no_circuit_, service kms = 0), Arrival and Departure
hours are set as the Driver's entry hour and being ready to work,
drivers' status is standby, of course!
"""
# sort drivers for the 1st period (0911) according to Drivers' EntryHour
# and in case of tie, Drivers' name
d = sorted(drivers.values())
v = sorted(vehicles.keys())
j = 0
for i in d:
driverName = i.getDriverName()
vehiclePlate = v[j]
serv = Service(driverName, vehiclePlate, "", i.getDriverEntryHour(), i.getDriverEntryHour(), "", "", "")
serv.noService()
self.append(serv)
j += 1
def __init__(self):
self.user = User()
self.account = Account()
self.employee = Employee()
self.service = Service()
self.utilities = Utilities()
self.initAmt = 0
def run_process(self):
service = Service()
# Load siti from excel (LoadResources class)
#TODO: qunado si leggerà la tabella bisogna prendere sia l'url del sito che il nome del negozio che andrà nel report
# al posto dell'url nella variabile sito
#lista_siti = ["https://www.lubecreostorepratolapeligna.it/", ]
lista_siti = [
"https://www.lubestoresenigallia.it/",
]
#lista_siti = ["https://lubecreomilano.it/", ]
#lista_siti = ["https://www.cucineluberoma.it/", ]
for sito in lista_siti:
report = service.valuta_sito_web(sito)
print(report.toJSON())
# self.db_manager.insert(self.cl,report)
# TODO: for social in lista social facebook e valuta
# for sito in lista_fcebook:
# report = service.valuta_facebook_profile(sito)
# print(report.toJSON())
# TODO:self.db_manager.insert(self.cl,report)
# TODO: for social in lista social instagram e valuta
# for sito in lista_instagram:
# report = service.valuta_instagram_profile(sito)
# print(report.toJSON())
# TODO: self.db_manager.insert(self.cl,report)
self.logger.info("FINISH")
def add_service(self, port, proto, value, uri=None, content=None, \
username=None, password=None):
service_name = "%s/%s" % (port, proto)
if self.services.has_key(service_name):
pass
self.services[service_name] = Service(port, proto, value, \
self.logger, uri, content, username, password)
def process_sheet(sheet, workbook):
services = []
sheet_ranges = workbook[sheet]
columnDict = get_columns_index(sheet_ranges)
max_col = sheet_ranges.rows.gi_frame.f_locals['max_col']
max_row = sheet_ranges.rows.gi_frame.f_locals['max_row']
STARTING_SERVICE_ROW = 2
for row in sheet_ranges.iter_rows(min_row=STARTING_SERVICE_ROW, max_col=max_col, max_row=max_row):
fields = {}
for cell in row:
if hasattr(cell,'column') and cell.column in columnDict.keys():
fields[columnDict[cell.column]] = cell.value
else:
continue
if len(fields) == 0:
continue
service = Service(fields)
if service.is_valid_service():
services.append(service)
print('Services for ' + sheet + ' has been processed')
return services
def test_request(self):
persistence = Persistence('test.db')
now = datetime.utcnow().replace(microsecond=0)
dt0 = now - timedelta(seconds=30)
persistence.store(dt0, 100.0, 100.0, 100.0, 100.0)
service = Service(persistence)
response = service.request(self.start_response)
self.assertEqual(
response.next(),
'data: {"dest": "archive", "items": [], "type": "preload"}\n\n')
self.assertEqual(
response.next(),
'data: {"dest": "recent", "items": [{"dt": "%sZ", "humidity": 100.0, "temperature": 100.0, "moisture": 100.0, "luminence": 100.0}], "type": "preload"}\n\n'
% dt0.isoformat())
dt1 = now
service.enqueue('recent', 'realtime', [{
'dt': dt1,
'moisture': 200.0,
'luminence': 200.0,
'temperature': 200.0,
'humidity': 200.0
}])
self.assertEqual(
response.next(),
'data: {"dest": "recent", "items": [{"dt": "%sZ", "humidity": 200.0, "temperature": 200.0, "moisture": 200.0, "luminence": 200.0}], "type": "realtime"}\n\n'
% dt1.isoformat())
def replanning(self):
print "Recovery Workflow started"
data = cherrypy.request.json
response = RESTInterface(self.params.pmaddress, self.params.pmport,
"/pm/v0.0/rest/get_services_involved",
json.dumps(data)).run()
print response
affected = json.loads(response)
#for service in affected -> delete (PM)
for service in affected['services']:
print "Service " + json.dumps(service)
request = self.generateRequest("", 0, service['id'], 2, "", "")
RESTInterface(self.params.pmaddress, self.params.pmport,
"/pm/v0.0/rest/dispatch", request).run()
#for service in affected -> path (PCE)
# -> configure (PM)
for service in affected['services']:
r = self.generatePCErequest(service['source'], service['sport'],
service['dest'], service['dport'])
req = json.loads(r)
xro = {'dpid': data['body']['dpid'], 'port': data['body']['port']}
req['xro'] = xro
r = json.dumps(req)
response = RESTInterface(self.params.pceaddress,
self.params.pceport,
"/pce/v0.0/rest/request", r).run()
jsonret = json.loads(response) #check error status
print response
id = self.getID(service['id'])
nwsrc = "unset"
nwdst = "unset"
if "nwDst" in service.keys():
nwdst = service['nwDst']
if "nwSrc" in service.keys():
nwsrc = service['nwSrc']
request = self.generateRequest(response[:-1], 100000000, id, 1,
nwsrc, nwdst)
if ("Error" in jsonret) | ("Error" in jsonret['path'][0]):
return '{"Error":"NOPATH found"}'
#trik for faster recovery
#recuest=json.loads(request)
#first=recuest['path'].pop(0)
#recuest['path'].append(first)
#request=json.dumps(recuest)
###
ri2 = RESTInterface(self.params.pmaddress, self.params.pmport,
"/pm/v0.0/rest/dispatch", request)
ret = ri2.run()
jsonret = json.loads(ret)
if "OK" in jsonret['Status']:
serv = Service(id, cherrypy.request.remote.ip,
"E2EProvisioning", "PM", jsonret['id'],
service['source'], service['dest'],
service['sport'], service['dport'], request,
nwsrc, nwdst)
self.services[id] = serv
print serv.toString()
def main():
crtDir = os.getcwd()
filePath = os.path.join(crtDir, 'data', 'hardE.txt')
Repo = Repository(filePath)
Repo.read_tsp_format()
Serv=Service(Repo)
Cons=Console(Serv)
Cons.print_info(100,100)
def setUp(self) -> None:
self.service = Service()
self.request_parameters = {
"keywords": ["openstack", "nova", "css"],
"proxies": ["93.152.176.225:54136", "185.189.211.70:8080"],
"type": "Repositories"
}
self.test_url = "https://github.com/search?utf8=✓&q=openstack+nova+css&type=Repositories"
def test_nine_digits_format(self, ):
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
service = Service(20, server_socket, True)
num = '12345'
expected = '000012345'
actual = service.nine_digits_format(num)
server_socket.close()
self.assertEqual(expected, actual)
def test_with_spy(self):
validator: SpyValidator = SpyValidator()
subject: Service = Service(validator)
subject.dowork()
self.assertTrue(validator.called)
self.assertEquals(0, subject.work_count)
def main(self):
while 1==1:
files=input("Fisier:" )
ngen=int(input("Generations:"))
popsize=int(input("Popsize:"))
r=repo(files,"1")m
s=Service(r)
print(str(s.solve(popsize,ngen)))
def __init__(self, inputData):
self.inputData = inputData
nBuses = self.inputData.nBuses
nDrivers = self.inputData.nDrivers
nServices = self.inputData.nServices
start = self.inputData.start
duration = self.inputData.duration
kms = self.inputData.kms
passengers = self.inputData.passengers
capacity = self.inputData.capacity
cost_km = self.inputData.cost_km
cost_min = self.inputData.cost_min
maxWorkingTime = self.inputData.maxWorkingTime
self.maxBuses = self.inputData.maxBuses
self.BM = self.inputData.BM
self.CBM = self.inputData.CBM
self.CEM = self.inputData.CEM
self.drivers = []
self.buses = []
self.services = []
self.overlapping = [[0 for x in range(nServices)]
for y in range(nServices)]
for sId in xrange(
0,
nServices): #hopefully really 0..(nServices-1) --> Check that
service = Service(sId, start[sId], duration[sId], kms[sId],
passengers[sId])
self.services.append(service)
for dId in xrange(0, nDrivers):
driver = Driver(dId, maxWorkingTime[dId])
self.drivers.append(driver)
for bId in xrange(0, nBuses):
bus = Bus(bId, capacity[bId], cost_km[bId], cost_min[bId])
self.buses.append(bus)
for s1 in xrange(0, nServices):
for s2 in xrange(0, nServices):
startS1 = self.services[s1].getStart()
endS1 = startS1 + self.services[s1].getDuration()
startS2 = self.services[s2].getStart()
endS2 = startS2 + self.services[s2].getDuration()
if not (endS1 < startS2 or startS1 > endS2):
self.overlapping[s1][s2] = 1
self.overlapping[s2][s1] = 1
else:
self.overlapping[s1][s2] = 0
self.overlapping[s2][s1] = 0
def services(self):
self._doinit()
if self._services == {}:
for hrd_path in j.sal.fs.listFilesInDir(j.dirs.ays, recursive=True, filter="instance.hrd",
case_sensitivity='os', followSymlinks=True, listSymlinks=False):
service_path = j.sal.fs.getDirName(hrd_path)
service = Service(path=service_path, args=None)
self._services[service.shortkey]=service
return self._services
def login_submit():
userName = request.form['loginUsername']
password = request.form['loginPassword']
loginMessage = Service().loginService(userName, password)
onlineUsers = Service().getOnlineUsersService()
if (loginMessage == "User logged in"):
if (onlineUsers != []):
onlineUsers.remove(userName)
userActive = userName
else:
userActive = ''
return render_template('index.html',
loginStatus=loginMessage,
onlineUsers=onlineUsers,
userActive=userActive)
def test_with_mock(self):
validator: MockValidator = MockValidator()
subject: Service = Service(validator)
subject.dowork()
expected: List[str] = ["foo", "bar"]
self.assertEquals(expected, validator.values)
self.assertEquals(0, subject.work_count)
def handler():
"""postfork hanlder, creates global domain object"""
global domain
persistence = Persistence('tve.db')
acquisition = Acquisition('/dev/ttyACM0')
service = Service(persistence)
domain = Domain(persistence, acquisition, service)
logging.basicConfig(level=logging.INFO,
format='%(asctime)s %(levelname)s %(message)s')
logging.info('Domain object initialized')
def __init__(self, host, port, buffer_size, repository, run_server):
self.host = host
self.port = port
self.buffer_size = buffer_size
self.run_server = run_server
self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.server_socket.bind((self.host, self.port))
self.server_socket.listen(5)
self.repository = repository
self.service = Service(self.buffer_size, self.server_socket, self.run_server)
def add_service(self, teamname, port, proto, value, uri=None, content=None, \
username=None, password=None):
service_name = "%s/%s" % (port, proto)
if self.services.has_key(service_name):
pass
this_queue = Queue.Queue()
self.services[service_name] = Service(port, proto, value, \
teamname , this_queue, self.hostname, uri, content, username, password)
self.service_rounds[service_name] = False
self.service_queues[service_name] = this_queue
def register_submit():
registerUserName = request.form['registerUserName']
registerEmail = request.form['registerEmail']
registerPassword = request.form['registerPassword']
registerTopic = request.form['registerTopic']
onlineUsers = Service().getOnlineUsersService()
if(registerUserName=='' or registerEmail=='' or registerPassword=='' or registerTopic==''):
registerMessage="Please Enter all fields"
return render_template('index.html', registrationStatus=registerMessage, onlineUsers=onlineUsers)
if(Service().registerService(registerUserName,registerEmail,registerPassword,registerTopic)):
registerMessage="Registration successfull"
else:
registerMessage="Registration unsucessfull"
return render_template('index.html', registrationStatus=registerMessage,onlineUsers = onlineUsers)
def main(self):
while 1:
try:
x = input()
if x == "0":
return
elif x == "1":
file = input()
self.__service = Service(file, 1)
self.__service.prob1()
print("Functie terminata")
elif x == "2":
file = input()
self.__service = Service(file, 2)
self.__service.prob1()
print("Functie terminata")
else:
print("Error")
except FileNotFoundError:
print("Fisierul nu exista")
def E2Eprovisioning(self):
data = cherrypy.request.json
source = data['source']
sport = data['sport']
dest = data['dest']
dport = data['dport']
bandwidth = data['bandwidth']
nwDst = "unset"
nwSrc = "unset"
wavelength = "unset"
if 'nwSrc' in data.keys():
nwSrc = data['nwSrc']
if 'nwDst' in data.keys():
nwDst = data['nwDst']
print "Test- Added wavelength to retrieve it from json"
if 'wavelength' in data.keys():
wavelength = data['wavelength']
#first of all: PCE request (via REsT APi)
print json.dumps(data)
ri = RESTInterface(self.params.pceaddress, self.params.pceport,
"/pce/v0.0/rest/request", json.dumps(data))
ret = ri.run()
jsonret = json.loads(ret) #check error status
id = self.generateID()
request = self.generateRequest(ret[:-1], bandwidth, id, 1, nwSrc,
nwDst, wavelength)
print "::::::::::::::::::::::::::::::::::::::::::::"
print ret[:-1]
print "-----------------------"
print request
print "::::::::::::::::::::::::::::::::::::::::::::"
if "vlan" in data.keys():
request = request[:-1] + ',"vlan":' + data['vlan'] + '}'
if ("Error" in ret):
return '{"Error":"NOPATH found"}'
print request
ri2 = RESTInterface(self.params.pmaddress, self.params.pmport,
"/pm/v0.0/rest/dispatch", request)
ret = ri2.run()
jsonret = json.loads(ret)
if "OK" in jsonret['Status']:
# Test- Added wavelength o service
serv = Service(id, cherrypy.request.remote.ip, "E2EProvisioning",
"PM", jsonret['id'], source, dest, sport, dport,
request, nwSrc, nwDst, wavelength)
#serv=Service(id,cherrypy.request.remote.ip,"E2EProvisioning", "PM", jsonret['id'],source,dest, sport, dport, request, nwSrc, nwDst)
self.services[id] = serv
print serv.toString()
return '{"Workflow":"' + serv.workflow + '","ID":"' + str(
serv.id
) + '","from":"' + serv.ip + '","Status":"E2EProvisioning successfully finished"}'
def main(self):
# we create the environment
# e = Environment(SIZE_X, SIZE_Y)
# e.loadEnvironment("test2.map")
# print(str(e))
# we create the map
# m = DroneMap()
# initialize the pygame module
pygame.init()
# load and set the logo
logo = pygame.image.load("swiper.jpg")
pygame.display.set_icon(logo)
pygame.display.set_caption("Dora the Explorer")
# we position the drone somewhere in the area
# x = randint(0, 19)
# y = randint(0, 19)
#
# # cream drona
# d = Drone(x, y)
service = Service()
# create a surface on screen that has the size of 800 x 480
screen = pygame.display.set_mode((800, 400))
screen.fill(WHITE)
screen.blit(service.getEnvironmentImage(), (0, 0))
# define a variable to control the main loop
running = True
# main loop
while running:
# event handling, gets all event from the event queue
for event in pygame.event.get():
# only do something if the event is of type QUIT
if event.type == pygame.QUIT:
# change the value to False, to exit the main loop
running = False
if service.droneCanMove():
service.markDetectedWalls()
screen.blit(service.getDroneMapImage(), (400, 0))
running = service.move()
pygame.display.flip()
pygame.time.delay(DURATION)
display_text("Swiper no swiping!", screen)
pygame.time.delay(3000)
pygame.quit()
def main():
# file = input("Introduceti nume fisierului:")
# pop = input("Introduceti populatia initiala:")
# gen = input("Introduceti numarul de generatii:")
file = "mediumF.txt"
pop = "100"
gen = "500"
start = 3
file = "data/" + file
r = Repo(file)
s = Service(r)
net = parseberlin("data/hardE.txt")
runGA(int(pop), int(gen), costofpath, s.getNet(), start)
def __init__(self):
self.total_addresses = 0
self.address_accuracy = 0
self.total_addresses_by_type = 0
self.address_accuracy_by_type = 0
self.accuracy_list = []
self.path_resources = Constants.path_resources
self.file_test_img = Constants.file_test_img
self.path_test_addresses = Constants.path_test_addresses
self.path_test_address_file = Constants.path_test_address_file
self.service = Service()
def __init__(self, inputData):
self.inputData = inputData
nServices = inputData.numServices
nBuses = inputData.numBuses
nDrivers = inputData.numDrivers
self.maxBuses = inputData.maxBuses
self.buses = {}
for busId in range(0, nBuses):
# Assuming that each element of inputData.buses is a string,
# remove initial and trailing "<...>", then split on ","
busData = inputData.buses[busId].strip('<>').split(',')
# Convert to numeral values
for i in range(0, len(busData)):
try:
busData[i] = int(busData[i].strip())
except ValueError:
busData[i] = float(busData[i].strip())
# Create element
bus = Bus(busId, busData[0], busData[1], busData[2])
self.buses[bus.id] = bus
self.drivers = {}
for driverId in range(0, nDrivers):
# Assuming that each element of inputData.drivers is a string,
# remove initial and trailing "<...>", then split on ","
driverData = inputData.drivers[driverId].strip('<>').split(',')
# Convert to numeral values
for i in range(0, len(driverData)):
try:
driverData[i] = int(driverData[i].strip())
except ValueError:
driverData[i] = float(driverData[i].strip())
# Create element
driver = Driver(driverId, driverData[0], driverData[1],
driverData[2], driverData[3])
self.drivers[driver.id] = driver
self.services = {}
for serviceId in range(0, nServices):
# Assuming that each element of inputData.services is a string,
# remove initial and trailing "<...>", then split on ","
serviceData = inputData.services[serviceId].strip('<>').split(',')
# Convert to numeral values
for i in range(0, len(serviceData)):
serviceData[i] = int(serviceData[i].strip())
service = Service(serviceId, serviceData[0], serviceData[1],
serviceData[2], serviceData[3], self.services)
self.services[service.id] = service
def run():
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
port = 4397
sock.bind(('0.0.0.0', 4397))
sock.listen(5)
cons = {} # 所有客户端连接存储
ready = {} # 对话准备
logger.debug("启动websock,端口是:" + str(4397))
while True:
con, addr = sock.accept()
key = str(uuid.uuid1()).replace("-", "")
cons[key] = {"con": con, "handshake": False, "name": None}
service = Service(key, cons, ready)
service.start()
