def test_divide(self, x):
"""Tests service.Service.divide(y)"""
result = service.Service().divide(2)
self.assertEqual(result, 3)
result = service.Service().divide(-1)
self.assertEqual(result, -6)
try:
result = service.Service().divide(0)
except ZeroDivisionError:
result = "ZeroDivisionError"
self.assertEqual(result, "ZeroDivisionError")
def test_abs_plus(self):
"""Tests service.Service.abs_plus(x)"""
result = service.Service().abs_plus(1)
self.assertEqual(result, 2)
result = service.Service().abs_plus(-1)
self.assertEqual(result, 2)
result = service.Service().abs_plus(0)
self.assertEqual(result, 1)
result = service.Service().abs_plus(-3.6)
self.assertEqual(result, 4.6)
def working_day(self):
print 'PROBE ready to work, {time}'.format(time=time.strftime('%Y-%m-%d %H:%M:%S'))
active_services = self.get_active_services()
for svc in active_services:
worker = service.Service(service_id=svc[0], probe_id=self.probe_id, cluster_id=self.cluster_id,
transport_protocol=svc[1], file_cmd=svc[2], file_name=svc[3], udp_cmd=svc[4],
path=self.path)
def filter_query_trigger(user_query):
#tokenizing user query
filtered_query = user_query.strip().split()
#calling function for respective query
if "file" in filtered_query:
fo.call(filtered_query)
elif "directory" in filtered_query or "folder" in filtered_query:
do.execute_directory_query(filtered_query)
elif "install" in filtered_query:
im.execute_install_query(filtered_query)
elif "service" in filtered_query:
se.Service(filtered_query)
elif "youtube" in filtered_query or "play" in filtered_query or "video" in filtered_query:
yp.play_youtube(filtered_query)
# search the words on google
elif "search" in filtered_query or "google" in filtered_query:
gs.search_google(filtered_query)
# elif "command" in filtered_query or "directory" in filtered_query or "file" in filtered_query :
# ec.execute_commands(filtered_query)
else:
#executing a command like date, cal, check internet
ec.execute_commands(filtered_query)
def test_complicated_function(self, mock_bad_random):
i = 5
mock_bad_random.return_value = i
br = service.Service()
result2 = br.complicated_function(2)
test = (2.5, 1)
self.assertEqual(test, result2)
def test_abs_plus(self, mock_bad_random):
i = 5
mock_bad_random.return_value = i
br = service.Service()
result2 = br.abs_plus(2)
test = 3
self.assertEqual(test, result2)
def test_divide(self, mock_bad_random):
i = 5
mock_bad_random.return_value = i
br = service.Service()
result2 = br.divide(2)
test = 2.5
self.assertEqual(test, result2)
def main():
global svc
global sigstop
with open('config.json') as cfgfile:
config = json.load(cfgfile)
logging.basicConfig(level=logging.DEBUG,
format='%(asctime)s %(levelname)s %(threadName)s %(relativeCreated)6d %(message)s')
loghdlr = logging.handlers.RotatingFileHandler(config['logfile'], maxBytes=1024*1024*50, backupCount=5)
logger = logging.getLogger('')
logger.addHandler(loghdlr)
logger.info('Execution started')
sys.excepthook = unhandledExceptionHandler
print('Initializing...')
svc = s.Service(config, logger)
signal.signal(signal.SIGINT, stopHandler)
print('Press ctrl-c to stop')
while not sigstop:
time.sleep(1)
logger.info('Execution finished')
def __init__(self):
#wywolanie modulu selenium, otwarcie przegladarki Chrome w trybie automatycznym, przejscie do podanej strony(allegro.pl)
self.service = service.Service('http://allegro.pl')
#definicja zmiennej tytul w celu porownania z tytulem strony
self.title = 'Allegro.pl – najlepsze ceny, największy wybór i zawsze bezpieczne zakupy online'
#zdefiniowanie szukanego elementu
self.serch_item = 'rower'
def on_add_device(self, name, ip):
if ip not in self.zeptrion_devices:
conn = ws.Connection(ip, self.on_close_ws, self.on_ws_message)
self.zeptrion_devices[ip] = conn
self.zeptrion_devices[ip].bta = '.........'
self.zeptrion_devices[ip].timer = None
self.zeptrion_devices[ip].service = service.Service(name)
print('new zeptrion device [%s][%s]' % (ip, name))
def init():
"""Initialize the XMPP module"""
menu = cfg.main_menu.get('apps:index')
menu.add_item('Chat', 'icon-comment', '/../jwchat', 20)
menu.add_urlname('XMPP', 'icon-comment', 'xmpp:index', 40)
service.Service('xmpp-client',
_('Chat Server - client connections'),
is_external=True,
enabled=True)
service.Service('xmpp-server',
_('Chat Server - server connections'),
is_external=True,
enabled=True)
service.Service('xmpp-bosh',
_('Chat Server - web interface'),
is_external=True,
enabled=True)
def process_service_file():
service_dict = {}
service_file = open("services.txt", 'r')
for service_inp in service_file:
service_split = service_inp.rstrip().split('#')
service_obj = service.Service(service_split[0], service_split[1],
service_split[2])
service_dict[service_split[0]] = service_obj
return service_dict
def init():
"""Initialize the ownCloud module"""
menu = cfg.main_menu.get('apps:index')
menu.add_urlname('Owncloud', 'icon-picture', 'owncloud:index', 35)
status = get_status()
global SERVICE # pylint: disable-msg=W0603
SERVICE = service.Service('owncloud', _('ownCloud'), ['http', 'https'],
is_external=True, enabled=status['enabled'])
def main():
shared.service = service.Service()
shared.interface = xinterface.Interface()
shared.cmanager = manager.Config()
shared.pmanager = manager.Phrases()
shared.service.start()
shared.interface.start()
shared.service.grab_hotkeys()
Indicator()
def setUpEvent(local_addr,peer_addr,mode):
ser = service.Service(local_addr, peer_addr)
ser.start()
'''tasks = [
def test_service_move_long(self):
s = service.Service()
s.state = game_state.GameState()
s.state.pathfinding_grid = graph_2d.SquareGraph(3, 3)
s.state.characters = {0: character.Character("Bob")}
# character id, destination coordinate
r = s.move(0, (2, 2))
for _ in xrange(200):
s.inc_tick()
self.assertEqual(s.character_location(0), (2, 2))
def __init__(self, callback=None):
self.main_loop = threading.Thread(target=self._main_loop,
name='Main Loop',
daemon=True)
self.queue = queue.Queue()
self.event_hook = threading.Thread(target=self._event_hook,
name='Event Hook',
daemon=True)
self.callback = callback
self.last_time_key_pressed = 0
self.service = service.Service(self)
self.static_display = display.Display()
self.local_display = display.Display()
self.record_display = display.Display()
self.context = self.record_display.record_create_context(
0, [record.AllClients
], [{
'core_requests': (0, 0),
'core_replies': (0, 0),
'ext_requests': (0, 0, 0, 0),
'ext_replies': (0, 0, 0, 0),
'delivered_events': (X.FocusIn, X.FocusIn),
'device_events': (X.KeyPress, X.KeyRelease),
'errors': (0, 0),
'client_started': False,
'client_died': False,
}])
self.MODIFIER_MASK = {
'NoModifier': 0,
'<Shift>': X.ShiftMask,
'<Control>': X.ControlMask,
'<Alt>': 0,
'<AltGr>': 0,
'<Super>': 0,
'<NumLock>': 0
}
self.set_modifier_mask()
self.KEYPAD = set()
for name in dir(CONSTANTS.XK):
if name.startswith('XK_KP'):
self.KEYPAD.add(
self.local_display.keysym_to_keycode(
getattr(CONSTANTS.XK, name)))
self.static_root = self.static_display.screen().root
self.static_window = self.static_display.get_input_focus().focus
self.root_window = self.local_display.screen().root
self._name_atom = self.local_display.intern_atom("_NET_WM_NAME", True)
self._visible_name_atom = self.local_display.intern_atom(
"_NET_WM_VISIBLE_NAME", True)
self.update_active_window()
def worker(self):
service_active = self.get_active_service()
# print service_active
for service_instance in service_active:
service_id = service_instance[0]
service_file = service_instance[1]
service_command = service_instance[2]
if service_file is None:
service_obj = service.Service(service_id, self.id, service_command)
else:
os.system('python {}/{} {} {} {}'.format(self.path, service_file, service_id, self.id, service_command))
def setUp(self):
sys.path.insert(0, os.getcwd())
source = open("TestingService.py", 'w')
source.write(_serviceCode)
source.close()
del source
import service
self.app = service.Reload(service.Service([
"TestingService",
]))
def createApp():
return self.app
wsgi_intercept.urllib2_intercept.install_opener()
wsgi_intercept.add_wsgi_intercept('myhost', 80, createApp)
def parse(self, command_line):
"""Fill in the AllJoyn data structures from the XML file."""
node = self.tree.getroot()
if node.tag != "node":
error = "Root xml object must be a 'node'."
error = AllJoynCodeGenCommon.get_xml_error(node, error)
raise ValidateException(error)
xml_bus_object_path = node.get("name")
cmd_bus_object_path = command_line.object_path
service_name = self.__get_bus_object_path(xml_bus_object_path,
cmd_bus_object_path, node)
return_value = service.Service(service_name)
return_value.parse(node, command_line.lax_naming)
return return_value
def workday(self):
state, collection_id = self.details()
if state.lower() == 'active' and collection_id != None:
print 'Ready to work. {time}'.format(
time=time.strftime('%Y-%m-%d %H:%M:%S'))
active_services = self.get_active_services(collection_id)
for svc in active_services:
# print svc
tester = service.Service(service_id=svc[0],
probe_id=self.probe_id,
collection_id=collection_id,
transport_protocol=svc[1],
file_cmd=svc[2],
file_name=svc[3],
udp_cmd=svc[4])
else:
print 'Probe fall as sleep ({state})'.format(state=state)
def getLoader(self, gml=None):
"""
Create a loader for EPSG objects
By default the loader is created from GML returned by the EPSG
web service but a custom GML string can be passed in using the
`gml` parameter.
"""
if gml is None:
# connect to the epsg service and retrieve the gml
svc = service.Service()
svc.connect()
gml = svc.export()
svc.close()
# load the gml into the EPSG object structure
xml = load.XML.FromString(gml)
loader = load.XMLLoader(xml)
loader.load()
return loader
def run(self):
print("type \"exit\" to exit the program")
while True:
path = self._getFilePath()
if path is None:
return
self._s = service.Service(sudokuParser.Sudokup(path))
if self._valid():
break
self._ofile = self._getFilePath("w")
if self._ofile is None:
return
algorithm = self._getAlg()
if algorithm == "EXIT":
return
show = False
if algorithm is not None:
print(
"show updates of sudoku (can REALLY SLOW DOWN the algorithm)?(Y/n)"
)
show = self._getResponse()
print("print solved sudoku on screen too ? (Y/n)")
show_final = self._getResponse()
timeS = time.time()
if algorithm is None:
return
elif algorithm == "GREEDY":
s = self._s.greedy(self._ofile, show, show_final)
elif algorithm == "GA":
s = self._ga()
elif algorithm == "HC":
s = self._hc()
else:
s = self._s.dfs(self._ofile, show, show_final)
if show_final:
print(s)
print("finished in {} seconds".format(time.time() - timeS))
def test_bad_random(self, x):
"""Tests service.Service.bad_random()"""
result = service.Service().bad_random()
self.assertEqual(result, 6)
def test_complicated_function(self, x):
"""Tests service.Service.complicated_function(x)"""
results = service.Service().complicated_function(2)
self.assertEqual(results[0], 3)
self.assertEqual(results[1], 0)
def start(self):
if self.service is None:
self.service = service.Service(self)
self.service.start()
self.main_loop.start()
self.event_hook.start()
from flask import Flask
from flask import request
from flask import jsonify
from flask import abort
from flask import Response
from flask import render_template
import service as serv
from datetime import datetime, timedelta
app = Flask(__name__)
service = serv.Service()
def get_period(begin, end):
if begin == None:
begin = datetime.now()
else:
begin = datetime.strptime(begin, "%Y-%m-%d")
if end == None:
end = begin + timedelta(days=1)
end = end.strftime('%Y-%m-%d')
begin = begin.strftime('%Y-%m-%d')
return (begin, end)
@app.route("/")
def hello():
return "insights"
@app.route("/product/<product>")
def product_handler(product):
def main():
ta = twitter.TwitterApi()
serv = service.Service(ta, "api-consumer-key", "api-consumer-secret")
token = serv.getRequestToken()
return response_jsonp(result, callback)
@app.route("/load_newpatient_data", methods=['GET'])
def api_load_calledpatient_data():
file = request.args.get("file")
lines = file.split("\r")
Lines = lines[1:]
for line in Lines:
service_imp.load_newpatient_data(line)
return "Correct"
@app.route("/<path:path>")
def api_file(path):
return send_from_directory('./view/', path)
if __name__ == '__main__':
global service_imp
service_imp = service.Service()
app.run(host='0.0.0.0', port=8081, debug=True, use_reloader=False)
def test_no_lock_permissions(self):
"""
Test starting a service without necessary permissions.
"""
service.Service(NAME).start()
