Python control.Control类代码示例

class Anna(sleekxmpp.ClientXMPP):
	def __init__(self):
		config = ConfigParser()
		config.read("config.ini")
		jid = config.get("general", "jid")
		resource = config.get("general", "resource")
		password = config.get("general", "password")
		self._owners = config.get("general", "owner").split(",")
		sleekxmpp.ClientXMPP.__init__(self, jid + "/" + resource, password)
		self._rooms = []
		self._control = Control(self)

		self.add_event_handler("session_start", self.handle_XMPP_connected)
		self.add_event_handler("message", self.handle_incoming_message)

		for r in config.get("general", "rooms").split(","):
			self._rooms.append(room.Room(self, config.get(r, "room"), config.get(r, "modules").split(','), config.get(r, "botname")))

	def handle_XMPP_connected(self, event):
		self.sendPresence(pstatus = "<3")
		self.getRoster()
		for room in self._rooms:
			room.connect()

	def handle_incoming_message(self, message):
		if message['type'] == 'chat':
			for room in self._rooms:
				if room.get_roomname() == message['from'].bare and message['from'].resource in room.get_roster():
					room.handle_private_message(message, message['from'])
					break
			if message['from'].bare in self._owners:
				self._control.handle_message(message, message['from'])

def main():
    cfg = Config()

    # PyGame init
    pygame.init()
    screen = pygame.display.set_mode(cfg.getDisplay())
    pygame.display.set_caption("Solar Mechanics")

    # Space init
    bg = Surface(cfg.getDisplay())
    bg.fill(Color(cfg.getSpaceColor()))
    # Draw fixed stars
    for i in range(cfg.getStarNumber()):
        draw.circle(bg, Color(random.sample(cfg.getStarColors(), 1)[0]),
                    (random.randrange(bg.get_width()),
                     random.randrange(bg.get_height())),
                    0)

    # Timer init
    timer = pygame.time.Clock()

    control = Control(timer, screen, bg, cfg)
    control.run()

    # Farewell
    print(":-)")

 def fogging(self,Indoor,Parameter,Control):
     if Indoor.get_temperature()>Parameter.temperature_to_open_fogging+1:
         Control.set_fogging("on")
        # if Control.get_thermal_screen()=="on"
         #    Control.set_thermal_screen("off")
     elif Indoor.get_temperature()<Parameter.temperature_to_open_fogging-1:
         Control.set_fogging("off")

 def __init__(self, parent, **kwargs):
     Control.__init__(self, Label(master=parent._frame), **kwargs)
     # Tk does not have a truly dedicated "Image" object
     # unless you install PIL
     self._picture = Picture(self._ctrl)
     if kwargs.get('file'):
         self._picture.open_file(kwargs['file'])

 def __init__(self, parent, **kwargs):
     Control.__init__(self, TkScale(parent._frame), **kwargs)
     self.min = 0
     self.max = 100
     self.value = 0
     self.ticks = 0
     self.show_label = False
     self.orientation = HORIZONTAL

def api_control_power():
	action = request.args.get('action')
	control = Control(config['control'])
	if action == 'halt':
		control.halt()
	elif action == 'reboot':
		control.reboot()
	return json.dumps('OK')

    def __init__(self, **kwargs): 

        Control.__init__(self, **kwargs)

        self.target = None

        # generalized coordinates
        self.target_gain = 2*np.pi
        self.target_bias = -np.pi

    def __init__(self, null_control=False, **kwargs): 
        """
        null_control boolean: 
        """

        Control.__init__(self, **kwargs)

        self.DOF = 2
        self.null_control = null_control

    def __init__(self, parent, **kwargs):
        Control.__init__(self, TkProgressBar(), **kwargs)

        self._min = 0
        self._max = 0
        self._value = 0
        
        self.max = 100
        self.min = 0
        self.value = 50

