示例#1
0
 def setup(self):
     """
     Initializes instance variables, creates manager instance and tests connection
     @return: Nothing
     """
     # Retrieve configuration settings
     addr = self.classconfig['addr']
     password = self.classconfig['password']
     if not addr:
         raise Exception('No address specified')
     # Check if addr is a "host:port" string
     (host, colon, port) = addr.partition(":")
     try:
         if colon:
             # IPv4/IPv6
             self._m = manager.manager(host=host,
                                       port=int(port),
                                       password=password)
         else:
             # UNIX Socket
             self._m = manager.manager(path=addr, password=password)
         # Test connection
         self.getpid()
     except Exception, e:
         raise Exception(str(e))
示例#2
0
 def __init__(self, *args, **kwargs):
     """
     Initializes instance variables, creates manager instance and tests connection
     @return: Nothing
     """
     # Retrieve configuration settings
     addr = self.app.get_config(self).addr
     password = self.app.get_config(self).password
     if not addr:
         raise ConfigurationError("No address specified")
     # Check if addr is a "host:port" string
     (host, colon, port) = addr.partition(":")
     try:
         if colon:
             # IPv4/IPv6
             self._m = manager.manager(host=host,
                                       port=int(port),
                                       password=password)
         else:
             # UNIX Socket
             self._m = manager.manager(path=addr, password=password)
         # Test connection
         self.getpid()
     except Exception, e:
         raise ConfigurationError(str(e))
def main():
    w = World(5, 5, [(0, 0, 5), (2, 2, 5), (4, 4, 5)], [(1, 4, 5), (3, 4, 5),
                                                        (4, 1, 5)], -1, 15, 15)
    a = Agent(1, 1)

    # This should run experiment number 1.  8000 steps total, the first 4000
    # steps we use PRANDOM policy, then we use PGREEDY for the next 4000 steps
    manager(w, a, q_learning, 0.3, 0.5, PRANDOM, 8000, [(4000, PGREEDY)])
示例#4
0
def jump():
    global name
    reg = Gui()
    if re.match("S", name):
        student(reg, mysql, name)
        gui.close()
    elif re.match("T", name):
        teacher(reg, mysql, name)
        gui.close()
    elif re.match("W", name):
        worker(reg, mysql, name)
        gui.close()
    elif re.match("M", name):
        manager(reg, mysql, name)
        gui.close()
    gui.close()
示例#5
0
    def __init__(this, name, dateTime, repeat, mus, volume, useGenetic,
                 usePuzzle):

        populationSize = 5

        #ATRIBS
        this.name = name
        this.dateTime = dateTime
        this.repeat = repeat
        this.mus = mus
        this.volume = volume
        this.useGenetic = useGenetic
        this.usePuzzle = usePuzzle
        this.activate = True
        this.wakeTime = 160

        #POPULATION MAKER FOR GENETIC
        transfer = copy.copy(this)
        transfer.wakeTime = 200
        this.population = manager.manager()
        this.population.add_alarm(transfer)

        for i in range(0, populationSize):

            transfer.volume = this.volume + random.randint(-15, 15)
            transfer.mus = this.population.avaibleSongs[random.randint(
                0,
                len(this.population.avaibleSongs) - 1)]
            transfer.usePuzzle = bool(random.getrandbits(1))
            this.population.add_alarm(transfer)
示例#6
0
    def __init__(self, model=None, *args, **kwargs):

        self.title_font = tkfont.Font(family='Helvetica',
                                      size=18,
                                      weight="bold",
                                      slant="italic")
        # the container is where we'll stack a bunch of frames
        # on top of each other, then the one we want visible
        # will be raised above the others
        container = tk.Frame(root)
        container.pack(side="top", fill="both", expand=True)
        container.grid_rowconfigure(0, weight=1)
        container.grid_columnconfigure(0, weight=1)

        self.frames = {}
        self.frames["startPage"] = startPage(container, self)
        self.frames["startPage"].grid(row=0, column=0, sticky="nsew")

        self.frames["login"] = login(container, self)
        self.frames["login"].grid(row=0, column=0, sticky="nsew")

        self.frames["userMenu"] = userMenu(container, self)
        self.frames["userMenu"].grid(row=0, column=0, sticky="nsew")

        self.frames["manager"] = manager(container, self)
        self.frames["manager"].grid(row=0, column=0, sticky="nsew")

        self.frames["graphData"] = graphData(container, self)
        self.frames["graphData"].grid(row=0, column=0, sticky="nsew")

        self.frames["updateRegulations"] = updateRegulations(container, self)
        self.frames["updateRegulations"].grid(row=0, column=0, sticky="nsew")

        self.show_frame("login")
