def runTest2():
repo = Repository("test2.txt")
service = Service(repo)
c = service.simulate(50, 10, 100)
assert (c.get_genes() == [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0])
assert (c.get_distance() == 10)
assert (c.fitness() == 1 / c.get_distance())
def runTest1():
repo = Repository("test1.txt")
service = Service(repo)
c = service.simulate(20, 10, 30)
assert (c.get_genes() == [0, 1, 2, 3, 0])
assert (c.get_distance() == 4)
assert (c.fitness() == 1 / c.get_distance())
def start():
service = Service("data/e_igloos.txt")
service.read_from_file()
sizes = service.get_office_sizes()
for i in range(sizes[0] * sizes[1]):
print(i)
this_problem_is_too_hard_so_we_gave_up(service.get_office_sizes(),
service.get_office_space(),
service.get_developers(),
service.get_project_managers())
def main():
global serv
serv = Service()
bankTest = Tests(serv)
print(type(bankTest))
# try:
print('testing successful login:'******'john', 'smith')
print()
print('testing successful withdrawal:')
bankTest.testWithdrawalSuccess(20.0)
print()
print('testing failed withdrawal:')
bankTest.testWithdrawalFailure(20000.0)
print()
print('')
bankTest.testLoginFailure('john', 'smithhh')
# except Exception as ex:
# # print(ex.with_traceback())
# print('Exception!!! ', ex.__cause__, ex.__traceback__)
# except Exception as e:
# print('problem: ', e.__cause__, '\n\n', e.__context__, 'error args:')
# finally:
print(
f'{bankTest.TESTS_PASSED} tests passed out of {bankTest.TESTS_EXECUTED} executed.'
)
def main():
factory = Factory.get_instance()
car_wash_repo = factory.create_car_wash_repo("json", "car_wash.json")
car_repo = factory.create_car_repo("json", "car_wash.json")
service = Service(car_repo, car_wash_repo)
console = Console(service)
console.run()
def main():
lobby = Lobby()
docker_client = docker.from_env()
container_manager = ContainerManager(docker_client)
file_manager = FileManager()
service = Service(container_manager, file_manager, lobby)
facade = Facade(service)
facade.app.run(host='0.0.0.0')
def result():
try:
result = Service(request, document_extractor, translator)
return jsonify(result)
except Exception as e:
return jsonify({
"english_result": "Error: {}".format(e),
"chinese_result": "錯誤: {}".format(e)
})
def post(self):
#obtener objeto json
json_data = request.get_json()
resultado = Service.newEvents(db, json_data['events'])
#invitacionesByDate = Service.getEventsByDate(db, '2020/06/01')
respuesta = {
'response': True,
'msg': "Mensaje al usuario",
'data': json_data
}
return respuesta
def __init__(self):
self.prompt = "➜ "
self.banner = """
n0framework
Powered by n0b0dy@Eur3kA
"""
self.session = None
self.commandReg = CommandRegister()
self.serviceReg = ServiceRegister()
self.history = FileHistory("/framelog/history.txt")
for cmd in Command.find_all():
self.commandReg.register(cmd())
for service in Service.find_all():
self.serviceReg.register(service())
def get(self):
#obtener algun parámetro de la url
#ejemplo: http://localhost:5000/?param1=1¶m2=2
json_data = Service.getAllInvitaciones(db)
param1 = request.args.get('param1')
param2 = request.args.get('param2')
print(param1)
print(param2)
respuesta = {
'response': True,
'msg': 'Mensaje al usuario',
'data': json_data
}
return respuesta
def main():
global mainloop
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
bus = dbus.SystemBus()
advertise_adapter = find_advertise_adapter(bus)
if not advertise_adapter:
print('LEAdvertisingManager1 interface not found')
return
gatt_adapter = find_gatt_adapter(bus)
if not gatt_adapter:
print('GattManager1 interface not found')
return
adapter_props = dbus.Interface(
bus.get_object(BLUEZ_SERVICE_NAME, advertise_adapter), DBUS_PROP_IFACE)
adapter_props.Set("org.bluez.Adapter1", "Powered", dbus.Boolean(1))
ad_manager = dbus.Interface(
bus.get_object(BLUEZ_SERVICE_NAME, advertise_adapter),
LE_ADVERTISING_MANAGER_IFACE)
test_advertisement = TestAdvertisement(bus, 0)
service_manager = dbus.Interface(
bus.get_object(BLUEZ_SERVICE_NAME, gatt_adapter), GATT_MANAGER_IFACE)
mainloop = gobject.MainLoop()
ad_manager.RegisterAdvertisement(test_advertisement.get_path(), {},
reply_handler=register_ad_cb,
error_handler=register_ad_error_cb)
Service.register_service(service_manager, ControlService(bus, 0))
Service.register_service(service_manager, DpgService(bus, 1))
Service.register_service(service_manager,
ReferenceOutputService(bus, 2)) ## mask
Service.register_service(service_manager, ReferenceInputService(bus, 3))
mainloop.run()
# 5. Configure a new global `tensorflow` session
session_conf = tf.compat.v1.ConfigProto(intra_op_parallelism_threads=1, inter_op_parallelism_threads=1)
sess = tf.compat.v1.Session(graph=tf.compat.v1.get_default_graph(), config=session_conf)
tf.compat.v1.keras.backend.set_session(sess)
from ui.ui import *
from service.service import Service
import dlib
from domain.EdgeCNN import *
# Create the network
number_classes = 7
number_features = 32
growthRate = 8
print('[INFO] loading the model...')
net = EdgeCNN(number_features, number_classes, growthRate) # get network architecture
net.load_weights('models/weights-improvement-299-0.65.hdf5') # get the weights of trained model
# Create the face_detector
print('[INFO] loading the face detector...')
face_detector = dlib.get_frontal_face_detector()
# Create the service
service = Service(net = net, face_detector = face_detector)
# start the app
print("[INFO] starting...")
pba = Application(service)
pba.start()
def main():
lobby_manager = LobbyManager()
game_manager = GameManager()
service = Service(lobby_manager, game_manager)
facade = Facade(service)
facade.run(host='0.0.0.0')
def create_car(self, car_owner, car_number):
car = Car(owner=car_owner, number=car_number)
Service.create_car(car)
from flask import Flask, render_template, request
from controller.configuration import Configuration
from controller.monitoring import Monitoring
from controller.api import Api
from service.service import Service
app = Flask(__name__, static_url_path='/assets', static_folder='assets')
import sqLine
configuration = Configuration()
monitoring = Monitoring()
api = Api()
service = Service()
@app.route("/")
def dashboard():
return render_template('dashboard.html')
@app.route("/add-host-snmp", methods=['GET', 'POST'])
def add_host_snmp():
return configuration.add_host_snmp()
@app.route("/del-host-snmp", methods=['GET'])
def del_host_snmp():
return configuration.del_host_snmp()
@app.route("/del-oid-snmp", methods=['GET'])
import sys
sys.path.append("..")
import random
import json
import time
from model.model import Model
from view.view import View
from service.service import Service
from data.data import Data
model = Model()
view = View()
service = Service()
data = Data()
character = [
"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O",
"P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d",
"e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s",
"t", "u", "v", "w", "x", "y", "z"
]
count = 0
while count < 1000:
bookName = ""
authorName = ""
nameLength = random.randint(10, 20)
for i in range(nameLength):
def test_service(self):
service = Service("json_test.json", "json_test.json", "json_test.json",
"json_test.json")
# Customer Options
company = Company()
address = Address()
address.set_address("Strada Academiei nr. 7")
address.set_county("Bucuresti")
address.set_country("Romania")
address.set_postal_code("010011")
company.set_id(1)
company.set_address(address)
company.set_company_name("La Geani")
company.set_registration_number("RO0123")
company.set_fiscal_no("0000231523647")
company.set_email_address("*****@*****.**")
company.set_first_name("Ion")
company.set_last_name("Bogdan")
company.set_phone_number("0752314567")
company.set_fiscal_no("0000012345678")
company.set_registration_number("RO01923")
service.create_customer(company)
self.assertEqual(service.get_company_customer(1), company)
company.set_company_name("Marketplex")
service.modify_customer(1, company)
self.assertEqual(service.get_company_customer(1), company)
service.delete_customer(company)
self.assertEqual(service.view_all_company_customer(), [])
individual = Individual()
individual.set_cnp("1971209075425")
individual.set_id(1)
individual.set_first_name("Petre")
individual.set_last_name("Vasile")
individual.set_phone_number("0745321784")
individual.set_email_address("*****@*****.**")
service.create_customer(individual)
self.assertEqual(service.get_individual_customer(1), individual)
individual.set_last_name("Gigel")
service.modify_customer(1, individual)
self.assertEqual(service.get_individual_customer(1), individual)
service.delete_customer(individual)
self.assertEqual(service.view_all_individual_customer(), [])
individual.set_address(address)
# Currency Options
currency = Currency("$", "Dollar", "USD")
currency.set_id(1)
currency.set_exchange_rate(4.5)
service.create_currency(currency)
self.assertEqual(currency, service.get_currency(1))
currency.set_exchange_rate(4.2)
service.modify_currency(1, currency)
self.assertEqual(currency, service.get_currency(1))
service.delete_currency(1)
self.assertEqual(service.view_currency(), [])
# Item Options
item = Item()
item.set_id(1)
item.set_currency(currency)
item.set_name("McChicken")
item.set_description("Chicken hamburger")
item.set_price(2)
item.set_discount(0)
service.create_item(item)
self.assertEqual(item, service.choose_item(1))
item.set_price(3)
service.modify_item(1, item)
self.assertEqual(item, service.choose_item(1))
service.delete_item(1)
self.assertEqual(service.view_items(), [])
# Bill Options
bill_item = BillItem()
bill_item.set_id(1)
bill_item.set_currency(currency)
bill_item.set_name("McChicken")
bill_item.set_description("Chicken hamburger")
bill_item.set_price(3)
bill_item.set_discount(0)
bill = Invoice()
bill.set_customer(individual)
bill.set_currency(currency)
bill.set_items([bill_item])
bill.set_id(1)
bill.set_issuer(company)
bill.set_issue_date("24.01.2021")
bill.set_due_date("10.02.2021")
bill.set_notes("Platiti la Banca Transilvania")
service.create_item(item)
service.create_bill(bill)
self.assertEqual(service.get_invoice(1), bill)
bill.set_notes("asdfge")
service.modify_bill(1, bill)
self.assertEqual(service.get_invoice(1), bill)
service.add_item_to_bill(1, bill)
bill.add_items(bill_item)
self.assertEqual(service.get_invoice(1), bill)
service.invoice_to_fiscal(1)
fiscal_bill = FiscalBill()
fiscal_bill.set_customer(individual)
fiscal_bill.set_currency(currency)
bill_item.set_quantity(2)
fiscal_bill.set_total(3.0)
fiscal_bill.set_items([bill_item])
fiscal_bill.set_id(1)
fiscal_bill.set_issuer(company)
fiscal_bill.set_issue_date("24.01.2021")
fiscal_bill.set_due_date("10.02.2021")
fiscal_bill.set_notes("asdfge")
self.assertEqual(fiscal_bill, service.get_fiscal(1))
service.delete_bill(bill)
file = open("json_test.json", "w")
file.truncate(0)
file.write("{}")
file.close()
def __test_service():
"""
Function to test service
:return: None
"""
val = BookValidator()
repo = Repository(val)
srv = Service(repo)
srv.add_book("Ion", "Liviu Rebreanu", "Drama", 1912)
assert len(srv.get_all_srv()) == 1
assert srv.get_all_srv()[0].get_title() == "Ion"
srv.add_book("Iona", "Marin Sorescu", "Drama", 1971)
assert len(srv.get_all_srv()) == 2
assert srv.remove_book(1) is not None
assert len(srv.get_all_srv()) == 1
assert srv.remove_book(1) is None
assert srv.modify_book(0, "Prislea", "Petre Ispirescu", "Fictiune",
1960) is not None
assert srv.get_all_srv()[0].get_writer() == "Petre Ispirescu"
srv.add_book("Ion", "Marin Sorescu", "Drama", 1971)
srv.add_book("Ion", "Liviu Rebreanu", "Drama", 1912)
rez = srv.filter_by_title("Ion")
assert len(rez) == 2 and rez[0].get_title() == "Ion"
rez = srv.filter_by_year(1960)
assert len(rez) == 1 and rez[0].get_title() == "Prislea"
sort = srv.sort_by_title(False)
assert sort[0].get_title() <= sort[1].get_title() <= sort[2].get_title(
)
sort = srv.sort_by_title(True)
assert sort[0].get_title() >= sort[1].get_title() >= sort[2].get_title(
)
sort = srv.sort_by_writer(False)
assert sort[0].get_writer() <= sort[1].get_writer(
) <= sort[2].get_writer()
sort = srv.sort_by_writer(True)
assert sort[0].get_writer() >= sort[1].get_writer(
) >= sort[2].get_writer()
sort = srv.sort_by_genre(False)
assert sort[0].get_genre() <= sort[1].get_genre() <= sort[2].get_genre(
)
sort = srv.sort_by_genre(True)
assert sort[0].get_genre() >= sort[1].get_genre() >= sort[2].get_genre(
)
sort = srv.sort_by_year(False)
assert sort[0].get_year() <= sort[1].get_year() <= sort[2].get_year()
sort = srv.sort_by_year(True)
assert sort[0].get_year() >= sort[1].get_year() >= sort[2].get_year()
from service.service import Service
if __name__ == "__main__":
service = Service()
service.run()
def update_car(self, car_owner, car_number, car_id):
new_car = Car(owner=car_owner, number=car_number)
Service.modify_car(car_id, new_car)
def delete_car(self, car_id):
Service.delete_car(car_id)
def get_rocket(name):
return Service.get_rocket(name)
from service.service import Service
def runTest1():
repo = Repository("test1.txt")
service = Service(repo)
c = service.simulate(20, 10, 30)
assert (c.get_genes() == [0, 1, 2, 3, 0])
assert (c.get_distance() == 4)
assert (c.fitness() == 1 / c.get_distance())
def runTest2():
repo = Repository("test2.txt")
service = Service(repo)
c = service.simulate(50, 10, 100)
assert (c.get_genes() == [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0])
assert (c.get_distance() == 10)
assert (c.fitness() == 1 / c.get_distance())
def runAllTest():
runTest1()
runTest2()
repo = Repository("data/150p_eil51.txt")
service = Service(repo)
c = service.simulate(70, 10, 250)
service.write_to_file(c)
from flask import Flask, render_template, request, redirect, jsonify, Response
import uuid
import time
import sqLine
from service.service import Service
service = Service()
class Api:
def api_list_oid_host(self):
id = request.args.get('id')
sqline = sqLine.Sqline()
oids = sqline.raw(
"SELECT oid.idOid,oid.name,oid.oid,oid.units,host_oid.value,host_oid.isWorking from host_oid INNER JOIN oid ON host_oid.idOid = oid.idOid WHERE host_oid.id='{}'"
.format(id))
response = jsonify({'data': oids[0][4]})
response.headers.add('Access-Control-Allow-Origin', '*')
return response
def api_host_ping(self):
id = request.args.get('id')
sqline = sqLine.Sqline()
oids = sqline.raw("SELECT * from host WHERE host.id='{}'".format(id))
response = jsonify({'data': oids[0][7]})
response.headers.add('Access-Control-Allow-Origin', '*')
return response
def api_set_email_ping(self):
return "hello"
def test_functions():
repo_car = FileCarRepo("test_car.txt")
repo_car_wash = FileCarWashRepo("test_car_wash.txt")
service = Service(repo_car, repo_car_wash)
# TEST CAR FUNCTIONS
car1 = Car(1, "AG 25 DMG", "Ian")
service.create_car(car1)
file = open("test_car.txt", "r")
read_car_line = file.readline()
file.close()
read_car = read_car_line.split(",")
car2 = Car(int(read_car[0]), read_car[1], read_car[2].strip("\n"))
assert car2 == car1
car3 = Car(1, "AG 65 DYN", "Ionel")
service.modify_car(1, car3)
file = open("test_car.txt", "r+")
read_car_line = file.readline()
read_car = read_car_line.split(",")
car4 = Car(int(read_car[0]), read_car[1], read_car[2].strip("\n"))
assert car4 == car3
service.delete_car(car3.get_id())
assert service.get_all_car() is not None
# TEST CAR WASH FUNCTIONS
car_wash1 = CarWash(1, "At Bob")
service.create_car_wash(car_wash1)
assert service.get_car_wash(1) == car_wash1
car_wash2 = CarWash(1, "La Geani")
service.modify_car_wash(car_wash2)
assert service.get_car_wash(1) == car_wash2
service.delete_car_wash(1)
assert service.get_all_car_wash() == []
# TEST ADD AND REMOVE FUNCTIONS
service.create_car_wash(car_wash1)
service.create_car(car1)
service.add_to_car_wash(1, 1)
assert service.get_cars_in_car_wash(1)
assert service.filter_by_number("AG")
car_wash2 = service.get_car_wash(1)
assert car_wash2.get_cars() == [car1.get_id()]
service.remove_from_car_wash(car_wash1.get_id(), car1.get_id())
car_wash2 = service.get_car_wash(1)
assert car_wash2.get_cars() == []
file2 = open("test_car_wash.txt", "w")
file.truncate(0)
file2.truncate(0)
file.close()
try:
service.test_input("2", 12)
assert True
except ValidationError:
assert False
'''
Created on Feb 4, 2019
@author: Cristina
'''
from ui.userInterface import UI
from service.service import Service
from repository.repository import Repository
ui = UI(Service(Repository("./files/Emisiuni.txt")))
ui.start()
from repository.repository import Repository
from service.service import Service
from ui.ui import Ui
from utils.utils import computeDistance
# berlin52.txt, Berlin (Germany), 52, optimal path=7542
repository = Repository("data/berlin52.txt", "data/out.txt", False)
service = Service(repository)
ui = Ui(service)
ui.run()
def test_def_test(self):
service = Service()
service.test_def()
import aiohttp_jinja2
from aiohttp import web
from aiohttp.web import json_response
from config import config
from exceptions.service.exceptions import WrongLocationError
from logger.create_logger import create_logger
from service.service import Service
service = Service(config)
routes = web.RouteTableDef()
logger = create_logger(config)
@routes.view("/")
class View(web.View):
@aiohttp_jinja2.template("home/index.html")
async def get(self):
return
@aiohttp_jinja2.template("home/index.html")
async def post(self):
location = (await self.request.post()).get("location")
try:
response = await service.validate_query(location)
except WrongLocationError:
return json_response({"error": "Wrong Location"})
return json_response({"answer": response})
from flask import Flask, request, render_template
from repository.memory import Storage
from service.service import Service
app = Flask(__name__)
app.config.from_object(__name__)
repo = Storage()
service = Service(repo)
@app.route('/')
def index():
return render_template('index.html')
@app.route('/favicon.ico')
def root():
return app.send_static_file('favicon.ico')
@app.route('/create', methods=['POST'])
def create():
data = request.get_json()
key = service.create(data['url'])
return key
@app.route('/<key>', methods=['GET'])
def get(key):
val = service.get(key)
return "not found" if val == None else val
if __name__ == '__main__': # pragma: no cover
app.run(port=80)
def read_coordinates():
coordinates = Service().get_coordinates()
return jsonify(coordinates=coordinates)