def main():
	global users
	users = dict()

	t = Control()
	t.start()

	reactor.listenTCP(PORT, ServerFactory())
	log("Server started, port {0}\n".format(PORT))
	reactor.run()

 def __init__(self, config):
     self.config = config
     self.game = Game()
     self.queue = Queue.Queue(0)
     pp("Initiating Irc Thread")
     self.c1 = Control(1, "Controller-1", self.config, self.queue, Irc.from_config(self.config, self.queue).start)
     self.c1.daemon = True
     self.c1.start()
     pp("Initiating Tornado Thread")
     self.c2 = Control(2, "Controller-2", self.config, self.queue, web.run)
     self.c2.daemon = True
     self.c2.start()

 def event_switch_to_list_view(self, widget, event, data=None):
   TixMode.current = TixMode.LIST
   self.status_bar.update("- Search: %s" % Control.get_last_regex() if Control.get_last_regex() else "")
   if Control.reload_notes:
     self.stored_items.load(self.notes_root, self.recursive)
     self.create_list()
     Control.reload_notes = False
   self.vbox.remove(self.editor.get_parent())
   self.vbox.pack_start(self.commandline, False, False, 0)
   self.vbox.add(self.tree_view.get_parent())
   self.tree_view.grab_focus()
   self.main_window.show_all()

class Handler:
    """This class represents a rectangular control points handler"""

    def __init__(self):
        self.control = list()
        self.can_pivot = True
        self.center_pivot = False
        self.pivot = Control()
        self.pivot.pivot = True

        self.line = False

        self.is_testing = False

        index = 0
        while index < ANONIMOUS:
            control = Control()
            self.control.append(control)
            index += 1

    def draw_handler(self, context):
        if not self.line:
            context.set_antialias(cairo.ANTIALIAS_NONE)
            context.set_line_width(1.0 / context.get_matrix()[0])
            context.set_source_rgb(0.5, 0.5, 1.0)
            dash = []
            context.set_dash(dash)
            context.rectangle(self.x, self.y, self.width, self.height)
            context.stroke()
            context.set_antialias(cairo.ANTIALIAS_DEFAULT)

    def draw_controls(self, context):
        for control in self.control:
            control.draw(context)

    def draw_pivot(self, context):
        self.pivot.draw(context)

    def draw(self, context):
        self.draw_handler(context)
        self.draw_controls(context)
        if self.can_pivot:
            self.draw_pivot(context)

    def at_position(self, x, y):
        return self.get_direction(x, y) is not NONE

    def get_direction(self, x, y):
        for direction, control in enumerate(self.control):
            if control.at_position(x, y):
                return direction
        return NONE

def main():
    print sys.argv
    arg = sys.argv[1]
    command = Command()
    command.room='living'
    command.action='power'
    command.value='on'
    if arg == '1':
    	command.value = 'on'
    elif arg == '2':
    	command.value = 'off'
    control = Control()
    control.execute_command(command)

    def datagramReceived(self, data, addr):
        """Event handler of receiving a UDP request.
        Verify the identity of the client and assign a Control
        to it if it is trusted.
        """
        logging.debug("received DNS request from %s:%d" % (addr[0], addr[1]))

        if not self.transmit:
            try:
                dnsq = dnslib.DNSRecord.parse(data)
                query_data = str(dnsq.q.qname).split('.')
                # Give a NXDOMAIN response
                self.answer(dnsq, addr)
            except KeyError:
                logging.info("Corrupt request")

        try:
            # One control corresponds to one client (with a unique SHA1)

            # TODO: get obfs level from query length

            if self.transmit:
                main_pw, client_sha1, number, tcp_port, remote_ip, certs_str, signature = \
                    self.parse_udp_msg_transmit(data)
            else:
                main_pw, client_sha1, number, tcp_port, remote_ip, certs_str, signature = \
                    self.parse_udp_msg(*query_data[:6])
            if (client_sha1 + main_pw) not in self.controls:
                cert = self.certs_db.query(client_sha1)
                control = Control(self, signature, client_sha1, cert[0], cert[1],
                                  remote_ip, tcp_port,
                                  main_pw, number, certs_str)
                self.controls[client_sha1 + main_pw] = control
            else:
                control = self.controls[client_sha1 + main_pw]
                control.update(remote_ip, tcp_port, number)

            control.connect()

        except CorruptedReq:
            logging.debug("corrupt request")
        except KeyError:
            logging.warning("untrusted client attempting to connect")
        except AssertionError:
            logging.debug("authentication failed or corrupt request")
        except BlacklistReq:
            logging.debug("request or salt on blacklist")
        except IllegalReq:
            logging.debug("request for too many connections")