def __init__(self):
"""
Instantiate the plugin and all its modules.
"""
self._core = Core(self)
self._interface = Interface(self)
self._network = Network(self)
def __init__(self, parent: QtWidgets.QWidget=None):
super().__init__(parent)
self.actions = {}
self.menus = {}
self.edit_lines = {}
self.buttons = {}
self.layouts = {}
self.widgets = {}
self.core = Core()
self.create_edit_lines()
self.create_buttons()
self.create_actions()
self.create_menus()
self.create_layouts()
self.create_widgets()
self.create_toolbars()
self.setCentralWidget(self.widgets['central_widget'])
self.connect_widgets_and_layouts()
self.statusBar()
self.connect_signals_to_slots()
def main():
core = Core()
core.cb.set_cb_regstate(regstate_cb)
core.start()
print "Registered at",
print "sip:", core.transport.info().host, " port", core.transport.info(
).port
while True:
print "Menu: m=make call, h=hangup call, a=answer call, q=quit"
input = sys.stdin.readline().rstrip("\r\n")
if input == "m":
print "Destination URI:",
input = sys.stdin.readline().rstrip("\r\n")
if input == "":
continue
core.make_call(input)
continue
elif input == "h":
core.hangup_call(core.calls.current_call)
continue
elif input == "a":
core.answer_call(core.calls.current_call)
continue
elif input == "q":
break
core.stop()
def setUp(self):
self.core = Core()
self.pjvalue = 5
self.pjmod = 2
self.vsvalue = 4
self.vsmod = 1
self.dificultad = 10
self.delim = '\n============================='
def test_subscribing_non_class(self):
class BadSubscriber(BaseModule):
def boot(self):
self.subscribe(lambda: None, types='MyEvent')
ai = Core()
module = BadSubscriber()
ai.add_module(module)
self.assertRaises(ModuleSubscribedToNonClassError, lambda: ai.boot())
def test():
core = Core()
# no_array = ['34XXX', '66XXX', '78XXX', '87XXX', '57XXX', '93XXX', '97XXX', '67XXX', '12XXX', '74XXX', '08XXX', '69XXX', '56XXX', '18XXX', '91XXX', '27XXX', '01XXX', '72XXX', '52XXX', '41XXX', '10XXX', '28XXX', '31XXX', '95XXX', '68XXX', '39XXX', '33XXX', '24XXX', '90XXX', '16XXX', '20XXX', '64XXX', '30XXX', '94XXX', '07XXX', '76XXX', '29XXX', '58XXX', '23XXX', '83XXX', '19XXX', '11XXX', '61XXX', '46XXX', '65XXX', '51XXX', '63XXX', '17XXX', '89XXX', '79XXX']
# for i in range(100):
# period = 258000 + i * 120
# core.get_regression_cycle_v2(period, 50, no_array)
# core.get_regression_cycle(50000)
# core.get_regression_cycle(10000, 10000, 50000, 20)
core.get_max_drop_regression(270000, 50)
def main():
url = ''
t = 30
r = 10
c = ''
r = False
d = 5
try:
opt,argv = getopt.getopt(sys.argv[1:],'hu:t:',['help','url'])
if opt == []:
print '\t[!] Please input the parameter.'
usage()
exit()
except getopt.GetoptError as e:
print e
usage()
exit(0)
for o,v in opt:
if o in ('-h','--help'):
usage()
exit(0)
if o in ('-u','--url'):
if v == '':
print 'url can\'t be null'
exit(0)
url.strip()
if v[0:7] != 'http://':
v = 'http://' + v
if v[-1] != '/':
v += '/'
url = v
if o in ('-t','--thread_num'):
if v.isdigit():
thread_num = int(v)
else :
print 'Thread_num is NOT a digit!'
exit(0)
if o in ('-c','--cookie'):
c = serializeCookie(v)
if o in ('-r','--retry'):
if v.isdigit():
retry = int(v)
else :
print 'retry times is NOT a digit!'
exit(0)
# if o in ('-R','--recursive'):
# r = True
# if o in ('-d','--depth') and v.isdigit():
print '[*] Start'
sTime = time.time()
# print str(sTime)
a = Core(url,t,c,r)
a.createThread()
a.getRes()
print '[*] Used ' + str(time.time()-sTime) + ' s'
def test_module_receives_all_events(self):
ai = Core()
module = AllEventsModule()
ai.add_module(module)
ai.boot()
ai.publish(EventTypeA(content="a"))
ai.publish(EventTypeB(content="b"))
self.assertEqual(['a', 'b'], module.received_events)
def __init__(self, ui):
self.form = ui
# dimanakah letak form.ui????? apa hubungannya????
self.core = Core()
self.holding = False #flag
self.core.cb.set_cb_callstate(self.call_state_cb)
self.core.cb.set_cb_regstate(self.regstate_cb)
self.core.cb.set_cb_incoming_call(self.incoming_call_cb)
self.core.start()
def test_handler_without_type_hint(self):
class ModuleWithMultipleTypes(BaseModule):
def boot(self) -> None:
self.subscribe(self.handle, types=[EventTypeA, EventTypeB])
def handle(self, event):
pass
ai = Core()
ai.add_module(ModuleWithMultipleTypes())
ai.boot()
def startup(verbosity, port, interface):
logging.basicConfig(
format='[%(asctime)s][%(levelname)s]%(name)s: %(message)s',
datefmt='%Y/%m/%d-%H:%M:%S',
level=logging.INFO if verbosity else logging.WARNING)
global house_core
house_core = Core()
if sender.getServerVersion() >= 400:
exit(-1)
# if sender.registerSubscriptions() >= 400:
# exit(-1)
app.run(host=interface, port=port)
def __init__(self):
cmd.Cmd.__init__(self)
self.core = Core()
self.core.list()
self.intro = "\nDecision Support System Logger: For information type help or ? \n"
self.prompt = ">> "
self.completekey = 'tab'
self._hist = []
self._locals = []
self._globals = []
def test_handler_type_matches_subscribe(self):
class ModuleWithTypeMismatch(BaseModule):
def boot(self) -> None:
self.subscribe(self.handle, types=EventTypeA)
def handle(self, event: EventTypeB):
pass
ai = Core()
ai.add_module(ModuleWithTypeMismatch())
self.assertRaises(ModuleError, lambda: ai.boot())
def test_handler_arguments(self):
class FooModule(BaseModule):
def boot(self):
self.subscribe(self.handle)
def handle(self, message):
pass
ai = Core()
ai.add_module(FooModule())
self.assertRaises(ModuleError, lambda: ai.boot())
def test_publishing_non_class(self):
class BadPublisher(BaseModule):
def boot(self):
pass
ai = Core()
module = BadPublisher()
ai.add_module(module)
ai.boot()
self.assertRaises(ModulePublishedBadEventError,
lambda: module.publish("not an event"))
def main() -> int:
"""
Define the project's mainline execution.
Creates and interacts with the command line argument parser, `argparse`,
in addition to setting the debugging standard project-wide, and initiating
file processing with the `Core` module.
This method exists largely as a pseudo-manager for keeping track of program
flow and high-level return codes.
"""
# Define a program for the argument argparser
argparser = argparse.ArgumentParser(description="C file parser for unique \
strings and their associated functions")
# Verbosity is a boolean flag rather than the traditional level
argparser.add_argument("-v",
"--verbose",
help="Set verbosity/\
debug level",
action="store_true")
# A user may specify n files as positional arguments
argparser.add_argument("files", type=argparse.FileType("r"), nargs="+")
# Grab the arguments from the command line
args = argparser.parse_args()
# Configures the hierarchical (root-level) logger instance
# TODO: Granularity beyond ON/OFF may follow in future releases
if args.verbose:
logging.basicConfig(level=logging.DEBUG)
# Create an instance of `Core`, which is responsible for managing
# high level functionality and program flow
mngr = Core()
# Double check that the files specified on the command line are
# in the proper mode and exist at the correct location
Verifier.check_parsable(args.files)
# Process each file, appending unique func:str pairs as found
mngr.process_files(args.files)
# Ultimately produce a final dictionary and convert to JSON
mngr.generate_bundle()
# Drop the JSON bundle to disk under the out/ directory
mngr.export()
return 0
def test_module_should_not_subscribe_after_boot(self):
class ModuleSubscribingAfterBoot(BaseModule):
def boot(self) -> None:
self.subscribe(self.handle, EventTypeA)
def handle(self, event: EventTypeA) -> None:
self.subscribe(lambda event: None, EventTypeB)
ai = Core()
ai.add_module(ModuleSubscribingAfterBoot())
ai.boot()
self.assertRaises(ModuleSubscribedAfterBoot,
lambda: ai.publish(EventTypeA('foobar')))
def __init__(self, app):
QMainWindow.__init__(self)
self.app = app
self.core = Core()
self.assets: Assets = Assets()
self.last_login: str = 'never'
self.login_repeater = Repeater()
self.tray_icon = SystemTrayIcon(parent=self,
assets=self.assets,
profile_list=self.core.config.list_groups())
self.log_dialog = LogDialog(self)
self.config_dialog = ConfigDialog(self)
self.set_key_dialog = SetKeyDialog(self)
self.rotate_key_dialog = RotateKeyDialog(self)
self.tray_icon.show()
def test_add_task(self):
e = []
class ModuleWithTask(BaseModule):
def boot(self) -> None:
self.add_task(self.sleep())
async def sleep(self) -> None:
await asyncio.sleep(0.001)
e.append('done')
ai = Core()
ai.add_module(ModuleWithTask())
ai.boot()
self.assertEqual(['done'], e)
def test_handle_metadata(self):
received_ids = []
class MetadataModule(BaseModule):
def boot(self):
self.subscribe(self.handler)
def handler(self, event: BaseEvent, metadata: Metadata):
received_ids.append(metadata.id)
ai = Core(metadata_provider=lambda: Metadata(id=test_uuid))
ai.add_module(MetadataModule())
ai.boot()
ai.publish(TestEvent('hello'))
self.assertEqual([test_uuid], received_ids)
def test_metadata_id_is_same_for_all_handlers(self):
received_ids = []
class MetadataModule(BaseModule):
def boot(self):
self.subscribe(
lambda metadata: received_ids.append(metadata.id))
self.subscribe(
lambda metadata: received_ids.append(metadata.id))
ai = Core()
ai.add_module(MetadataModule())
ai.boot()
ai.publish(TestEvent('hello'))
self.assertEqual(2, len(received_ids))
self.assertEqual(received_ids[0], received_ids[1])
def main():
banner()
parser = argparse.ArgumentParser(description='UserFinder v1.0.1')
parser.add_argument('-u',
'--url',
type=str,
help='Crawl specific url',
default=None)
parser.add_argument('-n',
'--name',
type=str,
help='Crawl specific name',
default=None,
required=True)
parser.add_argument('-v', "--verbose", action='store_true', default=False)
args = parser.parse_args()
c = Core(name=args.name, url=args.url, verbose=args.verbose)
c.run()
def trigger(self, evaluation_type):
for nc in self.network_configurations:
for spec in self.background_specs:
nc.setup_network_graph(mininet_setup_gap=1, synthesis_setup_gap=1)
background = self.configure(nc, self.run_time, self.base_dir, spec, evaluation_type)
exp = Core(self.run_time,
nc,
self.script_dir,
self.base_dir,
self.replay_pcaps_dir,
self.base_dir + "/logs/" + str(nc.project_name) + "_" + evaluation_type + "_" + str(nc.link_latency) + "_" + str(spec),
background[0],
background[1],
background[2])
exp.start_project()
def setUp(self):
# Bind model classes to test db. Since we have a complete list of
# all models, we do not need to recursively bind dependencies.
test_db.bind(MODELS, bind_refs=False, bind_backrefs=False)
test_db.connect()
test_db.create_tables(MODELS)
# create primitives
for raza in RAZAS:
Raza.create(nombre=raza[1])
for modtype in MOD_TYPE:
Mod.create(nombre=modtype[1])
for dif in DIFICULTADES:
Dificultad.create(valor=dif[0], texto=dif[1])
self.partida = Partida.create(nombre="Partida test")
self.core = Core()
def test_output_expression_result(self):
class TestHelperBot(BaseModule):
events: List[BaseEvent]
def boot(self) -> None:
self.events = []
self.subscribe(lambda event: self.events.append(event))
helper = TestHelperBot()
bot = MathBot()
ai = Core()
ai.add_module(bot)
ai.add_module(helper)
ai.boot()
ai.publish(TextInput('10+2'))
self.assertIn(MathParsed(Addition(Constant(10), Constant(2))),
helper.events)
self.assertIn(TextOutput('The result is: 12.0'), helper.events)
def test_module_receives_only_events_it_subscribed_to(self):
class AEventsModule(BaseModule):
received_events = []
def boot(self):
self.subscribe(self.handle_a, types=EventTypeA)
def handle_a(self, event: EventTypeA):
self.received_events.append(event.content)
ai = Core()
foobar = AEventsModule()
ai.add_module(foobar)
ai.boot()
ai.publish(EventTypeA(content="a"))
ai.publish(EventTypeB(content="b"))
self.assertEqual(['a'], foobar.received_events)
def setUp(self):
self.settings = Settings.load_config('../conf.json')
# Centrifuge uses it's own internal process.
# During running the tests this process prevents correct server shutdown and socket does not returns port.
# To prevent it - centrifuge should be simply disabled.
# (it is not used in this tests)
self.settings.use_centrifuge = False
self.core = Core(self.settings)
def run():
# It is necessary to seed random in forked process,
# otherwise - Crypto would throw an error.
Random.atfork()
self.core.run()
self.process = Process(target=run)
self.process.start()
# Wait until server would be stopped.
sleep(0.5)
from core.core import Core
core = Core()
#getUserSuscribedCommunities
#print core.UserOperation("getByIdUser", {"_id":"5891cced481f3416aa786783"})
#print core.UserOperation("getUserSuscribedCommunities", {"_id":"5891cced481f3416aa786783"})
#print core.CommunityOperation("getUserSuscribedCommunities", {"_id":"5891cced481f3416aa786783"})
#58948f16481f342f73d3d0ab
#print core.UserOperation("suscribeUser2Community", {"id_user":"******","id_community":"58936e7c481f3408dea712ea"})
#print core.UserOperation("unsuscribeUser2Community", {"id_user":"******","id_community":"58945f60481f340f226a9ba1"})
#print core.UserOperation("unsuscribeUser2Community", {"id_user":"******","id_community":"58948f16481f342f73d3d0ab"})
#print core.UserOperation("getByIdUser", {"_id":"5891cd34481f3416aa786785"})
#print core.UserOperation("deleteCommunityUnsuscribe", {"field":"communities_suscribed","_id":"58936e7c481f3408dea712ea"})
#589329df481f341a9db95828
#print core.UserOperation("suscribeUser2Community", {"id_user":"******","id_community":"5893723f481f340b515646a7"})
#print core.UserOperation("suscribeUser2Community", {"id_user":"******","id_community":"5893723f481f340b515646a7"})
#print core.UserOperation("suscribeUser2Community", {"id_user":"******","id_community":"5893723f481f340b515646a7"})
#result = core.PostOperation("getPostByCommunityId", {"community_id" : '5898b236481f3449bb923c94'})
result = core.PostOperation("getCommunityPosts", {"community_id" : '5898b236481f3449bb923c94'})
#result = core.UserOperation("getAllUsersFiltered", {'query':{}, 'filter':{'name':1, 'nick':1}})
print result
#print type(result)
#print result
def __init__(self):
self._core = Core()
self._response = self._core.response
def test_ai_must_be_booted_before_publishing(self):
ai = Core()
self.assertRaises(CoreNotBootedError,
lambda: ai.publish(EventTypeA(content="a")))