示例#7
0
    def initialize(self):
        _import()
        """アプリを初期化する。"""
        self.setGlobalVars()

        self.proxyEnviron = proxyUtil.virtualProxyEnviron()
        self.setProxyEnviron()
        self.installThreadExcepthook()
        # update関係を準備
        if self.config.getboolean("general", "update"):
            globalVars.update.update(True)
        self.hMainView = main.MainView()
        if self.config.getboolean(self.hMainView.identifier, "maximized",
                                  False):
            self.hMainView.hFrame.Maximize()
        self.hMainView.Show()
        # sessions.dat対応
        if self.config.getint("general", "fileVersion", 100) == 100:
            if os.path.exists(constants.SESSION_FILE_NAME):
                try:
                    os.remove(constants.SESSION_FILE_NAME)
                    self.log.debug("File %s deleted." %
                                   constants.SESSION_FILE_NAME)
                except Exception as e:
                    self.log.error("Failed to delete file %s: e" %
                                   constants.SESSION_FILE_NAME)
            self.config["general"]["fileVersion"] = 101
        self.accountManager = twitcasting.accountManager.AccountManager()
        self.hasAccountIssue = False
        self.Manager = manager.manager(self.hMainView)
        self.postItem = twitcasting.postItem.PostItem()
        if len(self.accountManager.tokens) == 0:
            simpleDialog.dialog(
                _("アカウント登録"),
                _("アカウントが登録されていません。ライブに接続する前に、設定メニューのアカウントマネージャからアカウントの登録を行ってください。"
                  ))
            self.hasAccountIssue = True
            return True
        for i in self.accountManager.tokens:
            if datetime.datetime.now().timestamp() > i["expires_at"]:
                simpleDialog.dialog(
                    _("アカウントの再登録"),
                    _("期限が切れたトークンが見つかりました。設定メニューのアカウントマネージャから、再度アカウントの追加を行ってください。"
                      ))
                self.accountManager.deleteAccount(
                    self.accountManager.tokens.index(i))
                self.hasAccountIssue = True
        self.accountManager.removeUnavailableTokens()
        if len(sys.argv) == 2:
            self.hMainView.Clear()
            self.Manager.connect(sys.argv[1])
            return True
        if self.hasAccountIssue == False and self.config.getboolean(
                "general", "autoconnect", True) == True:
            self.hMainView.events.connect()
            return True
示例#8
0
def main():
    """
    Main method to control the program flow
    """
    # set runtime name
    Vault.set_runtime_name(Util.datetime_to_string())

    # create runtime directory
    mkdir(f"{SESSION_CACHE_PATH}/{Vault.get_runtime_name()}")

    # set up threading
    Thread.set_interrupt(False)
    event = threading.Event()

    # start threads
    manager_thread = manager(event)
    Escapy.async_sniff(custom_action)

    # menu
    info_data = [
        f"{RED}Sniffer is running but not saving anything locally{RESET}",
        f"{GREEN}Sniffer is running saving packets locally{RESET}"
    ]
    option = [
        "Type \"start\" to start saving: ", "Type \"stop\" to stop saving: "
    ]

    while True:
        print(info_data[0 if not Vault.get_saving() else 1], end="\n")
        print(
            f"Dashboard: {YELLOW}http://127.0.0.1:8000{RESET} | \'q\' to stop")
        user_input = input(option[0 if not Vault.get_saving() else 1])
        if not Vault.get_saving() and user_input == "start":
            Util.start_saving()

        elif Vault.get_saving() and user_input == "stop":
            Util.stop_saving()

        elif user_input == "q":
            break

        else:
            print(f"{YELLOW}Invalid option{RESET}", end="\n\n")

    # SAVE TO FILE IF PROGRAM ENDED AND SAVING IS TRUE
    if Vault.get_saving():
        Util.stop_saving()

    # interrupt threads
    Thread.set_interrupt(True)
    event.set()
    Escapy.stop()

    # wait for threads to complete
    manager_thread.join()
示例#9
0
def engine(initUrls):

    total_pages = manager(initUrls)

    downloader()

    success_page = int(redis.get('success'))
    success_rate = success_page / total_pages
    print('success_page:', success_page)
    print('total_pages:', total_pages)
    print('success_rate: %0.2f%%' % (success_rate * 100))
示例#10
0
 def setUp(self):
     db.delete('Users', where='id > 0')
     self.input_mock = MagicMock()
     self.winput = patch('web.input')
     self.input_mock.uname = 'kevin'
     self.input_mock.utype = 1
     self.input_mock.pword = 'password'
     self.config_mock = MagicMock()
     self.config = patch('web.config', new=self.config_mock)
     self.config_mock._session.roleid = 1
     self.manager = manager()
示例#11
0
 def __init__(self, machine_services: object, server_config: object):
     # Services file position
     self.root_service_log = os.path.join("machine-services",
                                          machine_services)
     # Services file config
     self.root_service_cfg = os.path.join("services-cfg", server_config)
     # Config options of active services that must be initialized
     self.__server_config = self.__retrive_active_services()
     # Services Manager
     self.__manager = manager(self.__server_config)
     # All active services
     self.__services = None
示例#12
0
文件: backend.py 项目: Bryukh/ajenti
 def __init__(self, *args, **kwargs):
     """
     Initializes instance variables, creates manager instance and tests connection
     @return: Nothing
     """
     # Retrieve configuration settings
     addr = self.app.get_config(self).addr
     password = self.app.get_config(self).password
     if not addr:
         raise ConfigurationError("No address specified")
     # Check if addr is a "host:port" string
     (host, colon, port) = addr.partition(":")
     try:
         if colon:
             # IPv4/IPv6
             self._m = manager.manager(host = host, port = int(port), password = password)
         else:
             # UNIX Socket
             self._m = manager.manager(path = addr, password = password)
         # Test connection
         self.getpid()
     except Exception, e:
         raise ConfigurationError(str(e))
