def __init__(self): Thing.__init__(self, 'My Humidity Sensor', 'multiLevelSensor', 'A web connected humidity sensor') self.add_property( Property(self, 'on', Value(True), metadata={ 'type': 'boolean', 'description': 'Whether the sensor is on', })) self.level = Value(0.0) self.add_property( Property(self, 'level', self.level, metadata={ 'type': 'number', 'description': 'The current humidity in %', 'unit': '%', })) log.debug('starting the sensor update looping task')
def __setattr__(self, name, value): # Bypass all redirection when initializing if self.__dict__['__initializing__']: super(models.Model, self).__setattr__(name, value) return # Handle special case for `data` field if name == 'data': self.__dict__['data'] = Thing(value) return # Handle special case for `json_data` field if name == 'json_data': self.__dict__['data'] = Thing(value) self.__dict__['json_data'] = value return # Handle private and protected fields with default behaviour if name.startswith('_'): super(models.Model, self).__setattr__(name, value) return try: # Let Django try to solve the attribute super(models.Model, self).__getattribute__(name) # If it exists, then we just set it as usual super(models.Model, self).__setattr__(name, value) except AttributeError: # If it didn't existed, then set it inside our thing try: setattr(self.data, name, value) except ValueError as e: raise ValueError("At attribute `%s`: %s" % (name, str(e)))
def __init__(self, ledPin): Thing.__init__(self, 'urn:dev:ops:blue-led-1234', 'Blue LED', ['OnOffSwitch', 'Light'], 'Blue LED on SparkFun ESP32 Thing') self.pinLed = machine.Pin(ledPin, machine.Pin.OUT) self.pwmLed = machine.PWM(self.pinLed) self.ledBrightness = 50 self.on = False self.updateLed() self.add_property( Property(self, 'on', Value(self.on, self.setOnOff), metadata={ '@type': 'OnOffProperty', 'title': 'On/Off', 'type': 'boolean', 'description': 'Whether the LED is turned on', })) self.add_property( Property(self, 'brightness', Value(self.ledBrightness, self.setBrightness), metadata={ '@type': 'BrightnessProperty', 'title': 'Brightness', 'type': 'number', 'minimum': 0, 'maximum': 100, 'unit': 'percent', 'description': 'The brightness of the LED', }))
def render_n_things( n, things, THINGS_SURF ): # генерация settings.number_thingsнепересекающихся спрайтов с изображениями предметов на игровай панели index_things = 0 attempt = 0 offset = 30 points_list = game_render.get_points_list( settings.screen_width - 2 * offset, settings.screen_height - 2 * offset) while index_things < n and attempt < n * 3: if len( points_list ) > 0: # заранее подготовленный список точек в разных частях поля point = points_list.pop() new_thing = Thing(point[0] + offset, point[1] + offset, THINGS_SURF[index_things]) else: new_thing = Thing( randint(offset, settings.screen_width - offset), randint( offset, settings.screen_height + settings.height_bottom_panel - settings.height_bottom_panel - offset), THINGS_SURF[index_things]) blocks_hit_list = pygame.sprite.spritecollide( new_thing, things, False, pygame.sprite.collide_circle) if len(blocks_hit_list) == 0: things.add(new_thing) index_things += 1 attempt += 1 # print(attempt) return things
def __init__(self): Thing.__init__( self, 'urn:dev:ops:my-humidity-sensor-1234', 'My Humidity Sensor', ['MultiLevelSensor'], 'A web connected humidity sensor' ) self.level = Value(0.0) self.add_property( Property(self, 'level', self.level, metadata={ '@type': 'LevelProperty', 'title': 'Humidity', 'type': 'number', 'description': 'The current humidity in %', 'minimum': 0, 'maximum': 100, 'unit': 'percent', 'readOnly': True, })) log.debug('starting the sensor update looping task')
def __init__(self, default_name, path): Thing.__init__(self, default_name, path) self.open = False self.set_description( 'strong roots', 'These roots look very strong. You wish you could move them.') self.add_adjectives('strong') self.actions.append(Action(self.move_roots, ['move'], True, False))
def main(): t1 = Thing(0) for i in range(10,"good"): print "move:",i t1.display() t1.move()
def __init__(self, name, char, col, control, time_to_act, is_immobile): Thing.__init__(self, name, char, col, is_immobile) self.control = control self.time_to_act = time_to_act self.field_of_view_radius = 10
def test_heaviest_thing(self): t1 = Thing("some name", 20) t2 = Thing("some name", 30) s = Suitecase(100) s.add_thing(t1) s.add_thing(t2) self.assertEqual(t2, s.heaviest_thing())
def make_thing(): thing = Thing('My Lamp', 'dimmableLight', 'A web connected lamp') def noop(_): pass thing.add_property( Property(thing, 'on', Value(True, noop), metadata={ 'type': 'boolean', 'description': 'Whether the lamp is turned on', })) thing.add_property( Property(thing, 'level', Value(50, noop), metadata={ 'type': 'number', 'description': 'The level of light from 0-100', 'minimum': 0, 'maximum': 100, })) thing.add_available_action( 'fade', { 'description': 'Fade the lamp to a given level', 'input': { 'type': 'object', 'required': [ 'level', 'duration', ], 'properties': { 'level': { 'type': 'number', 'minimum': 0, 'maximum': 100, }, 'duration': { 'type': 'number', 'unit': 'milliseconds', }, }, } }, FadeAction) thing.add_available_event( 'overheated', { 'description': 'The lamp has exceeded its safe operating temperature', 'type': 'number', 'unit': 'celsius' }) return thing
def test_add_things_over_limit(self): t1 = Thing("some name", 80) t2 = Thing("some name", 21) s = Suitecase(100) s.add_thing(t1) s.add_thing(t2) self.assertEqual("1 thing (80kg)", s.to_string())
def __init__(self, width, height, mass, speedlimit=.5): Thing.__init__(self, width, height, mass, speedlimit=.5) self.gravity = True self.jump_power = 15 self.jump_power2 = 15 self.doublejump_delay = 0 self.walljump_power_right = False self.walljump_power_left = False
def get_objects_map(self): for thing_name in names_list['things']: if thing_name == 'Лошарик': object_instance = Thing(name=thing_name, hp=10, damage=10, protection=10) self.objects_map['things'].append(object_instance) else: capacity = random.randint(4, 8) for _ in range(capacity): hp = random.randint(1, 10) damage = random.randint(1, 10) protection = random.randint(1, 4) object_instance = Thing(name=thing_name, hp=hp, damage=damage, protection=protection) self.objects_map['things'].append(object_instance) for armor_name in names_list['armors']: capacity = random.randint(4, 8) for _ in range(capacity): hp = random.randint(1, 10) damage = random.randint(1, 10) protection = random.randint(1, 4) object_instance = Armor(name=armor_name, hp=hp, damage=damage, protection=protection) self.objects_map['armors'].append(object_instance) for armor_name in names_list['weapons']: capacity = random.randint(4, 8) for _ in range(capacity): hp = random.randint(1, 10) damage = random.randint(1, 10) protection = random.randint(1, 10) object_instance = Weapon(name=armor_name, hp=hp, damage=damage, protection=protection) self.objects_map['weapons'].append(object_instance) for person_name in names_list['persons']: hp = random.randint(1, 10) damage = random.randint(1, 10) protection = random.randint(1, 10) is_paladin = random.randint(1, 2) == 2 object_instance = Paladin(name=person_name, hp=hp, damage=damage, protection=protection) if is_paladin \ else Warrior(name=person_name, hp=hp, damage=damage, protection=protection) self.objects_map['persons'].append(object_instance) return self.objects_map
def __init__(self, default_name, path, bonus, unwieldiness, pref_id=None): Thing.__init__(self, default_name, path, pref_id) self.bonus = bonus self.unwieldiness = unwieldiness self.actions.append(Action(self.wear, ['wear', 'use'], True, False)) self.actions.append( Action(self.unwear, ['unwear', 'remove'], True, False)) # overwrite default drop action: for a in self.actions: if 'drop' in a.verblist: a.func = self.armor_drop
def __init__(self): Thing.__init__(self, 'urn:dev:ops:my-pycom-pysense', 'My Pycom', ['RGBLed', 'memory'], 'A web connected Pycom') self.color = 0 #0 is no light, 20 is very light blue #0xff00 #green self.updateLeds() self.mempycom = Value(0.0) self.seconds = 0 self.__alarm = Timer.Alarm(self._seconds_handler, s=10, periodic=True) #self._alarm = Timer.Alarm(updateMemPycom, 1, arg=None, periodic=True) self.add_property( Property(self, 'mempycom', self.mempycom, metadata={ '@type': 'SystemParameter', 'title': 'Memory', 'type': 'number', 'description': 'The free RAM of the system', })) self.add_property( Property(self, 'color', Value(self.color, self.setcolor), metadata={ '@type': 'ColorProperty', 'title': 'Color', 'type': 'integar', 'description': 'The color of the LED', })) self.add_available_action( 'setrgbcolor', { 'title': 'Change Color', 'description': 'Change the color of LED', 'input': { 'type': 'object', 'required': [ 'color', ], 'properties': { 'color': { 'type': 'integer', 'minimum': 0, 'maximum': 0xFFFFFF, #'unit': 'percent', }, }, }, }, SetRGBColor)
def __init__(self, ID, path, hidden_room): Thing.__init__(self, ID, path) self.set_description('bookcase full of books', \ 'This bookcase is a hodgepodge of books; some are newer, but a lot of old ones are scattered around them.') # we want this to trigger if they type, for example, "take old book" self.add_names("book") self.add_adjectives("old", "new") self.fix_in_place("The bookcase appears to be fixed to the wall.") self.actions.append( Action(self.handle_book, ["take", "get", "pull"], True, False)) self.hidden_room = hidden_room
def pair(): thing = request.form['thing'] # check if the authenticated user has already paired with this thing if len(filter(lambda x: x.name == thing, current_user.things)) > 0: return jsonify(success=True) # TODO: implement secure pairing via a pairing code # Will involve fetching the pairing code from the thing's shadow state # code = request.form['code'] # create the policy that gives the authenticated user access to the thing policy = { 'Version': '2012-10-17', 'Statement': [{ 'Effect': 'Allow', 'Action': [ 'iot:UpdateThingShadow', 'iot:GetThingShadow', 'iot:DeleteThingShadow' ], 'Resource': Thing.fullyQualifiedName(thing) }] } policyName = str(current_user.id) + '_' + thing iot = boto3.client('iot') try: r = iot.create_policy(policyName=policyName, policyDocument=json.dumps(policy)) except ClientError as e: logger.debug('pair: Error creating policy: {}'.format(e)) return jsonify(success=False) # attach the policy to the authenticated user try: iot.attach_principal_policy(policyName=policyName, principal=current_user.cognitoID) except ClientError as e: logger.debug( 'pair: Error attaching policy {} to principal {}: {}'.format( policyName, current_user.cognitoID, e)) return jsonify(success=False) current_user.things.append(Thing(name=thing)) db.session.commit() return jsonify(success=True)
def main(): names = ["Paul", "Simon", "Art"] things = [] for name in names: things.append(Thing(name)) another = Thing("Garfunkel", 7) things.append(another) for i in range(len(things)): print("{}. {}.".format(i, things[i])) things[i].process(i) print("{}. {}.".format(i, things[i])) print("...")
def __init__(self, default_name, path, pref_id=None): Thing.__init__(self, default_name, path, pref_id) self.contents = [] self.see_inside = True # can contents of container be seen? self.closed = False # can't remove items from closed container self.closed_err = "" # custom "container is closed" error msg self.closable = False # can this container be opened and closed? self.liquid = False # can this container carry liquid? self.max_weight_carried = 1 self.max_volume_carried = 1 self.insert_prepositions = ["in", "into", "inside"] self.actions.append(Action(self.put, ["put", "insert"], True, False)) self.actions.append(Action(self.remove, ["remove"], True, False)) self.actions.append(Action(self.open, ["open"], True, False)) self.actions.append(Action(self.close_action, ["close"], True, False))
def test_add_thing(self): t = Thing("some name", 10) s = Suitecase(100) s.add_thing(t) self.assertEqual("1 thing (10kg)", s.to_string())
def get_next_brick(self): brick = Thing("brick", self._brick_weight) if self._brick_weight < 100: self._brick_weight += 1 return brick
def put_thing(url, thing): res = requests.post( '{0}/things'.format(url), data=str(thing), headers={'Content-Type': 'application/json'}) res.raise_for_status() return Thing.from_json(res.json())
def __init__(self, *args, **kwargs): self.__dict__['__initializing__'] = True super(ThingModel, self).__init__(*args, **kwargs) self.__dict__['data'] = Thing(self.json_data) self.__dict__['__initializing__'] = False
def move_towards(self, turn_summary, param, active=True): ''' For moving map actorss around. Calls hidden method of the same name in parent. Returns TurnSummary, with 'TurnSummary.turn_taken' set to 'True' only if a voluntary move action was performed successfully. active: set to 'False' if movement is not voluntary (the default case for Thing objects), it defaults to 'True' ''' turn_summary = Thing.move_towards(self, turn_summary, param, active) blocker = turn_summary.blocked_by if active: if blocker: # TODO: default attack logging.debug("[%r] bumps into [%s]" % (self, blocker.name)) else: # Turn taken by moving self.time_to_act = 3 turn_summary.turn_taken = True turn_summary.to_refresh_game_map_console = True logging.debug("[%r] moved successfully" % self) return turn_summary
def fetch_all(page=1): page, last_page = page, Startup.num_pages() while page <= last_page: response = Thing.api().get('startups', {'filter': 'raising', 'page': page}) page = response['page'] + 1 for startup in response['startups']: yield Startup(startup)
def thrust_damage(a): a.attack_type = THRUST st = a.attacker.ST a.damage = Thing() a.damage.dice += 1 if st < 19 else 2 a.damage.mod = (-1 if st > 18 else int((st - 1) / 2) - 6) return a
def __init__(self, pin): Thing.__init__(self, 'Button 0', ['BinarySensor'], 'Button 0 on SparkFun ESP32 Thing') self.pin = machine.Pin(pin, machine.Pin.IN) self.button = Value(False) self.add_property( Property(self, 'on', self.button, metadata={ 'type': 'boolean', 'description': 'Button 0 pressed', 'readOnly': True, })) self.prev_pressed = self.is_pressed()
def setup(): test_thing = Thing(id='01', token='aaaa', name='aaaa') test_cloud = Cloud() assert test_cloud.connect(arguments="'wss' 'ws.knot.cloud' 443") return test_thing, test_cloud
def __init__(self, rPin, gPin, bPin): Thing.__init__( self, "urn:dev:ops:esp32-rgb-led-1234", "ESP32-RGB-LED", ["OnOffSwitch", "Light", "ColorControl"], "RGB LED on ESP-Wrover-Kit", ) self.pinRed = machine.Pin(rPin, machine.Pin.OUT) self.pinGreen = machine.Pin(gPin, machine.Pin.OUT) self.pinBlue = machine.Pin(bPin, machine.Pin.OUT) self.pwmRed = machine.PWM(self.pinRed) self.pwmGreen = machine.PWM(self.pinGreen) self.pwmBlue = machine.PWM(self.pinBlue) self.redLevel = 50 self.greenLevel = 50 self.blueLevel = 50 self.on = False self.updateLeds() self.add_property( Property( self, "on", Value(True, self.setOnOff), metadata={ "@type": "OnOffProperty", "title": "On/Off", "type": "boolean", "description": "Whether the LED is turned on", }, ) ) self.add_property( Property( self, "color", Value("#808080", self.setRGBColor), metadata={ "@type": "ColorProperty", "title": "Color", "type": "string", "description": "The color of the LED", }, ) )
def __init__(self, default_name, path, damage, accuracy, unwieldiness, pref_id=None): Thing.__init__(self, default_name, path, pref_id) self.damage = damage self.accuracy = accuracy self.unwieldiness = unwieldiness self.actions.append(Action(self.wield, ['wield', 'use'], True, False)) self.actions.append(Action(self.unwield, ['unwield'], True, False)) # overwrite default drop action: for a in self.actions: if 'drop' in a.verblist: a.func = self.weapon_drop
def test_add_suitecase(self): t = Thing("some name", 10) s = Suitecase(100) s.add_thing(t) c = Container(100) c.add_suitecase(s) self.assertEqual("1 suitecase (10kg)", c.to_string())
def cripple(a): if ((a.target.body.is_limb(a.location) and a.damage.injury >= int(a.target.HP / 2)) or (a.target.body.is_extremity(a.location) and a.damage.injury >= int(a.target.HP / 3))): if not a.target.crippled: a.target.crippled = Thing() a.target.crippled[a.location] = True a.damage.cripple = a.location return a
def swing_damage(a): a.attack_type = SWING st = a.attacker.ST a.damage = Thing() a.damage.dice += 1 if st < 9 else int((st - 5) / 4) if st < 9: a.damage.mod += (-5 + int((st - 1) / 2)) else: a.damage.mod += ((st - 1) % 4) - 1 return a
class TestThing(TestCase): def setUp(self): self.thing = Thing(name='thing') self.action1 = Action.create(name='action1') self.action2 = Action.create(name='action2') self.thing.add_agent_role(verb='action1') def test_add_role(self): self.thing.add_agent_role(verb='action2') self.assertTrue(self.thing.is_valid_agent(self.action2)) def test_is_valid_for_role(self): self.thing.add_role(Role.THEME, 'action2') self.assertTrue(self.thing.is_valid_for_role(Role.THEME, self.action2))
def __init__(self, rPin, gPin, bPin): Thing.__init__( self, 'urn:dev:ops:esp32-rgb-led-1234', 'ESP32-RGB-LED', ['OnOffSwitch', 'Light', 'ColorControl'], 'RGB LED on ESP-Wrover-Kit' ) self.pinRed = machine.Pin(rPin, machine.Pin.OUT) self.pinGreen = machine.Pin(gPin, machine.Pin.OUT) self.pinBlue = machine.Pin(bPin, machine.Pin.OUT) self.pwmRed = machine.PWM(self.pinRed) self.pwmGreen = machine.PWM(self.pinGreen) self.pwmBlue = machine.PWM(self.pinBlue) self.redLevel = 50 self.greenLevel = 50 self.blueLevel = 50 self.on = False self.updateLeds() self.add_property( Property(self, 'on', Value(True, self.setOnOff), metadata={ '@type': 'OnOffProperty', 'title': 'On/Off', 'type': 'boolean', 'description': 'Whether the LED is turned on', })) self.add_property( Property(self, 'color', Value('#808080', self.setRGBColor), metadata={ '@type': 'ColorProperty', 'title': 'Color', 'type': 'string', 'description': 'The color of the LED', }))
def __init__(self): try: # initialize pygame pygame.init() # create a clock to limit the frames per second self.clock = pygame.time.Clock() # Set the width and the height of the screen and create the sceen self.screen = pygame.display.set_mode((self.width, self.height)) pygame.display.set_caption("Press start to play") # create player self.player = Thing((self.width >> 1), (self.height >> 1)) # this variable is used to end the main loop self.done = 0 except: raise error.Error("init engine")
class Engine: done = 0 width = 1024 height = 768 clock = None screen = None def __init__(self): try: # initialize pygame pygame.init() # create a clock to limit the frames per second self.clock = pygame.time.Clock() # Set the width and the height of the screen and create the sceen self.screen = pygame.display.set_mode((self.width, self.height)) pygame.display.set_caption("Press start to play") # create player self.player = Thing((self.width >> 1), (self.height >> 1)) # this variable is used to end the main loop self.done = 0 except: raise error.Error("init engine") def main_loop(self): try: # start main loop while self.done != 1: # handle some events for event in pygame.event.get(): if event.type == pygame.VIDEORESIZE: self.width = event.dict["size"][0] self.height = event.dict["size"][1] self.screen = pygame.display.set_mode((self.width, self.height)) elif event.type == pygame.QUIT: self.done = 1 # handle some key input keys_pressed = pygame.key.get_pressed() if keys_pressed[pygame.K_ESCAPE]: self.done = 1 dx = 0 dy = 0 if keys_pressed[pygame.K_w]: dy -= 1 if keys_pressed[pygame.K_s]: dy += 1 if keys_pressed[pygame.K_a]: dx -= 1 if keys_pressed[pygame.K_d]: dx += 1 if dx != 0 or dy != 0: self.player.acclerate(dx, dy) # update objects self.player.update() # fill the screen with one color self.screen.fill((10, 10, 10)) # render the scene pygame.draw.rect(self.screen, (255, 0, 0), (\ self.player.position.x - 16, \ self.player.position.y - 16, \ 32, 32), 1) # update the screen pygame.display.flip() # Limit the game loop to 60 ticks(frames) per second self.clock.tick(60) except: raise error.Error("main loop") def __del__(self): try: # release pygame pygame.quit() except: raise error.Error("del engine")
def __init__(self, name, use, location=None, pin=0): Thing.__init__(self, name, use, location, pin)
__author__ = 'damariei' from thing import Thing from utils import genSeq # Testing t1 = Thing() t1.construct(genSeq()) print('T1: '+t1.name) t2 = Thing() t2.construct(genSeq()) print('T2: '+t2.name) print("Diff: "+str(t1.compareTo(t2.seq)))
def num_pages(): return Thing.api().get('startups', {'filter': 'raising', 'per_page': 1})['last_page']
def __init__(self): Thing.__init__(self) self.style = "O"
def get_thing(url, id): res = requests.get('{0}/things/{1}'.format(url, id)) res.raise_for_status() return Thing.from_json(res.json())
def __init__(self): Thing.__init__(self) self.at = {} self.df = Dexterity self.dm = Strength
def __init__(self, width, height, mass, surface=pygame.Surface((0,0)), speedlimit=2): Thing.__init__(self, width, height, mass, speedlimit=2) self.surface.fill((127,127,127)) self.mass = 2 self.gravity = False
def init (self): # don't allow reset when paused or already won if self.paused or self.transition: return data = conf.LEVEL_DATA[self.ID] self.run_timer = 0 self.kills = 0 self.won = False self.particles = [] # background self.bg = self.game.img('bg{0}.png'.format(self.ID)) # player s = self.space if not hasattr(self, 'player'): self.player = Player(self, data['start']) # doors try: s.remove_static(self.exit_shape) except AttributeError: pass else: self.player.reset(data['start']) self.entrance = data['entrance'] a, b = self.exit = data['exit'] self.exit_shape = l = pm.Segment(s.static_body, a, b, conf.LINE_RADIUS) l.group = conf.SHAPE_GROUP l.layers = conf.DOOR_LAYER l.sensor = True s.add_static(l) # things try: for t in self.things: t.die() except AttributeError: pass self.things = [] ts = self.things for p, d, ai in data['things']: t = Thing(self, p, d, ai) t.dead = False ts.append(t) # static shapes try: for shape in self.shapes_shapes: s.remove_static(shape) except AttributeError: pass self.shapes = [((0, 0), (1000, 0)), ((1000, 0), (1000, 540)), ((0, 500), (1000, 500)), ((0, 0), (0, 500))] self.shapes += data['shapes'] self.shapes_shapes = ss = [] rm = [] for pts in self.shapes: if pts[1] is False: rm.append(pts) pts = pts[0] if len(pts) == 2: p = pm.Segment(s.static_body, pts[0], pts[1], conf.LINE_RADIUS) else: p = pm.Poly(s.static_body, pts) p.friction = conf.SHAPE_FRICT p.elast = conf.SHAPE_ELAST p.group = conf.SHAPE_GROUP p.layers = conf.COLLISION_LAYER s.add_static(p) ss.append(p) for pts in rm: self.shapes.remove(pts) self.shape_colour = data['shape_colour'] # messages msgs = data['msg'] if msgs[0] is None: self.msgs = [] self.msg = None else: self.msgs = list(msgs[:-1]) self.msg = 0 self.end_msg = msgs[-1] self.msg_colour = data['msg_colour'] self.msg_arrow = self.game.img('arrow{0}.png'.format(data['msg_arrow'])) # music try: music = data['music'] except KeyError: self.game.music = [] self.game.play_music() else: try: if music != self.music: raise AttributeError() except AttributeError: self.music = music self.game.find_music(str(music)) self.game.play_music() # triggers try: s.remove_static(*self.trigger_shapes) except AttributeError: pass trigger_data = data.get('triggers', []) self.triggers = ts = [] self.trigger_shapes = tss = [] for pts, cb in trigger_data: ts.append(cb) shape = pm.Poly(s.static_body, pts) shape.group = conf.SHAPE_GROUP shape.layers = conf.TRIGGER_LAYER shape.sensor = True s.add_static(shape) tss.append(shape) self._triggers = []