示例#13
0
 def setup(self):
     """
     Initializes instance variables, creates manager instance and tests connection
     @return: Nothing
     """
     # Retrieve configuration settings
     addr = self.classconfig["addr"]
     password = self.classconfig["password"]
     if not addr:
         raise Exception("No address specified")
     # Check if addr is a "host:port" string
     (host, colon, port) = addr.partition(":")
     try:
         if colon:
             # IPv4/IPv6
             self._m = manager.manager(host=host, port=int(port), password=password)
         else:
             # UNIX Socket
             self._m = manager.manager(path=addr, password=password)
         # Test connection
         self.getpid()
     except Exception, e:
         raise Exception(str(e))
示例#14
0
	def initialize(self):
		"""アプリを初期化する。"""
		#実行環境の取得(exeファイルorインタプリタ)
		self.frozen=hasattr(sys,"frozen")
		self.InitLogger()
		self.LoadSettings()
		locale.setlocale(locale.LC_TIME,self.config["general"]["locale"])
		self.SetTimeZone()
		self.InitTranslation()

		# 音声読み上げの準備
		reader=self.config["autoReadingOptions"]["output"]
		if(reader=="PCTK"):
			self.log.info("use reader 'PCTalker'")
			self.speech=accessible_output2.outputs.pc_talker.PCTalker()
		elif(reader=="NVDA"):
			self.log.info("use reader 'NVDA'")
			self.speech=accessible_output2.outputs.nvda.NVDA()
		#SAPI4はバグってるっぽいので無効にしておく
		#elif(reader=="SAPI4"):
			#self.log.info("use reader 'SAPI4'")
			#self.speech=accessible_output2.outputs.sapi4.Sapi4()
		elif(reader=="SAPI5"):
			self.log.info("use reader 'SAPI5'")
			self.speech=accessible_output2.outputs.sapi5.SAPI5()
		elif(reader=="AUTO"):
			self.log.info("use reader 'AUTO'")
			self.speech=accessible_output2.outputs.auto.Auto()
		elif(reader=="JAWS"):
			self.log.info("use reader 'JAWS'")
			self.speech=accessible_output2.outputs.jaws.Jaws()
		elif(reader=="CLIPBOARD"):
			self.log.info("use reader 'CLIPBOARD'")
			self.speech=accessible_output2.outputs.clipboard.Clipboard()
		elif(reader=="NOSPEECH"):
			self.log.info("use reader 'NOSPEECH'")
			self.speech=accessible_output2.outputs.nospeech.NoSpeech()
		else:
			self.config.set("speech","reader","AUTO")
			self.log.warning("Setting missed! speech.reader reset to 'AUTO'")
			self.speech=accessible_output2.outputs.auto.Auto()

		# メインビューを表示
		self.hMainView=main.MainView()
		self.hMainView.Show()
		self.Manager = manager.manager(self.hMainView)
		return True
示例#15
0
    def __init__(self):
        #read config, create connections
        self.db_config = {}

        ini_parser = configparser.ConfigParser()
        ini_parser.read("config.ini", 'utf-8')
        for section in ini_parser.sections():
            self.db_config[section] = {}
            for option in ini_parser.options(section):
                self.db_config[section][option] = ini_parser.get(section,option)

        try:
            self.db_connection_from = dbConnection(self.db_config['source_db'])
            self.db_connection_to = dbConnection(self.db_config['target_db'])
            self.db_connection_target = dbConnection(self.db_config['target_db'], False)
        except dbException:
            sys.exit(1)

        self.informationParser = manager()
示例#16
0
    def __init__(self, parent=None, f=0):
        super(AddDialog, self).__init__(parent=parent, f=f)

        wrap = QtGui.QVBoxLayout()

        horiz = QtGui.QHBoxLayout()

        wrap.addLayout(horiz, 10)

        buttons = QtGui.QDialogButtonBox(QtGui.QDialogButtonBox.Ok |
                                         QtGui.QDialogButtonBox.Cancel)

        buttons.accepted.connect(self.accept)
        buttons.rejected.connect(self.reject)

        ok = buttons.button(QtGui.QDialogButtonBox.StandardButton.Ok)
        cancel = buttons.button(QtGui.QDialogButtonBox.StandardButton.Cancel)

        ok.setDefault(True)
        cancel.setDefault(False)

        wrap.addWidget(buttons)

        self.setLayout(wrap)

        self.tree = CDMSFileTree()
        tree_layout = QtGui.QVBoxLayout()
        toolbar = AddEditRemoveToolbar(u"Available Files",
                                       add_action=self.add_file,
                                       remove_action=self.remove_file)

        tree_layout.addWidget(toolbar, 0)
        tree_layout.addWidget(self.tree, 10)
        m = manager()
        for f in m.files:
            self.tree.add_file(m.files[f])

        m.addedFile.connect(self.addFileToTree)

        horiz.addLayout(tree_layout, 2)

        self.chooser = CDMSFileChooser()
        self.chooser.accepted.connect(self.added_files)
示例#17
0
def get_tasks():
    lenght = float(request.form['lenght'])
    bredth = float(request.form['bredth'])
    # check if the post request has the file part
    if 'file' not in request.files:
        flash('No file part')
    file = request.files['image']
    # if user does not select file, browser also
    # submit an empty part without filename

    if file.filename == '':
        flash('No selected file')
        # return redirect(request.url)

    if file and allowed_file(file.filename):
        filename = str(uuid.uuid4())
        file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
        # return redirect(url_for('uploaded_file',
                                # filename=filename))

    image=UPLOAD_FOLDER+filename
    no_of_colors = int(request.form['no_of_colors'])
    result = manager.manager(lenght, bredth, image, no_of_colors).valueTaker()
    area=float(result[1])
    tasks = []
    for values in result[0]:
        percent=values[0]
        percentNum = str(percent[:-1])
        color=values[1]
        hashVal=values[2]
        areaPercent=float(percentNum)*area/100

        task1=[
            {
                'percent':percent,
                'color':color,
                'hash':hashVal,
                'areaPercent':areaPercent,

            },
        ]
        tasks.append(task1)
    return jsonify({'tasks': tasks})
示例#18
0
    def initialize(self):
        _import()
        """アプリを初期化する。"""
        self.setGlobalVars()

        self.proxyEnviron = proxyUtil.virtualProxyEnviron()
        self.setProxyEnviron()
        self.installThreadExcepthook()
        # update関係を準備
        if self.config.getboolean("general", "update"):
            globalVars.update.update(True)
        self.hMainView = main.MainView()
        if self.config.getboolean(self.hMainView.identifier, "maximized",
                                  False):
            self.hMainView.hFrame.Maximize()
        self.hMainView.Show()
        self.accountManager = twitcasting.accountManager.AccountManager()
        self.hasAccountIssue = False
        self.Manager = manager.manager(self.hMainView)
        if len(self.accountManager.tokens) == 0:
            simpleDialog.dialog(
                _("アカウント登録"),
                _("アカウントが登録されていません。ライブに接続する前に、設定メニューのアカウントマネージャからアカウントの登録を行ってください。"
                  ))
            self.hasAccountIssue = True
            return True
        for i in self.accountManager.tokens:
            if datetime.datetime.now().timestamp() > i["expires_at"]:
                simpleDialog.dialog(
                    "",
                    _("期限が切れたトークンが見つかりました。設定メニューのアカウントマネージャから、再度アカウントの追加を行ってください。"
                      ))
                self.accountManager.deleteAccount(
                    self.accountManager.tokens.index(i))
                self.hasAccountIssue = True
        if len(sys.argv) == 2:
            self.hMainView.Clear()
            self.Manager.connect(sys.argv[1])
            return True
        if self.hasAccountIssue == False and self.config.getboolean(
                "general", "autoconnect", True) == True:
            self.hMainView.events.connect()
            return True
示例#19
0
    def updatemanager(self):
        import manager
        con = db.createconnection()

        self.a = self.txtusername.text()

        self.b = self.txtphone.text()
        self.c = self.txtdob.text()
        self.d = self.txtaddress.text()
        self.e = self.txtcity.text()
        self.f = self.txtcollege.text()
        query = "update managerprofile set Name=%s,Phone=%s,DoB=%s,Address=%s,City=%s,College=%s where UserId=%s"
        cursor = con.cursor()
        cursor.execute(
            query,
            (self.a, self.b, self.c, self.d, self.e, self.f, self.userid))
        con.commit()
        self.back = manager.manager()
        self.back.show()
        self.back.lbluser.setText(self.userid)
        self.close()
示例#20
0
    def __init__(self):
        #read config, create connections
        self.db_config = {}

        ini_parser = configparser.ConfigParser()
        ini_parser.read("config.ini", 'utf-8')
        for section in ini_parser.sections():
            self.db_config[section] = {}
            for option in ini_parser.options(section):
                self.db_config[section][option] = ini_parser.get(
                    section, option)

        try:
            self.db_connection_from = dbConnection(self.db_config['source_db'])
            self.db_connection_to = dbConnection(self.db_config['target_db'])
            self.db_connection_target = dbConnection(
                self.db_config['target_db'], False)
        except dbException:
            sys.exit(1)

        self.informationParser = manager()
示例#21
0
文件: test.py 项目: jmccormack200/SDR
def main():
    """ Parser Options """
    parser = OptionParser (option_class=eng_option)
    manager.add_parser_options (parser)
    (options, args) = parser.parse_args ()
    if len(args)!=0:
        parser.print_help()
        sys.exit(1)

    phy   = PyHydra.transceiver(options)
    mpif  = PyHydra.mpif_impl(options)
    mpif.set_transceiver(phy)

    g = PyHydra.FuncThread(phy.run)
    g.start()
    mpif.start()

    mgr = manager(options)
    mgr.SetMPIF(mpif)
    
    h = PyHydra.FuncThread(bar, "bar", mgr, mgr.control)
    h.setDaemon(1)
    h.start()
    mgr.run()
示例#22
0
import manager

if __name__ == '__main__':
    new_manager = manager.manager()
    new_manager.run()
示例#23
0
	def __init__(self):
		"""Initialize the interperter"""
		self._logger = logger.logger()
		self._manager = manager.manager(self._logger)
示例#24
0
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from telegram import Updater
import telegram
import logging
from manager import manager
from datetime import datetime
from mods import logger_sys as log
from time import sleep
id_channel = -116368010
id_priva = 84340477
man = manager()
logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.WARNING)
logger = logging.getLogger(__name__)

def packet(p,a):
    name = p.message.from_user.username
    id = p.message.chat_id
    text = p.message.text
    msg_id = p.message.message_id
    return {"name":name,"id":id,"text":text,"args":a, "msg_id": msg_id}

def get_print_time():
    return "%s:%s" % (datetime.now().hour, datetime.now().minute)

def brew(bot,update,args):
    p = packet(update,args)
    man.queue_coffee(p)
    print("%s - Brew %s" % (get_print_time(), p["name"]))

def brew_timer(bot):
示例#25
0
文件: main.py 项目: LarryCN/VEDiC
import time
import cPickle
import parser
import sys
import manager
import subindex
import config

PENDING = 0
RUNNING = 1
CHECKING = 2

doc_dic = {}
docid = 0

mgr = manager.manager()

#COUNTNUM = 12000
COUNTNUM = 500
COUNTNUM_L = 20

mgrcount = 0

def blockmanage(docid, parsed_data):
    global mgr, mgrcount
    print(mgrcount)
    mgrcount += 1
    if mgr.state == PENDING:
        block = subindex.subindex(mgr.blocknum, config.DATAPATH)
        mgr.blocknum += 1
        mgr.block.append(block)
示例#26
0
count_limit.set('请输入运行次数')

time_limit = tk.StringVar()
time_limit.set('请输入运行时间(分钟)')

win_name = tk.StringVar()
win_name.set('请输入模拟器窗口名(默认MuMu)')

recharge_num = tk.StringVar()
recharge_num.set('请输入碎石数量')

ratio = tk.StringVar()
ratio.set('请输入系统缩放倍率(默认1.5)')
w = 400
h = 300
auto = manager("明日方舟 - MuMu模拟器")
status_message = tk.StringVar()
status_message.set(auto.status_message)
time_message = tk.StringVar()
time_message.set(auto.time_message)

entry_win_name = tk.Entry(window, textvariable=win_name,width = 35, font=("微软雅黑", 14))
entry_win_name.pack(anchor='center')
entry_ratio = tk.Entry(window, textvariable=ratio, width = 35, font=("微软雅黑", 14))
entry_ratio.pack(anchor='center')

entry_recharge_num = tk.Entry(window, textvariable=recharge_num, width = 35, font=("微软雅黑", 14))
entry_recharge_num.pack(anchor='center')

entry_count_limit = tk.Entry(window, textvariable=count_limit, width = 35, font=("微软雅黑", 14))
entry_count_limit.pack(anchor='center')
示例#27
0
import shelve
from person import person
from manager import manager
bob=person('bob smith',42,30000,'sweng')
sue=person('sue jones',45,40000,'music')
tom=manager('tom doe',50,50000)
db=shelve.open('class-shelve')
db['bob']=bob
db['sue']=sue
db['tom']=tom
db.close()

示例#28
0
        elif this_time - self.last_time > self.interval:
            self.send(this_time)
        return done

"""listener args are [port]"""
class listener(manager.worker):
    def setup(self):
        self.port = self.args[0]
        self.soc = socket(AF_INET, SOCK_DGRAM)
        self.soc.bind(('', self.port))
        self.soc.settimeout(0.1)
        self.soc.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)

    def work(self):
        try:
            data, address = self.soc.recvfrom(1024)
        except timeout:
            return False
        else:
            self.queue.append(("listener", data, address))
        return False #this thread will never finish, it will only be killed by the others

if __name__ == "__main__":
    prog = manager.manager()
    prog.add_thread(listener, 12345)
    prog.add_thread(broadcaster, 12345, "This is all you get", -1)
    prog.add_thread(broadcaster, 12345, "hello", 1)

    prog.start_threads()
    prog.run()
示例#29
0
文件: vhmserver.py 项目: Pajinek/vhm
 def check_services(self):
     mng = manager(self.conf)
     self.rpc_srv.set_procs_running(self.token, mng.get_list())
示例#30
0
import flask
import gerador
import random
import manager
from flask import request
from flask_socketio import SocketIO
import json

app = flask.Flask('servidor')
m = manager.manager()

socketio = SocketIO(app)


@app.route("/solucao", methods=['POST'])
def solucao():
    sol = m.parseSolution(request.data)
    m.registerSolution(sol)
    #print(m.d[sol["uuid"]])
    return flask.jsonify({"status": "ok"})


@app.route("/")
def index():
    idGrupo = request.args.get("idGrupo")
    #p = random.randint(1,3)
    p = 3
    if p == 1:
        prob = gerador.geraProblema1()
    elif p == 2:
        prob = gerador.geraProblema2()
示例#31
0
     "123",
     "123",
     "123",
     "123",
 ]
 print("1==>login as manager")
 print("2==>login as staff")
 print("3==>quit")
 ch = int(input("enter the choice"))
 flag = 0
 if (ch == 1):
     user = input("enter the user id")
     pasw = input("enter the password")
     if (user == "admin"):
         if (pasw == "admin123"):
             manager()
         else:
             flag = 1
     else:
         flag = 1
     if (flag == 1):
         print("wrong admin userid or password")
 elif (ch == 2):
     user = input("enter the user id")
     pasw = input("enter the password")
     len1 = len(l1)
     for i in range(0, len1):
         if (l1[i] == user):
             if (l2[i] == pasw):
                 if (user == "nimit"):
                     while (True):
示例#32
0
def main():
    # use MW_HOME to find etc/ & var/ directories
    path = getenv('MW_HOME')
    if path == None:
        stderr.write("MW_HOME not set in environment, program cannot start.")
        _exit(1)
    logging.config.fileConfig('/'.join([path, 'etc', 'logging.conf']),
                              disable_existing_loggers=False)
    config = parse_config('/'.join([path, 'etc', 'vddb_async.conf']))
    start_dbpc(config, 'task_manager')

    # make db connection pool, assign 1 connection to each db accessing thread
    # kingship checker + db loader + task fetcher +
    # task cleanup : a total of 4 threads, + 1 manager thread pool
    db_pool = make_db_pool(config, DB_RESERVE_CONN + int(config['cleaner_threads_num']))
    # kingship granted event, all threads wait till this event is set
    hbase_pool = make_hbase_pool(config)

    kev = Event()
    kev.clear()
    # db load finished eventm all threads wait till this event is set
    lev = Event()
    lev.clear()
    # conditions each thread wait on, named after the waiter
    fetch_cond = Condition(Lock())
    pick_cond = Condition(Lock())
    manage_cond = Condition(Lock())
    clean_cond = Condition(Lock())
    # kingship checker
    check = Thread(target=check_kingship,
                   args=(config, db_pool, kev, config['tm_module_name'],
                         # NOTE: if task manager stops working for X minutes, the
                         #       tasks won't be scheduled and executed for X
                         #       minutes since tasks have to be finished in a
                         #       timely fashion, the task manager master timeout
                         #       should not be too long
                         int(config['tm_master_timeout']),
                         logging.getLogger('mwtm_tmcheck')))
    check.start()
    # all other threads wait here
    kev.wait()
    # this event is never cleared
    #assert kev.isSet()
    # worker threads, created in dependence order
    fetch = fetcher(config, db_pool, fetch_cond, pick_cond)
    clean = cleaner_cluster(config, db_pool, hbase_pool, clean_cond, manage_cond)
    manage = manager(config, db_pool, manage_cond, pick_cond, clean)
    pick = picker(config, pick_cond, fetch, manage)
    # db config observers, loader will notify them when there's new data loaded
    observers = [fetch, pick, manage, clean]
    load = Thread(target=load_database, args=(config, db_pool, lev, observers))
    # start the loader, and make other threads wait for the first load
    load.start()
    lev.wait()
    assert lev.isSet()

    # start all other threads
    fetch.start()
    clean.start()
    manage.start()
    pick.start()
示例#33
0
import alarms
import datetime
import manager
import pickle
try:
    with open('manager_data.pkl', 'rb') as manager_file:
        mngr = pickle.load(manager_file)
except FileNotFoundError:
    mngr = manager.manager()
except Exception:
    print("WARNING: Alarm file impossible to load.")
    mngr = manager.manager()
print("Program Test")
while True:

    command = input()

    if len(command) == 0:
        print('')

    elif command == "help":
        print(
            "Commands:\nadd <name> <hour:minute> <repeat (Y/N)> <year/month/day> <songFile> \nlist {alarmNumber} \nedit <index> <atrib> <value>\nrem <index>"
        )
    elif command.split()[0] == "add":
        try:
            clName = command.split()[1]
            clHour = command.split()[2].split(':')[0]
            clMinute = command.split()[2].split(':')[1]
            if command.split()[3] == 'Y':
                clRep = True
示例#34
0
import tkinter
from tkinter import messagebox
from manager import manager
import datetime
from textblob import TextBlob
import matplotlib
matplotlib.use("TKAgg")
import matplotlib.pyplot as plt


#button(window,text = "Text", width = 12, bg = "black", fg = "white", command = def)
#button.place(x,y)
#tkinter.messagebox.showinfo("Title","Text")


man = manager()

def log(x):
    man.logentry(x)
    rating = str(round(TextBlob(x).polarity,1))
    man.logRating(rating)
    man.logDates(str(datetime.date.today()))

def analyze():
    plt.plot(man.getX(),man.getY())
    plt.xlabel("Entry Dates")
    plt.ylabel("Happiness Rating")
    plt.title("Emotional Analysis")
    plt.show()

def journ():
示例#35
0
 def get_selected(self):
     if self.tabs.current_row() == 0:
         files = []
         for fpath in self.file_browser.get_selected_files():
             files.append(manager().get_file(fpath))
         return files
示例#36
0
def sendtomanager(cont):
    man = manager()
    man.logentry(cont)
def employee(root):
    def store(v):
        if e1.get() == "" or e2.get() == "":  #Condition to check Empty Fields
            messagebox.showinfo("ERROR3", "Each Field is Mandatory")

        else:

            res = []
            p.execute('''select username from employee1''')
            result = p.fetchall()
            for row in result:
                if row[0] == e1.get():
                    p.execute(
                        "select password from employee1 where username='******';")
                    result1 = p.fetchall()
                    name = e1.get()
                    if result1[0][0] == e2.get():
                        messagebox.showinfo("Success",
                                            "Logged In Successfully")
                        p.execute(
                            "select designation from employee1 where username='******';")
                        result2 = p.fetchall()
                        desig = result2[0][0]
                        e1.delete(0, 'end')
                        e2.delete(0, 'end')
                        login.login(v, root, name, desig)
                        break
            else:
                flag = False
                p.execute("select username from employee1")
                res = p.fetchall()
                for row in res:
                    if row[0] == e1.get():
                        flag = True
                #print(flag)
                if flag == False:
                    messagebox.showinfo("Error", "Wrong Username")
                else:
                    flag = False
                    p.execute(
                        "select password from employee1 where username='******';")
                    res1 = p.fetchall()
                    for row in res1:
                        if row[0] == e2.get():
                            flag = True
                    #print(flag)
                    if flag == False:
                        messagebox.showinfo("Error", "Wrong password")
                v.deiconify()

    i = 3
    v = Toplevel(root)
    v.title("employee")
    v.minsize(1250, 700)
    background_img = PhotoImage(file="./bg1.png")
    background_label = Label(v, image=background_img)
    background_label.pack(fill=BOTH, expand=True)
    #employee="employee"

    #print(employee)

    #BUTTON

    b1 = Button(v,
                bg="steelblue2",
                fg="black",
                text='HOME',
                font="Bold 10",
                pady=3.0,
                relief=FLAT,
                height=1,
                width=15,
                command=lambda: home(root, v))
    b1.place(x=600, y=20)
    b2 = Button(v,
                bg="steelblue2",
                fg="black",
                text='MANAGER',
                font="Bold 10",
                pady=3.0,
                relief=FLAT,
                height=1,
                width=15,
                command=lambda: manager.manager(v))
    b2.place(x=750, y=20)

    b3 = Button(v,
                bg="white",
                fg="black",
                text='EMPLOYEE',
                font="Bold 10",
                pady=3.0,
                relief=GROOVE,
                height=1,
                width=15)
    b3.place(x=900, y=20)

    b4 = Button(v,
                bg="steelblue2",
                fg="black",
                text='ACCOUNT DETAILS',
                font="Bold 10",
                pady=3.0,
                relief=FLAT,
                height=1,
                width=15,
                command=lambda: admin.admin(v))
    b4.place(x=1050, y=20)

    l1 = Label(v,
               font="Bold 15",
               fg="BLACK",
               bg="lightcyan",
               text="Username: "******"Bold 15",
               fg="BLACK",
               bg="lightcyan",
               text="Password  : "******"*")
    l1.place(x=500, y=250)
    l2.place(x=500, y=300)
    e1.place(x=700, y=250)
    e2.place(x=700, y=300)

    b5 = Button(v,
                bg="DEEP SKY BLUE",
                fg="Black",
                text='LOGIN',
                font="Bold 10",
                pady=3.0,
                relief=RAISED,
                height=1,
                width=15,
                command=lambda: store(v))
    b5.place(x=600, y=350)
    b6 = Button(v,
                bg="lightcyan",
                fg="NAVY BLUE",
                text='New User? Sign Up Here.',
                font="Bold 15",
                pady=3.0,
                relief=FLAT,
                height=1,
                width=20,
                command=lambda: signup.signup(v, root, "employee1"))
    b6.place(x=580, y=390)

    #c=con.cursor()
    #result=c.execute('''select * from employee1''')
    '''con.commit()
        for row in result:
                        print(row[0],end=', ')
                        print(row[1],end=', ')
                        print(row[2],end=', ')
                        print(row[3],end=', ')
                        print(row[4])'''

    root.withdraw()
    v.mainloop()

    return v
示例#38
0
from manager import manager
from engineer3 import engineer3
from task3 import task3

mSkill = 5.0
mCat = 1.0
mTimeliness = 1.0
mInsight = 1.0
m = manager(mSkill, mCat, mTimeliness, mInsight)

engSkill = 5.0
engCat = 1.0
timeliness = 1.0

# spawn the engineers
e0 = engineer3('e0', engSkill, engCat)
e1 = engineer3('e1', engSkill, engCat)
e2 = engineer3('e2', engSkill, engCat)

# set up the first task
diff = 5.0
cat = 1.0
prio = 1.0
days = 100

# make our test task
t0 = task3(diff, cat, prio, days, 't0')
t1 = task3(diff, cat, prio, days, 't1')
t2 = task3(diff, cat, prio, days, 't2')
t3 = task3(diff, cat, prio, days, 't3')
t4 = task3(diff, cat, prio, days, 't4')
            pady=3.0,
            relief=FLAT,
            height=1,
            width=15)
b1.place(x=600, y=20)

b2 = Button(root,
            bg="firebrick4",
            fg="white",
            text='MANAGER',
            font="Bold 10",
            pady=3.0,
            relief=FLAT,
            height=1,
            width=15,
            command=lambda: manager.manager(root))
b2.place(x=750, y=20)

b3 = Button(root,
            bg="firebrick4",
            fg="white",
            text='EMPLOYEE',
            font="Bold 10",
            pady=3.0,
            relief=FLAT,
            height=1,
            width=15,
            command=lambda: employee.employee(root))
b3.place(x=900, y=20)

b4 = Button(root,
示例#40
0
def main():
    # use MW_HOME to find etc/ & var/ directories
    path = getenv('MW_HOME')
    if path == None:
        stderr.write("MW_HOME not set in environment, program cannot start.")
        _exit(1)
    logging.config.fileConfig('/'.join([path, 'etc', 'logging.conf']),
                              disable_existing_loggers=False)
    config = parse_config('/'.join([path, 'etc', 'vddb_async.conf']))
    start_dbpc(config, 'task_manager')

    # make db connection pool, assign 1 connection to each db accessing thread
    # kingship checker + db loader + task fetcher +
    # task cleanup : a total of 4 threads, + 1 manager thread pool
    db_pool = make_db_pool(
        config, DB_RESERVE_CONN + int(config['cleaner_threads_num']))
    # kingship granted event, all threads wait till this event is set
    hbase_pool = make_hbase_pool(config)

    kev = Event()
    kev.clear()
    # db load finished eventm all threads wait till this event is set
    lev = Event()
    lev.clear()
    # conditions each thread wait on, named after the waiter
    fetch_cond = Condition(Lock())
    pick_cond = Condition(Lock())
    manage_cond = Condition(Lock())
    clean_cond = Condition(Lock())
    # kingship checker
    check = Thread(
        target=check_kingship,
        args=(
            config,
            db_pool,
            kev,
            config['tm_module_name'],
            # NOTE: if task manager stops working for X minutes, the
            #       tasks won't be scheduled and executed for X
            #       minutes since tasks have to be finished in a
            #       timely fashion, the task manager master timeout
            #       should not be too long
            int(config['tm_master_timeout']),
            logging.getLogger('mwtm_tmcheck')))
    check.start()
    # all other threads wait here
    kev.wait()
    # this event is never cleared
    #assert kev.isSet()
    # worker threads, created in dependence order
    fetch = fetcher(config, db_pool, fetch_cond, pick_cond)
    clean = cleaner_cluster(config, db_pool, hbase_pool, clean_cond,
                            manage_cond)
    manage = manager(config, db_pool, manage_cond, pick_cond, clean)
    pick = picker(config, pick_cond, fetch, manage)
    # db config observers, loader will notify them when there's new data loaded
    observers = [fetch, pick, manage, clean]
    load = Thread(target=load_database, args=(config, db_pool, lev, observers))
    # start the loader, and make other threads wait for the first load
    load.start()
    lev.wait()
    assert lev.isSet()

    # start all other threads
    fetch.start()
    clean.start()
    manage.start()
    pick.start()
示例#41
0
def home():
    form = ReusableForm(request.form)
 
# print form.errors
    if request.method == 'POST':
        lenght=float(request.form['lenght'])
        bredth=float(request.form['bredth'])
        no_of_colors=int(request.form['no_of_colors'])

        ##############################################
        if 'file' not in request.files:
            flash('No file part')
        file = request.files['image']
        # if user does not select file, browser also
        # submit an empty part without filename

        if file.filename == '':
            flash('No selected file')
            return redirect(request.url)

        if file and allowed_file(file.filename):
            filename = str(uuid.uuid4())
            file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
                                    

        image=UPLOAD_FOLDER+filename

        image=UPLOAD_FOLDER+filename
        result = manager.manager(lenght, bredth, image, no_of_colors).valueTaker()
        area=float(result[1])
        tasks = []
        for values in result[0]:
            percent=values[0]
            percentNum = str(percent[:-1])
            color=values[1]
            hashVal=values[2]
            areaPercent=float(percentNum)*area/100
            

            task1=[
                {
                    'percent':percent,
                    'color':color,
                    'hash':hashVal,
                    'areaPercent':areaPercent,

                },
            ]
            tasks.append(task1)
            # print(tasks)
        database=mydatabase.databse().material()
        final=[tasks,database]
        
        return render_template('result.html', my_objects=final)
    
    if form.validate():
    # Save the comment here.
        flash('Thanks for registration ')
    else:
        flash('Error: All the form fields are required. ')
    
    return render_template('hello.html', form=form)
示例#42
0
def main():
    sampleFamily = family.family()
    sampleFamily.addManager(manager.manager())
    sampleFamily.addCitizen(citizen.citizen())
    print"Created a family"
    sampleFamily.show()
示例#43
0
 def check_services(self):
     mng = manager(self.conf)
     self.rpc_srv.set_procs_running(self.token, mng.get_list())
示例#44
0
import manager
if __name__ != "__main__":
    __name__ = "__main__"


if __name__ == "__main__":

#    master = manager.manager(domain = "ilazycat.com")
#    master.execute(tasks = ['http://ilazycat.com/'])

    master = manager.manager(thread_size = 10, domain = "121.")
    master.execute(tasks = ['http://villanch.top/'])