Datasets:

---

gangiswag

/

python_ablation

like 0

[ "def potential_color(self):\n\n return (1., 1., 0.)", "def get_color(self):\r\n return self.__color", "def _get_color(self):\n return self.__color", "def _get_color(self):\n return self.__color", "def _get_color(self):\n return self.__color", "def _get_color(self):\n return self.__color", "def get_color(self):\n return self.color", "def random_color():\n colormode(255)\n return randint(0, 255), randint(0, 255), randint(0, 255)", "def get_color(self):\r\n return self._color", "def get_color(self):\n\n return self.color", "def colorscale(self):\n return self['colorscale']", "def color_mode(self):\n return ids_core.Camera.color_mode.__get__(self)", "def get_color(self):\n return self._color", "def get_color(self):\n return self._color", "def conseguir_color(self):\n return self.pluma.conseguir_color()", "def get_colour(self):\n return self.colour", "def color(self):\n return self.__color", "def get_color(self):\r\n if self.color:\r\n return \"RED\"\r\n else:\r\n return \"BLACK\"", "def colorscale(self):\n return self[\"colorscale\"]", "def color_mode(self) -> ColorMode:\n if self._dimmable:\n return ColorMode.BRIGHTNESS\n return ColorMode.ONOFF", "def get_color(self, point):\n \n d = point - self._origin\n dist = int(d.dot(d) ** 0.5) % 2\n if dist == 0:\n return self.c1.dup()\n else:\n return self.c2.dup()", "def norm(self):\n return self._color_mapper", "def get_color(self):\n\n return self._color", "def color(self):\n return self.COLOR", "def pastel_randcol():\n # begin with saturated then desaturate\n col = saturated_randcol()\n offset = 175\n \n for i in range(3):\n if col[i] == 255:\n continue\n elif col[i] != 0:\n col[i] = min(col[i]+offset,255)\n else:\n col[i] += offset\n \n return gfx.Color(tuple(col))", "def _get_color(self, r, g, b):\n clr = (r, g, b)\n return clr", "def get_node_color(self, origin_node_id):\n origin_node_id %= 11\n if origin_node_id == 9:\n return 0.753, 0.753, 0.753, 1.\n if origin_node_id == 8:\n return 0.824, 0.412, 0.118, 1.\n if origin_node_id == 7:\n return 1.000, 0.000, 1.000, 1.\n if origin_node_id == 6:\n return 1.000, 1.000, 0.000, 1.\n if origin_node_id == 5:\n return 1.000, 0.627, 0.478, 1.\n if origin_node_id == 4:\n return 0.498, 1.000, 0.000, 1.\n if origin_node_id == 3:\n return 0.000, 1.000, 1.000, 1.\n if origin_node_id == 2:\n return 1.000, 0.922, 0.804, 1.\n if origin_node_id == 1:\n return 0.871, 0.722, 0.529, 1.\n if origin_node_id == 0:\n return 0.000, 0.749, 1.000, 1.\n if origin_node_id == 0:\n return 0.500, 0.549, 1.000, 1.\n\n return 0.8, 0.8, 0.8, 1.0", "def color_column(self):\n return 8", "def color(self):\n return self._color", "def color(self):\n return self._color" ]

[ "0.61560196", "0.60476726", "0.5993631", "0.5993631", "0.5993631", "0.5993631", "0.59807307", "0.5946223", "0.5924161", "0.5885491", "0.58824646", "0.5869164", "0.58573097", "0.58573097", "0.58441573", "0.58146566", "0.58009475", "0.57854545", "0.5779842", "0.5760599", "0.5746968", "0.5735507", "0.5705982", "0.56836206", "0.566219", "0.56450623", "0.56444544", "0.5643665", "0.5620199", "0.5620199" ]

[ "def reset(self):\n TNavigator.reset(self)\n TPen._reset(self)\n self._clear()\n self._drawturtle()\n self._update()", "def reset(self):\n self._turtle.clear()\n self._turtle.setposition((0,0)) \n self._turtle.shape('turtle')\n self.color = 'red'\n self.heading = 180\n self.speed = 0", "def reset(cls):\n\n cls._set_mode_stopped()\n TimeDisplay.reset_time(erase=True)\n TimeDisplay.show_default()\n Notes.clear()\n for callback in cls.reset_callback:\n callback()", "def reset(self):\n self._turtle.clear()\n self._turtle.setposition((0,0)) \n try:\n self._turtle.shape('pen.gif')\n except:\n self._turtle.shape('classic')\n self._turtle.color('red')\n self.speed = 0\n \n #pair = self._turtle.color()\n self._pencolor = self._turtle.color()[0]\n self._fillcolor = self._turtle.color()[0]", "def reset(self):\n\n game.reset()\n sm.get_screen('game_screen').reset()", "def reset(self):\n self.num_steps = 0\n self.world_state = self.action = None", "def reset(self):\n Simulation.reset(self)", "def reset(self):\n self.state.fill(EMPTY)", "def reset(self):\n self._set_init()", "def reset(self):\n self.set_state(self._initial_state)", "def reset(self):\n self.steps = 0\n self.state = 0\n self.trajectory = []", "def reset_all(self):\n self._stepsize = _stepsize\n self.reset_f()\n self.reset_s()\n self.reset_u()", "def init_turtle():\n turtle.up()\n turtle.home()", "def reset_states(self):\n self.model.reset_states()", "def reset(self):\r\n self._p = self._p_init\r\n self._r = self._r_init\r\n self._v = self._v_init\r\n self._w = self._w_init\r\n self._a = self._a_init\r\n self._alpha = self._alpha_init", "def clear(self):\n self._frame.clear()\n self._turtles = []\n self._gpens = []", "def reset(self):\n self.index = self.start_index\n self.state = self.initial_state\n self.tape = Tape(empty_value=self.empty_value)", "def reset():\n if not game_state.is_solving:\n game_state.is_solving = False\n game_state.is_dirty = False\n\n del tower_a_disks[0:len(tower_a_disks)]\n del tower_b_disks[0:len(tower_b_disks)]\n del tower_c_disks[0:len(tower_c_disks)]\n\n disk_sprites.empty()\n\n [add_disk() for x in range(3)]\n\n return reset", "def reset(self):\n self.x = int(constants.SCREEN_WIDTH/2)\n self.y = int(constants.SCREEN_HEIGHT/2)\n self.DX = self.getRandSpeed()\n self.DY = self.getRandSpeed()", "def reset(self):\n self.creature.reset()\n self.current_world = copy.copy(self.init_world_rewards)\n self.draw_board()\n self.last_move = None", "def reset(self):\r\n self.body = [[int(self.x_pos/2), int(self.y_pos/2)]] # initial snake starts at center of screen\r\n self.direction = \"UP\"\r\n self.length = 1\r\n self.alive = True\r\n self.speed = 10", "def clear(self):\n self._turtle.clear()", "def clear(self):\n self._turtle.clear()", "def reset(self):\n\n # Ending variables\n self.time_idle = 0\n self.time_episode = 0\n self.done_time_idle = False\n self.done_falling = False\n self.done_time_episode = False\n\n # hero variables\n self.last_location = None\n self.last_velocity = 0\n\n # Sensor stack\n self.prev_image_0 = None\n self.prev_image_1 = None\n self.prev_image_2 = None\n\n self.last_heading_deviation = 0", "def reset(self):\n self.observable_fsm.reset()\n self.latent_fsm.reset()", "def reset(self):\n \n pass", "def reset(self, tape):\n self._current_state = self._start_state\n self._tape = list(tape)\n self._head = 0", "def reset(self):\n for i in range(0, len(self.current_state)):\n self.current_state[i] = 0\n\n for i in range(0, len(self.weights)):\n self.weights[i] = 0", "def reset():\n pass", "def reset():\n pass" ]

[ "0.7616165", "0.7476714", "0.706625", "0.70513546", "0.703268", "0.6975026", "0.6952702", "0.6930557", "0.6837944", "0.68164074", "0.67610794", "0.67327464", "0.6727695", "0.6708193", "0.66862565", "0.6662717", "0.6635122", "0.66217583", "0.65915465", "0.65861017", "0.65810686", "0.6581016", "0.6581016", "0.6572161", "0.6569747", "0.6569422", "0.65345883", "0.65153545", "0.6513867", "0.6513867" ]

[ "def turtles(self):\n return self._turtles[:]", "def makeTurtles(num):\n turtles = []\n for i in range(num):\n t = turtle.Turtle()\n #t.speed(0) # can set this for superfast disc movement\n t.up()\n t.shape('square')\n t.shapesize(stretch_len=(2 + i)) #bottom turtle is longest\n t.goto(0, num - i)\n turtles.append(t)\n return turtles", "def turbines(self):\n return self.turbine_map.turbines", "def terminals(self) -> List[Terminal]:\n return [terminal for prim in self.primitives for terminal in prim._terminals]", "def getturtle(self):\n return self", "def terminals(self):\n\n return self._terminals.getSlice(0)", "def terminals(self):\n\n return self._terminals.getSlice(0)", "def terminals(self) -> AbstractSet[Terminal]:\n return self._terminals", "def Screen():\n if Myturtle._screen is None:\n Myturtle._screen = _Screen()\n return Myturtle._screen", "def _drawturtle(self):\n screen = self.screen\n shape = screen._shapes[self.Myturtle.shapeIndex]\n ttype = shape._type\n titem = self.Myturtle._item\n if self._shown and screen._updatecounter == 0 and screen._tracing > 0:\n self._hidden_from_screen = False\n tshape = shape._data\n if ttype == \"polygon\":\n if self._resizemode == \"noresize\": w = 1\n elif self._resizemode == \"auto\": w = self._pensize\n else: w =self._outlinewidth\n shape = self._polytrafo(self._getshapepoly(tshape))\n fc, oc = self._fillcolor, self._pencolor\n screen._drawpoly(titem, shape, fill=fc, outline=oc,\n width=w, top=True)\n elif ttype == \"image\":\n screen._drawimage(titem, self._position, tshape)\n elif ttype == \"compound\":\n for item, (poly, fc, oc) in zip(titem, tshape):\n poly = self._polytrafo(self._getshapepoly(poly, True))\n screen._drawpoly(item, poly, fill=self._cc(fc),\n outline=self._cc(oc), width=self._outlinewidth, top=True)\n else:\n if self._hidden_from_screen:\n return\n if ttype == \"polygon\":\n screen._drawpoly(titem, ((0, 0), (0, 0), (0, 0)), \"\", \"\")\n elif ttype == \"image\":\n screen._drawimage(titem, self._position,\n screen._shapes[\"blank\"]._data)\n elif ttype == \"compound\":\n for item in titem:\n screen._drawpoly(item, ((0, 0), (0, 0), (0, 0)), \"\", \"\")\n self._hidden_from_screen = True", "def lights(self):\n return list(self.GetLights())", "def shapes():\r\n turtle.up()\r\n turtle.forward(500)\r\n turtle.down()\r\n draw_hexagon()\r\n draw_square()\r\n draw_triangle()", "def _get_current_session_tiling_list(self) -> List:\n return self._data[-1][History._TILINGS]", "def getScreenList(self, verbose = False):\n return execCmd(\"%s -list\" % self._screenPath, verbose)", "def listofstars():\n a = []\n for star in Star.select():\n a.append(star.name)\n return a", "def init_turtle():\n turtle.up()\n turtle.home()", "def draw_objects():\n\n # Disable the turtle animation, and erase the scren.\n turtle.tracer(False)\n turtle.hideturtle()\n turtle.clear()\n\n # Draw all the parts of the scene.\n draw_ball()\n draw_target()\n draw_bounds()\n draw_pins()\n\n show_status()\n\n # Now show the screen, after everything has been drawn\n turtle.tracer(True)", "def getAllTriStimulus(self):\n return self.tristimulus", "def thermostats(self):\n\n return self._thermostats", "def get_light_list(self):\n return self.light_array", "def shapes2():\r\n turtle.up()\r\n turtle.backward(100)\r\n turtle.left(270)\r\n turtle.forward(100)\r\n turtle.left(90)\r\n turtle.backward(700)\r\n shapes()", "def graphicsItems(self):\n return self.ctrl.getGraphicsItems()", "def draw(coorlist):\n tur = turtle.Turtle()\n for coor in coorlist:\n tur.penup()\n tur.goto(coor[0][0],coor[0][1])\n tur.pendown()\n tur.goto(coor[0][0],coor[1][1])\n tur.goto(coor[1][0],coor[1][1])\n tur.goto(coor[1][0],coor[0][1])\n tur.goto(coor[0][0],coor[0][1])", "def swing_list(self):\n return self._swing_list", "def draw_flower_bed():\n turtle.up()\n turtle.left(180)\n turtle.forward(200)\n turtle.right(180)\n turtle.down()\n for flower in range(3):\n draw_flower_advanced()", "def _get_all_spectra(self):\n pass", "def rays(self):\n try:\n return self._rays\n except:\n self._rays = [list(x) for x in self.ray_generator()]\n return self._rays", "def getRaceList(self):\n\t\tl = []\n\t\tfor r in self.races:\n\t\t\tl.append(r.name)\n\t\treturn l", "def look(self):\n heading_queue = copy(self.heading)\n heading_queue.rotate(-2)\n headings = list(heading_queue)[:5] # gives a list of 5 headings from leftmost to rightmost\n LED_list = []\n for w, l in headings:\n LED_list.append(self.search(w, l, 0))\n return LED_list", "def get_valid_terminals():\n result = []\n terminals = _get_terminals()\n for t in terminals:\n log.d(\"Checking for terminal %s\", t.name)\n if t.detect():\n log.d(\"Found terminal %s\", t.name)\n result.append(t)\n return result" ]

[ "0.77794784", "0.618826", "0.6020392", "0.5884094", "0.5768146", "0.570828", "0.570828", "0.55725443", "0.55628484", "0.5510625", "0.5503567", "0.5488319", "0.5483643", "0.54379463", "0.54103893", "0.53822607", "0.5370226", "0.5332753", "0.53281486", "0.5306837", "0.5304102", "0.5300733", "0.52750915", "0.5203581", "0.5194281", "0.5189096", "0.5166152", "0.5145319", "0.5139723", "0.5130415" ]

[ "def height(self):\n _, ymin, _, ymax = self.viewport\n return self.parent.window_size[1] * (ymax - ymin)", "def height(self):\n return(self.SCREEN_H)", "def height(self) -> int:\n return self.screen.getmaxyx()[0]", "def winfo_screenheight(self):\n return self.height", "def get_height(self):\n return self.calc_height(self.root)", "def height(self) -> int:\n self.tk_ref.update()\n return self.tk_ref.winfo_height()", "def get_height(self):\r\n return self.state['h']", "def get_height(self) -> int:\n return self.rsimulator.get_frame_height()", "def height(self):\n return self._el._parent.execute_script(\"return arguments[0].height\", self._el)", "def height(self):\n return self._el._parent.execute_script(\"return arguments[0].height\", self._el)", "def height(self):\n return _libsbml.Dimensions_height(self)", "def get_height(self):\r\n return self._height", "def get_height(self):\r\n return self._height", "def get_height(self):\r\n return self._height", "def screen_height(self):\n # type: () -> int\n return self._screen_height", "def get_height(self):\n return self._height", "def get_height(self):\n return self._height", "def get_height(self):\n return self._height", "def get_height(self):\n return self._height", "def get_height(self):\n return self.__height", "def getHeight(self):\n return self.height", "def getHeight(self):\n return self.height", "def height (self):\n return self._h", "def getHeight(self):\n return self._height", "def getHeight(self):\n return _libsbml.Dimensions_getHeight(self)", "def height(self) :\n return self.m_height", "def GetHeight(self):\r\n\r\n return self._height", "def getHeight(self):\n return _tkCall(self.image.height)", "def height(self):\n return self.maxy - self.miny", "def height(self):\n return self.client.call('GET', self.name + 'height')" ]

[ "0.77892154", "0.7528305", "0.74939007", "0.72679096", "0.7238108", "0.7189834", "0.71686447", "0.7113705", "0.70795184", "0.70795184", "0.70783186", "0.70663285", "0.70663285", "0.70663285", "0.7059714", "0.7046815", "0.7046815", "0.7046815", "0.7046815", "0.70452046", "0.70398134", "0.70398134", "0.70321614", "0.69719726", "0.69005156", "0.6854179", "0.6842286", "0.68218255", "0.68201596", "0.6799658" ]

[ "def canvas(self):\n return self._canvas", "def Screen():\n if Myturtle._screen is None:\n Myturtle._screen = _Screen()\n return Myturtle._screen", "def get_canvas(self, key) -> tk.Canvas:\n try:\n canvas = self._Canvases[key]\n except KeyError:\n canvas = self._Canvases[key] = tk.Canvas()\n return canvas", "def draw(self):\n return self._myCanvas.draw()", "def getScreen(self):\n \n return self.screen", "def create_canvas(self):\n self.canvas = tk.Canvas(\n self,\n bd=-2,\n height=self.controller.GAME_HEIGHT,\n width=self.controller.GAME_WIDTH)\n self.canvas.pack(expand=tk.YES, fill=tk.BOTH)", "def create_canvas(self):\n self.canvas = tk.Canvas(\n self,\n bd=-2,\n height=self.controller.GAME_HEIGHT,\n width=self.controller.GAME_WIDTH)\n self.canvas.pack(expand=tk.YES, fill=tk.BOTH)", "def create_canvas(self):\n self.canvas = tk.Canvas(\n self,\n bd=-2,\n height=self.controller.GAME_HEIGHT,\n width=self.controller.GAME_WIDTH)\n self.canvas.pack(expand=tk.YES, fill=tk.BOTH)", "def draw_canvas(self):\n\n self.canvas = Canvas(self)\n self.scrollbar = ttk.Scrollbar(self, orient= VERTICAL,\n command=self.canvas.yview) \n self.canvas.configure(yscrollcommand=self.scrollbar.set)\n \n # make sure to add scrollbar before adding the canvas\n self.scrollbar.pack(side=RIGHT, fill=Y)\n self.canvas.pack(side=TOP, fill=BOTH, expand=1, padx=20, pady=20)\n \n # adding a frame to hold all the widgets, ttk Frame doesn't support\n # background config option \n self.frame = Frame(self.canvas) \n self.canvas.create_window(0,0,window=self.frame, anchor='nw')", "def getturtle(self):\n return self", "def make_canvas(self, painter, **args):\n\t\treturn Canvas(painter, **args)", "def get_screen(self):\n return self._cached('raw', self.ale.getScreen)", "def getPic(self):\n if self.sync==False:\n self._drawOnCanvas()\n return self.canvas", "def get_context(self):\n return cairo.Context(self._s)", "def draw(self):\n return self._draw", "def getscreen(self):\n return self.screen", "def getscreen(self):\n return self.screen", "def make_canvas(self, painter, **args):\n\t\treturn None", "def to_canvas(self, canvas):\n self.sprite.to_canvas(canvas=canvas, location=self.location)", "def is_canvas(self):\n return self.canvas._isCanvas", "def create_board_window():\n wn = turtle.Screen()\n wn.setworldcoordinates(0, 0, WIDTH+1, HEIGHT+1)\n t = turtle.Turtle()\n t.pensize(1)\n t.speed(0)\n t.hideturtle()\n return (wn, t)", "def draw(self, screen):", "def _drawturtle(self):\n screen = self.screen\n shape = screen._shapes[self.Myturtle.shapeIndex]\n ttype = shape._type\n titem = self.Myturtle._item\n if self._shown and screen._updatecounter == 0 and screen._tracing > 0:\n self._hidden_from_screen = False\n tshape = shape._data\n if ttype == \"polygon\":\n if self._resizemode == \"noresize\": w = 1\n elif self._resizemode == \"auto\": w = self._pensize\n else: w =self._outlinewidth\n shape = self._polytrafo(self._getshapepoly(tshape))\n fc, oc = self._fillcolor, self._pencolor\n screen._drawpoly(titem, shape, fill=fc, outline=oc,\n width=w, top=True)\n elif ttype == \"image\":\n screen._drawimage(titem, self._position, tshape)\n elif ttype == \"compound\":\n for item, (poly, fc, oc) in zip(titem, tshape):\n poly = self._polytrafo(self._getshapepoly(poly, True))\n screen._drawpoly(item, poly, fill=self._cc(fc),\n outline=self._cc(oc), width=self._outlinewidth, top=True)\n else:\n if self._hidden_from_screen:\n return\n if ttype == \"polygon\":\n screen._drawpoly(titem, ((0, 0), (0, 0), (0, 0)), \"\", \"\")\n elif ttype == \"image\":\n screen._drawimage(titem, self._position,\n screen._shapes[\"blank\"]._data)\n elif ttype == \"compound\":\n for item in titem:\n screen._drawpoly(item, ((0, 0), (0, 0), (0, 0)), \"\", \"\")\n self._hidden_from_screen = True", "def getCurrentCanvasTab(self):\n # get the current tab index and the widget\n index = self.pickerUI.characterTabs.currentIndex()\n widget = self.pickerUI.characterTabs.widget(index)\n\n children = widget.children()\n for child in children:\n if type(child) == QtWidgets.QTabWidget:\n tab = child\n canvasIndex = tab.currentIndex()\n canvasWidget = tab.widget(canvasIndex)\n\n canvasChildren = canvasWidget.children()\n for canvasChild in canvasChildren:\n if type(canvasChild) == QtWidgets.QGraphicsView:\n view = canvasChild\n scene = view.scene()\n\n return scene", "def getWin(self):\n return self.__win", "def get_screen(env):\n # Returned screen requested by gym is 400x600x3\n # Transpose it into torch order (CHW).\n screen = env.render(mode='rgb_array').transpose((2, 0, 1))\n # Convert to float, rescale, convert to torch tensor\n screen = np.ascontiguousarray(screen, dtype=np.float32) / 255\n screen = torch.from_numpy(screen)\n # Resize, and add a batch dimension (BCHW)\n return resize(screen).unsqueeze(0)", "def setup_canvas(self):\n # create frame to contain canvas\n self.world_container = tk.Frame(self,\n width = self.world_size[1],\n height = self.world_size[0])\n self.world_container.grid(row = 1, column = 0, sticky = tk.W+tk.N)\n\n # create canvas\n self.canvas = tk.Canvas(\n self.world_container,\n width = self.world_size[1],\n height = self.world_size[0],\n borderwidth = 1,\n highlightthickness = 0)\n self.canvas.grid(row = 0, column = 0, sticky = tk.W)\n self.canvas.bind('<Button-1>', self.click_cell)", "def GetDC(self):\r\n\r\n return self.dc", "def new_canvas(self):\n libtcod.console_clear(self.console)", "def create_board_canvas(master: Widget) -> None:\r\n\r\n self.canvas = Canvas(master, bg='black')\r\n self.canvas.bind('<Configure>', self.on_canvas_resize)\r\n self.canvas.bind(\"<B1-Motion>\", self.on_canvas_click)\r\n self.canvas.bind(\"<Button-1>\", self.on_canvas_click)\r\n self.canvas.bind(\"<ButtonRelease-1>\", self.on_canvas_mouse_release)\r\n self.canvas.pack(fill=BOTH, expand = TRUE)" ]

[ "0.746768", "0.6747746", "0.6109935", "0.60657513", "0.6064832", "0.5963825", "0.5963825", "0.5963825", "0.5834056", "0.57346946", "0.5724637", "0.56410736", "0.5569283", "0.55174804", "0.5481251", "0.5480726", "0.5480726", "0.5450803", "0.5432645", "0.54213107", "0.53938913", "0.5285996", "0.52666825", "0.52609754", "0.5259097", "0.52383757", "0.5222006", "0.521607", "0.5200954", "0.51968247" ]

[ "def _onkeypress(self, fun, key=None):\n if fun is None:\n if key is None:\n self.cv.unbind(\"<KeyPress>\", None)\n else:\n self.cv.unbind(\"<KeyPress-%s>\" % key, None)\n else:\n def eventfun(event):\n fun()\n if key is None:\n self.cv.bind(\"<KeyPress>\", eventfun)\n else:\n self.cv.bind(\"<KeyPress-%s>\" % key, eventfun)", "def onkey(self, fun, key):\n if fun is None:\n if key in self._keys:\n self._keys.remove(key)\n elif key not in self._keys:\n self._keys.append(key)\n self._onkeyrelease(fun, key)", "def key_event(self, key: Any, action: Any):\n pass", "def keypress(cls, _, key):\n return key", "def on_key_event(self, key):\n pass", "def bind_key(self, key, command):\n self.key_bindings[key] = command", "def _onkeyrelease(self, fun, key):\n if fun is None:\n self.cv.unbind(\"<KeyRelease-%s>\" % key, None)\n else:\n def eventfun(event):\n fun()\n self.cv.bind(\"<KeyRelease-%s>\" % key, eventfun)", "def processKey(self, key):\n if self.key_handler is not None:\n self.key_handler(key)", "def _on_key_press(self, event):", "def keypress(key):\n k = PyKeyboard()\n if key == 'enter':\n key = k.return_key\n k.tap_key(key)", "def press_bound_key(self, event):\n if event.key in self.key_bindings:\n self.press()\n elif (event.key, pg.key.get_mods()) in self.key_bindings:\n self.press()", "def keyevent(self, keycode: Union[str, int]) -> None:\n self.shell(['input', 'keyevent', str(keycode)])", "def _handle_key_event(self, key, modifiers, mapping):\n if key in mapping:\n for callback in mapping[key]:\n callback()", "def __acceptKeyDown(self, key):\n self.accept(key, self.__handleKeyDown, [key])", "def key_press(keys):\n return lambda e: e.key if e.type == pygame.KEYDOWN \\\n and e.key in keys else EventConsumerInfo.DONT_CARE", "def keypress(self, key, state=None):\n\n\t\tself._interface.keypress(key, state)", "def on_key_press(self, key, callback):\n self._key_press_mappings.setdefault(key, []).append(callback)", "def on_press(key):\n try:\n # gets pressed key char value and searches it from dict with get method.\n mapped_key = key_mappings.get(key.char) # gets value and type tuple or None\n if mapped_key:\n module.pressed_key = mapped_key\n except AttributeError:\n traceback.print_exc()\n except KeyboardInterrupt:\n print(f\"\\n{module.current_time()} Application stopped\")", "def on_key(self, _win, key, _scancode, action, _mods):\n if action == glfw.PRESS or action == glfw.REPEAT:\n if key == glfw.KEY_ESCAPE or key == glfw.KEY_Q:\n glfw.set_window_should_close(self.win, True)\n if key == glfw.KEY_W:\n GL.glPolygonMode(GL.GL_FRONT_AND_BACK, next(self.fill_modes))\n\n self.key_handler(key)", "def on_key(self, _window, key, _scancode, action, _mods):\n is_press = action == glfw.PRESS or action == glfw.REPEAT\n if is_press and (key == glfw.KEY_ESCAPE or key == glfw.KEY_Q):\n glfw.set_window_should_close(self.window, True)\n\n if action != glfw.REPEAT:\n self.key_handler(key, is_press)", "def slot_keypress(self, gox, (key)):\r\n pass", "def keyevent(keyname, **kwargs):\n G.DEVICE.keyevent(keyname, **kwargs)\n delay_after_operation()", "def key_press_event(self, event):\n pass", "def keypress(self, key): # pragma: no cover\n if key == \"s\":\n self.screenshot()\n\n elif key == \"q\" or key == \"Esc\":\n self.close()\n\n elif key == \"c\":\n self._print_camera()", "def pressBoundKey(motion):\n if bindings[motion]:\n autopy.key.tap(bindings[motion], [])", "def k_press(self, key: KKey):\n pass", "def bind_key(self, key):\n self.key_bindings.append(key)", "def key_handler(self):\n \n self.pressed = waitKey(1) & 255 #wait for keypress for 10 ms\n if self.pressed == 27: #exit program on 'esc'\n print \"exiting...\"\n self.camera.cam.release()\n exit()\n \n for key in self.key_controls.keys():\n if chr(self.pressed) == key:\n self.key_controls[key]()", "def input_key_event(self, key, custom_key=None):\n\n key_event = INPUT_ACTION_SWITCHER.get(key)\n if key_event == \"-1\":\n key_event = custom_key\n self.android_device_driver.adb.exec_adb_cmd(\"shell input keyevent \" +\n key_event).wait()", "def on_key_press(self, key, modifiers):\n player_controller.input_press(self, key, self.player)" ]

[ "0.8049445", "0.728405", "0.7153001", "0.69796234", "0.690792", "0.6847852", "0.6822198", "0.67301124", "0.6724557", "0.6638977", "0.65856296", "0.651688", "0.6496849", "0.646137", "0.642909", "0.6423411", "0.6415512", "0.64058536", "0.63954604", "0.638796", "0.6359569", "0.6317063", "0.6304207", "0.628069", "0.62528366", "0.62524325", "0.6243325", "0.6223692", "0.6216864", "0.62165165" ]

[ "def _ontimer(self, fun, t):\n if t == 0:\n self.cv.after_idle(fun)\n else:\n self.cv.after(t, fun)", "def start(self, sec, callFunc, *args, **kwargs):\n self.cancel()\n \n def doit(args=args, kwargs=kwargs):\n self._timerID = None\n callFunc(*args, **kwargs)\n\n self._timerID = self._tkWdg.after(int(0.5 + (1000.0 * sec)), doit)", "def __timeout(self, seconds, func, *args):\n t = threading.Timer(seconds, func, *args)\n self._timer = t\n t.start()", "def timerfunc(func):\n function_timer = functools.partial(__timerfunc, printer=print)(func)\n return function_timer", "def timer(func):\n def timer_wraper(*args, **kwargs):\n start = time.time()\n func(*args, **kwargs)\n end = time.time()\n runtime = (end - start)\n #Minutes, seconds, hours, minutes\n m, s = divmod(runtime, 60)\n h, m = divmod(m, 60)\n print(\" Execution time: %d:%02d:%02d (H:MM:SS)\" % (h, m, s))\n return timer_wraper", "def create_timer(function, time):\n timer = Timer()\n timer.timeout.connect(function)\n timer.start(time)\n timer.speed = time\n return timer", "def __set_interval(self, func, sec):\n\n def func_wrapper():\n self.__set_interval(func, sec)\n func()\n\n t = threading.Timer(sec, func_wrapper)\n t.start()\n return t", "def timer(fun):\n @wraps(fun)\n def wrapper(args):\n \"\"\"Wraps function execution time.\"\"\"\n if args[\"--time\"]:\n import time\n start_time = time.time()\n result = fun(args)\n LOGGER.info(\"Total time:\", time.time() - start_time)\n return result\n\n return fun(args)\n\n return wrapper", "def startTimer (self, usec, callback):\n return self.impl.startTimer(usec, callback)", "def timer(func):\n @wraps(func)\n def wrapper_timer(*args, **kwargs):\n print(f'[Function: {func.__name__!r} start...]')\n tic = time()\n try:\n return func(*args, **kwargs)\n finally:\n toc = time()\n run_time = toc - tic\n print(f'[Function: {func.__name__!r} finished in {run_time:.4f} secs]\\n')\n return wrapper_timer", "def clockit(func):\n def new(*args, **kw):\n t = Timer()\n retval = func(*args, **kw)\n t.stop()\n print(\"{} in {}\".format(func.__name__, t))\n del t\n return retval\n return new", "def _settimer(t,m=''):\n\n FNULL = open(os.devnull, 'w')\n \n selfPath = os.path.abspath(__file__)\n cmd = 'nohup nice python {:s} _run {:0.10f} {:s}'.format(selfPath,t,m)\n \n subprocess.Popen(cmd.split(),stdout=FNULL, stderr=subprocess.STDOUT)\n print _gettxt(t,m=m)", "def timer(func):\n def wrapper(*args, **kwargs):\n start = time.time()\n value = func(*args, **kwargs)\n print(f\"Running time: {time.time() - start}\")\n return value\n return wrapper", "def watch(self, func, seconds=3600):\n func\n time.sleep(seconds)", "def timer(func):\n @functools.wraps(func)\n def wrapper_timer(*args, **kwargs):\n start_time = time.perf_counter() # 1\n value = func(*args, **kwargs)\n end_time = time.perf_counter() # 2\n run_time = end_time - start_time # 3\n print(\"Finished %r in %.2f seconds\"%(func.__name__,run_time))\n return value\n return wrapper_timer", "def Timer(func):\n @wraps(func)\n def wrapper(*args, **kwargs):\n start_time = time.perf_counter()\n ans = func(*args, **kwargs)\n end_time = time.perf_counter()\n running_time = end_time-start_time\n logger.debug(\n f'func:{func.__name__} running in {running_time:.4f} sec.')\n return ans\n return wrapper", "def update(self, func):\n if self.current_time == 0:\n func()\n return\n self.current_time -= 1\n hours = self.current_time // 3600\n minutes = self.current_time % 3600 // 60\n seconds = self.current_time % 60\n try:\n self.timer_label.setText('%02d:%02d:%02d' % (hours, minutes, seconds))\n if self.current_time <= 10:\n self.timer_label.setStyleSheet('color: red')\n Qt.QTimer().singleShot(1000, lambda: self.update(func))\n except RuntimeError:\n return", "def timer(func):\n\n @functools.wraps(func)\n def wrapper_timer(*args, **kwargs):\n start_time = time.perf_counter()\n value = func(*args, **kwargs)\n end_time = time.perf_counter()\n run_time = end_time - start_time\n print(f\"Finished {func.__name__!r} in {run_time:.4f} secs\")\n return value\n\n return wrapper_timer", "def timer(func):\n # Define the wrapper function to return\n def wrapper(*args, **kwargs):\n # When wrapper() is called, get the current time\n t_start = time.time()\n # Call the decorated function and store the result.\n result = func(*args, **kwargs)\n # Get the total time it took to run, and print it.\n t_total = time.time() - t_start\n print('{} took {}s'.format(func.__name__, t_total))\n\n return result\n\n return wrapper", "def time_it(func):\n\n def wrapper(*args, **kwargs):\n start = timer()\n func(*args, **kwargs)\n print(timer() - start)\n\n return wrapper", "def timer(func):\n\n @functools.wraps(func)\n def wrapper_timer(*args, **kwargs):\n start_time = time.perf_counter() # 1\n value = func(*args, **kwargs)\n end_time = time.perf_counter() # 2\n run_time = end_time - start_time # 3\n print(f\"Finished {func.__name__!r} in {run_time:.4f} secs\")\n return value\n\n return wrapper_timer", "def register_event(self, freq, func):\n def wrapper():\n if self.running:\n if func():\n t = threading.Timer(freq, wrapper)\n\n self.events_lock.acquire()\n self.events.append(t)\n t.start()\n self.events_lock.release()\n\n wrapper()", "def timer(func):\n @functools.wraps(func)\n def wrapper_timer(*args, **kwargs):\n start_time = time.perf_counter() # 1\n value = func(*args, **kwargs)\n end_time = time.perf_counter() # 2\n run_time = end_time - start_time # 3\n# print(f\"\\nFinished {func.__name__!r} in {run_time:.4f} secs\")\n print('\\nFinished {!r} in {:.4f} s'.format(func.__name__, run_time))\n return value\n return wrapper_timer", "def timer(func):\n @functools.wraps(func)\n def wrapper_timer(*args, **kwargs):\n start_time = time.clock() # 1\n value = func(*args, **kwargs)\n end_time = time.clock() # 2\n run_time = end_time - start_time # 3\n print(\"Finished {0!r} in {1:.4f} secs\".format(func.__name__, run_time ))\n return value\n return wrapper_timer", "def start_periodic_timer(self, interval, fun, *args, **kwargs):\n entry = timer(interval, fun, *args, **kwargs)\n self._timers.append(entry)\n return entry", "def _runtimer(t,m=''):\n t = float(t) # minutes\n \n if not os.path.exists('/var/tmp/timer'):\n os.makedirs('/var/tmp/timer')\n \n txt,endobj = _gettxt(t,m,ret_end=True)\n \n name = '/var/tmp/timer/' + str(time.mktime(endobj.timetuple()))\n with open(name,'w') as F:\n F.write(txt)\n \n time.sleep(t*60)\n \n if not os.path.exists(name):\n return # It was deleted while sleeping\n else:\n os.remove(name)\n \n # Just mac for now. Will add linux later\n uname = os.uname()[0]\n if uname.lower() == 'darwin':\n cmd = \"\"\"terminal-notifier -message 'Timer Finished: {:0.2f} minutes. {:s}' -title 'Timer'\"\"\".format(t,m)\n os.system(cmd)\n os.system('say -v bells \"beep\"')", "def func_with_internal_timer(n):\n start = time.time()\n\n # Do the work of the function here e.g.\n time.sleep(n)\n\n elapsed = time.time() - start\n print(\"{} finished in {:2.3f} seconds\".format(\"func_with_internal_timer\", elapsed))", "def timer_handler():\r\n \r\n global elapsed_time\r\n elapsed_time += 1", "def timer(func):\n @wraps(func)\n def wrap_timer(*args, **kwargs):\n t0 = perf_counter()\n returned = func(*args, **kwargs)\n t1 = perf_counter()\n print(f\"[Time: {t1-t0:.6f} s]\")\n return returned\n return wrap_timer", "def __window_setTimeout(self, f, delay):\n self.__dict__['__timeout'].append(f)" ]

[ "0.6821705", "0.65327096", "0.64860356", "0.6438011", "0.6404118", "0.6387972", "0.6329832", "0.632448", "0.62718546", "0.62434834", "0.61498404", "0.61293244", "0.6124812", "0.6119987", "0.61141527", "0.6110378", "0.6106083", "0.60576034", "0.6030907", "0.60302967", "0.60103554", "0.59817654", "0.59781295", "0.597292", "0.5971592", "0.595399", "0.5939575", "0.5933954", "0.5916163", "0.59151214" ]

[ "def setTurtle(t):\r\n t.pu()\r\n t.goto(initialCoordinates())", "def setTeXMode(mode):\n if mode:\n dislin.texmod('ON')\n else:\n dislin.texmod('OFF')", "def setScreenMode(mode='normal'):\n screendict = {'normal':'REVERS', 'black':'NOREV'}\n dislin.scrmod(screendict[mode])", "def reset(self):\n self._turtle.clear()\n self._turtle.setposition((0,0)) \n self._turtle.shape('turtle')\n self.color = 'red'\n self.heading = 180\n self.speed = 0", "def set_mode(self, mode):\n if mode in self.MODES:\n self.mode = self.MODES[mode]", "def init_turtle():\n turtle.up()\n turtle.home()", "def setMode(self, mode):\n self.mode = mode\n if self.mode == 0:\n self.setDrawingMode()\n elif self.mode == 1:\n self.setConstructionMode()\n elif self.mode == 2:\n self.setDisplayMode()\n self.context.text.append(\"mode: \" + self.messages[self.mode])", "def mode(self, mode):\n self.set_mode(mode)", "def setMode(self,mode):\n self.mode=mode\n if self.mode==0:\n self.setDrawing()\n elif self.mode==1:\n self.setConstruction()\n elif self.mode==2:\n self.setDisplay()\n self.context.text.append(\"mode: \"+self.messages[self.mode])", "def reset(self):\n for Myturtle in self._turtles:\n Myturtle._setmode(self._mode)\n Myturtle.reset()", "def set_mode(self, mode):\n print('set_mode', mode)\n self._mode = int(mode)", "def setMode(cls, mode):\n global CURRENT_MODE\n assert isinstance(mode, cls), \"Invalid mode {}\".format(mode)\n CURRENT_MODE = mode", "def _set_draw_mode(draw_mode):\n###############################################################################\n global _draw_mode\n _draw_mode = draw_mode", "def _prepare_turtle():\n turtle.setup(width=screen_width)\n turtle.shape(turtle_shape)\n turtle.title(title)", "def init():\n turtle.setworldcoordinates(-WINDOW_WIDTH / 2, -WINDOW_WIDTH / 2,\n WINDOW_WIDTH / 2, WINDOW_HEIGHT / 2)\n\n turtle.up()\n turtle.setheading(0)\n turtle.title('squares')\n pass", "def screen_setup(screen_size):\n window = turtle.Screen()\n window.bgcolor(\"black\")\n window.title(\"Maze Game\")\n window.setup(screen_size, screen_size)", "def set_mode(self, mode):\n if mode == 'train':\n self.hidden = self._make_hidden(self.batch_size)\n elif mode == 'generate':\n self.hidden = self._make_hidden(1)", "def set_mode(self, mode):\n if mode == 'train':\n self.hidden = self._make_hidden(self.batch_size)\n elif mode == 'generate':\n self.hidden = self._make_hidden(1)", "def turtle(self,turtleType):\n if self.turtleType == turtleType:\n return\n if self.turtleType and self.turtleType != PLAYER:\n self.mc.removeEntity(self.turtleId)\n self.turtleType = turtleType\n if turtleType == PLAYER:\n self.turtleId = None\n elif turtleType:\n self.turtleId = self.mc.spawnEntity(turtleType,\n self.position.x,self.position.y,self.position.z,\n \"{NoAI:1}\")\n self.setEntityCommands()\n self.positionOut()\n self.directionOut()", "def initialize(turtle_shape, bg_color, turtle_color, turtle_speed):\n turtle_instance = turtle.Turtle()\n turtle_instance.shape(turtle_shape)\n turtle.bgcolor(bg_color)\n turtle_instance.color(turtle_color)\n turtle_instance.speed(turtle_speed)\n return turtle_instance", "def testSetMode(self):\n my_button = buttonsprite.ButtonSprite()\n my_button.setMode('inactive')\n self.assertEquals(my_button._draw_function, my_button._drawInactive)\n my_button.setMode('highlighted')\n self.assertEquals(my_button._draw_function, my_button._drawHighlighted)\n my_button.setMode('pressed')\n self.assertEquals(my_button._draw_function, my_button._drawPressed)\n my_button.setMode('normal')\n self.assertEquals(my_button._draw_function, my_button._drawNormal)", "def setModes(self, measurement = 'Ambiant', color_space = 'CIExyY', illumination = 'Emission'):\n self.setMeasurementMode(measurement)\n self.setColorSpace(color_space) \n self.setIlluminationMode(illumination)", "def reset(self):\n self._turtle.clear()\n self._turtle.setposition((0,0)) \n try:\n self._turtle.shape('pen.gif')\n except:\n self._turtle.shape('classic')\n self._turtle.color('red')\n self.speed = 0\n \n #pair = self._turtle.color()\n self._pencolor = self._turtle.color()[0]\n self._fillcolor = self._turtle.color()[0]", "def set_mode(arg):\n global mode\n mode = arg\n # If we're going to Normal mode, the cursor must move one character to the\n # left.\n if mode == \"NORMAL\":\n buf = weechat.current_buffer()\n input_line = weechat.buffer_get_string(buf, \"input\")\n cur = weechat.buffer_get_integer(buf, \"input_pos\")\n set_cur(buf, input_line, cur - 1, False)\n weechat.bar_item_update(\"mode_indicator\")", "def set_slam_type(self, mode):\n if mode == LandmarkMode.RANSAC:\n self.slam.naive = False\n self.slam.slam_mode = SlamMode.LANDMARKS\n self.slam.landmark_mode = LandmarkMode.RANSAC\n elif mode == LandmarkMode.HOUGH:\n self.slam.naive = False\n self.slam.slam_mode = SlamMode.LANDMARKS\n self.slam.landmark_mode = LandmarkMode.HOUGH\n elif mode == SlamMode.SCAN_MATCHING:\n self.slam.naive = False\n self.slam.slam_mode = SlamMode.SCAN_MATCHING\n else:\n self.slam.naive = True", "def setMode(self):\n if self.currentTarget != None and self.finishedAssault == 0:\n if self.isAssault == 1:\n if self.currentTarget != None:\n self.mode = 'assault'\n else:\n self.mode = 'escape'\n else:\n self.log.debug('COUNT: %s: %s TARGET-> %s' % (self.myGalaxy.count, self.name, self.currentTarget.name))\n ##self.myGalaxy.resultList.append('COUNT: %s: %s TARGET-> %s' % (self.myGalaxy.count, self.name, self.currentTarget.name))\n if ((len(self.activeWeapons) == 0 or (self.currentISP/self.myShipHull.maxISP) < 0.7)) and self.__module__ == 'anw.war.ship':\n self.mode = 'escape'\n else:\n range = funcs.getTargetRange(self.posX, self.posY, self.currentTarget.posX, self.currentTarget.posY)\n if range <= self.range:\n self.mode = 'engage'\n else:\n self.mode = 'close'\n else:\n self.mode == 'escape'\n if globals.serverMode == 0:\n self.shipsim.updateShipMode()", "def setSurfaceShadingMode(mode='flat'):\n sdict = {'flat':'FLAT','smooth':'SMOOTH'}\n dislin.shdmod(sdict[mode], 'SURFACE')", "def set_mode(self, mode: str) -> None:\n # Not all programs are fully supported by the current\n # OpenInterface API version. The known restricitons are:\n # - The 'Calibration' and 'TightnessTest' programms cannot\n # be started through the API.\n # - The 'Dry' program does not expose all it's parameters\n # (see github.com/buchi-labortechnik-ag/openinterface_rotavapor/issues/1)\n return self.send(self.cmd.SET_MODE, mode)", "def set_mode_point():\n global DRAW_MODE\n DRAW_MODE=\"point\"", "def setColorMode(mode='full'):\n mdict = {'low':'NONE','full':'FULL'}\n dislin.clrmod(mdict[mode])" ]

[ "0.617484", "0.6054048", "0.58294433", "0.58062625", "0.578314", "0.572466", "0.5707494", "0.5694985", "0.5639299", "0.55981785", "0.55439913", "0.547545", "0.5439024", "0.5428712", "0.54244", "0.5385512", "0.53238237", "0.53238237", "0.5302166", "0.5295186", "0.5282529", "0.5280279", "0.5277806", "0.52642566", "0.5263718", "0.52416056", "0.5237325", "0.5228236", "0.52231616", "0.5199384" ]

[ "def setAngle(self,angle = 2.5):\n pass", "def set_angle(self, angle=0.0):\n self.angle = angle", "def setAngle(self, angle):\n self._angle = (angle + math.pi / 2) % math.pi - math.pi / 2\n # self._angle = angle % (2*math.pi)", "def set_angle(self, ang):\n if ang < 0:\n ang = 0\n elif ang > 180:\n ang = 180\n dutyCycle = 5 + (ang*5/180)\n self.servoPort.ChangeDutyCycle(dutyCycle)", "def angle(self, value):\n if value is None:\n value = 0.0\n\n self.__angle = value", "def set_angle(self, angle):\n new_angle = angle\n\n # Declaring conversion constants\n angle_min = 0\n angle_max = 180\n angle_range = angle_max - angle_min\n dc_range = self._dc_max - self._dc_min\n\n # Enforcing angle range\n if new_angle > angle_max:\n new_angle = angle_max\n elif new_angle < angle_min:\n new_angle = angle_min\n\n # Scaling input angle to an appropriate duty cycle\n duty_cycle = ((dc_range / angle_range) * (new_angle - angle_min)) + self._dc_min\n\n self._servo_pwm.changeDutyCycle(duty_cycle)", "def angle(self, angle_deg) -> None:\n ...", "def angle(self):\n self.convert_window(\"Angle\", \"degree\", [\"arcminute\", \"arcsecond\", \"circle\", \"degree\", \"gon\", \"gradian\", \"mil(Nato)\", \"mil(Soviet Union)\", \"mil(Sweden)\", \"octant\", \"quadrant\", \"radian\", \"revolution\", \"sextant\", \"sign\", \"turn\"])", "def wheel_angle(self, angle):\n self.angle = angle", "def angle(self, dangle_deg: float) -> None:\n ...", "def angle(self, angle):\n\n self._angle = angle", "def setAngularUnits(self,unit):\n\n\t\t#Sanity check\n\t\tassert unit.physical_type==\"angle\"\n\t\tself.side_angle = self.side_angle.to(unit)", "def setAngle(self, angle):\n self.vector.angle = angle", "def adjAngle(self, amt): \r\n\r\n self.angle = self.angle + radians(amt)\r\n self.redraw()", "def set_angle(self, angle):\n return self.bot_client.send_command(_Command.SetAngle, angle)", "def angle(self) -> float:\n ...", "def setAngle(self,a):\n self.angle = a\n if self.drawn == True:\n self.draw()", "def setAngle(self, value):\n n, a = Vector.polar(self.components)\n self.components = Vector.cartesian([n, value])", "def rotate_rad(self, angle):\n self.beam_angle += angle\n self.xy = rotate(self.xy, angle)\n self.angle += angle", "def adjAngle(self, amt):\n \n self.angle = self.angle+radians(amt)\n self.redraw()", "def change_angle(self, new_angle):\r\n self.angle = new_angle", "def angle(self, angle):\n self._angle = angle\n self.x_rate = self._rate * cos(self._angle)\n self.y_rate = self._rate * sin(self._angle)", "def set_angle(self, value):\n if not -90 <= value <= 90:\n raise ValueError('Servo angle must be between -90 and 90 degrees')\n self.duty_cycle = ...", "def adjustAngle(self, angle):\n\t\tif self.timeout <= 0:\n\t\t\tself.angle = (self.angle + angle) % 360", "def set_angle(self, angle_key: Union[EKT, str], v: float): # -> None:\n ...", "def set_angle(self, req_angle):\n self._current_angle = req_angle\n req_angle_pulse = (self._pulse_max - self._pulse_min) / (self._angle_max - self._angle_min) * (\n req_angle - self._angle_max) + self._pulse_max\n self.pwm.set_pwm(SERVO_CHANEL, 0, int(round(req_angle_pulse)))", "def change_angle(self, new_angle):\n if type(new_angle) not in [int, float]:\n raise ValueError('angle must be int or float.')\n self.__angle = new_angle", "def _rotate(self, angle):\n angle *= self._degreesPerAU\n self._orient = self._orient.rotate(angle)", "def set_rotation(self, angle):\n self._rotation = angle\n self._reset_slot_bounds()", "def setArticulateAngle(self, angle):\n self.articulatePID.setSetpoint(angle)" ]

[ "0.7401127", "0.72532266", "0.71483475", "0.7056934", "0.7036004", "0.69982886", "0.69501126", "0.6810016", "0.6792665", "0.6785843", "0.6776767", "0.6732968", "0.6699184", "0.6673731", "0.6673587", "0.66574335", "0.6656543", "0.6632068", "0.66133535", "0.655427", "0.65488106", "0.65379846", "0.64850366", "0.64673257", "0.64594615", "0.6452435", "0.6426754", "0.6404896", "0.6378977", "0.6313741" ]

[ "def move_turtle(self):\n self.forward(self.move_speed)", "def random_move(turtle, distance):\n angle = uniform(-90,90)\n d = uniform(0,distance)\n turtle.left(angle)\n turtle.forward(d)", "def move(self, direction, distance):\r\n distance = float(distance)\r\n distance = int(round(distance*100))\r\n return self.send_command('%s %s' % (direction, distance))", "def move_distance(self, distance, speed=1.0):\n distance = random.normalvariate(distance, self.standard_deviation)\n\n start_point = self.get_position()\n traveled_distance = 0\n while traveled_distance < distance:\n self.forward(speed)\n current_point = self.get_position()\n traveled_distance = math.sqrt(\n math.pow((start_point[0] - current_point[0]), 2) + math.pow((start_point[1] - current_point[1]), 2))\n self.stop()", "def _go(self, distance):\n ende = self._position + self._orient * distance\n self._goto(ende)", "async def move_to(self, distance: float, speed: float) -> None:\n time = self.time_for_distance(distance, speed)\n await self.rmotor.run(-speed, time)\n await self.lmotor.run(speed, time)", "def move(self, distance: int, direction: float, max_steering=np.pi / 2):\n if direction > max_steering:\n direction = max_steering\n if direction < -max_steering:\n direction = -max_steering\n\n if distance < 0.0:\n distance = 0.0\n\n self.total_distance_covered += distance\n\n self.theta = (self.theta + direction) % (2.0 * np.pi)\n self.x = self.x + (np.cos(self.theta) * distance)\n self.y = self.y + (np.sin(self.theta) * distance)", "def move_dolly(self, distance: int, direction: int, time: int = None):\n\n self.__do_action(self.motor.move(direction, distance, time))", "def forward(self,distance):\n assert (type(distance) in [int, float]), \"parameter distance:%s is not a valid number\" % `distance`\n self._turtle.forward(distance)", "def move_straight(robot, dist):\n journey = Journey(robot, distance=dist)\n journey.start()\n robot.position.move(dist)\n sleep(0.5)", "def move_distance(self, distance_x_m, distance_y_m, distance_z_m,\n velocity=VELOCITY):\n action = MoveDistance(distance_x_m, distance_y_m, distance_y_m, velocity=velocity)\n goal = PositionControlGoal(pickle.dumps(action))\n self._add_mc_goal(goal)", "def move(self, dx, dy):\n self.x += dx\n self.y += dy", "def move(self,dt):\n raise NotImplementedError(\"Robot.move\")", "def move(self):\r\n segments = len(self.all_turtles) - 1\r\n for i in range(len(self.all_turtles)):\r\n if segments == 0:\r\n self.all_turtles[segments].forward(MOVE_DISTANCE)\r\n else:\r\n new_x = self.all_turtles[segments - 1].xcor()\r\n new_y = self.all_turtles[segments - 1].ycor()\r\n self.all_turtles[segments].goto(new_x, new_y)\r\n segments -= 1", "def safe_goto(self, speed=1.0, distance=SAFETY_DISTANCE):\n\n moves = []\n point = copy.deepcopy(\n self.poses[self.selected_point].measured.position)\n orientation = self.poses[self.selected_point].measured.orientation\n point.z += distance\n move = Move()\n move.pose.position = point\n move.pose.orientation = orientation\n move.speed = speed\n moves.append(move)\n\n RobotControllerHandler().current_controller.set_speed(speed)\n RobotControllerHandler().current_controller.move_pose(moves)", "def move(self, direction):\n pass", "def jump(distance):\r\n t.penup()\r\n t.forward(200)\r\n t.pendown()\r\n return None", "def move(self, dt):\n dt = dt", "def move_forward(self, distance):\r\n return self.move('forward', distance)", "def move(self):\n self.position += self.speed", "def move(self) -> None:\n\n new_x = self.getX() + self.speed[0]\n new_y = self.getY() + self.speed[1]\n self.setX(new_x)\n self.setY(new_y)", "def move(self,amount):\n angle=self.dirction/180*math.pi\n self.postionx += amount*math.cos(angle)\n self.postiony += amount*math.sin(angle)", "def _move(self, direction, difference):\n future_tile_number = self.get_number() + difference\n if future_tile_number in range(1, Tile.total_tiles + 1):\n future_tile = Tile.get_tile(future_tile_number)\n if future_tile.walkable:\n self.set_target(future_tile)\n self.rotate(direction)", "def move_atom(self, atom1: CellAtom, atom2: CellAtom, new_distance: float):\n if atom2 == self.muon:\n raise NotImplementedError(\"Moving the muon is not supported\")\n\n vector_between = atom2.position - atom1.position\n distance = np.linalg.norm(vector_between)\n\n # old_pos + new_dist * direction\n new_pos = atom1.position + ((new_distance / distance) * vector_between)\n\n # Log what is happening so can keep track\n logging.info(\n \"Moving %s from %s to %s, changing the distance from %s to %s\",\n atom2.symbol,\n atom2.position,\n new_pos,\n distance,\n new_distance,\n )\n\n atom2.position = new_pos\n\n # Update the distance to the muon (calculate if haven't already)\n if atom1 == self.muon:\n atom2.distance_from_muon = new_distance\n else:\n atom2.distance_from_muon = np.linalg.norm(\n atom2.position - self.muon.position\n )", "def move(self, coordinates, direction):\n pass", "def move_right(self, distance):\r\n return self.move('right', distance)", "def move(self):\n\n # get the location we WOULD go to\n newX = self.xcor() + self.dx\n newY = self.ycor() + self.dy\n while (abs (newX) > self.BOX_RANGE) or (abs(newY) > self.BOX_RANGE):\n # print(\"choosing new direction... \",end=\"\")\n self.chooseNewDirection()\n # print(self.dx, self.dy)\n newX = self.xcor() + self.dx\n newY = self.ycor() + self.dy\n\n # now move our monster\n super().move()", "def move(self):\n \n # checks for bots nearby\n next_move = self.follow()\n \n # finds a random move if no bot\n if next_move is self.position:\n self.position = self.wander()\n else:\n self.position = next_move", "def move(self):\n pass", "def move_down(self, distance):\r\n return self.move('down', distance)" ]

[ "0.7544096", "0.7527483", "0.7361911", "0.7250653", "0.7237959", "0.7123979", "0.7103639", "0.7019398", "0.68791384", "0.6832654", "0.68047816", "0.68012816", "0.6792912", "0.6776059", "0.6766702", "0.676111", "0.66931254", "0.66137624", "0.6593665", "0.6574645", "0.65081805", "0.65021217", "0.6488986", "0.64841944", "0.64743286", "0.6468002", "0.6463589", "0.6434106", "0.6432469", "0.64294976" ]

[ "def up(self):\n self.move(0, 1)", "def move_up(self):\n\n if self.ycor() > 115:\n self.sety(130)\n else:\n new_y = self.ycor() + 40\n self.sety(new_y)", "def up():\n global y, canvas # y é modificado\n canvas.create_line(x, y, x, y - 10)\n y -= 10", "def draw_o(self):\r\n pen.down()\r\n pen.forward(40)\r\n pen.left(90)\r\n pen.forward(40)\r\n pen.left(90)\r\n pen.forward(40)\r\n pen.left(90)\r\n pen.forward(40)\r\n pen.left(90)\r\n pen.up()\r\n pen.forward(50)", "def up():\n turtleTmp.penup()", "def move_up(self):\n self.move_measurement(-1)", "def up(self):\r\n self.brush_on = False", "def draw_s(self):\r\n pen.down()\r\n pen.forward(40)\r\n pen.left(90)\r\n pen.forward(20)\r\n pen.left(90)\r\n pen.forward(40)\r\n pen.right(90)\r\n pen.forward(20)\r\n pen.right(90)\r\n pen.forward(40)\r\n pen.up()\r\n pen.back(40)\r\n pen.right(90)\r\n pen.forward(40)\r\n pen.left(90)\r\n pen.forward(50)", "def go_up(self):\n\t\tself.x,self.y = Mario._get_coordinates(Board.prev_i,Board.prev_j,Board.prev_k)\n\t\tMario._pass(self.x,self.y)\n\t\ttemp = self.x\n\t\tflag = 0\n\t\twhile(temp>=self.x-8):\n\t\t\tif(Board.board[temp][self.y] in obstacles):\n\t\t\t\tflag = 1\n\t\t\t\ttemp_x = temp+1\n\t\t\t\tbreak\n\t\t\ttemp = temp-1\n\n\t\tif(not flag):\n\t\t\ttemp_x = self.x-8\n\n\t\tif Board.board[temp_x-1][self.y]=='B':\n\t\t\tnew = self.y\n\t\t\tfor i in range(new-4,new+5):\n\t\t\t\tif Board.board[temp_x-1][i]=='B':\n\t\t\t\t\tBoard.board[temp_x-1][i]='T'\n\t\t\tMario.bonus+=50\n\t\t\tif self.y==229 or self.y ==230 or self.y==231:\n\t\t\t\tBoard.board[23][230]='P'\n\n\n\t\tBoard.board[temp_x][self.y] = 'M'\t\t\n\t\tos.system('clear')\n\t\tinit_board(Board.prev_i,Board.prev_j,Board.prev_k)", "def move_up(self):\r\n if self.rect.top > 0:\r\n self.rect.top -= self.speed", "def move_up(self):\n self.move_step(-1)", "def move_up(self):\n if self.pointer != 0:\n logging.debug(\"moved up\")\n self.pointer -= 1\n self.refresh()\n self.reset_scrolling()\n return True\n else:\n return False", "def update(self):\n pygame.event.pump()\n self.pos_x -= 1.5", "def move_down(self):\n self.y -= 1", "def down():\n global y, canvas # y é modificado\n canvas.create_line(x, y, x, y + 10)\n y += 10", "def pendown(self):\n if self._drawing:\n return\n self.pen(pendown=True)", "def move_down(self):\n self.move_measurement(1)", "def up(self):\n if self.head.heading() != DOWN and self.last_direction != DOWN:\n self.head.setheading(UP)", "def draw_t(self):\r\n pen.forward(20)\r\n pen.left(90)\r\n pen.down()\r\n pen.forward(40)\r\n pen.right(90)\r\n pen.up()\r\n pen.forward(20)\r\n pen.down()\r\n pen.back(40)\r\n pen.up()\r\n pen.right(90)\r\n pen.forward(40)\r\n pen.left(90)\r\n pen.forward(50)", "def down(self):\r\n self.brush_on = True", "def move_up(self):\n self.pitch_motor.step_backward()", "def move_up(self, step: int = 1) -> None:\n if self.cursor_pos.x == 0:\n self.cursor_pos = Point(self.height - step, self.cursor_pos.y)\n else:\n self.cursor_pos = Point(self.cursor_pos.x-step, self.cursor_pos.y)", "def move_up(self):\n if self.pointer != 0:\n logging.debug(\"moved up\")\n self.pointer -= 1\n self.refresh()\n return True\n else: \n return False", "def up(self):\n if self.selected_offset > 0:\n self.selected_offset -= 1\n if self.selected_offset < self.top_offset:\n self.top_offset -= 1\n self.__update_display()\n self.__update_selection()", "def move_up(self):\n #if user moves paddle right on top of screen, they won't be able to move it more upwards by using this if statement\n #SCREEN_HEIGHT - 20 = Exact number of pixels where paddle can stop exactly on top edge but still has its body fully shown\n if self.center.y < SCREEN_HEIGHT - 20:\n self.center.y += MOVE_AMOUNT", "def move_down(self):\n\n if self.ycor() < -280:\n self.sety(-300)\n else:\n new_y = self.ycor() - 40\n self.sety(new_y)", "def move_down(self):\r\n if self.rect.bottom < BG_HEIGHT - 60:\r\n self.rect.top += self.speed", "def move_up(self):\n if self.center.y < (self.screen_height - (self.height / 2)):\n self.center.y += 5", "def update(self):\n self.rect.y -= self.y_speed # Pawns move up the screen at the speed specified", "def draw_n(self):\r\n pen.down()\r\n pen.left(90)\r\n pen.forward(40)\r\n pen.right(135)\r\n pen.forward(1.414*40)\r\n pen.left(135)\r\n pen.forward(40)\r\n pen.up()\r\n pen.back(40)\r\n pen.right(90)\r\n pen.back(40)\r\n pen.forward(50)" ]

[ "0.7055451", "0.6950502", "0.6936961", "0.6897536", "0.68377566", "0.6774552", "0.6772057", "0.6721872", "0.6721722", "0.6694255", "0.6583421", "0.6510559", "0.65014124", "0.6495371", "0.6493058", "0.6481815", "0.64671576", "0.6464092", "0.6451035", "0.643395", "0.6425636", "0.6422976", "0.6403221", "0.63854265", "0.6353945", "0.6312791", "0.63115305", "0.62994707", "0.6297343", "0.62893784" ]

[ "def penColor( self ):\n return self._penColor", "def GetClassDefaultAttributes(self):\r\n\r\n attr = wx.VisualAttributes()\r\n attr.colFg = wx.SystemSettings_GetColour(wx.SYS_COLOUR_WINDOWTEXT)\r\n attr.colBg = wx.SystemSettings_GetColour(wx.SYS_COLOUR_LISTBOX)\r\n attr.font = wx.SystemSettings_GetFont(wx.SYS_DEFAULT_GUI_FONT)\r\n return attr", "def GetClassDefaultAttributes(self):\r\n\r\n attr = wx.VisualAttributes()\r\n attr.colFg = wx.SystemSettings_GetColour(wx.SYS_COLOUR_WINDOWTEXT)\r\n attr.colBg = wx.SystemSettings_GetColour(wx.SYS_COLOUR_LISTBOX)\r\n attr.font = wx.SystemSettings_GetFont(wx.SYS_DEFAULT_GUI_FONT)\r\n return attr", "def pencolor(self):\n return self._pencolor", "def GetDefaultAttributes(self):\n\n return wx.Button.GetClassDefaultAttributes()", "def get_text_attr():\n csbi = CONSOLE_SCREEN_BUFFER_INFO()\n GetConsoleScreenBufferInfo(stdout_handle, byref(csbi))\n return csbi.wAttributes", "def StockGDI_GetPen(*args, **kwargs):\n return _gdi_.StockGDI_GetPen(*args, **kwargs)", "def get_state(canvas):\n return {\n 'stroke.color': canvas.stroke.color,\n 'stroke.alpha': canvas.stroke.alpha,\n 'stroke.line_width': canvas.stroke.line_width,\n 'stroke.line_cap': canvas.stroke.line_cap,\n 'stroke.line_join': canvas.stroke.line_join,\n 'stroke.miter_limit': canvas.stroke.miter_limit,\n 'stroke.line_dash': canvas.stroke.line_dash,\n 'fill.color': canvas.fill.color,\n 'fill.alpha': canvas.fill.alpha,\n 'font.family': canvas.font.family,\n 'font.weight': canvas.font.weight,\n 'font.style': canvas.font.style,\n 'font.render_mode': canvas.font.render_mode,\n 'font.size_pts': canvas.font.size_pts,\n 'font.rise_pts': canvas.font.rise_pts,\n 'font.char_space_pts': canvas.font.char_space_pts,\n 'font.word_space_pts': canvas.font.word_space_pts,\n 'font.leading': canvas.font.leading\n }", "def attrs(self):\n return self.size, self.propSuffix, self.specified", "def get_attrs(foreground, background, style):\n return foreground + (background << 4) + style", "def artAttrSkinPaintCtx(*args, accopacity: bool=False, activeListChangedProc: Union[AnyStr,\n bool]=\"\", afterStrokeCmd: Union[AnyStr, bool]=\"\", alphaclamp:\n Union[AnyStr, bool]=\"none\", alphaclamplower: Union[float, bool]=0.0,\n alphaclampupper: Union[float, bool]=1.0, attrSelected: Union[AnyStr,\n bool]=\"\", beforeStrokeCmd: Union[AnyStr, bool]=\"\", brushalignment:\n bool=True, brushfeedback: bool=True, clamp: Union[AnyStr, bool]=\"none\",\n clamplower: Union[float, bool]=0.0, clampupper: Union[float, bool]=1.0,\n clear: bool=True, colorAlphaValue: Union[float, bool]=0.0,\n colorRGBAValue: Union[List[float, float, float, float], bool]=None,\n colorRGBValue: Union[List[float, float, float], bool]=None, colorRamp:\n Union[AnyStr, bool]=\"\", colorfeedback: bool=False,\n colorfeedbackOverride: bool=False, colorrangelower: Union[float,\n bool]=0.0, colorrangeupper: Union[float, bool]=1.0, dataTypeIndex:\n Union[int, bool]=0, disablelighting: bool=False, dragSlider: AnyStr=\"\",\n duringStrokeCmd: Union[AnyStr, bool]=\"\", dynclonemode: bool=True,\n exists: bool=True, expandfilename: bool=True, exportaspectratio:\n Union[float, bool]=0.0, exportfilemode: Union[AnyStr,\n bool]=\"luminance/rgb\", exportfilesave: AnyStr=\"\", exportfilesizex:\n Union[int, bool]=0, exportfilesizey: Union[int, bool]=0,\n exportfiletype: Union[AnyStr, bool]=\"\", filterNodes: bool=True,\n history: bool=True, image1: Union[AnyStr, bool]=\"\", image2:\n Union[AnyStr, bool]=\"\", image3: Union[AnyStr, bool]=\"\", importfileload:\n AnyStr=\"\", importfilemode: Union[AnyStr, bool]=\"alpha\", importreassign:\n bool=False, influence: Union[AnyStr, bool]=\"\", interactiveUpdate:\n bool=True, lastRecorderCmd: Union[AnyStr, bool]=\"\", lastStampName:\n Union[AnyStr, bool]=\"\", lowerradius: Union[float, bool]=0.0,\n makeStroke: Union[int, List[int], bool]=0, mappressure: Union[AnyStr,\n bool]=\"none\", maxvalue: Union[float, bool]=1.0, minvalue: Union[float,\n bool]=0.0, name: AnyStr=\"\", objattrArray: Union[AnyStr, bool]=\"\",\n opacity: Union[float, bool]=1.0, outline: bool=True, outwhilepaint:\n bool=False, paintNodeArray: Union[AnyStr, bool]=\"\", paintSelectMode:\n Union[int, bool]=0, paintattrselected: AnyStr=\"\", paintmode:\n Union[AnyStr, bool]=\"screen\", paintoperationtype: Union[AnyStr,\n bool]=\"Paint\", pickColor: bool=True, pickValue: bool=True,\n playbackCursor: Union[List[float, float], List[List[float, float]],\n bool]=None, playbackPressure: Union[float, List[float], bool]=0.0,\n preserveclonesource: bool=True, profileShapeFile: Union[AnyStr,\n bool]=\"\", projective: bool=False, radius: Union[float, bool]=1.0,\n rampMaxColor: Union[List[float, float, float], bool]=None,\n rampMinColor: Union[List[float, float, float], bool]=None, record:\n bool=True, reflection: bool=False, reflectionaboutorigin: bool=True,\n reflectionaxis: Union[AnyStr, bool]=\"x\", screenRadius: Union[float,\n bool]=0.0, selectclonesource: bool=True, selectedattroper: Union[AnyStr,\n bool]=\"absolute\", showactive: bool=True, skinPaintMode: Union[int,\n bool]=0, stampDepth: Union[float, bool]=0.0, stampProfile: Union[AnyStr,\n bool]=\"\", stampSpacing: Union[float, bool]=1.0, strokesmooth:\n Union[AnyStr, bool]=\"\", surfaceConformedBrushVertices: bool=True,\n tablet: bool=True, tangentOutline: bool=True, toolOffProc: Union[AnyStr,\n bool]=\"\", toolOnProc: Union[AnyStr, bool]=\"\", useColorRamp: bool=True,\n useMaxMinColor: bool=True, usepressure: bool=False, value: Union[float,\n bool]=0.0, whichTool: Union[AnyStr, bool]=\"\", worldRadius: Union[float,\n bool]=0.0, xrayJoints: bool=True, q=True, query=True, e=True, edit=True,\n **kwargs)->Union[None, Any]:\n pass", "def SetPen(*args, **kwargs):\n return _gdi_.DC_SetPen(*args, **kwargs)", "def setPen(self, *args, **kwargs):\n if kwargs == {} and (args == () or args == ('default',)):\n self.opts['pen'] = fn.mkPen(getConfigOption('foreground'))\n else:\n self.opts['pen'] = fn.mkPen(*args, **kwargs)\n\n self.picture = None\n self.update()", "def GetPen(*args, **kwargs):\n return _gdi_.StockGDI_GetPen(*args, **kwargs)", "def GetPen(*args, **kwargs):\n return _gdi_.DC_GetPen(*args, **kwargs)", "def color(self):\n assert False, 'Pen does not have a color; use pencolor or fillcolor'", "def GetAttrib( self ):\n attrib = GameNodePath.GetAttrib( self )\n \n if self.GetModified():\n attrib['path'] = self.GetPath()\n \n return attrib", "def SetPen(*args):\n return _gdi_.GraphicsContext_SetPen(*args)", "def artAttrCtx(*args, accopacity: bool=False, activeListChangedProc: Union[AnyStr, bool]=\"\",\n afterStrokeCmd: Union[AnyStr, bool]=\"\", alphaclamp: Union[AnyStr, bool]=\"none\",\n alphaclamplower: Union[float, bool]=0.0, alphaclampupper: Union[float, bool]=1.0,\n attrSelected: Union[AnyStr, bool]=\"\", beforeStrokeCmd: Union[AnyStr, bool]=\"\",\n brushalignment: bool=True, brushfeedback: bool=True, clamp: Union[AnyStr,\n bool]=\"none\", clamplower: Union[float, bool]=0.0, clampupper: Union[float,\n bool]=1.0, clear: bool=True, colorAlphaValue: Union[float, bool]=0.0,\n colorRGBAValue: Union[List[float, float, float, float], bool]=None,\n colorRGBValue: Union[List[float, float, float], bool]=None, colorRamp:\n Union[AnyStr, bool]=\"\", colorfeedback: bool=False, colorfeedbackOverride:\n bool=False, colorrangelower: Union[float, bool]=0.0, colorrangeupper:\n Union[float, bool]=1.0, dataTypeIndex: Union[int, bool]=0, disablelighting:\n bool=False, dragSlider: AnyStr=\"\", duringStrokeCmd: Union[AnyStr, bool]=\"\",\n dynclonemode: bool=True, exists: bool=True, expandfilename: bool=True,\n exportaspectratio: Union[float, bool]=0.0, exportfilemode: Union[AnyStr,\n bool]=\"luminance/rgb\", exportfilesave: AnyStr=\"\", exportfilesizex: Union[int,\n bool]=0, exportfilesizey: Union[int, bool]=0, exportfiletype: Union[AnyStr,\n bool]=\"\", filterNodes: bool=True, history: bool=True, image1: Union[AnyStr,\n bool]=\"\", image2: Union[AnyStr, bool]=\"\", image3: Union[AnyStr, bool]=\"\",\n importfileload: AnyStr=\"\", importfilemode: Union[AnyStr, bool]=\"alpha\",\n importreassign: bool=False, interactiveUpdate: bool=True, lastRecorderCmd:\n Union[AnyStr, bool]=\"\", lastStampName: Union[AnyStr, bool]=\"\", lowerradius:\n Union[float, bool]=0.0, makeStroke: Union[int, List[int], bool]=0, mappressure:\n Union[AnyStr, bool]=\"none\", maxvalue: Union[float, bool]=1.0, minvalue:\n Union[float, bool]=0.0, name: AnyStr=\"\", objattrArray: Union[AnyStr, bool]=\"\",\n opacity: Union[float, bool]=1.0, outline: bool=True, outwhilepaint: bool=False,\n paintNodeArray: Union[AnyStr, bool]=\"\", paintattrselected: AnyStr=\"\", paintmode:\n Union[AnyStr, bool]=\"screen\", paintoperationtype: Union[AnyStr, bool]=\"Paint\",\n pickColor: bool=True, pickValue: bool=True, playbackCursor: Union[List[float,\n float], List[List[float, float]], bool]=None, playbackPressure: Union[float,\n List[float], bool]=0.0, preserveclonesource: bool=True, profileShapeFile:\n Union[AnyStr, bool]=\"\", projective: bool=False, radius: Union[float, bool]=1.0,\n rampMaxColor: Union[List[float, float, float], bool]=None, rampMinColor:\n Union[List[float, float, float], bool]=None, record: bool=True, reflection:\n bool=False, reflectionaboutorigin: bool=True, reflectionaxis: Union[AnyStr,\n bool]=\"x\", screenRadius: Union[float, bool]=0.0, selectclonesource: bool=True,\n selectedattroper: Union[AnyStr, bool]=\"absolute\", showactive: bool=True,\n stampDepth: Union[float, bool]=0.0, stampProfile: Union[AnyStr, bool]=\"\",\n stampSpacing: Union[float, bool]=1.0, strokesmooth: Union[AnyStr, bool]=\"\",\n surfaceConformedBrushVertices: bool=True, tablet: bool=True, tangentOutline:\n bool=True, toolOffProc: Union[AnyStr, bool]=\"\", toolOnProc: Union[AnyStr,\n bool]=\"\", useColorRamp: bool=True, useMaxMinColor: bool=True, usepressure:\n bool=False, value: Union[float, bool]=0.0, whichTool: Union[AnyStr, bool]=\"\",\n worldRadius: Union[float, bool]=0.0, q=True, query=True, e=True, edit=True,\n **kwargs)->Union[AnyStr, Any]:\n pass", "def printer_attributes_tag(self) :\n self._curattributes = self._printer_attributes\n return self.parseTag()", "def attrib(self) -> Any:\n return self.attributes", "def artAttrPaintVertexCtx(*args, accopacity: bool=False, activeListChangedProc: Union[AnyStr,\n bool]=\"\", afterStrokeCmd: Union[AnyStr, bool]=\"\", alphaclamp:\n Union[AnyStr, bool]=\"none\", alphaclamplower: Union[float, bool]=0.0,\n alphaclampupper: Union[float, bool]=1.0, attrSelected: Union[AnyStr,\n bool]=\"\", beforeStrokeCmd: Union[AnyStr, bool]=\"\", brushalignment:\n bool=True, brushfeedback: bool=True, clamp: Union[AnyStr,\n bool]=\"none\", clamplower: Union[float, bool]=0.0, clampupper:\n Union[float, bool]=1.0, clear: bool=True, colorAlphaValue:\n Union[float, bool]=0.0, colorRGBAValue: Union[List[float, float,\n float, float], bool]=None, colorRGBValue: Union[List[float, float,\n float], bool]=None, colorRamp: Union[AnyStr, bool]=\"\", colorfeedback:\n bool=False, colorfeedbackOverride: bool=False, colorrangelower:\n Union[float, bool]=0.0, colorrangeupper: Union[float, bool]=1.0,\n dataTypeIndex: Union[int, bool]=0, disablelighting: bool=False,\n dragSlider: AnyStr=\"\", duringStrokeCmd: Union[AnyStr, bool]=\"\",\n dynclonemode: bool=True, exists: bool=True, expandfilename: bool=True,\n exportaspectratio: Union[float, bool]=0.0, exportfilemode:\n Union[AnyStr, bool]=\"luminance/rgb\", exportfilesave: AnyStr=\"\",\n exportfilesizex: Union[int, bool]=0, exportfilesizey: Union[int,\n bool]=0, exportfiletype: Union[AnyStr, bool]=\"\", filterNodes:\n bool=True, history: bool=True, image1: Union[AnyStr, bool]=\"\",\n image2: Union[AnyStr, bool]=\"\", image3: Union[AnyStr, bool]=\"\",\n importfileload: AnyStr=\"\", importfilemode: Union[AnyStr,\n bool]=\"alpha\", importreassign: bool=False, interactiveUpdate:\n bool=True, lastRecorderCmd: Union[AnyStr, bool]=\"\", lastStampName:\n Union[AnyStr, bool]=\"\", lowerradius: Union[float, bool]=0.0,\n makeStroke: Union[int, List[int], bool]=0, mappressure: Union[AnyStr,\n bool]=\"none\", maxvalue: Union[float, bool]=1.0, minvalue: Union[float,\n bool]=0.0, name: AnyStr=\"\", objattrArray: Union[AnyStr, bool]=\"\",\n opacity: Union[float, bool]=1.0, outline: bool=True, outwhilepaint:\n bool=False, paintComponent: Union[int, bool]=0, paintNodeArray:\n Union[AnyStr, bool]=\"\", paintNumChannels: Union[int, bool]=0,\n paintRGBA: bool=False, paintVertexFace: bool=False,\n paintattrselected: AnyStr=\"\", paintmode: Union[AnyStr, bool]=\"screen\",\n paintoperationtype: Union[AnyStr, bool]=\"Paint\", pickColor: bool=True,\n pickValue: bool=True, playbackCursor: Union[List[float, float],\n List[List[float, float]], bool]=None, playbackPressure: Union[float,\n List[float], bool]=0.0, preserveclonesource: bool=True,\n profileShapeFile: Union[AnyStr, bool]=\"\", projective: bool=False,\n radius: Union[float, bool]=1.0, rampMaxColor: Union[List[float, float,\n float], bool]=None, rampMinColor: Union[List[float, float, float],\n bool]=None, record: bool=True, reflection: bool=False,\n reflectionaboutorigin: bool=True, reflectionaxis: Union[AnyStr,\n bool]=\"x\", screenRadius: Union[float, bool]=0.0, selectclonesource:\n bool=True, selectedattroper: Union[AnyStr, bool]=\"absolute\",\n showactive: bool=True, stampDepth: Union[float, bool]=0.0,\n stampProfile: Union[AnyStr, bool]=\"\", stampSpacing: Union[float,\n bool]=1.0, strokesmooth: Union[AnyStr, bool]=\"\",\n surfaceConformedBrushVertices: bool=True, tablet: bool=True,\n tangentOutline: bool=True, toolOffProc: Union[AnyStr, bool]=\"\",\n toolOnProc: Union[AnyStr, bool]=\"\", useColorRamp: bool=True,\n useMaxMinColor: bool=True, usepressure: bool=False, value:\n Union[float, bool]=0.0, vertexColorRange: bool=False,\n vertexColorRangeLower: Union[float, bool]=0.0, vertexColorRangeUpper:\n Union[float, bool]=1.0, whichTool: Union[AnyStr, bool]=\"\",\n worldRadius: Union[float, bool]=0.0, q=True, query=True, e=True,\n edit=True, **kwargs)->Union[None, Any]:\n pass", "def device_state_attributes(self):\n if self.ticker is not None:\n return {\n ATTR_VOLUME_24H: self.ticker.values.get(\"volume\"),\n ATTR_ATTRIBUTION: ATTRIBUTION,\n ATTR_HIGH: self.ticker.values.get(\"high\"),\n ATTR_LOW: self.ticker.values.get(\"low\"),\n ATTR_VWAP: self.ticker.values.get(\"vwap\")\n }", "def device_state_attributes(self):\n if self._type == ATTR_CAQI:\n self._attrs[ATTR_CAQI_LEVEL] = self.data[ATTR_CAQI_LEVEL]\n if self._type == ATTR_PM25:\n self._attrs[ATTR_LIMIT] = self.data[ATTR_PM25_LIMIT]\n self._attrs[ATTR_PERCENT] = round(self.data[ATTR_PM25_PERCENT])\n if self._type == ATTR_PM10:\n self._attrs[ATTR_LIMIT] = self.data[ATTR_PM10_LIMIT]\n self._attrs[ATTR_PERCENT] = round(self.data[ATTR_PM10_PERCENT])\n return self._attrs", "def GetConnectionPen(self):\r\n\r\n return self._dottedPen", "def pensize(self, width=None):\n if width is None:\n return self._pensize\n self.pen(pensize=width)", "def attributes(self):\n _attrs = []\n if self.name:\n _attrs.append(\"name\")\n if self.label:\n _attrs.append(\"label\")\n if self.confidence:\n _attrs.append(\"confidence\")\n if self.index:\n _attrs.append(\"index\")\n if self.attrs:\n _attrs.append(\"attrs\")\n return _attrs + [\"points\"]", "def SetPen(*args, **kwargs):\n return _gdi_.PseudoDC_SetPen(*args, **kwargs)", "def getAttributes(self):\n pass", "def GetAttributes(self):\r\n\r\n return self._attr" ]

[ "0.60591114", "0.59521186", "0.59521186", "0.58202076", "0.57496095", "0.5679918", "0.5650609", "0.5590791", "0.5566379", "0.55577755", "0.55260926", "0.548827", "0.54644173", "0.5462271", "0.5438474", "0.54303217", "0.54254085", "0.53719974", "0.5362841", "0.5352906", "0.53107166", "0.53099114", "0.53030133", "0.52943504", "0.529317", "0.5288568", "0.5275731", "0.5261235", "0.52417666", "0.5220897" ]

[ "def __del__(self):\n self._screen._removePen(self)\n del self._turtle", "def clear(self):\n self._turtle.clear()", "def clear(self):\n self._turtle.clear()", "def _clear_drawing(self) -> None:\n self.vertices.clear()\n self.edges.clear()\n self.subplot.clear()\n self.selected_element = None\n self.pressed_elements.clear()", "def __del__(self):\n self.clear()\n self._screen._removeTurtle(self)\n del self._turtle", "def _clear_drawing(self) -> None:\n self.vertices.clear()\n self.edges.clear()\n self.subplot.clear()\n self.subplot2.clear()", "def clear(self):\n self._frame.clear()\n self._turtles = []\n self._gpens = []", "def clear_selected_shapes(self):\n self.shapes_to_draw = []", "def _clear(self):\n self._fillitem = self._fillpath = None\n for item in self.items:\n self.screen._delete(item)\n self.currentLineItem = self.screen._createline()\n self.currentLine = []\n if self._drawing:\n self.currentLine.append(self._position)\n self.items = [self.currentLineItem]\n self.clearstamps()", "def reset(self):\n self._turtle.clear()\n self._turtle.setposition((0,0)) \n self._turtle.shape('turtle')\n self.color = 'red'\n self.heading = 180\n self.speed = 0", "def clear(self):\n self._delayvalue = _CFG[\"delay\"]\n self._colormode = _CFG[\"colormode\"]\n self._delete(\"all\")\n self._bgpic = self._createimage(\"\")\n self._bgpicname = \"nopic\"\n self._tracing = 1\n self._updatecounter = 0\n self._turtles = []\n self.bgcolor(\"white\")\n for btn in 1, 2, 3:\n self.onclick(None, btn)\n self.onkeypress(None)\n for key in self._keys[:]:\n self.onkey(None, key)\n self.onkeypress(None, key)\n Myturtle._pen = None", "def reset(self):\n self._turtle.clear()\n self._turtle.setposition((0,0)) \n try:\n self._turtle.shape('pen.gif')\n except:\n self._turtle.shape('classic')\n self._turtle.color('red')\n self.speed = 0\n \n #pair = self._turtle.color()\n self._pencolor = self._turtle.color()[0]\n self._fillcolor = self._turtle.color()[0]", "def reset(self):\n for Myturtle in self._turtles:\n Myturtle._setmode(self._mode)\n Myturtle.reset()", "def _destroy(self):\n root = self._root\n turtle.Turtle._pen = None\n turtle.Turtle._screen = None\n self._root = None\n self._canvas = None\n turtle.TurtleScreen._RUNNING = True\n root.destroy()", "def clear(self):\n black = neo.Color(0,0,0)\n self.set_all(black)\n self.draw()", "def clearCanvas():\n global c, coordinates\n c.delete(\"all\")\n drawMusicLines()\n coordinates.clear()", "def bye(self):\n self._frame._destroy()\n self._turtles = []\n self._gpens = []\n del self._frame", "def __del__(self):\n try:\n self._frame._destroy()\n except:\n pass\n self._turtles = []\n self._pencils = []\n del self._frame", "def remove_drawing_rect(self):\n self.drawing_rect = QPolygonF()\n if self.connecting_rect:\n self.connecting_rect.setVisible(False)\n self.connecting_rect = None\n self.first_draw = True", "def reset(self):\n self.x_pos = 10\n self.y_pos = 10\n self.line_height = 15", "def clear_scene(self, event):\n self.shapes = []\n self.redraw()", "def clear(self):\n self.clear_markers()\n self.l_marker.remove()\n self.l_line.remove()\n self.r_marker.remove()\n self.r_line.remove()", "def clear(self):\n self.raster_path_line.clear()\n self.labels_path.clear()\n self.shapefile_path.clear()\n self.costumelabels.clear()\n self.layer_name.clear()\n self.class_name.clear()\n self.idfield.clear()", "def clear_visualization(self) -> None:\n if self._drawing_handle is not None:\n sim.simAddDrawingObjectItem(self._drawing_handle, None)", "def clear_drawn_objects(self, view_manager):\n view = view_manager.get_view()\n for item in self._drawnObjects:\n view.removeItem(item)\n # clear the list:\n self._drawnObjects = []", "def erase(self):\r\n self.in_arrow = None\r\n self.out_arrow = None", "def clear(self):\n self._x_prev = None\n self._y_prev = None", "def reset(self):\n if hasattr(self, \"W\"):\n del self.W\n if hasattr(self, \"T\"):\n del self.T\n if hasattr(self, \"P\"):\n del self.P", "def clear(self):\n self._fig = go.Figure()", "def clear(self):\n self._plt.clear()\n self._layer_items = {}" ]

[ "0.73617107", "0.72710234", "0.72710234", "0.7256286", "0.7098996", "0.7083982", "0.69770163", "0.69302595", "0.6780149", "0.6776574", "0.6736947", "0.6652254", "0.66375005", "0.6420664", "0.6326357", "0.62954605", "0.6271878", "0.6266315", "0.62353224", "0.6225887", "0.61865836", "0.6168218", "0.61610985", "0.6154304", "0.6122401", "0.6118188", "0.6105727", "0.61016005", "0.60787404", "0.60746825" ]

[ "def clone(self):\n return self.__class__(self, self.spectrum, wallet=self.wallet)", "def clone(self):", "def clone(self):\n return self", "def getturtle(self):\n return self", "def clone(self):\n return self.__class__(self.name, *self)", "def clone(self):\n return _libsbml.XMLTriple_clone(self)", "def clone(self, theta = None):\n cloned = eval(repr(self))\n if(theta is not None):\n cloned.theta = theta\n return cloned", "def clone(self):\n raise NotImplementedError", "def clone(self) -> 'State':\n return State(self.sim, state=self.get_state().copy())", "def clone(self):\n return _libsbml.Unit_clone(self)", "def clone(self):\n # make copies of my state\n beta = self.beta\n theta = self.theta.clone()\n sigma = self.sigma.clone()\n likelihoods = self.prior.clone(), self.data.clone(), self.posterior.clone()\n\n # make one and return it\n return type(self)(beta=beta, theta=theta, likelihoods=likelihoods, sigma=sigma)", "def clone(self):\n return self.copy()", "def clone(self):\n # Run the constructor.\n other = BoardPath()\n # Copy the object variables\n other._current_cost = self._current_cost\n other._path = self._path[:]\n other._current_loc = self._current_loc\n return other", "def copy(self):\n node_new = Node(self.state.copy(), self.parent, self.children.copy(), self.RRT, self.path_length)\n node_new.vs = self.vs.copy()\n node_new.RRT = self.RRT\n node_new.observed = self.observed\n node_new.observation_node = self.observation_node\n node_new.observation_area = self.observation_area\n\n return node_new", "def clone(self, empty=False):\n new = Robot()\n new.team = self.team\n new.position = self.position # Tuples are immutable\n if not empty:\n new.program = list(self.program) # Programs can be modified independently (but instructions are immutable)\n new.threads = [x.clone() for x in self.threads] # Threads can be modified\n new.thread_id = self.thread_id # Integer\n new.registers = list(self.registers)\n new.memory = self.memory.copy()\n self.world.add_robot(new)\n return new", "def clone(self):\n return _libsbml.SBase_clone(self)", "def clone(self):\n\n clone = self.__class__.__new__(self.__class__)\n clone._graph_state = self._graph_state\n clone._molecule_state = self._molecule_state\n return clone", "def clone(self) -> Mutator:\n raise NotImplementedError", "def clone(self):\n \n return TTTBoard(self.dim, self.reverse, self.board)", "def clone(self) -> Self:\n return clone(self, safe=True)", "def clone(self):\n return _libsbml.ReplacedBy_clone(self)", "def clone(self):\n return type(self)(iterator=self)", "def clone(self):\n return _libsbml.XMLNode_clone(self)", "def clone(self):\n return TTTBoard(self._dim, self._reverse, self._board)", "def clone_rand(self):", "def initialize(turtle_shape, bg_color, turtle_color, turtle_speed):\n turtle_instance = turtle.Turtle()\n turtle_instance.shape(turtle_shape)\n turtle.bgcolor(bg_color)\n turtle_instance.color(turtle_color)\n turtle_instance.speed(turtle_speed)\n return turtle_instance", "def clone(self):\n return _libsbml.Point_clone(self)", "def Clone(self):\n st = PunterGameState()\n st.fullGraph = self.fullGraph\n st.score = self.score\n st.playerJustMoved = self.playerJustMoved\n st.pathes = copy.deepcopy(self.pathes)\n st.scores = copy.deepcopy(self.scores)\n st.endpoints = self.endpoints[:]\n return st", "def clone(self):\n from copy import deepcopy\n return deepcopy(self)", "def clone(self):\n return shallow_clone(self)" ]

[ "0.7177898", "0.693291", "0.67999446", "0.67262167", "0.6714216", "0.6671243", "0.6549572", "0.65426743", "0.6524553", "0.6518727", "0.65127915", "0.6445799", "0.644339", "0.6410385", "0.63900346", "0.6379961", "0.6378835", "0.63401765", "0.6336102", "0.633265", "0.63267416", "0.6304902", "0.6303407", "0.6301432", "0.6300135", "0.62971187", "0.6273288", "0.6267379", "0.62520605", "0.62518936" ]

[ "def SetShape(self, *args):\n return _XCAFDoc.XCAFDoc_ShapeTool_SetShape(self, *args)", "def _spawn_turtle(self, trt_x, trt_y, name=None):\n\n\t\tif name is None or name == \"\":\n\t\t\tname = self._create_unique_turtle_name()\n\t\telif self._has_turtle(name):\n\t\t\treturn \"\"\n\n\t\tturtle = Turtle(name, Point(trt_x, trt_y))\n\t\tself._turtles[name] = turtle\n\n\t\trospy.loginfo(\"New turtle [%s] at x=[%d], y=[%d]\", name, trt_x, trt_y)\n\n\t\treturn name", "def get_shape(self, name):\n\n if name == \"circle\":\n return Circle(random.randint(1, 10))\n\n elif name == \"square\":\n return Square(random.randint(1, 10))\n\n elif name == \"rectangle\":\n return Rectangle(random.randint(1, 10), random.randint(1, 10))", "def add_shape_shing(shing_set: set, args: argparse.Namespace):\n shing_set.add(TrackShape.LOOP.value) if args.shape == 1 else shing_set.add(TrackShape.CURVE.value)", "def set_shape(self, shape):\n self._shape = self._shape.merge_with(shape)", "def SetShape(self, *args):\n return _XCAFDoc.XCAFDoc_ShapeMapTool_SetShape(self, *args)", "def add_shape(self, input_name, name=None):\n return self._build_op('Shape', [input_name], name=name)", "def get_random_shape(self):\n\n shape_name = random.choice([\"circle\", \"square\", \"rectangle\"])\n return self.get_shape(shape_name)", "def create_duplicate(shape, duplicate_name):\n\n logger.debug(\"Creating shape duplicate for {}\".format(shape))\n shape_holder = cmds.createNode(cmds.objectType(shape),\n name=\"{}Shape\".format(duplicate_name))\n cmds.rename(shape_holder, \"{}\".format(shape_holder))\n update_shape(shape, shape_holder)\n\n return shape_holder", "def __init__(self, shape, name=None):\n super().__init__(shape, is_independent=True)\n self.user_provided_name = name", "def __init__(self):\r\n pen.up()\r\n pen.setheading(0)\r\n pen.hideturtle()\r\n turtle.title(\"My name\")\r\n pen.speed(0)\r\n pen.right(90)\r\n pen.forward(40)\r\n pen.left(90)", "def setTurtle(t):\r\n t.pu()\r\n t.goto(initialCoordinates())", "def register_shapes():\n turtle.Screen().register_shape(\"saphire.gif\")\n turtle.Screen().register_shape(\"player_right.gif\")\n turtle.Screen().register_shape(\"player_left.gif\")\n turtle.Screen().register_shape(\"walls.gif\")", "def add_shape(self, input_name, attr=None, name=None):\n if attr is None:\n attr = {}\n return self._build_op('Shape', [input_name], attr=attr, name=name)", "def get_shapefile(self, shpname: str):\r\n self.get_geojson()\r\n self.geojson.to_shp(shpname)", "def Set(*args):\n return _XCAFDoc.XCAFDoc_ShapeTool_Set(*args)", "def select_shape(self, feature, value, **kwargs):\n self.shapes_to_draw.append(\n {'shapes': self.shapes[(self.shapes[feature] == value)]['path'].values,\n 'args': kwargs})", "def nameShip(self,newName,colour = None):\n self.setName(newName)\n if colour is not None:\n self.colour = colour", "def add_shape(self, spec):\n color_, shape_ = spec\n if shape_ is None:\n shape_ = self.random_shape()\n if color_ is None:\n color_ = self.random_color()\n x = shape.rand_pos()\n y = shape.rand_pos()\n return shape.SHAPE_IMPLS[shape_](x=x, y=y, color_=color_)", "def setObjectName( self, name ):\n scene = self.scene()\n if ( scene ):\n name = scene.uniqueNodeName(name)\n self._objectName = name\n self._titleFont = None\n self.update()", "def ashape(node):\n shp = node.shape\n assert shp is not None\n return shp", "def NewShape(self, *args):\n return _XCAFDoc.XCAFDoc_ShapeTool_NewShape(self, *args)", "def setName(self, name: str, /) -> Any:\n ...", "def XCAFDoc_ShapeTool_Set(*args):\n return _XCAFDoc.XCAFDoc_ShapeTool_Set(*args)", "def shape(self) -> str:\n return \"circle\"", "def settle_falilng_shape(self):\n if self.falling_shape:\n self._settle_shape(self.falling_shape)\n self.falling_shape = None\n self.new_shape()", "def find_shape(name):\n for path in shapes():\n shape_name = os.path.basename(path).replace('.json', '')\n\n if shape_name == name:\n return path\n\n return None", "def turtle_movement(turtle_shape, bg_color, turtle_color, turtle_speed):\n turtle_name = initialize(turtle_shape, bg_color,\n turtle_color, turtle_speed)\n\n for i in range(36):\n for i in range(4):\n turtle_name.forward(200)\n turtle_name.right(90)\n turtle_name.right(10)", "def set_shape(self, connection_shape):\n self.shape = connection_shape", "def _create_unique_turtle_name(self):\n\n\t\tself._id_counter += 1\n\t\tnew_name = \"turtle{}\".format(self._id_counter)\n\n\t\tif self._has_turtle(new_name):\n\t\t\treturn self._create_unique_turtle_name()\n\n\t\treturn new_name" ]

[ "0.6143828", "0.6078034", "0.60113525", "0.5845368", "0.5724729", "0.57068795", "0.5691938", "0.5600295", "0.558822", "0.5547906", "0.5531356", "0.5514071", "0.5507343", "0.5481607", "0.547538", "0.5390002", "0.53875524", "0.5384286", "0.53407335", "0.53226936", "0.524077", "0.5225936", "0.5223125", "0.52050763", "0.5198058", "0.51980543", "0.51876897", "0.5182099", "0.5177639", "0.5123706" ]

[ "def _transform_polygons(self, polygons):\n if self.rotation is not None:\n ct = numpy.cos(self.rotation * numpy.pi / 180.0)\n st = numpy.sin(self.rotation * numpy.pi / 180.0) * _mpone\n if self.magnification is not None:\n mag = numpy.array((self.magnification, self.magnification), dtype=float)\n if self.origin is not None:\n orgn = numpy.array(self.origin)\n if self.x_reflection:\n xrefl = numpy.array((1, -1))\n if isinstance(polygons, dict):\n out_polygons = {}\n for kk in polygons.keys():\n out_polygons[kk] = []\n for ii in range(self.columns):\n for jj in range(self.rows):\n spc = numpy.array([self.spacing[0] * ii, self.spacing[1] * jj])\n for points in polygons[kk]:\n if self.magnification:\n out_polygons[kk].append(points * mag + spc)\n else:\n out_polygons[kk].append(points + spc)\n if self.x_reflection:\n out_polygons[kk][-1] = out_polygons[kk][-1] * xrefl\n if self.rotation is not None:\n out_polygons[kk][-1] = (\n out_polygons[kk][-1] * ct\n + out_polygons[kk][-1][:, ::-1] * st\n )\n if self.origin is not None:\n out_polygons[kk][-1] = out_polygons[kk][-1] + orgn\n else:\n out_polygons = []\n for ii in range(self.columns):\n for jj in range(self.rows):\n spc = numpy.array([self.spacing[0] * ii, self.spacing[1] * jj])\n for points in polygons:\n if self.magnification is not None:\n out_polygons.append(points * mag + spc)\n else:\n out_polygons.append(points + spc)\n if self.x_reflection:\n out_polygons[-1] = out_polygons[-1] * xrefl\n if self.rotation is not None:\n out_polygons[-1] = (\n out_polygons[-1] * ct + out_polygons[-1][:, ::-1] * st\n )\n if self.origin is not None:\n out_polygons[-1] = out_polygons[-1] + orgn\n return out_polygons", "def _transform_polygons(self, polygons):\n if self.rotation is not None:\n ct = numpy.cos(self.rotation * numpy.pi / 180.0)\n st = numpy.sin(self.rotation * numpy.pi / 180.0) * _mpone\n if self.x_reflection:\n xrefl = numpy.array((1, -1))\n if self.magnification is not None:\n mag = numpy.array((self.magnification, self.magnification), dtype=float)\n if self.origin is not None:\n orgn = numpy.array(self.origin)\n if isinstance(polygons, dict):\n for kk in polygons.keys():\n for ii in range(len(polygons[kk])):\n if self.x_reflection:\n polygons[kk][ii] = polygons[kk][ii] * xrefl\n if self.magnification is not None:\n polygons[kk][ii] = polygons[kk][ii] * mag\n if self.rotation is not None:\n polygons[kk][ii] = (\n polygons[kk][ii] * ct + polygons[kk][ii][:, ::-1] * st\n )\n if self.origin is not None:\n polygons[kk][ii] = polygons[kk][ii] + orgn\n else:\n for ii in range(len(polygons)):\n if self.x_reflection:\n polygons[ii] = polygons[ii] * xrefl\n if self.magnification is not None:\n polygons[ii] = polygons[ii] * mag\n if self.rotation is not None:\n polygons[ii] = polygons[ii] * ct + polygons[ii][:, ::-1] * st\n if self.origin is not None:\n polygons[ii] = polygons[ii] + orgn\n return polygons", "def getShape(transform):\n\n pass", "def poly2mask(self):\n self.x_gridnum = int((self.x_range[1] - self.x_range[0]) / self.x_gridsize)\n self.y_gridnum = int((self.y_range[1] - self.y_range[0]) / self.y_gridsize)\n img = Image.new(\"L\", (self.x_gridnum, self.y_gridnum), 0)\n\n self.perimeter = 0.0\n for ii in self.polygons:\n pp = np.array(ii) * self.CD # polygon\n polygonlen = len(pp)\n self.perimeter += np.sum(np.abs(pp[0:-1] - pp[1:polygonlen]))\n pp[:, 0] = (pp[:, 0] - self.x_range[0]) / self.x_gridsize\n pp[:, 1] = (pp[:, 1] - self.y_range[0]) / self.y_gridsize\n vetex_list = list(pp)\n polygon = [tuple(y) for y in vetex_list]\n ImageDraw.Draw(img).polygon(polygon, outline=1, fill=1)\n\n self.data = np.array(img)\n self.data = np.float64(self.data)\n\n self.spat_part = pyfftw.empty_aligned(\n (self.y_gridnum, self.x_gridnum), dtype=\"complex128\"\n )\n self.freq_part = pyfftw.empty_aligned(\n (self.y_gridnum, self.x_gridnum), dtype=\"complex128\"\n )\n self.fft_mask = pyfftw.FFTW(self.spat_part, self.freq_part, axes=(0, 1))", "def _createpoly(self):\n return self.cv.create_polygon((0, 0, 0, 0, 0, 0), fill=\"\", outline=\"\")", "def make_shape_ccw(self):\n\n if not(self.closed):\n return\n\n # Optimization for closed shapes\n # Start value for the first sum\n\n if self.isDirectionOfGeosCCW(self.geos):\n self.reverse()\n logger.debug(self.tr(\"Had to reverse the shape to be CW\"))\n self.cw = True", "def convert_to_polygon_gate(self, transforms, n_vertices=128):\n # FlowJo stores ellipsoid vertex values differently from any other gate.\n # They are stored in the binned \"display space\", so range from 0.0 - 256.0.\n # The binned space is linear over the transform range.\n #\n # To convert to a polygon:\n # 1. Determine center & rotation angle from foci\n # 2. Translate foci & edge vertices such that center is at origin\n # 3. Rotate foci & edge vertices such that major/minor axes are || to x/y axes\n # 4. Determine major axis orientation (x vs y-axis)\n # 5. Use foci & major axis to determine minor axis (2nd FJ point is unreliable)\n # 6. Generate new x, y points from ellipse definition for set of angles\n # 7. Rotate & translate coordinates back to original orientation\n # 8. Scale any dimensions using biex transform\n # 9. Create PolygonGate from the new set of coordinates\n # Find center of ellipse\n foci = copy.deepcopy(self.foci) / 256.0\n center = (foci[0] + foci[1]) / 2.0\n\n # Determine rotation of ellipse\n slope = (foci[1][1] - foci[0][1]) / (foci[1][0] - foci[0][0])\n theta_rad = np.arctan(slope)\n cos, sin = np.cos(theta_rad), np.sin(theta_rad)\n r = np.array(((cos, -sin), (sin, cos)))\n\n # Translate foci & edge vertices to the origin\n foci_origin = foci - center\n edge_vertices_origin = (copy.deepcopy(self.edge_vertices) / 256.0) - center\n\n # According to FlowJo devs, edge vertices are ordered as:\n # 1st & 2nd points are major axis\n # 3rd & 4th points are minor axis\n # Rotate edge vertices\n # Only need are one major & one minor point since the other is symmetric\n foci_rotated = _rotate_point_around_point(foci_origin[0], r)\n rv1 = _rotate_point_around_point(edge_vertices_origin[0], r)\n rv3 = _rotate_point_around_point(edge_vertices_origin[2], r)\n\n # However, I don't trust that the 1st point is always the major\n # axis or if it is always on x or y, so we'll make sure.\n # Use absolute values & find max\n rv1 = np.abs(rv1)\n rv3 = np.abs(rv3)\n rv1_max_pos = rv1.argmax()\n rv3_max_pos = rv3.argmax()\n\n if rv1_max_pos == rv3_max_pos:\n raise FlowJoWSPParsingError(\n \"Cannot determine major axis of FlowJo ellipse gate '%s'\" % self.gate_name\n )\n\n rv1_max_val = rv1[rv1_max_pos]\n rv3_max_val = rv3[rv3_max_pos]\n\n if rv1_max_val >= rv3_max_val:\n # rv1 is major axis (even if a circle)\n a = rv1_max_val\n else:\n # rv3 is major axis\n a = rv3_max_val\n\n # Also, calculate b from foci and found 'a', since the\n # minor vertex stored by FlowJo seems off\n b = np.sqrt(np.abs((foci_rotated[0]) ** 2 - (a ** 2)))\n\n # Calculate set of angles for getting points on ellipse\n angles = [2 * np.pi * (i / n_vertices) for i in range(n_vertices)]\n\n # Calculate x, y coordinates for each of the angles\n # x = a * cos(θ)\n # y = b * sin(θ)\n if rv1_max_pos == 0:\n # major axis is the x-axis\n x = a * np.cos(angles)\n y = b * np.sin(angles)\n else:\n # minor axis is the x-axis\n x = b * np.cos(angles)\n y = a * np.sin(angles)\n\n # rotate ellipse to the original orientation, then translate\n inv_r = np.linalg.inv(r)\n xy = np.vstack([x, y]).T\n\n # this will be the final set of polygon vertices\n xy_rot_trans = np.dot(xy, inv_r) + center\n\n # the final complication is the different scaling of biex transforms\n for i, xform in enumerate(transforms):\n if isinstance(xform, WSPBiexTransform):\n # biex transform is always scaled from 0-4096\n xform_range = 4096.0\n else:\n # all others are scaled from 0-1\n xform_range = 1.0\n\n xy_rot_trans[:, i] *= xform_range\n\n return PolygonGate(self.gate_name, self.dimensions, xy_rot_trans, use_complement=self.use_complement)", "def translate_shape(shape, x_shift, y_shift):", "def to_shapely_polygon(self):\n # load shapely lazily, which makes the dependency more optional\n import shapely.geometry\n return shapely.geometry.Polygon([(point[0], point[1]) for point in self.exterior])", "def generatePolygons():", "def shrink_polygon(self,polygon, offset = 1):\r\n \r\n import numpy as np\r\n import copy\r\n import math\r\n \r\n def angle(x1, y1, x2, y2):\r\n numer = (x1*x2 + y1*y2)\r\n denom = np.sqrt((x1**2 + y1**2) * (x2**2 + y2**2))\r\n print(numer)\r\n print(denom)\r\n print( math.acos(numer/denom) )\r\n return math.acos(numer/denom) \r\n \r\n def cross_sign(x1, y1, x2, y2):\r\n return x1*y2 > x2*y1\r\n \r\n # If the polygon is closed, un-close it\r\n closed = False\r\n if np.linalg.norm(polygon[0,:]-polygon[-1,:]) < 1E-10:\r\n polygon = polygon[:-1,:]\r\n closed = True\r\n \r\n # Make sure polygon is counter-clockwise\r\n if self.are_vertices_clockwise(np.row_stack((polygon,polygon[0,:]))):\r\n polygon = np.flipud(polygon)\r\n \r\n polygon_shrinked = copy.copy(polygon)\r\n \r\n for idx in range(polygon.shape[0]):\r\n \r\n if idx == polygon.shape[0]-1:\r\n vtx_before = idx-1\r\n vtx_center = idx\r\n vtx_after = 0\r\n else:\r\n vtx_before = idx-1\r\n vtx_center = idx\r\n vtx_after = idx+1\r\n \r\n side_before = polygon[vtx_center,:] - polygon[vtx_before,:]\r\n side_after = polygon[vtx_after,:] - polygon[vtx_center,:]\r\n \r\n side_before /= np.linalg.norm(side_before)\r\n side_after /= np.linalg.norm(side_after)\r\n \r\n nvec_before = np.asarray([-side_before[1], side_before[0]])\r\n nvec_after = np.asarray([-side_after[1], side_after[0]])\r\n \r\n vtx1_before = polygon[vtx_before,:] + nvec_before*offset\r\n vtx2_before = polygon[vtx_center,:] + nvec_before*offset\r\n \r\n vtx1_after = polygon[vtx_center,:] + nvec_after*offset\r\n vtx2_after = polygon[vtx_after,:] + nvec_after*offset\r\n \r\n p = vtx1_before\r\n r = (vtx2_before-vtx1_before)\r\n \r\n q = vtx1_after\r\n s = (vtx2_after-vtx1_after)\r\n \r\n if np.cross(r,s) == 0:\r\n \r\n # Lines are collinear\r\n polygon_shrinked[idx,:] = vtx2_before\r\n \r\n else:\r\n \r\n # Lines are not collinear\r\n t = np.cross(q - p,s)/(np.cross(r,s))\r\n \r\n # This is the intersection point\r\n polygon_shrinked[idx,:] = p + t*r\r\n \r\n if closed:\r\n polygon_shrinked = np.row_stack((\r\n polygon_shrinked,\r\n polygon_shrinked[0,:]))\r\n \r\n return polygon_shrinked", "def shrink_polygon(self,polygon, offset = 1):\r\n \r\n import numpy as np\r\n import copy\r\n import math\r\n \r\n def angle(x1, y1, x2, y2):\r\n numer = (x1*x2 + y1*y2)\r\n denom = np.sqrt((x1**2 + y1**2) * (x2**2 + y2**2))\r\n print(numer)\r\n print(denom)\r\n print( math.acos(numer/denom) )\r\n return math.acos(numer/denom) \r\n \r\n def cross_sign(x1, y1, x2, y2):\r\n return x1*y2 > x2*y1\r\n \r\n # If the polygon is closed, un-close it\r\n closed = False\r\n if np.linalg.norm(polygon[0,:]-polygon[-1,:]) < 1E-10:\r\n polygon = polygon[:-1,:]\r\n closed = True\r\n \r\n # Make sure polygon is counter-clockwise\r\n if self.are_vertices_clockwise(np.row_stack((polygon,polygon[0,:]))):\r\n polygon = np.flipud(polygon)\r\n \r\n polygon_shrinked = copy.copy(polygon)\r\n \r\n for idx in range(polygon.shape[0]):\r\n \r\n if idx == polygon.shape[0]-1:\r\n vtx_before = idx-1\r\n vtx_center = idx\r\n vtx_after = 0\r\n else:\r\n vtx_before = idx-1\r\n vtx_center = idx\r\n vtx_after = idx+1\r\n \r\n side_before = polygon[vtx_center,:] - polygon[vtx_before,:]\r\n side_after = polygon[vtx_after,:] - polygon[vtx_center,:]\r\n \r\n side_before /= np.linalg.norm(side_before)\r\n side_after /= np.linalg.norm(side_after)\r\n \r\n nvec_before = np.asarray([-side_before[1], side_before[0]])\r\n nvec_after = np.asarray([-side_after[1], side_after[0]])\r\n \r\n vtx1_before = polygon[vtx_before,:] + nvec_before*offset\r\n vtx2_before = polygon[vtx_center,:] + nvec_before*offset\r\n \r\n vtx1_after = polygon[vtx_center,:] + nvec_after*offset\r\n vtx2_after = polygon[vtx_after,:] + nvec_after*offset\r\n \r\n p = vtx1_before\r\n r = (vtx2_before-vtx1_before)\r\n \r\n q = vtx1_after\r\n s = (vtx2_after-vtx1_after)\r\n \r\n if np.cross(r,s) == 0:\r\n \r\n # Lines are collinear\r\n polygon_shrinked[idx,:] = vtx2_before\r\n \r\n else:\r\n \r\n # Lines are not collinear\r\n t = np.cross(q - p,s)/(np.cross(r,s))\r\n \r\n # This is the intersection point\r\n polygon_shrinked[idx,:] = p + t*r\r\n \r\n if closed:\r\n polygon_shrinked = np.row_stack((\r\n polygon_shrinked,\r\n polygon_shrinked[0,:]))\r\n \r\n return polygon_shrinked", "def mask_to_poly_geojson(pred_arr, channel_scaling=None, reference_im=None,\n output_path=None, output_type='geojson', min_area=40,\n bg_threshold=0, do_transform=None, simplify=False,\n tolerance=0.5, **kwargs):\n\n mask_arr = preds_to_binary(pred_arr, channel_scaling, bg_threshold)\n\n if do_transform and reference_im is None:\n raise ValueError(\n 'Coordinate transformation requires a reference image.')\n\n if do_transform:\n with rasterio.open(reference_im) as ref:\n transform = ref.transform\n crs = ref.crs\n ref.close()\n else:\n transform = Affine(1, 0, 0, 0, 1, 0) # identity transform\n crs = rasterio.crs.CRS()\n\n mask = mask_arr > bg_threshold\n mask = mask.astype('uint8')\n\n polygon_generator = features.shapes(mask_arr,\n transform=transform,\n mask=mask)\n polygons = []\n values = [] # pixel values for the polygon in mask_arr\n for polygon, value in polygon_generator:\n p = shape(polygon).buffer(0.0)\n if p.area >= min_area:\n polygons.append(shape(polygon).buffer(0.0))\n values.append(value)\n\n polygon_gdf = gpd.GeoDataFrame({'geometry': polygons, 'value': values},\n crs=crs.to_wkt())\n if simplify:\n polygon_gdf['geometry'] = polygon_gdf['geometry'].apply(\n lambda x: x.simplify(tolerance=tolerance)\n )\n # save output files\n if output_path is not None:\n if output_type.lower() == 'geojson':\n if len(polygon_gdf) > 0:\n polygon_gdf.to_file(output_path, driver='GeoJSON')\n else:\n save_empty_geojson(output_path, polygon_gdf.crs.to_epsg())\n elif output_type.lower() == 'csv':\n polygon_gdf.to_csv(output_path, index=False)\n\n return polygon_gdf", "def mask_to_poly_geojson(pred_arr, channel_scaling=None, reference_im=None,\n output_path=None, output_type='geojson', min_area=40,\n bg_threshold=0, do_transform=None, simplify=False,\n tolerance=0.5, **kwargs):\n\n mask_arr = preds_to_binary(pred_arr, channel_scaling, bg_threshold)\n\n if do_transform and reference_im is None:\n raise ValueError(\n 'Coordinate transformation requires a reference image.')\n\n if do_transform:\n with rasterio.open(reference_im) as ref:\n transform = ref.transform\n crs = ref.crs\n ref.close()\n else:\n transform = Affine(1, 0, 0, 0, 1, 0) # identity transform\n crs = rasterio.crs.CRS()\n\n mask = mask_arr > bg_threshold\n mask = mask.astype('uint8')\n\n polygon_generator = features.shapes(mask_arr,\n transform=transform,\n mask=mask)\n polygons = []\n values = [] # pixel values for the polygon in mask_arr\n for polygon, value in polygon_generator:\n p = shape(polygon).buffer(0.0)\n if p.area >= min_area:\n polygons.append(shape(polygon).buffer(0.0))\n values.append(value)\n\n polygon_gdf = gpd.GeoDataFrame({'geometry': polygons, 'value': values},\n crs=crs.to_wkt())\n if simplify:\n polygon_gdf['geometry'] = polygon_gdf['geometry'].apply(\n lambda x: x.simplify(tolerance=tolerance)\n )\n # save output files\n if output_path is not None:\n if output_type.lower() == 'geojson':\n if len(polygon_gdf) > 0:\n polygon_gdf.to_file(output_path, driver='GeoJSON')\n else:\n save_empty_geojson(output_path, polygon_gdf.crs.to_epsg())\n elif output_type.lower() == 'csv':\n polygon_gdf.to_csv(output_path, index=False)\n\n return polygon_gdf", "def rasterize_vector(shp, rows, cols, geoTrans=None, saveto=None, method='within', transform=None):\r\n # Open the shapefile\r\n shp = ogr.Open(shp)\r\n\r\n # Get the layer from the shape\r\n layer = shp.GetLayer()\r\n\r\n # Get the layer's information\r\n lyrSrs = layer.GetSpatialRef().ExportToWkt()\r\n\r\n # Optionally transform to specified transformation\r\n if transform and transform.ExportToWkt() != lyrSrs:\r\n # Get the layer geometry\r\n poly = layer.GetNextFeature()\r\n geom = poly.GetGeometryRef()\r\n\r\n # Transform the geometry.\r\n geom.TransformTo(transform)\r\n\r\n # Create a new layer.\r\n lyr_driver = ogr.GetDriverByName('ESRI Shapefile')\r\n\r\n lyr_driver_name = tempfile.NamedTemporaryFile(suffix='.shp').name\r\n lyr_source = lyr_driver.CreateDataSource(lyr_driver_name)\r\n new_lyr = lyr_source.CreateLayer(lyr_driver_name, transform, geom_type=ogr.wkbPolygon)\r\n\r\n # Add an ID field to tie the geometry to\r\n id_field = ogr.FieldDefn('id', ogr.OFTInteger)\r\n new_lyr.CreateField(id_field)\r\n\r\n # Set the transformed geometry\r\n feature_defn = new_lyr.GetLayerDefn()\r\n feature = ogr.Feature(feature_defn)\r\n feature.SetGeometry(geom)\r\n feature.SetField('id',1)\r\n new_lyr.CreateFeature(feature)\r\n\r\n # Set the existing layer to be the new layer\r\n layer = new_lyr\r\n lyrSrs = transform.ExportToWkt()\r\n\r\n # Create the raster's name\r\n if not saveto:\r\n remove = True\r\n saveto = tempfile.NamedTemporaryFile(suffix='.tif')\r\n saveto = saveto.name\r\n else:\r\n remove = False\r\n\r\n # Create the new raster\r\n driver = gdal.GetDriverByName('GTiff')\r\n outRas = driver.Create(saveto, cols, rows, 1)\r\n outRas.SetProjection(lyrSrs)\r\n outRas.SetGeoTransform(geoTrans)\r\n outRas.GetRasterBand(1).Fill(1)\r\n\r\n # Rasterize the layer\r\n if method.lower() == 'touches':\r\n gdal.RasterizeLayer(outRas,[1],layer,None, None, [0], ['ALL_TOUCHED=TRUE'])\r\n else: # Just default to this.\r\n gdal.RasterizeLayer(outRas,[1],layer,None, None, [0])\r\n arr = outRas.ReadAsArray()\r\n if remove:\r\n os.remove(saveto)\r\n\r\n # Return the numpy array\r\n return arr", "def processed_shape(self, shape):\n return shape", "def _scale_polygon(self, event):\n if not self._selection_completed:\n return\n\n if self._old_box_extents == self._box.extents:\n return\n\n # Create transform from old box to new box\n x1, y1, w1, h1 = self._box._rect_bbox\n old_bbox = self._get_bbox()\n t = (transforms.Affine2D()\n .translate(-old_bbox.x0, -old_bbox.y0)\n .scale(1 / old_bbox.width, 1 / old_bbox.height)\n .scale(w1, h1)\n .translate(x1, y1))\n\n # Update polygon verts. Must be a list of tuples for consistency.\n new_verts = [(x, y) for x, y in t.transform(np.array(self.verts))]\n self._xys = [*new_verts, new_verts[0]]\n self._draw_polygon()\n self._old_box_extents = self._box.extents", "def writethreshold2shp(self):\n assert self.dataset!=None,'Null dataset'\n assert self.RasterSet,'Please Set Bool map in ndarray with SetRasterData() \\n, Current output polygon src band is '+str(self.imageoutput)\n shp_name = self.out_middle_tif_name + '_polygonized.shp'\n srcband = self.dataset.GetRasterBand(1)\n maskband = None\n format = 'ESRI Shapefile'\n drv = ogr.GetDriverByName(format)\n dst_ds = drv.CreateDataSource(shp_name)\n srs = osr.SpatialReference()\n srs.ImportFromWkt(self.outdataset.GetProjectionRef())\n\n dst_layer = dst_ds.CreateLayer(shp_name, geom_type=ogr.wkbPolygon, srs=srs)\n if (dst_layer == None):\n return 0, 0\n dst_field = dst_layer.GetLayerDefn().GetFieldIndex(shp_name)\n prog_func = gdal.TermProgress\n options = []\n result = gdal.Polygonize(srcband, maskband, dst_layer, dst_field, options,\n callback=prog_func)\n dst_ds = None\n print('Shapefile has write in ',shp_name)\n return shp_name", "def _create_main_shape(self):\n\n a, b = gc( self.size/2,\n self._ZERO_DEGREES - self.angle,\n self._180_DEGREES + self.angle)\n self.wafer_points = zip(a,b)\n self.wafer_polygon = gdspy.Polygon(self.wafer_points, self.WAFER_LAYER)\n self.cell.add(self.wafer_polygon)", "def _write_polygons(\n self,\n shapes: Iterable[Polygon],\n emissions: Iterable[float],\n info: EmissionInfo,\n source_group: int,\n ):\n\n # Rasterize the polygon on a grid\n shapes_serie = gpd.GeoSeries(shapes)\n # get polygon bounds\n minx, miny, maxx, maxy = shapes_serie.total_bounds\n # Create a grid for the rasterization\n x = np.arange(minx, maxx, self.polygon_raster_size)\n y = np.arange(miny, maxy, self.polygon_raster_size)\n\n # Get the emission per cell\n average_cells_proportion = (self.polygon_raster_size**2) / shapes_serie.area\n cell_emissions = np.array(emissions) * average_cells_proportion\n\n # WARNING: this might be not exactly mass convserving\n rasterized_emissions = rasterize(\n shapes=zip(shapes, cell_emissions),\n out_shape=(len(x), len(y)),\n transform=from_bounds(minx, miny, maxx, maxy, len(x), len(y)),\n all_touched=False,\n merge_alg=MergeAlg.add,\n )[\n ::-1, :\n ] # flip the y axis\n\n # Get the coordinates of the rasterized polygon\n indices = np.array(np.where(rasterized_emissions)).T\n\n # Write the polygon\n with open(self.file_cadastre, \"a\") as f:\n for i_x, i_y in indices:\n f.write(\n f\"{x[i_x]},{y[i_y]},{info.height},\"\n f\"{self.polygon_raster_size},{self.polygon_raster_size},{info.vertical_extension},\"\n f\"{rasterized_emissions[i_x, i_y]},0,0,0,{source_group},\\n\"\n )", "def m4_make_upper_shape_points_list(tx, ty, m4_info, SEN_info):\n \"\"\"\n 1 Get information from m4_info & SEN_info\n \"\"\"\n x_m4 = m4_info[0]\n y_m4 = m4_info[1]\n z_m = m4_info[2]\n\n m4_points = m4_info[3]\n\n m4_p0 = m4_points[0]\n m4_p1 = m4_points[1]\n m4_p2 = m4_points[2]\n m4_p3 = m4_points[3]\n\n w_sen = SEN_info[0]\n n_w_sen = SEN_info[1]\n h_sen = SEN_info[2]\n t_sen = SEN_info[3]\n u_n = SEN_info[4]\n l_n = SEN_info[5]\n set = SEN_info[6]\n u_offset = SEN_info[7]\n l_offset = SEN_info[8]\n\n \"\"\"\n 2 Make lists.\n upper_shape_upper_left_row list\n upper_shape_upper_right_row list\n\n upper_shape_lower_left_row list\n upper_shape_lower_right_row list\n \"\"\"\n # upper side\n upper_shape_upper_left_row = []\n upper_shape_upper_right_row = []\n\n for i in range(u_n - 1, -1, -1):\n # left row\n ix = tx - (x_m4 - t_sen)\n iy = ty + (i * u_offset + set) + 10\n\n p0, p1, p2, p3, p4, p5, p6, p7, p8 = Y_upper_shape_points(ix, iy, w_sen, t_sen, n_w_sen)\n left_points = [p8, p7, p6, p5, p4, p3, p2, p1]\n upper_shape_upper_left_row.extend((left_points))\n\n for i in range(u_n):\n # right row\n ix = tx - t_sen\n iy = ty + (i * u_offset + set) + 10\n\n p0, p1, p2, p3, p4, p5, p6, p7, p8 = Y_upper_shape_points(ix, iy, w_sen, t_sen, n_w_sen)\n right_points = [p4, p3, p2, p1, p8, p7, p6, p5]\n upper_shape_upper_right_row.extend(right_points)\n\n # lower side\n upper_shape_lower_left_row = []\n upper_shape_lower_right_row = []\n\n for i in range(l_n):\n # left row\n ix = tx - (x_m4 - t_sen)\n iy = ty - (i * l_offset + set) - 10\n\n p0, p1, p2, p3, p4, p5, p6, p7, p8 = Y_upper_shape_points(ix, iy, w_sen, t_sen, n_w_sen)\n left_points = [p8, p7, p6, p5, p4, p3, p2, p1]\n upper_shape_lower_left_row.extend((left_points))\n\n for i in range(l_n - 1, -1, -1):\n # right row\n ix = tx - t_sen\n iy = ty - (i * l_offset + set) - 10\n\n p0, p1, p2, p3, p4, p5, p6, p7, p8 = Y_upper_shape_points(ix, iy, w_sen, t_sen, n_w_sen)\n right_points = [p4, p3, p2, p1, p8, p7, p6, p5]\n upper_shape_lower_right_row.extend(right_points)\n\n upper_shape_upper = [upper_shape_upper_left_row, upper_shape_upper_right_row]\n upper_shape_lower = [upper_shape_lower_left_row, upper_shape_lower_right_row]\n\n return upper_shape_upper, upper_shape_lower", "def get_future_poly(self, poly):\n # If direction is changed, then run the rotation matrix poly. If not, just translation.\n if self.fdirection != self.direction:\n # Translation and rotation matrix\n new_poly = []\n for x, y in poly:\n rot = rotation_matrix(x, y, np.radians(self.fdirection))\n new_poly.append([rot[0] + self.fx, rot[1] + self.fy])\n return new_poly\n else:\n # Do normal translation\n return [ [self.fx + x, self.fy + y] for x, y in poly ]", "def transformed(self, T):\n new = Polygon2()\n new.path = self.path.transformed(Affine2D(T.A))\n return new", "def GetRevolutionMode(self, *args):\n return _ShapeUpgrade.ShapeUpgrade_ShapeConvertToBezier_GetRevolutionMode(self, *args)", "def from_gca_polygon(gca_obj, name_header, folder_name, folder_description='',\n altitude_mode=\"ctg\", style_to_use=None, poly_hidden=False,\n poly_follow_terrain=True, poly_extrude_to_ground=False, folder_collapsed=True):\n\n name_col = gca_obj.headers.index(name_header)\n\n polygons = list()\n\n for feature in gca_obj.features:\n name = feature[0][name_col]\n coords = feature[1]\n attrs = feature[0]\n headers = gca_obj.headers\n\n poly = kml_base.polygon(coords, name, headers, attrs, altitude_mode, style_to_use, poly_hidden, poly_follow_terrain, poly_extrude_to_ground)\n polygons.append(poly)\n\n poly_folder = kml_base.folder(folder_name, polygons, folder_description, folder_collapsed)\n\n return poly_folder", "def m4_make_lower_shape_points_list(tx, ty, m4_info, SEN_info):\n \"\"\"\n 1 Get information from m4_info & SEN_info\n \"\"\"\n x_m4 = m4_info[0]\n y_m4 = m4_info[1]\n z_m = m4_info[2]\n\n m4_points = m4_info[3]\n\n m4_p0 = m4_points[0]\n m4_p1 = m4_points[1]\n m4_p2 = m4_points[2]\n m4_p3 = m4_points[3]\n\n w_sen = SEN_info[0]\n n_w_sen = SEN_info[1]\n h_sen = SEN_info[2]\n t_sen = SEN_info[3]\n u_n = SEN_info[4]\n l_n = SEN_info[5]\n set = SEN_info[6]\n u_offset = SEN_info[7]\n l_offset = SEN_info[8]\n\n \"\"\"\n 2 Make lists.\n lower_shape_upper_left_row list\n lower_shape_upper_right_row list\n\n lower_shape_lower_left_row list\n lower_shape_lower_right_row list\n \"\"\"\n # upper side\n lower_shape_upper_left_row = []\n lower_shape_upper_right_row = []\n\n for i in range(u_n - 1, -1, -1):\n # left row\n ix = tx - (x_m4 - t_sen)\n iy = ty + (i * u_offset + set) + 10\n\n p0, p1, p2, p3, p4, p5, p6, p7, p8 = Y_lower_shape_points(ix, iy, w_sen, t_sen, n_w_sen)\n left_points = [p5, p6, p7, p8, p1, p2, p3, p4]\n lower_shape_upper_left_row.extend((left_points))\n\n for i in range(u_n):\n # right row\n ix = tx - t_sen\n iy = ty + (i * u_offset + set) + 10\n\n p0, p1, p2, p3, p4, p5, p6, p7, p8 = Y_lower_shape_points(ix, iy, w_sen, t_sen, n_w_sen)\n right_points = [p1, p2, p3, p4, p5, p6, p7, p8]\n lower_shape_upper_right_row.extend(right_points)\n\n # lower side\n lower_shape_lower_left_row = []\n lower_shape_lower_right_row = []\n\n for i in range(l_n):\n # left row\n ix = tx - (x_m4 - t_sen)\n iy = ty - (i * l_offset + set) - 10\n\n p0, p1, p2, p3, p4, p5, p6, p7, p8 = Y_lower_shape_points(ix, iy, w_sen, t_sen, n_w_sen)\n left_points = [p5, p6, p7, p8, p1, p2, p3, p4]\n lower_shape_lower_left_row.extend((left_points))\n\n for i in range(l_n - 1, -1, -1):\n # right row\n ix = tx - t_sen\n iy = ty - (i * l_offset + set) - 10\n\n p0, p1, p2, p3, p4, p5, p6, p7, p8 = Y_lower_shape_points(ix, iy, w_sen, t_sen, n_w_sen)\n right_points = [p1, p2, p3, p4, p5, p6, p7, p8]\n lower_shape_lower_right_row.extend(right_points)\n\n lower_shape_upper = [lower_shape_upper_left_row, lower_shape_upper_right_row]\n lower_shape_lower = [lower_shape_lower_left_row, lower_shape_lower_right_row]\n\n return lower_shape_upper, lower_shape_lower", "def compute_all_jxy(polygon=None):\n expressions = []\n symmetric = []\n\n # given a 12-gon, we do the following:\n # polygon = Symbolic12Gon()\n # polygon = make_regular()\n if polygon is None:\n polygon = make_any_gon()\n # polygon = make_assumption_gon()\n\n # print(polygon.vertices)\n for i in range(6):\n print(i)\n # translate such that this point is the origin\n# polygon = polygon.translate(polygon.vertices[i])\n# print(polygon)\n # shear so that the diagonal we are considering is vertical\n try:\n q = polygon.vertices[i].qx_to_shear_by(polygon.vertices[i+1])\n# print(\"q1:\", q.rational(D=3), q.irrational(D=3))\n except ZeroDivisionError:\n print(\"-------\")\n print(\"division by 0!\")\n print(\"-------\")\n continue\n\n sheared_polygon = polygon.shear_x_zero(q)\n# print(sheared_polygon)\n# print(\"test:\", sheared_polygon.vertices[i] - sheared_polygon.vertices[i+1])\n w, h = sheared_polygon.get_cylinder(i)\n # print(\"h: \",h.full_simplify())\n# print(\"shear 1 w: \",w.full_simplify())\n # print(len(sheared_polygon.vertices))\n# print(sheared_polygon.vertices[i])\n # shear again so that the edge that we consider is horizontal\n try:\n q = sheared_polygon.vertices[i].qy_to_shear_by(sheared_polygon.vertices[(i + 7) % 12])\n# print(sheared_polygon.vertices[i], sheared_polygon.vertices[(i + 7) % 12])\n# print(\"q2:\", q.rational(D=3), q.irrational(D=3))\n except ZeroDivisionError:\n print(\"-------\")\n print(\"division by 0!\")\n print(\"-------\")\n continue\n\n twice_sheared = sheared_polygon.shear_y_zero(q)\n\n # rescale such that the modulus of the vertical cylinder is rational\n w, h = twice_sheared.get_cylinder(i)\n# print(\"shear 2 h: \",h.full_simplify())\n# print(\"shear 2 w: \",w.full_simplify())\n # print(w.y, h.x)\n stretch_factor = w.x/h.y # this should be reciprocated, but we just care it is rational\n # print(stretch_factor)\n stretched_polygon = sheared_polygon.stretch_y(stretch_factor)\n\n # compute Jxy\n jxy = stretched_polygon.jxy()\n expressions.append(jxy)\n symmetric.append((jxy[1], jxy[2]))\n\n return expressions, symmetric", "def update_transform(self):\n\n self.a = self.scale * self.pixel_size * math.cos(self.angle)\n self.d = self.scale * self.pixel_size * math.sin(self.angle)\n self.b = self.d\n self.e = -self.a\n self.c = self.point.x() - self.a*self.width/2.0 - self.b*self.height/2.0\n self.f = self.point.y() - self.d*self.width/2.0 - self.e*self.height/2.0\n\n self.bounding_box = [[self.c,self.f],[self.c+self.a*self.width,self.f+self.d*self.width],[self.c+self.a*self.width+self.b*self.height,self.f+self.d*self.width+self.e*self.height],[self.c+self.b*self.height,self.f+self.e*self.height],]", "def SetRevolutionMode(self, *args):\n return _ShapeUpgrade.ShapeUpgrade_ShapeConvertToBezier_SetRevolutionMode(self, *args)", "def amplify_2d_shape(shape, x_amplify, y_amplify):" ]

[ "0.63912666", "0.62640005", "0.6012609", "0.58500296", "0.57715154", "0.5723352", "0.5626749", "0.55777913", "0.5576676", "0.55393016", "0.5469966", "0.5469966", "0.54367065", "0.54367065", "0.5385322", "0.53791654", "0.53470826", "0.5342397", "0.532508", "0.53185755", "0.5316333", "0.5299679", "0.52902466", "0.5262178", "0.5219172", "0.5207638", "0.51794684", "0.51775557", "0.51511943", "0.5132562" ]

[ "def _prepare_turtle():\n turtle.setup(width=screen_width)\n turtle.shape(turtle_shape)\n turtle.title(title)", "def _update_layout(self):\n for i in self._MODES:\n self._parts[i].set_texture(self._prefix + i, \"skin\", resize=True)\n\n # Top and Left\n self._parts[\"Top\"].width = \"100%\"\n self._parts[\"Top\"].margin = (0, self._parts[\"TR\"].width, 0, self._parts[\"TL\"].width)\n\n self._parts[\"Left\"].height = \"100%\"\n self._parts[\"Left\"].margin = (self._parts[\"TL\"].height, 0, self._parts[\"BL\"].height, 0)\n\n # Mid\n self._parts[\"Mid\"].set_size(\"100%\", \"100%\")\n self._parts[\"Mid\"].margin = (self._parts[\"Top\"].height, self._parts[\"Right\"].width,\n self._parts[\"Bottom\"].height, self._parts[\"Left\"].width)\n\n # Bottom and Right\n self._parts[\"Bottom\"].width = \"100%\"\n self._parts[\"Bottom\"].margin = (0, self._parts[\"BR\"].width, 0, self._parts[\"BL\"].width)\n self._parts[\"Bottom\"].bottom = 0\n\n self._parts[\"Right\"].height = \"100%\"\n self._parts[\"Right\"].margin = (self._parts[\"TR\"].height, 0, self._parts[\"BR\"].width, 0)\n self._parts[\"Right\"].right = 0\n\n # Corners\n self._parts[\"TL\"].top_left = 0, 0\n self._parts[\"TR\"].top_right = 0, 0\n self._parts[\"BL\"].bottom_left = 0, 0\n self._parts[\"BR\"].bottom_right = 0, 0", "def turtle_setup():\n # ___ ___ _ _ ___ _____ __ __ ___ ___ ___ _____ __\n # | \\ / _ \\ | \\| |/ _ \\_ _| | \\/ |/ _ \\| \\_ _| __\\ \\ / /\n # | |) | (_) | | .` | (_) || | | |\\/| | (_) | |) | || _| \\ V /\n # |___/ \\___/ |_|\\_|\\___/ |_| |_| |_|\\___/|___/___|_| |_|\n # _____ _ _ ___ ___ ___ _ _ _ _ ___ _____ ___ ___ _ _\n # |_ _| || |_ _/ __| | __| | | | \\| |/ __|_ _|_ _/ _ \\| \\| |\n # | | | __ || |\\__ \\ | _|| |_| | .` | (__ | | | | (_) | .` |\n # |_| |_||_|___|___/ |_| \\___/|_|\\_|\\___| |_| |___\\___/|_|\\_|\n #\n # Create the turtle graphics screen and set a few basic properties.\n screen = turtle.Screen()\n screen.setup( WIDTH, HEIGHT, MARGIN, MARGIN )\n screen.bgcolor( \"SkyBlue\" )\n\n # Create two turtles, one for drawing and one for writing.\n artist = turtle.Turtle()\n writer = turtle.Turtle()\n\n # Change the artist turtle's shape so the artist and writer are distinguishable.\n artist.shape( \"turtle\" )\n\n # Make the animation as fast as possible and hide the turtles.\n if DRAW_FAST:\n screen.delay( 0 )\n artist.hideturtle()\n artist.speed( \"fastest\" )\n writer.hideturtle()\n writer.speed( \"fastest\" )\n\n # Set a few properties of the writing turtle useful since it will only be writing.\n writer.setheading( 90 ) # Straight up, which makes it look sort of like a cursor.\n writer.penup() # A turtle's pen does not have to be down to write text.\n writer.setposition( 0, HEIGHT // 2 - FONT_SIZE * 2 ) # Centered at top of the screen.\n\n return screen, artist, writer", "def render(self, mode='human'):\n screen_width = 800\n screen_height = 550\n\n # Width is one column for each variable\n n_sect = 7\n world_width = n_sect*2 # X axis is just pixels\n \n buff_axis = cfg['buff_axis']\n #bottom of the screen scales to the input/output range of values\n world_height_bottom = np.max(self.maxes)+buff_axis\n \n # Top is for counting steps\n world_height_top = 100\n\n #Split the screen:\n world_top = .3\n world_bottom = 1-world_top\n screen_height_bottom = world_bottom*screen_height\n\n #Set where to draw the steps axis\n axes_line1 = screen_height*(world_bottom + .2)\n\n # Scale the pixels in the screen:\n scalex = screen_width/world_width\n scaley_bottom= screen_height_bottom/world_height_bottom\n\n # Some adjustments to move some objects up/ right\n move_oval = -scalex*.2\n move_up= scaley_bottom * buff_axis*.5\n\n #set sizes of shapes:\n self.oval_length = 25.0\n self.oval_width = 50.0\n self.rect_width = 70.0\n self.rect_height = 5.0 \n\n #Step plot:\n scalestep = screen_width/cfg['scalestep']\n\n #color shades:\n light_col = .7\n dark_col = 1\n c11 = .6\n c22 = .8\n c33 = 1\n\n if self.viewer is None:\n #TO DO: find an alternative to copy-paste to generate multiple similar shapes\n self.viewer = rendering.Viewer(screen_width, screen_height)\n \n #Input states:\n\n #the temp action\n self.temptrans1 = self.make_oval(0,0,light_col)\n self.temptrans2 = self.make_oval(0,0,dark_col)\n #flow action:\n self.flowtrans1 = self.make_oval(light_col,0,light_col)\n self.flowtrans2 = self.make_oval(dark_col,0,dark_col)\n\n #output states:\n #out1:\n #the gauge is a rectangle \n self.outgauge1 = self.make_rect(0,c33,0)\n #goal is red rectangle\n self.outgoal1= self.make_rect(c33,0,0)\n \n #out2:\n #the gauge is a rectangle \n self.outgauge2 = self.make_rect(0,c22,0)\n #goal is red rectangle\n self.outgoal2= self.make_rect(c22,0,0)\n\n #out3:\n #the gauge is a rectangle \n self.outgauge3 = self.make_rect(0,c11,0)\n #goal is red rectangle\n self.outgoal3 = self.make_rect(c11,0,0)\n\n #lines on which \"controls\" sit\n for l in range(n_sect): \n self.make_line(scalex*((l*2)+1),0, scalex*((l*2)+1),screen_height*world_bottom)\n\n # Line separating the top and bottom of the screen. \n self.make_line(0,world_bottom*screen_height,screen_width,world_bottom*screen_height)\n # Step # axis.\n self.make_line(scalex*1.5,axes_line1,screen_width-scalex*1,axes_line1)\n\n # The dot tracking the step #\n dot = rendering.make_circle(self.oval_length)\n self.dottrans = rendering.Transform()\n dot.add_attr(self.dottrans)\n dot.set_color(0,0,0)\n self.viewer.add_geom(dot)\n\n #labels: \n num = 0\n label_buff_y = 1.07\n label_buff_x = .2\n img_scale = .5\n img_wid = 179 *img_scale\n img_height = 124 * img_scale\n\n for label in self.labels:\n pth = (self.label_dir+label+'.png')\n self.txt = rendering.Image(pth,img_wid,img_height)\n locx = (num*2)+1\n self.txtis = rendering.Transform(translation=(scalex*locx +locx* label_buff_x,world_bottom*screen_height*label_buff_y))\n self.txt.add_attr(self.txtis)\n self.viewer.add_geom(self.txt)\n num = num+1\n\n #step label\n pth = (self.label_dir+'Step.png')\n self.txt = rendering.Image(pth,img_wid,img_height)\n self.txtis = rendering.Transform(translation=(scalex*.5,axes_line1))\n self.txt.add_attr(self.txtis)\n self.viewer.add_geom(self.txt)\n\n if self.state is None: return None\n\n x = self.state\n\n # 4 ins:\n self.flowtrans1.set_translation(move_oval+scalex*1,move_up+scaley_bottom*x[0])\n self.temptrans1.set_translation(move_oval+scalex*3,move_up+scaley_bottom*x[1])\n self.flowtrans2.set_translation(move_oval+scalex*5,move_up+scaley_bottom*x[2])\n self.temptrans2.set_translation(move_oval+scalex*7,move_up+scaley_bottom*x[3])\n\n # 3 outs: current & goal:\n self.outgauge1.set_translation(scalex*9,move_up+scaley_bottom*x[4])\n self.outgoal1.set_translation(scalex*9,move_up+scaley_bottom*x[7])\n self.outgauge2.set_translation(scalex*11,move_up+scaley_bottom*x[5])\n self.outgoal2.set_translation(scalex*11,move_up+scaley_bottom*x[8])\n self.outgauge3.set_translation(scalex*13,move_up+scaley_bottom*x[6])\n self.outgoal3.set_translation(scalex*13,move_up+scaley_bottom*x[9])\n\n #step info:\n self.dottrans.set_translation(scalex*1.5 + self.steps*scalestep, axes_line1)\n done_grow = .5*self.done\n self.dottrans.set_scale(1+done_grow,1+done_grow) #expand size when done\n\n return self.viewer.render(return_rgb_array = mode=='rgb_array')", "def reset(self):\n self._turtle.clear()\n self._turtle.setposition((0,0)) \n self._turtle.shape('turtle')\n self.color = 'red'\n self.heading = 180\n self.speed = 0", "def setDrawingMode(self):\n pass", "def render(self):\n self.axial.Render()\n self.coronal.Render()\n self.sagittal.Render()\n #self.isosurface.Render()\n #self.rwi_pcp.Render()", "def render(self):\n\t\tself._getSize()\n\t\tself.screen.clear()\n\t\tif self.width < 60 or self.height < 20:\n\t\t\tself.wts(1, 1, \"Windows too small to render!\" , 1)\n\t\telse:\n\t\t\t# check if resized\n\t\t\tif curses.is_term_resized(self.height, self.width):\n\t\t\t\tcurses.resizeterm(self.height, self.width)\n\t\t\t\tself._getSize()\n\t\t\t# render border\n\t\t\tif self.screenBorder:\n\t\t\t\tself.drawBorder()\n\t\t\t# render lines\n\t\t\tself.drawLines()\n\t\t\t# render status\n\t\t\tself.wts(self.height - 1, 1, self.status , 1)\n\t\t\t# render objects\n\t\t\tself.drawObjects(self.objects)\n\t\t\t# render menus\n\t\t\tself.drawObjects(self.menus)\n\t\tself.screen.refresh()", "def draw_long_shape():\n turtle.fillcolor('blue')\n draw_block()\n turtle.forward(50)\n draw_block()\n turtle.forward(50)\n draw_block()\n turtle.forward(50)\n draw_block()\n turtle.back(150)", "def __init__(self, _pendown=1, gridmode=False, gridsize=50, homeX = 50 + 25 + 5, homeY = 50 + 25 + 5, canvWidth = 400, canvHeight = 200, \\\n turtleMainColor=\"#00A651\", turtleAccentColor=\"#FFF600\", speed = 5, rotspeed = 5, pencolor = 'red', penwidth=3):\n self._turtleMainColor = turtleMainColor\n self._turtleAccentColor = turtleAccentColor\n self._speed = speed\n self._rotspeed = rotspeed\n self._pendown = _pendown\n self._pencolor = pencolor\n self._penwidth = penwidth\n self._rotation = 90\n self._gridsize = gridsize\n self._gridmode = gridmode\n \n if(gridmode and homeX == 80):\n homeX = 0\n homeY = 0\n \n self._x = homeX\n self._y = homeY\n self._homeX = homeX\n self._homeY = homeY\n \n self._canvWidth = canvWidth\n self._canvHeight = canvHeight\n self._actions = []\n self._levelDataString = [] \n \n self._walls = []\n self._lava = []\n \n self._appendCurrentState();", "def setUp(self):\n self.screentype_patcher = mock.patch(\n 'turtle._Screen',\n new=mock.Mock\n )\n self.mock_screentype = self.screentype_patcher.start()\n\n self.screen_patcher = mock.patch('turtle.Turtle._screen')\n self.mock_screen = self.screen_patcher.start()\n self.mock_screen.xscale = 1.0\n self.mock_screen.yscale = 1.0\n self.mock_screen.mode.return_value = 'standard'\n\n\n self.update_patcher = mock.patch(\n 'aioturtle.aioturtle.AioBaseTurtle._update_graphics'\n )\n self.mock_update = self.update_patcher.start()", "def draw_shape(self, r=0, g=0, b=0): # black is the default color\r\n turtles= turtle.Turtle()\r\n turtles.speed(0) # Makes the turtle speed up\r\n turtles.color(r, g, b)\r\n turtles.showturtle()\r\n turtles.penup()\r\n turtles.pendown()\r\n\r\n # draws the Shape to the screen\r\n\r\n for i in range(self.num_sides):\r\n turtles.forward(self.side_length)\r\n turtles.left(360/(self.num_sides))\r\n turtles.hideturtle()", "def render(self, screen) -> None:\n screen.fill(self.background_color)\n self.draw_center_circle(screen)\n self.draw_rectangle_field(screen)\n self.draw_defense_areas(screen)\n self.draw_field_divider(screen)\n self.draw_goals(screen)", "def render(self):\n draw.filled_rect(self.x, self.y, self.w, self.h, (0.0,0.0,0.0,1.))\n self._render_scrollbar(self.x, self.y + 1, self.w, 8)\n\n # render oscilloscope window edge\n gl.glPushMatrix()\n gl.glTranslatef(.5,.5,0.)\n gl.glLineWidth(1.)\n draw.rect(self.x, self.y, self.w, self.h, (0.6,0.6,0.6,1.))\n gl.glPopMatrix()\n\n gl.glPushMatrix()\n x, y, w, h = self._raw_graph_window_dim()\n xx, yy = self.parent.gl_coordinates(x, y)\n gl.glScissor(int(xx), int(yy - h), int(w), int(h))\n gl.glEnable(gl.GL_SCISSOR_TEST)\n #print \"sy1 %.2f sy2 %.2f sy2 - sy1 %.2f\" % (self.sy1, self.sy2, self.sy2 - self.sy1)\n self.graph_renderer.render(x, y, w, h, self.sx1, self.sy1, self.sx2 - self.sx1, self.sy2 - self.sy1)\n gl.glDisable(gl.GL_SCISSOR_TEST)\n gl.glPopMatrix()\n\n if self.render_legend:\n x, y = self.render_legend_pos\n self._render_legend(self.x + x, self.y + y)", "def reset(self):\n self._turtle.clear()\n self._turtle.setposition((0,0)) \n try:\n self._turtle.shape('pen.gif')\n except:\n self._turtle.shape('classic')\n self._turtle.color('red')\n self.speed = 0\n \n #pair = self._turtle.color()\n self._pencolor = self._turtle.color()[0]\n self._fillcolor = self._turtle.color()[0]", "def _setup(self, width=turtle._CFG[\"width\"], height=turtle._CFG[\"height\"],\n startx=turtle._CFG[\"leftright\"], starty=turtle._CFG[\"topbottom\"]):\n if not hasattr(self._root, \"set_geometry\"):\n return\n \n sw = self._root.win_width()\n sh = self._root.win_height()\n if isinstance(width, float) and 0 <= width <= 1:\n width = sw*width\n if startx is None:\n startx = (sw - width) / 2\n if isinstance(height, float) and 0 <= height <= 1:\n height = sh*height\n if starty is None:\n starty = (sh - height) / 2\n self._root.set_geometry(width, height, startx, starty)\n self.update()", "def draw(self, shape):\n shape.draw(shader=self.shader)", "def create_rink():\n\n # RINK\n coords = OFFSET, OFFSET, OFFSET+22*SCALE, OFFSET+22*SCALE\n canvas.create_arc(coords, start=90, extent=90, fill=WHITE, outline=\"\")\n coords = OFFSET, HEIGHT-OFFSET-22*SCALE, OFFSET+22*SCALE, HEIGHT-OFFSET\n canvas.create_arc(coords, start=180, extent=90, fill=WHITE, outline=WHITE)\n coords = WIDTH-OFFSET-22*SCALE, HEIGHT-OFFSET-22*SCALE, WIDTH-OFFSET, HEIGHT-OFFSET\n canvas.create_arc(coords, start=270, extent=90, fill=WHITE, outline=WHITE)\n coords = WIDTH-OFFSET-22*SCALE, OFFSET, WIDTH-OFFSET, OFFSET+22*SCALE\n canvas.create_arc(coords, start=0, extent=90, fill=WHITE, outline=WHITE)\n coords = OFFSET+11*SCALE, OFFSET, WIDTH-OFFSET-11*SCALE, OFFSET, WIDTH-OFFSET-11*SCALE, HEIGHT-OFFSET, OFFSET+11*SCALE, HEIGHT-OFFSET\n canvas.create_polygon(coords, fill=WHITE, outline=WHITE)\n coords = OFFSET, OFFSET+11*SCALE, WIDTH-OFFSET, OFFSET+11*SCALE, WIDTH-OFFSET, HEIGHT-OFFSET-11*SCALE, OFFSET, HEIGHT-OFFSET-11*SCALE\n canvas.create_polygon(coords, fill=WHITE, outline=WHITE)\n\n # CENTER CIRCLE\n coords = WIDTH/2-15*SCALE, HEIGHT/2-15*SCALE, WIDTH/2+15*SCALE, HEIGHT/2+15*SCALE\n canvas.create_oval(coords, outline=BLUE, width=2, fill=WHITE)\n\n # HALF CENTER CIRCLE\n coords = WIDTH/2-10*SCALE, HEIGHT-OFFSET-10*SCALE, WIDTH/2+10*SCALE, HEIGHT-OFFSET+10*SCALE\n canvas.create_arc(coords, outline=RED, width=2, start=0, extent=180)\n\n # GOAL AREA\n # - Left\n # - - Crease\n coords = OFFSET+5*SCALE, HEIGHT/2-6*SCALE, OFFSET+17*SCALE, HEIGHT/2+6*SCALE\n canvas.create_arc(coords, fill=LIGHT_BLUE, start=318, extent=84, outline=\"\")\n canvas.create_arc(coords, outline=RED, start=318, extent=84, style=ARC)\n coords = OFFSET+11*SCALE, HEIGHT/2-4*SCALE, OFFSET+15.5*SCALE, HEIGHT/2-4*SCALE, OFFSET+15.5*SCALE, HEIGHT/2+4*SCALE, OFFSET+11*SCALE, HEIGHT/2+4*SCALE\n canvas.create_polygon(coords, fill=LIGHT_BLUE, outline=\"\")\n coords = OFFSET+11*SCALE, HEIGHT/2-4*SCALE, OFFSET+15.2*SCALE+1, HEIGHT/2-4*SCALE\n canvas.create_line(coords, fill=RED)\n coords = OFFSET+15.2*SCALE+1, HEIGHT/2+4*SCALE, OFFSET+11*SCALE, HEIGHT/2+4*SCALE\n canvas.create_line(coords, fill=RED)\n # - - Restricted Area\n coords = OFFSET, HEIGHT/2-14*SCALE, OFFSET+11*SCALE, HEIGHT/2-9*SCALE\n canvas.create_line(coords, fill=RED)\n coords = OFFSET, HEIGHT/2+14*SCALE, OFFSET+11*SCALE, HEIGHT/2+9*SCALE\n canvas.create_line(coords, fill=RED)\n # - - Goal\n coords = OFFSET+8*SCALE, HEIGHT/2-3*SCALE, OFFSET+11*SCALE, HEIGHT/2-3*SCALE, OFFSET+11*SCALE, HEIGHT/2+3*SCALE, OFFSET+8*SCALE, HEIGHT/2+3*SCALE\n canvas.create_polygon(coords, fill=GRAY, outline=RED)\n # - Right\n # - - Crease\n coords = WIDTH-(OFFSET+5*SCALE), HEIGHT/2-6*SCALE, WIDTH-(OFFSET+17*SCALE), HEIGHT/2+6*SCALE\n canvas.create_arc(coords, fill=LIGHT_BLUE, start=138, extent=84, outline=\"\")\n canvas.create_arc(coords, outline=RED, start=138, extent=84, style=ARC)\n coords = WIDTH-(OFFSET+11*SCALE), HEIGHT/2-4*SCALE, WIDTH-(OFFSET+15.5*SCALE), HEIGHT/2-4*SCALE, WIDTH-(OFFSET+15.5*SCALE), HEIGHT/2+4*SCALE, WIDTH-(OFFSET+11*SCALE), HEIGHT/2+4*SCALE\n canvas.create_polygon(coords, fill=LIGHT_BLUE, outline=\"\")\n coords = WIDTH-(OFFSET+11*SCALE), HEIGHT/2-4*SCALE, WIDTH-(OFFSET+15.2*SCALE+1), HEIGHT/2-4*SCALE\n canvas.create_line(coords, fill=RED)\n coords = WIDTH-(OFFSET+15.2*SCALE+1), HEIGHT/2+4*SCALE, WIDTH-(OFFSET+11*SCALE), HEIGHT/2+4*SCALE\n canvas.create_line(coords, fill=RED)\n # - - Restricted Area\n coords = WIDTH-OFFSET, HEIGHT/2-14*SCALE, WIDTH-OFFSET-11*SCALE, HEIGHT/2-9*SCALE\n canvas.create_line(coords, fill=RED)\n coords = WIDTH-OFFSET, HEIGHT/2+14*SCALE, WIDTH-OFFSET-11*SCALE, HEIGHT/2+9*SCALE\n canvas.create_line(coords, fill=RED)\n # - - Goal\n coords = WIDTH-(OFFSET+8*SCALE), HEIGHT/2-3*SCALE, WIDTH-(OFFSET+11*SCALE), HEIGHT/2-3*SCALE, WIDTH-(OFFSET+11*SCALE), HEIGHT/2+3*SCALE, WIDTH-(OFFSET+8*SCALE), HEIGHT/2+3*SCALE\n canvas.create_polygon(coords, fill=GRAY, outline=RED)\n\n # LINES\n # - Left Baseline\n coords = OFFSET+11*SCALE, OFFSET, OFFSET+11*SCALE, HEIGHT-OFFSET\n canvas.create_line(coords, fill=RED, width=1.5)\n # - Right Baseline\n coords = WIDTH-OFFSET-11*SCALE, OFFSET, WIDTH-OFFSET-11*SCALE, HEIGHT-OFFSET\n canvas.create_line(coords, fill=RED, width=1.5)\n # - Left Blueline\n coords = OFFSET+70*SCALE, OFFSET, OFFSET+70*SCALE, HEIGHT-OFFSET\n canvas.create_line(coords, fill=BLUE, width=7)\n # - Right Blueline\n coords = WIDTH-(OFFSET+70*SCALE), OFFSET, WIDTH-(OFFSET+70*SCALE), HEIGHT-OFFSET\n canvas.create_line(coords, fill=BLUE, width=7)\n # - Redline\n coords = WIDTH/2, OFFSET, WIDTH/2, HEIGHT-OFFSET\n canvas.create_line(coords, fill=RED, width=7)\n coords = WIDTH/2, OFFSET, WIDTH/2, HEIGHT-OFFSET\n canvas.create_line(coords, fill=WHITE, width=5, dash=(9,9))\n\n # RINK OUTLINE\n coords = OFFSET, OFFSET, OFFSET+22*SCALE, OFFSET+22*SCALE\n canvas.create_arc(coords, start=90, extent=90, outline=BLACK, style=ARC, width=2)\n coords = OFFSET, HEIGHT-OFFSET-22*SCALE, OFFSET+22*SCALE, HEIGHT-OFFSET\n canvas.create_arc(coords, start=180, extent=90, outline=BLACK, style=ARC, width=2)\n coords = WIDTH-OFFSET-22*SCALE, HEIGHT-OFFSET-22*SCALE, WIDTH-OFFSET, HEIGHT-OFFSET\n canvas.create_arc(coords, start=270, extent=90, outline=BLACK, style=ARC, width=2)\n coords = WIDTH-OFFSET-22*SCALE, OFFSET, WIDTH-OFFSET, OFFSET+22*SCALE\n canvas.create_arc(coords, start=0, extent=90, outline=BLACK, style=ARC, width=2)\n coords = OFFSET+11*SCALE, OFFSET, WIDTH-OFFSET-11*SCALE, OFFSET\n canvas.create_line(coords, fill=BLACK, width=2)\n coords = WIDTH-OFFSET, OFFSET+11*SCALE, WIDTH-OFFSET, HEIGHT-OFFSET-11*SCALE\n canvas.create_line(coords, fill=BLACK, width=2)\n coords = WIDTH-OFFSET-11*SCALE, HEIGHT-OFFSET, OFFSET+11*SCALE, HEIGHT-OFFSET\n canvas.create_line(coords, fill=BLACK, width=2)\n coords = OFFSET, OFFSET+11*SCALE, OFFSET, HEIGHT-OFFSET-11*SCALE\n canvas.create_line(coords, fill=BLACK, width=2)\n\n\n # CENTER DOT\n coords = WIDTH/2-1*SCALE-1, HEIGHT/2-1*SCALE-1, WIDTH/2+1*SCALE+1, HEIGHT/2+1*SCALE+1\n canvas.create_oval(coords, outline=WHITE, fill=BLUE)\n\n # FACEOFF\n # - Top Left\n # - - Ticks\n coords = OFFSET+29.5*SCALE, HEIGHT/2-39*SCALE, OFFSET+29.5*SCALE, HEIGHT/2-5*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = OFFSET+32.5*SCALE, HEIGHT/2-39*SCALE, OFFSET+32.5*SCALE, HEIGHT/2-5*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n # - - Circles\n coords = OFFSET+16*SCALE, HEIGHT/2-37*SCALE, OFFSET+46*SCALE, HEIGHT/2-7*SCALE\n canvas.create_oval(coords, outline=RED, width=2, fill=WHITE)\n coords = OFFSET+30*SCALE, HEIGHT/2-23*SCALE, OFFSET+32*SCALE, HEIGHT/2-21*SCALE\n canvas.create_oval(coords, fill=RED, outline=\"\")\n # - - Cross\n coords = OFFSET+25*SCALE, HEIGHT/2-22.8*SCALE, OFFSET+29*SCALE, HEIGHT/2-22.8*SCALE, OFFSET+29*SCALE, HEIGHT/2-25.8*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = OFFSET+25*SCALE, HEIGHT/2-21.2*SCALE, OFFSET+29*SCALE, HEIGHT/2-21.2*SCALE, OFFSET+29*SCALE, HEIGHT/2-18.2*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = OFFSET+37*SCALE, HEIGHT/2-22.8*SCALE, OFFSET+33*SCALE, HEIGHT/2-22.8*SCALE, OFFSET+33*SCALE, HEIGHT/2-25.8*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = OFFSET+37*SCALE, HEIGHT/2-21.2*SCALE, OFFSET+33*SCALE, HEIGHT/2-21.2*SCALE, OFFSET+33*SCALE, HEIGHT/2-18.2*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n # - Bottom Left\n # - - Ticks\n coords = OFFSET+29.5*SCALE, HEIGHT/2+39*SCALE, OFFSET+29.5*SCALE, HEIGHT/2+5*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = OFFSET+32.5*SCALE, HEIGHT/2+39*SCALE, OFFSET+32.5*SCALE, HEIGHT/2+5*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n # - - Circles\n coords = OFFSET+16*SCALE, HEIGHT/2+37*SCALE, OFFSET+46*SCALE, HEIGHT/2+7*SCALE\n canvas.create_oval(coords, outline=RED, width=2, fill=WHITE)\n coords = OFFSET+30*SCALE, HEIGHT/2+23*SCALE, OFFSET+32*SCALE, HEIGHT/2+21*SCALE\n canvas.create_oval(coords, fill=RED, outline=\"\")\n # - - Cross\n coords = OFFSET+25*SCALE, HEIGHT/2+22.8*SCALE, OFFSET+29*SCALE, HEIGHT/2+22.8*SCALE, OFFSET+29*SCALE, HEIGHT/2+25.8*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = OFFSET+25*SCALE, HEIGHT/2+21.2*SCALE, OFFSET+29*SCALE, HEIGHT/2+21.2*SCALE, OFFSET+29*SCALE, HEIGHT/2+18.2*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = OFFSET+37*SCALE, HEIGHT/2+22.8*SCALE, OFFSET+33*SCALE, HEIGHT/2+22.8*SCALE, OFFSET+33*SCALE, HEIGHT/2+25.8*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = OFFSET+37*SCALE, HEIGHT/2+21.2*SCALE, OFFSET+33*SCALE, HEIGHT/2+21.2*SCALE, OFFSET+33*SCALE, HEIGHT/2+18.2*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n # - Top Right\n # - - Ticks\n coords = WIDTH-(OFFSET+29.5*SCALE), HEIGHT/2-39*SCALE, WIDTH-(OFFSET+29.5*SCALE), HEIGHT/2-5*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = WIDTH-(OFFSET+32.5*SCALE), HEIGHT/2-39*SCALE, WIDTH-(OFFSET+32.5*SCALE), HEIGHT/2-5*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n # - - Circles\n coords = WIDTH-(OFFSET+16*SCALE), HEIGHT/2-37*SCALE, WIDTH-(OFFSET+46*SCALE), HEIGHT/2-7*SCALE\n canvas.create_oval(coords, outline=RED, width=2, fill=WHITE)\n coords = WIDTH-(OFFSET+30*SCALE), HEIGHT/2-23*SCALE, WIDTH-(OFFSET+32*SCALE), HEIGHT/2-21*SCALE\n canvas.create_oval(coords, fill=RED, outline=\"\")\n # - - Cross\n coords = WIDTH-(OFFSET+25*SCALE), HEIGHT/2-22.8*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2-22.8*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2-25.8*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = WIDTH-(OFFSET+25*SCALE), HEIGHT/2-21.2*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2-21.2*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2-18.2*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = WIDTH-(OFFSET+37*SCALE), HEIGHT/2-22.8*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2-22.8*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2-25.8*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = WIDTH-(OFFSET+37*SCALE), HEIGHT/2-21.2*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2-21.2*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2-18.2*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n # - Bottom Right\n # - - Ticks\n coords = WIDTH-(OFFSET+29.5*SCALE), HEIGHT/2+39*SCALE, WIDTH-(OFFSET+29.5*SCALE), HEIGHT/2+5*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = WIDTH-(OFFSET+32.5*SCALE), HEIGHT/2+39*SCALE, WIDTH-(OFFSET+32.5*SCALE), HEIGHT/2+5*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n # - - Circles\n coords = WIDTH-(OFFSET+16*SCALE), HEIGHT/2+37*SCALE, WIDTH-(OFFSET+46*SCALE), HEIGHT/2+7*SCALE\n canvas.create_oval(coords, outline=RED, width=2, fill=WHITE)\n coords = WIDTH-(OFFSET+30*SCALE), HEIGHT/2+23*SCALE, WIDTH-(OFFSET+32*SCALE), HEIGHT/2+21*SCALE\n canvas.create_oval(coords, fill=RED, outline=\"\")\n # - - Cross\n coords = WIDTH-(OFFSET+25*SCALE), HEIGHT/2+22.8*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2+22.8*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2+25.8*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = WIDTH-(OFFSET+25*SCALE), HEIGHT/2+21.2*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2+21.2*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2+18.2*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = WIDTH-(OFFSET+37*SCALE), HEIGHT/2+22.8*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2+22.8*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2+25.8*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = WIDTH-(OFFSET+37*SCALE), HEIGHT/2+21.2*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2+21.2*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2+18.2*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n\n # NEUTRAL ZONE FACEOFF\n # - Top Left\n coords = WIDTH/2-21*SCALE, HEIGHT/2-23*SCALE, WIDTH/2-19*SCALE, HEIGHT/2-21*SCALE\n canvas.create_oval(coords, outline=\"\", fill=RED)\n # - Bottom Left\n coords = WIDTH/2-21*SCALE, HEIGHT/2+23*SCALE, WIDTH/2-19*SCALE, HEIGHT/2+21*SCALE\n canvas.create_oval(coords, outline=\"\", fill=RED)\n # - Top Right\n coords = WIDTH/2+21*SCALE, HEIGHT/2-23*SCALE, WIDTH/2+19*SCALE, HEIGHT/2-21*SCALE\n canvas.create_oval(coords, outline=\"\", fill=RED)\n # - Bottom Right\n coords = WIDTH/2+21*SCALE, HEIGHT/2+23*SCALE, WIDTH/2+19*SCALE, HEIGHT/2+21*SCALE\n canvas.create_oval(coords, outline=\"\", fill=RED)\n\n\n canvas.grid(row=1, columnspan=5)", "def flush(self):\n if self.fill:\n self._turtle.fill(False)\n self._turtle.fill(True)", "def paint(self):\r\n pass", "def __display(self):\n self.__rotate_model()\n self.__generate_shadows()\n self.__generate_model()\n\n glutSwapBuffers()\n if self.__callback is not None:\n self.__callback()", "def draw():\n recursion_depth = self.get_recursion_depth()\n base_length = self.get_base_length()\n self.parent_class.classes[\"fractal\"].set_base_length(base_length)\n is_curved = self.vars[\"round_corners\"].get()\n fill_color = self.vars[\"fill_color\"].get()\n self.parent_class.classes[\"fractal\"].draw_fractal(\n recursion_depth, is_curved, fill_color)", "def _set_frame_shape(self) -> None:\n width, height = self.GetSize()\n self.SetShape(wx.Region(_get_round_edges_bitmap(width, height, 10)))", "def _set_frame_shape(self) -> None:\n width, height = self.GetSize()\n self.SetShape(wx.Region(_get_round_edges_bitmap(width, height, 10)))", "def initialize(turtle_shape, bg_color, turtle_color, turtle_speed):\n turtle_instance = turtle.Turtle()\n turtle_instance.shape(turtle_shape)\n turtle.bgcolor(bg_color)\n turtle_instance.color(turtle_color)\n turtle_instance.speed(turtle_speed)\n return turtle_instance", "def settle_falilng_shape(self):\n if self.falling_shape:\n self._settle_shape(self.falling_shape)\n self.falling_shape = None\n self.new_shape()", "def __init__(self, level, treasures, maze_size):\n turtle.Turtle.__init__(self)\n self.shape(\"player_right.gif\")\n self.color(\"blue\")\n self.penup()\n self.pensize(1)\n self.speed(0)\n self.score = 0\n self.level = level\n self.treasures = treasures\n self.maze_size = maze_size\n self.end_writer = writers.EndWriter(maze_size)\n\n turtle.Screen().onkey(self.go_left, \"Left\")\n turtle.Screen().onkey(self.go_right, \"Right\")\n turtle.Screen().onkey(self.go_up, \"Up\")\n turtle.Screen().onkey(self.go_down, \"Down\")\n turtle.Screen().onkey(self.find_path, \"f\")", "def cool_turtle():\n # Make the TurtleWindow.\n window = rg.TurtleWindow()\n\n # Make the SimpleTurtle.\n cool_turtle = rg.SimpleTurtle('turtle')\n cool_turtle.pen = rg.Pen('forest green', 1) # Try thickness 5 too\n cool_turtle.speed = 1 # Slow\n\n # Move the SimpleTurtle to her starting position.\n start_at = rg.Point(100, -50)\n cool_turtle.pen_up()\n cool_turtle.go_to(start_at)\n cool_turtle.pen_down()\n\n # Set up some parameters that control the nature of the shape drawn.\n size = 100 # Try 150 too\n angle = 1 # Try 20 too\n iterations = 360 # Try 90 too\n\n # Store the animation speed (to reset it later).\n tracer_n, tracer_d = window.tracer(), window.delay()\n\n # Make the animation go much faster.\n # First number: bigger means faster.\n # Second number: bigger means slower.\n window.tracer(5, 5)\n\n for _ in range(iterations):\n cool_turtle.right(angle)\n cool_turtle.draw_square(size)\n\n # Reset the animation to its original speed.\n window.tracer(tracer_n, tracer_d)\n\n window.close_on_mouse_click()", "def decorate(self):\n\n c = self.canvas\n c.rect(20, 20, 20, 20, fill=1) # bt lf\n c.rect(self.width - 40, 20, 20, 20, fill=1) # bt rt\n c.rect(20, self.height - 40, 20, 20, fill=1) # tp lf\n c.rect(self.width/2 - 10, 20, 20, 20, fill=1) # bt md\n c.rect(20, self.height/2 - 10, 20, 20, fill=1) # md lf\n c.rect(self.width - 40, self.height - 40, 20, 20, fill=1) # tp rt\n c.rect(self.width - 40, self.height/2 - 10, 20, 20, fill=1) # md rt", "def setup_draw(self):\n pass" ]

[ "0.6403576", "0.5803147", "0.5757534", "0.57560647", "0.57122225", "0.5616213", "0.5585007", "0.55566514", "0.549937", "0.54844797", "0.5455318", "0.5445823", "0.544214", "0.53811437", "0.53739995", "0.53730935", "0.5357551", "0.5353902", "0.53484035", "0.53455514", "0.53418976", "0.53329974", "0.53193295", "0.53193295", "0.5316049", "0.529295", "0.52686137", "0.5267409", "0.5263313", "0.5258058" ]

[ "def shape_id(self):\n return self._shape_id", "def shape(self, name=None):\n if name is None:\n return self.Myturtle.shapeIndex\n if not name in self.screen.getshapes():\n raise TurtleGraphicsError(\"There is no shape named %s\" % name)\n self.Myturtle._setshape(name)\n self._update()", "def update_counter(cls, value):\n SFFShape.shape_id = value", "def getId(self):\n return _libsbml.Point_getId(self)", "def draw(self, shape):\n shape.draw(shader=self.shader)", "def _identify_target(self):\n \n # change the cursor for the drawing area\n x_cursor = gtk.gdk.Cursor(gtk.gdk.X_CURSOR)\n self.drawing_area.window.set_cursor(x_cursor)\n \n # set the drawing area mode\n self.drawing_area_mode = \"IDENTIFY_TARGET\"\n \n #clear the screen\n if self.box_drawn == True:\n self.redraw_current_image()", "def _create_unique_turtle_name(self):\n\n\t\tself._id_counter += 1\n\t\tnew_name = \"turtle{}\".format(self._id_counter)\n\n\t\tif self._has_turtle(new_name):\n\t\t\treturn self._create_unique_turtle_name()\n\n\t\treturn new_name", "def _spawn_turtle(self, trt_x, trt_y, name=None):\n\n\t\tif name is None or name == \"\":\n\t\t\tname = self._create_unique_turtle_name()\n\t\telif self._has_turtle(name):\n\t\t\treturn \"\"\n\n\t\tturtle = Turtle(name, Point(trt_x, trt_y))\n\t\tself._turtles[name] = turtle\n\n\t\trospy.loginfo(\"New turtle [%s] at x=[%d], y=[%d]\", name, trt_x, trt_y)\n\n\t\treturn name", "def draw(hyp):\r\n print 'g.createShape(',hyp.getAttList(),')'\r\n print type(hyp.getAttList())\r\n g.createShape(hyp.getAttList())", "def _drawturtle(self):\n screen = self.screen\n shape = screen._shapes[self.Myturtle.shapeIndex]\n ttype = shape._type\n titem = self.Myturtle._item\n if self._shown and screen._updatecounter == 0 and screen._tracing > 0:\n self._hidden_from_screen = False\n tshape = shape._data\n if ttype == \"polygon\":\n if self._resizemode == \"noresize\": w = 1\n elif self._resizemode == \"auto\": w = self._pensize\n else: w =self._outlinewidth\n shape = self._polytrafo(self._getshapepoly(tshape))\n fc, oc = self._fillcolor, self._pencolor\n screen._drawpoly(titem, shape, fill=fc, outline=oc,\n width=w, top=True)\n elif ttype == \"image\":\n screen._drawimage(titem, self._position, tshape)\n elif ttype == \"compound\":\n for item, (poly, fc, oc) in zip(titem, tshape):\n poly = self._polytrafo(self._getshapepoly(poly, True))\n screen._drawpoly(item, poly, fill=self._cc(fc),\n outline=self._cc(oc), width=self._outlinewidth, top=True)\n else:\n if self._hidden_from_screen:\n return\n if ttype == \"polygon\":\n screen._drawpoly(titem, ((0, 0), (0, 0), (0, 0)), \"\", \"\")\n elif ttype == \"image\":\n screen._drawimage(titem, self._position,\n screen._shapes[\"blank\"]._data)\n elif ttype == \"compound\":\n for item in titem:\n screen._drawpoly(item, ((0, 0), (0, 0), (0, 0)), \"\", \"\")\n self._hidden_from_screen = True", "def _create_random_tetrino(self):\n shape_index = randrange(constant.NUM_SHAPES)\n shape = constant.SHAPES[shape_index]\n shape_locations = self.translate_shape(shape[0], 0, 0)\n num_blocks = len(shape_locations)\n location = self._create_random_offsets(shape_locations)\n new_tetrino = Tetrino(location, shape_index, \\\n num_blocks, self.tetrino_id, self.game_size)\n self.tetrino_set[self.tetrino_id] = new_tetrino\n self.tetrino_id += 1\n return new_tetrino", "def draw(hyp):\n print 'g.createShape(',hyp.getAttList(),')'\n print type(hyp.getAttList())\n g.createShape(hyp.getAttList())", "def shape(self) -> Shape:", "def create_duplicate(shape, duplicate_name):\n\n logger.debug(\"Creating shape duplicate for {}\".format(shape))\n shape_holder = cmds.createNode(cmds.objectType(shape),\n name=\"{}Shape\".format(duplicate_name))\n cmds.rename(shape_holder, \"{}\".format(shape_holder))\n update_shape(shape, shape_holder)\n\n return shape_holder", "def clone(self):\n screen = self.screen\n self._newLine(self._drawing)\n\n Myturtle = self.Myturtle\n self.screen = None\n self.Myturtle = None # too make self deepcopy-able\n\n q = deepcopy(self)\n\n self.screen = screen\n self.Myturtle = Myturtle\n\n q.screen = screen\n q.Myturtle = _TurtleImage(screen, self.Myturtle.shapeIndex)\n\n screen._turtles.append(q)\n ttype = screen._shapes[self.Myturtle.shapeIndex]._type\n if ttype == \"polygon\":\n q.Myturtle._item = screen._createpoly()\n elif ttype == \"image\":\n q.Myturtle._item = screen._createimage(screen._shapes[\"blank\"]._data)\n elif ttype == \"compound\":\n q.Myturtle._item = [screen._createpoly() for item in\n screen._shapes[self.Myturtle.shapeIndex]._data]\n q.currentLineItem = screen._createline()\n q._update()\n return q", "def new_shape(self):\n if self.current_shape is not None and not self.current_shape:\n return self.current_shape\n else:\n shape = Shape()\n self.shapes.append(shape)\n self.current_shape = shape\n return shape", "def draw_target():\n\n t = turtle\n t.up()\n t.goto(-target[SIZE], -target[SIZE])\n t.setheading(0)\n t.pensize(2)\n t.down()\n for side in range(4):\n t.fd(target[SIZE] * 2)\n t.left(90)", "def _position_to_id(self, x, y):\n return x + y * self.n", "def create_new_text(self, *args, **kw):\n shape_id = self._create('text', args, kw)\n self.variables.shape_ids.append(shape_id)\n canvas_coords = args[0]\n self.variables.vector_objects[str(shape_id)] = VectorObject(SHAPE_TYPES.TEXT, None)\n self.variables.shape_ids.append(shape_id)\n self.set_shape_pixel_coords_from_canvas_coords(shape_id, canvas_coords)\n self.variables.current_shape_id = shape_id\n return shape_id", "def object_id(o):\n return id(o)", "def shape_ref(self):\n return self._shape_ref", "def shape(self):\n return self.active.shape", "def callback_handle_left_mouse_click(self, event):\n\n if self.variables.active_tool == TOOLS.PAN_TOOL:\n self.variables.pan_anchor_point_xy = event.x, event.y\n self.variables.tmp_anchor_point = event.x, event.y\n elif self.variables.active_tool == TOOLS.TRANSLATE_SHAPE_TOOL:\n self.variables.tmp_anchor_point = event.x, event.y\n elif self.variables.active_tool == TOOLS.EDIT_SHAPE_COORDS_TOOL:\n closest_coord_index = self.find_closest_shape_coord(self.variables.current_shape_id, event.x, event.y)\n self.variables.tmp_closest_coord_index = closest_coord_index\n elif self.variables.active_tool == TOOLS.SELECT_CLOSEST_SHAPE_TOOL:\n closest_shape_id = self.find_closest_shape(event.x, event.y)\n self.variables.current_shape_id = closest_shape_id\n self.highlight_existing_shape(self.variables.current_shape_id)\n else:\n start_x = self.canvasx(event.x)\n start_y = self.canvasy(event.y)\n\n self.variables.current_shape_canvas_anchor_point_xy = (start_x, start_y)\n if self.variables.current_shape_id not in self.variables.shape_ids:\n coords = (start_x, start_y, start_x + 1, start_y + 1)\n if self.variables.active_tool == TOOLS.DRAW_LINE_BY_DRAGGING:\n self.create_new_line(coords)\n elif self.variables.active_tool == TOOLS.DRAW_LINE_BY_CLICKING:\n self.create_new_line(coords)\n self.variables.actively_drawing_shape = True\n elif self.variables.active_tool == TOOLS.DRAW_ARROW_BY_DRAGGING:\n self.create_new_arrow(coords)\n elif self.variables.active_tool == TOOLS.DRAW_ARROW_BY_CLICKING:\n self.create_new_arrow(coords)\n self.variables.actively_drawing_shape = True\n elif self.variables.active_tool == TOOLS.DRAW_RECT_BY_DRAGGING:\n self.create_new_rect(coords)\n elif self.variables.active_tool == TOOLS.DRAW_RECT_BY_CLICKING:\n self.create_new_rect(coords)\n self.variables.actively_drawing_shape = True\n elif self.variables.active_tool == TOOLS.DRAW_ELLIPSE_BY_DRAGGING:\n self.create_new_ellipse(coords)\n elif self.variables.active_tool == TOOLS.DRAW_POINT_BY_CLICKING:\n self.create_new_point((start_x, start_y))\n elif self.variables.active_tool == TOOLS.DRAW_POLYGON_BY_CLICKING:\n self.create_new_polygon(coords)\n self.variables.actively_drawing_shape = True\n else:\n print(\"no tool selected\")\n else:\n if self.variables.current_shape_id in self.variables.shape_ids:\n vector_object = self.get_vector_object(self.variables.current_shape_id)\n if vector_object.type == SHAPE_TYPES.POINT:\n self.modify_existing_shape_using_canvas_coords(self.variables.current_shape_id,\n (start_x, start_y))\n elif self.variables.active_tool == TOOLS.DRAW_LINE_BY_CLICKING:\n self.event_click_line(event)\n elif self.variables.active_tool == TOOLS.DRAW_ARROW_BY_CLICKING:\n self.event_click_line(event)\n elif self.variables.active_tool == TOOLS.DRAW_POLYGON_BY_CLICKING:\n self.event_click_polygon(event)\n elif self.variables.active_tool == TOOLS.DRAW_RECT_BY_CLICKING:\n if self.variables.actively_drawing_shape:\n self.variables.actively_drawing_shape = False\n else:\n self.variables.actively_drawing_shape = True", "def shape(self):", "def shape(self):", "def setTurtle(t):\r\n t.pu()\r\n t.goto(initialCoordinates())", "def newID(plot, height, x):\n\n new_id = str(plot) + '_' + str(height) + '_' + str(x)\n\n return new_id", "def getSerpentId(self):\n raise NotImplementedError", "def _settle_shape(self, shape):\n if shape:\n for block in shape.blocks:\n self.array[block.row_position][block.column_position] = block\n self.remove_completed_lines()", "def event_click_line(self, event):\n event_x_pos = self.canvasx(event.x)\n event_y_pos = self.canvasy(event.y)\n if self.get_vector_object(self.variables.current_shape_id).image_drag_limits:\n drag_lims = self.get_vector_object(self.variables.current_shape_id).image_drag_limits\n canvas_lims = self.image_coords_to_canvas_coords(drag_lims)\n if event_x_pos < canvas_lims[0]:\n event_x_pos = canvas_lims[0]\n elif event_x_pos > canvas_lims[2]:\n event_x_pos = canvas_lims[2]\n if event_y_pos < canvas_lims[1]:\n event_y_pos = canvas_lims[1]\n elif event_y_pos > canvas_lims[3]:\n event_y_pos = canvas_lims[3]\n if self.variables.actively_drawing_shape:\n old_coords = self.get_shape_canvas_coords(self.variables.current_shape_id)\n new_coords = tuple(list(old_coords) + [event_x_pos, event_y_pos])\n self.modify_existing_shape_using_canvas_coords(self.variables.current_shape_id, new_coords)\n else:\n new_coords = (event_x_pos, event_y_pos, event_x_pos + 1, event_y_pos + 1)\n self.modify_existing_shape_using_canvas_coords(self.variables.current_shape_id, new_coords)\n self.variables.actively_drawing_shape = True" ]

[ "0.59545773", "0.5305236", "0.52509373", "0.51337767", "0.499248", "0.49788505", "0.4818722", "0.4803845", "0.47822112", "0.47462147", "0.47376835", "0.47128975", "0.46846437", "0.4662359", "0.46457627", "0.46033564", "0.45889434", "0.4588359", "0.4588201", "0.4573066", "0.45668957", "0.4563115", "0.45610854", "0.45566243", "0.45566243", "0.45525372", "0.45482984", "0.4528099", "0.45248246", "0.4519845" ]

[ "def _clearstamp(self, stampid):\n if stampid in self.stampItems:\n if isinstance(stampid, tuple):\n for subitem in stampid:\n self.screen._delete(subitem)\n else:\n self.screen._delete(stampid)\n self.stampItems.remove(stampid)\n # Delete stampitem from undobuffer if necessary\n # if clearstamp is called directly.\n item = (\"stamp\", stampid)\n buf = self.undobuffer\n if item not in buf.buffer:\n return\n index = buf.buffer.index(item)\n buf.buffer.remove(item)\n if index <= buf.ptr:\n buf.ptr = (buf.ptr - 1) % buf.bufsize\n buf.buffer.insert((buf.ptr+1)%buf.bufsize, [None])", "def delete(self, _id):", "def ts_delete(self, tsuid, raise_exception=True):\n\n # Checks inputs\n check_type(value=tsuid, allowed_types=str, var_name=\"tsuid\", raise_exception=True)\n\n response = self.send(root_url=self.session.dm_url + self.root_url,\n verb=GenericClient.VERB.DELETE,\n template=TEMPLATES['remove_ts'],\n uri_params={\n 'tsuid': tsuid\n })\n\n if response.status_code == 204:\n # Timeseries has been successfully deleted\n result = True\n elif response.status_code == 404:\n # Timeseries not found in database\n if raise_exception:\n raise IkatsNotFoundError(\"Timeseries %s not found in database\" % tsuid)\n result = False\n elif response.status_code == 409:\n # Timeseries linked to existing dataset\n if raise_exception:\n raise IkatsConflictError(\"%s belongs to -at least- one dataset\" % tsuid)\n result = False\n else:\n if raise_exception:\n raise SystemError(\"An unhandled error occurred\")\n result = False\n return result", "def delete_by_id(self, subject_id: str) -> any:\n pass", "def _delete_tell(conn, tell):\n cur = conn.cursor()\n cur.execute('DELETE FROM tells WHERE msg=? AND time=? AND seen_time=?', (tell[2], tell[3], tell[5]))\n conn.commit()\n db.ccache()", "def delete_timer(twitchid, id):\n\twith postgres, postgres.cursor() as cur:\n\t\tcur.execute(\"delete from mustard.timers where id=%s and twitchid=%s\",\n\t\t\t(id, twitchid))\n\t\tif not cur.rowcount: raise ValueError(\"Timer not found, or not owned by that user\")", "def remove_timestamp(file):\n delete = open(file, 'w')\n delete.write('')\n delete.close()", "def delete(thing, id_):\n pass", "def DeleteParticle(particle, fieldset, time):\n print('particle is deleted') \n #print(particle.lon, particle.lat, particle.depth)\n particle.delete()", "def delete_point(self, key, table):\n if table == 'checkpoints':\n column = 'checkpoint_id'\n elif table == 'traversed':\n column = 'traversed_id'\n else:\n table = 'waypoints'\n key = self.__compound_key(key)\n column = 'waypoint_id'\n\n sql = f'DELETE FROM {table} WHERE {column}=?'\n connection = self.__create_connection()\n cur = connection.cursor()\n cur.execute(sql, (key,))\n connection.commit()", "def delete(self, id):\n raise NotImplementedError", "def delete_tip(tip_id):\n mongo.db.tips.remove({\"_id\": ObjectId(tip_id)})\n flash(\"Tip Successfully Deleted\")\n return redirect(url_for(\n \"profile\", username=session[\"user\"]))", "def delete_tag(delete_timestamps):\n\n ctx = dash.callback_context\n triggered_id, triggered_prop, triggered_value = utils.ctx_triggered_info(ctx)\n\n # When the button is initially added, it fires a callback.\n # We want to prevent this callback from making changes to the update signal.\n if triggered_value is None:\n raise PreventUpdate\n\n # Unfortunately, we have to convert the stringified dict back to a dict.\n # Dash doesn't provide us any other method to see which element triggered the callback.\n # This isn't very elegant, but I don't see any other way to proceed.\n id_dict = utils.string_to_dict(triggered_id)\n tag_idx = id_dict[\"index\"]\n state.delete_tag(tag_idx)\n\n return constants.OK_SIGNAL", "def delete():", "def delete_snapshot(SnapshotId=None):\n pass", "def delete_entry(self, scenario_info):\n sql = self.delete(\"id\")\n self.cur.execute(sql, (scenario_info[\"id\"],))", "def delete_time_entry_by_task_id(task_id):\n try:\n json_data = request.get_json()\n timestamp = json_data[\"timestamp\"]\n result = mongo.db.tasks.update_one({\"_id\": ObjectId(task_id)}, {\n '$pull': {'timeWorked': {\"timestamp\": timestamp}}})\n return json_util.dumps({\"removed\": result.modified_count})\n except Exception as err:\n abort(400)", "def delete_entry(self, scenario_id):\n sql = self.delete(\"id\")\n self.cur.execute(sql, (scenario_id,))", "def delete_entry(self, id, **args):\n args.update(id=id)\n return self.fetch(\"/entry/delete\", post_args=args)", "def delete(log, args):\n log('dataset id: {highlight}{id}{reset}',\n highlight=Fore.GREEN,\n id=args.id,\n reset=Style.RESET_ALL)\n log.warn('delete dataset command coming soon.')", "def delete_item(dataobj_id):\n file = get_by_id(dataobj_id)\n remove_from_index(dataobj_id)\n if file:\n Path(file).unlink()", "def remove_measurement():\n meas_id = request.args.get('id', type=int)\n if meas_id is not None:\n db.session.query(Measurement).filter(Measurement.id == meas_id).delete()\n db.session.commit()\n\n return redirect('/measurements')", "def delete_record(self, record_id):\r\n self.record.deleteObject(id=record_id)", "def delete_study(self, study_id: int) -> None:\n raise NotImplementedError", "def del_stkpnt(*args):\n return _ida_frame.del_stkpnt(*args)", "def ticket_deleted(self, ticket):", "def delete(ident):\n con = mdb.connect(constants.sql_.IP, constants.sql_.USER, constants.sql_.PASS,\n constants.sql_.DB)\n with con:\n cur = con.cursor()\n sql = 'DELETE FROM '+constants.sql_tables.cron.name+' WHERE id = '+ str(ident)\n cur.execute(sql)\n con.close()", "def delete(self, file_id: str):\n file_path = self._path_to_file(file_id)\n os.remove(file_path)\n del self.index[file_id]", "def deleteFileRecordByID(file_id):\n session = Queries.createSession()\n try:\n file_db = session.query(FileTable).filter_by(id=file_id).first()\n servers = file_db.server_id[:]\n for server in servers:\n file_db.server_id.remove(server)\n session.commit()\n session.delete(file_db)\n session.commit()\n except sqlalchemy.exc.ArgumentError:\n print 'SQLAlchemy ERROR: Invalid or conflicting function argument is supplied'\n except sqlalchemy.exc.CompileError:\n print 'SQLAlchemy ERROR: Error occurs during SQL compilation'\n finally:\n session.close()", "def delete(\n id: int = typer.Argument(\n ...,\n help=\"ID of the log entry\"\n )\n):\n manager = LogBookManager()\n deleted, message = manager.delete(id)\n\n if deleted:\n typer.echo(\n typer.style(message, fg=typer.colors.GREEN, bold=True)\n )\n else:\n typer.echo(\n typer.style(message, fg=typer.colors.RED, bold=True)\n )" ]

[ "0.6817432", "0.6323765", "0.6092936", "0.5960528", "0.5938911", "0.5921734", "0.5871521", "0.58428675", "0.58353716", "0.5810618", "0.58022326", "0.5802029", "0.57991624", "0.5793931", "0.57803595", "0.57751805", "0.5750283", "0.57027435", "0.5691786", "0.5686231", "0.56447107", "0.560708", "0.55964667", "0.5578747", "0.55641085", "0.55427074", "0.55329114", "0.5521514", "0.5521295", "0.55212367" ]

[ "def erase(self, n=1):\n if len(self.x) < n:\n raise IndexError('Does not have enough data to erase!')\n for k in range(n):\n self.diff.pop()\n self.x.pop()", "def delete_all(self, n):\n for i in range(n):\n try:\n del self.dictionary[i]\n except KeyError:\n continue", "def purge_last(self, tf, n):\n if tf > 0:\n candles = self._candles.get(tf)\n if candles and len(candles) > n:\n self._candles[tf] = candles[-n:]\n elif self._ticks and len(self._ticks) > n:\n self._ticks = self._ticks[-n:]", "def _cull_oldest(self, n=1):\n for msg_id in self.get_history()[:n]:\n self.log.debug(\"Culling record: %r\", msg_id)\n self._culled_ids.add(msg_id)\n self.drop_record(msg_id)", "def destroy_oxygen(self, n = 1):\n\n self.count = max(0, self.count - 1)", "def _clear_last_lines(n=1):\n for _ in range(n):\n sys.stdout.write(CURSOR_UP_ONE)\n sys.stdout.write(ERASE_LINE)", "def remove_n_nos(self, num_nos):\n for i in range(num_nos):\n elem = random.randint(1, 11 ** 4)\n self.remove(elem)", "def towers(n: int, from_pile=1, to_pile=2):\n if n == 1:\n print(\"Remove 1 disk from {} pile to {} pile\"\n .format(from_pile, to_pile))\n else:\n tmp = 6 - from_pile - to_pile\n towers(n-1, from_pile, tmp)\n print(\"Remove {} disk from {} pile to {} pile\"\n .format(n, from_pile, to_pile))\n towers(n-1, tmp, to_pile)", "def drop(lst, n): # noqa: N805\n for _ in range(n):\n try:\n lst = lst.tail\n except AttributeError:\n break\n return lst", "def _popN(self, n):\n for _ in range(n):\n self._buffer.popleft()", "def trim_axs(axs, n):\n axs = axs.flat\n for ax in axs[n:]:\n ax.remove()\n return axs[:n]", "def reset(self):\r\n store = get_store()\r\n nbval = store.get('Nbtimecompound')[\"value\"]\r\n for i in range(1, nbval):\r\n self.del_line(1)", "def delete_segment(self, n):\n self.get_segment(n).delete()", "def delete_last_record():\n\tnewRcrds = list()\n\twith jsonlines.open('tempRecords.jsonl', mode='r') as readerOp:\n\t\tfor obj in readerOp:\n\t\t\tnewRcrds.append(obj)\n\twith jsonlines.open('tempRecords.jsonl', mode='w') as writerOp:\n\t\tif len(newRcrds) != 1:\n\t\t\t# checking if the record being removed is the last record which has file names.\n\t\t\tfor obji in newRcrds[:len(newRcrds)-1]:\n\t\t\t\twriterOp.write(obji)\n\t\telse:\n\t\t\t# if its the last record then do not delet it, as it is required for annotation data\n\t\t\tfor obji in newRcrds[:len(newRcrds)]:\n\t\t\t\twriterOp.write(obji)", "def keep_haikus_n_rows(cls, db_session, n: int = None):\n if n is not None:\n ids = db_session.query(cls.id).order_by(desc(cls.created_at)).all()\n ids_to_delete = [x[0] for x in ids[n:]]\n\n if ids_to_delete:\n try:\n logger.info(f\"Keeping most recent {n} rows of haikus\")\n delete_q = cls.__table__.delete().where(cls.id.in_(ids_to_delete))\n\n db_session.execute(delete_q)\n db_session.commit()\n except Exception as e:\n logger.warning(\n f\"Exception when keeping most recent rows of haikus: {e}\"\n )\n db_session.rollback()", "def remove_stuck(traj,size):\n from numpy import sqrt, where\n \n r_min = traj.groupby('particle').first()\n r_max = traj.groupby('particle').last()\n\n pos_columns = ['x','y']\n dist = r_min[pos_columns] - r_max[pos_columns]\n dist_eu = sqrt(dist['x']**2+dist['y']**2)\n\n index_remove = dist_eu.index[where(dist_eu < size)]\n \n traj_new = traj\n for i in range(len(index_remove)):\n traj_new = traj_new[(traj_new['particle'] != index_remove[i])]\n \n return traj_new", "def undelete(self,\r\n undeletelist=None,\r\n update_table=True):\r\n\r\n m_temp = iter([a_temp for a_temp\r\n in range(1,len(self.indexes()*2))\r\n if str(a_temp)\r\n not in self.indexes()])\r\n\r\n\r\n # iter function is used to find free spots for the notes to be undeleted\r\n\r\n if undeletelist is None:\r\n undeletelist = [Index(x_temp)\r\n for x_temp in\r\n self.find_within(indexfrom=None,\r\n indexto=0)]\r\n\r\n for u in undeletelist:\r\n print(PERIOD,end=EMPTYCHAR)\r\n\r\n self.move(u,\r\n Index(next(m_temp)),\r\n withchildren=True,\r\n update_table=update_table)\r\n print()", "def delete_packets(self, num):\n for i in range(num):\n del self._packets[0]", "def delete(self, value):\n for i in range(value):\n self.popleft()\n self.annotations.popleft()", "def trim_axs(axs, N):\n axs = axs.flat\n for ax in axs[N:]:\n ax.remove()\n return axs[:N]", "def trim_axs(axs, N):\n axs = axs.flat\n for ax in axs[N:]:\n ax.remove()\n return axs[:N]", "def trim_axs(axs, N):\n axs = axs.flat\n for ax in axs[N:]:\n ax.remove()\n return axs[:N]", "def decr(self, n=1):\n return _osgAnimation.SwigPyIterator_decr(self, n)", "def hollow(t, n):\n lt(t)\n skip(t, n)\n rt(t)", "def free(n):\n global _tracks\n _tracks[n] = False\n while not _tracks[-1]:\n _tracks.pop()\n if len(_tracks) == 0:\n break", "def get_tweets(n=1):\n tweets = list(collection.find())[-n:]\n return tweets", "def _clearstamp(self, stampid):\n if stampid in self.stampItems:\n if isinstance(stampid, tuple):\n for subitem in stampid:\n self.screen._delete(subitem)\n else:\n self.screen._delete(stampid)\n self.stampItems.remove(stampid)\n # Delete stampitem from undobuffer if necessary\n # if clearstamp is called directly.\n item = (\"stamp\", stampid)\n buf = self.undobuffer\n if item not in buf.buffer:\n return\n index = buf.buffer.index(item)\n buf.buffer.remove(item)\n if index <= buf.ptr:\n buf.ptr = (buf.ptr - 1) % buf.bufsize\n buf.buffer.insert((buf.ptr+1)%buf.bufsize, [None])", "def drop(n, seq):\n return itertools.islice(seq, n, None)", "def drop(n):\n def _drop_xducer(step):\n outer = {\"count\": 0}\n def _drop_step(r=Missing, x=Missing):\n if r is Missing: return step()\n if x is Missing:\n return step(r)\n if outer[\"count\"] < n:\n outer[\"count\"] += 1\n return r\n else:\n return step(r, x)\n return _drop_step\n return _drop_xducer", "def clean_sfd(sfd_to_clean, nkeep=30):\n with sfd_to_clean.open(sfd_to_clean.filename) as f:\n txt = f.readlines()\n # remove all lines after nkeep lines\n txt2 = txt[:nkeep]\n # add note to end of file\n txt2 += [u'WARNING: REST OF FILE WAS CLEANED SO SAVE SPACE!!!\\n']\n # overwrite file\n with sfd_to_clean.open(sfd_to_clean.filename, 'w') as fnew:\n fnew.writelines(txt2)" ]

[ "0.66142964", "0.62436444", "0.61857015", "0.60634005", "0.5881258", "0.585615", "0.5854961", "0.58503574", "0.5723285", "0.57020855", "0.5692238", "0.5617511", "0.5545051", "0.54746693", "0.54557824", "0.54481196", "0.542017", "0.54046494", "0.5377807", "0.5370303", "0.5370303", "0.5370303", "0.5319694", "0.53136265", "0.5305169", "0.5280408", "0.52703273", "0.5252589", "0.5189654", "0.5152392" ]

[ "def end_of_line():\r\n set_point(point().end_of_line())", "def move(self,x,y):\n assert (type(x) in [int, float]), \"parameter x:%s is not a valid number\" % `x`\n assert (type(y) in [int, float]), \"parameter y:%s is not a valid number\" % `y`\n d = self._turtle.isdown()\n if d:\n self._turtle.penup()\n self._turtle.setposition(x,y)\n if d:\n self._turtle.pendown()", "def up():\n global y, canvas # y é modificado\n canvas.create_line(x, y, x, y - 10)\n y -= 10", "def down():\n global y, canvas # y é modificado\n canvas.create_line(x, y, x, y + 10)\n y += 10", "def move_end_node(self, x, y):", "def redraw(self): \r\n\r\n self.arrow.undraw() \r\n pt2 = Point(self.vel*cos(self.angle), self.vel*sin(self.angle))\r\n self.arrow = Line(Point(0,0), pt2).draw(self.win) \r\n self.arrow.setArrow('last')\r\n self.arrow.setWidth(3)", "def setEndPoint(self, x, y):\n self._end = QPointF(x, y)", "def move_turtle(self):\n self.forward(self.move_speed)", "def drawLine(self, dx, dy):\n assert (type(dx) in [int, float]), \"parameter x:%s is not a valid number\" % `dx`\n assert (type(dy) in [int, float]), \"parameter y:%s is not a valid number\" % `dy`\n x = self._turtle.xcor()\n y = self._turtle.ycor()\n self._turtle.setposition(x+dx, y+dy)", "def forward(self, dist):\n start = (self.pos_x, self.pos_y)\n self.pos_x += dist * math.cos(math.radians(self.angle))\n self.pos_y += dist * math.sin(math.radians(self.angle))\n self._update_limits()\n end = (self.pos_x, self.pos_y)\n if self.pen_down:\n self.draw.line([start, end], fill=self.colour, width=self.width)", "def redraw(self):\n \n self.arrow.undraw()\n pt2 = Point(self.vel*cos(self.angle), self.vel*sin(self.angle))\n self.arrow = Line(Point(0,0), pt2).draw(self.win)\n self.arrow.setArrow(\"last\")\n self.arrow.setWidth(3)", "def move(self, x, y):\r\n if self.brush_on:\r\n for lx, ly in line(self.pos_x, self.pos_y, x, y):\r\n self.set(lx, ly)\r\n\r\n self.pos_x = x\r\n self.pos_y = y", "def move(self,x,y):\n assert (type(x) in [int, float]), \"parameter x:%s is not a valid number\" % `x`\n assert (type(y) in [int, float]), \"parameter y:%s is not a valid number\" % `y`\n fstate = self._turtle.fill()\n if fstate: # only need to do this if in mid-fill\n self._turtle.fill(False)\n self._turtle.penup()\n self._turtle.setposition(x,y)\n self._turtle.pendown()\n if fstate: # only need to do this if in mid-fill\n self._turtle.fill(True)", "def draw_t(self):\r\n pen.forward(20)\r\n pen.left(90)\r\n pen.down()\r\n pen.forward(40)\r\n pen.right(90)\r\n pen.up()\r\n pen.forward(20)\r\n pen.down()\r\n pen.back(40)\r\n pen.up()\r\n pen.right(90)\r\n pen.forward(40)\r\n pen.left(90)\r\n pen.forward(50)", "def draw_o(self):\r\n pen.down()\r\n pen.forward(40)\r\n pen.left(90)\r\n pen.forward(40)\r\n pen.left(90)\r\n pen.forward(40)\r\n pen.left(90)\r\n pen.forward(40)\r\n pen.left(90)\r\n pen.up()\r\n pen.forward(50)", "def line():\n tt.left(90)\n tt.down()\n tt.forward(50)\n tt.up()\n tt.right(90)\n tt.forward(10)\n tt.right(90)\n tt.forward(50)\n tt.left(90)", "def penup(self):\n if not self._drawing:\n return\n self.pen(pendown=False)", "def pendown(self):\n if self._drawing:\n return\n self.pen(pendown=True)", "def drawTo(self, x, y):\n assert (type(x) in [int, float]), \"parameter x:%s is not a valid number\" % `x`\n assert (type(y) in [int, float]), \"parameter y:%s is not a valid number\" % `y`\n self._turtle.setposition(x, y)", "def move_to_line_end(self) -> None:\n self.index = self.buffer.get_line_end(self.index)", "def move_forward(self,length,draw=True):\r\n new_x = self.x + length * math.cos(math.radians(self.angle))\r\n new_y = self.y + length * math.sin(math.radians(self.angle))\r\n self.draw_tool.line(((self.x,self.y),(new_x,new_y)), fill=(0,0,0),width=2)\r\n self.x = new_x\r\n self.y = new_y", "def draw_n(self):\r\n pen.down()\r\n pen.left(90)\r\n pen.forward(40)\r\n pen.right(135)\r\n pen.forward(1.414*40)\r\n pen.left(135)\r\n pen.forward(40)\r\n pen.up()\r\n pen.back(40)\r\n pen.right(90)\r\n pen.back(40)\r\n pen.forward(50)", "def draw_s(self):\r\n pen.down()\r\n pen.forward(40)\r\n pen.left(90)\r\n pen.forward(20)\r\n pen.left(90)\r\n pen.forward(40)\r\n pen.right(90)\r\n pen.forward(20)\r\n pen.right(90)\r\n pen.forward(40)\r\n pen.up()\r\n pen.back(40)\r\n pen.right(90)\r\n pen.forward(40)\r\n pen.left(90)\r\n pen.forward(50)", "def next_line():\r\n set_point(point().next_line())", "def draw_point(self, p):\n length = 3\n self.set_line_width(0.1)\n self.set_source_rgba(0, 0, 1, 1)\n self.move_to(p.x + length, p.y)\n self.line_to(p.x - length, p.y)\n self.stroke()\n self.move_to(p.x, p.y + length)\n self.line_to(p.x, p.y - length)\n self.stroke()", "def _motion(self, event):\n if self.current:\n # modify the current line by changing the end coordinates\n # to be the current mouse position\n coords = event.widget.coords(self.current)\n coords[2] = event.x\n coords[3] = event.y\n\n event.widget.coords(self.current, *coords)", "def move_turtle(self, x, y):\n tortuga = self.turtle\n if self.capture_mode:\n tortuga.setheading(tortuga.towards(x, y))\n tortuga.setpos(x, y)\n self.add_punto(Punto(x, y))", "def __draw_line(display, color, ball_pos, dx, dy):\n pygame.draw.line(display, color, ball_pos, (ball_pos[0] + dx, ball_pos[1] + dy), 2)", "def _lineTo(self, pt):\n x, y = pt\n # duplicate point\n if x == self._lastX and y == self._lastY:\n return\n # vertical line\n elif x == self._lastX:\n cmd = \"V\"\n pts = str(y)\n # horizontal line\n elif y == self._lastY:\n cmd = \"H\"\n pts = str(x)\n # previous was a moveto\n elif self._lastCommand == \"M\":\n cmd = None\n pts = \" \" + pointToString(pt)\n # basic\n else:\n cmd = \"L\"\n pts = pointToString(pt)\n # write the string\n t = \"\"\n if cmd:\n t += cmd\n self._lastCommand = cmd\n t += pts\n self._commands.append(t)\n # store for future reference\n self._lastX, self._lastY = pt", "def lineTo(self, pt: Tuple[float, float]) -> None:\n raise NotImplementedError" ]

[ "0.6613528", "0.6424479", "0.641985", "0.64038825", "0.6334372", "0.63291734", "0.6282229", "0.62446344", "0.62211007", "0.62094563", "0.61869323", "0.6183097", "0.6168437", "0.61666554", "0.6136846", "0.6133894", "0.61330557", "0.6131271", "0.60847", "0.603834", "0.60336095", "0.5949156", "0.5943696", "0.59145385", "0.5865185", "0.5861476", "0.5858458", "0.58545655", "0.5743446", "0.5739588" ]

[ "def enter(self):\n if self.pos < self.line_length():\n # If the position is not at the end of the line split the line\n self.buffer.split_line(self.line, self.pos)\n else:\n self.buffer.insert_line(\"\", self.line + 1)\n \n self.line += 1\n self.pos = 0\n self.has_changes = True", "def close_path(numbers, p_current, p_start):\n return Line(p_current, p_start)", "def advance(self):\n self._current_inst += 1\n self._line = self._lines[self._current_inst].strip()", "def start_edit(self):\n txt = self.model.get_current_line()\n self._line.original_widget = self._line_edit\n self._line_edit.set_edit_text(txt)\n self._line_edit.set_edit_pos(len(txt))\n self._top.set_focus(2)", "def pop_current_line(self):\n self.current_line.pop()", "def new(self):\n self.last_artistid += 1\n self.add_artist_line(self.last_artistid)\n vbar = self.scrl.verticalScrollBar()\n vbar.setMaximum(vbar.maximum() + 34)\n vbar.setValue(vbar.maximum())", "def mouseMoveEvent(self, mouseEvent):\n if self.myMode == self.InsertLine and self.line:\n newLine = QLineF(self.line.line().p1(), mouseEvent.scenePos())\n self.line.setLine(newLine)\n \n endItems = self.items(self.line.line().p2())\n if len(endItems) and endItems[0] == self.line:\n endItems.pop(0)\n \n if len(endItems) and isinstance(endItems[0], DiagramItem) :\n self.endItem = endItems[0]\n self.endItem.showHotspots()\n else:\n if self.endItem is not None:\n self.endItem.hideHotspots()\n self.endItem = None\n else:\n super(DiagramScene, self).mouseMoveEvent(mouseEvent)", "def __editJoin(self):\n self.activeWindow().joinLines()", "def update_line(self):\n self._draw_line_text()\n self._draw_status()\n self._line_listbox.set_focus(self.model.l_index)", "def next_line(self, context, line):", "def del_line(self, buttoninstance):\r\n try:\r\n widgets = self.timecompoundlist.pop()\r\n except IndexError:\r\n return\r\n for w in widgets:\r\n self.ids.inlayout.remove_widget(w)\r\n #del the line in the jsonfile\r\n store = get_store()\r\n lastval = store.get('Nbtimecompound')[\"value\"]\r\n store.delete('Timecompound'+str(lastval))\r\n store.put('Nbtimecompound', value=lastval-1)\r\n self.ids.inlayout.rows = 5 + store.get('Nbtimecompound')[\"value\"]\r\n #force the good size\r\n self.ids.tscrollview.change_child_height(self.ids.tscrollview.height)", "def render_curr_line(self):\n if self.launcher_curr_pos is None:\n self.launcher_curr_pos = len(vim.current.buffer) - 1\n line = vim.current.buffer[self.launcher_curr_pos]\n vim.current.buffer[self.launcher_curr_pos] = '▸ ' + line[2:]", "def mouseReleaseEvent(self, mouseEvent):\n if self.line and self.myMode == self.InsertLine:\n p1 = self.line.line().p1()\n p2 = self.line.line().p2()\n \n startItems = self.items(self.line.line().p1())\n if len(startItems) and startItems[0] == self.line:\n startItems.pop(0)\n endItems = self.items(self.line.line().p2())\n if len(endItems) and endItems[0] == self.line:\n endItems.pop(0)\n\n self.removeItem(self.line)\n self.line = None\n\n if len(startItems) and len(endItems) and startItems[0] != endItems[0]: \n if (isinstance(startItems[0], DiagramItem) and isinstance(endItems[0], DiagramItem) ):\n startItem = startItems[0]\n endItem = endItems[0]\n if len(startItem.outputs)<startItem.maxOutputs and len(endItem.inputs)<endItem.maxInputs:\n arrow = Arrow(startItem, endItem, arrow_start_point = p1, arrow_end_point= p2)\n arrow.setColor(self.myLineColor)\n startItem.addArrow(arrow)\n endItem.addArrow(arrow)\n arrow.setZValue(-1000.0)\n self.addItem(arrow)\n arrow.updatePosition()\n self.line = None\n super(DiagramScene, self).mouseReleaseEvent(mouseEvent)", "def RefreshLine(self, item):\r\n\r\n if self._dirty:\r\n return\r\n if self._freezeCount:\r\n return\r\n\r\n rect = wx.Rect()\r\n x, rect.y = self.CalcScrolledPosition(0, item.GetY())\r\n rect.width = self.GetClientSize().x\r\n rect.height = self.GetLineHeight(item)\r\n\r\n self.Refresh(True, rect)", "def close_subblock(self, lines: Tuple[int, int]) -> None:", "def close(self, current, xml):\n self.setCurrent(current)\n if current.getOrganizeTypeChildren() == \"grid\":\n rows = xml.findall(\"row\")\n current.setRows(rows)", "def unreadline(self, line):\n self.linebuf.append(line)", "def GetNextLine(self):\n\t\tline = self._fin.readline()\n\n\t\tif len(line) == 0:\n\t\t\twx.MessageBox(\"All records processed\", \"DONE!\", wx.ICON_INFORMATION | wx.OK)\n\t\t\tself.EndRun()\n\t\t\t\n\t\telse:\n\t\t\tline = line[:-1]\n\t\t\tobj = json.loads(line)\n\t\t\tself._textControl.SetValue(obj[\"description\"])\n\t\t\tself._existingClass = obj[\"class\"]\n\t\t\tself._existingClassLabel.SetLabel(obj[\"class\"])", "def stopLineDrawing(self):\n taskMgr.remove(\"drawLineTask\")\n if self.line is not None:\n self.line.reset()\n self.line = None", "def menu_end_of_line_marker(self, event=None):\n self.parentPanel.end_of_line_marker(event)", "def move_to_line_end(self) -> None:\n self.index = self.buffer.get_line_end(self.index)", "def next_line():\r\n set_point(point().next_line())", "def do_open(self, line):\n\t\ttry:\n\t\t\tself.cl = Book().open_book(line)\n\t\t\tif isinstance(self.cl, Book):\n\t\t\t\tself.prompt = '({})> '.format(line)\n\t\t\tself.can_be_closed = True\n\t\t\tself.bookfile = line\n\t\texcept FileNotFoundError:\n\t\t\tprint(\"There is no such file!\")", "def close(self):\n file = self.file\n self.file = None\n self.filename = None\n self.current_line = None\n file.close()", "def close(self):\n active_item = self.stack.pop()\n self.graveyard.append(active_item)", "def ChildrenClosing(self, item):\r\n\r\n if self._textCtrl != None and item != self._textCtrl.item() and self.IsDescendantOf(item, self._textCtrl.item()):\r\n self._textCtrl.StopEditing()\r\n\r\n if self.IsDescendantOf(item, self._selectItem):\r\n self._selectItem = item\r\n \r\n if item != self._current and self.IsDescendantOf(item, self._current):\r\n self._current.SetHilight(False)\r\n self._current = None", "def close(self):\n self.drill = None", "def on_click(self, event):\n item = self.identify(\"item\", event.x, event.y)\n if item:\n if item in self.selection():\n self.selection_remove(item)\n else:\n self.selection_add(item)\n return \"break\"", "def go_to_exit(self, _: int = 0) -> None:\n self.current_option = self.last_item_index\n self.draw()", "def start(text=\"\"):\n global _current_line\n _current_line = StatusLine(text, WIDTH)" ]

[ "0.59516805", "0.58582115", "0.5794361", "0.5769524", "0.57671", "0.5683701", "0.5653681", "0.5647587", "0.5551085", "0.5520081", "0.55083084", "0.5490593", "0.54669076", "0.54596514", "0.5449109", "0.5424114", "0.53633904", "0.5338641", "0.53292465", "0.53283644", "0.5254835", "0.5246902", "0.5243922", "0.52408975", "0.5234466", "0.5217733", "0.52139187", "0.5213593", "0.5201854", "0.5170089" ]

[ "def initiate(self):\n pts = []\n for point in self.points:\n pt = gr.Point(point[0],point[1])\n pts.append(pt)\n\n self.vis = [gr.Polygon(pts)]\n\n self.draw()", "def give_polygon(vertices, points):\n polygon = np.zeros((len(vertices), 2))\n for i, vertex in enumerate(vertices):\n polygon[i] = points[vertex]\n # End point of a polygon equals to start point\n polygon = polygon.tolist()\n if polygon[-1] != polygon[0]:\n polygon.append(polygon[0])\n return polygon", "def _draw_polygon(self):\n xs, ys = zip(*self._xys) if self._xys else ([], [])\n self._selection_artist.set_data(xs, ys)\n self._update_box()\n # Only show one tool handle at the start and end vertex of the polygon\n # if the polygon is completed or the user is locked on to the start\n # vertex.\n if (self._selection_completed\n or (len(self._xys) > 3\n and self._xys[-1] == self._xys[0])):\n self._polygon_handles.set_data(xs[:-1], ys[:-1])\n else:\n self._polygon_handles.set_data(xs, ys)\n self.update()", "def draw_polygon():\n\n glBegin(GL_POLYGON)\n glColor3f(0.3, 0.4, 1.0)\n i = 0\n while i <= (matrix_order - 1):\n x = vertices[0][i]\n y = vertices[1][i]\n # casting\n glVertex2f((float(x) / 2) + (width / 2), (float(y) / 2) + (height / 2))\n i = i + 1\n glEnd()", "def __init__(self, vertices, subs=None, **kwargs):\n super(Polygon, self).__init__(vertices, ring=True, **kwargs)\n self._geotype = \"Polygon\"\n if subs is not None:\n self.subs = list(subs)\n else:\n self.subs = []\n return", "def __draw_polygon(self, event, klick):\n global creating_polygon\n curX = self.canvas.canvasx(event.x)\n curY = self.canvas.canvasy(event.y)\n if not klick and len(self.polygon_points) >= 2:\n c_r_x, c_r_y = self.get_canvas_relative_coords((self.polygon_points[-2], self.polygon_points[-1]))\n distanceX = curX - c_r_x\n distanceY = curY - c_r_y\n if pow(pow(distanceX, 2) + pow(distanceY, 2), 1 / 2) <= 15:\n return\n image_relative_x, image_relative_y = self.get_image_relative_coords((curX, curY))\n self.polygon_points.extend((image_relative_x, image_relative_y))\n self.polygon_groundstructure.append(self.canvas.create_rectangle(curX - 2, curY - 2, curX + 2, curY + 2,\n outline='magenta', width=1,\n activewidth=2))\n if not creating_polygon: # start with a new polygon\n creating_polygon = True\n return\n else: # draw a line between the last points\n c_r_x1, c_r_y1 = self.get_canvas_relative_coords((self.polygon_points[-4], self.polygon_points[-3]))\n c_r_x2, c_r_y2 = self.get_canvas_relative_coords((self.polygon_points[-2], self.polygon_points[-1]))\n self.polygon_groundstructure.append(self.canvas.create_line([c_r_x1, c_r_y1, c_r_x2, c_r_y2],\n fill='magenta', width=2))", "def make_polygon(*coords):\n global GEOMETRY_SURF, POLYGONS,col\n if len(coords) < 3:\n print(\"Warning: Invalid polygon passed, ignoring...\")\n return\n start = coords[0]\n prev = coords[0]\n for coord in coords:\n POLYGONS |= {coord}\n line = Boundary(prev[0],prev[1],coord[0],coord[1]) #add segment to WALL list\n prev = coord\n line = Boundary(prev[0], prev[1],start[0],start[1])\n #now draw poly\n pygame.draw.polygon(GEOMETRY_SURF,col[\"SHAPECOL\"], coords)\n return", "def draw_shape_polygon(self, poly, xform, colour):\n pts = [xform.chain(p) for p in poly.points]\n self.canvas.polygon([(p.x, p.y) for p in pts], outline=colour)", "def test_polygon_to_vertex_arrays(self):\n\n these_vertex_x_coords, these_vertex_y_coords = (\n skeleton_lines._polygon_to_vertex_arrays(POLYGON_OBJECT_XY))\n\n self.assertTrue(numpy.allclose(\n these_vertex_x_coords, VERTEX_X_COORDS, atol=TOLERANCE))\n self.assertTrue(numpy.allclose(\n these_vertex_y_coords, VERTEX_Y_COORDS, atol=TOLERANCE))", "def draw_polygon(self, *points, color=DEFAULT.color):", "def DrawPolygon(self, vertices, color):\r\n if not vertices:\r\n return\r\n\r\n if len(vertices) == 2:\r\n pygame.draw.aaline(self.surface, color.bytes, vertices[0], vertices)\r\n else:\r\n pygame.draw.polygon(self.surface, color.bytes, vertices, 1)", "def __init__(self, vertices):\n if len(vertices) < 3:\n raise LocationsTooLittle(\"Requires three or more vertices to form \"\n \"a polygon\")\n self.vertices = vertices", "def _finish_polygon(self):\n global undo_stack, choose_polygon\n if len(self.polygon_points) < 6:\n messagebox.showinfo(title='Info', message='Too few points for a polygon')\n return 'too_few_points'\n relative_poly_points = []\n for p in range(0, len(self.polygon_points), 2):\n relative_poly_points.extend(self.get_canvas_relative_coords((self.polygon_points[p],\n self.polygon_points[p + 1])))\n if choose_polygon:\n undo_stack.append('p')\n self.polygons.append(self.canvas.create_polygon(relative_poly_points,\n outline='blue', activewidth=3, width=1,\n fill='magenta', stipple='gray50'))\n self.canvas.tag_bind(self.polygons[-1], '<ButtonPress-1>', self.callback_click_polygon)\n self.canvas.tag_bind(self.polygons[-1], '<ButtonRelease-1>', self.callback_release_polygon)\n self.canvas.tag_bind(self.polygons[-1], '<B1-Motion>', self.callback_move_polygon)\n for p in self.polygon_groundstructure:\n self.canvas.delete(p)\n self.polygon_points_history[self.polygons[-1]] = np.reshape(np.asarray(self.polygon_points),\n (round(len(self.polygon_points) / 2),\n 2))\n self.polygon_points.clear()\n self.polygon_groundstructure.clear()\n self.parent_class.activate_save_bt()", "def add_poly_to_scene(self, polygon, point_marker_dict=None, curve_marker_dict=None, hole_mode=False):\n if hole_mode:\n poly = self.addPolygon(polygon, QPen(QColor(0, 0, 0, 0)), QBrush(QColor(255, 255, 255)))\n poly.setZValue(1)\n self.poly_list.append(poly)\n self.hole_list.append(poly)\n else:\n poly = self.addPolygon(polygon, QPen(QColor(0, 0, 0, 0)), QBrush(QColor(0, 0, 0, 50)))\n self.poly_list.append(poly)\n self.add_poly_corners(poly, point_marker_dict)\n self.add_poly_edges(poly, curve_marker_dict)\n poly.setFlag(QGraphicsItem.GraphicsItemFlag.ItemIsSelectable)\n poly.setFlag(QGraphicsItem.GraphicsItemFlag.ItemIsMovable)\n return poly", "def vertices(self, *args, **kwargs) -> Any:\n pass", "def addPolygon(self, verts, color=[220,0,0], thickness=1.0, alpha=255,\n linestyle='=', fill=None, selectable=True, movable=False,\n selectThickness=2.0, selectColor=None, closed=True,\n name='QIVPolygon', noadd=False, isCosmetic=False):\n\n # create the polygon object\n polygon = QIVPolygon(verts, color=color, thickness=thickness,\n alpha=alpha, linestyle=linestyle, fill=fill, selectable=selectable,\n movable=movable, closed=closed, view=self, name=name,isCosmetic=isCosmetic)\n\n if (not noadd):\n # add the polygon to the scene\n self.scene.addItem(polygon)\n\n # and add it to our list of items\n self.sceneItems.append(polygon)\n\n return polygon", "def redefinir_vertices(self):\n self.nueva_posicion_posible_parte_inferior = [0,0]\n self.nueva_posicion_posible_parte_superior = [0,0]\n self.vertice_1 = self.posicion\n self.vertice_2 = [self.posicion[0] + self.medidas, self.posicion[1]]\n self.vertice_3 = [self.posicion[0], self.posicion[1] + self.medidas]\n self.vertice_4 = [self.posicion[0] + self.medidas, self.posicion[1] + self.medidas]", "def init_vertices(self):\n self.vertices = []\n for key in self.graph:\n self.vertices.append(self.Vertex(key, self.graph[key]))", "def __init__(self):\n self.vertices = {}", "def generatePolygons():", "def getStartVertex(self):", "def _proc_polygon(self, tokens, filled):\n\n pts = [(p[\"x\"], p[\"y\"]) for p in tokens[\"points\"]]\n component = Polygon(pen=self.pen, points=pts, filled=filled)\n\n return component", "def vertices(self, v):\n self._vertices = v", "def polygon(self, center, angle, points, color=(255, 255, 255), width=0):\n poly = list()\n\n for point in points:\n point = self._rotate(point, angle)\n point += center\n point = self._transform(point)\n poly.append(point)\n\n pygame.draw.polygon(self.screen, color, poly, width)", "def __init__(self, vertices):\n self.vertices = vertices", "def draw( self ):\r\n print \"Drawing cuboid!\"\r\n glTranslated( *self.pos3D ) # This moves the origin of drawing , so that we can use the above coordinates at each draw location\r\n if self.rotnByOGL:\r\n glRotated( self.thetaDeg , *self.rotAxis )\r\n # glTranslated( 0 , 0 , 0 ) # This moves the origin of drawing , so that we can use the above coordinates at each draw location\r\n print \"DEBUG:\" , \"Translated to\" , 0 , 0 , 0\r\n glColor3ub( *self.color ) # Get the color according to the voxel type\r\n print \"DEBUG:\" , \"Set color to\" , self.color\r\n pyglet.graphics.draw_indexed( \r\n 8 , # --------------------- Number of seqential triplet in vertex list\r\n GL_QUADS , # -------------- Draw quadrilaterals\r\n self.indices , # ---------- Indices where the coordinates are stored\r\n ( 'v3f' , self.vertX ) # vertex list , OpenGL offers an optimized vertex list object , but this is not it\r\n ) # 'v3i' # This is for integers I suppose!\r\n \r\n glColor3ub( *self.colorLine )\r\n pyglet.gl.glLineWidth( 3 )\r\n pyglet.graphics.draw_indexed( \r\n 8 , # --------------------- Number of seqential triplet in vertex list\r\n GL_LINES , # -------------- Draw quadrilaterals\r\n self.linDices , # ---------- Indices where the coordinates are stored\r\n ( 'v3f' , self.vertX ) # vertex list , OpenGL offers an optimized vertex list object , but this is not it\r\n ) # 'v3i' # This is for integers I suppose!\r\n \r\n print \"DEBUG:\" , \"Indices\"\r\n print self.indices \r\n print \"DEBUG:\" , \"Vertices\"\r\n print self.vertices \r\n \"\"\" URL: http://pyglet.readthedocs.io/en/pyglet-1.2-maintenance/programming_guide/graphics.html#vertex-lists\r\n \r\n There is a significant overhead in using pyglet.graphics.draw and pyglet.graphics.draw_indexed due to pyglet \r\n interpreting and formatting the vertex data for the video device. Usually the data drawn in each frame (of an animation) \r\n is identical or very similar to the previous frame, so this overhead is unnecessarily repeated.\r\n \r\n A VertexList is a list of vertices and their attributes, stored in an efficient manner that’s suitable for direct \r\n upload to the video card. On newer video cards (supporting OpenGL 1.5 or later) the data is actually stored in video memory.\r\n \"\"\"\r\n if self.rotnByOGL:\r\n glRotated( -self.thetaDeg , *self.rotAxis )\r\n glTranslated( *np.multiply( self.pos3D , -1 ) ) # Reset the transform coordinates\r\n print \"DEBUG:\" , \"Translated to\" , 0 , 0 , 0\r\n print \"Done drawing!\"", "def draw_filled_polygon(\n self, points: Iterable[Vec3], properties: Properties\n ) -> None:\n raise NotImplementedError", "def test_simple_polygonisation(n_points=20):\n # generate random sample points.\n sample_points = np.random.random_sample((n_points,2))*10\n # generate simple polygon\n seq = simple_polygonisation(sample_points)\n # plot polygon\n plt.figure()\n plt.plot(seq[:,0], seq[:,1], color=\"blue\", marker=\"s\", alpha=0.5)", "def _update_vertices(self):\n raise NotImplementedError(\"_update_vertices must be defined\"\n \"for every ShapeBase subclass\")", "def draw_polygon(*points):\r\n global _canvas\r\n global _current_color\r\n if _canvas == None:\r\n raise RuntimeError(\"Canvas is not open yet.\")\r\n else:\r\n newpoints = []\r\n for x in range(0, len(points), 2):\r\n pt = Point(points[x], points[x+1])\r\n newpoints += [ pt ]\r\n polygon = Polygon(*newpoints)\r\n _set_not_filled(polygon)\r\n _canvas.add(polygon)" ]

[ "0.62927264", "0.61782724", "0.6133704", "0.60111237", "0.57999295", "0.57220894", "0.56979716", "0.5694384", "0.5685063", "0.56764746", "0.5590536", "0.5583972", "0.55473775", "0.5522647", "0.55015236", "0.5489928", "0.54840237", "0.54795456", "0.5473881", "0.54701525", "0.5451997", "0.54464877", "0.544293", "0.54262185", "0.54258734", "0.5409215", "0.5400289", "0.5385877", "0.5378631", "0.53767776" ]

[ "def obj(self) -> object:\n pass", "def obj(self):\r\n return self._obj", "def fire_torpedo(self):\n return Torpedo(self)", "def obj(self):\n if not self._obj:\n self._get()\n return self._obj", "def Screen():\n if Myturtle._screen is None:\n Myturtle._screen = _Screen()\n return Myturtle._screen", "def obj(self):\n return self._obj", "def object(self):", "def get_obj(self):\n assert self._obj is not None, \"Object XML tree has not been generated yet!\"\n return self._obj", "def get_main_object(tc):\n return Daal(tc)", "def get_object (self) :\n\n # object is a weak_ref, and may have been garbage collected - we simply\n # return 'None' then\n return self._object ()", "def get_object(self):\n return self._object", "def __current_object__(self):\n return self.__lookup()", "def turtles(self):\n return self._turtles", "def get_object ( self, object ):\n return object", "def object(self):\n return self._object", "def turtles(self):\n return self._turtles[:]", "def T(self) :\n\t\ttry :\n\t\t\treturn self._T\n\t\texcept Exception as e:\n\t\t\traise e", "def get_object(self):\n if getattr(self, 'current_instance', None):\n ret = self.current_instance\n else:\n ret = super().get_object()\n return ret", "def _self(self):\n return self.__self", "def getTender(self):\n return self._Tender", "def initialize(turtle_shape, bg_color, turtle_color, turtle_speed):\n turtle_instance = turtle.Turtle()\n turtle_instance.shape(turtle_shape)\n turtle.bgcolor(bg_color)\n turtle_instance.color(turtle_color)\n turtle_instance.speed(turtle_speed)\n return turtle_instance", "def _get_current_object(self):\n if not hasattr(self.__local, '__release_local__'):\n return self.__local()\n try:\n return getattr(self.__local, self.__name__)\n except AttributeError:\n raise RuntimeError('no object bound to %s' % self.__name__)", "def _get_current_object(self):\n if not hasattr(self.__local, '__release_local__'):\n return self.__local()\n try:\n return getattr(self.__local, self.__name__)\n except AttributeError:\n raise RuntimeError('no object bound to %s' % self.__name__)", "def __self__(self):\n if self._ob is not None:\n return self._ob()", "def get_traj(self):\n return self.trajectory.copy()", "def get_current(self) -> typing.Any:\n\n return self.current_obj", "def get(self):\n return getNaturopathy(self)", "def getObject(self):\n parent = aq_parent(self)\n obj = None\n try:\n obj = parent.unrestrictedTraverse(self.getPath()) \n except:\n log.error(\"Unable to get object from brain. Path: {0}. Catalog may be out of sync.\".format(self._result.uid))\n return obj", "def turtle(self,turtleType):\n if self.turtleType == turtleType:\n return\n if self.turtleType and self.turtleType != PLAYER:\n self.mc.removeEntity(self.turtleId)\n self.turtleType = turtleType\n if turtleType == PLAYER:\n self.turtleId = None\n elif turtleType:\n self.turtleId = self.mc.spawnEntity(turtleType,\n self.position.x,self.position.y,self.position.z,\n \"{NoAI:1}\")\n self.setEntityCommands()\n self.positionOut()\n self.directionOut()", "def getPortalObject( self ):\n return self" ]

[ "0.6059407", "0.59336627", "0.58552444", "0.5826366", "0.5818572", "0.5818455", "0.5800745", "0.57855034", "0.5761922", "0.5760971", "0.5730162", "0.56956524", "0.5682162", "0.5641696", "0.5630629", "0.55974203", "0.55940217", "0.5570873", "0.5502058", "0.54970336", "0.5486084", "0.54860157", "0.54860157", "0.54667646", "0.5466411", "0.54615855", "0.54048795", "0.5389064", "0.5354066", "0.5327859" ]

[ "def getInstance(screen):\r\n if Game.__instance == None:\r\n Game.__instance = Game(screen)\r\n return Game.__instance", "def getScreen(self):\n \n return self.screen", "def getscreen(self):\n return self.screen", "def getscreen(self):\n return self.screen", "def get_screen(self):\n return self._cached('raw', self.ale.getScreen)", "def getInstance(cls):\n cls.locker.acquire()\n try:\n if not cls.instance:\n cls.instance = cls()\n return cls.instance\n finally:\n cls.locker.release()", "def getScreen(self, screenName):\n return self.screens[self.screenDictionary[screenName]]", "def getinstance():\n if cls not in instances:\n instances[cls] = cls()\n return instances[cls]", "def instance(cls):\n if not hasattr(cls, '_instance'):\n cls._instance = cls()\n return cls._instance", "def instance(cls):\n if cls._instance is None:\n cls._instance = cls()\n return cls._instance", "def get_display_object(self):\n if len(self.objects) == 0:\n return self.tile.get_display_object()\n else:\n return self.objects[-1].get_display_object()", "def instance(cls):\n if not hasattr(cls, \"_instance\"):\n cls._instance = cls()\n\n return cls._instance", "def master_screen(self):\n return self.screen_manager.master_screen", "def get_instance(cls):\n if cls.__instance is None:\n cls.__guard = False\n cls.__instance = PvMonitors()\n cls.__guard = True\n return PvMonitors.__instance", "def get_object(self):\n if getattr(self, 'current_instance', None):\n ret = self.current_instance\n else:\n ret = super().get_object()\n return ret", "def singleton(defined_class):\n instances_of_classes = {} # Dictionary of our singletons instances\n\n def get_instance():\n if defined_class not in instances_of_classes:\n # We create our first class object\n instances_of_classes[defined_class] = defined_class()\n return instances_of_classes[defined_class]\n\n return get_instance", "def get_object(self):\n if not self.user.is_authenticated():\n raise Http404('Access denied')\n self.url_name = self.request.resolver_match.url_name\n if self.url_name == 'sticker-detail':\n return Sticker.objects.get(\n board__desk__owner__user=self.user,\n board__prefix=self.kwargs['prefix'],\n sequence=self.kwargs['sequence']\n )\n elif self.url_name == 'board-comments':\n return Board.objects.get(\n desk__owner__user=self.user,\n sequence=self.kwargs['board_sequence']\n )\n elif self.url_name == 'sprint-comments':\n return Sprint.objects.get(\n number=self.kwargs['sprint_number'],\n board__desk__owner__user=self.user,\n board__sequence=self.kwargs['board_sequence']\n )", "def instance(cls):\n if not cls.__singleton_instance:\n with cls.__singleton_lock: # # pylint: disable=E1129\n if not cls.__singleton_instance:\n cls.__singleton_instance = cls()\n return cls.__singleton_instance", "def get_active(cls):\n\n\t\tif cls._interface:\n\t\t\twindow = cls._interface.get_active()\n\t\t\tif window:\n\t\t\t\treturn cls(window)\n\t\t\telse:\n\t\t\t\treturn None\n\t\telse:\n\t\t\traise NotImplementedError('Unsupported platform')", "def singleton(cls):\n instances = {}\n\n def getinstance():\n \"\"\" Creates a single object and use instances dict as cache \"\"\"\n if cls not in instances:\n instances[cls] = cls()\n return instances[cls]\n return getinstance", "def getInstance(klass):\n klass.locker.acquire()\n try:\n if not klass.instance:\n klass.instance = klass()\n return klass.instance\n finally:\n klass.locker.release()", "def instance(cls):\r\n if cls._INSTANCE is None:\r\n cls._INSTANCE = cls()\r\n return cls._INSTANCE", "def get_instance(cls, *args, **kwargs):\n if cls._instance is not None:\n return cls._instance\n return cls(*args, **kwargs)", "def get_instance(self):\n try:\n return self._instance\n except AttributeError:\n self._instance = self._decorated()\n return self._instance", "def singleton(class_):\n instances = {}\n\n def get_instance(*args, **kwargs):\n if class_ not in instances:\n instances[class_] = class_(*args, **kwargs)\n return instances[class_]\n\n return get_instance", "def singleton(class_):\n instances = {}\n\n def get_instance(*args, **kwargs):\n if class_ not in instances:\n instances[class_] = class_(*args, **kwargs)\n return instances[class_]\n\n return get_instance", "def getDisplay(self):\n for display in self.listDisplays():\n if self.testDisplay(display):\n if self.verbose:\n print \"Got an existing working display on %s\" % display\n return display\n if self.verbose:\n print \"Not found any existing working display\"\n\n return self.startServer()", "def __call__(cls, *args, **kwargs):\n if cls not in cls._instances:\n cls._instances[cls] = super(Singleton, cls).__call__(*args,\n **kwargs)\n return cls._instances[cls]", "def singleton(cls):\n instances = {}\n\n def get_instance():\n if cls not in instances:\n instances[cls] = cls()\n return instances[cls]\n return get_instance", "def singleton(cls):\n instances = {}\n\n def getinstance():\n if cls not in instances:\n instances[cls] = cls()\n return instances[cls]\n\n return getinstance" ]

[ "0.7267535", "0.6170684", "0.6133751", "0.6133751", "0.60925436", "0.59846085", "0.5899024", "0.58917165", "0.57748014", "0.577314", "0.57484686", "0.5736769", "0.5713113", "0.56793666", "0.56304425", "0.5627452", "0.5620755", "0.5566278", "0.55652213", "0.55126613", "0.5504288", "0.5488469", "0.5482407", "0.54631037", "0.54446113", "0.54446113", "0.54301137", "0.53813535", "0.5363876", "0.5354735" ]

[ "def write_dictionary(args, dictio):\n if not args.dictfile.endswith(\".file\"):\n args.dictfile += \".file\"\n with open(args.dictfile, \"wb\") as f:\n dump(dictio, f, protocol=HIGHEST_PROTOCOL)", "def write_completed_dictionary_to_file(the_dict):\n\ttry:\n\t\toutputLocation = open('usable_dictionary.json','w')\n\t\toutputString = str(the_dict)\n\t\toutputLocation.write(outputString)\n\t\toutputLocation.close()\n\texcept IOError:\n\t\tprint (\"could not open file\")", "def file_write(filename, dic):\n d = dic \n f = open(filename, 'w') \n f.write(str(d))\n f.close()", "def open_output_files(self):\n if not os.path.exists(self.outputDictionaryPath):\n os.makedirs(self.outputDictionaryPath)\n\n self.XMLfile = open(os.path.join(self.outputDictionaryPath, 'MyDictionary.xml'), 'w+', encoding='utf-8') # this is the output file\n self.Makefile = open(os.path.join(self.outputDictionaryPath, 'Makefile'), 'w+', encoding='utf-8')\n self.MyInfoFile = open(os.path.join(self.outputDictionaryPath, 'MyInfo.plist'), 'w+', encoding='utf-8')", "def write_dict_txtfile(input_file_name, data_dict):\n \n output_file = open(input_file_name, 'w')\n output_file.write('Human Metabolome database')\n output_file.write('\\n\\n')\n\n for keys, values in data_dict.items():\n output_file.write(str(keys)+', '+str(values)+'\\n')", "def save_manual_file(filename):\n if not filename:\n return\n with open(filename, \"w\") as file:\n for value in Verse.DICT.values():\n file.write(str(value[\"scansion\"]) + \"\\t\" + value[\"comment\"] + \"\\n\")", "def write_dictionary(dictionary, path):\n with open(path, 'w+') as file:\n file.truncate() # Erase contents of config file\n for key in dictionary:\n file.write(f'{key}={dictionary[key]}\\n')", "def __write_config(self):\n with open(self.config_file, 'w') as data_file:\n config = {\"ibooks_doc_root\":self.ibooks_doc_root,\n \"library_folder\":self.library_folder,\n \"annotation_folder\":self.annotation_folder,\n \"tmp_dir\":self.tmp_dir\n } \n data = json.dumps(config, ensure_ascii=False)\n data_file.write(data)", "def save(self):\n if not os.path.exists(self.dictionary_save_path) and self.dictionary_save_path != \"\":\n os.makedirs(self.dictionary_save_path)\n with open(self.dictionary_save_path + \"dictionary\", 'w') as f:\n f.write(\"{}\\n\".format(len(self.dictionary)))\n\n for word in self.dictionary:\n f.write(\"{}\\t{}\\n\".format(self.dictionary[word]['id'], word))", "def write(self, fp):\n if self._defaults:\n fp.write(\"[%s]\\n\" % DEFAULTSECT)\n for (key, value) in self._defaults.items():\n fp.write(\"%s = %s\\n\" % (key, str(value).replace('\\n', '\\n\\t')))\n fp.write(\"\\n\")\n for section in self._sections:\n fp.write(\"[%s]\\n\" % section)\n for (key, value) in self._sections[section].items():\n if key == \"__name__\":\n continue\n if (value is not None) or (self._optcre == self.OPTCRE):\n key = \" = \".join((key, str(value).replace('\\n', '\\n\\t')))\n fp.write(\"%s\\n\" % (key))\n fp.write(\"\\n\")", "def save(self):\n \n with open(os.path.join(self.output_dir, 'terms.dict'), 'wb') as f:\n pkl.dump(self.term_id_map, f)\n with open(os.path.join(self.output_dir, 'docs.dict'), 'wb') as f:\n pkl.dump(self.doc_id_map, f)", "def write_pecfile_dict(output_file, record_dict):\n for key in sorted(record_dict.keys()):\n output_file.write('%s\\n' % str(record_dict[key]))\n return output_file", "def write(name, keyword, domain, citation, author, description, species, version, contact, license, values, output):\n write_namespace(\n name, keyword, domain, author, citation, values,\n namespace_description=description,\n namespace_species=species,\n namespace_version=version,\n author_contact=contact,\n author_copyright=license,\n file=output,\n )", "def write(name, keyword, domain, citation, author, description, species, version, contact, license, values,\n functions, output, value_prefix):\n write_namespace(\n name, keyword, domain, author, citation, values,\n namespace_description=description,\n namespace_species=species,\n namespace_version=version,\n author_contact=contact,\n author_copyright=license,\n functions=functions,\n file=output,\n value_prefix=value_prefix\n )", "def save_to_file():\n dict_from_file.update(temp_dict)\n plik=open('data.txt', 'w')\n for key in dict_from_file.keys():\n plik.write(key)\n plik.write(\" \")\n plik.write(str(dict_from_file[key][0]))\n plik.write(' ')\n plik.write(dict_from_file[key][1].replace(' ','_'))\n plik.write(' ')\n plik.write(str(dict_from_file[key][2]))\n plik.write('\\n')", "def Write(self):\n template_mappings = {}\n\n template_file = os.path.join(self._l2tdevtools_path, self._TEMPLATE_FILE)\n file_content = self._GenerateFromTemplate(template_file, template_mappings)\n\n file_content = file_content.encode('utf-8')\n\n with open(self.PATH, 'wb') as file_object:\n file_object.write(file_content)", "def _output_dict(self):\n lang = self.ddnGuiLanguage.get()\n\n fileout = os.path.normpath('{}/{}-{}.xml'.\\\n format(self.MapCreator, self.Source, self.ddnCurProject.get()))\n linesout = ['<?xml version=\"1.0\" encoding=\"UTF-8\"?>', \\\n '<DictionarySet xmlns:mc=\"urn:fmosoft-map-creator\" xmlns=\"urn:fmosoft-map-creator\" Version=\"1\">', \\\n ' <Dictionary SourceLanguage=\"{}\" SourceLanguageIsPredefined=\"true\" TargetLanguage=\"{}\" TargetLanguageIsPredefined=\"false\">'.\\\n format(self.Source, self.ddnCurProject.get()), \\\n ]\n for child in self.tree.get_children('approved'):\n vv = self.tree.item(child)['values']\n linesout.append(' <Translation Source=\"{}\" Target=\"{}\"/>'.format(vv[0], vv[1]))\n linesout.append(' </Dictionary>')\n linesout.append('</DictionarySet>')\n linesout.append('')\n\n if os.path.exists(fileout):\n os.remove(fileout)\n\n if fileout:\n output = codecs.open(fileout, mode='w', encoding='utf-8')\n output.write('\\n'.join(linesout))\n output.close()\n pass", "def write_stewicombo_metadata(file_name, metadata_dict, category=''):\n meta = set_stewicombo_meta(file_name, category=category)\n meta.tool_meta = metadata_dict\n write_metadata_to_file(paths, meta)", "def store_documentation(self, file_path, *args, **dargs):\n pass", "def write_file(config, key, template, interactive, logger, perm='644'):\n from cannula.utils import write_file as wf\n f = config.get(key)\n name = key.upper()\n if interactive:\n f = raw_input(\"\\nGenerate %s at (%s) \\nor enter new name: \" % (name, f)) or f\n \n directory = os.path.dirname(f)\n if not os.path.isdir(directory):\n logger.info(\"Creating Directory: %s\" % directory)\n os.makedirs(directory, 0700)\n \n # Write out the file\n wf(f, template, config, perm=perm)\n \n config[key] = f\n return config", "def write_calling_seq(d):\n dr= get_sample_dir(d['outdir'],d['obj'])\n fn=os.path.join(dr,'README.txt')\n if os.path.exists(fn):\n os.remove(fn)\n with open(fn,'w') as foo:\n for key in d.keys():\n foo.write('%s %s\\n' % (key,str(d[key])))\n print('Wrote %s' % fn)", "def _write_docx(self):\n with ZipFile(self.out_file, 'w') as f:\n self._write_content_types(f)\n self._write_app(f)\n self._write_core(f)\n self._write_rels(f)\n self._write_document(f)\n self._write_fonts(f)\n self._write_document_rels(f)\n self._write_settings(f)\n self._write_styles(f)", "def write_conll(cls, filename, writer, document_id, sentences):\n with open(filename, 'w') as fd:\n writer.write(fd, document_id, sentences)", "def _createConfigFile(self):\n configFile = self._configFile()\n try:\n with open(configFile) as fh:\n pass\n except IOError:\n try:\n with open(configFile, 'w') as fh:\n fh.write(\"[settings]\\n\")\n fh.write(\"debug = false\\n\")\n fh.write(\"hidefilenames = false\\n\")\n except IOError:\n pass", "def _write_template_to(self, tmpl_file, dest_file, template_dict):\n template = self.env.get_template(tmpl_file)\n mkdir_p(os.path.dirname(dest_file))\n logging.info(\"Writing: %s -> %s with %s\", tmpl_file, dest_file, template_dict)\n with open(dest_file, \"w\") as dfile:\n dfile.write(template.render(template_dict))", "def SaveDictFile(file,dict_):\n with open(file,'w') as f:\n for id in dict_:\n f.write(dict_[id] + \"=\" + str(id)+\"\\n\")", "def google_docstring_to_dict(\n docstring: Optional[str],\n file_import: Optional[Any] = None,\n ) -> Tuple[str, list, list]:\n\n if not docstring:\n return \"\", [], []\n\n regex_sections = r\"^(?: {4}|\\t)(?P<name>\\*{0,4}\\w+|\\w+\\s\\w+):\\n(?P<desc>(?:(\\s|\\S)*?(\\n\\n|\\Z)))\"\n regex_titles = r\"^(?: {4}|\\t)(?P<name>\\*{0,4}\\w+|\\w+\\s\\w+):\"\n section_titles = re.findall(regex_titles, docstring, re.MULTILINE)\n regex_description_sections = r\"(?P<desc>\\A(\\s|\\S)*?)(\\n\\n|\\Z)\"\n descrition_sections = re.findall(\n regex_description_sections, docstring, re.MULTILINE\n )\n description = descrition_sections[0][0] if descrition_sections else \"\"\n sections = re.findall(regex_sections, docstring, re.MULTILINE)\n if not sections and not description:\n description = docstring\n input_list = []\n output_list = []\n if \"Args\" in section_titles or \"Context Outputs\" in section_titles:\n for section in sections:\n if \"Args\" in section:\n lines = section[1].split(\"\\n\")\n # get first indent number\n spaces_num = len(lines[0]) - len(lines[0].lstrip())\n arg_lines = section[1].split(f'\\n{spaces_num*\" \"}')\n for arg_line in arg_lines:\n in_arg, in_arg_type = MetadataToDict.parse_in_argument_lines(\n arg_line, file_import\n )\n if in_arg:\n input_list.append((in_arg, in_arg_type))\n\n if \"Context Outputs\" in section:\n lines = section[1].split(\"\\n\")\n spaces_num = len(lines[0]) - len(lines[0].lstrip())\n out_lines = section[1].split(f'\\n{spaces_num*\" \"}')\n for out_line in out_lines:\n out_arg = MetadataToDict.parse_out_argument_lines(\n out_line,\n )\n if out_arg:\n output_list.append(out_arg)\n\n return description, input_list, output_list", "def write_config_file(input_dict, file_name, entry_char='>',\n attribution_char='=', usekeys=None):\n fp = open(file_name, \"w\")\n fp.write(write_config_string(input_dict, entry_char, attribution_char,\n usekeys))\n fp.close()", "def write(filename, rcdict) :\n\n # open file for writing:\n f = open(filename, 'w')\n\n # loop over key/value pairs:\n for k, v in rcdict.items():\n # add line; at least the specified number of characters \n # is used for the key:\n f.write('%-20s:%s\\n' % (k, v))\n #endfor\n\n # close file:\n f.close()", "def create_document(self, output):\n if not os.path.exists(self.template_path):\n raise IOError('Template file not found.')\n\n documents = []\n with open(self.template_path, 'rb') as f:\n data = f.read()\n template = Template(to_unicode(data))\n indent_targets = ['params', 'response_body']\n for v in self.vars:\n if self.template_path.endswith('.rst'):\n for k in indent_targets:\n lines = v[k].split('\\n')\n ret = []\n for i, l in enumerate(lines):\n if i > 0:\n ret.append(' {0}'.format(l).rstrip())\n else:\n ret.append(l)\n v[k] = '\\n'.join(ret)\n\n document = template.substitute(v)\n documents.append(document)\n\n with open(output, 'w') as f:\n f.write('\\n'.join(documents))" ]

[ "0.61986554", "0.6153944", "0.58657086", "0.57220095", "0.5718355", "0.5694824", "0.5671296", "0.566762", "0.56513095", "0.5645625", "0.56439674", "0.5630535", "0.5581719", "0.55736256", "0.5555813", "0.55523473", "0.5548598", "0.554656", "0.5536558", "0.55274606", "0.5520095", "0.5511453", "0.5504906", "0.550466", "0.54648405", "0.5456658", "0.5444885", "0.5435487", "0.5407391", "0.5398758" ]

[ "def convert_doxygen_docstring(lines, name):\n\n lines = lines[:]\n newlines = []\n indent = 0\n reading_desc = False\n\n while lines:\n line = lines.pop(0)\n if line.startswith(\"////\"):\n continue\n\n line = line.rstrip()\n if line.startswith('///<'):\n strline = line[4:]\n else:\n strline = line\n\n strline = strline.lstrip('/ \\t')\n\n if strline == \"**\" or strline == \"*/\":\n continue\n\n if strline.startswith(\"** \"):\n strline = strline[3:]\n elif strline.startswith(\"* \"):\n strline = strline[2:]\n elif strline == \"*\":\n strline = \"\"\n\n strline = strline.lstrip(' \\t')\n\n if strline.startswith('@'):\n special = strline.split(' ', 1)[0][1:]\n if special == 'par' and strline.endswith(':') and lines and '@code' in lines[0]:\n newlines.append(' '*indent + strline[5:] + ':')\n newlines.append('')\n line = lines.pop(0)\n offset = line.index('@code')\n while lines:\n line = lines.pop(0)\n if '@endverbatim' in line or '@endcode' in line:\n break\n newlines.append(' ' + line[offset:])\n\n newlines.append('')\n continue\n elif special == \"verbatim\" or special == \"code\":\n if newlines and newlines[-1]:\n newlines.append('')\n\n newlines.append('.. code-block:: guess')\n newlines.append('')\n offset = line.index('@' + special)\n while lines:\n line = lines.pop(0)\n if '@endverbatim' in line or '@endcode' in line:\n break\n newlines.append(' ' + line[offset:])\n\n newlines.append('')\n continue\n elif special == \"f[\":\n if newlines and newlines[-1]:\n newlines.append('')\n\n newlines.append('.. math::')\n newlines.append('')\n offset = line.index('@' + special)\n while lines:\n line = lines.pop(0)\n if '@f]' in line:\n break\n newlines.append(' ' + line[offset:])\n\n newlines.append('')\n continue\n elif special == 'param':\n #TODO\n #if extra is not None:\n # _, name, desc = strline.split(' ', 2)\n # extra['param:' + name] = desc\n continue\n elif special == 'deprecated':\n if newlines and newlines[-1]:\n newlines.append('')\n\n _, value = strline.split(' ', 1)\n\n # I'd love to use the proper Sphinx deprecated tag, but it\n # requires a version number, whereas Doxygen doesn't.\n newlines.append('*Deprecated:* ' + convert_doxygen_format(value, name))\n newlines.append('')\n continue\n elif special in ('brief', 'return', 'returns'):\n #TODO\n #if extra is not None:\n # _, value = strline.split(' ', 1)\n # extra[special] = value\n continue\n elif special == 'details':\n strline = strline[9:]\n elif special == 'sa' or special == 'see':\n if newlines and newlines[-1]:\n newlines.append('')\n\n _, value = strline.split(' ', 1)\n values = value.split(',')\n\n for i, value in enumerate(values):\n result = resolve_reference(value.partition('(')[0], name)\n if result:\n values[i] = ':{0}:`{1}`'.format(*result)\n else:\n values[i] = ':obj:`{0}`'.format(value)\n\n if special == 'see':\n newlines.append('See {}.'.format(', '.join(values)))\n else:\n newlines.append('See also {}.'.format(', '.join(values)))\n newlines.append('')\n continue\n elif special in ('note', 'warning'):\n if newlines and newlines[-1]:\n newlines.append('')\n\n newlines.append('.. %s:: ' % (special))\n newlines.append('')\n newlines.append(' ' + convert_doxygen_format(strline[2 + len(special):], name))\n while lines and lines[0].strip(' *\\t/'):\n line = lines.pop(0).lstrip(' *\\t')\n newlines.append(' ' + convert_doxygen_format(line, name))\n\n newlines.append('')\n continue\n elif special == 'since':\n if newlines and newlines[-1]:\n newlines.append('')\n\n newlines.append('.. versionadded:: ' + strline[7:])\n newlines.append('')\n continue\n else:\n print(\"Unhandled documentation tag: @\" + special)\n\n if strline or len(newlines) > 0:\n newlines.append(' '*indent + convert_doxygen_format(strline, name))\n\n return newlines", "def main_docstring():", "def scan_docs():\n\n\n def scan_file(fn):\n f = open(fn)\n\n for l in f:\n m = re.search(r\"\\.\\. (\\w+):: ([.\\w+]+)\", l)\n\n if not m:\n continue\n\n name_kind[m.group(2)] = m.group(1)\n\n for i in os.listdir(\"source\"):\n if i.endswith(\".rst\"):\n scan_file(os.path.join(\"source\", i))\n\n for i in os.listdir(\"source/inc\"):\n scan_file(os.path.join(\"source\", \"inc\", i))", "def load_docs(direc, lemmatize, labelMapFile='labels.csv'):\n\n\n labelMap = {} # docID => gold label, loaded from mapping file\n with open(os.path.join(direc, labelMapFile)) as inF:\n for ln in inF:\n docid, label = ln.strip().split(',')\n assert docid not in labelMap\n labelMap[docid] = label\n\n # create parallel lists of documents and labels\n docs, labels = [], []\n for file_path in glob.glob(os.path.join(direc, '*.txt')):\n filename = os.path.basename(file_path)\n labels.append(labelMap[filename])\n with open(file_path) as f:\n doc = f.read().split()\n # credit: http://stackoverflow.com/questions/13259288/returning-a-list-of-words-after-reading-a-file-in-python\n # print(\"lemma\")\n if lemmatize:\n docs.append([lm.lemmatize(word) for word in doc])\n else:\n docs.append(doc)\n #print(\"finish lemma\")\n\n return docs, labels", "def __init__(self, c: Cmdr) -> None:\n # pylint: disable=super-init-not-called\n self.c = c\n self.init_language()\n fn = self.find_user_dict()\n self.d: dict[str, str] = self.open_dict_file(fn)\n g.app.spellDict = self.d", "def load_doc_config(self):\n parser_aliases = dexy.parser.Parser.aliases\n for k in parser_aliases.keys():\n if os.path.exists(k):\n self.log.debug(\"found doc config file '%s'\" % k)\n parser = parser_aliases[k](self)\n with open(k, \"r\") as f:\n parser.parse(f.read())", "def clean_module(file_dir, old_dir, lang, dict):\r\n\tword_list = []\r\n\tmake_old_directory(file_dir, old_dir) # step 6\r\n\tfile_list = read_files(file_dir, \"lab\") # step 7\r\n\tfor file in file_list:\r\n\t\twith codecs.open(file, 'r') as f:\r\n\t\t\ttext = f.read()\r\n\t\tfilename = file.replace(file_dir, '')\r\n\t\ttext = clean_text(lang, text) # step 8ci\r\n\t\tif dict == True:\r\n\t\t\tword_list = store_to_dictionary(text, word_list) # step 8cii\r\n\t\tmove_old_lab(file_dir, old_dir, filename) # step 8ciii\r\n\t\twrite_to_lab(file_dir, filename, text) # step 8civ\r\n\t\t\r\n\tif dict == True and word_list != []:\r\n\t\tmake_dictionary_file(file_dir, word_list) # step 9\r", "def __init__(self,\n source_path='./*.py',\n template_path='./docs/templates/*_template.md',\n output_path='./docs/documentation.md',\n ignore=['extra']\n ):\n\n template_files = glob.glob(template_path)\n # filename = t.split('/')[-1]\n self.sources = {os.path.basename(s).split('.')[0]: os.path.normpath(s) for s in glob.glob(source_path) if not any(i in s for i in ignore)}\n self.templates = {os.path.basename(t).split('_')[0]: os.path.normpath(t) for t in template_files}\n self.output_path = output_path\n\n self.template_content = {}\n for k, v in self.templates.items():\n path = v\n with open(path, 'r') as template_file:\n self.template_content[k] = template_file.read()\n\n self.text = ''\n self.classes = []\n self.headers = ['Params', 'Returns', 'Attributes']\n self.hierarchy = [\n 'class',\n 'method',\n 'parameter',\n 'pinfo',\n 'extra'\n ]\n self.tab_length = 6", "def store_documentation(self, file_path, *args, **dargs):\n pass", "def main():\n # We know that qidoc build will set the correct cwd\n qibuild_dir = \"..\"\n qibuild_dir = os.path.abspath(qibuild_dir)\n this_file = __file__\n this_dir = os.path.dirname(this_file)\n cmake_api = os.path.join(this_dir, \"../source/advanced/cmake/api\")\n cmake_api = os.path.abspath(cmake_api)\n if not os.path.exists(cmake_api):\n os.makedirs(cmake_api)\n qibuild_cmake = os.path.join(qibuild_dir, \"cmake\", \"qibuild\")\n for filename in DOCUMENTED_FILES:\n cmake_file = os.path.join(qibuild_cmake, filename + \".cmake\")\n rst_file = os.path.join(cmake_api, filename + \".rst\")\n gen_cmake_doc(cmake_file, rst_file)", "def google_docstring_to_dict(\n docstring: Optional[str],\n file_import: Optional[Any] = None,\n ) -> Tuple[str, list, list]:\n\n if not docstring:\n return \"\", [], []\n\n regex_sections = r\"^(?: {4}|\\t)(?P<name>\\*{0,4}\\w+|\\w+\\s\\w+):\\n(?P<desc>(?:(\\s|\\S)*?(\\n\\n|\\Z)))\"\n regex_titles = r\"^(?: {4}|\\t)(?P<name>\\*{0,4}\\w+|\\w+\\s\\w+):\"\n section_titles = re.findall(regex_titles, docstring, re.MULTILINE)\n regex_description_sections = r\"(?P<desc>\\A(\\s|\\S)*?)(\\n\\n|\\Z)\"\n descrition_sections = re.findall(\n regex_description_sections, docstring, re.MULTILINE\n )\n description = descrition_sections[0][0] if descrition_sections else \"\"\n sections = re.findall(regex_sections, docstring, re.MULTILINE)\n if not sections and not description:\n description = docstring\n input_list = []\n output_list = []\n if \"Args\" in section_titles or \"Context Outputs\" in section_titles:\n for section in sections:\n if \"Args\" in section:\n lines = section[1].split(\"\\n\")\n # get first indent number\n spaces_num = len(lines[0]) - len(lines[0].lstrip())\n arg_lines = section[1].split(f'\\n{spaces_num*\" \"}')\n for arg_line in arg_lines:\n in_arg, in_arg_type = MetadataToDict.parse_in_argument_lines(\n arg_line, file_import\n )\n if in_arg:\n input_list.append((in_arg, in_arg_type))\n\n if \"Context Outputs\" in section:\n lines = section[1].split(\"\\n\")\n spaces_num = len(lines[0]) - len(lines[0].lstrip())\n out_lines = section[1].split(f'\\n{spaces_num*\" \"}')\n for out_line in out_lines:\n out_arg = MetadataToDict.parse_out_argument_lines(\n out_line,\n )\n if out_arg:\n output_list.append(out_arg)\n\n return description, input_list, output_list", "def lint_file_overview() -> Dict[str, str]:\n folder_file_docstring = generate_folder_file_docstrings_dict()\n existing_doc_dict = extract_docstrings_from_file_overview()\n # folders and files which return error while linting are stored under\n # error_message_dict with their respective error messages\n error_message_dict = {}\n for folder in folder_file_docstring:\n # check if the folder for the docstring is present or not\n if folder in existing_doc_dict:\n for file in folder_file_docstring[folder]:\n # check if the file under the folder is present or not\n if file in existing_doc_dict[folder]:\n # check if docstrings match or not\n if (\n folder_file_docstring[folder][file]\n != existing_doc_dict[folder][file]\n ):\n error_message_dict[\n f\"{folder}/{file}\"\n ] = f\"Docstrings do not match those listed in {DEVELOPER_DOC_NAME}\"\n del existing_doc_dict[folder][file]\n else:\n error_message_dict[\n f\"{folder}/{file}\"\n ] = f\"File does not exist in {DEVELOPER_DOC_NAME}\"\n # if the folder dictionary is empty, delete it from the existing_doc_dict\n if not existing_doc_dict[folder]:\n del existing_doc_dict[folder]\n else:\n error_message_dict[folder] = f\"Folder not present in {DEVELOPER_DOC_NAME}\"\n\n # for docstrings in DESC_FOR_NO_FILE_FOLDERS\n for folder_name in DESC_FOR_NO_FILE_FOLDERS:\n if (\n DESC_FOR_NO_FILE_FOLDERS[folder_name]\n != existing_doc_dict[folder_name][\"no_file_present\"]\n ):\n error_message_dict[\n folder_name\n ] = f\"Docstrings do not match those listed in {DEVELOPER_DOC_NAME}\"\n del existing_doc_dict[folder_name]\n\n # check if there are any docstrings in the overview file\n # for which folder/file has been removed\n if existing_doc_dict:\n for folder_name in existing_doc_dict:\n if existing_doc_dict[folder_name]:\n for file_name in existing_doc_dict[folder_name]:\n error_message_dict[\n f\"{folder_name}/{file_name}\"\n ] = \"Folder/File for this docstring has been removed\"\n return error_message_dict", "def __init__ (self, isInternal, docstring, name, args, isConst):\n\n self.name = name\n self.isConst = isConst\n self.isInternal = isInternal\n\n if isInternal:\n if language == 'java':\n # We have a special Javadoc doclet that understands a non-standard\n # Javadoc tag, @internal. When present in the documentation string\n # of a method, it causes it to be excluded from the final\n # documentation output. @internal is something doxygen offers.\n #\n p = re.compile('(\\s+?)\\*/', re.MULTILINE)\n self.docstring = p.sub(r'\\1* @internal\\1*/', docstring)\n elif language == 'csharp':\n # We mark internal methods in a different way for C#.\n self.docstring = docstring\n else:\n self.docstring = \" @internal\\n\" + docstring\n else:\n self.docstring = docstring\n\n # In Java and C#, if a method is const and swig has to translate the type,\n # then for some reason swig cannot match up the resulting doc strings\n # that we put into %javamethodmodifiers. The result is that the java\n # documentation for the methods are empty. I can't figure out why, but\n # have figured out that if we omit the argument list in the doc string\n # that is put on %javamethodmodifiers for such case, swig does generate \n # the comments for those methods. This approach is potentially dangerous\n # because swig might attach the doc string to the wrong method if a\n # methods has multiple versions with varying argument types, but the\n # combination doesn't seem to arise in antimony currently, and anyway,\n # this fixes a real problem in the Java documentation for antimony.\n\n if language == 'java' or language == 'csharp':\n if isConst and (args.find('unsigned int') >= 0):\n self.args = ''\n elif not args.strip() == '()':\n if isConst:\n self.args = args + ' const'\n else:\n self.args = args\n else:\n if isConst:\n self.args = '() const'\n else:\n self.args = ''\n else:\n self.args = args", "def genlangs(self):\r\n raise NotImplementedError", "def do_docs(self, path):\n print(\"scaraping documentation\")\n for p in path.glob(\"**/*\"):\n if p.is_file():\n parts = p.relative_to(path).parts\n if parts[-1].endswith(\"rst\"):\n data = tsparse(p.read_bytes())\n blob = DocBlob()\n blob.arbitrary = data\n blob.content = {}\n\n blob.ordered_sections = []\n blob.item_file = None\n blob.item_line = None\n blob.item_type = None\n blob.aliases = []\n blob.example_section_data = Section()\n blob.see_also = []\n blob.signature = None\n blob.references = None\n blob.refs = []\n\n self.docs[parts] = json.dumps(blob.to_json(), indent=2)\n else:\n pass\n # data = p.read_bytes()", "def _read_files(self):\n \n for langname in self.langnames:\n filename = f'data/word_lists/{langname}.txt'\n with open(filename) as f:\n index = self.langnames.index(langname)\n lang_list = getattr(self, f'word_list{index}')\n words = f.readlines()\n for word in words:\n fword = ''.join(char for char in word if char is not '\\n')\n lang_list.append(fword)\n f.close()\n return", "def extract_docstrings_from_file_overview() -> Dict[str, Dict[str, str]]:\n with open(DEVELOPER_DOC_PATH, \"r\") as file:\n doc_data = file.readlines()\n\n existing_doc_dict: Dict[str, Dict[str, str]] = {}\n\n # table is present from line TABLE_OFFSET to (length - 1)\n for doc_row in doc_data[TABLE_OFFSET - 1 :]:\n _, folder, filename, docstring, _ = doc_row.split(\"|\")\n folder, filename = folder.strip(), filename.strip()\n if folder:\n # For files under a folder but no folder value in overview file (eg. core.py)\n folder_name = folder\n existing_doc_dict[str(folder_name)] = {}\n if docstring.strip():\n if filename:\n existing_doc_dict[folder_name][filename] = docstring.strip()\n else:\n existing_doc_dict[folder_name][\"no_file_present\"] = docstring.strip()\n return existing_doc_dict", "def __init__ (self, languageFilename):\n if not isinstance(languageFilename, str): # Checks if the filename is entered as a string.\n raise TypeError('The filename must be a string')\n self._words = set()\n try:\n with open(languageFilename) as data:\n line = data.readline()\n while line:\n line = line.rstrip()\n self._words.add(line)\n line = data.readline()\n except IOError:\n print('Please specify the correct name for the dictionary')", "def __init__(self, filePath = None, savePath = None, stop_puncs=\"./data/stoppuncs.txt\", stop_words=\"./data/stopwords.txt\", norm_words=\"./data/normwords.txt\"):\n\n\t\tself.super = super(DocumentPlus, self)\t# Assign self.super the parent class Document\n\t\tself.super.__init__(filePath, savePath)\t# Initialize the parent class Document\n\t\t\n\t\tself.stop_puncs = self.open(stop_puncs).split()\n\t\tself.stop_words = self.open(stop_words).split()\n\t\tself.norm_words = dict()\n\n\t\t# initialize the norm_words variable\n\t\tfor line in self.open(norm_words, splitLines=True, splitTabs=True):\n\n\t\t\tcontractions \t= line[0].split(';')\n\t\t\tnormalized_word = line[-1]\n\n\t\t\tfor contraction in contractions:\n\t\t\t\tself.norm_words[contraction] = normalized_word", "def __init__(self, c: Cmdr) -> None:\n # pylint: disable=super-init-not-called\n self.c = c\n if not g.app.spellDict:\n g.app.spellDict = DefaultDict()\n self.d = g.app.spellDict\n self.user_fn = self.find_user_dict()\n if not g.os_path_exists(self.user_fn):\n # Fix bug 1175013: leo/plugins/spellpyx.txt is\n # both source controlled and customized.\n self.create(self.user_fn)\n self.main_fn = self.find_main_dict()\n table = (\n ('user', self.user_fn),\n ('main', self.main_fn),\n )\n for kind, fn in table:\n if fn:\n words = self.read_words(kind, fn)\n self.d.add_words_from_dict(kind, fn, words)", "def GdictWrite(filename=\"turtle_docstringdict\"):\n docsdict = {}\n\n for methodname in gScreenFunc:\n key = \"_Screen.\"+methodname\n docsdict[key] = eval(key).__doc__\n for methodname in gMoveFunc:\n key = \"Myturtle.\"+methodname\n docsdict[key] = eval(key).__doc__\n\n with open(\"%s.py\" % filename,\"w\") as f:\n keys = sorted(x for x in docsdict\n if x.split('.')[1] not in _alias_list)\n f.write('docsdict = {\\n\\n')\n for key in keys[:-1]:\n f.write('%s :\\n' % repr(key))\n f.write(' \"\"\"%s\\n\"\"\",\\n\\n' % docsdict[key])\n key = keys[-1]\n f.write('%s :\\n' % repr(key))\n f.write(' \"\"\"%s\\n\"\"\"\\n\\n' % docsdict[key])\n f.write(\"}\\n\")\n f.close()", "def __init__(self, *args, **kwargs) -> None:\n super().__init__(*args, **kwargs)\n self._lines: TokenLines = defaultdict(list)\n self._docstrings = get_docstring_tokens(self.file_tokens)", "def lispdoc(self, irc, msg, args, num, req):\n self.googleq('http://lispdoc.com/', req, num, irc)", "def fetch_from_md(file_name, lang=constant.DEFAULT_LANGUAGE, limit=constant.DEFAULT_LIMIT):\n\n with open(file_name, 'r') as file:\n content = file.read()\n words = re.findall(r'\\[(\\w+[^]]*)\\]\\(\\)', content)\n words_links = dict()\n for word in words:\n words_links.update(fetch(word, code=lang, limit=limit))\n with open(file_name, 'w') as file_w:\n file_w.write(mdLinker.replace_in_md(content, words_links))\n return words", "def test_doc_with_comments():\n doc = CoNLL.conll2doc(input_str=RUSSIAN_SAMPLE)\n check_russian_doc(doc)", "def updateDocFiles(self):\n for filename, filetype in self._get_doc_files():\n lines = open(filename).readlines()\n\n if self.Verbose:\n print 'Reading %s' % filename\n \n if filename.endswith('conf.py'):\n lines, write_out = self._update_doc_conf_file(lines, filename)\n else:\n raise TypeError, \"Unknown doc file type: %s\" % filetype\n\n if write_out:\n self._file_writer(lines, filename)", "def load_words(): \r\n return lw.load_words()", "def main():\r\n\tlang = get_arguments()\r\n\twiki_analyzer(lang)", "def get_help_strings():\n info = {}\n header = \"\"\n with open(\"opsbot/helpdoc.md\") as f:\n content = f.readlines()\n\n for line in content:\n line = line.strip()\n if line.startswith(\"#\"):\n header = line.replace(\"#\", \"\").strip().lower()\n elif not line.startswith(\"#\") and line:\n info[header] = line\n header = \"\"\n\n return info", "def inheritdocstrings(cls):\n for name, func in vars(cls).items():\n if isinstance(func, types.FunctionType) and not func.__doc__:\n for parent in cls.__bases__:\n parfunc = getattr(parent, name, None)\n if parfunc and getattr(parfunc, '__doc__', None):\n func.__doc__ = parfunc.__doc__\n break\n return cls" ]

[ "0.5545969", "0.5444798", "0.5415546", "0.53539515", "0.5306852", "0.5291794", "0.5276163", "0.5273808", "0.5238084", "0.51521593", "0.51123774", "0.51029795", "0.51015687", "0.50694877", "0.5067063", "0.50619537", "0.5060623", "0.5039005", "0.5029071", "0.5023167", "0.5008531", "0.49806276", "0.49795356", "0.49760136", "0.49632838", "0.4962577", "0.49596393", "0.493596", "0.49311975", "0.49309376" ]

[ "def _serialize_date(val):\n return date_to_iso8601(val)", "def _serialize_datetime(val):\n return datetime_to_iso8601(val)", "def serialize(date):\n # From database to client\n\n # Convert date-object to datetime\n # See: https://stackoverflow.com/questions/1937622/convert-date-to-datetime-in-python\n dt = datetime.combine(date, datetime.min.time())\n date_format = \"%Y-%m-%d\"\n return datetime.strftime(dt, date_format)", "def test_datetime_encoding(self):\n data = {\n 'date': datetime.datetime(1970, 2, 3, 11, 20, 42),\n 'int': 4,\n 'str': 'string'\n }\n s = json.dumps(data, cls=stellr.stellr.StellrJSONEncoder)\n self.assertEqual(\n s, '{\"date\": \"1970-02-03T11:20:42Z\", \"int\": 4, \"str\": \"string\"}')", "def json_serialize_datetime(self, obj):\n if isinstance(obj, datetime.datetime):\n return int(time.mktime(obj.timetuple()))\n\n raise TypeError(\"Type %s not serializable\" % type(obj))", "def to_datetime(date_string):\n return dt.strptime(date_string, '%Y-%m-%d')", "def serialize_dt(value):\n return value.isoformat() if hasattr(value, 'isoformat') else value", "def date_to_python(self, value):\r\n # this throws away fractions of a second\r\n return datetime(*strptime(value[:-5], \"%Y-%m-%dT%H:%M:%S\")[0:6])", "def serialize_datetime(self, obj):\r\n if isinstance(obj, datetime.datetime):\r\n return obj.isoformat()\r\n raise TypeError(\"Type not serializable\")", "def test_json_to_date(self):\n json_date_string = \"2018-10-13 12:12:12\"\n the_date = ct.json_to_date(json_date_string)\n assert isinstance(the_date, datetime)\n assert the_date.year == 2018\n assert the_date.month == 10", "def to_datetime(self, raw_date_str):\n if raw_date_str is None:\n return ''\n dateformat = '%Y-%m-%dT%H:%M:%S'\n date_str = raw_date_str\n if raw_date_str.endswith('Z'):\n date_str = date_str[:-1]\n dt = datetime.strptime(date_str, dateformat)\n return dt", "def decode_datetime(self, string):\n if isinstance(string, str):\n if 'T' in string:\n return datetime.strptime(string, \"%Y%m%dT%H%M%S\")\n else:\n return datetime.strptime(string, \"%Y%m%d\")\n else:\n return string", "def _str_to_date(self, date):\n return datetools.date_parser(date)", "def deserialize_date(string):\n try:\n from dateutil.parser import parse\n return parse(string).date()\n except ImportError:\n return string", "def str2date(s):\n return datetime.strptime(s.decode(), \"%Y-%m-%d %H:%M:%S\")", "def dump_datetime(value):\n return value.strftime('%Y-%m-%dT%H:%M:%SZ')", "def convert_str2date(date):\n import datetime\n date = str(date)\n year = int(date[0:4])\n month = int(date[4:6])\n day = int(date[6:8])\n return datetime.datetime(year,month,day)", "def test_date_to_json(self):\n now = datetime.now()\n the_date = datetime(2018, 10, 13, 12, 12, 12)\n assert ct.date_to_json(the_date) == \"2018-10-13 12:12:12\"\n assert isinstance(ct.date_to_json(), str)\n assert ct.date_to_json()[:4] == str(now.year)", "def _serialize_datetime(cls, dt): # pylint: disable=invalid-name\n if dt:\n return JSONEncoder().default(dt)\n return None", "def str_to_date(date_as_str):\n date_time_obj = datetime.datetime.strptime(date_as_str, '%Y-%m-%d').date()\n return date_time_obj", "def date(self):\n return self._parse_date(self.value)", "def serialize_datetime(date_time) -> timezone:\n if isinstance(date_time, struct_time):\n return timezone.datetime.fromtimestamp(mktime(date_time)).replace(tzinfo=pytz.UTC)\n else:\n raise TypeError(\"Can't convert this type to datetime\")", "def _date_to_datetime(value):\r\n assert isinstance(value, datetime.date)\r\n return datetime.datetime(value.year, value.month, value.day)", "def str_to_date(st):\r\n return datetime.strptime(st, '%Y-%m-%dT%H:%M:%S.%fZ')", "def _parse(self, date_str, format='%Y-%m-%d'):\n from pandas import to_datetime\n rv = to_datetime(date_str, format=format)\n if hasattr(rv, 'to_datetime'):\n rv = rv.to_datetime()\n return rv", "def _parse_date(date_str: str) -> datetime:\n datetime_obj = datetime.strptime(date_str, \"%Y-%m-%dT%H:%M:%SZ\")\n return f\"<t:{int(datetime_obj.timestamp())}:d>\"", "def _get_datetime(date):\n return datetime.strptime(date, '%Y-%m-%dT%H:%M:%S.000%z')", "def parse_date(str_date):\n return ciso8601.parse_datetime(str_date)", "def to_python(self, value):\n return string_to_partialdate(value)", "def to_datetime(dt_str):\n return datetime.datetime.strptime(dt_str, \"%Y-%m-%dT%H:%M:%S.%f\")" ]

[ "0.71354926", "0.68498755", "0.66490716", "0.6419961", "0.6376044", "0.63656783", "0.6365236", "0.63495934", "0.6346184", "0.634235", "0.6338759", "0.62420154", "0.62168455", "0.62115145", "0.619565", "0.6186587", "0.6179467", "0.61690307", "0.6158575", "0.6152683", "0.61498827", "0.6112713", "0.6107024", "0.6080981", "0.60739183", "0.60587466", "0.60526735", "0.6052632", "0.6033149", "0.60290027" ]

[ "def cached_property(func):\n return Property(fget=func, cached=True)", "def cached_property(fun):\n @functools.wraps(fun)\n def get(self):\n try:\n return self._cache[fun]\n except AttributeError:\n self._cache = {}\n except KeyError:\n pass\n ret = self._cache[fun] = fun(self)\n return ret\n return property(get)", "def memoized(fget):\n attr_name = \"_{0}\".format(fget.__name__)\n\n @wraps(fget)\n def fget_memoized(self):\n if not hasattr(self, attr_name):\n setattr(self, attr_name, fget(self))\n return getattr(self, attr_name)\n\n return property(fget_memoized)", "def cached_property(expensive_function):\n @property\n def caching_function(self):\n cacheName = f\"__cache__{expensive_function.__name__}\"\n \n\t\t\n try: # check if the cache has been initialized\n cacheExists = True\n cache = getattr(self, cacheName)\n except AttributeError:\n cacheExists = False\n cache = None\n \n\t\t# Check if the cache is valid (not None), caching is requested, and that it exists\n if ( cache is not None ) and ( self.withCaching == True ) and (cacheExists == True):\n return cache\n else:\n\t\t\t#worst case, now we have to compute the quantity\n computed = expensive_function(self)\n setattr(self, cacheName, computed)\n return computed\n \n return caching_function", "def cached_property(f):\r\n def get(self):\r\n try:\r\n return self._property_cache[f]\r\n except AttributeError:\r\n self._property_cache = {}\r\n x = self._property_cache[f] = f(self)\r\n return x\r\n except KeyError:\r\n x = self._property_cache[f] = f(self)\r\n return x\r\n \r\n return property(get)", "def memoized_property(method):\n\n method_name = method.__name__\n attr_name = \"_\" + method_name\n undefined = object()\n\n def wrapped(self):\n attr = getattr(self, attr_name, undefined)\n if attr is undefined:\n attr = method(self)\n setattr(self, attr_name, attr)\n return attr\n\n wrapped = property(wrapped)\n return wrapped", "def lazyproperty(f: Callable[..., Any]):\n # pylint: disable=unused-variable\n return property(functools.lru_cache(maxsize=100)(f))", "def lazyprop(fn):\n\n @property\n def _lazyprop(self):\n if not hasattr(self, _LAZY_PROP_VALUES):\n setattr(self, _LAZY_PROP_VALUES, {})\n lazy_props_dict = self.__dict__[_LAZY_PROP_VALUES]\n if fn.__name__ not in lazy_props_dict:\n lazy_props_dict[fn.__name__] = fn(self)\n return lazy_props_dict[fn.__name__]\n\n return _lazyprop", "def test_cached_property():\n new_value = \"99999\"\n\n class DummyClass:\n def __init__(self):\n self.value = \"11111\"\n\n def change_value_in_instance(self, value):\n self.value = value\n\n @cached_property\n def test_property(self):\n return self.value\n\n @property\n def test_uncached_property(self):\n return self.value\n\n testClass = DummyClass()\n first_cached_test_property = testClass.test_property\n first_uncached_test_property = testClass.test_uncached_property\n testClass.change_value_in_instance(new_value)\n second_cached_test_property = testClass.test_property\n second_uncached_test_property = testClass.test_uncached_property\n\n assert first_cached_test_property == second_cached_test_property\n assert first_cached_test_property == \"11111\"\n\n assert first_uncached_test_property != second_uncached_test_property\n assert first_uncached_test_property == \"11111\"\n assert second_uncached_test_property == \"99999\"", "def memoization(function):\n\n def _decorator_(self):\n key = function.__name__\n value = memoization_get(self, key)\n if value is not None:\n return value\n else:\n value = function(self)\n memoization_set(self, key, value)\n return value\n\n _decorator_.__doc__ = function.__doc__\n return _decorator_", "def decorator(method):\n\n def wrapper(self):\n \"\"\"\n decorates the given method or property and makes it a lazy one.\n\n :returns: method or property result.\n \"\"\"\n\n result = caching_services.try_get('permanent', method, self)\n if result is not None:\n return result\n\n result = method(self)\n caching_services.try_set('permanent', result, method, self)\n return result\n\n return update_wrapper(wrapper, method)", "def memoize(func):\n\n @wraps(func)\n def wrapped():\n try:\n return func.result\n except AttributeError:\n pass\n\n func.result = func()\n return func.result\n\n return wrapped", "def memoize(obj):\n cache = obj.cache = {}\n\n @functools.wraps(obj)\n def memoizer(*args, **kwargs):\n key = str(args) + str(kwargs)\n if key not in cache:\n cache[key] = obj(*args, **kwargs)\n return cache[key]\n return memoizer", "def memoize(obj):\n cache = obj.cache = {}\n\n @functools.wraps(obj)\n def memoizer(*args, **kwargs):\n key = str(args) + str(kwargs)\n if key not in cache:\n cache[key] = obj(*args, **kwargs)\n return cache[key]\n return memoizer", "def memoize(obj):\n cache = obj.cache = {}\n\n @functools.wraps(obj)\n def memoizer(*args, **kwargs):\n key = str(args) + str(kwargs)\n if key not in cache:\n cache[key] = obj(*args, **kwargs)\n return cache[key]\n return memoizer", "def memoize(obj):\n cache = obj.cache = {}\n\n @functools.wraps(obj)\n def memoizer(*args, **kwargs):\n key = str(args) + str(kwargs)\n if key not in cache:\n cache[key] = obj(*args, **kwargs)\n return cache[key]\n\n return memoizer", "def memoize(func):\n @wraps(func)\n def memoizer(self):\n if not hasattr(self, '_cache'):\n self._cache = {}\n if func.__name__ not in self._cache:\n self._cache[func.__name__] = func(self)\n return self._cache[func.__name__]\n return memoizer", "def memoize(func):\n memo = None\n\n @wraps(func)\n def wrapper(self):\n if memo is not None:\n return memo\n\n return func(self)\n\n return wrapper", "def Property(name):\n\n attr_name = \"__\" + name\n\n def get(self):\n try:\n return self.__dict__[attr_name]\n except KeyError:\n raise AttributeError, name\n\n def set(self, value):\n if attr_name not in self.__dict__ \\\n or self.__dict__[attr_name] != value:\n self.__dict__[attr_name] = value\n self.is_modified = True\n\n return property(get, set)", "def memoize(func):\r\n func.cache = {}\r\n return decorator(_memoize, func)", "def lazy(fn):\n attr_name = '_lazy_' + fn.__name__\n @property\n def _lazyprop(self):\n if not hasattr(self, attr_name):\n setattr(self, attr_name, fn(self))\n return getattr(self, attr_name)\n return _lazyprop", "def CheckFactory(cached_property_decorator, threadsafe=False):\n\n class Check(object):\n\n cached_total = 0\n lock = Lock()\n\n @cached_property_decorator\n def add_cached(cls):\n if threadsafe:\n time.sleep(1)\n # Need to guard this since += isn't atomic.\n with cls.lock:\n cls.cached_total += 1\n else:\n cls.cached_total += 1\n return cls.cached_total\n\n def run_threads(self, num_threads):\n threads = []\n for _ in range(num_threads):\n thread = Thread(target=lambda: self.add_cached)\n thread.start()\n threads.append(thread)\n for thread in threads:\n thread.join()\n\n return Check", "def _cache_property_accessor(self, name):\n try:\n methods = self.instance_properties[name]\n except KeyError:\n methods = self._cache_property_methods(name)\n self.instance_properties[name] = methods\n if methods:\n return methods[0]\n return None", "def _cache_property_mutator(self, name):\n try:\n methods = self.instance_properties[name]\n except KeyError:\n methods = self._cache_property_methods(name)\n self.instance_properties[name] = methods\n if methods:\n return methods[1]\n return None", "def memoize(obj):\r\n cache = obj.cache = {}\r\n\r\n @functools.wraps(obj)\r\n def memoizer(*args, **kwargs):\r\n key = str(args) + str(kwargs)\r\n if key not in cache:\r\n cache[key] = obj(*args, **kwargs)\r\n # only keep the most recent 100 entries\r\n if len(cache) > 100:\r\n cache.popitem(last=False)\r\n return cache[key]\r\n return memoizer", "def memoize(decorated, memo):\n key = convert_to_hashable(decorated.args, decorated.kwargs)\n if key in memo:\n return memo[key]\n res = decorated(*decorated.args, **decorated.kwargs)\n memo[key] = res\n return res", "def cached(key):\n\n def decorator(fn):\n def decorated(cls):\n value = cls.get_cache(key)\n if value is not None:\n return value\n else:\n value = fn(cls)\n cls.set_cache(key, value)\n return value\n\n return decorated\n\n return decorator", "def memoize(cls, func, *args, **kw):\n with cls._locks[func], cls._lock:\n if not isinstance(args, collections.Hashable):\n result = func(*args, **kw)\n return result\n if kw:\n # frozenset is used to ensure hashability\n key = args, frozenset(kw.items())\n else:\n key = args\n # func.cache attribute added by memoize\n cache = cls._caches[func]\n try:\n if key in cache:\n result = cache[key].result\n cls.shrink_cache()\n return result\n except TypeError:\n result = func(*args, **kw)\n return result\n\n start = time.time()\n result = func(*args, **kw)\n end = time.time()\n duration = end - start\n\n cache[key] = CacheEntry(func, key, duration, result,\n kw.get('expiration'), *args, **kw)\n cls.shrink_cache()\n cls._cache.append(cache[key])\n return result", "def _cache_property_methods(self, name):\n if name.endswith(\"_\"):\n # If the requested name ends with _, that's a marker that we're\n # dealing with a method call, not a property, so we can shortcut\n # the process.\n methods = None\n else:\n # Check 1: Does the class respond to the property?\n responds = libobjc.class_getProperty(self, name.encode(\"utf-8\"))\n\n # Check 2: Does the class have an instance method to retrieve the given name\n accessor = self._cache_method(name)\n\n # Check 3: Is there a setName: method to set the property with the given name\n mutator = self._cache_method(\"set\" + name[0].title() + name[1:] + \":\")\n\n # Check 4: Is this a forced property on this class or a superclass?\n forced = False\n superclass = self\n while superclass is not None:\n if name in superclass.forced_properties:\n forced = True\n break\n superclass = superclass.superclass\n\n # If the class responds as a property, or it has both an accessor *and*\n # and mutator, then treat it as a property in Python.\n if responds or (accessor and mutator) or forced:\n methods = (accessor, mutator)\n else:\n methods = None\n return methods", "def memo(func):\n cache = {}\n\n @functools.wraps(func)\n def wrapper(*args, **kwargs):\n key = str(args) + str(kwargs)\n try:\n return cache[key]\n except KeyError:\n rc = func(*args, **kwargs)\n cache[key] = rc\n return rc\n return wrapper" ]

[ "0.74533105", "0.7447887", "0.733369", "0.7268538", "0.7268411", "0.7180744", "0.7005188", "0.68395853", "0.6735997", "0.6628319", "0.65378666", "0.6476915", "0.64601874", "0.64601874", "0.64601874", "0.6451155", "0.64159197", "0.6384591", "0.6326874", "0.6313788", "0.62631667", "0.6236663", "0.6223233", "0.6175977", "0.6156", "0.602406", "0.60059464", "0.6005792", "0.5995057", "0.5984389" ]

[ "def __parse_user_keyfiles(self):\n\n user_sshdir = os.path.expanduser('~/.ssh')\n if not os.path.isdir(user_sshdir):\n return\n\n paths = []\n for filename in os.listdir(user_sshdir):\n if filename in SSH_CONFIG_FILES or os.path.splitext(filename)[1] != '.pub':\n continue\n path = os.path.join(user_sshdir, filename)\n if os.path.isfile(path):\n paths.append(path)\n for path in paths:\n try:\n sshkey = SSHKeyFile(self, path)\n except SSHKeyError as e:\n self.log.debug(e)\n continue\n\n self[sshkey.path] = sshkey", "def getUsers(self):\n return [u[0] for u in pwd.getpwall()\n if (u[5].startswith('/home/') and u[6].endswith('sh'))]", "def get_ssh_keys(self, user_id):\n _gu = self.get_user(user_id)\n if _gu is None:\n return []\n\n # build URL and make request\n return self._get('/users/{0}/keys'.format(_gu['id']))", "def getAuthorizedKeysFiles(self, credentials):\n #pwent = self._userdb.getpwnam(credentials.username)\n #root = FilePath(pwent.pw_dir).child('.ssh')\n #files = ['authorized_keys', 'authorized_keys2']\n #return [root.child(f) for f in files]\n return self._files", "def getssh():\n return Path.home() / \".ssh\"", "def find_juju_ssh_keys():\n\n paths = []\n paths.append(os.path.expanduser(\"~/.local/share/juju/ssh\"))\n\n for path in paths:\n if os.path.exists(path):\n private = os.path.expanduser(\"{}/juju_id_rsa\".format(path))\n public = os.path.expanduser(\"{}/juju_id_rsa.pub\".format(path))\n if os.path.exists(private) and os.path.exists(public):\n return (private, public)\n return (None, None)", "def listusers():\n allusers = []\n with open('/etc/passwd', 'r') as pw:\n for l in pw.readlines():\n allusers.append(l.split(':')[0])\n users = [ d for d in os.listdir(\"/home\") if d in allusers ]\n return(users)", "def _getSshDir():\n return f'{Path.home()}/.ssh'", "def GetAllUserFiles(user, mkdir=False, dircheck=True, _homedir_fn=None):\n helper = compat.partial(GetUserFiles, user, mkdir=mkdir, dircheck=dircheck,\n _homedir_fn=_homedir_fn)\n result = [(kind, helper(kind=kind)) for kind in constants.SSHK_ALL]\n\n authorized_keys = [i for (_, (_, _, i)) in result]\n\n assert len(frozenset(authorized_keys)) == 1, \\\n \"Different paths for authorized_keys were returned\"\n\n return (authorized_keys[0],\n dict((kind, (privkey, pubkey))\n for (kind, (privkey, pubkey, _)) in result))", "def local_user_ids(steam):\n if steam is None:\n return None\n # The userdata directory, at the top level, just contains a single\n # subdirectory for every user which has logged into this system (and\n # therefore that Steam has data for)\n return os.listdir(steam.userdata_directory)", "def find_remote_files(remote_path, type, ssh):\n (ssh_in, ssh_out, ssh_err) = ssh.exec_command(\"find %s -name \\\"*\\\" -type %s\" % (remote_path, type))\n files = []\n for file in ssh_out.readlines():\n files.append(file.rstrip())\n return files", "def sshkeys(self):\n return self._authenticated_server_proxy.sshkeys", "def get_user_auth_keys(self, username):\n if username in self.users_keys:\n return self.users_keys[username]\n\n self.users_keys[username] = []\n\n userdir = os.path.expanduser(\"~\" + username)\n if not userdir:\n return self.users_keys[username]\n\n keyfile = os.path.join(userdir, \".ssh/authorized_keys\")\n if not keyfile or not os.path.exists(keyfile):\n return self.users_keys[username]\n\n with open(keyfile) as f:\n for line in f.readlines():\n line = line.strip()\n if not line or line.startswith(\"#\"):\n continue\n values = [x.strip() for x in line.split()]\n\n exp = None\n try:\n int(values[0]) # bits value?\n except ValueError:\n # Type 1 or type 2, type 1 is bits in second value\n options_ktype = values[0]\n try:\n int(values[1]) # bits value?\n except ValueError:\n # type 2 with options\n ktype = options_ktype\n data = values[1]\n else:\n # Type 1 no options.\n exp = int(values[1])\n data = values[2]\n else:\n # Type 1 no options.\n exp = int(values[1])\n data = values[2]\n\n # XXX For now skip type 1 keys\n if exp is not None:\n continue\n\n if data:\n import base64\n if ktype == \"ssh-rsa\":\n key = ssh.RSAKey(data=base64.decodebytes(data.encode('ascii')))\n elif ktype == \"ssh-dss\":\n key = ssh.DSSKey(data=base64.decodebytes(data.encode('ascii')))\n else:\n key = None\n if key:\n self.users_keys[username].append(key)\n return self.users_keys[username]", "def urls(gh, user):\n return [repo.url for repo in getuserrepos(gh, user)]", "def GuessHistoryPaths(self, username):\n client = data_store.REL_DB.ReadClientSnapshot(self.client_id)\n system = client.knowledge_base.os\n user_info = flow_utils.GetUserInfo(client.knowledge_base, username)\n\n if not user_info:\n self.Error(\"Could not find homedir for user {0}\".format(username))\n return\n\n paths = []\n if system == \"Windows\":\n path = \"{app_data}\\\\Mozilla\\\\Firefox\\\\Profiles/\"\n paths.append(path.format(app_data=user_info.appdata))\n elif system == \"Linux\":\n path = \"{homedir}/.mozilla/firefox/\"\n paths.append(path.format(homedir=user_info.homedir))\n elif system == \"Darwin\":\n path = (\"{homedir}/Library/Application Support/\" \"Firefox/Profiles/\")\n paths.append(path.format(homedir=user_info.homedir))\n else:\n raise OSError(\"Invalid OS for Chrome History\")\n return paths", "def get_public_keys(vm_):\n key_filename = config.get_cloud_config_value(\n \"ssh_public_key\", vm_, __opts__, search_global=False, default=None\n )\n if key_filename is not None:\n key_filename = os.path.expanduser(key_filename)\n if not os.path.isfile(key_filename):\n raise SaltCloudConfigError(\n \"The defined ssh_public_key '{}' does not exist\".format(key_filename)\n )\n ssh_keys = []\n with salt.utils.files.fopen(key_filename) as rfh:\n for key in rfh.readlines():\n ssh_keys.append(salt.utils.stringutils.to_unicode(key))\n\n return ssh_keys", "def list_users_in_pool():\n files = []\n USERS_DIR = os.path.join(UPLOAD_DIRECTORY, \"users\")\n for filename in os.listdir(USERS_DIR):\n path = os.path.join(USERS_DIR, filename)\n if os.path.isdir(path):\n files.append(filename)\n return jsonify(files)", "def getuserrepos_keys(gh, user):\n repos = getuserrepos(gh, user)\n return repos[0].keys()", "def get_files_paths(self):\n return self.__files_paths", "def find_n2vc_ssh_keys():\n\n paths = []\n paths.append(os.path.expanduser(\"~/.ssh/\"))\n\n for path in paths:\n if os.path.exists(path):\n private = os.path.expanduser(\"{}/id_n2vc_rsa\".format(path))\n public = os.path.expanduser(\"{}/id_n2vc_rsa.pub\".format(path))\n if os.path.exists(private) and os.path.exists(public):\n return (private, public)\n return (None, None)", "def userlist_path(address):\n return path.join(conf.userlistdir, match_userlist(address))", "def GetAllLogFilePaths(ssh):\n ssh_cmd = [ssh.GetBaseCmd(constants.SSH_BIN), _FIND_LOG_FILE_CMD]\n log_files = []\n try:\n files_output = utils.CheckOutput(\" \".join(ssh_cmd), shell=True)\n log_files = FilterLogfiles(files_output.splitlines())\n except subprocess.CalledProcessError:\n logger.debug(\"The folder(%s) that running launch_cvd doesn't exist.\",\n constants.REMOTE_LOG_FOLDER)\n return log_files", "def _get_paths():\n paths = [\n '/'\n ]\n return paths", "def dir_list(self, instance, where):\n\n instance = self.get_instance(instance)\n output = ''\n\n try:\n if instance.get('address'):\n username = instance.get('address') + \"@\" + instance.get('credentials').get('username')\n key = instance.get('credentials').get('publickey')\n output = subprocess.check_output([\"ssh\", key, username, 'ls', self.default_path_aws + where]).decode(\n \"utf-8\")\n else:\n username = 'ubuntu@' + instance.get('credentials').get('EC2_ACCESS_ID')\n key = instance.get('credentials').get('EC2_SECRET_KEY')\n # output = os.popen(\"ls\"+ \" | \" + \"ssh\"+ \" -i \"+ key +\" \"+ username).read()\n output = subprocess.check_output(\n [\"ssh\", \"-i\", key, username, 'ls', self.default_path_aws + where]).decode(\"utf-8\")\n return output\n except:\n return \"Fail to access the instance\"", "def protectedfiles(self):\n return self._protectedpaths", "def filepaths(self):\n pass", "def GuessHistoryPaths(self, username):\n client = data_store.REL_DB.ReadClientSnapshot(self.client_id)\n system = client.knowledge_base.os\n user_info = flow_utils.GetUserInfo(client.knowledge_base, username)\n\n if not user_info:\n self.Error(\"Could not find homedir for user {0}\".format(username))\n return\n\n paths = []\n if system == \"Windows\":\n path = (\"{app_data}\\\\{sw}\\\\User Data\\\\Default\\\\\")\n for sw_path in [\"Google\\\\Chrome\", \"Chromium\"]:\n paths.append(path.format(app_data=user_info.localappdata, sw=sw_path))\n elif system == \"Linux\":\n path = \"{homedir}/.config/{sw}/Default/\"\n for sw_path in [\"google-chrome\", \"chromium\"]:\n paths.append(path.format(homedir=user_info.homedir, sw=sw_path))\n elif system == \"Darwin\":\n path = \"{homedir}/Library/Application Support/{sw}/Default/\"\n for sw_path in [\"Google/Chrome\", \"Chromium\"]:\n paths.append(path.format(homedir=user_info.homedir, sw=sw_path))\n else:\n raise OSError(\"Invalid OS for Chrome History\")\n return paths", "def gridfs_files(self):\n return self[\"files\"]", "def get_paths(self):\n return self.paths", "def paths(self):\r\n return self._paths" ]

[ "0.6815306", "0.65893316", "0.6569793", "0.6539029", "0.6516319", "0.634172", "0.62293583", "0.61868155", "0.61260295", "0.6075835", "0.6063089", "0.5990238", "0.5982808", "0.595064", "0.593153", "0.5919284", "0.59001994", "0.58423096", "0.58388907", "0.5830525", "0.5772707", "0.57663745", "0.57054436", "0.56638294", "0.56418115", "0.56349254", "0.56342214", "0.5622543", "0.558529", "0.5573137" ]

[ "def GetUserFiles(user, mkdir=False, dircheck=True, kind=constants.SSHK_DSA,\n _homedir_fn=None):\n if _homedir_fn is None:\n _homedir_fn = utils.GetHomeDir\n\n user_dir = _homedir_fn(user)\n if not user_dir:\n raise errors.OpExecError(\"Cannot resolve home of user '%s'\" % user)\n\n if kind == constants.SSHK_DSA:\n suffix = \"dsa\"\n elif kind == constants.SSHK_RSA:\n suffix = \"rsa\"\n else:\n raise errors.ProgrammerError(\"Unknown SSH key kind '%s'\" % kind)\n\n ssh_dir = utils.PathJoin(user_dir, \".ssh\")\n if mkdir:\n utils.EnsureDirs([(ssh_dir, constants.SECURE_DIR_MODE)])\n elif dircheck and not os.path.isdir(ssh_dir):\n raise errors.OpExecError(\"Path %s is not a directory\" % ssh_dir)\n\n return [utils.PathJoin(ssh_dir, base)\n for base in [\"id_%s\" % suffix, \"id_%s.pub\" % suffix,\n \"authorized_keys\"]]", "def get_user_auth_keys(self, username):\n if username in self.users_keys:\n return self.users_keys[username]\n\n self.users_keys[username] = []\n\n userdir = os.path.expanduser(\"~\" + username)\n if not userdir:\n return self.users_keys[username]\n\n keyfile = os.path.join(userdir, \".ssh/authorized_keys\")\n if not keyfile or not os.path.exists(keyfile):\n return self.users_keys[username]\n\n with open(keyfile) as f:\n for line in f.readlines():\n line = line.strip()\n if not line or line.startswith(\"#\"):\n continue\n values = [x.strip() for x in line.split()]\n\n exp = None\n try:\n int(values[0]) # bits value?\n except ValueError:\n # Type 1 or type 2, type 1 is bits in second value\n options_ktype = values[0]\n try:\n int(values[1]) # bits value?\n except ValueError:\n # type 2 with options\n ktype = options_ktype\n data = values[1]\n else:\n # Type 1 no options.\n exp = int(values[1])\n data = values[2]\n else:\n # Type 1 no options.\n exp = int(values[1])\n data = values[2]\n\n # XXX For now skip type 1 keys\n if exp is not None:\n continue\n\n if data:\n import base64\n if ktype == \"ssh-rsa\":\n key = ssh.RSAKey(data=base64.decodebytes(data.encode('ascii')))\n elif ktype == \"ssh-dss\":\n key = ssh.DSSKey(data=base64.decodebytes(data.encode('ascii')))\n else:\n key = None\n if key:\n self.users_keys[username].append(key)\n return self.users_keys[username]", "def __parse_user_keyfiles(self):\n\n user_sshdir = os.path.expanduser('~/.ssh')\n if not os.path.isdir(user_sshdir):\n return\n\n paths = []\n for filename in os.listdir(user_sshdir):\n if filename in SSH_CONFIG_FILES or os.path.splitext(filename)[1] != '.pub':\n continue\n path = os.path.join(user_sshdir, filename)\n if os.path.isfile(path):\n paths.append(path)\n for path in paths:\n try:\n sshkey = SSHKeyFile(self, path)\n except SSHKeyError as e:\n self.log.debug(e)\n continue\n\n self[sshkey.path] = sshkey", "def getAuthorizedKeysFiles(self, credentials):\n #pwent = self._userdb.getpwnam(credentials.username)\n #root = FilePath(pwent.pw_dir).child('.ssh')\n #files = ['authorized_keys', 'authorized_keys2']\n #return [root.child(f) for f in files]\n return self._files", "def getPrivateKeys(self):\n privateKeys = {}\n for filename in os.listdir(self.dataRoot):\n if filename[:9] == 'ssh_host_' and filename[-4:]=='_key':\n fullPath = os.path.join(self.dataRoot, filename)\n try:\n key = keys.Key.fromFile(fullPath)\n except IOError as e:\n if e.errno == errno.EACCES:\n # Not allowed, let's switch to root\n key = runAsEffectiveUser(\n 0, 0, keys.Key.fromFile, fullPath)\n privateKeys[key.sshType()] = key\n else:\n raise\n except Exception as e:\n log.msg('bad private key file %s: %s' % (filename, e))\n else:\n privateKeys[key.sshType()] = key\n return privateKeys", "def ListFiles(self, ext_attrs=None):\n del ext_attrs # Unused.\n\n if not self.IsDirectory():\n return\n\n if self.hive is None:\n for name in dir(winreg):\n if name.startswith(\"HKEY_\"):\n response = rdf_client_fs.StatEntry(st_mode=stat.S_IFDIR)\n response_pathspec = self.pathspec.Copy()\n response_pathspec.last.path = utils.JoinPath(\n response_pathspec.last.path, name)\n response.pathspec = response_pathspec\n\n yield response\n return\n\n try:\n with OpenKey(self.hive, self.local_path) as key:\n (self.number_of_keys, self.number_of_values,\n self.last_modified) = QueryInfoKey(key)\n\n # First keys - These will look like directories.\n for i in range(self.number_of_keys):\n try:\n name = EnumKey(key, i)\n key_name = utils.JoinPath(self.local_path, name)\n\n try:\n # Store the default value in the stat response for values.\n with OpenKey(self.hive, key_name) as subkey:\n value, value_type = QueryValueEx(subkey, \"\")\n except OSError:\n value, value_type = None, None\n\n response = self._Stat(name, value, value_type)\n # Keys look like Directories in the VFS.\n response.st_mode = stat.S_IFDIR\n\n yield response\n except OSError:\n pass\n\n # Now Values - These will look like files.\n for i in range(self.number_of_values):\n try:\n name, value, value_type = EnumValue(key, i)\n response = self._Stat(name, value, value_type)\n\n # Values look like files in the VFS.\n response.st_mode = stat.S_IFREG\n\n yield response\n\n except OSError:\n pass\n except OSError as e:\n raise IOError(\"Unable to list key %s: %s\" % (self.key_name, e))", "def get_files(self, block):\n \n raise NotImplementedError('get_files')", "def get_files(self):\n\n if str(self.files) == \"unset\": return []\n if len(self.files) > 0: return self.files[:int(Settings.get_upload_max())]\n if len(Settings.get_input_as_files()) > 0:\n self.files = Settings.get_input_as_files()\n return self.files\n # prompt skip\n if not Settings.is_prompt() and Settings.get_category() == None:\n self.files = \"unset\"\n return []\n files = []\n if len(self.files) == 0:\n files = File.select_file_upload_method()\n if str(files[0]) == \"unset\" or str(files) == \"unset\":\n self.files = \"unset\"\n files = []\n if Settings.is_prompt(): return []\n if files == None: files = []\n # get files from appropriate source's menu selection\n if Settings.get_source() == \"google\":\n googleFiles = Google_File.get_files()\n if len(files) == 0 and len(googleFiles) > 0:\n files = Google_File.select_files()\n elif len(files) == 0 and len(googleFiles) == 0:\n self.files = \"unset\"\n return []\n elif Settings.get_source() == \"remote\":\n remoteFiles = Remote.get_files()\n if len(remoteFiles) > 0:\n files = Remote.select_files()\n elif len(files) == 0 and len(remoteFiles) == 0:\n self.files = \"unset\"\n return []\n elif Settings.get_source() == \"local\":\n localFiles = File.get_files()\n if len(files) == 0 and len(localFiles) > 0:\n files = File.select_files()\n elif len(files) == 0 and len(localFiles) == 0:\n self.files = \"unset\"\n return []\n filed = []\n for file in files:\n # turn all folders into their files\n if isinstance(file, Folder) or isinstance(file, Google_Folder): filed.extend(file.get_files())\n else:\n # flag that the files include a performer\n if hasattr(file, \"performer\"):\n self.hasPerformers = True\n filed.append(file)\n self.files = filed[:int(Settings.get_upload_max())]\n return self.files", "def get_ssh_keys(self, user_id):\n _gu = self.get_user(user_id)\n if _gu is None:\n return []\n\n # build URL and make request\n return self._get('/users/{0}/keys'.format(_gu['id']))", "def getfiles(self, path, ext=None, start=None, stop=None, recursive=False):\n from .utils import connection_with_anon, connection_with_gs\n\n parse = BotoClient.parse_query(path)\n\n scheme = parse[0]\n bucket_name = parse[1]\n\n if scheme == 's3' or scheme == 's3n':\n conn = connection_with_anon(self.credentials)\n bucket = conn.get_bucket(parse[1])\n elif scheme == 'gs':\n conn = connection_with_gs(bucket_name)\n bucket = conn.get_bucket()\n else:\n raise NotImplementedError(\"No file reader implementation for URL scheme \" + scheme)\n\n keys = BotoClient.retrieve_keys(\n bucket, parse[2], prefix=parse[3], postfix=parse[4], recursive=recursive)\n keylist = [key.name for key in keys]\n if ext:\n keylist = [keyname for keyname in keylist if keyname.endswith(ext)]\n keylist.sort()\n keylist = select(keylist, start, stop)\n\n return scheme, bucket.name, keylist", "def api_files():\n files = FileWrapper.get_files(g.user.id)\n return jsonify([f.serialize() for f in files])", "def _private_keys(self) -> List[Tuple[str, str]]:\n\n directory = tedious.config.CONFIG[\"KEYS\"]['private-keys']\n if self._cached_private_keys is None:\n self._cached_private_keys = [(file, os.path.join(directory, file)) for file in os.listdir(directory) if\n os.path.isfile(os.path.join(directory, file))]\n if len(self._cached_private_keys) == 0:\n raise ValueError(\"'{}' does not contains any private keys.\".format(directory))\n return self._cached_private_keys", "def find_remote_files(remote_path, type, ssh):\n (ssh_in, ssh_out, ssh_err) = ssh.exec_command(\"find %s -name \\\"*\\\" -type %s\" % (remote_path, type))\n files = []\n for file in ssh_out.readlines():\n files.append(file.rstrip())\n return files", "def search(self):\n try:\n log.debug('Search file for user ID: %s', self.current_user.id)\n\n sql = \"select fs.id, fs.name, fs.size, fs.type, fs.date_load, u.id shared_by_id, u.login shared_by_login, \"\\\n \"concat(u.first_name, ' ', COALESCE(u.second_name, '')) shared_by_name \"\\\n \"FROM file_store fs inner join file_share fsh on fsh.file_id = fs.id \"\\\n \"inner join user u on u.id = fsh.user_own_id where fsh.user_assigned_id ={0} \"\\\n \"union all(select fs.id, fs.name, fs.size, fs.type, fs.date_load, '' shared_by_id, \"\\\n \"'' shared_by_login, '' shared_by_name \" \\\n \"FROM file_store fs where fs.user_id ={0})\".format(self.current_user.id)\n\n files = self.db.execute(sql)\n\n response = {'files': files,\n 'used_quota': self.user_api.user_db.used_file_quota,\n 'quota': self.user_api.user_db.file_quota,\n 'total': len(files),\n 'extends': list(set(fl['type'] for fl in files))}\n\n return {'success': True, 'result': response}\n\n except StandardError:\n log.exception('Cannot search file')\n return SERVER_ERROR", "def list_user_keys(self):\n return AlgoliaUtils_request(self.headers, self.read_hosts, \"GET\", \"/1/keys\", self.timeout)", "def getKeys(name = None):\n if name == None:\n name = session.get('name')\n\n keys = hl.getUser(\"Name\",name)[\"Keys\"]\n hl.keyDistributeFlag(name)\n #If on a production server, use actual path\n if os.path.isdir(keys_dir):\n filename = keys_dir + keys + '.ovpn' \n\n #if not os.path.exists(filename):\n # hl.zipUserKeys(keys) \n\n return send_file(filename, as_attachment=True)\n #Else use relative dev path\n else:\n return send_file('static\\\\Test_client1.zip', as_attachment=True)", "def list_file_types(project_id, host, email, password, api_key):\n ListFileTypes(\n project_id,\n Credentials(email=email, password=password, api_key=api_key),\n Optionals(host=host),\n ).run()", "def get_files(self):\n\n self.files = []\n retriever_methods = [\n m\n for m in rtorrent9.file.methods\n if m.is_retriever() and m.is_available(self._rt_obj)\n ]\n # 2nd arg can be anything, but it'll return all files in torrent\n # regardless\n m = rtorrent9.rpc.Multicall(self)\n m.add(\n \"f.multicall\",\n self.info_hash,\n \"\",\n *[method.rpc_call + \"=\" for method in retriever_methods]\n )\n\n results = m.call()[0] # only sent one call, only need first result\n\n offset_method_index = retriever_methods.index(\n rtorrent9.rpc.find_method(\"f.offset\")\n )\n\n # make a list of the offsets of all the files, sort appropriately\n offset_list = sorted([r[offset_method_index] for r in results])\n\n for result in results:\n results_dict = {}\n # build results_dict\n for m, r in zip(retriever_methods, result):\n results_dict[m.varname] = rtorrent9.rpc.process_result(m, r)\n\n # get proper index positions for each file (based on the file\n # offset)\n f_index = offset_list.index(results_dict[\"offset\"])\n\n self.files.append(\n File(self._rt_obj, self.info_hash, f_index, **results_dict)\n )\n\n return self.files", "def files(self):\n files = dict()\n for name, value in self.__dict__.items():\n public_methods = ['list_filenames', 'add']\n if not name.startswith('_') and name not in public_methods:\n files[name] = value\n return files", "def GetFilesForTool(self):\n raise NotImplementedError()", "def get_files():\n\n if File.FILES: return File.FILES\n category = Settings.get_category()\n if not category: category = Settings.select_category()\n if not category: Settings.warn_print(\"missing category\")\n files = File.get_files_by_category(category)\n if Settings.get_title() and str(files) != \"unset\":\n for file in files:\n if str(Settings.get_title()) == str(file.get_title()):\n files = [file]\n break\n File.FILES = files\n return files", "def get_file(self, key):\n result = (None, None)\n path = os.path.join(self.directory, self.subdirectory, key)\n if os.path.isfile(path):\n content_type, _ = mimetypes.guess_type(path)\n with open(path, \"rb\") as file:\n result = content_type, file.read()\n return result", "def build_private_data_files(self, instance, private_data_dir):\n private_data = self.build_private_data(instance, private_data_dir)\n private_data_files = {'credentials': {}}\n ssh_key_data = None\n if private_data is not None:\n for credential, data in private_data.get('credentials', {}).items():\n # OpenSSH formatted keys must have a trailing newline to be\n # accepted by ssh-add.\n if 'OPENSSH PRIVATE KEY' in data and not data.endswith('\\n'):\n data += '\\n'\n # For credentials used with ssh-add, write to a named pipe which\n # will be read then closed, instead of leaving the SSH key on disk.\n if credential and credential.credential_type.namespace in ('ssh', 'scm'):\n ssh_key_data = data\n # Ansible network modules do not yet support ssh-agent.\n # Instead, ssh private key file is explicitly passed via an\n # env variable.\n else:\n private_data_files['credentials'][credential] = self.write_private_data_file(private_data_dir, None, data, sub_dir='env')\n for credential, data in private_data.get('certificates', {}).items():\n self.write_private_data_file(private_data_dir, 'ssh_key_data-cert.pub', data, sub_dir=os.path.join('artifacts', str(self.instance.id)))\n return private_data_files, ssh_key_data", "def find_keys(args):\n key = args['--key']\n if key:\n return [key]\n\n keyfile = args['--apikeys']\n if keyfile:\n return read_keyfile(keyfile)\n\n envkey = os.environ.get('TINYPNG_API_KEY', None)\n if envkey:\n return [envkey]\n\n local_keys = join(abspath(\".\"), \"tinypng.keys\")\n\n if isfile(local_keys):\n return read_keyfile(local_keys)\n\n home_keys = join(expanduser(\"~/.tinypng.keys\"))\n if isfile(home_keys):\n return read_keyfile(home_keys)\n\n return []", "def readKeys(keydir):\r\n for filename in os.listdir(keydir):\r\n if filename.startswith('.'):\r\n continue\r\n basename, ext = os.path.splitext(filename)\r\n if ext != '.pub':\r\n continue\r\n\r\n if not isSafeUsername(basename):\r\n log.warn('Unsafe SSH username in keyfile: %r', filename)\r\n continue\r\n\r\n path = os.path.join(keydir, filename)\r\n f = file(path)\r\n for line in f:\r\n line = line.rstrip('\\n')\r\n yield (basename, line)\r\n f.close()", "def files(self):\n files = []\n if self.package_type == 'package':\n file_data = dict([(k, self[k]) \\\n for k in ['size', 'sha1', 'sha256', 'md5sum']])\n file_data['name'] = self['filename'].split('/')[-1]\n files.append(file_data)\n else:\n for d in self['files']:\n file_data = d.copy()\n # Get checksum data as well...\n for key in ['sha1', 'sha256']:\n for data in self['checksums-' + key]:\n if file_data['name'] == data['name']:\n file_data[key] = data[key]\n files.append(file_data)\n return files", "def list_users_in_pool():\n files = []\n USERS_DIR = os.path.join(UPLOAD_DIRECTORY, \"users\")\n for filename in os.listdir(USERS_DIR):\n path = os.path.join(USERS_DIR, filename)\n if os.path.isdir(path):\n files.append(filename)\n return jsonify(files)", "def renku_op(self):\n\n files = [f for f in self.cache.get_files(self.user) if f.exists()]\n return {\"files\": sorted(files, key=lambda rec: (rec.is_dir, rec.relative_path))}", "def _FindKeyFiles(self):\r\n \r\n if self.__fCachedFiles is not None:\r\n return self.__fCachedFiles\r\n \r\n app = wingapi.gApplication\r\n proj = app.GetProject()\r\n files = proj.GetAllFiles()\r\n manage_files = []\r\n settings_files = []\r\n for fn in files:\r\n if os.path.basename(fn) == 'manage.py' and not os.path.dirname(fn).endswith('project_template') and os.path.isfile(fn):\r\n manage_files.append(fn)\r\n elif os.path.basename(fn) == 'settings.py' and not os.path.dirname(fn).endswith('project_template') and os.path.isfile(fn):\r\n settings_files.append(fn)\r\n\r\n pairs = []\r\n for manage_file in manage_files:\r\n for settings_file in settings_files:\r\n manage_dir = os.path.dirname(manage_file)\r\n settings_dir = os.path.dirname(settings_file)\r\n if manage_dir == settings_dir:\r\n pairs.append((manage_file, settings_file))\r\n if len(pairs) > 1:\r\n app.SetStatusMessage(\"Warning: Multiple manage.py/settings.py pairs found in project\")\r\n \r\n if len(pairs) > 0:\r\n self.__fCachedFiles = pairs[0]\r\n else:\r\n self.__fCachedFiles = (None, None)\r\n \r\n return self.__fCachedFiles", "def __iter__(self):\n return self.pwfiles.keys().__iter__()" ]

[ "0.7022788", "0.6507771", "0.644886", "0.622935", "0.5820931", "0.5751039", "0.55767727", "0.55684954", "0.5534864", "0.55161965", "0.5452578", "0.54422456", "0.54075515", "0.5397115", "0.53943914", "0.5381998", "0.5344919", "0.5326442", "0.53219026", "0.5310566", "0.5283549", "0.52707624", "0.5259064", "0.52576315", "0.5242895", "0.52355504", "0.5218249", "0.5214413", "0.5209028", "0.5203717" ]

[ "def build_options(self):\n opts = [\n \"-k rpm.rpmva=off\",\n \"-k apache.log=True\",\n ]\n\n sensitive_keys = {\n self._engine_plugin: 'sensitive_keys',\n 'ovirt_engine_dwh': 'dwh_sensitive_keys',\n }\n if self.configuration['include_sensitive_data']:\n for plugin in sensitive_keys:\n self.configuration[sensitive_keys[plugin]] = ':'\n\n for plugin in sensitive_keys:\n if self.configuration.get(sensitive_keys[plugin]):\n opts.append(\n '-k {plugin}.sensitive_keys={keys}'.format(\n plugin=plugin,\n keys=self.configuration.get(sensitive_keys[plugin]),\n )\n )\n\n if self.configuration.get(\"ticket_number\"):\n opts.append(\n \"--ticket-number=%s\" % self.configuration.get(\"ticket_number\")\n )\n\n if self.sos_version < '30':\n opts.append('--report')\n\n if self.configuration.get(\"log_size\"):\n opts.append(\n \"--log-size=%s\" %\n self.configuration.get('log_size')\n )\n else:\n if self.sos_version < '30':\n opts.append('--report')\n opts.append(\"-k general.all_logs=True\")\n elif self.sos_version < '32':\n opts.append(\"-k logs.all_logs=True\")\n else:\n opts.append(\"--all-logs\")\n\n if self.configuration.get(\"upload\"):\n opts.append(\"--upload=%s\" % self.configuration.get(\"upload\"))\n return \" \".join(opts)", "def list_opts():\n return [(None, copy.deepcopy(service_opts))]", "def create_options(self):\n return []", "def list_opts():\n return [('ironic_lib', utils_opts)]", "def _internal_get_ssh_device_configs(self) -> List[dict]:\n\n ssh_device_config_list = []\n\n for device_config in self._internal_get_device_configs():\n dev_type = device_config[\"deviceType\"]\n\n if dev_type == \"network/ssh\":\n ssh_device_config_list.append(device_config)\n\n return ssh_device_config_list", "def list_opts():\n return _make_opt_list([OPTS], 'tvdb')", "def build_multiple_options(self):\n multiple_options = \"\"\n for index, option in self.options.iteritems():\n multiple_options += \"\\n[\" + index + \"] \" + option\n multiple_options += \"\\n\"\n return multiple_options", "def list_manage_opts():\n return [(g, copy.deepcopy(o)) for g, o in _manage_opts]", "def _getOptions(self):\n args = []\n for iname, value in self.options:\n args.append('-' + iname)\n if value != 'true':\n args.append(value)\n return args", "def _init_ssh_options(self) -> asyncssh.SSHClientConnectionOptions:\n options = asyncssh.SSHClientConnectionOptions(\n login_timeout=self.connect_timeout,\n username=self.username,\n agent_identities=self.pvtkey if self.pvtkey else None,\n client_keys=self.pvtkey if self.pvtkey else None,\n password=self.password if not self.pvtkey else None\n )\n if self.ignore_known_hosts:\n options = asyncssh.SSHClientConnectionOptions(\n options=options,\n known_hosts=None,\n )\n if self.ssh_config_file:\n options = asyncssh.SSHClientConnectionOptions(\n options=options,\n config=[self.ssh_config_file],\n )\n\n return options", "def get_options(self):\n return []", "def options() -> List:\n return list(c.value for c in Plugin)", "def get_options(self):\n return (\n Option('-H', '--host',\n dest='host',\n default=self.host,\n help='IP address or hostname of the Glancesync server.'),\n\n Option('-p', '--port',\n dest='port',\n type=int,\n default=self.port,\n help='Port in which the GlanceSync server is running'),\n\n Option('-w', '--workers',\n dest='workers',\n type=int,\n default=self.workers,\n help='Number of concurrent workers to be launched, usually 2*core numbers+1.'),\n )", "def _all_cli_opts(self):\n for item in self._cli_opts:\n yield item['opt'], item['group']", "def _make_opt_list(opts, group):\n import copy\n import itertools\n\n _opts = [(group, list(itertools.chain(*opts)))]\n return [(g, copy.deepcopy(o)) for g, o in _opts]", "def get_ssh_device_configs(self, exclude_upnp=False) -> List[dict]:\n ssh_device_config_list = []\n\n for devinfo in self._internal_get_device_configs():\n dev_type = devinfo[\"deviceType\"]\n\n if exclude_upnp and dev_type == \"network/upnp\":\n continue\n\n if \"ssh\" in devinfo:\n ssh_device_config_list.append(devinfo)\n\n return ssh_device_config_list", "def make_port_list(ssh, https, port):\n\n ports = []\n\n if ssh:\n ports.append(22)\n if https:\n ports.append(443)\n ports.append(80)\n if port is not None:\n ports.append(port)\n\n return ports", "def list_opts():\n return [(constants.MLNX_BAREMETAL_DRIVER_GROUP_NAME, DRIVER_OPTS)]", "async def config_options(self, ctx):\n embeds = []\n for names in zip_longest(*(iter(sorted(self.bot.config.public_keys)),) * 15):\n description = \"\\n\".join(\n f\"`{name}`\" for name in takewhile(lambda x: x is not None, names)\n )\n embed = Embed(\n title=\"Available configuration keys:\",\n color=self.bot.main_color,\n description=description,\n )\n embeds.append(embed)\n\n session = EmbedPaginatorSession(ctx, *embeds)\n await session.run()", "def list_api_opts():\n\n return [(g, copy.deepcopy(o)) for g, o in _api_opts]", "def plugin_options(request):\n options = (\n '--rabbit-amqp-uri',\n '--rabbit-api-uri'\n )\n\n args = [\n \"{}={}\".format(opt, request.config.getoption(opt)) for opt in options\n ]\n return args", "def retrieve_options(env):\n\n options = []\n if env.core != -1:\n options.extend([\"--core {}\".format(env.core)])\n if env.mtor != 4:\n options.extend([\"--mtor {}\".format(env.mtor)])\n if env.n != 1000:\n options.extend([\"--n {}\".format(env.n)])\n if env.forcefield != \"OPLS2005\":\n options.extend([\"--force {}\".format(env.forcefield)])\n if env.mae_lig:\n options.extend([\"--mae_charges\"])\n if env.gridres != 10:\n options.extend([\"--gridres {}\".format(env.gridres)])\n return \" \".join(options)", "async def get_options(self) -> List[Tuple[str, str]]:\n options = [\n (\"TRUE\", \"true\"),\n (\"FALSE\", \"false\"),\n ]\n if self.context.get(\"null\"):\n options.insert(0, (\"\", \"\"))\n\n return options", "def options(self, scriptable=None):\n options = list(Insert.KIND_OPTIONS.get(self.kind, []))\n if scriptable:\n if self.kind == 'var':\n options += scriptable.variables.keys()\n options += scriptable.project.variables.keys()\n elif self.kind == 'list':\n options += scriptable.lists.keys()\n options += scriptable.project.lists.keys()\n elif self.kind == 'costume':\n options += [c.name for c in scriptable.costumes]\n elif self.kind == 'backdrop':\n options += [c.name for c in scriptable.project.stage.costumes]\n elif self.kind == 'sound':\n options += [c.name for c in scriptable.sounds]\n options += [c.name for c in scriptable.project.stage.sounds]\n elif self.kind in ('spriteOnly', 'spriteOrMouse', 'spriteOrStage',\n 'touching'):\n options += [s.name for s in scriptable.project.sprites]\n elif self.kind == 'attribute':\n pass # TODO\n elif self.kind == 'broadcast':\n options += list(set(scriptable.project.get_broadcasts()))\n return options", "def options(cls, how: Optional[str] = None) -> List[tmt.options.ClickOptionDecoratorType]:\n return [\n click.option(\n '-i', '--image', metavar='IMAGE',\n help='Select image to use. Short name or complete url.'),\n click.option(\n '-c', '--container', metavar='NAME',\n help='Name or id of an existing container to be used.'),\n click.option(\n '-p', '--pull', 'force_pull', is_flag=True,\n help='Force pulling a fresh container image.'),\n click.option(\n '-u', '--user', metavar='USER',\n help='User to use for all container operations.')\n ] + super().options(how)", "def generate_options(self):\n super(CreateMachine, self).generate_options()\n options = [\"image\", \"flavor\", \"files\", \"meta\", \"scheduler_hints\"]\n for option in self.command_options:\n if option['dest'] in options:\n option['action'] = \"append\"", "def list_image_import_opts():\n\n opts = copy.deepcopy(_image_import_opts)\n opts.extend(plugin_opts.get_plugin_opts())\n return [(g, copy.deepcopy(o)) for g, o in opts]", "def GetDefaultFlags(self):\n return [\n '-i', self.ssh_key_file,\n '-o', 'UserKnownHostsFile=/dev/null',\n '-o', 'CheckHostIP=no',\n '-o', 'StrictHostKeyChecking=no',\n ]", "def get_ssh_device_list(self) -> List[dict]:\n\n ssh_device_list = []\n\n for device in self._all_devices.values():\n device_type = device.device_type\n if device_type == \"network/ssh\":\n ssh_device_list.append(device)\n elif device_type == \"network/upnp\":\n if device.has_ssh_credential:\n ssh_device_list.append(device)\n\n return ssh_device_list", "def list_scrubber_opts():\n return [(g, copy.deepcopy(o)) for g, o in _scrubber_opts]" ]

[ "0.6554022", "0.639308", "0.62351835", "0.6176157", "0.6151676", "0.60372573", "0.5989086", "0.5973253", "0.5886928", "0.58624715", "0.58454704", "0.58434445", "0.58004487", "0.5762706", "0.5728157", "0.5720622", "0.5677747", "0.5641881", "0.5615017", "0.55816853", "0.5575047", "0.5567311", "0.5557619", "0.5546999", "0.554588", "0.5531411", "0.55233204", "0.55129313", "0.55044353", "0.5503101" ]

[ "def needs_ssh(hostname, _socket=None):\n if hostname.lower() in ['localhost', '127.0.0.1', '127.0.1.1']:\n return False\n _socket = _socket or socket\n fqdn = _socket.getfqdn()\n if hostname == fqdn:\n return False\n local_hostname = _socket.gethostname()\n local_short_hostname = local_hostname.split('.')[0]\n if local_hostname == hostname or local_short_hostname == hostname:\n return False\n return True", "def test_vms_hosts(self):\n testflow.step(\"Check if VM's started on the same host\")\n assert (\n ll_vms.get_vm_host(vm_name=conf.VM_NAME[0]) ==\n ll_vms.get_vm_host(vm_name=conf.VM_NAME[1])\n )", "def test_vms_hosts(self):\n testflow.step(\"Check if VM's started on the same host\")\n assert (\n ll_vms.get_vm_host(vm_name=conf.VM_NAME[0]) ==\n ll_vms.get_vm_host(vm_name=conf.VM_NAME[1])\n )", "def check_ssh_known_host(name_or_ip, known_hosts_file=KNOWN_HOSTS_FILE):\n try:\n with KNOWN_HOSTS_MUTEX:\n subprocess.check_call(['ssh-keygen', '-F', name_or_ip,\n '-f', known_hosts_file])\n return True\n except subprocess.CalledProcessError as e:\n if e.returncode == 1:\n return False\n else:\n raise", "def _hostOK(self, host):\n if os.system(\"ping -c 1 $node &> /dev/null\"):\n # No access to host\n return False\n elif os.system(\"ssh -n -a -x $node 'ls' &> /dev/null\"):\n # No route to host\n return False\n else:\n return True", "def test_vms_host(self):\n testflow.step(\"Check if VM's started on different hosts\")\n assert (\n ll_vms.get_vm_host(vm_name=conf.VM_NAME[0]) !=\n ll_vms.get_vm_host(vm_name=conf.VM_NAME[1])\n )", "def test_vms_host(self):\n testflow.step(\"Check if VM's started on different hosts\")\n assert (\n ll_vms.get_vm_host(vm_name=conf.VM_NAME[0]) !=\n ll_vms.get_vm_host(vm_name=conf.VM_NAME[1])\n )", "def test_verify_hostname(self):\n verify_certificate_hostname(X509_DNS_ONLY, u\"twistedmatrix.com\")", "def _check_connection() -> bool:\n return bool(subprocess.check_output([\"hostname\", \"-I\"]))", "def __check_ssh(self):\n sfcs = self.sshTunnelDict[\"target_ip\"]\n\n cmd = \"ps aux | grep ssh | awk '{print $20}'\"\n result = subprocess.Popen(cmd,\n shell= True,\n stdout=subprocess.PIPE,\n stderr=subprocess.PIPE)\n stdout, stderr = result.communicate()\n if sfcs not in stdout.decode():\n return False\n else: return True", "def _check_host_existence(self, hostname: str) -> bool:\n with self.lock:\n hosts = self.hosts.all()\n for host in hosts:\n if host['hostname'] == hostname:\n return True\n return False", "def test_hostname_value(self):\n \n hostname = get_hostname()\n \n # Check to make sure the hostname is \"tjw-imac.grid.labs\"\n self.assertEqual(hostname, 'tjw-imac.grid.labs')", "def ssh_connection(hostname, username):\n\n #We testing if the username can to connect to the hostname\n if username == \"company1\":\n if hostname in open(\"./servers_list_company1.txt\", \"r\").read():\n pass\n else:\n return 1\n elif username == \"company2\":\n if hostname in open(\"./servers_list_company2.txt\", \"r\").read():\n pass\n else:\n return 1\n else:\n return 1\n\n #Connexion au serveur (nb, il faut que l'échange de clé ssh est eu lieu)\n try:\n ssh = paramiko.SSHClient()\n ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())\n ssh.connect(hostname, username=\"postfix\", timeout=4)\n print \"Connected to %s\" % hostname\n except paramiko.AuthenticationException:\n return 1\n except:\n return 1\n\n return ssh", "def test_rebuilt_server_hostname(self):\n remote_client = self.server_behaviors.get_remote_instance_client(\n self.server, self.servers_config)\n hostname = remote_client.get_hostname()\n self.assertEqual(hostname, self.expected_name)", "def hostname(self,hostname=None):\n return self.ssh_host(hostname)", "def __isSameHost( self, hostCN, hostConn ):\n hostCN_m = hostCN\n if '/' in hostCN:\n hostCN_m = hostCN.split( '/' )[1]\n if hostCN_m == hostConn:\n return True\n result = checkHostsMatch( hostCN_m, hostConn )\n if not result[ 'OK' ]:\n return False\n return result[ 'Value' ]", "def validate_host_key(cls, transport, hostname):\n # check server's host key -- this is important.\n key = transport.get_remote_server_key()\n if not PHelper.host_keys.has_key(hostname):\n print \"Warning : Host not found ! \", hostname\n #raise HostValidationException(1, \"Host not found\")\n elif not PHelper.host_keys[hostname].has_key(key.get_name()):\n print \"Warning: Key not found ! \", hostname\n #raise HostValidationException(2, \"Key not found.\")\n elif PHelper.host_keys[hostname][key.get_name()] != key:\n raise HostValidationException(3, \"Keys mismatch for \" + hostname)\n \n return True", "def connectSsh(self):\n connect_handle = pexpect.spawn(\"ssh -q -o StrictHostKeyChecking=no root@%s\" % self.ip)\n connect_handle.setwinsize(800,800)\n connect_handle.logfile_read = sys.stdout\n #connect_handle.logfile_send = sys.stdout\n i = 0\n ssh_newkey = r'(?i)Are you sure you want to continue connecting'\n remote_key_changed = r\"REMOTE HOST IDENTIFICATION HAS CHANGED\"\n\n perm_denied = r\"(?i)Permission denied\"\n while True:\n i = connect_handle.expect([ssh_newkey, 'assword:',self.promptshell,\n pexpect.EOF, pexpect.TIMEOUT,\n remote_key_changed, perm_denied])\n if i==0:\n connect_handle.sendline('yes')\n continue\n elif i==1:\n logger.info(\"Password supplied\")\n connect_handle.sendline(self.password)\n continue\n\t elif i==2:\n self._mode = CLI_MODES.shell\n self._prompt = self.promptshell\n break\n elif i==3:\n logger.info(\"Connection closed: %s\" % self)\n logger.info(connect_handle.before) # print out the result\n raise ValueError(\"Connection Closed: %s\" % self)\n elif i==4:\n logger.warning(\"Timeout while waiting for connection\")\n logger.info(connect_handle.before) # print out the result\n raise ValueError(\"Unable to establish connection %s\" % self)\n elif i==5:\n logger.warn(\"Removing offending key from .known_hosts..\")\n known_hosts_file = os.path.expanduser(\"~/.ssh/known_hosts\")\n\n if \"darwin\" in sys.platform.lower():\n # MAC OS\n utils.run_cmd(\"sed -i 1 's/%s.*//' %s\" % (self.ip, known_hosts_file))\n elif \"linux\" in sys.platform.lower():\n # Linux\n utils.run_cmd(\"sed -i 's/%s.*//' %s\" % (self.ip, known_hosts_file))\n\n connect_handle = pexpect.spawn(\"ssh root@%s\" % self.ip)\n connect_handle.setwinsize(800,800)\n connect_handle.logfile_read = sys.stdout\n\n continue\n elif i==6:\n logger.warning(\"Permission denied: %s\" % self)\n logger.info(connect_handle.before) # print out the result\n raise ValueError(\"Permission denied: %s.\" % self)\n return connect_handle", "def validate_host(request):\n log.debug(\n \"Inside validate_host. Request Data: %s\" % request.data)\n if request.method == 'POST':\n try:\n status = usm_wrapper_utils.check_host_ssh_auth(\n request.data['host'],\n request.data['port'],\n request.data['fingerprint'],\n request.data['username'],\n request.data['password'])\n if status:\n return Response({'message': 'Success'}, status=200)\n else:\n return Response({'message': 'Failed'}, status=417)\n except Exception, e:\n log.exception(e)\n return Response(\n {'message': 'Failed'}, status=417)\n else:\n return Response({})", "def check_all_hosts (self, repo_version_id, version_name):\n if self.compare_versions(self.ambari_version, \"2.1.0\") < 0:\n query1 = \"SELECT chm.host_name from ClusterHostMapping chm JOIN clusters c ON c.cluster_name = '{0}';\".format(self.cluster_name)\n else:\n query1 = \"SELECT h.host_name from ClusterHostMapping chm JOIN clusters c ON c.cluster_name = '{0}' JOIN hosts h ON chm.host_id = h.host_id;\".format(self.cluster_name)\n\n if self.compare_versions(self.ambari_version, \"2.1.0\") < 0:\n query2 = \"SELECT hv.host_name, hv.state FROM host_version hv WHERE hv.repo_version_id = {0};\".format(repo_version_id)\n else:\n #query2 = \"SELECT hv.state,h.host_name FROM hosts h JOIN host_version hv ON h.host_id = hv.host_id WHERE hv.repo_version_id = {0};\".format(repo_version_id)\n query2 = \"SELECT hv.state,h.host_name, hs.health_status,hs.agent_version,(h.total_mem/1024/1024) as total_mem_gb,(hs.available_mem/1024/1024) as available_mem_gb FROM hosts h JOIN host_version hv ON h.host_id = hv.host_id JOIN hoststate hs ON h.host_id = hs.host_id WHERE hv.repo_version_id = {0} order by h.host_name;\".format(repo_version_id)\n # All cluster hosts\n host_names = set()\n self.cursor.execute(query1)\n rows = self.cursor.fetchall()\n if self.options.verbose:\n Logger.debug(query1 + \"\\n\")\n if rows and len(rows) > 0:\n host_names = set([row[0] for row in rows if len(row) == 1])\n Logger.debug(\"Hosts: {0}\".format(\", \".join(host_names)))\n\n host_name_to_state = {} # keys should be a subset of host_names\n hosts_with_repo_version_state_not_in_current = set()\n self.cursor.execute(query2 + \"\\n\")\n rows = self.cursor.fetchall()\n Logger.info(\"******************************************************************************************************************************************************\")\n Logger.info(\"\\t\\t\\t\\t\\t\\t\\tHOST(S) STATE\\t\")\n Logger.info(\"******************************************************************************************************************************************************\\n\")\n Logger.info(\"------------------------------------------------------------------------------------------------------------------------------------------------------\")\n Logger.info(\"State\\t\\tHostname\\t\\t\\t\\tHealth\\t\\tAgentVersion\\tTotalMemory\\tAvailableMemory\")\n Logger.info(\"------------------------------------------------------------------------------------------------------------------------------------------------------\")\n\n if rows and len(rows) > 0:\n for row in range(len(rows)):\n data = json.loads(rows[row][2])\n data1 = json.loads(rows[row][3])\n Logger.info(\"{0}\\t\\t{1}\\t\\t{2}\\t\\t{3}\\t\\t{4}\\t\\t{5}\".format(rows[row][0], rows[row][1], data[\"healthStatus\"], data1[\"version\"], rows[row][4], rows[row][5]))\n print (\"\\n\")\n Logger.debug(query2)\n if rows and len(rows) > 0:\n for row in rows:\n if len(row) == 6:\n host_name = row[1]\n state = row[0]\n host_name_to_state[host_name] = state\n if state.upper() != \"CURRENT\":\n hosts_with_repo_version_state_not_in_current.add(host_name)\n host_names_with_version = set(host_name_to_state.keys())\n host_names_without_version = host_names - host_names_with_version\n # Logger.info(\"\\t\\tHost(s) state Summary\")\n if len(host_names) > 0:\n if len(host_names_without_version) > 0:\n Logger.error(\"{0} host(s) do not have a Host Version for Repo Version {1}.\\n\" \\\n \"Host(s):\\n{2}\\n\".\n format(len(host_names_without_version), version_name, \", \".join(host_names_without_version)))\n\n if len(hosts_with_repo_version_state_not_in_current) > 0:\n Logger.error(\"{0} host(s) have a Host Version for Repo Version {1} but the state is not CURRENT.\\n\" \\\n \"Host(s):\\n{2}\\n\".\n format(len(hosts_with_repo_version_state_not_in_current), version_name, \", \".join(hosts_with_repo_version_state_not_in_current)))\n\n if len(host_names_without_version) == 0 and len(hosts_with_repo_version_state_not_in_current) == 0:\n Logger.info(\"Found {0} host(s) in the cluster, and all have a Host Version of CURRENT for \" \\\n \"Repo Version {1}. Things look good.\\n\".format(len(host_names), version_name))\n else:\n Logger.error(\"Make sure that all of these hosts are heartbeating, that they have the packages installed, the\\n\" \\\n \"hdp-select symlinks are correct, and that the services on these hosts have been restarated.\\n\")\n pass", "def check_hostname(hostname):\n errors = []\n for result in validation.check_hostname(misc.utf8(hostname)):\n if result == validation.HOSTNAME_LENGTH:\n errors.append('hostname_error_length')\n elif result == validation.HOSTNAME_BADCHAR:\n errors.append('hostname_error_badchar')\n elif result == validation.HOSTNAME_BADHYPHEN:\n errors.append('hostname_error_badhyphen')\n elif result == validation.HOSTNAME_BADDOTS:\n errors.append('hostname_error_baddots')\n return errors", "def is_host_localhost(hostname: str, port: str = None) -> None:\n\n if port is None:\n port = 22 # no port specified, lets just use the ssh port\n\n # socket.getfqdn(\"127.0.0.1\") does not return localhost\n # on some users' machines\n # thus, we directly return True if hostname is localhost, 127.0.0.1 or 0.0.0.0\n if hostname in (\"localhost\", \"127.0.0.1\", \"0.0.0.0\"):\n return True\n\n hostname = socket.getfqdn(hostname)\n localhost = socket.gethostname()\n localaddrs = socket.getaddrinfo(localhost, port)\n targetaddrs = socket.getaddrinfo(hostname, port)\n\n return localaddrs == targetaddrs", "def checkGetHostByName(self, result):\n self.assertEquals(result, '127.0.0.1')", "def hostname(ctx):\n ctl = ctx.ctl\n\n jobs = ctl('list-avail', '--partition', 'main', flatten=False)\n\n if len(jobs) == 0:\n click.echo('No jobs running', err=True)\n sys.exit(1)\n\n for job in jobs:\n host = ctl('get-host', '--jobid', job['id']).get('host')\n click.echo(host)\n\n return 0", "def host_is_up(self, conn_type, hostname):\n try:\n socket_host = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n socket_host.settimeout(1)\n if conn_type == CONN_SSH:\n if ':' in hostname:\n LIBVIRT_HOST, PORT = (hostname).split(\":\")\n PORT = int(PORT)\n else:\n PORT = SSH_PORT\n LIBVIRT_HOST = hostname\n socket_host.connect((LIBVIRT_HOST, PORT))\n if conn_type == CONN_TCP:\n socket_host.connect((hostname, TCP_PORT))\n if conn_type == CONN_TLS:\n socket_host.connect((hostname, TLS_PORT))\n socket_host.close()\n return True\n except Exception as err:\n return err", "def cache_ssh_key(hostname):\n\n try:\n sh.grep('-q', hostname, SSH_KNOWN_HOSTS)\n except sh.ErrorReturnCode:\n with open(SSH_KNOWN_HOSTS, 'ab') as known_hosts_file:\n known_hosts_file.write('\\n')\n\n keyscan = sh.Command('ssh-keyscan')\n keyscan('-t', 'rsa', hostname, _out=known_hosts_file)", "def check_if_same_host(host, url):\n # print '\\nchecking same origin:', host, get_host_name(url)\n\n if host == get_host_name(url):\n return True\n return False", "def _host_exists(self, host_name):\n hosts = self.host_obj.search_by_name(host_name)\n\n if len(hosts) > 0:\n for host in hosts:\n hostname = host['match']\n if host_name == hostname:\n return hostname\n return hostname\n LOG.debug(\"no host found for:\" + host_name)\n return None", "def test_build_ssh_hostname_command(self):\n actual_result = SshCommandBuilder(SERVER_USER, COMMAND) \\\n .set_password(SERVER_PASSWORD) \\\n .set_hostname(SERVER_HOST) \\\n .to_build()\n self.assertListEqual(actual_result,\n ['sshpass', '-p', 'QWERTY', 'ssh',\n 'root@server', 'command'])", "def enforce_hostnames(self) -> pulumi.Output[Optional[bool]]:\n return pulumi.get(self, \"enforce_hostnames\")" ]

[ "0.69107556", "0.656078", "0.656078", "0.65098125", "0.6342981", "0.63187635", "0.63187635", "0.6303591", "0.62600493", "0.6256846", "0.62546986", "0.6138215", "0.61173916", "0.6107151", "0.5987594", "0.5957575", "0.5948089", "0.5927646", "0.5832362", "0.58163154", "0.5786314", "0.57833153", "0.57626766", "0.5725101", "0.57177716", "0.5704112", "0.5700933", "0.56938183", "0.56767493", "0.56638473" ]

[ "def generate_hosts_file(n, path=\"./tests/fixtures\"):\n if not os.path.isdir(path):\n os.mkdir(path)\n with open(f\"{path}/hosts.txt\", \"w\") as f:\n for i in range(n):\n f.write(f\"{i},localhost,127.0.0.1,{5000+i}\\n\")", "def write(content):\n with open(TMP_HOSTS_FILE, \"w\") as f:\n f.write(content)", "def create_knownhosts_txt(self, containers):\n tcp_connection_list = []\n udp_connection_list = []\n\n sorted_containers = sorted(containers, key=lambda x: x.name)\n for container in sorted_containers:\n tcp_connection_list.append([container.name, container.tcp_port_range[0]])\n udp_connection_list.append([container.name, container.udp_port_range[0]])\n\n # Writing complete knownhosts csvs to input directory'\n networked_containers = self.get_standard_containers(containers)\n router = self.get_router(containers)\n\n if router is not None:\n networked_containers.append(router)\n\n sorted_networked_containers = sorted(networked_containers, key=lambda x: x.name)\n for container in sorted_networked_containers:\n knownhosts_location = os.path.join(container.directory, 'knownhosts_tcp.txt')\n with open(knownhosts_location, 'w') as outfile:\n for tup in tcp_connection_list:\n outfile.write(\" \".join(map(str, tup)) + '\\n')\n outfile.flush()\n autograding_utils.add_all_permissions(knownhosts_location)\n\n knownhosts_location = os.path.join(container.directory, 'knownhosts_udp.txt')\n with open(knownhosts_location, 'w') as outfile:\n for tup in udp_connection_list:\n outfile.write(\" \".join(map(str, tup)) + '\\n')\n outfile.flush()\n autograding_utils.add_all_permissions(knownhosts_location)", "def inject_hosts_files(self):\n self.log.info(\"Injecting host files\")\n hosts = dict()\n for i in self.all_nodes:\n hosts[i.name] = i.get_public_addr()\n #add the host names to etc/hosts\n orchestrator.inject_hostnames(hosts, delete=self.cluster_name)\n for i in self.all_nodes:\n i.inject_hostnames(hosts, delete=self.cluster_name)\n self.all_nodes[0].run_command(\"service ganglia-monitor restart; service gmetad restart\", silent=True)\n orchestrator.run_command(\"service ganglia-monitor restart; service gmetad restart\", silent=True)", "def _update_hosts_file(self, resolution):\n self._execute_command('echo {0} >> /etc/hosts'.format(resolution),\n sudo=True)", "def _write_fingerprints_pubkeys_to_files(hostdict=None,\n known_hosts_root=None):\n\n if hostdict is None:\n raise RuntimeError('[-] hostdict not specified')\n if known_hosts_root is None:\n known_hosts_root = os.getcwd()\n for subdir in ['known_hosts', 'fingerprints']:\n dir = os.path.join(known_hosts_root, subdir)\n if not os.path.exists(dir):\n logger.debug(\"[+] creating directory '%s'\", dir)\n os.makedirs(dir, exist_ok=True)\n else:\n if not os.path.isdir(dir):\n raise RuntimeError(\n f\"[-] '{dir}' exists and is not a directory\")\n for host, v in hostdict.items():\n for fingerprint in v['fingerprint']:\n dir = os.path.join(known_hosts_root, 'fingerprints', host)\n os.makedirs(dir, exist_ok=True)\n ktype = _get_type(fingerprint)\n fp_file = os.path.join(dir, f'{ktype}.fingerprint')\n with open(fp_file, 'w') as f:\n f.write(f'{fingerprint}\\n')\n logger.debug(\"[+] wrote fingerprint to '%s'\", fp_file)\n\n for hostkey in v['hostkey']:\n dir = os.path.join(known_hosts_root, 'known_hosts', host)\n os.makedirs(dir, exist_ok=True)\n ktype = _get_type(hostkey)\n hk_file = os.path.join(dir, f'{ktype}.known_hosts')\n with open(hk_file, 'w') as f:\n f.write(f'{hostkey}\\n')\n logger.debug(\"[+] wrote hostkey to '%s'\", hk_file)\n pass", "def hosts_windows_format(cls):\n\n template = Helpers.File(Settings.hosts_windows_template).read()\n\n template = Helpers.Regex(\n template, r\"%%version%%\", replace_with=Settings.version\n ).replace()\n template = Helpers.Regex(\n template, r\"%%lenHosts%%\", replace_with=format(len(Settings.domains), \",d\")\n ).replace()\n\n data_to_write = \"127.0.0.1 \" + \"\\n127.0.0.1 \".join(Settings.domains)\n\n template = Helpers.Regex(\n template, r\"%%content%%\", replace_with=data_to_write\n ).replace()\n\n print(\"Generation of %s\" % Settings.hosts_windows_file, end=\" \")\n Helpers.File(Settings.hosts_windows_file).write(template, overwrite=True)\n print(Settings.done)", "def done():\n for host in context.hosts_list:\n hostfile = re.sub('\\W|^(?=\\d)', '_', host)\n filename = context.dump_file + '-' + hostfile + '.py'\n code = context.locusts.get(host)\n open(filename, \"w\").write(code)", "def set_hosts(self, hypervisor_per_cluster=False):\n\n self.conf['hosts'] = set()\n\n host_patterns, host_others = self._sift_patterns(\n self.conf.get('hosts_list')\n )\n datacenter_patterns = self.conf.get('datacenter', [])\n cluster_patterns = self.conf.get('cluster', [])\n\n if host_patterns:\n self.conf['host_pattern'] = host_patterns\n\n self.conf['hosts'] = self._get_hypervisors_from_api()\n # Filter all host specified with -H\n host_filtered = set()\n if host_others:\n host_filtered = set([\n (dc, cl, h, is_spm, is_up)\n for dc, cl, h, is_spm, is_up in self.conf['hosts']\n if h in host_others\n ])\n not_found = host_others - set(host[2] for host in host_filtered)\n if not_found != set():\n # try to resolve to ip specified hosts\n for fqdn in set(not_found):\n try:\n ipaddr = socket.gethostbyname(fqdn)\n logging.debug('%s --> %s' % (fqdn, ipaddr))\n for (dc, cl, h, is_spm, is_up) in self.conf['hosts']:\n if h == ipaddr:\n host_filtered.add((dc, cl, h, is_spm, is_up))\n not_found.remove(fqdn)\n except socket.error:\n logging.warning(\n _('Cannot resolve {host}').format(\n host=fqdn,\n )\n )\n if not_found != set():\n # try to resolve to ip known hypervisors\n for (dc, cl, h, is_spm, is_up) in self.conf['hosts']:\n try:\n ipaddr = socket.gethostbyname(h)\n logging.debug('%s --> %s' % (h, ipaddr))\n if ipaddr in host_others:\n host_filtered.add((dc, cl, h, is_spm, is_up))\n not_found.remove(ipaddr)\n except socket.error:\n logging.warning(\n _('Cannot resolve {host}').format(\n host=h,\n )\n )\n if not_found != set():\n logging.error(\n _(\n 'The following host are not listed as hypervisors: '\n '{not_listed}. Known hypervisors can be listed using '\n 'the list command'\n ).format(\n not_listed=','.join(not_found)\n )\n )\n sys.exit(ExitCodes.CRITICAL)\n\n orig_hosts = self.conf['hosts'].copy()\n\n if host_patterns:\n for pattern in host_patterns:\n host_filtered |= self._filter_hosts('host', pattern)\n if host_patterns or host_others:\n self.conf['hosts'] &= host_filtered\n\n # Intersect with hosts belonging to the data centers specified with -d\n if datacenter_patterns:\n datacenter_filtered = set()\n for pattern in datacenter_patterns:\n datacenter_filtered |= self._filter_hosts(\n 'datacenter', pattern\n )\n self.conf['hosts'] &= datacenter_filtered\n\n # Intersect with hosts belonging to the clusters specified with -c\n if cluster_patterns:\n # remove all hosts that don't match the patterns\n cluster_filtered = set()\n for pattern in cluster_patterns:\n cluster_filtered |= self._filter_hosts('cluster', pattern)\n self.conf['hosts'] &= cluster_filtered\n\n # If hypervisor_per_cluster is set, collect data only from a single\n # hypervisor per cluster; if the Spm found, collect data from it.\n if hypervisor_per_cluster:\n selected_hosts = dict()\n for dc, cluster, host, is_spm, is_up in self.conf['hosts']:\n # Always add the SPM\n if is_spm:\n selected_hosts[cluster.name] = (dc, cluster, host, is_spm,\n is_up)\n # For the given cluster, if no host added yet, add it\n elif cluster.name not in selected_hosts:\n selected_hosts[cluster.name] = (dc, cluster, host, is_spm,\n is_up)\n # If a host is up and the SPM isn't added yet, add this host\n elif is_up and not selected_hosts[cluster.name][3]:\n selected_hosts[cluster.name] = (dc, cluster, host, is_spm,\n is_up)\n self.conf['hosts'] &= set(selected_hosts.values())\n\n # warn users if they are going to collect logs from all hosts.\n if orig_hosts and self.conf['hosts'] == orig_hosts:\n logging.warning(\n _(\n 'This ovirt-log-collector call will collect logs from '\n 'all available hosts. This may take long time, '\n 'depending on the size of your deployment'\n )\n )\n\n return bool(self.conf.get('hosts'))", "def hosts_unix_format(cls):\n\n template = Helpers.File(Settings.hosts_unix_template).read()\n\n template = Helpers.Regex(\n template, r\"%%version%%\", replace_with=Settings.version\n ).replace()\n template = Helpers.Regex(\n template, r\"%%lenHosts%%\", replace_with=format(len(Settings.domains), \",d\")\n ).replace()\n\n data_to_write = \"0.0.0.0 \" + \"\\n0.0.0.0 \".join(Settings.domains)\n\n template = Helpers.Regex(\n template, r\"%%content%%\", replace_with=data_to_write\n ).replace()\n\n print(\"Generation of %s\" % Settings.hosts_unix_file, end=\" \")\n Helpers.File(Settings.hosts_unix_file).write(template, overwrite=True)\n print(Settings.done)", "def combine_host():\n lines = []\n for path in [google_hosts, my_hosts]:\n with open(path, 'r') as f:\n lines += f.readlines()\n with open(output_hosts, 'w') as f:\n f.writelines(line for line in lines)", "def _write_ce_collector_file(self, info_services_file):\n view_hosts = []\n for host in self.ce_collectors:\n if ':' not in host:\n view_hosts.append(\"%s:%d\" % (host, HTCONDOR_CE_COLLECTOR_PORT))\n else:\n view_hosts.append(host)\n info_services_file_contents = \"\"\"\\\n# Do not edit - file generated by osg-configure\nCONDOR_VIEW_HOST = %s\n\"\"\" % \",\".join(view_hosts)\n\n return utilities.atomic_write(info_services_file, info_services_file_contents)", "def update_cluster_hosts(self, hosts):\n self._hosts = hosts\n self._collect_hosts_d = True", "def _write_dataset(name, dataset, num_shards, output_dir):\n borders = np.int32(np.linspace(0, len(dataset), num_shards + 1))\n indices = list(range(len(dataset)))\n\n for i in range(num_shards):\n filename = os.path.join(\n output_dir, '%s-%.5d-of-%.5d' % (name, i, num_shards))\n shard_indices = indices[borders[i]:borders[i + 1]]\n _write_shard(filename, dataset, shard_indices)\n logging.info('Wrote dataset indices [%d, %d) to output shard %s',\n borders[i], borders[i + 1], filename)", "def _add_node_to_etc_hosts(self):\n image = 'alpine:latest'\n command = 'echo \"{} {} # clusterdock\" >> /etc/hosts'.format(self.ip_address,\n self.fqdn)\n volumes = {'/etc/hosts': {'bind': '/etc/hosts', 'mode': 'rw'}}\n\n logger.debug('Adding %s to /etc/hosts ...', self.fqdn)\n client.containers.run(image=image,\n command=[self.execute_shell, '-c', command],\n volumes=volumes,\n remove=True)", "def writeOutServers(self):\n # we'll be writing out to the server tracker file, overwriting\n # anything that may exist in it\n global server_tracker_file\n \n with open(server_tracker_file, 'wb') as outfile:\n # let's leverage the printStatus method we have\n outfile.write(self.printStatus())\n \n return", "def set_hostname(self, path, hostname):\n\n f = open(os.path.join(path, 'etc', 'hostname'), 'w')\n f.write(hostname + \"\\n\")\n f.close()\n\n hosts = os.path.join(path, 'etc', 'hosts')\n\n with open(hosts, 'rb') as f:\n reader = csv.reader(f, delimiter=\"\\t\")\n rows = [row for row in reader]\n\n for row in rows:\n if len(row) > 1 and row[0] == '127.0.1.1':\n row[1] = hostname\n break\n\n with open(hosts, 'w') as f:\n for row in rows:\n f.write(\"\\t\".join(row) + \"\\n\")", "def all_hosts(self):\n ...", "def write(self):\n self.__domainlist.sort()\n\n try:\n fileobject = open(filename, mode=\"w\")\n for domain in self.__domainlist:\n fileobject.write(domain + \"\\n\")\n fileobject.close()\n except:\n print(\"Error when writing file\")", "def update_known_hosts(ips=None, ssh_key=None,\n known_hosts_file=KNOWN_HOSTS_FILE):\n\n for ip, hostname in ips:\n # wipe out the old keys (if any)\n remove_ssh_known_host(hostname)\n remove_ssh_known_host(guess_fqdn(ip=ip, hostname=hostname))\n # Remove entries having the same IP just in a case. Note that\n # addr might be None for several reasons (VM is down at the moment,\n # network configuration is still in progress, etc)\n if ip:\n remove_ssh_known_host(ip)\n\n if ssh_key:\n entries = []\n for ip, hostname in ips:\n fqdn = guess_fqdn(ip=ip, hostname=hostname)\n entries.append('{fqdn},{ip} {key}'.format(fqdn=fqdn, ip=ip, key=ssh_key))\n with KNOWN_HOSTS_MUTEX:\n with open(known_hosts_file, 'a') as f:\n for entry in entries:\n f.write(entry + '\\n')\n f.flush()", "def add_host_entries(hosts_file=None):\n from fabric.contrib.files import append\n if hosts_file:\n try:\n hosts = open(hosts_file)\n for line in hosts:\n append(\"/etc/hosts\", line.rstrip(\"\\n\"), use_sudo=True)\n except IOError:\n print \"ERROR: defined hosts file is missing!\"", "def write(self, path):\n try:\n contents = self.file_contents()\n except Exception as e:\n raise e\n\n tmp_hosts_file_path = \"{0}.tmp\".format(path) # Write atomically\n with open(tmp_hosts_file_path, 'w') as tmp_hosts_file:\n tmp_hosts_file.write(contents)\n\n os.rename(tmp_hosts_file_path, path)", "def add_hosts(self, hosts):\n for host in hosts:\n if host not in self.__hosts__:\n self.__hosts__.append(KnownHostsHost(host))", "def writeEcs( self ):\n\n self.logger.info( 'writeEcs: START' )\n\n # Generate inserts for ecs table.\n self.importerEc.writeEcs()\n\n self.logger.info( 'writeEcs: DONE' )", "def share_config_with_other_nodes(self):\n my_host, _ = self.experiment.get_peer_ip_port_by_id(self.experiment.my_id)\n other_hosts = set()\n for peer_id in self.experiment.all_vars.keys():\n host = self.experiment.all_vars[peer_id]['host']\n if host not in other_hosts and host != my_host:\n other_hosts.add(host)\n self._logger.info(\"Syncing config with host %s\", host)\n os.system(\"rsync -r --delete /home/martijn/hyperledger-deploy-scripts martijn@%s:/home/martijn/\" % host)", "def set_hosts(hostfile='allhosts'):\n\n remote_servers = []\n\n file = open(hostfile, 'r')\n for line in file.readlines():\n remote_servers.append(line.strip('\\r\\n'))\n\n env.hosts = remote_servers", "def _write_dataset(name, dataset, indices, num_shards):\n tf.logging.info(\"Writing dataset %s\", name)\n borders = np.int32(np.linspace(0, len(indices), num_shards + 1))\n for i in range(num_shards):\n filename = os.path.join(FLAGS.output_dir, \"%s-%.5d-of-%.5d\" % (name, i,\n num_shards))\n shard_indices = indices[borders[i]:borders[i + 1]]\n _write_shard(filename, dataset, shard_indices)\n tf.logging.info(\"Wrote dataset indices [%d, %d) to output shard %s\",\n borders[i], borders[i + 1], filename)\n tf.logging.info(\"Finished writing %d sentences in dataset %s.\",\n len(indices), name)", "def createcluster(self):\n for hostitem in OTHER_NODES:\n checkhost(hostitem)\n if OTHER_WSREP:\n for wsrepitem in OTHER_WSREP:\n REMAINING_NODES.append(wsrepitem)\n if REMAINING_NODES:\n alive = str(REMAINING_NODES)[1:-1]\n print \"{}\\nThe following nodes are alive in cluster:{}\\n {}\".format(\n RED, WHITE, alive)\n print \"\\n\\nTo boostrap a new cluster you need to switch them off\\n\"\n os.sys.exit(1)\n else:\n if self.mode == \"new\" and not self.force:\n ask('\\nThis operation will destroy the local data')\n clean_dir(self.datadir)\n initialize_mysql(self.datadir)\n bootstrap_mysql(self.mode)\n if self.mode == \"new\":\n create_monitor_table()\n ALL_NODES.append(\"localhost\")\n for creditem in CREDENTIALS:\n create_users(creditem)\n print \"\"\n drop_anonymous()", "def store_clusters(mapping, sff_fp, outdir=\"/tmp/\", store_members=False):\r\n\r\n # get mapping read to cluster\r\n invert_map = invert_mapping(mapping)\r\n (flowgrams, header) = lazy_parse_sff_handle(open(sff_fp))\r\n\r\n leftover_fasta_fh = open(outdir + \"/singletons.fasta\", \"w\")\r\n centroids = []\r\n for f in flowgrams:\r\n try:\r\n key = invert_map[f.Name]\r\n except KeyError:\r\n # this flowgram has not been clustered\r\n continue\r\n if (len(mapping[key]) == 0):\r\n # do not store singletons in a separate cluster\r\n leftover_fasta_fh.write(f.toFasta() + \"\\n\")\r\n continue\r\n elif(f.Name in mapping):\r\n # save as a centroid\r\n centroids.append((len(mapping[f.Name]) + 1, f.Name, f.toSeq()))\r\n\r\n if (store_members):\r\n flows_fh = open(outdir + key + \".flows\", \"a\")\r\n fasta_fh = open(outdir + key + \".fasta\", \"a\")\r\n flows_fh.write(\"%s\\n\" % f)\r\n fasta_fh.write(f.toFasta() + \"\\n\")\r\n fasta_fh.close()\r\n flows_fh.close()\r\n\r\n leftover_fasta_fh.close()\r\n\r\n # sort and store ordered by cluster_size\r\n centroids.sort(reverse=True)\r\n centroid_fh = open(outdir + \"/centroids.fasta\", \"w\")\r\n for size, name, seq in centroids:\r\n centroid_fh.write(\">%s | cluster size: %d \\n%s\\n\" %\r\n (name, size, seq))\r\n centroid_fh.close()", "def batchSetHosts(serverList, hostList, delHostList=[]):\n def sortedByKeys(dic):\n keys = dic.keys()\n keys.sort()\n retDic = {}\n for key in keys:\n retDic[key] = dic[key]\n return retDic\n\n for server in serverList:\n env.host_string = server['host']\n env.port = server['port']\n env.user = server['user']\n env.password = server['password']\n ret = sudo('cat /etc/hosts')\n lines = ret.split('\\n')\n hostHash = {}\n newHostList = []\n for line in lines:\n line = line.replace('\\n', '')\n line = line.replace('\\r', '')\n line = line.strip()\n if line == '':\n continue\n if line.replace(' ', '') == '':\n continue\n if line[0] == '#':\n newHostList.append(line)\n continue\n items = line.split(' ')\n ip = items[0].strip()\n for i in xrange(len(items)):\n if i == 0:\n continue\n domain = items[i]\n domain = domain.strip()\n if domain == '':\n continue\n if domain in delHostList:\n continue\n hostHash[domain] = ip\n setHostHash = {}\n for host in hostList:\n host = host.strip()\n items = host.split(' ')\n ip = items[0].strip()\n for i in xrange(len(items)):\n if i == 0:\n continue\n domain = items[i]\n domain = domain.strip()\n if domain == '':\n continue\n if domain in delHostList:\n continue\n setHostHash[domain] = ip\n for domain, ip in setHostHash.items():\n hostHash[domain] = ip\n hostHash = sortedByKeys(hostHash)\n for domain, ip in hostHash.items():\n hostline = ip + ' ' + domain\n newHostList.append(hostline)\n newHostList.sort()\n hosts = '\\n'.join(newHostList)\n sudo(\"echo '%s' > /etc/hosts\" % (hosts))" ]

[ "0.6225859", "0.60397935", "0.5874528", "0.5857438", "0.58426636", "0.5815164", "0.57000405", "0.554411", "0.55060196", "0.5492018", "0.54734915", "0.53940684", "0.53639436", "0.53541887", "0.5298685", "0.5272429", "0.521711", "0.51572895", "0.5101507", "0.5088074", "0.5026904", "0.49947712", "0.49829358", "0.49798986", "0.48843604", "0.48735926", "0.48716286", "0.48584735", "0.4857655", "0.48517758" ]

[ "def __repr__(self):\n return \"Personne: nom({}), prénom({}), âges ({})\".format(self.nom, self.prenom, self.age)", "def crier_ordres(self, personnage):\n adverse = self.adverse\n msg = \"{} s'écrie : un boulet sur {} !\".format(\n personnage.distinction_audible, adverse.desc_survol)\n self.navire.envoyer(msg)", "def persons(self):\r\n return persons.Persons(self)", "def crier_ordres(self, personnage):\n msg = \"{} s'écrie : rameurs, laissez courir !\".format(\n personnage.distinction_audible)\n self.navire.envoyer(msg)", "def add_person(self, person):\n # Check if the person is an instance of the Person class\n # and if the room has a vacancy, then allocate\n # TODO: Perform SQL Query\n # if isinstance(person, Person) and has_vacancy(self):\n # self.occupants.append(person)\n pass", "def __call__(self,person):\r\n age = person.get_age() #get the age of a person\r\n age += self.__years #add the right number of yeras\r\n person.set_age(age)", "def ser_perseguido(self, personaje):\n if personaje not in self.__perseguidores:\n self.__perseguidores.append(personaje)", "def initialize_persons(self) -> None:\n self.population.initialize_id(0, self.size)\n self.population.initialize_ages(self.min_age, self.max_age, self.size)\n self.population.initialize_positions(self.x_bounds, self.y_bounds,\n self.size)\n self.population.initialize_g_value(self.r, 1/self.k, self.size)\n self.population.initialize_mortality_rate(self.size,\n self.mortality_rate)\n self.population.initialize_susceptibility()\n self.population.initialize_infected_by()\n\n self.persons[:, 7] = 1\n self.persons[:, 10] = 0.1\n self.persons[:, 11] = 0.1\n\n # Update the destination each person is headed to and corresponding\n # speed randomly\n self.persons = self.movement.update_persons(self.persons, self.size,\n self.speed, 1)\n\n self.infected_person = np.random.randint(0, self.size)\n self.persons[self.infected_person, index.g_value] = 3\n self.population.set_infected_at(self.infected_person, 0)\n self.persons[self.infected_person, index.infected_by] = \\\n self.infected_person\n self.persons[self.infected_person, index.social_distance] = 0\n self.persons[self.infected_person, 9] = 1", "def __init__(self, nombre, socios):\n self.__nombre = nombre\n self.__socios = socios\n self.__resultados = {'p1': '', 'p2': '', 'p3': '', 'p4': '', 'p5': '', 'p6': '', 'p7': ''}", "def entrer(self):\n valeur = getattr(self.objet, self.attribut, None)\n if valeur is None:\n setattr(self.objet, self.attribut, [])", "def relationships(self):", "def __init__(self,partnership_type,person1,person2,s):\n \n self.type = partnership_type\n self.persons = [person1,person2]\n \n person1.add_partner(person2,s)\n person2.add_partner(person1,s)", "def find(self, person):\n page = self.find_page(person)\n try:\n entity_id = self.get_entity_id(page.title)\n entity = self.get_entity(entity_id)\n person.dob = self.get_birthday(entity)\n person.occupation = self.get_occupation(entity)\n person.nationality = self.get_country_of_citizenship(entity)\n res_domicile = self.get_domicile(entity)\n if res_domicile:\n person.domicile = res_domicile\n elif person.nationality == self.get_birthcountry(entity):\n person.domicile = person.nationality # this is an assumption!\n birth_name = self.get_birth_name(entity)\n person.middle_name = self.get_middle_name(birth_name, person)\n if page:\n person.is_famous = 'True'\n else:\n person.is_famous = ''\n person.net_worth = self.get_networth(entity)\n person.description = page.summary\n person.set_raw()\n except:\n pass", "def set_ages(self):\n for i in self.individuals.values():\n i.set_age(i._age_line)", "def person(self, person_id):\r\n return persons.Person(self, person_id)", "def populate_person(root) :\n\tfor person in root.findall(\"Person\"):\n\t\ttemp_person = Person()\n\t\ttemp_person.person_ID = person.get(\"ID\")\n\t\ttemp_person.name = person.get(\"Name\")\n\n\t\tif person.find(\"Kind\") is not None :\n\t\t\ttemp_person.kind = person.find(\"Kind\").text\n\t\tif person.find(\"Location\") is not None :\n\t\t\ttemp_person.location = person.find(\"Location\").text\n\n\t\tfor crisis in person.iter(\"Crisis\") :\n\t\t\ttemp_relations = Relations()\n\t\t\tcheck = Relations.objects.filter(crisis_ID = crisis.get(\"ID\"), person_ID = person.get(\"ID\"))\n\t\t\tif len(check) == 0:\n\t\t\t\ttemp_relations.populate(c_id = crisis.get(\"ID\"), p_id = person.get(\"ID\"))\n\t\t\t\ttemp_relations.save()\n\n\t\tfor org in person.iter(\"Org\") :\n\t\t\ttemp_relations = Relations()\n\t\t\tcheck = Relations.objects.filter(org_ID = org.get(\"ID\"), person_ID = person.get(\"ID\"))\n\t\t\tif len(check) == 0:\n\t\t\t\ttemp_relations.populate(p_id = person.get(\"ID\"), o_id = org.get(\"ID\"))\n\t\t\t\ttemp_relations.save()\n\n\t\tpopulate_common(person, person.get(\"ID\"), temp_person)\n\t\ttemp_person.save()", "def set_age (self, PersonAge): \r\n self.age = PersonAge", "def populate_community():\n\t\tfor i in range(1,11):\n\t\t\tSimulation.community[\"person\"+str(i)] = Person(\"person\"+str(i))", "def _get_persons(self):\n if not hasattr(self, 'persons'):\n url = \"http://www.kongehuset.no/program.html?tid=27511&sek=26946\"\n r = requests.get(url)\n soup = BeautifulSoup(r.text, \"html.parser\")\n options = soup.find(\"select\", { \"name\": \"person\" })\\\n .find_all(\"option\")\n self.persons = zip(\n [x.text for x in options],\n [x[\"value\"] for x in options]\n )\n return self.persons[2:]", "def update(self):\n\n # Ordenamos los personajes por fila, para luego dibujarlos correctamente. Para que no se solapen.\n self._personajes.sort(self._comparar_coordenadas_personajes)\n\n for personaje in self._personajes:\n if (personaje.andando): # Si está andando.\n # Si el personaje se encuentra en el centro de la celda a donde debia llegar ...\n if (personaje.obtener_coordenadas() == self._mapa.obtener_coordenadas_por_posicion((personaje.camino[0][0], personaje.camino[0][1]),self._mapa.CENTER)): \n del personaje.camino[:1] # Eliminamos esa celda del camino ha seguir porque ya ha llegado a ella. \n if ((personaje.camino == []) or (personaje.camino == None)): # Si ya no queda camino a seguir...\n personaje.parar() # Paramos al Personaje.\n if not(personaje.accion == None): # Si tiene asignada alguna acción después de haber llegado a su destino ...\n personaje.accion() # Ejecutamos la acción\n personaje.accion = None # Y limpiamos la acción\n if (personaje.nombre != \"Jugador\"): # Si el Personaje no es el Jugador establacemos su dirección final.\n personaje.actualizar_direccion(personaje.direccion_final)\n else: # Calculamos la nueva direccion hacia donde tiene que mover\n # Obtenemos la fila y columna donde se encuenta el personaje.\n origen = self._mapa.obtener_posicion_por_coordenadas(personaje.obtener_coordenadas())\n # Establecemos hacia donde tiene que mirar el Personaje para ir en esa dirección.\n personaje.actualizar_direccion(self._mapa.direcciones.index([personaje.camino[0][0] - origen[0], personaje.camino[0][1] - origen[1]]))\n else: # Si el personaje no esa todavia en el centro de la celda \n if (not self._hay_colision(personaje, (personaje.camino[0][0], personaje.camino[0][1]))): # Si no hay colisión en la celda de destino \n personaje.mover(personaje.obtener_direccion()) # Movemos al personaje en esa dirección.\n else: # Si hay colision\n celda_personaje = self._mapa.obtener_posicion_por_coordenadas(personaje.obtener_coordenadas())\n personaje.actualizar_posicion(self._mapa.obtener_coordenadas_por_posicion((celda_personaje[0], celda_personaje[1]),self._mapa.CENTER))\n # Volvermos a calcular una ruta para llegar al destino.\n self.ir_a(personaje, personaje.destino, personaje.direccion_final)\n \n personaje.update() # Actualizamos el personaje.\n \n for objeto in self._objetos: # Actualizamos los objetos.\n objeto.update()\n \n self._dibujar(\n )", "def person_fields(self):\r\n return persons.PersonFields(self)", "def get_people(self):\n return self._people", "def replace_person(self,p):\n p.age = 15\n p.days = 0\n \n self.age_group[4].remove(p.identifier)\n self.age_group[0].add(p.identifier)\n \n if np.random.random() < self.sexual_activity_high:\n p.sexual_activity = 1\n self.high_sexual_activity.add(p.identifier)\n else:\n p.sexual_activity = 0\n \n p.cure(self)\n \n #remove all partnerships where p is involved in\n for i,ps in enumerate(self.partnerships):\n if p.identifier in [ps.persons[0].identifier,ps.persons[1].identifier]:\n ps.remove(self)\n self.partnerships[i] = None\n #if deleting steady partnership\n if ps.type == 1:\n self.number_of_steady -= 1\n self.partnerships = list(filter(None,self.partnerships))", "def __init__(self, nom, prenom):\n \n self.nom = nom\n self.prenom = prenom\n self.age = 33\n self._lieu_residence = \"Paris\" # Notez le souligné _ devant le nom", "def __len__(self):\n return len(self.people)", "def __str__(self):\n return \"person:\"+str(self.name)+\":\"+str(self.age)", "def get_people(team):", "def all_persons(self):\n all_persons = {}\n all_persons.update(self.staff)\n all_persons.update(self.fellows)\n return all_persons", "def __init__(self, nom, prenom):\r\n self.nom = nom\r\n self.prenom = prenom\r\n self.age = 33", "def __init__(self, firstname, lastname):\r\n\t\tsuper().__init__(firstname, lastname)\r\n\t\tself.privelages= Privelages()" ]

[ "0.591366", "0.56589794", "0.5635063", "0.5557006", "0.554344", "0.5504283", "0.5426705", "0.53781843", "0.53479624", "0.5333507", "0.5312377", "0.53016996", "0.53004044", "0.5246279", "0.5229622", "0.52253735", "0.5167496", "0.5154765", "0.51299393", "0.5124255", "0.5115383", "0.51074564", "0.5102158", "0.50915134", "0.50890005", "0.5084402", "0.5073598", "0.5068625", "0.50567824", "0.50355345" ]

[ "def win(self, player):\n if player == 1:\n a = self.player_one.moves\n else:\n a = self.player_two.moves\n winning_moves = []\n for i in range(1, 9, 3):\n winning_moves.append(range(i, i + 3))\n for i in range(1, 4):\n winning_moves.append(range(i, i + 7, 3))\n winning_moves.append([1, 5, 9])\n winning_moves.append([3, 5, 7])\n for move in winning_moves:\n flg = True\n for index in move:\n if index not in a:\n flg = False\n break\n if flg:\n return True, player\n if len(self.player_one.moves) + len(self.player_two.moves) == 9:\n self.print_space()\n self.display_board()\n self.print_space()\n print \" Games is drawn\"\n self.logging.debug(\"Game is draw, nobody won\")\n self.logging.debug(\"Enjoy the game again :)\")\n sys.exit(100)\n return False, player", "def winning_event(self, player):\n # vertical check\n for col in range(GameData.columns):\n if self.board[0][col] == player and self.board[1][col] == player and self.board[2][col] == player:\n self.draw_vertical_winning_line(col, player)\n print(\"Player {} has won the game!\".format(player))\n self.game_over = True\n return True\n\n # horizontal check\n for row in range(GameData.rows):\n if self.board[row][0] == player and self.board[row][1] == player and self.board[row][2] == player:\n self.draw_horizontal_winning_line(row, player)\n print(\"Player {} has won the game!\".format(player))\n self.game_over = True\n return True\n\n # ascending diagonal heck\n if self.board[2][0] == player and self.board[1][1] == player and self.board[0][2] == player:\n self.draw_asc_diagonal(player)\n print(\"Player {} has won the game!\".format(player))\n self.game_over = True\n return True\n\n # descending diagonal win chek\n if self.board[0][0] == player and self.board[1][1] == player and self.board[2][2] == player:\n self.draw_desc_diagonal(player)\n print(\"Player {} has won the game!\".format(player))\n self.game_over = True\n return True\n\n return False", "def handle_win(context: GameContext, event: pygame.event.Event) -> None:\n if event.type == WIN:\n win_text = WINNER_FONT.render(f\"{event.winner.name} wins\", True, WHITE)\n context.game_window.blit(\n win_text,\n (context.game_window.get_width() // 2 - win_text.get_width() // 2,\n context.game_window.get_height() // 2 - win_text.get_height() // 2))\n pygame.display.update()\n pygame.time.delay(WIN_TEXT_DELAY) # Wait a bit in the winner screen\n restart_game(context)", "def handleDraw(self):\n print(\"Its a draaaw\")\n self.board.drawDrawBoard()\n\n self.ui.game = None\n if self.istournament:\n if self.tournamentgame.gamecount < 2:\n self.tournamentgame.gamecount = self.tournamentgame.gamecount+1\n self.board.displayTournamentDrawInfo(3-self.tournamentgame.gamecount)\n time.sleep(3)\n self.board = None\n self.ui.displayTournamentGame(True)\n else:\n winner = math.floor(random.random()*2+1)\n self.board.displayRandomizingWinner()\n time.sleep(2)\n if self.tournamentgame.winner == 1:\n self.board.drawWinBoard(1)\n if self.tournamentgame.winner == 2:\n self.board.drawWinBoard(-1)\n self.board = None\n self.ui.tournament.setWinner(winner)\n self.ui.displayCurrentTournament()", "def win_game(self):\n\n def horizontal_win():\n \"\"\"Return whether there is horizontal win\"\"\"\n\n for i in range(0, board_size):\n if set(self.board[i]) == set([o_symbol]) or set(self.board[i]) == set([x_symbol]):\n print \"horizontal win\"\n return True\n\n def vertical_win():\n \"\"\"Return whether there is vertical win\"\"\"\n\n vert_set = set()\n for i in range(0, board_size):\n for j in range(0, board_size):\n vert_set.add(self.board[j][i])\n if vert_set == set([o_symbol]) or vert_set == set([x_symbol]):\n print \"vertical win\"\n return True \n vert_set = set()\n\n def diagonal_win():\n \"\"\"Return whether there is diagonal win\"\"\"\n\n diagonal_set = set()\n for i in range(0, board_size):\n diagonal_set.add(self.board[i][i]) \n\n if diagonal_set == set([o_symbol]) or diagonal_set == set([x_symbol]):\n print \"diagonal win 1\"\n return True\n \n diagonal_set = set()\n for i in range(0, board_size):\n diagonal_set.add(self.board[i][board_size - 1 - i])\n\n if diagonal_set == set([o_symbol]) or diagonal_set == set([x_symbol]):\n print \"diagonal win 2\"\n return True\n\n if horizontal_win() or vertical_win() or diagonal_win():\n print \"You have won.\"\n return True", "def winFor(self,player):\n if(self.cachedWin == False):\n won = False;\n if(player==WHITE):\n for x in range(0,WIDTH):\n if(self.gameState[x,0]==WHITE):\n won = True\n \n elif(player==BLACK):\n for x in range(0,WIDTH):\n if(self.gameState[x,HEIGHT-1]==BLACK):\n won = True\n \n if(len(self.successors()) == 0):#IF there are no available moves for both players\n bCount = self.count(BLACK) #check who has the most pawns\n wCount = self.count(BLACK)\n if(bCount>wCount):\n self.cachedWin = True\n self.cachedWinner = player\n return True\n if(wCount>bCount):\n self.cachedWin = True\n self.cachedWinner = player\n return True\n \n if(won):\n self.cachedWin = True\n self.cachedWinner = player\n return True\n else:\n return False\n else:\n return player == self.cachedWinner", "def win_game(self):\r\n self.board.clear_hovered_tiles_list()\r\n self.is_game_over = True\r\n self.reset_button.won_game()\r\n self.high_score.update(self.timer.seconds)", "def __check_winner(self):\n for i in range(0, 3):\n col = self.__get_col(i)\n if col.get(self.player_char) == 3:\n print('\\nYou win!')\n self.game_ended = True\n return\n if col.get(self.opponent_char) == 3:\n print('\\nYou lose.')\n self.game_ended = True\n return\n row = self.__get_row(i)\n if row.get(self.player_char) == 3:\n print('\\nYou win!')\n self.game_ended = True\n return\n if row.get(self.opponent_char) == 3:\n print('\\nYou lose.')\n self.game_ended = True\n return\n for i in range(0, 2):\n diag = self.__get_diag(i)\n if diag.get(self.player_char) == 3:\n print('\\nYou win!')\n self.game_ended = True\n return\n if diag.get(self.opponent_char) == 3:\n print('\\nYou lose.')\n self.game_ended = True\n return\n if self.state.count(' ') == 0:\n print('\\nDraw!')\n self.game_ended = True", "def check_win(self):\r\n wins = [self.check_rows(), self.check_cols(), self.check_diag()]\r\n for case, pos in wins:\r\n if case != -1:\r\n print('Game over!')\r\n if self.grid[case][-1] == self.computer:\r\n print('The computer won!')\r\n return (True, pos)\r\n print('The player won!')\r\n return (True, pos)\r\n\r\n return (self.check_draw(), None)", "def player_win(self):\r\n\r\n self.summary = (\" \" * 83) + \"YOU WIN\"\r\n print(\"Player wins against opponent.\\n\")\r\n self.player_wins += 1", "def on_win(data):\n print(str(data))\n update_score_db(data['winner'], data['loser'])\n users, scores = calculate_scores()\n socketio.emit('leaderboard_info', {'users': users, 'scores': scores})", "def event_player_wins(self) -> None:\n win_amount = self.user.bet\n print(\"Congratulations, you win:\", win_amount)\n self.user.win_balance(self.user.bet)", "def checkForWin(self, board, player):\n\t\tif ((board[0][0] == player and board[0][1] == player and board[0][2] == player) or\n\t\t\t(board[1][0] == player and board[1][1] == player and board[1][2] == player) or\n\t\t\t(board[2][0] == player and board[2][1] == player and board[2][2] == player) or\n\t\t\t(board[0][0] == player and board[1][1] == player and board[2][2] == player) or\n\t\t\t(board[0][2] == player and board[1][1] == player and board[2][0] == player) or\n\t\t\t(board[0][0] == player and board[1][0] == player and board[2][0] == player) or\n\t\t\t(board[0][1] == player and board[1][1] == player and board[2][1] == player) or\n\t\t\t(board[0][2] == player and board[1][2] == player and board[2][2] == player)):\n\t\t\tprint(\"----------------------------\")\n\t\t\tprint(\"Yay! Player%d is the winner!\" % player)\n\t\t\tprint(\"----------------------------\")\n\t\t\tself.win = player", "def checkForWin(self):\n w = self.getWinner()\n if w == PLAYER or w == AI:\n # self.printBoard()\n # print('%d'%w + ' won!')\n return\n if w == Tie:\n # print('Tie')\n return", "def play_game():\n display_board()\n while ongoing_game:\n handle_turn(current_player)\n check_if_game_over()\n swap_player()\n global board\n if winner == \"X\" or winner == \"O\":\n print(\"<-------- Congratulations \" +\n winner + \", you win. -------->\")\n play_again()", "def endOfTurn(self, tracker):\n\n # Get status on whether all ships have been sunk\n win = self.checkForWin(tracker)\n\n if not win:\n if self.frame1.state() == 'normal':\n battleships = game1\n else:\n battleships = game2\n self.frame1.after(500)\n self.switchTurn()\n else:\n\n # Calculate scores\n if self.winCondition:\n text = 'hits per move'\n for i in range(2):\n if len(self.moves[i]) == 1:\n continue\n total = self.moves[i][0]\n for n in self.moves[i][1:]:\n total += n\n avg = float(len(self.moves[i]) - 1) / total\n self.score[i] = float('%.2f' % avg)\n else:\n text = 'points'\n\n # Player with the highest score is the winner\n index = self.score.index(max(self.score))\n winner = self.usernames[index]\n margin = max(self.score) - min(self.score)\n\n # Prepare scorecard\n mssg0 = \"Congratulations, %s wins!\" % self.usernames[index]\n mssg1 = \"Scorecard:\\n\\n%s's score: %s %s\\n\" \\\n \"%s's score: %s %s\\n\\n\" % (self.usernames[0], self.score[0],\\\n text, self.usernames[1], self.score[1], text)\n mssg2 = \"%s wins by a margin of %s %s\" % (winner, margin, text)\n\n if self.score[0] == self.score[1]:\n mssg0 = \"It's a draw!\"\n mssg2 = \"\"\n\n # Reveal ship positions for both players\n game1.canvas.tag_raise('ship', 'square')\n game2.canvas.tag_raise('ship', 'square')\n game1.canvas.tag_raise('text')\n game2.canvas.tag_raise('text')\n\n # Display scorecard\n showDialogBox(mssg0)\n self.frame1.deiconify()\n self.frame2.deiconify()\n showDialogBox(mssg1 + mssg2)\n showDialogBox(\"End of game!\\n\\n\" \\\n \"Here are the board setups for both players\")", "def board_status(board):\n if terminal(board):\n victor = winner(board)\n if victor is not None:\n emit(\"game_over\", \"winner: \" + victor)\n else:\n emit(\"game_over\", \"Draw\")", "def record_winner(cls):\n # Determine number of contiguous positions needed to win\n win_length = 3 if cls.size == 3 else 4\n\n # Store all sets of coordinates for contiguous positions\n sets = []\n\n # Loop through all 3x3 squares on the board\n for x in range(0, cls.size-(win_length-1)):\n for y in range(0, cls.size-(win_length-1)):\n # Add sets for rows\n for row in range(x, x+win_length):\n set = []\n for col in range(y, y+win_length):\n set.append([row, col])\n sets.append(set)\n # Add sets for columns\n for col in range(y, y+win_length):\n set = []\n for row in range(x, x+win_length):\n set.append([row, col])\n sets.append(set)\n # Add sets for diagonals\n if cls.size == 3:\n sets.append([[x,y],[x+1,y+1],[x+2,y+2]])\n sets.append([[x,y+2],[x+1,y+1],[x+2,y]])\n else:\n sets.append([[x,y],[x+1,y+1],[x+2,y+2],[x+3,y+3]])\n sets.append([[x,y+3],[x+1,y+2],[x+2,y+1],[x+3,y]])\n\n # Check all sets for winner\n for set in sets:\n d = {}\n for coords in set:\n token = cls.board[coords[0]][coords[1]]\n d[token] = token != cls.empty\n # If the dictionary only has one key and it's not empty, then we have a winner\n tokens = list(d.keys())\n if len(tokens) == 1 and d[tokens[0]]:\n cls.winner = tokens[0]", "def winner(board):\n # finite list of possible wins\n winnings = [\n (0, 0), (0, 1), (0, 2), \n (1, 0), (1, 1), (1, 2),\n (2, 0), (2, 1), (2, 2),\n (0, 0), (1, 0), (2, 0),\n (0, 1), (1, 1), (2, 1),\n (0, 2), (1, 2), (2, 2),\n (0, 0), (1, 1), (2, 2),\n (2, 0), (1, 1), (0, 2)\n ]\n # if the board has one of the lists in winnings \n # then the piece in one of those spots is the winner\n xcount = 0\n ocount = 0\n for i in range(len(winnings)):\n if(board[winnings[i][0]][winnings[i][1]] == X):\n xcount += 1\n if(board[winnings[i][0]][winnings[i][1]] == O):\n ocount += 1\n if((i + 1) % 3 == 0):\n if(ocount == 3 or xcount == 3):\n return board[winnings[i][0]][winnings[i][1]]\n else:\n ocount = 0\n xcount = 0\n return EMPTY", "def drawWinner(result):\n\t# determines who is the winner from the result\n\tif result == 1:\n\t\ttext = \"Black player is the winner !\"\n\telif result == 2:\n\t\ttext = \"White player is the winner !\"\n\telse:\n\t\ttext = \"Tie Game !\"\n\t\t\n\t#draws the text as in a surface\n\twinner_surf = BASICFONT.render(text, True, BLACK)\n\twinner_rect = winner_surf.get_rect()\n\twinner_rect.topleft = ((WINDOWWIDTH - winner_rect.width)/2, 20)\n\tDISPLAYSURF.blit(winner_surf, winner_rect)", "def end_game(self, won=False):\n\n self.game_over = True\n if not won:\n self.message = \"Game Over\"\n else:\n self.message = \"Winner\"\n game_win = Win(\n user=self.user,\n date=datetime.utcnow(),\n won=True,\n attempts_used=self.attempts_used,\n score=self.score\n )\n game_win.put()\n self.put()\n # Add the game to the score 'board'", "def winner():\n winning_lbl_zero.grid(row=0, column=LEFT_COL, rowspan=80, columnspan=2, sticky=N) # Placing the winning image\n messagebox.showinfo(title=\"**** WINNER! ****\", message=\"CONGRATS!!\\n\"\n \"You figured out the word/phrase\\n\"\n \"before it was too late, clearly your\\n\"\n \"guessing skills are unfathomable\")\n\n play_again() # Finds out if they'd like to play again", "def show_board(player_name='player',win=False):\r\n print('\\n'*10)\r\n triple_hash();\r\n print(f' {loc[0]} # {loc[1]} # {loc[2]}')\r\n triple_hash()\r\n print(' #################################################################')\r\n triple_hash()\r\n print(f' {loc[3]} # {loc[4]} # {loc[5]}')\r\n triple_hash()\r\n print(' #################################################################')\r\n triple_hash()\r\n print(f' {loc[6]} # {loc[7]} # {loc[8]}')\r\n triple_hash()\r\n\r\n if win:\r\n print(f'\\n\\ncongratulations, {player_name}, you have won!')", "def winner(self, black, white):\n fill(255)\n rect(150, 150, 150, 80, 7)\n fill(0)\n textSize(20)\n if self.tie:\n text(\"It's Tie\", 160, 180)\n elif self.black_wins:\n text(\"Black WINS\", 160, 180)\n elif self.white_wins:\n text(\"White WINS\", 160, 180)\n result = \"black: \" + str(black)\n text(result, 160, 200)\n result = \"white: \" + str(white)\n text(result, 160, 220)", "def check_win(self):\n lines = []\n\n # rows\n lines.extend(self._board)\n\n # cols\n cols = [[self._board[rowidx][colidx] for rowidx in range(self._dim)]\n for colidx in range(self._dim)]\n lines.extend(cols)\n\n # diags\n diag1 = [self._board[idx][idx] for idx in range(self._dim)]\n diag2 = [self._board[idx][self._dim - idx -1]\n for idx in range(self._dim)]\n lines.append(diag1)\n lines.append(diag2)\n\n # check all lines\n for line in lines:\n if len(set(line)) == 1 and line[0] != EMPTY:\n if self._reverse:\n return switch_player(line[0])\n else:\n return line[0]\n\n # no winner, check for draw\n if len(self.get_empty_squares()) == 0:\n return DRAW\n\n # game is still in progress\n return None", "def winner(board):\n \n possible_wins = []\n row1 = board[0]\n row2 = board[1]\n row3 = board[2]\n col1 = [board[0][0],board[1][0],board[2][0]]\n col2 = [board[0][1],board[1][1],board[2][1]]\n col3 = [board[0][2],board[1][2],board[2][2]]\n diag1 = [board[0][0],board[1][1],board[2][2]]\n diag2 = [board[2][0],board[1][1],board[0][2]]\n \n possible_wins.append(row1)\n possible_wins.append(row2)\n possible_wins.append(row3)\n possible_wins.append(col1)\n possible_wins.append(col2)\n possible_wins.append(col3)\n possible_wins.append(diag1)\n possible_wins.append(diag2)\n \n for trait in possible_wins:\n if trait.count(\"X\") == 3:\n return \"X\"\n elif trait.count(\"O\") == 3:\n return \"O\"\n \n return None", "def game_initiate(self, win):\n font = pygame.font.SysFont('comicsans', 70)\n\n pygame.draw.rect(win, white, (0, screen_height // 4, screen_width, screen_height // 2))\n text = font.render('ROCK!', 1, black)\n win.blit(text, (180, 300))\n self.display_player('rock', win)\n self.display_computer('rock', win)\n pygame.display.update()\n pygame.time.delay(500)\n\n pygame.draw.rect(win, white, (0, screen_height // 4, screen_width, screen_height // 2))\n text = font.render('PAPER!', 1, black)\n win.blit(text, (170, 300))\n self.display_player('paper', win)\n self.display_computer('paper', win)\n pygame.display.update()\n pygame.time.delay(500)\n\n pygame.draw.rect(win, white, (0, screen_height // 4, screen_width, screen_height // 2))\n text = font.render('SCISSOR!', 1, black)\n win.blit(text, (140, 300))\n self.display_player('scissor', win)\n self.display_computer('scissor', win)\n pygame.display.update()\n pygame.time.delay(500)\n\n pygame.draw.rect(win, white, (0, screen_height // 4, screen_width, screen_height // 2))\n text = font.render('SHOOT!', 1, black)\n win.blit(text, (165, 300))", "def game_over(self, win=False):\n self.is_game_over = True\n\n if win:\n self.flags_pts.set_data(*np.where(self.mines)[::-1]) # shows mines marked with flags\n self.title_txt.set_text('You win! Press F2 to start a new game')\n else:\n self.wrong_img.set_data(self.wrong) # wrong guesses\n self.mines_pts = self.ax.plot(self.jj[self.mines & ~self.flags],\n self.ii[self.mines & ~self.flags],\n 'kX', ms=10) # shows mines\n self.title_txt.set_text('You lose! Press F2 to start a new game')\n\n self.refresh_canvas()", "def winner(self):\n\n\t\tfor player in [1,2]:\n\t\t\twon = np.full((self.boardSize), player)\n\n\t\t\t# Check diagonals\n\t\t\tif(np.array_equal(np.diag(self.board), won)): return player\n\t\t\tif(np.array_equal(np.diag(np.fliplr(self.board)), won)): return player\n\n\t\t\t# Check lines and columns\n\t\t\tfor i in range(self.boardSize):\n\t\t\t\tif(np.array_equal(self.board[i], won)): return player\n\t\t\t\tif(np.array_equal(self.board[:,i], won)): return player\n\n\t\t# Draw\n\t\tif(not(0 in self.board)): return 3\n\n\t\t# No win or draw\n\t\treturn 0", "def check_win(self, player):\n def check_row_win(player):\n for row in self.game_state:\n if player == row[0] == row[1] == row[2]:\n return True\n return False\n\n def check_column_win(player):\n # For doing a column check, transpose the grid and do a row check\n trans_game_state = numpy.transpose(self.game_state)\n for row in trans_game_state:\n if player == row[0] == row[1] == row[2]:\n return True\n return False\n\n def check_diag_win(player):\n # Left to right diagonal\n if player == self.game_state[0][0] == self.game_state[1][1] == self.game_state[2][2]:\n return True\n # Right to left diagonal\n if player == self.game_state[0][2] == self.game_state[1][1] == self.game_state[2][0]:\n return True\n return False\n\n if check_column_win(player) or check_diag_win(player) or check_row_win(player):\n return True\n return False" ]

[ "0.7354114", "0.73210603", "0.72094834", "0.7175612", "0.7138135", "0.7133121", "0.71170354", "0.7065439", "0.7011677", "0.6992712", "0.6905542", "0.69014484", "0.68530196", "0.6849343", "0.6781418", "0.67568487", "0.6755098", "0.67207557", "0.6717351", "0.6711404", "0.6691753", "0.6674954", "0.66164684", "0.6580483", "0.65758103", "0.65623164", "0.65449154", "0.6528195", "0.650917", "0.6494957" ]

[ "def __check_winner(self):\n for i in range(0, 3):\n col = self.__get_col(i)\n if col.get(self.player_char) == 3:\n print('\\nYou win!')\n self.game_ended = True\n return\n if col.get(self.opponent_char) == 3:\n print('\\nYou lose.')\n self.game_ended = True\n return\n row = self.__get_row(i)\n if row.get(self.player_char) == 3:\n print('\\nYou win!')\n self.game_ended = True\n return\n if row.get(self.opponent_char) == 3:\n print('\\nYou lose.')\n self.game_ended = True\n return\n for i in range(0, 2):\n diag = self.__get_diag(i)\n if diag.get(self.player_char) == 3:\n print('\\nYou win!')\n self.game_ended = True\n return\n if diag.get(self.opponent_char) == 3:\n print('\\nYou lose.')\n self.game_ended = True\n return\n if self.state.count(' ') == 0:\n print('\\nDraw!')\n self.game_ended = True", "def drawsheet_complete_draw(draw, wins, scores):\n current_results = []\n next_results = []\n\n logging.debug(\"################ PROCESSING DRAW ###############\")\n\n while len(wins) > 0 and len(draw[-1]) != 1:\n \n if len(draw[-1]) < 2:\n break\n\n logging.debug(\"ROUND OF {}\".format(len(draw[-1])))\n rnd = []\n match = 0\n while len(rnd) < (len(draw[-1]) / 2) and len(wins) > 0:\n prev_a = draw[-1][match * 2]\n prev_b = draw[-1][match * 2 + 1]\n\n logging.debug(\"\\tMatchup: {} v. {}\".format(prev_a[0], prev_b[0]))\n\n candidates = []\n for p in (prev_a[0], prev_b[0]):\n if p in wins:\n candidates = wins[p]\n\n if len(candidates) == 0:\n # There's something wrong, discard somebody and try again\n del draw[-1][match * 2]\n print(\"ERROR: Can't find winner for {} \"\n \"v. {} in round of {}\".\n format(prev_a[0], prev_b[0], len(draw[-1])))\n continue\n\n ax, ay = prev_a[1]\n bx, by = prev_b[1]\n avg_x = (ax + bx) / 2\n\n candidates.sort(key=lambda e: abs(avg_x - e[1][0]))\n candidates.sort(key=lambda e: e[1][1] >= ay and e[1][1] <= by,\n reverse=True)\n\n winner = candidates[0]\n del candidates[0]\n for p in (prev_a[0], prev_b[0]):\n if p in wins:\n c = wins[p]\n if len(c) == 0:\n del wins[p]\n\n\n if prev_a[0].upper() == \"BYE\" or prev_b[0].upper() == \"BYE\":\n score = 'bye'\n else:\n score = drawsheet_get_score(winner, scores)\n\n logging.debug(\"\\t\\tWINNER {} ({})\".format(winner[0], score))\n\n if winner[0] == prev_a[0]:\n loser = prev_b[0]\n else:\n loser = prev_a[0]\n\n rnd += [(winner[0], winner[1], score, loser)]\n match += 1\n\n draw += [rnd]", "def handleWin(self, winningplayer):\n self.board.drawWinBoard(winningplayer, self.istournament)\n self.board = None\n self.ui.game = None\n if self.istournament:\n if winningplayer == 1:\n self.ui.tournament.setWinner(1)\n if winningplayer == -1:\n self.ui.tournament.setWinner(2)\n\n threading.Timer(3, self.ui.displayCurrentTournament).start()", "def draw(canvas): \n \n canvas.draw_text(outcome, \n (CANVAS_WIDTH // 2, CANVAS_HEIGHT // 5), \n FONT_SIZE, OUTCOME_FONT_COLOR, FONT_FACE)\n\n canvas.draw_text(outcome_plus,\n (CANVAS_WIDTH // 2, CANVAS_HEIGHT // 4),\n FONT_SIZE, OUTCOME_FONT_COLOR, FONT_FACE)\n\n canvas.draw_text(outcome_plus_plus,\n (CANVAS_WIDTH // 2, (CANVAS_HEIGHT // 4) + Y_MARGIN_PLUS),\n FONT_SIZE, OUTCOME_FONT_COLOR, FONT_FACE)\n \n canvas.draw_text(GAME_TITLE, \n (CANVAS_WIDTH // 10, CANVAS_HEIGHT // 10), \n TITLE_FONT_SIZE, TITLE_FONT_COLOR, FONT_FACE)\n\n canvas.draw_text(\"Score: \" + str(score), \n (CANVAS_WIDTH // 10 , CANVAS_HEIGHT // 5), \n FONT_SIZE, FONT_COLOR, FONT_FACE)\n \n canvas.draw_text(\"Dealer\", \n (CANVAS_WIDTH // 10 , CANVAS_HEIGHT // 3), \n FONT_SIZE, FONT_COLOR, FONT_FACE)\n\n dealer.draw(canvas, [CANVAS_WIDTH // 10, CANVAS_HEIGHT // 3 + Y_MARGIN]) \n \n canvas.draw_text(\"Player\", \n (CANVAS_WIDTH // 10 , CANVAS_HEIGHT // 3 + 3 * Y_MARGIN + CARD_SIZE[1]), \n FONT_SIZE, FONT_COLOR, FONT_FACE)\n \n player.draw(canvas, [CANVAS_WIDTH // 10, CANVAS_HEIGHT // 3 + 4 * Y_MARGIN + CARD_SIZE[1]]) \n\n canvas.draw_text(action, \n (CANVAS_WIDTH // 2, CANVAS_HEIGHT // 3 + 3 * Y_MARGIN + CARD_SIZE[1]), \n FONT_SIZE, TITLE_FONT_COLOR, FONT_FACE)\n \n # If the round is still in play, an image of the back \n # of a \"Card\" should be drawn over the dealer's first\n # (hole) \"Card\" to hide it. Once the round is over, \n # the dealer's hole \"Card\" should be displayed. \n if in_play:\n card_loc = (CARD_CENTER[0], CARD_CENTER[1])\n canvas.draw_image(card_back, card_loc, \n CARD_SIZE, \n [CANVAS_WIDTH // 10 + CARD_CENTER[0], \n CANVAS_HEIGHT // 3 + Y_MARGIN + CARD_CENTER[1]], \n CARD_SIZE) \n \n return None", "def play(self):\r\n self.num_players = int(input(\"Welcome to card drawing game, Please enter number of players:\"))\r\n #contains all the draws from different players as list of draws per player.\r\n #with player number as key\r\n print(f\"Num players:{self.num_players}\")\r\n \r\n #initialize player points and draws\r\n self._initialize_player_stats()\r\n \r\n for y in range(DrawCardsGame.num_turns):\r\n for x in range(self.num_players):\r\n input(f\"Press enter for turn no {y+1} to draw for player {x+1}:\")\r\n card_drawn = self.cards.get_top_card()\r\n self.player_draws[f'{x}'].append(card_drawn)\r\n print(f\"card_drawn {card_drawn}\")\r\n self.player_points[f'{x}']+= DrawCardsGame.shades_points_dict[card_drawn[0]] * card_drawn[1]\r\n print(f\"player_points {self.player_points}\")\r\n \r\n print(repr(self.player_draws)) \r\n print(repr(self.player_points)) \r\n self.determine_winner(self.player_draws['0'],self.player_draws['1'])\r\n self.determine_winner1()", "def game_draw(self):\n pass", "def draw_board(board_list):\n\n # clears out the canvas to make an empty board\n canvas.delete(\"all\")\n\n # Horizontal Lines\n canvas.create_rectangle(600, 170, 0, 160, fill=\"black\")\n canvas.create_rectangle(600, 330, 0, 320, fill=\"black\")\n\n # Vertical Lines\n canvas.create_rectangle(210, 480, 200, 0, fill=\"black\")\n canvas.create_rectangle(410, 480, 400, 0, fill=\"black\")\n\n # iterate through the board and draw each of the positions\n for row in range(len(board_list)):\n for column in range(len(board_list[0])):\n\n if board_list[row][column] == \"x\":\n draw_x(row + 1, column + 1)\n elif board_list[row][column] == \"o\":\n draw_o(row + 1, column + 1)\n\n winner = check_win(board_list)\n\n # count how many empty spaces are left on the board\n empty_count = 0\n for i in range(len(board_list)):\n empty_count += board_list[i].count(0)\n\n # no spaces left and there is still no winner\n if (winner is None) and (empty_count == 0):\n winner = \"Draw\"\n winner_popup(winner)\n\n # There is a winner\n elif winner is not None:\n winner_popup(winner)", "def winning_event(self, player):\n # vertical check\n for col in range(GameData.columns):\n if self.board[0][col] == player and self.board[1][col] == player and self.board[2][col] == player:\n self.draw_vertical_winning_line(col, player)\n print(\"Player {} has won the game!\".format(player))\n self.game_over = True\n return True\n\n # horizontal check\n for row in range(GameData.rows):\n if self.board[row][0] == player and self.board[row][1] == player and self.board[row][2] == player:\n self.draw_horizontal_winning_line(row, player)\n print(\"Player {} has won the game!\".format(player))\n self.game_over = True\n return True\n\n # ascending diagonal heck\n if self.board[2][0] == player and self.board[1][1] == player and self.board[0][2] == player:\n self.draw_asc_diagonal(player)\n print(\"Player {} has won the game!\".format(player))\n self.game_over = True\n return True\n\n # descending diagonal win chek\n if self.board[0][0] == player and self.board[1][1] == player and self.board[2][2] == player:\n self.draw_desc_diagonal(player)\n print(\"Player {} has won the game!\".format(player))\n self.game_over = True\n return True\n\n return False", "def draw_game():\n # Fill window with background color\n RENDER_WINDOW.fill(BACKGROUNDCOLOR)\n\n # Draw Game Title\n draw_title()\n\n # Draw Puzzle\n draw_puzzle()\n \n # Draw buttons to GUI \n draw_buttons()\n\n # Draw Text\n draw_text() \n\n # Draw random toggle\n draw_rand_toggle()", "def check_draw(winner, board):\n if not winner and all(\"_\" not in row for row in board):\n print(\"Game Over, game is a tie\")\n return True", "def check_win(self):\n lines = []\n\n # rows\n lines.extend(self._board)\n\n # cols\n cols = [[self._board[rowidx][colidx] for rowidx in range(self._dim)]\n for colidx in range(self._dim)]\n lines.extend(cols)\n\n # diags\n diag1 = [self._board[idx][idx] for idx in range(self._dim)]\n diag2 = [self._board[idx][self._dim - idx -1]\n for idx in range(self._dim)]\n lines.append(diag1)\n lines.append(diag2)\n\n # check all lines\n for line in lines:\n if len(set(line)) == 1 and line[0] != EMPTY:\n if self._reverse:\n return switch_player(line[0])\n else:\n return line[0]\n\n # no winner, check for draw\n if len(self.get_empty_squares()) == 0:\n return DRAW\n\n # game is still in progress\n return None", "def draw_board(win, board):\n win.fill(WHITE)\n \n #Draw board\n for row in board:\n for col in row:\n #Current grid position\n coords = col['coord']\n\n #coords\n h_fence_coords = (coords[0]*(SQUARESIZE+FENCEWIDTH), coords[1]*SQUARESIZE+FENCEWIDTH*(coords[1]-1))\n v_fence_coords = (coords[0]*SQUARESIZE+FENCEWIDTH*(coords[0]-1), coords[1]*(SQUARESIZE+FENCEWIDTH))\n board_spotcoords = (coords[0]*(SQUARESIZE+FENCEWIDTH), coords[1]*(SQUARESIZE+FENCEWIDTH))\n \n #Rect objects\n h_fence = pygame.Rect(h_fence_coords, ((2*SQUARESIZE+FENCEWIDTH),FENCEWIDTH))\n v_fence = pygame.Rect(v_fence_coords, (FENCEWIDTH,2*SQUARESIZE+FENCEWIDTH))\n board_spot = pygame.Rect(board_spotcoords, (SQUARESIZE,SQUARESIZE))\n \n #Draw horizontal fence \n if coords[1] != 0 and coords[1] != 9 and coords[0] != 8:\n if col['h'] == 1:\n pygame.draw.rect(win, RED, h_fence)\n elif col['h'] == 2:\n pygame.draw.rect(win, BLUE, h_fence)\n\n #Draw vertical fence\n if coords[0] != 0 and coords[0] != 9 and coords[1] != 9:\n if col['v'] == 1:\n pygame.draw.rect(win, RED, v_fence)\n elif col['v'] == 2:\n pygame.draw.rect(win, BLUE, v_fence)\n \n #Draw grid square\n if coords[1] != 9 and coords[0] != 9:\n if coords[1] == 0:\n pygame.draw.rect(win, LIGHTRED, board_spot)\n elif coords[1] == 8:\n pygame.draw.rect(win, LIGHTBLUE, board_spot)\n else:\n pygame.draw.rect(win, GRAY, board_spot)", "def testDraw():\n deleteMatches()\n deletePlayers()\n registerPlayer(\"Pikachu\")\n registerPlayer(\"Charmander\")\n registerPlayer(\"Bulbasaur\")\n registerPlayer(\"Squirtle\")\n standings = playerStandings()\n [id1, id2, id3, id4] = [row[0] for row in standings]\n reportMatch(id1, id2, True)\n reportMatch(id3, id4, True)\n standings = playerStandings()\n if not (standings[0][2]==standings[1][2]==standings[2][2]==standings[3][2]):\n raise ValueError(\n \"Players should have the same number of points after drawing\"\n )\n\n print \"3. Draw is recorded properly.\"", "def draw(canvas):\n if len(cardSelected) == 16:\n label.set_text(\"You Win! Turns taken = \" + str(turns))\n else:\n label.set_text(\"Turns = \" + str(turns))\n Player.draw(canvas, [10, 10])", "def main():\n\tglobal FPSCLOCK, DISPLAYSURF, BASICFONT\n\tpygame.init()\n\tFPSCLOCK = pygame.time.Clock()\n\t# set up the window\n\tBASICFONT = pygame.font.Font('freesansbold.ttf', 20)\n\tDISPLAYSURF = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT), 0, 32)\n\tpygame.display.set_caption('Othello')\n\tDISPLAYSURF.fill(BGCOLOR)\n\t#Initialization of the variable\n\t###############################\n\ttestg = 0 #variable to contain result of testwinner\n\tboard = init_board() #variable to contain the board\n\tturn = 1 # whose turn is it {1: black, 2: white}\n\tdrawBoard()\n\twhile True:\n\t\tclicked_box = () #init\n\t\tlegals = possible(board,turn)\n\t\tfor e in pygame.event.get():\n\t\t\tif e.type == QUIT: #handling quitting\n\t\t\t\tpygame.quit()\n\t\t\t\tsys.exit()\n\t\t\telif e.type == MOUSEBUTTONUP: #handling click\n\t\t\t\tmousex,mousey = e.pos #record a click and its position\n\t\t\t\tclicked_box = isInBoard(mousex,mousey)\n\t\tif clicked_box != () and clicked_box in legals:\n\t\t\t#if it the clicked box is a legal move, make the move\n\t\t\tplayer_move = Move(clicked_box,turn, board)\n\t\t\tplayer_move.make(board)\n\t\t\twinner = test_winner(board)\n\t\t\tif winner: #if true : game is not done\n\t\t\t\t#tests the winner if the game is done\n\t\t\t\tif winner == 1:\n\t\t\t\t\tprint \"Black player winns\"\n\t\t\t\telif winner == 2:\n\t\t\t\t\tprint \"White player wins.\"\n\t\t\t\telif winner == 3:\n\t\t\t\t\tprint \"This is a tie game !\"\n\t\t\t\telse:\n\t\t\t\t\tturn = 2/(winner-3) # if res= 4 it is black's turn if it is 5 it is white's turn'\n\t\t\tturn = 2/turn\n\t\tpygame.display.update()\n\t\tFPSCLOCK.tick(FPS)", "def human():\n table = [ \n \"-\", \"-\", \"-\", \n \"-\", \"-\", \"-\", \n \"-\", \"-\", \"-\", \n ]\n choices = choice()\n turn = [0,1,2,3,4,5,6,7,8]\n\n # while table still have available space, run until all boxes are filled\n while len(turn) != 0:\n \n # Player1's turn\n move_index, turn = table_check(table, turn) # Check if the index is valid\n table[move_index] = choices[0] # Fill X or O to the table base on the index chosen\n display_board(table) # Display to let them see for 2nd player's turn\n\n # The game cannot be won unless 5 moves has been played, so when turn has been reduced to 4 moves or less, check win\n # Check win before tie since last move might make it a win\n if len(turn) <= 4:\n win_condition, player = win_check(table)\n if win_condition == True:\n print(f\"\\nPlayer \\\"{player}\\\" won!!\\nThanks for playing!\")\n retry()\n\n # Player 1 will be the one who finish the game, so after filling every turn of player 1\n # we need to check if it's the last turn, if yes than break\n if len(turn) == 0:\n break\n \n # Player2's turn\n move_index, turn = table_check(table, turn) # Check if the index is valid\n table[move_index] = choices[1] # Fill X or O to the table base on the index chosen\n display_board(table) # Display to let them see for 2nd player's turn\n\n # The game cannot be won unless 5 moves has been played, so when turn has been reduced to 4 moves or less, check win\n if len(turn) <= 4:\n win_condition, player = win_check(table)\n if win_condition == True:\n print(f\"\\nPlayer \\\"{player}\\\" won!!\\nThanks for playing!\")\n retry()\n \n print(\"\\nDRAW!\")\n retry()", "def draw_game(self) -> None:\n\n self.screen.fill(THECOLORS['royalblue4'])\n self.our_board.draw(self.screen)\n self.game_status.draw(self.screen)\n self.heading_bar.draw(self.screen)\n\n if self.our_game_state == STATE_PREPARING:\n self.start_game_button.draw(self.screen)\n elif not self.our_game_state == STATE_READY_TO_START:\n self.their_board.draw(self.screen)", "def draw(self):\n i = 0\n self.window.fill((60,50,20))\n for i in range(len(self.board)):\n for j in range(len(self.board[i])):\n pygame.draw.rect(self.window, ((i+j)%2*255, (i+j)%2*255, (i+j)%2*255), (20+j*100, 20+i*100, 100, 100))\n if self.board[i][j] != 0:\n if self.board[i][j].player == 0:\n color = (200, 0, 0)\n else:\n color = (0, 0, 200)\n if self.board[i][j].direction == 0:\n pygame.draw.ellipse(self.window, color, (30+j*100, 40+i*100, 80, 60))\n elif self.board[i][j].direction == 1:\n pygame.draw.ellipse(self.window, color, (40+j*100, 30+i*100, 60, 80))\n if self.board[i][j].master:\n if self.board[i][j].direction == 0:\n pygame.draw.ellipse(self.window, (255,255,0), (40+j*100, 50+i*100, 60, 40))\n pygame.draw.ellipse(self.window, color, (45+j*100, 55+i*100, 50, 30))\n elif self.board[i][j].direction == 1:\n pygame.draw.ellipse(self.window, (255,255,0), (50+j*100, 40+i*100, 40, 60))\n pygame.draw.ellipse(self.window, color, (55+j*100, 45+i*100, 30, 50))\n \n if self.selected != None:\n pygame.draw.rect(self.window, (200, 200, 0), (20+self.selected[1]*100, 20+self.selected[0]*100, 100, 100), 5)\n pygame.display.flip()", "def bot():\n table = [ \n \"-\", \"-\", \"-\", \n \"-\", \"-\", \"-\", \n \"-\", \"-\", \"-\", \n ]\n choices = choice()\n turn = [0,1,2,3,4,5,6,7,8]\n \n while len(turn) != 0:\n \n # Player1 turn\n move_index, turn = table_check(table, turn) # Check if the index is valid\n table[move_index] = choices[0] # Fill X or O to the table base on the index chosen\n display_board(table) # Display to let them see for 2nd player's turn\n\n # The game cannot be won unless 5 moves has been played, so when turn has been reduced to 4 moves or less, check win\n # Check win before tie since last move might make it a win\n if len(turn) <= 4:\n win_condition, win = win_check(table)\n if win_condition == True:\n print(f\"\\nYou won!!!\\nThanks for playing!\")\n retry()\n\n # \"X\" will be the one who finish the game, so after filling the X into the table\n # We need to check if it's the last turn, if yes than break\n if len(turn) == 0:\n break\n \n # Bot's turn\n move_index = random.choice(turn) # Bot moves can just be chosen randomly from the\n turn.remove(move_index) # available moves from turn, so doesnt need to table_check()\n table[move_index] = choices[1] # Fill X or O to the table base on the index chosen\n print(\"Bot is thinking....\")\n time.sleep(random.randint(1,2)) # Make it realistic\n\n # The game cannot be won unless 5 moves has been played, so when turn has been reduced to 4 moves or less, check win\n if len(turn) <= 4:\n win_condition, win = win_check(table)\n if win_condition == True:\n display_board(table)\n print(f\"The bot won!!!\\nThanks for playing!\")\n retry()\n\n\n print(\"\\nDRAW!\")\n retry()", "def record_winner(cls):\n # Determine number of contiguous positions needed to win\n win_length = 3 if cls.size == 3 else 4\n\n # Store all sets of coordinates for contiguous positions\n sets = []\n\n # Loop through all 3x3 squares on the board\n for x in range(0, cls.size-(win_length-1)):\n for y in range(0, cls.size-(win_length-1)):\n # Add sets for rows\n for row in range(x, x+win_length):\n set = []\n for col in range(y, y+win_length):\n set.append([row, col])\n sets.append(set)\n # Add sets for columns\n for col in range(y, y+win_length):\n set = []\n for row in range(x, x+win_length):\n set.append([row, col])\n sets.append(set)\n # Add sets for diagonals\n if cls.size == 3:\n sets.append([[x,y],[x+1,y+1],[x+2,y+2]])\n sets.append([[x,y+2],[x+1,y+1],[x+2,y]])\n else:\n sets.append([[x,y],[x+1,y+1],[x+2,y+2],[x+3,y+3]])\n sets.append([[x,y+3],[x+1,y+2],[x+2,y+1],[x+3,y]])\n\n # Check all sets for winner\n for set in sets:\n d = {}\n for coords in set:\n token = cls.board[coords[0]][coords[1]]\n d[token] = token != cls.empty\n # If the dictionary only has one key and it's not empty, then we have a winner\n tokens = list(d.keys())\n if len(tokens) == 1 and d[tokens[0]]:\n cls.winner = tokens[0]", "def drawWinner(result):\n\t# determines who is the winner from the result\n\tif result == 1:\n\t\ttext = \"Black player is the winner !\"\n\telif result == 2:\n\t\ttext = \"White player is the winner !\"\n\telse:\n\t\ttext = \"Tie Game !\"\n\t\t\n\t#draws the text as in a surface\n\twinner_surf = BASICFONT.render(text, True, BLACK)\n\twinner_rect = winner_surf.get_rect()\n\twinner_rect.topleft = ((WINDOWWIDTH - winner_rect.width)/2, 20)\n\tDISPLAYSURF.blit(winner_surf, winner_rect)", "def checkWin(self):\n winstates = [(0, 1, 2),\n (3, 4, 5),\n (6, 7, 8),\n (0, 3, 6),\n (1, 4, 7),\n (2, 5, 8),\n (0, 4, 8),\n (2, 4, 6)]\n win = False\n for state in winstates:\n if (self.gameState[state[0]] + self.gameState[state[1]] + self.gameState[state[2]]) == 3:\n self.handleWin(1)\n win = True\n elif (self.gameState[state[0]] + self.gameState[state[1]] + self.gameState[state[2]]) == -3:\n self.handleWin(-1)\n win = True\n\n if len([i for i in range(9) if self.gameState[i] == 0]) == 0 and not win:\n print(\"Draw yo\")\n self.handleDraw()\n return None", "def draw(self, win):\n for y in range(len(self.board)):\n for x, color in enumerate(self.board[y]):\n pygame.draw.rect(win, color, (self.x+x*self.cell_size, self.y+y*self.cell_size,\n self.cell_size, self.cell_size), 0)\n\n pygame.draw.rect(win, (0, 0, 0), (self.x, self.y, self.width, self.height), BORDER_THICKNESS)", "def play(self, event):\n\n # locate second column and row when player click on a square\n colrow_tuple = self.board.find_coords_of_selected_sq(event)\n\n # save the col and row as variable\n corner_two_col, corner_two_row = colrow_tuple[0], colrow_tuple[1]\n\n # calculations to get the key to help locate specific square on\n # the unused dictionary of squares left to play\n col_fl, row_fl = self.board.floor_of_row_col(event.x, event.y)\n rowcol_key = self.board.convert_to_key(col_fl, row_fl)\n\n try:\n self.unused_squares_dict[rowcol_key]\n except KeyError:\n return\n\n if self.player1_turn == True:\n self.add_to_player_sq(rowcol_key, self.player1.selected_sq)\n\n # delete from game unused dictionary of set\n self.delete_used_sq(rowcol_key)\n\n self.board.color_selected_sq(event,\n corner_two_col,\n corner_two_row,\n self.player1.color)\n\n # check game for 3 conditions: a tie, player1 win, or player2 win\n self.check_for_winner(self.player1.selected_sq, self.player1.name)\n\n # switch turn\n self.player1_turn = False\n\n else: # player2's turn\n self.board.color_selected_sq(event,\n corner_two_col,\n corner_two_row,\n self.player2.color)\n\n self.add_to_player_sq(rowcol_key, self.player2.selected_sq)\n self.delete_used_sq(rowcol_key)\n self.check_for_winner(self.player2.selected_sq, self.player2.name)\n self.player1_turn = True", "async def evaluate(self):\n if self.players[1].id == bot.user.id:\n self.p2_move = random.choice((\"Rock\", \"Paper\", \"Scissors\"))\n\n if None in self.moves:\n return\n\n if len(self.moves) == 1:\n tie_embed = discord.Embed(title=\"It's a Draw\")\n await self.channel.send(embed=tie_embed)\n return await self.end()\n\n if self.moves == {\"Rock\", \"Paper\"}:\n winner = \"Paper\"\n elif self.moves == {\"Scissors\", \"Paper\"}:\n winner = \"Scissors\"\n elif self.moves == {\"Rock\", \"Scissors\"}:\n winner = \"Rock\"\n\n # P1 Wins\n if self.p1_move == winner:\n embed = discord.Embed(\n title=f\"{self.players[0].name}'s **{winner}** beats {self.players[1].name}'s **{self.p2_move}**\")\n await self.channel.send(embed=embed)\n await self.end(winner=self.players[0])\n\n # P2 Wins\n elif self.p2_move == winner:\n embed = discord.Embed(\n title=f\"{self.players[1].name}'s **{winner}** beats {self.players[0].name}'s **{self.p1_move}**\")\n await self.channel.send(embed=embed)\n await self.end(winner=self.players[1])", "def check_win(self):\r\n wins = [self.check_rows(), self.check_cols(), self.check_diag()]\r\n for case, pos in wins:\r\n if case != -1:\r\n print('Game over!')\r\n if self.grid[case][-1] == self.computer:\r\n print('The computer won!')\r\n return (True, pos)\r\n print('The player won!')\r\n return (True, pos)\r\n\r\n return (self.check_draw(), None)", "def draw_new_score(self):\n pygame.event.get() #clear event list? Otherwise it skips\n self.screen.fill((0, 0, 0))\n #sessionsurf = self.f24.render(\"Session %d, Game %d/%s\"%(self.session_number, self.game_number, self.config[\"games_per_session\"]), True, (255,255,255))\n # sessionrect = sessionsurf.get_rect()\n # sessionrect.centerx = self.SCREEN_WIDTH / 2\n # sessionrect.y = 100\n # self.screen.blit(sessionsurf, sessionrect)\n gamesurf = self.f36.render(\"Game %d\" % (self.current_game), True, (255, 255, 0))\n gamerect = gamesurf.get_rect()\n gamerect.centery = self.SCREEN_HEIGHT / 16 * 2\n gamerect.centerx = self.SCREEN_WIDTH / 2\n self.screen.blit(gamesurf, gamerect)\n pygame.draw.line(self.screen, (255, 255, 255), (self.SCREEN_WIDTH / 4 , self.SCREEN_HEIGHT / 16 * 3), (self.SCREEN_WIDTH / 4 * 3, self.SCREEN_HEIGHT / 16 * 3))\n pntssurf = self.f24.render(\"Flight score:\", True, (255, 255, 0))\n pntsrect = pntssurf.get_rect()\n pntsrect.left = self.SCREEN_WIDTH / 3\n pntsrect.centery = self.SCREEN_HEIGHT / 16 * 4\n self.screen.blit(pntssurf, pntsrect)\n cntrlsurf = self.f24.render(\"Fortress score:\", True, (255, 255, 0))\n cntrlrect = cntrlsurf.get_rect()\n cntrlrect.left = self.SCREEN_WIDTH / 3\n cntrlrect.centery = self.SCREEN_HEIGHT / 16 * 6\n self.screen.blit(cntrlsurf, cntrlrect)\n vlctysurf = self.f24.render(\"Mine score:\", True, (255, 255, 0))\n vlctyrect = vlctysurf.get_rect()\n vlctyrect.left = self.SCREEN_WIDTH / 3\n vlctyrect.centery = self.SCREEN_HEIGHT / 16 * 8\n self.screen.blit(vlctysurf, vlctyrect)\n speedsurf = self.f24.render(\"Bonus score:\", True, (255, 255, 0))\n speedrect = speedsurf.get_rect()\n speedrect.left = self.SCREEN_WIDTH / 3\n speedrect.centery = self.SCREEN_HEIGHT / 16 * 10\n self.screen.blit(speedsurf, speedrect)\n pntsnsurf = self.f24.render(\"%d\" % self.score.flight, True, (255, 255, 255))\n pntsnrect = pntsnsurf.get_rect()\n pntsnrect.right = self.SCREEN_WIDTH / 3 * 2\n pntsnrect.centery = self.SCREEN_HEIGHT / 16 * 4\n self.screen.blit(pntsnsurf, pntsnrect)\n cntrlnsurf = self.f24.render(\"%d\" % self.score.fortress, True, (255, 255, 255))\n cntrlnrect = cntrlnsurf.get_rect()\n cntrlnrect.right = self.SCREEN_WIDTH / 3 * 2\n cntrlnrect.centery = self.SCREEN_HEIGHT / 16 * 6\n self.screen.blit(cntrlnsurf, cntrlnrect)\n vlctynsurf = self.f24.render(\"%d\" % self.score.mines, True, (255, 255, 255))\n vlctynrect = vlctynsurf.get_rect()\n vlctynrect.right = self.SCREEN_WIDTH / 3 * 2\n vlctynrect.centery = self.SCREEN_HEIGHT / 16 * 8\n self.screen.blit(vlctynsurf, vlctynrect)\n speednsurf = self.f24.render(\"%d\" % self.score.bonus, True, (255, 255, 255))\n speednrect = speednsurf.get_rect()\n speednrect.right = self.SCREEN_WIDTH / 3 * 2\n speednrect.centery = self.SCREEN_HEIGHT / 16 * 10\n self.screen.blit(speednsurf, speednrect)\n #draw line\n pygame.draw.line(self.screen, (255, 255, 255), (self.SCREEN_WIDTH / 4 , self.SCREEN_HEIGHT / 16 * 11), (self.SCREEN_WIDTH / 4 * 3, self.SCREEN_HEIGHT / 16 * 11))\n totalsurf = self.f24.render(\"Total game score:\", True, (255, 255, 0))\n totalrect = totalsurf.get_rect()\n totalrect.left = self.SCREEN_WIDTH / 3\n totalrect.centery = self.SCREEN_HEIGHT / 16 * 12\n self.screen.blit(totalsurf, totalrect)\n totalnsurf = self.f24.render(\"%d\" % (self.score.flight + self.score.fortress + self.score.mines + self.score.bonus), True, (255, 255, 255))\n totalnrect = totalnsurf.get_rect()\n totalnrect.right = self.SCREEN_WIDTH / 3 * 2\n totalnrect.centery = self.SCREEN_HEIGHT / 16 * 12\n self.screen.blit(totalnsurf, totalnrect)\n if self.current_game == self.config['General']['games_per_session']:\n finalsurf = self.f24.render(\"You're done! Press return to exit\", True, (0, 255, 0))\n else:\n finalsurf = self.f24.render(\"Press return for next game\", True, (0, 255, 0))\n finalrect = finalsurf.get_rect()\n finalrect.centerx = self.SCREEN_WIDTH / 2\n finalrect.centery = self.SCREEN_HEIGHT / 16 * 14\n self.screen.blit(finalsurf, finalrect)", "def draw(c):\n c.draw_line((0,130), (580,130), 200, mood)\n c.draw_line((0,450), (290,450), 200, p1mood)\n c.draw_line((290,450), (580,450), 200, p2mood)\n c.draw_line((0,290), (580,290), 200, \"black\")\n c.draw_text(format(current), (150, 330), 110, \"yellow\")\n \n c.draw_line((193,108), (387,108), 120, \"#000080\")\n c.draw_line((0,25), (580,25), 50, \"#00FFFF\")\n c.draw_text(\"SINGLE PLAYER\", (20, 34), 30, \"#191970\")\n c.draw_text(\"Score\", (250, 90), 30, \"white\", \"sans-serif\")\n c.draw_line((250,96), (329,96), 4, \"white\")\n c.draw_text(score(wins, tries), scorepos, 40, \"white\", \"sans-serif\")\n \n c.draw_line((66,472), (220,472), 120, \"#556B2F\")\n c.draw_line((360,472), (514,472), 120, \"#4B0082\") \n c.draw_line((0,555), (580,555), 50, \"#F4A460\")\n c.draw_text(\"TWO PLAYER\", (20, 566), 30, \"#800000\")\n c.draw_text(\"Player 1\", (90, 454), 30, \"#F0E68C\", \"sans-serif\")\n c.draw_line((90,464), (200,464), 4, \"#F0E68C\")\n c.draw_text(score_string(p1score), p1scorepos, 40, \"#F0E68C\", \"sans-serif\")\n c.draw_text(\"Player 2\", (380,454), 30, \"#E6E6FA\", \"sans-serif\")\n c.draw_line((380,464), (490,464), 4, \"#E6E6FA\")\n c.draw_text(score_string(p2score), p2scorepos, 40, \"#E6E6FA\", \"sans-serif\")\n c.draw_line((0,440), (580,440), result2pline, \"#F7DE00\")\n c.draw_text(result2p, (180,450), 35, \"black\")", "def clear_board_callback(self, data):\n if self.team == 'blue':\n self.color = (255,0,0)\n elif self.team == 'red':\n self.color = (0,0,255)\n\n if self.current_round_red_score < 0:\n self.current_round_red_score = 0\n if self.current_round_blue_score < 0:\n self.current_round_blue_score = 0\n\n self.red_score_total += self.current_round_red_score\n self.blue_score_total += self.current_round_blue_score\n\n self.bags_found = []\n self.bag_poses = {}\n self.red_score = []\n self.blue_score = []\n self.current_round_red_score = 0\n self.current_round_blue_score = 0\n\n put_text('New Score:')\n rospy.sleep(1)\n put_text('B ' + str(self.blue_score_total) + ' - ' + str(self.red_score_total) + ' R')\n\n if self.blue_score_total == 21:\n put_text('Blue Wins!', (255,0,0))\n rospy.sleep(2.5)\n if self.team == 'blue':\n display_png('happy.png', self.color)\n elif self.team == 'red':\n display_png('sad.png', self.color)\n rospy.sleep(2)\n elif self.red_score_total == 21:\n put_text('Red Wins!', (0,0,255))\n rospy.sleep(2.5)\n if self.team == 'blue':\n display_png('sad.png', self.color)\n elif self.team == 'red':\n display_png('happy.png', self.color)\n rospy.sleep(2)\n\n if self.blue_score_total > 21:\n self.blue_score_total = 15\n put_text('Blue Busts!', (255, 0, 0))\n rospy.sleep(2.5)\n if self.team == 'blue':\n display_png('sad.png', self.color)\n elif self.team == 'red':\n display_png('happy.png', self.color)\n rospy.sleep(2)\n\n if self.red_score_total > 21:\n self.red_score_total = 15\n put_text('Red Busts!', (0, 0, 255))\n rospy.sleep(2.5)\n if self.team == 'red':\n display_png('sad.png', self.color)\n elif self.team == 'blue':\n display_png('happy.png', self.color)\n rospy.sleep(2)\n\n return EmptyResponse()", "def play_gui():\n global done\n GAME_OVER = False\n pygame.init()\n board = create_board()\n\n screen = pygame.display.set_mode(SIZE)\n draw_board(board, screen)\n pygame.display.update()\n\n myfont = pygame.font.SysFont(\"monospace\", 75)\n turn = np.random.randint(0, 2)\n\n while not GAME_OVER:\n g = Game()\n done = False\n transitions_agent = []\n\n for event in pygame.event.get():\n if event.type == pygame.QUIT:\n sys.exit()\n\n if event.type == pygame.MOUSEMOTION:\n pygame.draw.rect(screen, black, (0, 0, WIDTH, SQUARESIZE))\n posx = event.pos[0]\n if turn == PLAYER:\n pygame.draw.circle(screen, red, (posx, int(SQUARESIZE / 2)), RADIUS)\n pygame.display.update()\n\n if event.type == pygame.MOUSEBUTTONDOWN:\n pygame.draw.rect(screen, black, (0, 0, WIDTH, SQUARESIZE))\n\n if turn == PLAYER:\n posx = event.pos[0]\n col = int(math.floor(posx / SQUARESIZE))\n\n if is_valid_location(board, col):\n row = get_next_open_row(board, col)\n drop_piece(board, row, col, PLAYER_PIECE)\n\n if winning_move(board, PLAYER_PIECE):\n label = myfont.render(\"Player 1 wins!!\", 1, red)\n screen.blit(label, (40, 10))\n GAME_OVER = True\n\n turn = (turn + 1) % 2\n draw_board(board, screen)\n\n # # Ask for Player 2 Input\n if turn == AI and not GAME_OVER:\n observation = []\n #print(f\"BOARD: {board}\")\n temp_board = np.flipud(board)\n for col in range(COLUMN_COUNT):\n col_elements = temp_board[:,col]\n for element in col_elements:\n observation.append(element)\n\n #print(f\"OBS: {observation}\")\n observation = np.asarray(observation)\n col = agent.choose_action(observation)\n\n if is_valid_location(board, col):\n row = get_next_open_row(board, col)\n drop_piece(board, row, col, AI_PIECE)\n\n if winning_move(board, AI_PIECE):\n label = myfont.render(\"Player 2 wins!!\", 1, yellow)\n screen.blit(label, (40, 10))\n GAME_OVER = True\n\n draw_board(board, screen)\n turn = (turn + 1) % 2\n\n else:\n print(\"AI random choice\")\n col = np.random.randint(7)\n row = get_next_open_row(board, col)\n drop_piece(board, row, col, AI_PIECE)\n\n if winning_move(board, AI_PIECE):\n label = myfont.render(\"Player 2 wins!!\", 1, yellow)\n screen.blit(label, (40, 10))\n GAME_OVER = True\n\n draw_board(board, screen)\n turn = (turn + 1) % 2" ]

[ "0.71793014", "0.7135505", "0.69333947", "0.679917", "0.67140776", "0.6689482", "0.6616458", "0.6603764", "0.660077", "0.6580719", "0.6579889", "0.6572002", "0.6518525", "0.65171593", "0.64786243", "0.647032", "0.6414249", "0.63918775", "0.63835615", "0.6371472", "0.6370773", "0.63613945", "0.63480127", "0.63276494", "0.63226545", "0.6311243", "0.6310414", "0.62920916", "0.6281002", "0.624259" ]

[ "def play(self, player, game): \n super().play(player, game)\n game.set_action(\"SLEEP_CODER\")", "def update(self):\r\n if not self.tr.game_over and self.tr.turn_tracker:\r\n self.computer_play()", "def play_game(self):\n # need everyone to pass to move to next phase?\n self.deal_cards()\n self.plant_food()", "def resign_game(self):\n if self._current_player == \"BLACK\":\n self._game_state = \"WHITE_WON\"\n\n else:\n self._game_state = \"BLACK_WON\"", "def start_game(self):\n while self.can_deal:\n self.take_turn()", "def play(self, player, game):\n super().play(player, game)\n game.set_action(\"STEAL_CODER\")", "def stand(self):\n self.endgame()", "def play_game():\n pass", "def game(self):\n sender = self.sender()\n if(sender.text() == \" \"):\n sender.setText(\"x\" if self.firstPlayer else \"0\")\n self.firstPlayer = not(self.firstPlayer)\n res = self.checkForResult()\n if(res[0] == True):\n self.endGame(res[1])", "def playerdefeated(self):\n globalvalues.gameover_combat()", "def play(self, player, game):\n super().play(player, game)\n game.set_action(\"PICKUP_CODER\")", "def end_game(self):\n if self._waiting_for_players:\n [p.client.cancel_interactions() for p in self.all_players]\n self._waiting_for_players = False\n\n super().end_game()\n\n self.states[self.state][\"next\"] = \"STOP\"\n self._run_next_state()", "def play(self, player, game):\n player.get_hand().get_cards().remove(self)\n card = game.pick_card()\n player.get_hand().add_cards(card)\n game.next_player()\n game.set_action(\"NO_ACTION\")", "def restart_game(self):\n self.play()", "def fainted(self):\n self.pkmn.faint()\n messages = self.effect.attemptAfterTurn(self.pkmn)\n assert messages == [], \"Should receive no messages since nothing was performed\"", "def _activate(self):\n self.game.lives += 1", "def game_over(self):\n self.over = True", "def play_game(self):\n self.welcome()\n while (self.winner is None) and (not self.exit_flag) and (not self.board.full()):\n self.play_round()\n self.exit_game()", "def notify_game_over(self):\n self.is_game_over = True", "def play(self, player, game):\n player.get_hand().get_cards().remove(self)\n card = game.pick_card()\n player.get_hand().add_cards(card)\n game.set_action(\"NO_ACTION\")", "def play_game():\n\n _initial_deal()\n\n main_window.mainloop()", "def endGame(self):\n pass", "def game_play(self):", "def faint(self):\n if self.current_health <= 0:\n self.is_alive = False\n print(\"Pykemon \" + self.name + \" has fainted!\")\n input(\"Press Enter to continue.\")", "def game_over(self):\n if not self.should_change_scene:\n self.should_fade_out = True", "def end_game(self):\n self.game.stop_running()", "def resign_game(self):\n # If entered, it will return winner status for the opposing player\n if self._current_player == 'W':\n self._game_status = 'BLACK_WON'\n if self._current_player == 'B':\n self._game_status = 'WHITE_WON'", "def evolve(self):\n # Start with first player\n self.phase.set(1)\n\n #self.first_player\n \n # Autopass turn if no cards left for player\n \n \n pass", "def play(self):\n print('Playing game...')", "def reset(self, *args):\n self.state = GameStates.playing\n self.human = evilrps.Player('Human', self.get_player_choice)\n self.ai = evilrps.Player('AI', evilrps.create_ai())\n self.game = evilrps.Game(self.human, self.ai)" ]

[ "0.72997624", "0.7028231", "0.6982496", "0.69552714", "0.69463617", "0.69215953", "0.6851516", "0.675886", "0.668377", "0.66815096", "0.66583437", "0.66448665", "0.65827966", "0.655984", "0.65565306", "0.654274", "0.65393883", "0.6524599", "0.6484492", "0.6471058", "0.6466911", "0.64466965", "0.64347106", "0.6426657", "0.64180684", "0.639501", "0.63852805", "0.6381", "0.63698757", "0.63579017" ]

[ "def device_class(self):\n return self._sensor_type", "def device_class(self):\n return self.sensor_type[\"class\"]", "def device_class(self) -> str | None:\n return self._get_sensor_type()[2]", "def metertype(self):\n return self._metertype.get_waarde()", "def get_default_sensor_type():\n return get_sensor_type_id(DEFAULT_SENSOR_TYPE)", "def state(self):\n return self.device.device_data[self.device_id][self._sensor_type]", "def device_class(self):\n return BINARY_SENSORS[self.info_type][\"device_class\"]", "def state(self):\n if not self.available:\n return None\n if self._type == SENSOR_TYPE_TEMPERATURE:\n return self._value_as_temperature\n if self._type == SENSOR_TYPE_HUMIDITY:\n return self._value_as_humidity\n if self._type == SENSOR_TYPE_LUMINANCE:\n return self._value_as_luminance\n return self._value", "def device_class(self):\r\n return self._sensor_cfg[3]", "def device_class(self):\r\n return self._sensor_cfg[3]", "def device_type(self):\n # type: () -> string_types\n return self._device_type", "def device_class(self):\n return SENSOR_TYPES[self._type][1]", "def device_class(self):\n return SENSOR_TYPES[self._type][1]", "def device_class(self):\n if self._sensor_type == \"temperature\":\n return DEVICE_CLASS_TEMPERATURE\n if self._sensor_type == \"humidity\":\n return DEVICE_CLASS_HUMIDITY\n if self._sensor_type == \"battery_level\":\n return DEVICE_CLASS_BATTERY\n return None", "def device_class(self):\n if self._type in SENSOR_TYPES:\n return self._type\n return None", "def _get_sensor_type(self) -> list[str | None]:\n pres = self.gateway.const.Presentation\n set_req = self.gateway.const.SetReq\n\n _sensor_type = SENSORS.get(set_req(self.value_type).name, [None, None, None])\n if isinstance(_sensor_type, dict):\n sensor_type = _sensor_type.get(\n pres(self.child_type).name, [None, None, None]\n )\n else:\n sensor_type = _sensor_type\n return sensor_type", "def device_class(self):\n return BINARY_SENSOR_DEVICE_CLASS", "def name(self):\n return f\"{self._tc_object.name} {SENSOR_TYPES[self.type][0]}\"", "def device_type(self) -> str:\n if self.android_feature_phone():\n return 'smartphone'\n\n dt = self.all_details.get('device', {}).get('type', '')\n if dt:\n return dt\n\n aat = self.android_device_type()\n if aat:\n return aat\n\n if self.windows_tablet():\n return 'tablet'\n\n if self.is_television():\n return 'tv'\n\n if self.is_desktop():\n return 'desktop'\n\n if self.opera_tablet():\n return 'tablet'\n\n return ''", "def type(self):\n return self._device.type_name", "def type(self) -> str:\n return self._device_info[\"Type\"]", "def device_class(self):\n return SENSOR_TYPES[self._type][3] if self._type in SENSOR_TYPES else None", "def device_class(self):\n return SENSOR_TYPES[self.sensor][3].get(\"device_class\")", "def device_class(self):\n return NumberDeviceClass.BATTERY", "def get_temperature_sensor(self) -> Tuple[str, int]:\n self.serial.write(b\"t!\")\n temp_sensor = self.__read_response(1)[0]\n if temp_sensor[0:3] == b\"!th\":\n temp_sensor = self.__extract_int(temp_sensor, b\"!th\")\n # if we get 65536, the sensor is not connected\n if temp_sensor == 65535:\n raise CloudWatcherException(\n \"High precision RHEL/temp sensor not connected\"\n )\n return \"th\", temp_sensor\n else:\n temp_sensor = self.__extract_int(temp_sensor, b\"!t\")\n # if we get 100, the sensor is not connected\n if temp_sensor == 100:\n raise CloudWatcherException(\n \"Low precision RHEL/temp sensor not connected\"\n )\n return \"t\", temp_sensor", "def getLightSensor() -> int:\n pass", "def getType(self):\n if (self.type == 's'):\n #suit type\n type = \"suit\"\n elif (self.type == 'b'):\n #boss type\n type = \"boss\"\n else:\n notify.error(\"Invalid DNA type: \", self.type)\n\n return type", "def probe_type(self):\n return self.extract_secondary_header(29)", "def name(self):\n return self.device.device_data[self.device_id]['name'] + \\\n f' {self._sensor_type}'", "def state(self):\n\n if self._device_attribute == ATTR_INSIDE_TEMPERATURE:\n if self._api.roomTemperature == 126 or self._api.roomTemperature == None:\n return 'unavailable'\n else:\n return self._api.roomTemperature\n\n if self._device_attribute == ATTR_OUTSIDE_TEMPERATURE:\n if self._api.outdoorTemperature == 126 or self._api.outdoorTemperature == None:\n return 'unavailable'\n else:\n return self._api.outdoorTemperature\n return None" ]

[ "0.712751", "0.6980082", "0.6964943", "0.6866985", "0.6718667", "0.67184216", "0.6718335", "0.67090505", "0.6664326", "0.6664326", "0.66510004", "0.6639602", "0.6639602", "0.66321737", "0.66211474", "0.6606579", "0.66017085", "0.653939", "0.64990103", "0.6498133", "0.64922404", "0.6473972", "0.64739496", "0.6464629", "0.64323616", "0.6419462", "0.6417309", "0.63974243", "0.63853246", "0.6371345" ]

[ "def get_wind_sensor(self) -> int:\n self.serial.write(b\"V!\")\n wind_sensor = self.__extract_int(self.__read_response(1)[0], b\"!w\")\n\n return wind_sensor", "def get_number(self):\n return self.__device_number", "def getLightSensor() -> int:\n pass", "def sensor(self , sensor_index):\n sensor = obd_sensors.SENSORS[sensor_index]\n try:\n r = self.get_sensor_value(sensor)\n except \"NORESPONSE\":\n r = \"NORESPONSE\"\n return (sensor.name,r, sensor.unit)", "def device_num(self) -> str:\n return pulumi.get(self, \"device_num\")", "def raw_sensor_count(self):\n\n # two complement bytes, MSB comes after LSB!\n bytes = self.raw_sensor_strings[1].split()\n\n # Convert from 16 bit hex string into int\n int16 = int(bytes[1] + bytes[0], 16)\n\n # check first signing bit\n if int16 >> 15 == 0:\n return int16 # positive values need no processing\n else:\n return int16 - (1 << 16) # substract 2^16 to get correct negative value", "def get_sensor_name(self):\n return self.data[1]", "def getNumber():", "def get_teds_serial( channel ):\n serial = uInt32(0)\n CALL('GetPhysicalChanTEDSSerialNum', channel, byref(serial))\n return serial.value", "def get_sensor_type(self):\n return self.data[1][:-1]", "def READ_PRESSURE_SENSOR():\n return 15.246", "def get_serial_number(self):\n\n\t\treturn struct.unpack('<Q', self.boot_sector_data[72 : 80])[0]", "def get_ir_sensor_temperature(self) -> float:\n self.serial.write(b\"T!\")\n ir_sensor_temp = self.__extract_int(self.__read_response(1)[0], b\"!2\")\n\n return round(ir_sensor_temp / 100, 2)", "def raw_sensor_temp(self):\n\n # return the value in millicelsius\n return float(self.raw_sensor_strings[1].split(\"=\")[1])", "def get_temperature_sensor(self) -> Tuple[str, int]:\n self.serial.write(b\"t!\")\n temp_sensor = self.__read_response(1)[0]\n if temp_sensor[0:3] == b\"!th\":\n temp_sensor = self.__extract_int(temp_sensor, b\"!th\")\n # if we get 65536, the sensor is not connected\n if temp_sensor == 65535:\n raise CloudWatcherException(\n \"High precision RHEL/temp sensor not connected\"\n )\n return \"th\", temp_sensor\n else:\n temp_sensor = self.__extract_int(temp_sensor, b\"!t\")\n # if we get 100, the sensor is not connected\n if temp_sensor == 100:\n raise CloudWatcherException(\n \"Low precision RHEL/temp sensor not connected\"\n )\n return \"t\", temp_sensor", "def get_temperature(self, sensor: int = 0) -> float:\n\n return self.send(self.cmd.GET_HEATING_ACT)", "def get_value(self):\n return self.sensor.get_value()", "def temperature():\n snmp.temperature()\n return 0", "def temperature_sensor():\n\n\tsensor_name = \"humiture\"\n\treg_addr = 26\n\tdata_len = 4\n\tregist_sensor(sensor_name, reg_addr, data_len)\n\n\t# get sensor data\n\tdata = rospy.wait_for_message('MediumSize/SensorHub/Temperature', Temperature, 2)\n\ttemperature = data.temperature\n\n\tdelete_sensor(sensor_name)\n\treturn temperature", "def read_temperature(self):\n data = self.ag.read_bytes(Register.OUT_TEMP_L, 2)\n return lsm9ds1.to_int16(data)", "def _get_info_about_sensor(self):\n reg_id = 0xD0\n chip_id, chip_version = self.bus.read_i2c_block_data(self.address,\n reg_id,\n 2)\n return chip_id, chip_version", "def get_robot_sn(self):\r\n return self._arm.get_robot_sn()", "def internal_temp_c(self) -> int:\n return int(self._device_info[\"Temperature\"])", "def get_sensors_info(self):\n return [0 if np.isnan(s.getValue()) else int(s.getValue())\n for s in self.sensors]", "def _serial_number(self):\n hops_config = self._configurations[TextualDevice.connection_hops]\n cfg_ux2adb = hops_config[UnixRemote.unix_remote][AdbRemote.adb_shell]\n serial_number = cfg_ux2adb[\"command_params\"][\"serial_number\"]\n return serial_number", "def get_inttemp(self):\n return self.read_register(4104, 1, 3)", "def read_sensor(sensor: int, gpio_pin: int) -> (int, float, float, datetime):\r\n logging.debug('reading sensor')\r\n hum_rh, temp_c = Adafruit_DHT.read_retry(sensor, gpio_pin)\r\n if hum_rh is None or temp_c is None:\r\n logging.error(\"failed to read from the sensor\")\r\n return 1, 0, 0, datetime.now()\r\n logging.debug('sensor data: RH: {}, Tc: {}'.format(hum_rh, temp_c))\r\n return 0, hum_rh, temp_c, datetime.now()", "def station_serial(self) -> str:\n return self.camera_info[\"station_sn\"]", "def humidity_sensor():\n\n\tsensor_name = \"humiture\"\n\treg_addr = 26\n\tdata_len = 4\n\tregist_sensor(sensor_name, reg_addr, data_len)\n\n\t# get sensor data\n\tdata = rospy.wait_for_message('MediumSize/SensorHub/Humidity', RelativeHumidity, 2)\n\thumidity = data.relative_humidity\n\n\tdelete_sensor(sensor_name)\n\treturn humidity", "def get_device_sn(self):\n summary = self.get_version_summary()\n pattern = '\\$.*? .*? .*? (.*?) .*? .*? .*? .*? .*? \\r\\n' \n mcu_sn = int(re.findall(pattern,summary).pop())\n return mcu_sn" ]

[ "0.72921866", "0.72716254", "0.72215855", "0.6991148", "0.6926272", "0.6887004", "0.6755828", "0.67055243", "0.67028284", "0.6701708", "0.66806006", "0.6632175", "0.661996", "0.6568401", "0.65603375", "0.6507038", "0.6482421", "0.6466721", "0.643406", "0.6386015", "0.6343718", "0.6330134", "0.63254374", "0.62911564", "0.6286827", "0.6263805", "0.6247657", "0.6219973", "0.62175184", "0.6193227" ]

[ "def name(self):\n return self._sensor.name", "def friendly_name(self):\n return self._sensor_name", "def name(self):\n return f\"{self._name} {SENSOR_TYPES[self.sensor][0]}\"", "def name(self):\n return self.device.device_data[self.device_id]['name'] + \\\n f' {self._sensor_type}'", "def name(self) -> str:\n return f\"{self.platform_name} {self._sensor_name}\"", "def name(self):\n return f\"{self._name} {self._sensor_name}\"", "def name(self):\n return f\"{self._name}_{self._sensor}\"", "def name(self):\n return f\"{get_device_name(self._data, self._actuator.id)} Floor Temp Offset\"", "def name(self):\n return f\"{self.sensor_type['name']} ({self._mac[-5:]})\"", "def name(self):\n return self.device.get_station_name(self.station_number)", "def name(self):\n return f\"{DEFAULT_NAME}_{BINARY_SENSOR}\"", "def get_sensor_name(self):\n\n return self._sensor_results_list[0].get_sensor_model()", "def name(self):\n return f\"{self._tc_object.name} {SENSOR_TYPES[self.type][0]}\"", "def name(self):\n return f\"{habitica.DOMAIN}_{self._name}_{self._sensor_name}\"", "def name(self) -> str:\n station_name = self._get_station_name()\n return f\"{station_name} {self._fuel_type}\"", "def name(self):\n if self._connection.location_names:\n return '{} {} {}'.format(self._device.location2, self._device.location, self._device.name)\n else:\n return self._device.name", "def symbolize_sensorname_sysfs(name):\n return name.split(\"_\")[1] + \"_temp\"", "def get_temperature_name(self, sensor):\n if sensor >= self.num_temperatures or sensor < 0:\n raise I2CException('Illegal sensor index {} specified'.format(sensor))\n\n return PSCU.TEMP_SENSOR_NAMES[sensor]", "def name(self) -> str:\n return f\"{get_friendly_name(self._name)} temperature\"", "def raw_unit_of_measurement(self) -> str:\n if len(self._node.uom) == 1:\n if self._node.uom[0] in UOM_FRIENDLY_NAME:\n friendly_name = UOM_FRIENDLY_NAME.get(self._node.uom[0])\n if friendly_name == TEMP_CELSIUS or \\\n friendly_name == TEMP_FAHRENHEIT:\n friendly_name = self.hass.config.units.temperature_unit\n return friendly_name\n else:\n return self._node.uom[0]\n else:\n return None", "def name(self):\n return f\"{get_device_name(self._data, 0, self._name)}\"", "def name(self):\n return f\"{self.device_name} {self.device_variable}\"", "def name(self):\n return f'{self._vehicle.name} {self.wan_name} Signal'", "def _get_sensor_name(self, zone=0, sensor_type=None):\n zone = int(zone)\n if zone == 0:\n return self._name + \" Last heartbeat\"\n else:\n zone_name = self._get_zone_name(zone)\n if sensor_type:\n return (\n self._name\n + (\" \" + zone_name + \" \" if zone_name else \" \")\n + sensor_type\n )\n else:\n _LOGGER.error(\n \"Hub: Get Sensor Name: Not allowed to create an entity_id without type, unless zone == 0.\"\n )\n return None", "def get_station_name(self, station=0):\n return self.statuslist()[station][1]", "def get_humidity_name(self, sensor):\n if sensor >= self.num_humidities or sensor < 0:\n raise I2CException('Illegal sensor index {} specified'.format(sensor))\n\n return PSCU.HUMIDITY_SENSOR_NAMES[sensor]", "def get_wind_sensor(self) -> int:\n self.serial.write(b\"V!\")\n wind_sensor = self.__extract_int(self.__read_response(1)[0], b\"!w\")\n\n return wind_sensor", "def windspeed(self):\r\n try:\r\n return str(self.connect()['wind']['speed'])\r\n except:\r\n return '@weather_windspeed'", "def sensor(self, _mask, _target, args) -> str:\n return self.get_sensor(args[\"<sensor_name>\"])", "def weather(self):\r\n try:\r\n return str(self.connect()['weather'][0]['description'])\r\n except:\r\n return '@weather'" ]

[ "0.7582795", "0.7523397", "0.7500788", "0.7433387", "0.7193106", "0.71633244", "0.71525973", "0.70375884", "0.70051795", "0.6941416", "0.6824166", "0.6777688", "0.67560774", "0.6752853", "0.6744714", "0.66684556", "0.66287833", "0.66215414", "0.6407245", "0.6396662", "0.637726", "0.6330388", "0.633006", "0.63129944", "0.63008875", "0.6237803", "0.6217826", "0.61836815", "0.6137957", "0.610121" ]

[ "def get_value(self):\n return self.sensor.get_value()", "def raw_sensor_temp(self):\n\n # return the value in millicelsius\n return float(self.raw_sensor_strings[1].split(\"=\")[1])", "def get_ir_sensor_temperature(self) -> float:\n self.serial.write(b\"T!\")\n ir_sensor_temp = self.__extract_int(self.__read_response(1)[0], b\"!2\")\n\n return round(ir_sensor_temp / 100, 2)", "def native_value(self):\n return self.temperature", "def native_value(self):\n return self.mon.data[\"temp\"]", "def get_temperature(self):\n pass", "def get_temperature_sensor(self) -> Tuple[str, int]:\n self.serial.write(b\"t!\")\n temp_sensor = self.__read_response(1)[0]\n if temp_sensor[0:3] == b\"!th\":\n temp_sensor = self.__extract_int(temp_sensor, b\"!th\")\n # if we get 65536, the sensor is not connected\n if temp_sensor == 65535:\n raise CloudWatcherException(\n \"High precision RHEL/temp sensor not connected\"\n )\n return \"th\", temp_sensor\n else:\n temp_sensor = self.__extract_int(temp_sensor, b\"!t\")\n # if we get 100, the sensor is not connected\n if temp_sensor == 100:\n raise CloudWatcherException(\n \"Low precision RHEL/temp sensor not connected\"\n )\n return \"t\", temp_sensor", "def getData(self,sensor_id,t):\r\n assert t > 0 and t < self.measurements\r\n try:\r\n return round(float(self.app.data[int(t*self.samplerate)][sensor_id].text),3)\r\n except:# No data loaded, or scrubber out of bounds\r\n return 0", "def temperature() -> float:", "def get_temperature(self):\n return self.ipcon.send_request(self, BrickletBarometerV2.FUNCTION_GET_TEMPERATURE, (), '', 'i')", "def get_temperature(self, sensor: int = 0) -> float:\n\n return self.send(self.cmd.GET_HEATING_ACT)", "def read_temperature(self):\n data = self.ag.read_bytes(Register.OUT_TEMP_L, 2)\n return lsm9ds1.to_int16(data)", "def get_temperature(self):\n self.temperature = self.temperature_sensors.get_temperature(\n self.channel)\n return self.temperature", "def READ_PRESSURE_SENSOR():\n return 15.246", "def get_temperature_state(self):\n return self.__sensor_states[0]", "def get_temp(self):\n\t\traw_temp = self.read_i2c_word(self.TEMP_OUT0)\n\n\t\t# Get the actual temperature using the formule given in the\n\t\t# MPU-6050 Register Map and Descriptions revision 4.2, page 30\n\t\tactual_temp = (raw_temp / 340.0) + 36.53\n\n\t\treturn actual_temp", "def temperature(self):\r\n self._read_temperature()\r\n return self._t_fine / 5120.0", "def getTemperature(self):\n return self.temperature", "def getTemperature(self):\n with self.lock:\n temp = self.temp\n return temp", "def temperature(self):\n return self.read_short(65) / 340.0 + 36.53", "def get_ft_sensor_data(self):\r\n return self._arm.get_ft_sensor_data()", "def __getRawTemperature(self):\n t1 = self.read_byte_data(self.address, 0x03)\n t2 = self.read_byte_data(self.address, 0x04)\n t3 = self.read_byte_data(self.address, 0x05)\n t = (t1 << 16) | (t2 << 8) | t3\n t = getTwosComplement(t, 24)\n return t", "def read_temperature(self):\n tRaw = self._read_multiple_bytes_as_array(self.BME280_TEMP_MSB, 3)\n\n return float(self._compensate_temperature((tRaw[0] << 12) + (tRaw[1] << 4) + (tRaw[2] >> 4)))", "def temperature_sensor():\n\n\tsensor_name = \"humiture\"\n\treg_addr = 26\n\tdata_len = 4\n\tregist_sensor(sensor_name, reg_addr, data_len)\n\n\t# get sensor data\n\tdata = rospy.wait_for_message('MediumSize/SensorHub/Temperature', Temperature, 2)\n\ttemperature = data.temperature\n\n\tdelete_sensor(sensor_name)\n\treturn temperature", "def state(self):\n return self.device.device_data[self.device_id]['temperature']", "def target_temperature(self):\n if self.ac.status is None:\n _LOGGER.debug(f\"target_temperature: status is None, returning None\")\n return None\n value = self.ac.status.spt\n if value is not None:\n value = int(value)\n _LOGGER.debug(f\"value of target_temperature property: {value}\")\n return value", "def state(self):\n return self._device.temperature", "def get_temperature(self):\r\n\r\n\t# get current resolution\r\n\r\n\tconf = self.read_config()\r\n\tmask = 0x60 # 0110 0000\r\n\tres = conf & mask # extract resolution from config register\r\n\t# get temperature from register\r\n \r\n self.write('\\x00')\r\n data = self.read(2)\r\n t_raw = struct.unpack('>h', data)\r\n\tt_raw = t_raw[0]\r\n\r\n#\tmsb = 0b11110101\r\n#\tlsb = 0b11100000\r\n#\tdata = struct.pack('BB', msb, lsb)\r\n # t_raw = struct.unpack('>h', data)\r\n#\tt_raw = t_raw[0]\r\n#\tprint t_raw\r\n\t\r\n # return t_raw\r\n\t# t_raw = ((msb << 8) + lsb) # convert to 2 Byte Integer\r\n\r\n\tif (res == 0x00): # 9 bit resolution 0.5 degree\r\n\t print \"res: 0.5\"\r\n\t return (t_raw >> 7) * 0.5\r\n\r\n\tif (res == 0x20): # 10 bit resolution 0.25 degree\r\n\t print \"res: 0.25\"\r\n\t return (t_raw >> 6) * 0.25\r\n\r\n\tif (res == 0x40): # 11 bit resolution 0.125 degree\r\n\t print \"res: 0.125\"\r\n\t return (t_raw >> 5) * 0.125\r\n\r\n\tif (res == 0x60): # l2 bit resolution 0.0625 degree\r\n\t print \"res: 0.0625\"\r\n\t return (t_raw >> 4) * 0.0625", "def get_tank_temperature():\n if sensor is None:\n return DEFAULT_TEMPERATURE\n\n try:\n # Read the temperature from the I2C sensor.\n return sensor.read_temperature(True)\n except OSError:\n return DEFAULT_TEMPERATURE", "def get_temperature(self, sensor):\n if sensor >= self.num_temperatures or sensor < 0:\n raise I2CException('Illegal sensor index {} specified'.format(sensor))\n\n return self.__temperature_values[sensor]" ]

[ "0.77358204", "0.7388789", "0.7291502", "0.72200984", "0.7182863", "0.71696424", "0.7142843", "0.7139891", "0.7104367", "0.7070535", "0.7047923", "0.7047081", "0.6964376", "0.69313365", "0.6930856", "0.69106907", "0.68933904", "0.68690497", "0.6823682", "0.6791697", "0.67678934", "0.67602503", "0.675698", "0.67477125", "0.67460334", "0.67237043", "0.6715952", "0.6714022", "0.6711576", "0.67074573" ]

[ "def get_th_mean_values(self, value_list):\n if not len(value_list):\n return None, None, None\n t, h, d = map(list, zip(*value_list))\n return (\n round(statistics.mean(t), 1),\n int(round(statistics.mean(h), 0)),\n round(statistics.mean(d), 1),\n )", "def _mean(listvalue):\n\treturn sum(listvalue)/len(listvalue)", "def mean(vals):", "def mean(list_of_values):\r\n # Explicit float(...) to allow for Python 2 division.\r\n return sum(list_of_values) / float(len(list_of_values))", "def mean_value( values ):\n return sum( values ) / len( values )", "def get_thb_mean_values(self, value_list):\n if not len(value_list):\n return None, None, None, None, None\n\n temp, hum, dew, baro, forecast, sealevel = map(list, zip(*value_list))\n return (\n round(statistics.mean(temp), 1),\n int(round(statistics.mean(hum), 0)),\n round(statistics.mean(dew), 1),\n round(statistics.mean(baro), 1),\n round(statistics.mean(sealevel), 1),\n )", "def mean(values):\r\n return sum(values) / float(len(values))", "def mean(self, values):\n return self.aggregate(values, \"mean\")", "def find_mean(values):\n mean = sum(values) / len(values)\n return mean", "def mean(values):\n # Write the mean() function\n mean = sum(values) / len(values)\n return mean", "def mean(values):\n # Write the mean() function\n mean = sum(values) / len(values)\n return mean", "def CalculateListAverage(values):\n if not values:\n return 0\n return sum(values) / float(len(values))", "def get_mean(numlist):\n return np.mean(numlist)", "def get_sol_mean_value(self, value_list):\n if len(value_list):\n return int(round(statistics.mean(value_list), 0))\n else:\n return None", "def find_mean(values):\n return sum(values) / len(values)", "def averaged(*values):\n values = [_normalize(v) for v in values]\n for v in zip(*values):\n yield mean(v)", "def mean(list_of_values):\n # so don't have to worry about getting the divisor.\n # Explicit float(...) to allow for Python 2 division.\n try:\n mean = sum(list_of_values) / float(len(list_of_values))\n return mean\n except:\n return False", "def mean_list(data):\n return sum(data) / len(data)", "def get_uv_mean_value(self, value_list):\n if len(value_list):\n return int(round(statistics.mean(value_list), 0))\n else:\n return None", "def mean(num_list):\n i = 0\n num_sum = 0.0\n for item in num_list:\n num_sum += item\n i += 1\n return num_sum/i", "def mean(values):\n total = sum(values)\n len_values = len(values)\n return total/len_values", "def getMean(list):\n return sum(list) / len(list)", "def avg(values):\n return sum(values) / float(len(values))", "def get_mean(self):\n self.meanval = np.mean(self.adulist)", "def get_wind_mean_values(self, value_list):\n if not len(value_list):\n return None, None, None, None\n\n dir, gust, avg, chill = map(list, zip(*value_list))\n return (\n int(round(statistics.mean(dir), 0)),\n round(statistics.mean(gust), 1),\n round(statistics.mean(avg), 1),\n round(statistics.mean(chill), 1),\n )", "def list_mean(lst):\n return list_sum(lst) / len(lst)", "def average(values):\n\treturn sum(values)/len(values)", "def mean(self, values: pdarray, skipna: bool = True) -> Tuple[groupable, pdarray]:\n k, v = self.aggregate(values, \"mean\", skipna)\n return k, cast(pdarray, v)", "def get_rain_mean_values(self, value_list):\n if not len(value_list):\n return None, None\n\n rate, total = map(list, zip(*value_list))\n rain = round(total[-1] - total[0], 1)\n\n # Rain can't be negative and in january many rain sensors are\n # resetted to 0 which leads to negative values\n if rain < 0:\n rain = 0.0\n return round(statistics.mean(rate)), rain", "def mean(my_list):\n the_mean = sum(my_list) / len(my_list)\n return the_mean" ]

[ "0.8035656", "0.7831136", "0.7761068", "0.768525", "0.7579617", "0.7523615", "0.7422822", "0.73106337", "0.72299606", "0.7228836", "0.72205615", "0.7220237", "0.719906", "0.71492904", "0.71233815", "0.71087384", "0.7099522", "0.7043981", "0.7041665", "0.70132077", "0.6996165", "0.6917998", "0.6852041", "0.6838916", "0.67982894", "0.67879033", "0.67826265", "0.6772731", "0.675909", "0.6746647" ]

[ "def get_sensors_data(self):\n\n temp_in_celsius = self.get_temperature()\n\n return (\n round(temp_in_celsius, 1), \n round(self.to_fahrenheit(temp_in_celsius), 1), \n round(self.get_humidity(), 0), \n round(self.get_pressure(), 1)\n )", "def temperatures():\n\n return station_9281", "def read_values(self):\n temp, acc, gyro = self.read_ag_data()\n tempc = lsm9ds1.TEMPC_0 + temp * lsm9ds1.TEMP_SENSOR_SCALE\n tempf = (tempc * 9/5) + 32\n acc = [c * lsm9ds1.ACC_SENSOR_SCALE for c in acc]\n gyro = [g * lsm9ds1.DPS_SENSOR_SCALE for g in gyro]\n return tempf, acc, gyro", "def get_temperature(self):\n \n # Get temp readings from both sensors\n humidity_temp = self._sense_hat.get_temperature_from_humidity()\n pressure_temp = self._sense_hat.get_temperature_from_pressure()\n \n # avg_temp becomes the average of the temperatures from both sensors\n # We need to check for pressure_temp value is not 0, to not ruin avg_temp calculation\n avg_temp = (humidity_temp + pressure_temp) / 2 if pressure_temp else humidity_temp\n \n # Get the CPU temperature\n cpu_temp = self._get_cpu_temp()\n \n # Calculate temperature compensating for CPU heating\n adj_temp = avg_temp - (cpu_temp - avg_temp) / 1.5\n \n # Average out value across the last three readings\n return self._get_smooth(adj_temp)", "def get_data():\n loopstate = get_loopstate()\n loudness = grovepi.analogRead(LOUDNESS_SENSOR)\n [temp, hum] = grovepi.dht(TEMP_HUM_SENSOR, module_type=0)\n return [loopstate, loudness, temp, hum]", "async def get_temperatures(self, **kwargs: Any) -> Dict[str, float]:\n ...", "def get_temperature(self):\n return self.ipcon.send_request(self, BrickletBarometerV2.FUNCTION_GET_TEMPERATURE, (), '', 'i')", "def get_temperature_sensor(self) -> Tuple[str, int]:\n self.serial.write(b\"t!\")\n temp_sensor = self.__read_response(1)[0]\n if temp_sensor[0:3] == b\"!th\":\n temp_sensor = self.__extract_int(temp_sensor, b\"!th\")\n # if we get 65536, the sensor is not connected\n if temp_sensor == 65535:\n raise CloudWatcherException(\n \"High precision RHEL/temp sensor not connected\"\n )\n return \"th\", temp_sensor\n else:\n temp_sensor = self.__extract_int(temp_sensor, b\"!t\")\n # if we get 100, the sensor is not connected\n if temp_sensor == 100:\n raise CloudWatcherException(\n \"Low precision RHEL/temp sensor not connected\"\n )\n return \"t\", temp_sensor", "def raw_sensor_temp(self):\n\n # return the value in millicelsius\n return float(self.raw_sensor_strings[1].split(\"=\")[1])", "def humidity(self):\r\n self._read_temperature()\r\n hum = self._read_register(_BME280_REGISTER_HUMIDDATA, 2)\r\n #print(\"Humidity data: \", hum)\r\n adc = float(hum[0] << 8 | hum[1])\r\n #print(\"adc:\", adc)\r\n\r\n # Algorithm from the BME280 driver\r\n # https://github.com/BoschSensortec/BME280_driver/blob/master/bme280.c\r\n var1 = float(self._t_fine) - 76800.0\r\n #print(\"var1 \", var1)\r\n var2 = (self._humidity_calib[3] * 64.0 + (self._humidity_calib[4] / 16384.0) * var1)\r\n #print(\"var2 \",var2)\r\n var3 = adc - var2\r\n #print(\"var3 \",var3)\r\n var4 = self._humidity_calib[1] / 65536.0\r\n #print(\"var4 \",var4)\r\n var5 = (1.0 + (self._humidity_calib[2] / 67108864.0) * var1)\r\n #print(\"var5 \",var5)\r\n var6 = 1.0 + (self._humidity_calib[5] / 67108864.0) * var1 * var5\r\n #print(\"var6 \",var6)\r\n var6 = var3 * var4 * (var5 * var6)\r\n humidity = var6 * (1.0 - self._humidity_calib[0] * var6 / 524288.0)\r\n\r\n if humidity > _BME280_HUMIDITY_MAX:\r\n return _BME280_HUMIDITY_MAX\r\n if humidity < _BME280_HUMIDITY_MIN:\r\n return _BME280_HUMIDITY_MIN\r\n # else...\r\n return humidity", "def temperature() -> float:", "def temp_series(smhi_data):\n consumable_data = {\n \"station\": smhi_data[\"station\"][\"name\"],\n \"temp\": [],\n \"from\": smhi_data[\"value\"][0][\"date\"],\n \"to\": smhi_data[\"value\"][-1][\"date\"]\n }\n for temp_post in smhi_data[\"value\"]:\n consumable_data[\"temp\"].append(float(temp_post[\"value\"]))\n return consumable_data", "def get_temperature(self):\n pass", "def get_brightnesstemperature(self, channel):\n K1 = {\n \"10\": 3040.136402, # Constant K1 [W m-2 um-1].\n \"11\": 2482.375199,\n \"12\": 1935.060183,\n \"13\": 866.468575,\n \"14\": 641.326517,\n }\n\n K2 = {\n \"10\": 1735.337945, # Constant K2 [K].\n \"11\": 1666.398761,\n \"12\": 1585.420044,\n \"13\": 1350.069147,\n \"14\": 1271.221673,\n }\n\n return K2[channel] / np.log((K1[channel] / self.get_radiance(channel)) + 1)", "def get_temperature(self, sensor: int = 0) -> float:\n\n return self.send(self.cmd.GET_HEATING_ACT)", "def getHourlyTemp(self, keyword, scale):\n\n\t\tweather_data = self.getHourlyWeatherFromCSV(keyword, scale, \"temperature\")\n\t\ttemp_values = [] # Array that will contain all the temperature data\n\t\ttemp_data = {} # Dictionary of temperature data\n\n\t\t# Getting temperature data\n\t\tfor data in weather_data:\n\t\t\ttemp_data[\"x\"] = self.helper.getDateInEpoch(data[\"date\"])\n\t\t\ttemp_data[\"y\"] = float(data[\"temperature\"].split(\"°\")[0].split(\" \")[0])\n\t\t\ttemp_values.append(temp_data)\n\t\t\ttemp_data = {}\n\n\t\treturn temp_values", "def temperature_sensor():\n\n\tsensor_name = \"humiture\"\n\treg_addr = 26\n\tdata_len = 4\n\tregist_sensor(sensor_name, reg_addr, data_len)\n\n\t# get sensor data\n\tdata = rospy.wait_for_message('MediumSize/SensorHub/Temperature', Temperature, 2)\n\ttemperature = data.temperature\n\n\tdelete_sensor(sensor_name)\n\treturn temperature", "def get_temperature(self, sensor):\n if sensor >= self.num_temperatures or sensor < 0:\n raise I2CException('Illegal sensor index {} specified'.format(sensor))\n\n return self.__temperature_values[sensor]", "def getTemperatureMeasurements(self):\n # self.board.readline()\n self.stop = False\n times = []\n temps = [[], [], []]\n \n # A synchronisation string containing the characters tx is sent before each set of measurements,\n # we ensure correct reading of the measurements by waiting for this string\n while str(self.board.readline()).strip('b\\'\\\\rn') != 'tx':\n pass\n \n while not self.stop:\n # A synchronisation string containing the characters tx is sent before each set of measurements\n tx = self.board.readline()\n if str(tx).strip('b\\'\\\\rn') == 'tx':\n rawData1 = self.board.readline()\n rawData2 = self.board.readline()\n rawData3 = self.board.readline()\n rawData4 = self.board.readline()\n \n \n timeStamp = str(rawData1).strip('b\\'\\\\rn')\n temp1 = str(rawData2).strip('b\\'\\\\rn')\n temp2 = str(rawData3).strip('b\\'\\\\rn')\n temp3 = str(rawData4).strip('b\\'\\\\rn')\n try:\n times.append(float(timeStamp) / 1000)\n temps[0].append(float(temp1) / 128)\n temps[1].append(float(temp2) / 128)\n temps[2].append(float(temp3) / 128)\n # print(f'\\rtime: {float(timeStamp) / 1000:.2f} s, Temperature measured on sensor 1: {float(temp1) / 128:.2f} °C,'\n # f'sensor 2: {float(temp2) / 128:.2f} °C, sensor 3: {float(temp3) / 128:.2f} °C', sep='', end='', flush=True)\n except:\n print(rawData1, rawData2, rawData3, rawData4)\n \n \n if self.stop:\n print('\\nMeasurement finished...')\n \n self.data_stack[self.fetch_kinds[0]] = times\n self.data_stack[self.fetch_kinds[1]] = temps[0]\n self.data_stack[self.fetch_kinds[2]] = temps[1]\n self.data_stack[self.fetch_kinds[3]] = temps[2]\n \n if (len(self.data_stack['Sensor 1 Temp']) != len(times) or len(self.data_stack['Sensor 2 Temp']) != len(times) or len(self.data_stack['Sensor 3 Temp']) != len(times)):\n print(\"Warning: There may be some missing values!\")", "def get_data(self):\n return DataGatherer().get_temperature_data()", "def getHourlyHumidity(self, keyword):\n\n\t\tweather_data = self.getHourlyWeatherFromCSV(keyword, \"f\", \"humidity\")\n\t\thumidity_values = [] # Array that will contain all the humidity data\n\t\thumidity_data = {} # Dictionary of humidity data\n\n\t\t# Getting humidity data\n\t\tfor data in weather_data:\n\t\t\thumidity_data[\"x\"] = self.helper.getDateInEpoch(data[\"date\"])\n\t\t\thumidity_data[\"y\"] = float(data[\"humidity\"][:-1])/100\n\t\t\thumidity_values.append(humidity_data)\n\t\t\thumidity_data = {}\n\n\t\treturn humidity_values", "def temperature() -> FlowFieldVal:\n return [\n self._t_s - self._delta_t * tf.math.tanh(z / self._height) for z in zz\n ]", "def get_ft_sensor_data(self):\r\n return self._arm.get_ft_sensor_data()", "def updateTempSensorValues(self):\n # Look through each temperature sensor\n for hw_sensor in self.t_sensors:\n # Grab the serial number for the sensor\n try:\n sensor_serial = hw_sensor.returnSerial()\n except:\n return\n # Look through the entries in the dictionary\n try:\n for sensor_type, sensor_entries in self.ard_dictionary.items():\n for name, sensor_dict in sensor_entries.items():\n # Within each entry, look at the name and value\n for attribute, value in sensor_dict.items():\n # If the serial number value matches the one in the \n # hw_sensor, then update the hw_sensor value\n if value == sensor_serial:\n hw_sensor.cur_temp = sensor_dict['value']\n except:\n return", "def read_tph(self):\n resultsTPH = [ 0.0, 0.0, 0.0 ]\n\n self._force_read(False)\n\n tempADC = (self._read_register_1ubyte(self.BME680_TEMP_MSB) << 12) | (self._read_register_1ubyte(self.BME680_TEMP_LSB) << 4) | (self._read_register_1ubyte(self.BME680_TEMP_XLSB) >> 4)\n presADC = (self._read_register_1ubyte(self.BME680_PRESS_MSB) << 12) | (self._read_register_1ubyte(self.BME680_PRESS_LSB) << 4) | (self._read_register_1ubyte(self.BME680_PRESS_XLSB) >> 4)\n humADC = (self._read_register_1ubyte(self.BME680_HUM_MSB) << 8) | (self._read_register_1ubyte(self.BME680_HUM_LSB))\n\n resultsTPH[0] = float(self._compensate_temperature(tempADC))\n resultsTPH[1] = float(self._compensate_pressure(presADC))\n resultsTPH[2] = float(self._compensate_humidity(humADC))\n\n return resultsTPH", "def temperature(self):\n done, data = self._request('GP')\n if done:\n return {\n 'ds3231temp': float(data[0])/10,\n 'mcp9808temp': float(data[1])/10,\n 'tmp007temp': float(data[2])/10\n }\n\n raise EvseError", "def get_temperature(self):\n summary = \" \".join(self.get_summary().split())\n pattern = '\\$.... .. .*? .*? (.*?) .*? .*? . .*? .*? . . . .*?'\n temperature = float(re.findall(pattern,summary).pop())\n return temperature", "def temperatures(self):\r\n return self._arm.temperatures", "def _get_temperatures_vaĺues(self, _dict):\n temp = None\n temp_max = None\n temp_min = None\n\n if _dict.get(\"temp\"):\n temp = int(round(_dict.get(\"temp\")))\n if _dict.get(\"day\"):\n temp = int(round(_dict.get(\"day\")))\n if _dict.get(\"min\"):\n temp_min = int(round(_dict.get(\"min\")))\n if _dict.get(\"temp_min\"):\n temp_min = int(round(_dict.get(\"temp_min\")))\n if _dict.get(\"max\"):\n temp_max = int(round(_dict.get(\"max\")))\n if _dict.get(\"temp_max\"):\n temp_max = int(round(_dict.get(\"temp_max\")))\n\n return temp, temp_max, temp_min", "def get_temps(self):\n try:\n cmos = self.cmos_temp\n except Exception:\n cmos = None\n try:\n pcb = self.pcb_temp\n except Exception:\n pcb = None\n return cmos, pcb" ]

[ "0.71954936", "0.71794486", "0.69512266", "0.68936956", "0.67637795", "0.6748177", "0.66847765", "0.66613424", "0.66547906", "0.6625184", "0.6584921", "0.6561356", "0.65596384", "0.655392", "0.6550401", "0.6500118", "0.6472888", "0.6423746", "0.642214", "0.6420399", "0.64096564", "0.6403401", "0.6393891", "0.6390154", "0.6386354", "0.63785064", "0.6361245", "0.63549757", "0.6344205", "0.63391495" ]

[ "def _mean(listvalue):\n\treturn sum(listvalue)/len(listvalue)", "def get_thb_mean_values(self, value_list):\n if not len(value_list):\n return None, None, None, None, None\n\n temp, hum, dew, baro, forecast, sealevel = map(list, zip(*value_list))\n return (\n round(statistics.mean(temp), 1),\n int(round(statistics.mean(hum), 0)),\n round(statistics.mean(dew), 1),\n round(statistics.mean(baro), 1),\n round(statistics.mean(sealevel), 1),\n )", "def get_t_mean_value(self, value_list):\n if not len(value_list):\n return None\n else:\n return round(statistics.mean(value_list), 1)", "def mean(list_of_values):\r\n # Explicit float(...) to allow for Python 2 division.\r\n return sum(list_of_values) / float(len(list_of_values))", "def mean(vals):", "def mean_value( values ):\n return sum( values ) / len( values )", "def mean(values):\r\n return sum(values) / float(len(values))", "def mean(values):\n # Write the mean() function\n mean = sum(values) / len(values)\n return mean", "def find_mean(values):\n mean = sum(values) / len(values)\n return mean", "def mean(values):\n # Write the mean() function\n mean = sum(values) / len(values)\n return mean", "def find_mean(values):\n return sum(values) / len(values)", "def get_mean(numlist):\n return np.mean(numlist)", "def mean(self, values):\n return self.aggregate(values, \"mean\")", "def mean(values):\n total = sum(values)\n len_values = len(values)\n return total/len_values", "def CalculateListAverage(values):\n if not values:\n return 0\n return sum(values) / float(len(values))", "def mean(list_of_values):\n # so don't have to worry about getting the divisor.\n # Explicit float(...) to allow for Python 2 division.\n try:\n mean = sum(list_of_values) / float(len(list_of_values))\n return mean\n except:\n return False", "def mean(num_list):\n i = 0\n num_sum = 0.0\n for item in num_list:\n num_sum += item\n i += 1\n return num_sum/i", "def get_sol_mean_value(self, value_list):\n if len(value_list):\n return int(round(statistics.mean(value_list), 0))\n else:\n return None", "def list_mean(lst):\n return list_sum(lst) / len(lst)", "def getMean(list):\n return sum(list) / len(list)", "def mean_list(data):\n return sum(data) / len(data)", "def avg(values):\n return sum(values) / float(len(values))", "def average(values):\n\treturn sum(values)/len(values)", "def mean(numbers):\n return float(sum(numbers)) / float(len(numbers))", "def averaged(*values):\n values = [_normalize(v) for v in values]\n for v in zip(*values):\n yield mean(v)", "def mean(my_list):\n the_mean = sum(my_list) / len(my_list)\n return the_mean", "def get_mean(self):\n self.meanval = np.mean(self.adulist)", "def get_uv_mean_value(self, value_list):\n if len(value_list):\n return int(round(statistics.mean(value_list), 0))\n else:\n return None", "def average(values):\n return sum(values) / len(values)", "def average(values):\n return sum(values) / len(values)" ]

[ "0.8034713", "0.7950179", "0.7874193", "0.785855", "0.78545845", "0.7767807", "0.7683209", "0.7574799", "0.75705093", "0.7557271", "0.74656934", "0.7425457", "0.7381087", "0.73020715", "0.7276637", "0.7194838", "0.7187722", "0.7095684", "0.70814633", "0.70770663", "0.7069976", "0.7038577", "0.70051515", "0.69966704", "0.6988877", "0.6988131", "0.69407916", "0.6889051", "0.6857567", "0.6857567" ]

[ "def wind_speed(self):\n names = ['anc_mean_wind_speed']\n return self.sensor.get_with_fallback('wind_speed', names)", "def get_sensors_data(self):\n\n temp_in_celsius = self.get_temperature()\n\n return (\n round(temp_in_celsius, 1), \n round(self.to_fahrenheit(temp_in_celsius), 1), \n round(self.get_humidity(), 0), \n round(self.get_pressure(), 1)\n )", "def get_data(self):\n return DataGatherer().get_wind_data()", "def get_wind_mean_values(self, value_list):\n if not len(value_list):\n return None, None, None, None\n\n dir, gust, avg, chill = map(list, zip(*value_list))\n return (\n int(round(statistics.mean(dir), 0)),\n round(statistics.mean(gust), 1),\n round(statistics.mean(avg), 1),\n round(statistics.mean(chill), 1),\n )", "def get_wind_sensor(self) -> int:\n self.serial.write(b\"V!\")\n wind_sensor = self.__extract_int(self.__read_response(1)[0], b\"!w\")\n\n return wind_sensor", "def read_values(self):\n temp, acc, gyro = self.read_ag_data()\n tempc = lsm9ds1.TEMPC_0 + temp * lsm9ds1.TEMP_SENSOR_SCALE\n tempf = (tempc * 9/5) + 32\n acc = [c * lsm9ds1.ACC_SENSOR_SCALE for c in acc]\n gyro = [g * lsm9ds1.DPS_SENSOR_SCALE for g in gyro]\n return tempf, acc, gyro", "def wind_speed(self):\r\n return self._yesterdays_weather.get_average_wind_speed()", "def getHourlyWind(self, keyword):\n\n\t\tweather_data = self.getHourlyWeatherFromCSV(keyword, \"f\", \"wind\")\n\t\twind_values = [] # Array that will contain all the wind data\n\t\twind_data = {} # Dictionary of wind data\n\n\t\t# Getting humidity data\n\t\tfor data in weather_data:\n\t\t\twind_data[\"x\"] = self.helper.getDateInEpoch(data[\"date\"])\n\t\t\twind_data[\"y\"] = float(data[\"wind\"].split(\" \")[1])\n\t\t\twind_values.append(wind_data)\n\t\t\twind_data = {}\n\n\t\treturn wind_values", "def wind(self):\n return self._wind", "def get_rain_values(self):\n return float(self.data[2]) / 10, float(self.data[4]) / 10", "def extract_wind(source,la,lo,lats,lons,wd,ws):\r\n lat = source[la]\r\n lon = source[lo]\r\n wdir = []\r\n wspd = [] \r\n for coor in zip(lon,lat): \r\n in_lon = coor[0]\r\n in_lat = coor[1]\r\n # since lons are 0 thru 360, convert to -180 thru 180\r\n converted_lons = lons - ( lons.astype(np.int32) / 180) * 360\r\n # get cell of facility\r\n lat_idx = geo_idx(in_lat, lats)\r\n lon_idx = geo_idx(in_lon, converted_lons)\r\n #extract winddirection and wind speed from that cell\r\n d = wd[:,lat_idx,lon_idx][0]\r\n wdir.append(d)\r\n s = ws[:,lat_idx,lon_idx][0]\r\n wspd.append(s)\r\n \r\n return wdir,wspd", "def wind_direction(self):\n names = ['anc_wind_direction']\n return self.sensor.get_with_fallback('wind_direction', names)", "def GetParameters_and_Weight_of_CalSensor(ind, similar_sensors): \n v, a, h = similar_sensors.loc[ind]['Vert_Shift'], similar_sensors.loc[ind]['Amplitude'], similar_sensors.loc[ind]['Horiz_Shift']\n por, res, drain = similar_sensors.loc[ind]['Porosity'], similar_sensors.loc[ind]['Res_SM'], similar_sensors.loc[ind]['Drainage']\n n, w = similar_sensors.loc[ind]['n'], similar_sensors.loc[ind]['Weight']\n return v,a,h,por,res,drain,n,w", "def get_data():\n loopstate = get_loopstate()\n loudness = grovepi.analogRead(LOUDNESS_SENSOR)\n [temp, hum] = grovepi.dht(TEMP_HUM_SENSOR, module_type=0)\n return [loopstate, loudness, temp, hum]", "def getSensors(self):\n return [float(self.current_state),]", "def wind_meta(self):\n return self.data.wind_meta", "def get_vwind(self):\n return self.read_register(4100, 1, 3)", "def temperatures():\n\n return station_9281", "def get_windtspeed(self):\n return self.read_register(4111, 0, 3)", "def get_wind():\n return get_next_random(wind, WIND_MAX, WIND_MIN, WIND_DELTA)", "def READ_PRESSURE_SENSOR():\n return 15.246", "def extract_wind_information(quantities):\n # From quantities filter to just sentences that have wind or winds in them\n wind_sents = eh.filter_to_relevant_sentences(['wind', 'winds'], quantities)\n\n # Collect units from these sentences that are in terms of speed (put in speeds list)\n speed_units = ['mph', 'miles per hour', 'kph', 'kilometers per hour']\n speeds = eh.extract_spacy_tag(wind_sents, 'QUANTITY')\n correct_unit_speeds = list(filter(lambda s: any(word in s for word in speed_units), speeds))\n converted_speeds = list(map(lambda s: eh.convert_to_mph(s), correct_unit_speeds))\n\n # Throw out low numbers as even category 1 hurricanes have winds more than 70 mph\n higher_speeds = list(filter(lambda x: x > 40, converted_speeds))\n wind_speed_mean = numpy.mean(higher_speeds)\n wind_speed_std = numpy.std(higher_speeds)\n return int(wind_speed_mean - wind_speed_std), int(wind_speed_mean + wind_speed_std), int(wind_speed_mean)", "def windspeed(self):\r\n try:\r\n return str(self.connect()['wind']['speed'])\r\n except:\r\n return '@weather_windspeed'", "def getSensors(self):\n sensors = array([])\n sensors = r_[sensors, self._getTotalDemandSensor()]\n# sensors = r_[sensors, self._getDemandSensor()]\n# sensors = r_[sensors, self._getPriceSensor()]\n\n# sensors = r_[sensors, self._getBusVoltageSensor()]\n\n# sensors = r_[sensors, self._getBusVoltageMagnitudeSensor()]\n# sensors = r_[sensors, self._getBusVoltageLambdaSensor()]\n# sensors = r_[sensors, self._getBranchFlowSensor()]\n\n# logger.info(\"State: %s\" % sensors)\n\n return sensors", "def native_wind_speed(self) -> float:\r\n return self._first_timeserie[\"data\"][\"instant\"][\"details\"][\"wind_speed\"]", "def windSpeed(self, json, units):\n windSpeed = str(json['forecast']['simpleforecast']['forecastday'][0]['avewind'][units])\n return windSpeed", "def wind_bearing(self) -> float:\r\n return self._first_timeserie[\"data\"][\"instant\"][\"details\"][\r\n \"wind_from_direction\"\r\n ]", "def raw_sensor_temp(self):\n\n # return the value in millicelsius\n return float(self.raw_sensor_strings[1].split(\"=\")[1])", "def decode_wind(buf):\n data = {}\n if DEBUG_DECODE:\n logdbg(\"WGS BUF[25]=%02x BUF[26]=%02x\" % (buf[25], buf[26]))\n if bcd2int(buf[25] & 0xf0) > 90 or bcd2int(buf[25] & 0x0f) > 9:\n if buf[25] == 0xbb and buf[26] == 0x8b:\n data['windgust_state'] = STATE_OUT_OF_RANGE\n elif buf[25] == 0xee and buf[26] == 0x8e:\n data['windgust_state'] = STATE_MISSING_LINK\n else:\n data['windgust_state'] = STATE_ERROR\n data['windgust'] = None\n else:\n data['windgust_state'] = STATE_OK\n offset = 100 if buf[26] & 0x10 == 0x10 else 0\n data['windgust'] = bcd2int(buf[25]) / 10.0 \\\n + bcd2int(buf[26] & 0x0f) * 10.0 \\\n + offset\n if DEBUG_DECODE:\n logdbg(\"WGS %s %s\" % (data['windgust'], data['windgust_state']))\n\n if DEBUG_DECODE:\n logdbg(\"WSP BUF[27]=%02x BUF[28]=%02x\" % (buf[27], buf[28]))\n if bcd2int(buf[27] & 0xf0) > 90 or bcd2int(buf[27] & 0x0f) > 9:\n if buf[27] == 0xbb and buf[28] == 0x8b:\n data['windspeed_state'] = STATE_OUT_OF_RANGE\n elif buf[27] == 0xee and buf[28] == 0x8e:\n data['windspeed_state'] = STATE_MISSING_LINK\n else:\n data['windspeed_state'] = STATE_ERROR\n data['windspeed'] = None\n else:\n data['windspeed_state'] = STATE_OK\n offset = 100 if buf[28] & 0x10 == 0x10 else 0\n data['windspeed'] = bcd2int(buf[27]) / 10.0 \\\n + bcd2int(buf[28] & 0x0f) * 10.0 \\\n + offset\n if DEBUG_DECODE:\n logdbg(\"WSP %s %s\" % (data['windspeed'], data['windspeed_state']))\n\n if DEBUG_DECODE:\n logdbg(\"WDR BUF[29]=%02x\" % buf[29])\n if data['windspeed_state'] == STATE_MISSING_LINK:\n data['winddir_state'] = data['windspeed_state']\n data['winddir'] = None\n else:\n data['winddir_state'] = STATE_OK\n data['winddir'] = int(buf[29] & 0x0f)\n if DEBUG_DECODE:\n logdbg(\"WDR %s %s\" % (data['winddir'], data['winddir_state']))\n \n return data", "def read_core_vbat(self) -> float:" ]

[ "0.70536834", "0.6606275", "0.6605308", "0.66043174", "0.6554906", "0.652577", "0.6509941", "0.64786017", "0.64461035", "0.6393536", "0.62955326", "0.6292042", "0.6269706", "0.6226568", "0.6199306", "0.6139651", "0.6106034", "0.6064414", "0.60123414", "0.5982694", "0.59728", "0.5943818", "0.59289414", "0.5895386", "0.5868576", "0.58605087", "0.5845354", "0.5842311", "0.58284605", "0.57818115" ]

[ "def mean(list_of_values):\r\n # Explicit float(...) to allow for Python 2 division.\r\n return sum(list_of_values) / float(len(list_of_values))", "def get_rain_mean_values(self, value_list):\n if not len(value_list):\n return None, None\n\n rate, total = map(list, zip(*value_list))\n rain = round(total[-1] - total[0], 1)\n\n # Rain can't be negative and in january many rain sensors are\n # resetted to 0 which leads to negative values\n if rain < 0:\n rain = 0.0\n return round(statistics.mean(rate)), rain", "def _mean(listvalue):\n\treturn sum(listvalue)/len(listvalue)", "def get_th_mean_values(self, value_list):\n if not len(value_list):\n return None, None, None\n t, h, d = map(list, zip(*value_list))\n return (\n round(statistics.mean(t), 1),\n int(round(statistics.mean(h), 0)),\n round(statistics.mean(d), 1),\n )", "def get_thb_mean_values(self, value_list):\n if not len(value_list):\n return None, None, None, None, None\n\n temp, hum, dew, baro, forecast, sealevel = map(list, zip(*value_list))\n return (\n round(statistics.mean(temp), 1),\n int(round(statistics.mean(hum), 0)),\n round(statistics.mean(dew), 1),\n round(statistics.mean(baro), 1),\n round(statistics.mean(sealevel), 1),\n )", "def mean(vals):", "def mean_value( values ):\n return sum( values ) / len( values )", "def mean(values):\r\n return sum(values) / float(len(values))", "def get_sol_mean_value(self, value_list):\n if len(value_list):\n return int(round(statistics.mean(value_list), 0))\n else:\n return None", "def find_mean(values):\n mean = sum(values) / len(values)\n return mean", "def CalculateListAverage(values):\n if not values:\n return 0\n return sum(values) / float(len(values))", "def get_mean(numlist):\n return np.mean(numlist)", "def mean(values):\n # Write the mean() function\n mean = sum(values) / len(values)\n return mean", "def mean(values):\n # Write the mean() function\n mean = sum(values) / len(values)\n return mean", "def mean(list_of_values):\n # so don't have to worry about getting the divisor.\n # Explicit float(...) to allow for Python 2 division.\n try:\n mean = sum(list_of_values) / float(len(list_of_values))\n return mean\n except:\n return False", "def geo_mean(num_list):\n np_array = np.array(num_list)\n return np_array.prod() ** (1.0 / len(np_array))", "def find_mean(values):\n return sum(values) / len(values)", "def mean(self, values):\n return self.aggregate(values, \"mean\")", "def calculate_mean(weather_data):\n sum_value=0\n\n for value in weather_data:\n sum_value += float(value)\n \n mean = sum_value/len(weather_data)\n\n return (mean)", "def get_t_mean_value(self, value_list):\n if not len(value_list):\n return None\n else:\n return round(statistics.mean(value_list), 1)", "def mean(num_list):\n i = 0\n num_sum = 0.0\n for item in num_list:\n num_sum += item\n i += 1\n return num_sum/i", "def mean(my_list):\n the_mean = sum(my_list) / len(my_list)\n return the_mean", "def get_uv_mean_value(self, value_list):\n if len(value_list):\n return int(round(statistics.mean(value_list), 0))\n else:\n return None", "def mean(values):\n total = sum(values)\n len_values = len(values)\n return total/len_values", "def get_mean(self):\n self.meanval = np.mean(self.adulist)", "def getMean(list):\n return sum(list) / len(list)", "def averaged(*values):\n values = [_normalize(v) for v in values]\n for v in zip(*values):\n yield mean(v)", "def weighted_average(listofvalues):\n total = 0\n weights = 0\n for [w, v] in listofvalues:\n total += w*v\n weights += w\n return total/weights", "def average(values):\n\treturn sum(values)/len(values)", "def avg(values):\n return sum(values) / float(len(values))" ]

[ "0.7609455", "0.75113475", "0.7445969", "0.7359098", "0.7183681", "0.7170421", "0.7114486", "0.7094264", "0.7062167", "0.7044667", "0.7039881", "0.7026979", "0.70164853", "0.6987465", "0.69849795", "0.6969095", "0.69474036", "0.69014347", "0.6857735", "0.68284947", "0.6737842", "0.6735228", "0.6713244", "0.670503", "0.6699179", "0.6668727", "0.6668171", "0.66178423", "0.65744036", "0.65408695" ]

[ "def _mean(listvalue):\n\treturn sum(listvalue)/len(listvalue)", "def mean(list_of_values):\r\n # Explicit float(...) to allow for Python 2 division.\r\n return sum(list_of_values) / float(len(list_of_values))", "def mean_value( values ):\n return sum( values ) / len( values )", "def mean(vals):", "def find_mean(values):\n mean = sum(values) / len(values)\n return mean", "def get_mean(numlist):\n return np.mean(numlist)", "def mean(values):\r\n return sum(values) / float(len(values))", "def find_mean(values):\n return sum(values) / len(values)", "def get_mean(self):\n self.meanval = np.mean(self.adulist)", "def CalculateListAverage(values):\n if not values:\n return 0\n return sum(values) / float(len(values))", "def get_uv_mean_value(self, value_list):\n if len(value_list):\n return int(round(statistics.mean(value_list), 0))\n else:\n return None", "def mean(list_of_values):\n # so don't have to worry about getting the divisor.\n # Explicit float(...) to allow for Python 2 division.\n try:\n mean = sum(list_of_values) / float(len(list_of_values))\n return mean\n except:\n return False", "def mean_square_value( values ):\n return sum( [ i**2 for i in values] ) / len( values )", "def mean(values):\n # Write the mean() function\n mean = sum(values) / len(values)\n return mean", "def mean(values):\n # Write the mean() function\n mean = sum(values) / len(values)\n return mean", "def mean(self, values):\n return self.aggregate(values, \"mean\")", "def get_t_mean_value(self, value_list):\n if not len(value_list):\n return None\n else:\n return round(statistics.mean(value_list), 1)", "def mean(num_list):\n i = 0\n num_sum = 0.0\n for item in num_list:\n num_sum += item\n i += 1\n return num_sum/i", "def getMean(list):\n return sum(list) / len(list)", "def mean(my_list):\n the_mean = sum(my_list) / len(my_list)\n return the_mean", "def mean(values):\n total = sum(values)\n len_values = len(values)\n return total/len_values", "def get_wind_mean_values(self, value_list):\n if not len(value_list):\n return None, None, None, None\n\n dir, gust, avg, chill = map(list, zip(*value_list))\n return (\n int(round(statistics.mean(dir), 0)),\n round(statistics.mean(gust), 1),\n round(statistics.mean(avg), 1),\n round(statistics.mean(chill), 1),\n )", "def get_th_mean_values(self, value_list):\n if not len(value_list):\n return None, None, None\n t, h, d = map(list, zip(*value_list))\n return (\n round(statistics.mean(t), 1),\n int(round(statistics.mean(h), 0)),\n round(statistics.mean(d), 1),\n )", "def mean_stat(list):\n answer = 0 #Final value\n count = 0 #number of values\n\n ##Mean calculation\n for item in list:\n answer += item\n count +=1\n\n if(answer == 0):\n answer = \"List is Empty\"\n return answer\n else:\n answer = answer/count\n return answer", "def lmean (inlist):\r\n sum = 0\r\n for item in inlist:\r\n sum = sum + item\r\n return sum/float(len(inlist))", "def avg(values):\n return sum(values) / float(len(values))", "def geo_mean(num_list):\n np_array = np.array(num_list)\n return np_array.prod() ** (1.0 / len(np_array))", "def mean(numbers):\n return float(sum(numbers)) / float(len(numbers))", "def mean_list(data):\n return sum(data) / len(data)", "def list_mean(lst):\n return list_sum(lst) / len(lst)" ]

[ "0.77464134", "0.76582295", "0.74594337", "0.74359584", "0.7278", "0.7259888", "0.72362965", "0.7208554", "0.7151343", "0.70732075", "0.70670736", "0.69791293", "0.6977969", "0.69734216", "0.6966683", "0.6957543", "0.69306076", "0.6917578", "0.68614304", "0.6828481", "0.67620593", "0.6749778", "0.67379665", "0.6736927", "0.6711442", "0.6696069", "0.66940373", "0.66924137", "0.6623829", "0.66114956" ]

[ "def getUVIndex(self):\n\t\tval = grovepi.analogRead(self.uv_sensor)\n\t\tillumination_intensity = val*307\n\t\tuv_index = illumination_intensity/float(200)\n\t\treturn uv_index", "def read_uv(self):\n return self._read16(0x2C, little_endian=True) / 100", "def get_value(self):\n return self.sensor.get_value()", "def read_actual_voltage(self):\n function_string = 'V' + self.output + 'O?'\n value_string = self.scpi_comm(function_string)\n LOGGER.warn(value_string)\n time.sleep(0.1) # This might only be necessary on LAN interface\n try:\n value = float(value_string.replace('V', ''))\n except ValueError:\n value = -999999\n return value", "def native_value(self):\n return self.mon.data[\"temp\"]", "def get_u_value(self, observation: BlackjackObservation) -> float:\n state = self.create_state3(observation)\n\n return self.U[state]", "def raw_sensor_temp(self):\n\n # return the value in millicelsius\n return float(self.raw_sensor_strings[1].split(\"=\")[1])", "def get_voltage(self):\n status = self.get_status_response()\n volts = status[20] + (status[21] * 0x100) + (status[22] * 0x10000) + (status[23] * 0x1000000)\n volts = float(volts)\n volts /= (1000.0 * 1000.0)\n return volts\n #end get_voltage", "def read_core_vbat(self) -> float:", "def READ_PRESSURE_SENSOR():\n return 15.246", "def _value(self):\n return self.device.value(*self._id[1:])", "def uv_at_xy(self, x, y, x0, y0, s0):\n dx, dy = self.distance(x0, y0, x, y)\n #print 'dx, dy:', dx, dy\n rr2 = (dx**2 + dy**2)**-1\n u = - s0 * dy * r_twopi * rr2\n v = s0 * dx * r_twopi * rr2\n #print 'u, v', u, v\n return u, v", "def get_vbat(self):\n return self.read_register(4096, 1, 3)", "def raw_value(self):\n if self.__trigger == gyro_trigger_mode.GET_RAW_VALUE_TRIGGER_READ:\n self.read_and_update_angle()\n return self.__value", "def to_real(self):\n return _uhd_swig.sensor_value_t_to_real(self)", "def native_value(self):\n return self.temperature", "def read_set_voltage(self):\n function_string = 'V' + self.output + '?'\n value_string = self.scpi_comm(function_string)\n try:\n value = float(value_string.replace('V' + self.output, ''))\n except ValueError:\n value = -9997\n return value", "def value(self) -> float:", "def get_value(self) -> float:\n return self.points[0, 0]", "def read_sensor_raw(self):\n return self.read_sensor()", "def read_sensor_raw(self):\n return self.read_sensor()", "def raw(self):\n return float(self.uw.send(self.name + '.val')[0])", "def get_volt(data):\n volt = (data * 5.0) / 255\n #volt = round(volt, 1)\n return volt", "def value(self) -> pulumi.Input[float]:\n return pulumi.get(self, \"value\")", "def read_vref(self) -> float:", "def read_voltage(self):\n self.write(':FETC?')\n msg = self.read()\n #print ('dmm msg = ', msg)\n v = msg.split(',')[0].rstrip('NVDC').strip()\n if v[-1] == 'R':\n return float(v[:-1])\n else:\n return float(v)", "def point(self, uv):\n pt = self.surface().Value(uv[0], uv[1])\n return geom_utils.gp_to_numpy(pt)", "def outputValue(self):\n string = self.ask('od;E;')\n string = re.sub(r'^(NDCV|NDCA|EDCV)', r'', string)\n self.notify('voltage', float(string))\n return float(string)", "def Get_RawOutX_Value(self):\r\n l = self.__readFromRegister(self.__REG_R_OUT_X_L, 0xff)\r\n h_u2 = self.__readFromRegister(self.__REG_R_OUT_X_H, 0xff)\r\n h = bitOps.TwosComplementToByte(h_u2)\r\n if (h < 0):\r\n return (h*256 - l) * self.gain\r\n elif (h >= 0):\r\n return (h*256 + l) * self.gain", "def wave_get_micros():\n return _u2i(_pigpio_command(_control, _PI_CMD_WVSM, 0, 0))" ]

[ "0.7297083", "0.71961826", "0.7134578", "0.6486077", "0.64282644", "0.6422018", "0.6419723", "0.64034706", "0.64009273", "0.64002705", "0.6395955", "0.6345213", "0.634253", "0.6341466", "0.6248994", "0.6207543", "0.618416", "0.61705834", "0.6160929", "0.6148105", "0.6148105", "0.6134806", "0.6118845", "0.6088897", "0.608683", "0.60766566", "0.6070751", "0.60614854", "0.60420436", "0.60303295" ]

[ "def _mean(listvalue):\n\treturn sum(listvalue)/len(listvalue)", "def mean(list_of_values):\r\n # Explicit float(...) to allow for Python 2 division.\r\n return sum(list_of_values) / float(len(list_of_values))", "def mean_value( values ):\n return sum( values ) / len( values )", "def get_sol_mean_value(self, value_list):\n if len(value_list):\n return int(round(statistics.mean(value_list), 0))\n else:\n return None", "def mean(vals):", "def get_t_mean_value(self, value_list):\n if not len(value_list):\n return None\n else:\n return round(statistics.mean(value_list), 1)", "def mean(values):\r\n return sum(values) / float(len(values))", "def find_mean(values):\n mean = sum(values) / len(values)\n return mean", "def get_mean(self):\n self.meanval = np.mean(self.adulist)", "def find_mean(values):\n return sum(values) / len(values)", "def mean(values):\n # Write the mean() function\n mean = sum(values) / len(values)\n return mean", "def mean(values):\n # Write the mean() function\n mean = sum(values) / len(values)\n return mean", "def get_mean(numlist):\n return np.mean(numlist)", "def get_th_mean_values(self, value_list):\n if not len(value_list):\n return None, None, None\n t, h, d = map(list, zip(*value_list))\n return (\n round(statistics.mean(t), 1),\n int(round(statistics.mean(h), 0)),\n round(statistics.mean(d), 1),\n )", "def CalculateListAverage(values):\n if not values:\n return 0\n return sum(values) / float(len(values))", "def mean(v):\n return sum(v)/len(v)", "def mean(list_of_values):\n # so don't have to worry about getting the divisor.\n # Explicit float(...) to allow for Python 2 division.\n try:\n mean = sum(list_of_values) / float(len(list_of_values))\n return mean\n except:\n return False", "def mean(self, values):\n return self.aggregate(values, \"mean\")", "def mean(values):\n total = sum(values)\n len_values = len(values)\n return total/len_values", "def get_thb_mean_values(self, value_list):\n if not len(value_list):\n return None, None, None, None, None\n\n temp, hum, dew, baro, forecast, sealevel = map(list, zip(*value_list))\n return (\n round(statistics.mean(temp), 1),\n int(round(statistics.mean(hum), 0)),\n round(statistics.mean(dew), 1),\n round(statistics.mean(baro), 1),\n round(statistics.mean(sealevel), 1),\n )", "def _get_u_mean(self, nodelist: List[Tuple[int, int]]) -> Optional[float]:\n meanlist = [self.u_matrix[u_node] for u_node in nodelist]\n u_mean = None\n if self.u_mean_mode_ == \"mean\":\n u_mean = np.mean(meanlist)\n elif self.u_mean_mode_ == \"median\":\n u_mean = np.median(meanlist)\n elif self.u_mean_mode_ == \"min\":\n u_mean = np.min(meanlist)\n elif self.u_mean_mode_ == \"max\":\n u_mean = np.max(meanlist)\n return u_mean", "def avg(values):\n return sum(values) / float(len(values))", "def mean_list(data):\n return sum(data) / len(data)", "def mean(num_list):\n i = 0\n num_sum = 0.0\n for item in num_list:\n num_sum += item\n i += 1\n return num_sum/i", "def get_rain_mean_values(self, value_list):\n if not len(value_list):\n return None, None\n\n rate, total = map(list, zip(*value_list))\n rain = round(total[-1] - total[0], 1)\n\n # Rain can't be negative and in january many rain sensors are\n # resetted to 0 which leads to negative values\n if rain < 0:\n rain = 0.0\n return round(statistics.mean(rate)), rain", "def action_store_mean(raw_val):\n\n if isinstance(raw_val, list):\n val_med = None\n values = []\n for val in raw_val:\n val = auto_type_convert(val)\n if isinstance(val, (int, float)):\n values.append(val)\n\n values_length = len(values)\n if values_length != 0:\n mean = sum(values)/values_length\n return mean\n else:\n return None\n else:\n return None", "def getMean(list):\n return sum(list) / len(list)", "def average(values):\n\treturn sum(values)/len(values)", "def mean_stat(list):\n answer = 0 #Final value\n count = 0 #number of values\n\n ##Mean calculation\n for item in list:\n answer += item\n count +=1\n\n if(answer == 0):\n answer = \"List is Empty\"\n return answer\n else:\n answer = answer/count\n return answer", "def mean_square_value( values ):\n return sum( [ i**2 for i in values] ) / len( values )" ]

[ "0.7751135", "0.75171626", "0.75041956", "0.7471181", "0.74531263", "0.7412795", "0.73203397", "0.7221085", "0.71762145", "0.71451473", "0.71089", "0.7086222", "0.7031144", "0.70291066", "0.7024628", "0.6963111", "0.6928992", "0.69074994", "0.69034994", "0.6855154", "0.68495584", "0.6698807", "0.66986305", "0.6697439", "0.66796887", "0.665477", "0.66497624", "0.66058254", "0.65883166", "0.65286887" ]

[ "def raw_rain_sensor_temp(self) -> int:\n self._update_analog_value_cache()\n return self.analog_cache.rain_sensor_temp", "def get_rain_mean_values(self, value_list):\n if not len(value_list):\n return None, None\n\n rate, total = map(list, zip(*value_list))\n rain = round(total[-1] - total[0], 1)\n\n # Rain can't be negative and in january many rain sensors are\n # resetted to 0 which leads to negative values\n if rain < 0:\n rain = 0.0\n return round(statistics.mean(rate)), rain", "async def rain_rate(self, value):\n if not value:\n return 0\n return await self.rain(value * 60)", "def get_rain():\n global rain\n\n # Report rain only if the condition is 'rainy' (and not always).\n if weather_condition == CONDITION_RAINY and random.random() > 0.7:\n rain += round(random.random(), 2)\n return rain", "def get_rain_frequency(self) -> int:\n self.serial.write(b\"E!\")\n rain_freq = self.__extract_int(self.__read_response(1)[0], b\"!R\")\n\n return rain_freq", "def read_values(self):\n temp, acc, gyro = self.read_ag_data()\n tempc = lsm9ds1.TEMPC_0 + temp * lsm9ds1.TEMP_SENSOR_SCALE\n tempf = (tempc * 9/5) + 32\n acc = [c * lsm9ds1.ACC_SENSOR_SCALE for c in acc]\n gyro = [g * lsm9ds1.DPS_SENSOR_SCALE for g in gyro]\n return tempf, acc, gyro", "def READ_PRESSURE_SENSOR():\n return 15.246", "def get_temp(self) -> float:\n return np.round(np.mean(self.temp_data), 1)", "def read(self):\n beats, interval_ms = self.read_raw()\n if 0 < interval_ms < 2500:\n rate = 60000.0 / interval_ms\n else:\n raise RuntimeError(\"Value out of range or device not connected.\")\n return rate", "def temperature() -> float:", "def get_wind_values(self):\n return (\n int(self.data[2]), # dir\n float(self.data[3]) / 10, # gust\n float(self.data[4]) / 10, # avg\n float(self.data[5]) / 10, # chill\n )", "def R(self):\n\t\treturn (arange(self.rbins) + 0.5) * (self.cbins - 0.5) / self.rbins", "def read_line(self):\n self.read_calibrated()\n\n avg = 0\n summ = 0\n online = False\n\n for i in range(0, self.NUM_SENSORS):\n val = self.sensorValues[i]\n if val > 500: online = True\n if val > 50:\n multiplier = i * 1000\n avg += val * multiplier\n summ += val\n\n if online == False:\n if self.lastValue < (self.NUM_SENSORS-1)*1000/2:\n return 0\n else:\n return (self.NUM_SENSORS-1)*1000\n\n self.lastValue = avg/summ\n return self.lastValue", "def _eventRs(self, phi, u):\n with np.errstate(all='ignore'):\n return 1/u[0] - self.Rs", "def value(self):\n if self.buffer:\n return np.mean([ep['r'] for ep in self.buffer])\n else:\n return 0.0", "def get_sky_ir_temperature(self) -> float:\n self.serial.write(b\"S!\")\n sky_ir_temp = self.__extract_int(self.__read_response(1)[0], b\"!1\")\n\n return round(sky_ir_temp / 100, 2)", "def raw_sensor_temp(self):\n\n # return the value in millicelsius\n return float(self.raw_sensor_strings[1].split(\"=\")[1])", "def extract_rain_information(quantities):\n # From quantities filter to just sentences that have wind or winds in them\n rain_sents = eh.filter_to_relevant_sentences(['rain'], quantities)\n\n # Collect units from these sentences that are in terms of speed (put in speeds list)\n measurement_units = ['inches', 'in', 'centimeters', 'cm']\n measurements = eh.extract_spacy_tag(rain_sents, 'QUANTITY')\n correct_unit_measurements = list(filter(lambda s: any(word in s for word in measurement_units), measurements))\n converted_measurements = list(map(lambda s: eh.convert_to_in(s), correct_unit_measurements))\n\n rain_mean = numpy.mean(converted_measurements)\n rain_std = numpy.std(converted_measurements)\n return int(rain_mean - rain_std), int(rain_mean + rain_std), int(rain_mean)", "def event_based_r_factor(self):\n # assign variables\n rain_energy = 'rain_energy'\n rain_volume = 'rain_volume'\n erosivity = 'erosivity'\n r_factor = 'r_factor'\n\n # derive rainfall energy (MJ ha^-1 mm^-1)\n gscript.run_command(\n 'r.mapcalc',\n expression=\"{rain_energy}\"\n \"=0.29*(1.-(0.72*exp(-0.05*{rain_intensity})))\".format(\n rain_energy=rain_energy,\n rain_intensity=self.rain_intensity),\n overwrite=True)\n\n # derive rainfall volume\n \"\"\"\n rainfall volume (mm)\n = rainfall intensity (mm/hr)\n * (rainfall interval (min)\n * (1 hr / 60 min))\n \"\"\"\n gscript.run_command(\n 'r.mapcalc',\n expression=\"{rain_volume}\"\n \"= {rain_intensity}\"\n \"*({rain_interval}\"\n \"/60.)\".format(\n rain_volume=rain_volume,\n rain_intensity=self.rain_intensity,\n rain_interval=self.rain_interval),\n overwrite=True)\n\n # derive event erosivity index (MJ mm ha^-1 hr^-1)\n gscript.run_command(\n 'r.mapcalc',\n expression=\"{erosivity}\"\n \"=({rain_energy}\"\n \"*{rain_volume})\"\n \"*{rain_intensity}\"\n \"*1.\".format(\n erosivity=erosivity,\n rain_energy=rain_energy,\n rain_volume=rain_volume,\n rain_intensity=self.rain_intensity),\n overwrite=True)\n\n # derive R factor (MJ mm ha^-1 hr^-1 yr^1)\n \"\"\"\n R factor (MJ mm ha^-1 hr^-1 yr^1)\n = EI (MJ mm ha^-1 hr^-1)\n / (rainfall interval (min)\n * (1 yr / 525600 min))\n \"\"\"\n gscript.run_command(\n 'r.mapcalc',\n expression=\"{r_factor}\"\n \"={erosivity}\"\n \"/({rain_interval}\"\n \"/525600.)\".format(\n r_factor=r_factor,\n erosivity=erosivity,\n rain_interval=self.rain_interval),\n overwrite=True)\n\n # remove temporary maps\n gscript.run_command(\n 'g.remove',\n type='raster',\n name=['rain_energy',\n 'rain_volume',\n 'erosivity'],\n flags='f')\n\n return r_factor", "def get_ir_sensor_temperature(self) -> float:\n self.serial.write(b\"T!\")\n ir_sensor_temp = self.__extract_int(self.__read_response(1)[0], b\"!2\")\n\n return round(ir_sensor_temp / 100, 2)", "def temp(self):\n\t\ttemp_out = self.read16(MPU9250_ADDRESS, TEMP_DATA)\n\t\ttemp = temp_out / 333.87 + 21.0 # these are from the datasheets\n\t\treturn temp", "def get_sensors_data(self):\n\n temp_in_celsius = self.get_temperature()\n\n return (\n round(temp_in_celsius, 1), \n round(self.to_fahrenheit(temp_in_celsius), 1), \n round(self.get_humidity(), 0), \n round(self.get_pressure(), 1)\n )", "def read_calibrated(self):\n\n self.read_sensors()\n\n print(\"uncalibrated readings\")\n self.print_sensor_values(self.sensorValues)\n\n for i in range(0, self.NUM_SENSORS):\n denominator = self.calibratedMax[i] - self.calibratedMin[i]\n val = 0\n if denominator != 0:\n val = (self.sensorValues[i] - self.calibratedMin[i]) * 1000 / denominator\n if val < 0:\n val = 0\n elif val > 1000:\n val = 1000\n self.sensorValues[i] = val\n\n print(\"calibrated readings\")\n self.print_sensor_values(self.sensorValues)", "def get_capacitive_rain_sensor_temp(\n self, rain_sensor_temp: Optional[int] = None\n ) -> float:\n # TODO: these values were hardcoded but now are taken from the CW.\n # Check which way is the \"true\" way based on the sensor type (capacitive vs Hydredon)\n # rain_pull_up_resistance = 1\n # rain_res_at_25 = 1\n # rain_beta = 3450\n absolute_zero = 273.15\n\n if rain_sensor_temp is None:\n rain_sensor_temp = self.raw_rain_sensor_temp\n\n if rain_sensor_temp < 1:\n rain_sensor_temp = 1\n elif rain_sensor_temp > 1022:\n rain_sensor_temp = 1022\n\n r = self.rain_pull_up_resistance / ((1023 / rain_sensor_temp) - 1)\n r = math.log(r / self.rain_res_at_25)\n\n return 1 / (r / self.rain_beta + 1 / (absolute_zero + 25)) - absolute_zero", "def rainfall_series(self):\n\n # assign local temporal variables\n datatype = 'strds'\n increment = str(self.rain_interval)+\" minutes\"\n raster = 'raster'\n rain_excess = 'rain_excess'\n net_difference = 'net_difference'\n #iterations = sum(1 for row in precip)\n\n # create a raster space time dataset\n gscript.run_command(\n 't.create',\n type=datatype,\n temporaltype=self.temporaltype,\n output=self.elevation_timeseries,\n title=self.elevation_title,\n description=self.elevation_description,\n overwrite=True)\n gscript.run_command(\n 't.create',\n type=datatype,\n temporaltype=self.temporaltype,\n output=self.depth_timeseries,\n title=self.depth_title,\n description=self.depth_description,\n overwrite=True)\n gscript.run_command(\n 't.create',\n type=datatype,\n temporaltype=self.temporaltype,\n output=self.erdep_timeseries,\n title=self.erdep_title,\n description=self.erdep_description,\n overwrite=True)\n gscript.run_command(\n 't.create',\n type=datatype,\n temporaltype=self.temporaltype,\n output=self.flux_timeseries,\n title=self.flux_title,\n description=self.flux_description,\n overwrite=True)\n gscript.run_command(\n 't.create',\n type=datatype,\n temporaltype=self.temporaltype,\n output=self.difference_timeseries,\n title=self.difference_title,\n description=self.difference_description,\n overwrite=True)\n\n # register the initial digital elevation model\n gscript.run_command(\n 't.register',\n type=raster,\n input=self.elevation_timeseries,\n maps=self.elevation,\n start=self.start,\n increment=increment,\n flags='i',\n overwrite=True)\n\n # create evolution object\n evol = Evolution(\n elevation=self.elevation,\n precipitation=self.precipitation,\n start=self.start,\n rain_intensity=self.rain_intensity,\n rain_interval=self.rain_interval,\n walkers=self.walkers,\n runoff=self.runoff,\n mannings=self.mannings,\n detachment=self.detachment,\n transport=self.transport,\n shearstress=self.shearstress,\n density=self.density,\n mass=self.mass,\n grav_diffusion=self.grav_diffusion,\n erdepmin=self.erdepmin,\n erdepmax=self.erdepmax,\n k_factor=self.k_factor,\n c_factor=self.c_factor,\n m=self.m,\n n=self.n,\n threads=self.threads,\n fill_depressions=self.fill_depressions)\n\n # open txt file with precipitation data\n with open(evol.precipitation) as csvfile:\n\n # check for header\n has_header = csv.Sniffer().has_header(csvfile.read(1024))\n\n # rewind\n csvfile.seek(0)\n\n # skip header\n if has_header:\n next(csvfile)\n\n # parse time and precipitation\n precip = csv.reader(csvfile, delimiter=',', skipinitialspace=True)\n\n # initial run\n initial = next(precip)\n evol.start = initial[0]\n evol.rain_intensity = 'rain_intensity'\n # compute rainfall intensity (mm/hr)\n # from rainfall observation (mm)\n gscript.run_command(\n 'r.mapcalc',\n expression=\"{rain_intensity}\"\n \"={rain_observation}\"\n \"/{rain_interval}\"\n \"*60.\".format(\n rain_intensity=evol.rain_intensity,\n rain_observation=float(initial[1]),\n rain_interval=self.rain_interval),\n overwrite=True)\n\n # determine mode and run model\n if self.mode == \"simwe_mode\":\n (evolved_elevation, time, depth, erosion_deposition,\n difference) = evol.erosion_deposition()\n # remove relative timestamps\n # from r.sim.water and r.sim.sediment\n gscript.run_command(\n 'r.timestamp',\n map=depth,\n date='none')\n gscript.run_command(\n 'r.timestamp',\n map=erosion_deposition,\n date='none')\n\n elif self.mode == \"usped_mode\":\n (evolved_elevation, time, depth, erosion_deposition,\n difference) = evol.usped()\n\n elif self.mode == \"rusle_mode\":\n (evolved_elevation, time, depth, sediment_flux,\n difference) = evol.rusle()\n\n else:\n raise RuntimeError(\n '{mode} mode does not exist').format(mode=self.mode)\n\n # register the evolved maps\n gscript.run_command(\n 't.register',\n type=raster,\n input=self.elevation_timeseries,\n maps=evolved_elevation,\n start=evol.start,\n increment=increment,\n flags='i',\n overwrite=True)\n gscript.run_command(\n 't.register',\n type=raster,\n input=self.depth_timeseries,\n maps=depth,\n start=evol.start,\n increment=increment,\n flags='i',\n overwrite=True)\n try:\n gscript.run_command(\n 't.register',\n type=raster,\n input=self.erdep_timeseries,\n maps=erosion_deposition,\n start=evol.start,\n increment=increment,\n flags='i',\n overwrite=True)\n except (NameError, CalledModuleError):\n pass\n try:\n gscript.run_command(\n 't.register',\n type=raster,\n input=self.flux_timeseries,\n maps=sediment_flux,\n start=evol.start,\n increment=increment,\n flags='i', overwrite=True)\n except (NameError, CalledModuleError):\n pass\n gscript.run_command(\n 't.register',\n type=raster,\n input=self.difference_timeseries,\n maps=difference,\n start=evol.start,\n increment=increment,\n flags='i',\n overwrite=True)\n\n # run the landscape evolution model for each rainfall record\n for row in precip:\n\n # update the elevation\n evol.elevation=evolved_elevation\n\n # update time\n evol.start=row[0]\n\n # compute rainfall intensity (mm/hr)\n # from rainfall observation (mm)\n rain_intensity = 'rain_intensity'\n gscript.run_command(\n 'r.mapcalc',\n expression=\"{rain_intensity}\"\n \"={rain_observation}\"\n \"/{rain_interval}\"\n \"*60.\".format(\n rain_intensity=rain_intensity,\n rain_observation=float(row[1]),\n rain_interval=self.rain_interval),\n overwrite=True)\n\n # derive excess water (mm/hr) from rainfall rate (mm/hr)\n # plus the depth (m) per rainfall interval (min)\n gscript.run_command(\n 'r.mapcalc',\n expression=\"{rain_excess}\"\n \"={rain_intensity}\"\n \"+{depth}\"\n \"/1000.\"\n \"/{rain_interval}\"\n \"*60.\".format(\n rain_excess=rain_excess,\n rain_intensity=rain_intensity,\n depth=depth,\n rain_interval=self.rain_interval),\n overwrite=True)\n\n # update excess rainfall\n gscript.run_command(\n 'r.mapcalc',\n expression=\"{rain_intensity} = {rain_excess}\".format(\n rain_intensity='rain_intensity',\n rain_excess=rain_excess),\n overwrite=True)\n evol.rain_intensity = rain_intensity\n\n # determine mode and run model\n if self.mode == \"simwe_mode\":\n (evolved_elevation, time, depth, erosion_deposition,\n difference) = evol.erosion_deposition()\n # remove relative timestamps\n # from r.sim.water and r.sim.sediment\n gscript.run_command(\n 'r.timestamp',\n map=depth,\n date='none')\n gscript.run_command(\n 'r.timestamp',\n map=erosion_deposition,\n date='none')\n\n elif self.mode == \"usped_mode\":\n (evolved_elevation, time, depth, erosion_deposition,\n difference) = evol.usped()\n\n elif self.mode == \"rusle_mode\":\n (evolved_elevation, time, depth, sediment_flux,\n difference) = evol.rusle()\n\n else:\n raise RuntimeError(\n '{mode} mode does not exist').format(mode=self.mode)\n\n # register the evolved maps\n gscript.run_command(\n 't.register',\n type=raster,\n input=self.elevation_timeseries,\n maps=evolved_elevation,\n start=evol.start,\n increment=increment,\n flags='i',\n overwrite=True)\n gscript.run_command(\n 't.register',\n type=raster,\n input=self.depth_timeseries,\n maps=depth,\n start=evol.start,\n increment=increment,\n flags='i',\n overwrite=True)\n try:\n gscript.run_command(\n 't.register',\n type=raster,\n input=self.erdep_timeseries,\n maps=erosion_deposition,\n start=evol.start,\n increment=increment,\n flags='i',\n overwrite=True)\n except (NameError, CalledModuleError):\n pass\n try:\n gscript.run_command(\n 't.register',\n type=raster,\n input=self.flux_timeseries,\n maps=sediment_flux,\n start=evol.start,\n increment=increment,\n flags='i', overwrite=True)\n except (NameError, CalledModuleError):\n pass\n gscript.run_command(\n 't.register',\n type=raster,\n input=self.difference_timeseries,\n maps=difference,\n start=evol.start,\n increment=increment,\n flags='i',\n overwrite=True)\n\n # remove temporary maps\n gscript.run_command(\n 'g.remove',\n type='raster',\n name=['rain_excess'],\n flags='f')\n\n # compute net elevation change\n gscript.run_command(\n 'r.mapcalc',\n expression=\"{net_difference}\"\n \"= {evolved_elevation}-{elevation}\".format(\n net_difference=net_difference,\n elevation=self.elevation,\n evolved_elevation=evol.elevation),\n overwrite=True)\n gscript.write_command(\n 'r.colors',\n map=net_difference,\n rules='-',\n stdin=difference_colors)", "def compute_rate(self):\n bg_rate = self.counts.data / self.livetime.data\n\n bg_rate /= self.counts.bin_volume\n\n bg_rate = bg_rate.to('MeV-1 sr-1 s-1')\n\n self.bg_rate.data = bg_rate\n self.bg_rate.data_err = (np.sqrt(self.counts.data) / (self.counts.bin_volume * self.livetime.data)).to(\n 'MeV-1 sr-1 s-1')", "def intensity(self) -> int:", "def rain(self, json):\n rain = str(json['forecast']['txt_forecast']['forecastday'][0]['pop'])\n return rain", "def chance_of_rain(self):\r\n # Amount of yesterday's rain indicating chance of it occurring.\r\n NO_RAIN = 0.1\r\n LITTLE_RAIN = 3\r\n SOME_RAIN = 8\r\n # Chance of rain occurring.\r\n NONE = 0\r\n MILD = 40\r\n PROBABLE = 75\r\n LIKELY = 90\r\n\r\n if self._yesterdays_weather.get_rainfall() < NO_RAIN:\r\n chance_of_rain = NONE\r\n elif self._yesterdays_weather.get_rainfall() < LITTLE_RAIN:\r\n chance_of_rain = MILD\r\n elif self._yesterdays_weather.get_rainfall() < SOME_RAIN:\r\n chance_of_rain = PROBABLE\r\n else:\r\n chance_of_rain = LIKELY\r\n\r\n return chance_of_rain", "def calculateR(sapienses: list) -> float:\n r = 0\n for i in sapienses:\n r = r + i.numberInfected\n r=r/I0\n r = r*S/(S+R+D)\n return r" ]

[ "0.72224313", "0.7113404", "0.7036755", "0.67013526", "0.65311795", "0.6367569", "0.6340259", "0.63118654", "0.6237534", "0.61978304", "0.6195324", "0.6149609", "0.6134852", "0.60428345", "0.60210586", "0.60131687", "0.5961657", "0.5958928", "0.5943346", "0.5934416", "0.5927146", "0.5918668", "0.5874573", "0.58708614", "0.58690345", "0.5800708", "0.57697684", "0.5760235", "0.57501006", "0.5745907" ]

[ "def get_rain_values(self):\n return float(self.data[2]) / 10, float(self.data[4]) / 10", "def get_mean(self):\n return self.serie.mean()", "def calculate_mean(weather_data):\n sum_value=0\n\n for value in weather_data:\n sum_value += float(value)\n \n mean = sum_value/len(weather_data)\n\n return (mean)", "def get_mean(self):\n self.meanval = np.mean(self.adulist)", "def get_mean(self):\n mean = np.array(np.zeros((4,8)))\n for i,c in enumerate(self.cellLines):\n for j,l in enumerate(self.ligands):\n mean[i][j] = self.aucs[c][l]['mean']\n return mean", "def mean_temperature(self):\n return self._mean_temperature", "def Mean(data):\n return data.mean()", "def mean(vals):", "def getMean(self):\n return self.mean", "def raw_rain_sensor_temp(self) -> int:\n self._update_analog_value_cache()\n return self.analog_cache.rain_sensor_temp", "def mean(self):\n\n\t\tif not self._masked:\n\t\t\t\n\t\t\treturn self.data.mean()\n\t\t\n\t\telse:\n\t\t\t\n\t\t\tif not hasattr(self,\"_full_mask\"):\n\t\t\t\tself.maskBoundaries()\n\t\t\t\n\t\t\treturn self.data[self._full_mask].mean()", "def mean_value(self):\n\n return self._system.mean()", "def mean(self):\r\n return np.mean(self.data_array)", "def mean(self):\n return self.vmean", "def get_mean(self):\r\n for i in range(1,len(self.data[0])):\r\n self.prom.append(np.mean(self.data[:,i]))", "def _get_mean(self):\n return (0.485, 0.456, 0.406)", "def mean(self) -> float:\n return self._data.mean()", "def mean(self):\r\n\t\treturn sum(self.sample)/len(self.sample)", "def _get_mean(self):\n return self._get_conditional_negative_energy()", "def mean(self):\n return self._mean", "def mean(self):\n return self._mean", "def mean(self):\n return self.aggregate(np.mean)", "def mean(self) -> \"Stream[float]\":\n return self.agg(np.mean).astype(\"float\")", "def mean(self):\n\n return self._reduce_for_stat_function(F.mean, only_numeric=True)", "def get_temp(self) -> float:\n return np.round(np.mean(self.temp_data), 1)", "def mean(values):\n # Write the mean() function\n mean = sum(values) / len(values)\n return mean", "def mean(self):\n return np.average(self.particles, weights=self.weights, axis=0)", "def mean(values):\r\n return sum(values) / float(len(values))", "def mean(values):\n # Write the mean() function\n mean = sum(values) / len(values)\n return mean", "def mean(self):\n return self._lift(\"mean\")" ]

[ "0.7449613", "0.7121376", "0.7068443", "0.7016701", "0.68816674", "0.6832859", "0.680174", "0.67747545", "0.6772888", "0.6760779", "0.6729011", "0.6711309", "0.67074865", "0.6706144", "0.67000014", "0.6675047", "0.66674566", "0.6647652", "0.65865636", "0.65680385", "0.65680385", "0.655842", "0.65447193", "0.6533103", "0.6511556", "0.6498373", "0.6490407", "0.6468733", "0.6459408", "0.6446587" ]

[ "def _set_style(style):\n if isinstance(style, (str, dict)):\n return Style(style)\n elif isinstance(style, Style):\n return style\n else:\n return Style()", "def validate_order_params(self,\n asset,\n amount,\n limit_price,\n stop_price,\n style):\n\n if not self.initialized:\n raise OrderDuringInitialize(\n msg=\"order() can only be called from within handle_data()\"\n )\n\n if style:\n if limit_price:\n raise UnsupportedOrderParameters(\n msg=\"Passing both limit_price and style is not supported.\"\n )\n\n if stop_price:\n raise UnsupportedOrderParameters(\n msg=\"Passing both stop_price and style is not supported.\"\n )\n\n for control in self.trading_controls:\n control.validate(asset,\n amount,\n self.portfolio,\n self.get_datetime(),\n self.executor.current_data)", "def _create_stop(self, price_stop):\n if self.price_stop is not None:\n return(order(self.symbol, -self.volume, style=StopOrder(self.price_stop))) # , exchange=self.order_master.style.exchange\n else:\n return(None)", "def predefined_style(self, style):\n if style == 'minimal':\n self.style(box_style=None, border_visible=True,\n border_color='black', border_style='solid',\n border_width=1, border_radius=0, padding='0.2cm',\n margin='0.3cm', font_family='', font_size=None,\n font_style='', font_weight='', slider_width='',\n slider_handle_colour=None, slider_bar_colour=None,\n buttons_style='')\n elif (style == 'info' or style == 'success' or style == 'danger' or\n style == 'warning'):\n self.style(box_style=style, border_visible=True,\n border_color=map_styles_to_hex_colours(style),\n border_style='solid', border_width=1, border_radius=10,\n padding='0.2cm', margin='0.3cm', font_family='',\n font_size=None, font_style='', font_weight='',\n slider_width='',\n slider_handle_colour=map_styles_to_hex_colours(style),\n slider_bar_colour=None, buttons_style='primary')\n else:\n raise ValueError('style must be minimal or info or success or '\n 'danger or warning')", "def predefined_style(self, style):\n if style == 'minimal':\n self.style(box_style='', border_visible=False)\n self.play_stop_toggle.button_style = ''\n self.play_stop_toggle.font_weight = 'normal'\n self.play_options_toggle.button_style = ''\n format_box(self.loop_interval_box, '', False, 'black', 'solid', 1,\n 10, '0.1cm', '0.1cm')\n if self.index_style == 'buttons':\n self.index_wid.button_plus.button_style = ''\n self.index_wid.button_plus.font_weight = 'normal'\n self.index_wid.button_minus.button_style = ''\n self.index_wid.button_minus.font_weight = 'normal'\n self.index_wid.index_text.background_color = None\n elif self.index_style == 'slider':\n self.index_wid.slider.slider_color = None\n self.index_wid.slider.background_color = None\n self._toggle_play_style = ''\n self._toggle_stop_style = ''\n elif (style == 'info' or style == 'success' or style == 'danger' or\n style == 'warning'):\n self.style(box_style=style, border_visible=False)\n self.play_stop_toggle.button_style = 'success'\n self.play_stop_toggle.font_weight = 'bold'\n self.play_options_toggle.button_style = 'info'\n format_box(self.loop_interval_box, 'info', True,\n map_styles_to_hex_colours('info'), 'solid', 1, 10,\n '0.1cm', '0.1cm')\n if self.index_style == 'buttons':\n self.index_wid.button_plus.button_style = 'primary'\n self.index_wid.button_plus.font_weight = 'bold'\n self.index_wid.button_minus.button_style = 'primary'\n self.index_wid.button_minus.font_weight = 'bold'\n self.index_wid.index_text.background_color = \\\n map_styles_to_hex_colours(style, True)\n elif self.index_style == 'slider':\n self.index_wid.slider.slider_color = \\\n map_styles_to_hex_colours(style)\n self.index_wid.slider.background_color = \\\n map_styles_to_hex_colours(style)\n self._toggle_play_style = 'success'\n self._toggle_stop_style = 'danger'\n else:\n raise ValueError('style must be minimal or info or success or '\n 'danger or warning')", "def predefined_style(self, style):\n if style == 'minimal':\n self.style(box_style='', border_visible=False)\n self.play_stop_toggle.button_style = ''\n self.play_stop_toggle.font_weight = 'normal'\n self.play_options_toggle.button_style = ''\n _format_box(self.loop_interval_box, '', False, 'black', 'solid', 1,\n 10, '0.1cm', '0.1cm')\n if self.index_style == 'buttons':\n self.index_wid.button_plus.button_style = ''\n self.index_wid.button_plus.font_weight = 'normal'\n self.index_wid.button_minus.button_style = ''\n self.index_wid.button_minus.font_weight = 'normal'\n self.index_wid.index_text.background_color = None\n elif self.index_style == 'slider':\n self.index_wid.slider.slider_color = None\n self.index_wid.slider.background_color = None\n self._toggle_play_style = ''\n self._toggle_stop_style = ''\n elif (style == 'info' or style == 'success' or style == 'danger' or\n style == 'warning'):\n self.style(box_style=style, border_visible=False)\n self.play_stop_toggle.button_style = 'success'\n self.play_stop_toggle.font_weight = 'bold'\n self.play_options_toggle.button_style = 'info'\n _format_box(self.loop_interval_box, 'info', True,\n _map_styles_to_hex_colours('info'), 'solid', 1, 10,\n '0.1cm', '0.1cm')\n if self.index_style == 'buttons':\n self.index_wid.button_plus.button_style = 'primary'\n self.index_wid.button_plus.font_weight = 'bold'\n self.index_wid.button_minus.button_style = 'primary'\n self.index_wid.button_minus.font_weight = 'bold'\n self.index_wid.index_text.background_color = \\\n _map_styles_to_hex_colours(style, True)\n elif self.index_style == 'slider':\n self.index_wid.slider.slider_color = \\\n _map_styles_to_hex_colours(style)\n self.index_wid.slider.background_color = \\\n _map_styles_to_hex_colours(style)\n self._toggle_play_style = 'success'\n self._toggle_stop_style = 'danger'\n else:\n raise ValueError('style must be minimal or info or success or '\n 'danger or warning')", "def calculate_stop_loss_price(market_price: float, order_price: float, stop_loss_price: float, side: str):\n if side == 'LONG':\n if not stop_loss_price:\n stop_loss_price = order_price - (order_price / 100) * CONF.stop_loss_in_percent\n if market_price - (market_price / 100) * CONF.stop_loss_in_percent > stop_loss_price:\n stop_loss_price = market_price - (market_price / 100) * CONF.stop_loss_in_percent\n if not CONF.no_action_at_loss or stop_loss_price > order_price:\n return stop_loss_price\n return None\n if not stop_loss_price:\n stop_loss_price = order_price + (order_price / 100) * CONF.stop_loss_in_percent\n if market_price + (market_price / 100) * CONF.stop_loss_in_percent < stop_loss_price:\n stop_loss_price = market_price + (market_price / 100) * CONF.stop_loss_in_percent\n if not CONF.no_action_at_loss or stop_loss_price < order_price:\n return stop_loss_price\n return None", "def make_style(opts=(), **kwargs):\n # pylint: disable-msg=W0142\n return lambda text: colorize(text, opts, **kwargs)", "def predefined_style(self, style):\n if style == 'minimal':\n self.style(box_style=None, border_visible=True,\n border_colour='black', border_style='solid',\n border_width=1, border_radius=0, padding='0.2cm',\n margin='0.3cm', font_family='', font_size=None,\n font_style='', font_weight='', labels_buttons_style='')\n elif (style == 'info' or style == 'success' or style == 'danger' or\n style == 'warning'):\n self.style(box_style=style, border_visible=True,\n border_colour=map_styles_to_hex_colours(style),\n border_style='solid', border_width=1, border_radius=10,\n padding='0.2cm', margin='0.3cm', font_family='',\n font_size=None, font_style='', font_weight='',\n labels_buttons_style='primary')\n else:\n raise ValueError('style must be minimal or info or success or '\n 'danger or warning')", "def predefined_style(self, style):\n if style == 'minimal':\n self.style(box_style=None, border_visible=True,\n border_color='black', border_style='solid',\n border_width=1, border_radius=0, padding='0.2cm',\n margin='0.3cm', font_family='', font_size=None,\n font_style='', font_weight='', labels_buttons_style='')\n elif (style == 'info' or style == 'success' or style == 'danger' or\n style == 'warning'):\n self.style(box_style=style, border_visible=True,\n border_color=_map_styles_to_hex_colours(style),\n border_style='solid', border_width=1, border_radius=10,\n padding='0.2cm', margin='0.3cm', font_family='',\n font_size=None, font_style='', font_weight='',\n labels_buttons_style='primary')\n else:\n raise ValueError('style must be minimal or info or success or '\n 'danger or warning')", "def get(cls, style # type: Union[str, Callable]\n ):\n # type: (...) -> Callable[[UnionFixtureAlternative], str]\n if style is None or isinstance(style, string_types):\n # return one of the styles from the class\n style = style or 'nostyle'\n try:\n return getattr(cls, style)\n except AttributeError:\n raise ValueError(\"Unknown style: %r\" % style)\n else:\n # assume a callable: return it directly\n return style", "def predefined_style(self, style):\n if style == 'minimal':\n self.style(box_style=None, border_visible=True,\n border_colour='black', border_style='solid',\n border_width=1, border_radius=0, padding='0.1cm',\n margin='0.3cm', font_family='', font_size=None,\n font_style='', font_weight='')\n elif (style == 'info' or style == 'success' or style == 'danger' or\n style == 'warning'):\n self.style(box_style=style, border_visible=True,\n border_colour=map_styles_to_hex_colours(style),\n border_style='solid', border_width=1, border_radius=10,\n padding='0.1cm', margin='0.3cm', font_family='',\n font_size=None, font_style='', font_weight='')\n else:\n raise ValueError('style must be minimal or info or success or '\n 'danger or warning')", "def _require_style(style):\n if not isinstance(style, (dict, type(None))):\n raise ValueError(\"Expected a dictionary of CSS styles or None, received %s.\" % style)\n return style", "def predefined_style(self, style):\n if style == 'minimal':\n self.style(box_style=None, border_visible=True,\n border_color='black', border_style='solid',\n border_width=1, border_radius=0, padding='0.1cm',\n margin='0.3cm', font_family='', font_size=None,\n font_style='', font_weight='')\n elif (style == 'info' or style == 'success' or style == 'danger' or\n style == 'warning'):\n self.style(box_style=style, border_visible=True,\n border_color=_map_styles_to_hex_colours(style),\n border_style='solid', border_width=1, border_radius=10,\n padding='0.1cm', margin='0.3cm', font_family='',\n font_size=None, font_style='', font_weight='')\n else:\n raise ValueError('style must be minimal or info or success or '\n 'danger or warning')", "def configure_style(self, style):\n if style.fg.isreset():\n fg = Color()\n else:\n if style.fg in ANSI_16_COLOR_PALETTE:\n fg = style.fg\n else:\n fg = self._rgb_to_color(*style.fg.rgb)\n if style.bg.isreset():\n bg = Color()\n else:\n if style.bg in ANSI_16_COLOR_PALETTE:\n bg = style.bg\n else:\n bg = self._rgb_to_color(*style.bg.rgb)\n\n def issupported(style):\n return style in self.supported_attrs\n\n attrs = filter(issupported, style.attrs)\n attrs = [attr for attr in attrs]\n return Style(fg, bg, attrs)", "def predefined_style(self, style):\n if style == 'minimal':\n self.style(box_style=None, border_visible=True,\n border_colour='black', border_style='solid',\n border_width=1, border_radius=0, padding='0.2cm',\n margin='0.3cm', font_family='', font_size=None,\n font_style='', font_weight='', slider_width='4cm')\n format_box(self.glyph_options_box, box_style='',\n border_visible=False, border_colour='',\n border_style='solid', border_width=1, border_radius=0,\n padding='0.1cm', margin=0)\n elif (style == 'info' or style == 'success' or style == 'danger' or\n style == 'warning'):\n self.style(box_style=style, border_visible=True,\n border_colour=map_styles_to_hex_colours(style),\n border_style='solid', border_width=1, border_radius=10,\n padding='0.2cm', margin='0.3cm', font_family='',\n font_size=None, font_style='', font_weight='',\n slider_width='4cm')\n format_box(self.glyph_options_box, box_style=style,\n border_visible=True,\n border_colour=map_styles_to_hex_colours(style),\n border_style='solid', border_width=1, border_radius=10,\n padding='0.1cm', margin=0)\n else:\n raise ValueError('style must be minimal or info or success or '\n 'danger or warning')", "def predefined_style(self, style):\n if style == 'minimal':\n self.style(box_style='', border_visible=True, border_colour='black',\n border_style='solid', border_width=1, border_radius=0,\n padding='0.2cm', margin='0.3cm', font_family='',\n font_size=None, font_style='', font_weight='')\n elif (style == 'info' or style == 'success' or style == 'danger' or\n style == 'warning'):\n self.style(box_style=style, border_visible=True,\n border_colour= map_styles_to_hex_colours(style),\n border_style='solid', border_width=1, border_radius=10,\n padding='0.2cm', margin='0.3cm', font_family='',\n font_size=None, font_style='', font_weight='')\n else:\n raise ValueError('style must be minimal or info or success or '\n 'danger or warning')", "def get_stop_loss_price(price, stop, relative_stop=False):\n if relative_stop:\n sl_price = price - stop\n else:\n sl_price = abs(stop)\n return sl_price", "def compose_style(stylestrs):\n funstack = []\n for s in stylestrs:\n funstack.append(vars(fmt)[s])\n def f(t):\n for fun in funstack:\n t = fun(t)\n return t\n return f", "def predefined_style(self, style):\n if style == 'minimal':\n self.style(box_style='', border_visible=True, border_color='black',\n border_style='solid', border_width=1, border_radius=0,\n padding='0.2cm', margin='0.3cm', font_family='',\n font_size=None, font_style='', font_weight='')\n elif (style == 'info' or style == 'success' or style == 'danger' or\n style == 'warning'):\n self.style(box_style=style, border_visible=True,\n border_color= _map_styles_to_hex_colours(style),\n border_style='solid', border_width=1, border_radius=10,\n padding='0.2cm', margin='0.3cm', font_family='',\n font_size=None, font_style='', font_weight='')\n else:\n raise ValueError('style must be minimal or info or success or '\n 'danger or warning')", "def SetStyle(self, start=None, end=None, style=None):\n # Global default styles for all languages\n self.StyleSetSpec(stc.STC_STYLE_DEFAULT, \"face:%(helv)s,size:%(size)d\" % faces)\n self.StyleClearAll() # Reset all to be like the default\n\n # Global default styles for all languages\n self.StyleSetSpec(stc.STC_STYLE_DEFAULT, \"face:%(helv)s,size:%(size)d\" % faces)\n self.StyleSetSpec(stc.STC_STYLE_LINENUMBER, \"back:#C0C0C0,face:%(helv)s,size:%(size2)d\" % faces)\n self.StyleSetSpec(stc.STC_STYLE_CONTROLCHAR, \"face:%(other)s\" % faces)\n self.StyleSetSpec(stc.STC_STYLE_BRACELIGHT, \"fore:#FFFFFF,back:#0000FF,bold\")\n self.StyleSetSpec(stc.STC_STYLE_BRACEBAD, \"fore:#000000,back:#FF0000,bold\")\n\n # Python styles\n # Default\n self.StyleSetSpec(stc.STC_P_DEFAULT, \"fore:#000000,face:%(helv)s,size:%(size)d\" % faces)\n # Comments\n self.StyleSetSpec(stc.STC_P_COMMENTLINE, \"fore:#007F00,face:%(other)s,size:%(size)d\" % faces)\n # Number\n self.StyleSetSpec(stc.STC_P_NUMBER, \"fore:#007F7F,size:%(size)d\" % faces)\n # String\n self.StyleSetSpec(stc.STC_P_STRING, \"fore:#7F007F\")\n # Single quoted string\n self.StyleSetSpec(stc.STC_P_CHARACTER, \"fore:#7F007F,face:%(helv)s,size:%(size)d\" % faces)\n # Keyword\n self.StyleSetSpec(stc.STC_P_WORD, \"fore:#00007F,bold,size:%(size)d\" % faces)\n # Triple quotes\n self.StyleSetSpec(stc.STC_P_TRIPLE, \"fore:#7F0000,size:%(size)d\" % faces)\n # Triple double quotes\n self.StyleSetSpec(stc.STC_P_TRIPLEDOUBLE, \"fore:#7F0000,size:%(size)d\" % faces)\n # Class name definition\n self.StyleSetSpec(stc.STC_P_CLASSNAME, \"fore:#0000FF,bold,size:%(size)d\" % faces)\n # Function or method name definition\n self.StyleSetSpec(stc.STC_P_DEFNAME, \"fore:#007F7F,bold,size:%(size)d\" % faces)\n # Operators\n self.StyleSetSpec(stc.STC_P_OPERATOR, \"bold,size:%(size)d\" % faces)\n # Identifiers\n self.StyleSetSpec(stc.STC_P_IDENTIFIER, \"fore:#000000,face:%(helv)s,size:%(size)d\" % faces)\n # Comment-blocks\n self.StyleSetSpec(stc.STC_P_COMMENTBLOCK, \"fore:#7F7F7F,size:%(size)d\" % faces)\n # End of line where string is not closed\n self.StyleSetSpec(stc.STC_P_STRINGEOL, \"fore:#000000,face:%(mono)s,back:#E0C0E0,eol,size:%(size)d\" % faces)\n\n self.SetCaretForeground(\"BLUE\")", "def add_style(self, style, keepdefault=False):\n for key, styledict in style.items():\n target = self.style[key]\n for k, v in styledict.items():\n if keepdefault:\n target.setdefault(k, v)\n else:\n target[k] = v\n return self", "def predefined_style(self, style):\n if style == 'minimal':\n self.style(box_style=None, border_visible=True,\n border_color='black', border_style='solid',\n border_width=1, border_radius=0, padding='0.2cm',\n margin='0.3cm', font_family='', font_size=None,\n font_style='', font_weight='', slider_width='5cm',\n slider_colour='')\n _format_box(self.glyph_options_box, box_style='',\n border_visible=False, border_color='',\n border_style='solid', border_width=1, border_radius=0,\n padding='0.1cm', margin=0)\n elif (style == 'info' or style == 'success' or style == 'danger' or\n style == 'warning'):\n self.style(box_style=style, border_visible=True,\n border_color=_map_styles_to_hex_colours(style),\n border_style='solid', border_width=1, border_radius=10,\n padding='0.2cm', margin='0.3cm', font_family='',\n font_size=None, font_style='', font_weight='',\n slider_width='5cm',\n slider_colour=_map_styles_to_hex_colours(style))\n _format_box(self.glyph_options_box, box_style=style,\n border_visible=True,\n border_color=_map_styles_to_hex_colours(style),\n border_style='solid', border_width=1, border_radius=10,\n padding='0.1cm', margin=0)\n else:\n raise ValueError('style must be minimal or info or success or '\n 'danger or warning')", "def _eval_args(vals=None, style=\"bool\", threshold=1.0, return_lines=False):\n assert style in [\"bool\", \"values\"],\"style must be 'bool' or 'values'\"\n assert 0.0 < threshold <= 1.0, \"threshold is invalid, must be between 0 and 1\"\n assert vals is not None\n\n try:\n assert ~vals.empty\n except AttributeError:\n pass\n return", "def change_style(style, representer):\n\n def new_representer(dumper, data):\n scalar = representer(dumper, data)\n scalar.style = style\n return scalar\n\n return new_representer", "def _combine_styles(*styles):\n computed_style = {}\n for style in styles:\n if style is not None:\n computed_style.update(style)\n return computed_style", "def predefined_style(self, style, subwidgets_style):\n if style == 'minimal':\n box_style = None\n border_visible = False\n border_colour = 'black'\n border_radius = 0\n elif (style == 'info' or style == 'success' or style == 'danger' or\n style == 'warning'):\n box_style = style\n border_visible = True\n border_colour = map_styles_to_hex_colours(style)\n border_radius = 10\n else:\n raise ValueError('style and must be minimal or info or success '\n 'or danger or warning')\n\n if subwidgets_style == 'minimal':\n bboxes_box_style = None\n bboxes_border_colour = 'black'\n bboxes_border_radius = 0\n patches_box_style = None\n patches_border_colour = 'black'\n patches_border_radius = 0\n elif (subwidgets_style == 'info' or subwidgets_style == 'success' or\n subwidgets_style == 'danger' or subwidgets_style == 'warning'):\n bboxes_box_style = subwidgets_style\n bboxes_border_colour = map_styles_to_hex_colours(subwidgets_style)\n bboxes_border_radius = 10\n patches_box_style = subwidgets_style\n patches_border_colour = map_styles_to_hex_colours(subwidgets_style)\n patches_border_radius = 10\n else:\n raise ValueError('subwidgets_style and must be minimal or info '\n 'or success or danger or warning')\n\n self.style(\n box_style=box_style, border_visible=border_visible,\n border_colour=border_colour, border_style='solid', border_width=1,\n border_radius=border_radius, padding='0.2cm', margin='0.3cm',\n font_family='', font_size=None, font_style='', font_weight='',\n bboxes_box_style=bboxes_box_style, bboxes_border_visible=True,\n bboxes_border_colour=bboxes_border_colour,\n bboxes_border_style='solid', bboxes_border_width=1,\n bboxes_border_radius=bboxes_border_radius, bboxes_padding='0.2cm',\n bboxes_margin='0.1cm', patches_box_style=patches_box_style,\n patches_border_visible=True,\n patches_border_colour=patches_border_colour,\n patches_border_style='solid', patches_border_width=1,\n patches_border_radius=patches_border_radius,\n patches_padding='0.2cm', patches_margin='0.1cm')", "def stop_loss_prices(self, stop_loss_prices: List[float]):\n\n self._stop_loss_prices = stop_loss_prices", "def predefined_style(self, style):\n if style == 'minimal':\n self.style(box_style='', border_visible=True, border_colour='black',\n border_style='solid', border_width=1, border_radius=0,\n padding='0.2cm', margin='0.3cm', font_family='',\n font_size=None, font_style='', font_weight='')\n self.save_button.button_style = ''\n self.save_button.font_weight = 'normal'\n elif (style == 'info' or style == 'success' or style == 'danger' or\n style == 'warning'):\n self.style(box_style=style, border_visible=True,\n border_colour= map_styles_to_hex_colours(style),\n border_style='solid', border_width=1, border_radius=10,\n padding='0.2cm', margin='0.3cm', font_family='',\n font_size=None, font_style='', font_weight='')\n self.save_button.button_style = 'primary'\n self.save_button.font_weight = 'bold'\n else:\n raise ValueError('style must be minimal or info or success or '\n 'danger or warning')", "def apply_prices(data, conditions=None, price='open', stop_loss=0, order='B'):\n if order.upper() == 'B':\n multiplier = 1 - (stop_loss * 0.01)\n elif order.upper() == 'S':\n multiplier = 1 + (stop_loss * 0.01)\n else:\n raise ValueError('Order should be either B or S')\n\n # All conditions are forced to lower case AND ed\n if conditions:\n big_condition = '&'.join(['(' + c.lower() + ')' for c in conditions])\n # TO DO: Deal with Memory Error in case of lots of conditions\n # f shorthand for filtered\n f = data.query(big_condition).copy()\n else:\n f = data.copy()\n f['price'] = f.eval(price).apply(tick)\n f['stop_loss'] = (f['price'] * multiplier).apply(tick)\n\n # Price map to determine whether buy or sell is the entry\n p_map = {\n 'B': ('buy', 'sell'),\n 'S': ('sell', 'buy')\n }\n\n col_price, col_sl = p_map.get(order)\n\n f.loc[:, col_price] = [isPrice(p,h,l) for p,h,l in zip(\n f.price, f.high, f.low)] * f['price']\n f.loc[:, col_sl] = [isPrice(p,h,l) for p,h,l in zip(\n f.stop_loss, f.high, f.low)] * f['stop_loss']\n f.loc[f.buy == 0, 'buy'] = f.loc[f.buy == 0, 'close']\n f.loc[f.sell == 0, 'sell'] = f.loc[f.sell == 0, 'close']\n return f" ]

[ "0.5426312", "0.52149206", "0.5101911", "0.5037377", "0.50249916", "0.500891", "0.49706978", "0.48260212", "0.48249587", "0.480683", "0.47849914", "0.47360033", "0.47242194", "0.47186542", "0.47162336", "0.4714977", "0.47024837", "0.469033", "0.46809167", "0.4660018", "0.46556357", "0.4650563", "0.4634732", "0.4620282", "0.46055165", "0.45933196", "0.4583549", "0.4580372", "0.45691133", "0.45466238" ]

[ "def register_trading_control(self, control):\n if self.initialized:\n raise RegisterTradingControlPostInit()\n self.trading_controls.append(control)", "def register(account_type):\n def class_rebuilder(cls):\n ACCOUNT_TYPES[account_type] = cls\n return cls\n return class_rebuilder", "def set_ixtools_account(self, item_name):\n self.single_selection_from_kendo_dropdown(self.ixtools_account_kendo_dropdown_locator, item_name)\n self.wait_for_ajax_spinner_load()", "def addControl(*args):", "def addControl(*args):", "def addControl(*args):", "def addControl(*args):", "def set_account(self, account_list):\n self.multiple_items_selection_from_kendo_dropdown(self.account_kendo_dropdown_locator, account_list)\n self.wait_for_ajax_spinner_load()", "def add(self):\n d = {}\n\n self.ok_signal.emit(d, 'account')", "def accounts(self, accounts):\n\n self._accounts = accounts", "def __init__(self, parent=None):\n super(QAccountWidget, self).__init__(parent)\n self.setupUi(self)", "def append_control(self, control):\n\n self._control_manager.append_control(control)", "def add_control(self, name, control_object):\n if name in self._controls:\n raise ValueError('The name provided for the control is already used. Please either remove the control with that name first or use a different name for this control.')\n self._controls[name] = control_object", "def accounts():", "def add_callback(callback, control_instance):\n pass", "def _add_control( self, control ):\r\n try:\r\n succeeded = True\r\n control[ \"special\" ] = False\r\n if ( self.use_desc_as_key ): key = control[ \"description\" ]\r\n else: key = control[ \"id\" ]\r\n # image control\r\n if ( control[ \"type\" ] == \"image\" ):\r\n if ( control[ \"info\" ] ):\r\n control[ \"texture\" ] = xbmc.getInfoImage( control[ \"info\" ][ 0 ] )\r\n current_control = xbmcgui.ControlImage(\r\n x = control[ \"posx\" ],\r\n y = control[ \"posy\" ],\r\n width = control[ \"width\" ],\r\n height = control[ \"height\" ],\r\n filename = control[ \"texture\" ],\r\n colorKey = control[ \"colorkey\" ],\r\n aspectRatio = control[ \"aspectratio\" ],\r\n colorDiffuse = control[ \"colordiffuse\" ]\r\n )\r\n self.win.addControl( current_control )\r\n # progress control\r\n elif ( control[ \"type\" ] == \"progress\" ):\r\n current_control = xbmcgui.ControlProgress(\r\n x = control[ \"posx\" ],\r\n y = control[ \"posy\" ],\r\n width = control[ \"width\" ],\r\n height = control[ \"height\" ],\r\n texturebg = control[ \"texturebg\" ],\r\n textureleft = control[ \"lefttexture\" ],\r\n texturemid = control[ \"midtexture\" ],\r\n textureright = control[ \"righttexture\" ],\r\n textureoverlay = control[ \"overlaytexture\" ]\r\n )\r\n self.win.addControl( current_control )\r\n # label control\r\n elif ( control[ \"type\" ] == \"label\" ):\r\n if ( control[ \"info\" ] ):\r\n control[ \"label\" ][ 0 ] = xbmc.getInfoLabel( control[ \"info\" ][ 0 ] )\r\n current_control = xbmcgui.ControlLabel(\r\n x = control[ \"posx\" ],\r\n y = control[ \"posy\" ],\r\n width = control[ \"width\" ],\r\n height = control[ \"height\" ],\r\n label = control[ \"label\" ][ 0 ],\r\n font = control[ \"font\" ],\r\n textColor = control[ \"textcolor\" ],\r\n disabledColor = control[ \"disabledcolor\" ],\r\n alignment = control[ \"align\" ],\r\n hasPath = control[ \"haspath\" ],\r\n #shadowColor = control[ \"shadowcolor\" ],\r\n angle = control[ \"angle\" ]\r\n )\r\n self.win.addControl( current_control )\r\n # button control\r\n elif ( control[ \"type\" ] == \"button\" ):\r\n if ( control[ \"info\" ] ):\r\n control[ \"label\" ][ 0 ] = xbmc.getInfoLabel( control[ \"info\" ][ 0 ] )\r\n current_control = xbmcgui.ControlButton(\r\n x = control[ \"posx\" ],\r\n y = control[ \"posy\"],\r\n width = control[ \"width\" ],\r\n height = control[ \"height\" ],\r\n label = control[ \"label\" ][ 0 ],\r\n font = control[ \"font\" ],\r\n textColor = control[ \"textcolor\" ],\r\n focusedColor = control[ \"focusedcolor\" ],\r\n disabledColor = control[ \"disabledcolor\" ],\r\n alignment = control[ \"align\" ],\r\n angle = control[ \"angle\" ],\r\n shadowColor = control[ \"shadowcolor\" ],\r\n focusTexture = control[ \"texturefocus\" ],\r\n noFocusTexture = control[ \"texturenofocus\" ],\r\n textXOffset = control[ \"textoffsetx\" ],\r\n textYOffset = control[ \"textoffsety\"]\r\n )\r\n self.win.addControl( current_control )\r\n # checkmark control\r\n elif ( control[ \"type\" ] == \"checkmark\" ):\r\n if ( control[ \"info\" ] ):\r\n control[ \"label\" ][ 0 ] = xbmc.getInfoLabel( control[ \"info\" ][ 0 ] )\r\n current_control = xbmcgui.ControlCheckMark(\r\n x = control[ \"posx\" ],\r\n y = control[ \"posy\" ],\r\n width = control[ \"width\" ],\r\n height = control[ \"height\" ],\r\n label = control[ \"label\" ][ 0 ],\r\n font = control[ \"font\" ],\r\n textColor = control[ \"textcolor\" ],\r\n disabledColor = control[ \"disabledcolor\" ],\r\n alignment = control[ \"align\" ],\r\n focusTexture = control[ \"texturecheckmark\" ],\r\n noFocusTexture = control[ \"texturecheckmarknofocus\" ],\r\n checkWidth = control[ \"markwidth\" ],\r\n checkHeight = control[ \"markheight\" ]\r\n )\r\n self.win.addControl( current_control )\r\n # textbox control\r\n elif ( control[ \"type\" ] == \"textbox\" ):\r\n if ( control[ \"info\" ] ):\r\n control[ \"label\" ][ 0 ] = xbmc.getInfoLabel( control[ \"info\" ][ 0 ] )\r\n current_control = xbmcgui.ControlTextBox(\r\n x = control[ \"posx\" ],\r\n y = control[ \"posy\" ],\r\n width = control[ \"width\" ],\r\n height = control[ \"height\" ],\r\n font = control[ \"font\" ],\r\n textColor = control[ \"textcolor\" ]\r\n )\r\n self.win.addControl( current_control )\r\n if ( \"label\" in control ): current_control.setText( control[ \"label\" ][ 0 ] )\r\n #fadelabel control\r\n elif ( control[ \"type\" ] == \"fadelabel\" ):\r\n current_control = xbmcgui.ControlFadeLabel(\r\n x = control[ \"posx\" ],\r\n y = control[ \"posy\" ],\r\n width = control[ \"width\" ],\r\n height = control[ \"height\" ],\r\n font = control[ \"font\" ],\r\n textColor = control[ \"textcolor\" ],\r\n #shadowColor = control[ \"shadowcolor\" ],\r\n alignment = control[ \"align\" ]\r\n )\r\n self.win.addControl( current_control )\r\n if ( control[ \"info\" ] ):\r\n for item in control[ \"info\" ]:\r\n if ( item != \"\" ): current_control.addLabel( xbmc.getInfoLabel( item ) )\r\n if ( control[ \"label\" ] ):\r\n for item in control[ \"label\" ]:\r\n if ( item != \"\" ): current_control.addLabel( item )\r\n # list control\r\n elif ( control[ \"type\" ] == \"list\" or control[ \"type\" ] == \"listcontrol\" ):\r\n current_control = xbmcgui.ControlList(\r\n x = control[ \"posx\" ],\r\n y = control[ \"posy\" ],\r\n width = control[ \"width\" ],\r\n height = control[ \"height\" ],\r\n font = control[ \"font\" ],\r\n textColor = control[ \"textcolor\" ],\r\n alignmentY = control[ \"aligny\" ],\r\n buttonTexture = control[ \"texturenofocus\" ],\r\n buttonFocusTexture = control[ \"texturefocus\" ],\r\n selectedColor = control[ \"selectedcolor\" ],\r\n imageWidth = control[ \"itemwidth\" ],\r\n imageHeight = control[ \"itemheight\" ],\r\n itemTextXOffset = control[ \"textxoff\" ],\r\n itemTextYOffset = control[ \"textyoff\" ],\r\n itemHeight = control[ \"textureheight\" ],\r\n #shadowColor=control[\"shadowcolor\"],\r\n space = control[ \"spacebetweenitems\" ]\r\n )\r\n self.win.addControl( current_control )\r\n current_control.setPageControlVisible( not control[ \"hidespinner\" ] )\r\n control[ \"special\" ] = control[ \"hidespinner\" ]\r\n if ( control[ \"label\" ] ):\r\n for cnt, item in enumerate( control[ \"label\" ] ):\r\n if ( item != \"\" ): \r\n if ( cnt < len( control[ \"label2\" ] ) ): tmp = control[ \"label2\" ][ cnt ]\r\n else: tmp = \"\"\r\n if ( cnt < len( control[ \"image\" ] ) ): tmp2 = control[ \"image\" ][ cnt ]\r\n elif control[ \"image\" ]: tmp2 = control[ \"image\" ][ len( control[ \"image\" ] ) - 1 ]\r\n else: tmp2 = \"\"\r\n list_item = xbmcgui.ListItem( item, tmp, tmp2, tmp2 )\r\n current_control.addItem( list_item )\r\n \r\n self.win.controls[ key ] = {\r\n \"id\"\t\t\t: control[ \"id\" ],\r\n \"controlId\"\t: current_control.getId(),\r\n \"control\"\t\t: current_control,\r\n \"special\"\t\t: control[ \"special\" ],\r\n \"visible\"\t\t: [ control[ \"visible\" ].lower(), control[ \"allowhiddenfocus\" ] ],\r\n \"enable\"\t\t: control[ \"enable\" ].lower(),\r\n \"animation\"\t: control[ \"animation\" ],\r\n \"onclick\"\t\t: control[ \"onclick\" ],\r\n \"onfocus\"\t: control[ \"onfocus\" ]\r\n }\r\n self.navigation[ control[ \"id\" ] ] = ( key, int( control[ \"onup\" ] ), int( control[ \"ondown\" ] ), int( control[ \"onleft\" ] ), int( control[ \"onright\" ] ) )\r\n except:\r\n succeeded = False\r\n return succeeded", "def __init__(self, label, account):\n self.label = label\n self.account = account", "def save_account(self):\n Credential.account_list.append(self)", "def _append_account(self, credentials):\n # Check if duplicated credentials are already in use. By convention,\n # we assume (hub, group, project) is always unique.\n if credentials.unique_id() in self._accounts.keys():\n raise IBMQAccountError('Credentials are already in use')\n\n single_provider = IBMQSingleProvider(credentials, self)\n self._accounts[credentials.unique_id()] = single_provider\n\n return single_provider", "def accounts():\n pass", "def set_controls(self):\n # Image control\n image = pyxbmct.Image(addonfolder+artsfolder+'/tvh.png')\n self.placeControl(image, 0, 0, rowspan=8, columnspan=16)\n\n\t\t# Label information\n image = pyxbmct.Image(addonfolder+artsfolder+'/users.png')\n self.placeControl(image, 8, 1, rowspan=1, columnspan=14)\n\t\t\n\t\t# Username input\n image = pyxbmct.Image(addonfolder+artsfolder+'/username.png')\n self.placeControl(image, 10, 1, rowspan=1, columnspan=3)\n self.username_input = pyxbmct.Edit('')\n self.placeControl(self.username_input, 10, 4, rowspan=1, columnspan=4)\n\n\t\t# Password input\n image = pyxbmct.Image(addonfolder+artsfolder+'/password.png')\n self.placeControl(image, 11, 1, rowspan=1, columnspan=3)\n self.password_input = pyxbmct.Edit('', isPassword=True)\n self.placeControl(self.password_input, 11, 4, rowspan=1, columnspan=4)\n\n\t\t# Next button\n self.next_button = pyxbmct.Button('Next')\n self.placeControl(self.next_button, 13, 14, rowspan=1, columnspan=1)\n # Connect close button\n self.connect(self.next_button, lambda: self.page())\n\t\t\n\t\t# Close button\n self.close_button = pyxbmct.Button('Exit')\n self.placeControl(self.close_button, 13, 15, rowspan=1, columnspan=1)\n self.connect(self.close_button, lambda: self.closepage())", "def accounts(self):\r\n return Accounts(self)", "def add(self, account):\n if isinstance(account, Account) and account not in self.account:\n self.account.append(account)", "def AddControl(self, control, label=\"\"):\r\n\r\n item = AuiToolBarItem()\r\n item.window = control\r\n item.label = label\r\n item.bitmap = wx.NullBitmap\r\n item.disabled_bitmap = wx.NullBitmap\r\n item.active = True\r\n item.dropdown = False\r\n item.spacer_pixels = 0\r\n item.id = control.GetId()\r\n item.state = 0\r\n item.proportion = 0\r\n item.kind = ITEM_CONTROL\r\n item.sizer_item = None\r\n item.min_size = control.GetEffectiveMinSize()\r\n item.user_data = 0\r\n item.sticky = False\r\n item.orientation = self._tool_orientation\r\n\r\n self._items.append(item)\r\n return self._items[-1]", "def add_control(self, iot_control):\n if isinstance(iot_control, Alarm):\n iot_control.message_tx_event += self.send_alarm\n key = iot_control.msg_type + \"_\" + iot_control.control_id\n self.alarm_dict[key] = iot_control\n else:\n if isinstance(iot_control, Page):\n self.number_of_pages += 1\n iot_control.message_tx_event += self.send_data\n key = iot_control.msg_type + \"_\" + iot_control.control_id\n self.control_dict[key] = iot_control", "def set_controls(self):\n # Image control\n image = pyxbmct.Image(addonfolder+artsfolder+'/osc.png')\n self.placeControl(image, 0, 0, rowspan=8, columnspan=16)\n\n\t\t# Label information\n image = pyxbmct.Image(addonfolder+artsfolder+'/users.png')\n self.placeControl(image, 8, 1, rowspan=1, columnspan=14)\n\t\t\n\t\t# Username input\n image = pyxbmct.Image(addonfolder+artsfolder+'/username.png')\n self.placeControl(image, 10, 1, rowspan=1, columnspan=3)\n self.username_input = pyxbmct.Edit('')\n self.placeControl(self.username_input, 10, 4, rowspan=1, columnspan=4)\n self.username_input.setText('oscam')\n\t\t\n\t\t# Password input\n image = pyxbmct.Image(addonfolder+artsfolder+'/password.png')\n self.placeControl(image, 11, 1, rowspan=1, columnspan=3)\n self.password_input = pyxbmct.Edit('', isPassword=True)\n self.placeControl(self.password_input, 11, 4, rowspan=1, columnspan=4)\n self.password_input.setText('oscam')\n\t\t\n\t\t# Port input\n image = pyxbmct.Image(addonfolder+artsfolder+'/port.png')\n self.placeControl(image, 12, 1, rowspan=1, columnspan=3)\n self.port_input = pyxbmct.Edit('')\n self.placeControl(self.port_input, 12, 4, rowspan=1, columnspan=4)\n self.port_input.setText('8888')\n\t\t\n\t\t# Next button\n self.next_button = pyxbmct.Button('Next')\n self.placeControl(self.next_button, 13, 14, rowspan=1, columnspan=1)\n # Connect close button\n self.connect(self.next_button, lambda: self.page())\n\t\t\n\t\t# Close button\n self.close_button = pyxbmct.Button('Exit')\n self.placeControl(self.close_button, 13, 15, rowspan=1, columnspan=1)\n self.connect(self.close_button, lambda: self.closepage())", "def __set_accion(self, widget, modo, accion):\n self.__cancel_toolbars()\n if accion == \"Salir\":\n self.toolbar.switch(\"menu\")\n\n else:\n self.base_panel.set_accion(modo, accion)", "def setAccountsDispatcher(self, accounts, callback):\n self.ws.setAccountsDispatcher(accounts, callback)", "def EventContentMissionExcelAddAccountType(builder, AccountType):\n return AddAccountType(builder, AccountType)", "def change_account(self, account):\r\n check_account = Account(account, steem_instance=self.steem)\r\n self.account = check_account[\"name\"]\r\n self.refresh()" ]

[ "0.621743", "0.5511488", "0.55006987", "0.54347086", "0.54347086", "0.54347086", "0.54347086", "0.53059524", "0.5241029", "0.52371526", "0.52322316", "0.5176735", "0.51662064", "0.5137405", "0.5110972", "0.50961804", "0.5025272", "0.5015871", "0.5009514", "0.500842", "0.49696615", "0.49680346", "0.4945535", "0.49419397", "0.49213827", "0.492126", "0.49168217", "0.48898825", "0.48726198", "0.48672906" ]

[ "def set_limit_max():\n limit_max = request.params.get(\"limit_max\", 0, type=float)\n output = request.params.get(\"output\", 1, type=int)\n retval = RP_LIB.rp_LimitMax(output, ctypes.c_float(limit_max))\n if retval != 0:\n LOG.error(\"Failed to set maximum output voltage. Error code: %s\", ERROR_CODES[retval])", "def setMaxValue(self, max_value):\r\n\t\tself.MaxValue = max_value", "def setMaxValue(self, max_value):\r\n\t\tself.MaxValue = max_value", "def set_max(self, val):\n self._max = val", "def set_maxVal(self, val):\n self.maxVal = val", "def limit(self, limit):\n raise NotImplementedError(\"This should have been implemented.\")", "def set_max(self, max):\n self.set_val((self.val[0], max))", "def limit(self, limit):\n self._evaluated = False\n self._limit = limit\n return self", "async def max(self, ctx, limit: int):\n self.data_check(ctx)\n server = ctx.message.server\n\n self.riceCog2[server.id][\"max\"] = limit\n dataIO.save_json(self.warning_settings,\n self.riceCog2)\n await self.bot.say(\"Warn limit is now: \\n{}\".format(limit))", "def _set_maximum(self):\n self._level_gen.maximum_length = self._maximum_length_spinbox.value()\n self._refresh_view()", "def set_Limit(self, value):\n super(DescribeEvaluationsInputSet, self)._set_input('Limit', value)", "def limit(self, limit):\n self._limit = limit", "def userMaximum(self, new_max: float) -> None:\n self._user_maximum = new_max\n self.reset_limits()", "def max_price(self, new_max_price):\n self._max_price = new_max_price", "def max_voltage_limit(self, value):\n self._write(MX_MAX_VOLTAGE_LIMIT, value)", "def abs_max_cool_setpoint_limit(self) -> int:\n return self.cluster.get(\"abs_max_cool_setpoint_limit\", 3200)", "def _set_bet_limit(self) -> None:\n for i, ratio in enumerate(BET_LIMIT_RATIOS):\n self._bet_limits[i] = self._treasury_min.get() // ratio", "def SetAntLimit(cls, value=0):\n cls.antLimit = value", "def set_maximum_iterations(self, n):\n self.maximum_iterations = n\n return", "def limit(self, limit):\n\n self._limit = limit", "def limit(self, limit):\n\n self._limit = limit", "def limit(self, limit):\n\n self._limit = limit", "def adaptive_limit(self) -> int:\n return pulumi.get(self, \"adaptive_limit\")", "def SetLimit(self, *args):\n return _BRepAlgo.BRepAlgo_NormalProjection_SetLimit(self, *args)", "def set_limit(self, limit):\n self.limit = limit\n self._prune()", "def setmaxsize(self, maxsize):\n self.maxsize = maxsize", "def set_max(calories, max_calories):\n return calories if calories > max_calories else max_calories", "def set_maximum(self, max_value):\n\n self._progress.setMaximum(max_value)", "def setMaxValue(self, max_value):\r\n\t\tself.MaxValue = max_value\r\n\t\tself.OutputValueIncrement = (self.MaxValue - self.MinValue)/(self.RampDuration/self.Ts)", "def setMaxValue(self, max_value):\r\n\t\tself.MaxValue = max_value\r\n\t\tself.OutputValueIncrement = (self.MaxValue - self.MinValue)/(self.RampDuration/self.Ts)" ]

[ "0.724919", "0.7016326", "0.7016326", "0.6927392", "0.6867965", "0.6846231", "0.6833265", "0.6795299", "0.67814326", "0.67062867", "0.6705914", "0.66737866", "0.6662624", "0.6634589", "0.6630519", "0.6624588", "0.65863127", "0.6568773", "0.6564483", "0.6545328", "0.6545328", "0.6545328", "0.6539919", "0.6534052", "0.65061104", "0.65049994", "0.64936507", "0.6465193", "0.64475447", "0.64475447" ]

[ "def register_account_control(self, control):\n if self.initialized:\n raise RegisterAccountControlPostInit()\n self.account_controls.append(control)", "def add_control(self, iot_control):\n if isinstance(iot_control, Alarm):\n iot_control.message_tx_event += self.send_alarm\n key = iot_control.msg_type + \"_\" + iot_control.control_id\n self.alarm_dict[key] = iot_control\n else:\n if isinstance(iot_control, Page):\n self.number_of_pages += 1\n iot_control.message_tx_event += self.send_data\n key = iot_control.msg_type + \"_\" + iot_control.control_id\n self.control_dict[key] = iot_control", "def addControl(*args):", "def addControl(*args):", "def addControl(*args):", "def addControl(*args):", "def test_add_control(perfectModelEnsemble_initialized_control):\n assert perfectModelEnsemble_initialized_control.get_control()", "def add_control(operation, num_ctrl_qubits, label):\n if isinstance(operation, UnitaryGate):\n # attempt decomposition\n operation._define()\n if _control_definition_known(operation, num_ctrl_qubits):\n return _control_predefined(operation, num_ctrl_qubits)\n return control(operation, num_ctrl_qubits=num_ctrl_qubits, label=label)", "def add_control(self, name, control_object):\n if name in self._controls:\n raise ValueError('The name provided for the control is already used. Please either remove the control with that name first or use a different name for this control.')\n self._controls[name] = control_object", "def before_trading_start(context, data):", "def add_callback(callback, control_instance):\n pass", "def control(self, control):\n # * a function called as ``f(vehicle, t, x)`` that returns a tuple\n # * an interpolator called as f(t) that returns a tuple, see\n # SciPy interp1d\n\n self._control = control\n if isinstance(control, VehicleDriver):\n # if this is a driver agent, connect it to the vehicle\n control.vehicle = self", "def append_control(self, control):\n\n self._control_manager.append_control(control)", "def register_trader(self):\n trader = self.market.add_trader()\n return jsonify({'id': trader.id, 'cash': trader.cash, 'stocks': trader.stocks})", "def _registerEvent(self):\n # new DyStockDataTicksGateway instance for each ticks hand to avoid mutex\n self._ticksGateways = [DyStockDataTicksGateway(self._eventEngine, self._info, i) for i in range(DyStockDataEventHandType.stockHistTicksHandNbr)]", "def _add_control( self, control ):\r\n try:\r\n succeeded = True\r\n control[ \"special\" ] = False\r\n if ( self.use_desc_as_key ): key = control[ \"description\" ]\r\n else: key = control[ \"id\" ]\r\n # image control\r\n if ( control[ \"type\" ] == \"image\" ):\r\n if ( control[ \"info\" ] ):\r\n control[ \"texture\" ] = xbmc.getInfoImage( control[ \"info\" ][ 0 ] )\r\n current_control = xbmcgui.ControlImage(\r\n x = control[ \"posx\" ],\r\n y = control[ \"posy\" ],\r\n width = control[ \"width\" ],\r\n height = control[ \"height\" ],\r\n filename = control[ \"texture\" ],\r\n colorKey = control[ \"colorkey\" ],\r\n aspectRatio = control[ \"aspectratio\" ],\r\n colorDiffuse = control[ \"colordiffuse\" ]\r\n )\r\n self.win.addControl( current_control )\r\n # progress control\r\n elif ( control[ \"type\" ] == \"progress\" ):\r\n current_control = xbmcgui.ControlProgress(\r\n x = control[ \"posx\" ],\r\n y = control[ \"posy\" ],\r\n width = control[ \"width\" ],\r\n height = control[ \"height\" ],\r\n texturebg = control[ \"texturebg\" ],\r\n textureleft = control[ \"lefttexture\" ],\r\n texturemid = control[ \"midtexture\" ],\r\n textureright = control[ \"righttexture\" ],\r\n textureoverlay = control[ \"overlaytexture\" ]\r\n )\r\n self.win.addControl( current_control )\r\n # label control\r\n elif ( control[ \"type\" ] == \"label\" ):\r\n if ( control[ \"info\" ] ):\r\n control[ \"label\" ][ 0 ] = xbmc.getInfoLabel( control[ \"info\" ][ 0 ] )\r\n current_control = xbmcgui.ControlLabel(\r\n x = control[ \"posx\" ],\r\n y = control[ \"posy\" ],\r\n width = control[ \"width\" ],\r\n height = control[ \"height\" ],\r\n label = control[ \"label\" ][ 0 ],\r\n font = control[ \"font\" ],\r\n textColor = control[ \"textcolor\" ],\r\n disabledColor = control[ \"disabledcolor\" ],\r\n alignment = control[ \"align\" ],\r\n hasPath = control[ \"haspath\" ],\r\n #shadowColor = control[ \"shadowcolor\" ],\r\n angle = control[ \"angle\" ]\r\n )\r\n self.win.addControl( current_control )\r\n # button control\r\n elif ( control[ \"type\" ] == \"button\" ):\r\n if ( control[ \"info\" ] ):\r\n control[ \"label\" ][ 0 ] = xbmc.getInfoLabel( control[ \"info\" ][ 0 ] )\r\n current_control = xbmcgui.ControlButton(\r\n x = control[ \"posx\" ],\r\n y = control[ \"posy\"],\r\n width = control[ \"width\" ],\r\n height = control[ \"height\" ],\r\n label = control[ \"label\" ][ 0 ],\r\n font = control[ \"font\" ],\r\n textColor = control[ \"textcolor\" ],\r\n focusedColor = control[ \"focusedcolor\" ],\r\n disabledColor = control[ \"disabledcolor\" ],\r\n alignment = control[ \"align\" ],\r\n angle = control[ \"angle\" ],\r\n shadowColor = control[ \"shadowcolor\" ],\r\n focusTexture = control[ \"texturefocus\" ],\r\n noFocusTexture = control[ \"texturenofocus\" ],\r\n textXOffset = control[ \"textoffsetx\" ],\r\n textYOffset = control[ \"textoffsety\"]\r\n )\r\n self.win.addControl( current_control )\r\n # checkmark control\r\n elif ( control[ \"type\" ] == \"checkmark\" ):\r\n if ( control[ \"info\" ] ):\r\n control[ \"label\" ][ 0 ] = xbmc.getInfoLabel( control[ \"info\" ][ 0 ] )\r\n current_control = xbmcgui.ControlCheckMark(\r\n x = control[ \"posx\" ],\r\n y = control[ \"posy\" ],\r\n width = control[ \"width\" ],\r\n height = control[ \"height\" ],\r\n label = control[ \"label\" ][ 0 ],\r\n font = control[ \"font\" ],\r\n textColor = control[ \"textcolor\" ],\r\n disabledColor = control[ \"disabledcolor\" ],\r\n alignment = control[ \"align\" ],\r\n focusTexture = control[ \"texturecheckmark\" ],\r\n noFocusTexture = control[ \"texturecheckmarknofocus\" ],\r\n checkWidth = control[ \"markwidth\" ],\r\n checkHeight = control[ \"markheight\" ]\r\n )\r\n self.win.addControl( current_control )\r\n # textbox control\r\n elif ( control[ \"type\" ] == \"textbox\" ):\r\n if ( control[ \"info\" ] ):\r\n control[ \"label\" ][ 0 ] = xbmc.getInfoLabel( control[ \"info\" ][ 0 ] )\r\n current_control = xbmcgui.ControlTextBox(\r\n x = control[ \"posx\" ],\r\n y = control[ \"posy\" ],\r\n width = control[ \"width\" ],\r\n height = control[ \"height\" ],\r\n font = control[ \"font\" ],\r\n textColor = control[ \"textcolor\" ]\r\n )\r\n self.win.addControl( current_control )\r\n if ( \"label\" in control ): current_control.setText( control[ \"label\" ][ 0 ] )\r\n #fadelabel control\r\n elif ( control[ \"type\" ] == \"fadelabel\" ):\r\n current_control = xbmcgui.ControlFadeLabel(\r\n x = control[ \"posx\" ],\r\n y = control[ \"posy\" ],\r\n width = control[ \"width\" ],\r\n height = control[ \"height\" ],\r\n font = control[ \"font\" ],\r\n textColor = control[ \"textcolor\" ],\r\n #shadowColor = control[ \"shadowcolor\" ],\r\n alignment = control[ \"align\" ]\r\n )\r\n self.win.addControl( current_control )\r\n if ( control[ \"info\" ] ):\r\n for item in control[ \"info\" ]:\r\n if ( item != \"\" ): current_control.addLabel( xbmc.getInfoLabel( item ) )\r\n if ( control[ \"label\" ] ):\r\n for item in control[ \"label\" ]:\r\n if ( item != \"\" ): current_control.addLabel( item )\r\n # list control\r\n elif ( control[ \"type\" ] == \"list\" or control[ \"type\" ] == \"listcontrol\" ):\r\n current_control = xbmcgui.ControlList(\r\n x = control[ \"posx\" ],\r\n y = control[ \"posy\" ],\r\n width = control[ \"width\" ],\r\n height = control[ \"height\" ],\r\n font = control[ \"font\" ],\r\n textColor = control[ \"textcolor\" ],\r\n alignmentY = control[ \"aligny\" ],\r\n buttonTexture = control[ \"texturenofocus\" ],\r\n buttonFocusTexture = control[ \"texturefocus\" ],\r\n selectedColor = control[ \"selectedcolor\" ],\r\n imageWidth = control[ \"itemwidth\" ],\r\n imageHeight = control[ \"itemheight\" ],\r\n itemTextXOffset = control[ \"textxoff\" ],\r\n itemTextYOffset = control[ \"textyoff\" ],\r\n itemHeight = control[ \"textureheight\" ],\r\n #shadowColor=control[\"shadowcolor\"],\r\n space = control[ \"spacebetweenitems\" ]\r\n )\r\n self.win.addControl( current_control )\r\n current_control.setPageControlVisible( not control[ \"hidespinner\" ] )\r\n control[ \"special\" ] = control[ \"hidespinner\" ]\r\n if ( control[ \"label\" ] ):\r\n for cnt, item in enumerate( control[ \"label\" ] ):\r\n if ( item != \"\" ): \r\n if ( cnt < len( control[ \"label2\" ] ) ): tmp = control[ \"label2\" ][ cnt ]\r\n else: tmp = \"\"\r\n if ( cnt < len( control[ \"image\" ] ) ): tmp2 = control[ \"image\" ][ cnt ]\r\n elif control[ \"image\" ]: tmp2 = control[ \"image\" ][ len( control[ \"image\" ] ) - 1 ]\r\n else: tmp2 = \"\"\r\n list_item = xbmcgui.ListItem( item, tmp, tmp2, tmp2 )\r\n current_control.addItem( list_item )\r\n \r\n self.win.controls[ key ] = {\r\n \"id\"\t\t\t: control[ \"id\" ],\r\n \"controlId\"\t: current_control.getId(),\r\n \"control\"\t\t: current_control,\r\n \"special\"\t\t: control[ \"special\" ],\r\n \"visible\"\t\t: [ control[ \"visible\" ].lower(), control[ \"allowhiddenfocus\" ] ],\r\n \"enable\"\t\t: control[ \"enable\" ].lower(),\r\n \"animation\"\t: control[ \"animation\" ],\r\n \"onclick\"\t\t: control[ \"onclick\" ],\r\n \"onfocus\"\t: control[ \"onfocus\" ]\r\n }\r\n self.navigation[ control[ \"id\" ] ] = ( key, int( control[ \"onup\" ] ), int( control[ \"ondown\" ] ), int( control[ \"onleft\" ] ), int( control[ \"onright\" ] ) )\r\n except:\r\n succeeded = False\r\n return succeeded", "def set_control(self, control):\n self.o.write_register(self.dev_id, CONTROL, control)", "def replace_control(self, control: cat.Control) -> None:\n self._control_dict[control.id].control = control", "def add(self, timer):\n # Give timer info about the registry and service\n timer.registered(self)\n \n # Update timer so it has the correct time\n timer.update()\n \n # Insert it into the chain\n self.insert(timer)", "def orderWatch(self, order):\r\n\t\tself.orders.append(order)", "def check(cls, control_instance):\n pass", "def add_inputt(self, name='T', control=False):\n inpt = InputT(name=name)\n self.nodes[name] = inpt\n self.rc.add_node(inpt)\n if control: # control input\n if name in self.inp.keys():\n raise Exception('Input temperature already defined')\n self.inp[name] = inpt\n else: # disturbance\n if name in self.dist.keys():\n raise Exception('Input temperature already defined')\n self.dist[name] = inpt", "def start_tracking_order(self,\n order_id: str,\n exchange_order_id: str,\n trading_pair: str,\n trade_type: TradeType,\n price: Decimal,\n amount: Decimal):\n self._in_flight_orders[order_id] = TerraInFlightOrder(\n client_order_id=order_id,\n exchange_order_id=exchange_order_id,\n trading_pair=trading_pair,\n order_type=OrderType.LIMIT,\n trade_type=trade_type,\n price=price,\n amount=amount\n )", "def place_order_ts(self, instrument, lower, upper, units=1, side_arg='buy'):\n return self.oanda.create_order(self.account_id, instrument=instrument,\n units=units, side=side_arg,\n trailingStop=lower, takeProfit=upper,\n type='market')", "def place_order(self, order: Order) -> None:\n\n if order.id in [order.id for order in self.orders]:\n raise OrderAlreadyCreatedError(order)\n\n if not order.symbol.is_enabled:\n raise SymbolIsNotEnabledError(order.symbol)\n\n t = Thread(target=self.__place_order, args=(order,))\n t.start()\n\n self.__sort_orders_by_price()", "def register(self, predictor):\n assert self.round == 0, \"Simulation is already running: \" + \\\n \"Predictors can not be added any more!\"\n#würde \"register\" abbrechen, wenn self.round > 0 ist,\n# dient nur der Programmsicherheit\n\n if isinstance(predictor, MetaInductivist):\n self.miList.append(predictor)\n else:\n self.non_miList.append(predictor)\n self.favN[predictor.name] = 0\n self.absucc[predictor.name] = 0\n self.nonultdeceivers.append(predictor)\n self.deceiveCount[predictor.name] = 0\n self.deceiveState[predictor.name] = False\n \n predictor.registeredBy(self)\n #print str(predictor)", "def register(self, carrier):\n self.carriers[carrier.name] = carrier()", "def set_control(self, value):\n self.control = value", "def enableCheckBoxTriState( self, cCtrlName, bTriStateEnable ):\n oControl = self.getControl( cCtrlName )\n oControl.enableTriState( bTriStateEnable )", "def orderWatch(self, order):\r\n\t\tself.pair.orders.append(order)" ]

[ "0.6567349", "0.5557626", "0.55111516", "0.55111516", "0.55111516", "0.55111516", "0.5382541", "0.53327614", "0.52990526", "0.5287516", "0.5225305", "0.5105157", "0.50551075", "0.4919047", "0.48890963", "0.48584044", "0.48385772", "0.4827087", "0.47736055", "0.47574076", "0.4741037", "0.4655364", "0.461044", "0.4591117", "0.45862922", "0.45512375", "0.4542376", "0.45372692", "0.45304897", "0.45234993" ]

[ "def strict_limit(self, strict_limit):\n\n self._strict_limit = strict_limit", "def limit_chase(self, oq, max_chase=3.0, failsafe=False, double_check=False):\n ret = self.send_order(oq=oq, ot='limit', price=None)\n order_id = ret[0]['orderID']\n last_price = ret[0]['price']\n side = ret[0]['side']\n max_chase_buy = float(last_price) + float(max_chase)\n max_chase_sell = float(last_price) - float(max_chase)\n avg = last_price\n time.sleep(1)\n self.logger.info(\n f'Chasing {side} order {order_id}, order_price: {avg}, last_price: {last_price}, '\n f'current price: {last_price} max chase: {max_chase_buy}')\n count = 0\n while True:\n count += 1\n o = self.ws_orders(order_id)\n if o:\n if side == 'Buy':\n if double_check:\n quote = self.get_quote()\n self.logger.info('Bid: {} Ask: {}'.format(quote['bidPrice'], quote['askPrice']))\n _price = quote['buy']\n else:\n _price = self.ws.get_ticker()['buy']\n if float(_price) <= float(max_chase_buy):\n if float(last_price) < float(_price):\n self.logger.info(f'Amending order {order_id} to price {_price}')\n ret = self.client.Order.Order_amend(orderID=order_id, price=_price).result()\n self.logger.info(ret)\n last_price = _price\n else:\n self.logger.debug(f'Sleeping, order_price: {last_price}, current price: {_price}')\n if double_check:\n time.sleep(0.5)\n\n else:\n if failsafe:\n self.logger.info(f'Order {order_id} exceeded max chase. Placing a market order.')\n self.client.Order.Order_cancel(orderID=order_id).result()\n self.send_order(oq, 'market', text='OrderChase Market Failsafe')\n else:\n self.logger.info(f'Price {_price} exceeded max chase {max_chase_buy}, giving up.')\n self.client.Order.Order_cancel(orderID=order_id).result()\n break\n elif side == 'Sell':\n if double_check:\n quote = self.get_quote()\n self.logger.info('Bid: {} Ask: {}'.format(quote['bidPrice'], quote['askPrice']))\n _price = quote['sell']\n else:\n _price = self.ws.get_ticker()['sell']\n if float(_price) >= float(max_chase_sell):\n if float(last_price) > float(_price):\n self.logger.info(f'Amending order {order_id} to price {_price} ')\n ret = self.client.Order.Order_amend(orderID=order_id, price=_price).result()\n self.logger.info(ret)\n last_price = _price\n else:\n self.logger.debug(f'Sleeping, order_price: {last_price}, current price: {_price}')\n if double_check:\n time.sleep(0.5)\n\n else:\n if failsafe:\n self.logger.info(f'Order {order_id} exceeded max chase. Placing a market order.')\n self.client.Order.Order_cancel(orderID=order_id).result()\n self.send_order(oq, 'market', text='OrderChase Market Failsafe')\n else:\n self.logger.info(f'Price {_price} exceeded max chase {max_chase_buy}, giving up.')\n self.client.Order.Order_cancel(orderID=order_id).result()\n break\n else:\n time.sleep(0.5)\n if o:\n self.logger.info(f'{side} Order manually Canceled!')\n self.logger.info('Order Filled')\n break", "def limit(self, side, order_id, quantity, price):\n Library.functions.limit(self._book, side, order_id, quantity, price)", "def place_limit_order(self, side, symbol, size, price, **kwargs):\n pass", "def set_max_order_count(self, max_count, on_error='fail'):\n control = MaxOrderCount(on_error, max_count)\n self.register_trading_control(control)", "def limit(self, limit):\n raise NotImplementedError(\"This should have been implemented.\")", "def set_limit(limit_name, value):\n LIMITS[limit_name] = value", "def charge_limit(self, limit=None):\n if limit is None:\n done, data = self._request('GH')\n if done:\n return int(data[0])\n else:\n if self._request('SH', str(int(limit)))[0]:\n return limit\n\n raise EvseError", "def limit(self, amount):\n self._limit = amount\n return self", "def market_sell_limit(self, market_symbol, quantity, rate, time_in_force='GOOD_TIL_CANCELLED'):\n return self.post('orders', {\n 'marketSymbol': market_symbol,\n 'direction': 'SELL',\n 'type': 'LIMIT',\n 'quantity': quantity,\n 'limit': rate,\n 'timeInForce': time_in_force\n }, auth=True)", "def limit_buy(self, order_id, quantity, price):\n Library.functions.limit_buy(self._book, order_id, quantity, price)", "def limit(self, limit):\n self._limit = limit", "def _create_limit(self, price_limit):\n if self.price_limit is not None:\n return(order(self.symbol, -self.volume, style=LimitOrder(self.price_limit)))\n else:\n return", "def limit_sell(self, order_id, quantity, price):\n Library.functions.limit_sell(self._book, order_id, quantity, price)", "def sell_limit_order(self, price=0, volume=0):\n auth = CoinbaseExchangeAuth(self.api_key, self.secret_key, self.passphrase)\n data = {\n \"size\": volume,\n \"price\": price,\n \"side\": \"sell\",\n \"product_id\": self.rate,\n \"type\": \"limit\"\n }\n\n sell = requests.post(self.url + 'orders',\n data=json.dumps(data),\n auth=auth).json()\n\n sell['txid'] = sell['id']\n\n logging.debug(sell)\n return sell", "def SetLimit(self, *args):\n return _BRepAlgo.BRepAlgo_NormalProjection_SetLimit(self, *args)", "def set_Limit(self, value):\n super(DescribeEvaluationsInputSet, self)._set_input('Limit', value)", "def set_max_position_size(\n self,\n asset=None,\n max_shares=None,\n max_notional=None,\n on_error='fail'):\n control = MaxPositionSize(asset=asset,\n max_shares=max_shares,\n max_notional=max_notional,\n on_error=on_error)\n self.register_trading_control(control)", "def limit(self, limit):\n\n self._limit = limit", "def limit(self, limit):\n\n self._limit = limit", "def limit(self, limit):\n\n self._limit = limit", "def set_limit(self, errors):\n self.limit = errors", "async def cclimit(self, ctx, limit_amount: int = None):\n if limit_amount is None:\n return await ctx.send_help()\n if limit_amount < 0:\n return await ctx.send(\"You need to use a number larger than 0.\")\n await self.config.limit.set(limit_amount)\n await ctx.send(f\"Chatchart is now limited to {limit_amount} messages.\")", "def set_limit(self, limit, truncated=False):\n self.limit = {'limit': limit, 'type': 'limit', 'truncated': truncated}", "def limit(self, limit):\n self._evaluated = False\n self._limit = limit\n return self", "async def _submit_limit_buy(self, pair: str, trade_size: float):\n\n adjusted_value = self.market.adjusted_close_values[pair][-1]\n current_value = self.market.close_values[pair][-1]\n\n min_trade_size = self.market.min_trade_sizes[pair] * (1.0 + config['trade_min_safe_percent'])\n if min_trade_size < self.market.min_safe_trade_size:\n min_trade_size = self.market.min_safe_trade_size\n\n if trade_size < min_trade_size:\n self.log.warning(\"{} using trade size of {}, please update your config.\", pair, min_trade_size)\n trade_size = min_trade_size\n\n quantity = trade_size / adjusted_value\n min_quantity = self.market.min_trade_qtys[pair]\n\n if quantity < min_quantity:\n self.log.warning(\"{} trade quantity {} too low, using minimum of {}.\", pair, quantity, min_quantity)\n quantity = min_quantity\n\n limit_value = current_value * (1.0 + config['trade_buy_limit_margin'])\n order_id = await self.api.buy_limit(pair, quantity, limit_value)\n\n if order_id is None:\n base = pair.split('-')[0]\n base_mult = await self.market.get_base_mult(config['trade_base'], base)\n reserved = config['remit_reserved'][base] if base in config['remit_reserved'] else 0.0\n balance = await self.api.get_balance(base)\n\n if balance is None:\n self.log.error(\"Could not get available balance for {}!\", base)\n return (None, 0.0)\n\n balance *= (1.0 - config['trade_buy_retry_margin']) - reserved\n\n min_size = self.market.min_trade_size / base_mult\n if min_size < self.market.min_trade_sizes[pair]:\n min_size = self.market.min_trade_sizes[pair]\n\n if balance >= min_size:\n quantity = balance / limit_value\n self.log.warning(\"{} re-trying buy with available balance {}.\", pair, balance)\n order_id = await self.api.buy_limit(pair, quantity, limit_value)\n\n if order_id is None:\n return (None, 0.0)\n\n return (order_id, quantity)", "async def new_limit_order(side):\n symbol = App.config[\"symbol\"]\n now_ts = now_timestamp()\n\n #\n # Find limit price (from signal, last kline and adjustment parameters)\n #\n last_kline = App.analyzer.get_last_kline(symbol)\n last_close_price = to_decimal(last_kline[4]) # Close price of kline has index 4 in the list\n if not last_close_price:\n log.error(f\"Cannot determine last close price in order to create a market buy order.\")\n return None\n\n price_adjustment = App.config[\"trader\"][\"limit_price_adjustment\"]\n if side == SIDE_BUY:\n price = last_close_price * Decimal(1.0 - price_adjustment) # Adjust price slightly lower\n elif side == SIDE_SELL:\n price = last_close_price * Decimal(1.0 + price_adjustment) # Adjust price slightly higher\n\n price_str = round_str(price, 2)\n price = Decimal(price_str) # We will use the adjusted price for computing quantity\n\n #\n # Find quantity\n #\n if side == SIDE_BUY:\n # Find how much quantity we can buy for all available USD using the computed price\n quantity = App.quote_quantity # USD\n percentage_used_for_trade = App.config[\"trader\"][\"percentage_used_for_trade\"]\n quantity = (quantity * percentage_used_for_trade) / Decimal(100.0) # Available for trade\n quantity = quantity / price # BTC to buy\n # Alternatively, we can pass quoteOrderQty in USDT (how much I want to spend)\n elif side == SIDE_SELL:\n # All available BTCs\n quantity = App.base_quantity # BTC\n\n quantity_str = round_down_str(quantity, 6)\n\n #\n # Execute order\n #\n order_spec = dict(\n symbol=symbol,\n side=side,\n type=ORDER_TYPE_LIMIT, # Alternatively, ORDER_TYPE_LIMIT_MAKER\n timeInForce=TIME_IN_FORCE_GTC,\n quantity=quantity_str,\n price=price_str,\n )\n\n if App.config[\"trader\"][\"no_trades_only_data_processing\"]:\n print(f\"NOT executed order spec: {order_spec}\")\n else:\n order = execute_order(order_spec)\n\n #\n # Store/log order object in our records (only after confirmation of success)\n #\n App.order = order\n App.order_time = now_ts\n\n return order", "def limit(self, limit):\n self._limit = limit\n return self", "def limit(self, v):\r\n if not (v is None or isinstance(v, (int, long))):\r\n raise TypeError\r\n if v == self._limit:\r\n return self\r\n\r\n if v < 0:\r\n raise QueryException(\"Negative limit is not allowed\")\r\n\r\n clone = copy.deepcopy(self)\r\n clone._limit = v\r\n return clone", "def set_limit(self, limit):\n self.limit = limit\n self._prune()" ]

[ "0.5921895", "0.57735974", "0.5725143", "0.57079554", "0.56382525", "0.5630813", "0.55486006", "0.5509752", "0.54923606", "0.5483896", "0.5443233", "0.54388654", "0.5404075", "0.53903586", "0.5376704", "0.5374852", "0.53745776", "0.53409106", "0.53382504", "0.53382504", "0.53382504", "0.52828634", "0.5272387", "0.5252269", "0.52504075", "0.5235023", "0.52310294", "0.51733875", "0.515917", "0.51557744" ]

[ "def test_itar_restrict_asset(self):\n pass", "def set_restriction_filters(self):\n self.restriction_filters[\"pk__exact\"] = self.request.user.pk", "def test_itar_restrict_test_asset(self):\n pass", "def set_do_not_order_list(self, restricted_list, on_error='fail'):\n if isinstance(restricted_list, SecurityList):\n warnings.warn(\n \"`set_do_not_order_list(security_lists.leveraged_etf_list)` \"\n \"is deprecated. Use `set_asset_restrictions(\"\n \"security_lists.restrict_leveraged_etfs)` instead.\",\n category=DeprecationWarning,\n stacklevel=2\n )\n restrictions = SecurityListRestrictions(restricted_list)\n else:\n warnings.warn(\n \"`set_do_not_order_list(container_of_assets)` is deprecated. \"\n \"Create a zipline.finance.asset_restrictions.\"\n \"StaticRestrictions object with a container of assets and use \"\n \"`set_asset_restrictions(StaticRestrictions(\"\n \"container_of_assets))` instead.\",\n category=DeprecationWarning,\n stacklevel=2\n )\n restrictions = StaticRestrictions(restricted_list)\n\n self.set_asset_restrictions(restrictions, on_error)", "def test_itar_restrict_software_asset(self):\n pass", "def SetRestriction(self, restrict_type):\n return _hypre.HypreBoomerAMG_SetRestriction(self, restrict_type)", "def SetAntLimit(cls, value=0):\n cls.antLimit = value", "def set_license_queryset(self, access_policy):\n self.fields['license'].queryset = License.objects.filter(\n resource_types__icontains=str(self.instance.resource_type.id),\n access_policy=access_policy)", "def _setordering_institution_52A(self, val):\n self.swift_obj.OrderingInstitution_A = val\n self.swift_obj.OrderingInstitution_A.swiftTag = '52A'", "def SetLimit(self, *args):\n return _BRepAlgo.BRepAlgo_NormalProjection_SetLimit(self, *args)", "def attribute_restrictions(self, attribute_restrictions):\n\n self._attribute_restrictions = attribute_restrictions", "def allowance(self, allowance):\n\n self._allowance = allowance", "def restrict_robots(self, restrict_robots):\n if restrict_robots is None:\n raise ValueError(\"Invalid value for `restrict_robots`, must not be `None`\")\n\n self._restrict_robots = restrict_robots", "def manual(self):\n\n\t\tfilter = [\"January\", \"February\", \"March\", \"April\", \"May\", \"June\", \"July\", \"August\", \"September\", \"October\", \"November\", \"December\", \"World War II\"],\n\n\t\tself.index[\"authorities\"] = [auth for auth in self.index[\"authorities\"] if auth not in filter]\n\n\t\tfor item in self.index[\"items\"]:\n\t\t\tself.index[\"items\"][item] = [auth for auth in self.index[\"items\"][item] if auth in self.index[\"authorities\"]]", "def set_parameters(min_orders, max_orders, max_clicks):\n assert min_orders <= max_orders\n global MIN_ORDERS, MAX_ORDERS, MAX_CLICKS\n MIN_ORDERS = min_orders\n MAX_ORDERS = max_orders\n MAX_CLICKS = max_clicks", "def __init__(self, editable=True, **kwargs):\n super().__init__(**kwargs)\n\n # Get licenses for this resource type\n licenses = License.objects.filter(\n resource_types__icontains=str(self.instance.resource_type.id))\n # Set allowed access policies based on license policies\n available_policies = [a for a in range(len(Metadata.ACCESS_POLICIES)) if licenses.filter(access_policy=a)]\n self.fields['access_policy'].choices = tuple(Metadata.ACCESS_POLICIES[p] for p in available_policies)\n\n if not editable:\n for f in self.fields.values():\n f.disabled = True", "def _setordering_customer_50A(self, val):\n self.swift_obj.OrderingCustomer_A = val\n self.swift_obj.OrderingCustomer_A.swiftTag = '50A'", "def limit_possible(self, *values):\n self.possible.intersection_update(values)", "def test_set_project_limits(self):\n pass", "def setRatingFilter(self, min = 0, max = 100):\n self._updateMovieList = self._updateMovieList or self._filterRatingMin != min or self._filterRatingMax != max\n self._filterRatingMin, self._filterRatingMax = min, max", "def setRatingFilter(self, min = 0, max = 100):\n self._updateMovieList = self._updateMovieList or self._filterRatingMin != min or self._filterRatingMax != max\n self._filterRatingMin, self._filterRatingMax = min, max", "def setRatingFilter(self, min = 0, max = 100):\n self._updateMovieList = self._updateMovieList or self._filterRatingMin != min or self._filterRatingMax != max\n self._filterRatingMin, self._filterRatingMax = min, max", "def reindex_licence_permissions(container, event):\n if IUrbanEvent.providedBy(container):\n licence = container.aq_parent\n licence.reindexObject(idxs=['allowedRolesAndUsers'])", "def __init__(self,name,maneuverability,protection):\n\t\tsuper().__init__(name)\n\t\tself.maneuverability = super().limitsValues(maneuverability)\n\t\tself.protection = super().limitsValues(protection)", "def allowed_vehicles(self, allowed_vehicles):\n\n self._allowed_vehicles = allowed_vehicles", "def allowed_vehicles(self, allowed_vehicles):\n\n self._allowed_vehicles = allowed_vehicles", "def restrict_param(cls, value: bool):\n cls._restrict_param = value", "def set_values(self):\n super(ResConfigInherit, self).set_values()\n self.env['ir.config_parameter'].sudo().set_param(\n 'sale_stock_restrict.product_restriction', self.product_restriction)\n self.env['ir.config_parameter'].sudo().set_param(\n 'sale_stock_restrict.check_stock', self.check_stock)", "def enableAddOrder(self):\n if self.lstType.selected == -1 or self.lstRes.selected == -1:\n self.btnAddMarketOrder.disable()\n else:\n self.btnAddMarketOrder.enable()\n if self.lstType.getSelectedItem().data == 'sell':\n self.txtMin.readOnly = 0\n else:\n self.txtMax.readOnly = 0", "def prepare_domain_restrictions(self):\n for index, restriction in enumerate(self._domain_restrictions):\n self.add_specific_domain_restriction(index+1, restriction)" ]

[ "0.5862194", "0.5779639", "0.5694709", "0.56470656", "0.55811715", "0.54445773", "0.52758116", "0.51754206", "0.5161849", "0.5132235", "0.5066222", "0.5035237", "0.501944", "0.49849662", "0.4979434", "0.4963584", "0.49379414", "0.4887372", "0.4876058", "0.4779043", "0.4779043", "0.4779043", "0.47701943", "0.4763319", "0.47570607", "0.47570607", "0.47540292", "0.47316045", "0.4730727", "0.47151133" ]

[ "def packages(self):\n return []", "def test_distinct(self):\n pkgs = [\n make_package(factory=DynamoPackage),\n make_package(version=\"1.3\", filename=\"mypath3\", factory=DynamoPackage),\n make_package(\"mypkg2\", \"1.3.4\", \"my/other/path\", factory=DynamoPackage),\n ]\n self._save_pkgs(*pkgs)\n saved_pkgs = self.db.distinct()\n self.assertCountEqual(saved_pkgs, set([p.name for p in pkgs]))", "def get_all_packages(self):\n return self._package_cache.values()", "def get_all_package_ids(self):\n return self._package_cache.keys()", "def get_packages(self):\n packages = []\n for obj in self.objects_used:\n packages.extend(obj.get_packages())\n # Remove duplicates (not necessary but it's cleaner)\n packages = list(set(packages))\n return packages", "def unique_deps(deps):\n deps.sort()\n return list(k for k, _ in itertools.groupby(deps))", "def getusersitepackages():\n\tpass", "def get_all_packages(cls):\n packages = Package.query.all()\n return packages", "def test_distinct(self):\n pkgs = [\n make_package(factory=SQLPackage),\n make_package(version=\"1.3\", filename=\"mypath3\", factory=SQLPackage),\n make_package(\"mypkg2\", \"1.3.4\", \"my/other/path\", factory=SQLPackage),\n ]\n self.sql.add_all(pkgs)\n saved_pkgs = self.db.distinct()\n self.assertCountEqual(saved_pkgs, set([p.name for p in pkgs]))", "def get_package_list():\n pip_freeze = subprocess.check_output(('pip', 'freeze')).decode('utf8')\n package_list = [x.strip().split('==') for x in pip_freeze.split('\\n') if x.find('==') != -1]\n package_list = [(x[0].lower(), x[1]) for x in package_list]\n return package_list", "def test_distinct(self):\n pkgs = [\n make_package(factory=SQLPackage),\n make_package(version=\"1.3\", filename=\"mypath3\", factory=SQLPackage),\n make_package(\"mypkg2\", \"1.3.4\", \"my/other/path\", factory=SQLPackage),\n ]\n for pkg in pkgs:\n self.db.save(pkg)\n saved_pkgs = self.db.distinct()\n\n self.assertCountEqual(saved_pkgs, set([p.name for p in pkgs]))", "def get_all_packages(self):\n with self._conn.begin():\n return {\n rec.package\n for rec in self._conn.execute(self._packages.select())\n }", "def list_packages():\n\n shelf_dir = settings.shelf_dir\n\n package_list = os.listdir(shelf_dir)\n\n package_list.sort()\n\n return package_list", "def get_packages(root):\n root = os.path.realpath(root)\n proot = parent(root) + \"/\"\n py_files = [file.rsplit(proot)[1] for file in listfiles(root)]\n packages = list(np.unique([parent(file).replace(\"/\", \".\") for file in py_files]))\n # return list(np.unique([parent(file).replace(\"/\", \".\").split(\".{name_root}.\".format(name_root=name(root)))[1]\n # for file in py_files]))\n return packages", "def packages(self):\r\n return self._packages", "def list_package(all: bool = False) -> List[List[str]]:\n if not all:\n pkgs_info = read_installation_records()\n else:\n pkgs_info = []\n for pkg in pkg_resources.working_set:\n pkgs_info.append([pkg.project_name, pkg.version])\n\n return pkgs_info", "def get_packages():\n\tapps=[]\n\tlspackages = glob.glob(u'/home/wpkg/packages/*.xml')\n\tfor fic in lspackages:\n #print fic\n\t\tif os.path.isfile(fic):\n\t\t\ttry:\n\t\t\t\txml = etree.parse(fic)\n\t\t\texcept:\n\t\t\t\t#si erreur on tente de corriger le fichier\n\t\t\t\toput = open(\"output.txt\",\"w\")\n\t\t\t\tdata = open(fic).read()\n\t\t\t\toput.write( re.sub('&(?!amp;|quot;|nbsp;|gt;|lt;|laquo;|raquo;|copy;|reg;|bul;|rsquo;)', '&amp;', data) )\n\t\t\t\toput.close()\n\t\t\t\tshutil.move(\"output.txt\", fic)\n\n\t\t\tfinally:\n\t\t\t\tparser = etree.XMLParser(remove_comments=False)\n\t\t\t\txml = etree.parse(fic,parser)\n\t\t\t\tstrxml = etree.tostring(xml.getroot())\n\t\t\t\tfor group in xml.getiterator(u'package'):\n\t\t\t\t\tuid = group.get(u'id')\n\t\t\t\t\tname = group.get(u'name')\n\t\t\t\t\tdvars = dict()\n\t\t\t\t\tfor vars in xml.getiterator('variable'):\n\t\t\t\t\t\tdvars[vars.get('name').lower()] = vars.get('value').lower()\n\n\t\t\t\t#on remplit le dico des appli dispo\n\t\t\t\t#print fic,uid,name\n\t\t\t\tapps.append((fic,uid,name))\n\n\treturn apps", "def libraries(self):\n\n status, stdout, stderr = self.__xcall__(['--libs-only-l'])\n\n if status != 0:\n raise RuntimeError(\"error querying --libs-only-l for package `%s': %s\" % (self.name, stderr))\n\n retval = []\n for token in stdout.split():\n retval.append(token[2:])\n\n return uniq(retval)", "def packages():", "def get_packages(package):\n return [str(path.parent) for path in Path(package).glob(\"**/__init__.py\")]", "def get_packages():\n packages = []\n for repo in repositories:\n packages.extend(repo.get_packages())\n return packages", "def unique(x):\n\n return list(set(x))", "def get_default_packages(rootfs, include_essential=False,\n include_priorities=None):\n if include_priorities is None:\n include_priorities = []\n\n package_list = set()\n\n list_dir = os.path.join(rootfs, 'var/lib/apt/lists')\n for filename in os.listdir(list_dir):\n if not filename.endswith('_Packages'):\n continue\n\n with open(os.path.join(list_dir, filename)) as infile:\n for pkg in rfc822_parse(infile):\n if 'Essential' in pkg and include_essential:\n package_list.add(pkg['Package'])\n continue\n if 'Priority' not in pkg:\n continue\n\n if pkg['Priority'] in include_priorities:\n package_list.add(pkg['Package'])\n\n return list(sorted(package_list))", "def distinct(x):\n return list(set(x))", "def get_conflicts(self):\n packages = []\n for obj in self.objects_used:\n packages.extend(obj.get_conflicts())\n # Remove duplicates (not necessary but it's cleaner)\n packages = list(set(packages))\n return packages", "def get_suspect_packages():\n with open(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'gistfile1.txt'), 'r') as f:\n return map(lambda line: line.strip(), f.readlines())", "def sort_packages(self) -> None:\n self.recommended_packages = []\n self.required_packages = []\n for package in self.repository_packages:\n try:\n output = self.guest.execute(Command('rpm', '-q', package), silent=True)\n assert output.stdout\n self.debug(f\"Package '{output.stdout.strip()}' already installed.\")\n except tmt.utils.RunError:\n if self.skip_missing:\n self.recommended_packages.append(package)\n else:\n self.required_packages.append(package)", "def list_packages(self):\n for tag, pkg in PACKAGES.iteritems():\n print \"{tag} - {label}\".format(tag=tag, label=pkg['label'])", "def dump(self):\n\n\t\treturn [\n\t\t\tpkg.dump()\n\t\t\tfor pkg in self._packages.values()\n\t\t]", "def list_package_ids(self):\n raise NotImplementedError" ]

[ "0.6430366", "0.6309106", "0.6299323", "0.62896633", "0.6276589", "0.62677157", "0.62133825", "0.6208776", "0.61960036", "0.61661726", "0.611649", "0.60419285", "0.59264976", "0.58020616", "0.5763166", "0.57164764", "0.56727856", "0.56717694", "0.56565005", "0.5655758", "0.56428087", "0.5627177", "0.56165624", "0.5610608", "0.5610334", "0.55833083", "0.55771875", "0.5555683", "0.5536457", "0.55228204" ]

[ "def button(self):\n return self._button", "def button(self):\n return self._button", "def GetButton(self):\r\n\r\n return self.button", "def okButton(self):\n return self.__okButton", "def okButton(self):\n return self.__okButton", "def okButton(self):\n return self.__okButton", "def get_button(self):\n if self.button is not None:\n return self.button\n b=gtk.Button(self.description_getter(self.current))\n if self.editable:\n b.connect('clicked', lambda w: self.popup_menu())\n b.show()\n self.button=b\n return b", "def GetButtonObj(self):\n\n return self.theButton", "def GetBtnLabel(self):\r\n\r\n if self.GetWindowStyleFlag() & CP_GTK_EXPANDER:\r\n return self.GetLabel()\r\n \r\n return self.GetLabel() + (self.IsCollapsed() and [\" >>\"] or [\" <<\"])[0]", "def get_nunchuk_buttons(self):\n if not 'nunchuk' in self.get_state():\n return None\n buttons_state = self.wm.state['nunchuk']['buttons']\n\n return buttons_state", "def push_button_up(self, position: Tuple[int, int], button: int):\n raise NotImplementedError", "def ev_mousebuttonup(self, event: tcod.event.MouseButtonUp) -> T | None:", "def get_button(self, button):\n return getattr(self.get_buttons_state(), button)", "def ev_mousebuttonup(self, event: MouseButtonUp) -> None:", "def cancelButton(self):\n return self.__cancelButton", "def cancelButton(self):\n return self.__cancelButton", "def cancelButton(self):\n return self.__cancelButton", "def click_user_widget_button(self):\n return self", "def click_upload_button(self):\n return self", "def OnLeftUp_ClickButton(self, event):\r\n \r\n self._hover_button = None\r\n\r\n if self._action_part:\r\n self.RefreshButton(self._action_part)\r\n\r\n # make sure we're still over the item that was originally clicked\r\n if self._action_part == self.HitTest(*event.GetPosition()):\r\n \r\n # fire button-click event\r\n e = AuiManagerEvent(wxEVT_AUI_PANE_BUTTON)\r\n e.SetManager(self)\r\n e.SetPane(self._action_part.pane)\r\n e.SetButton(self._action_part.button.button_id)\r\n self.ProcessMgrEvent(e)", "def rightButtonUp(self):\n\t\tautopy.mouse.toggle(False,autopy.mouse.RIGHT_BUTTON)", "def __create_button(self, parent, flag):\n btns = {\n wx.ID_OK: (MSG_ACTION_OK, \"ok\"),\n wx.ID_CANCEL: (MSG_ACTION_CANCEL, \"cancel\"),\n wx.ID_YES: (MSG_ACTION_YES, \"yes\"),\n wx.ID_NO: (MSG_ACTION_NO, \"no\"),\n wx.ID_APPLY: (MSG_ACTION_APPLY, \"apply\"),\n wx.ID_CLOSE: (MSG_ACTION_CLOSE, \"close-window\"),\n wx.ID_SAVE: (MSG_ACTION_SAVE, \"save\"),\n }\n btn = sppasBitmapTextButton(parent, label=btns[flag][0], name=btns[flag][1])\n btn.SetId(flag)\n\n if flag == wx.CANCEL:\n self.SetAffirmativeId(wx.ID_CANCEL)\n\n elif flag in (wx.CLOSE, wx.OK):\n btn.SetDefault()\n btn.SetFocus()\n self.SetAffirmativeId(flag)\n\n elif flag == wx.YES:\n self.SetAffirmativeId(wx.ID_YES)\n\n elif flag == wx.OK:\n btn.SetDefault()\n\n return btn", "def get_placement_buttons():\r\n return placement_buttons", "def corner_buttons(self):\r\n buttons = []\r\n if c.user_is_loggedin:\r\n if c.user.name in g.admins:\r\n if c.user_is_admin:\r\n buttons += [NamedButton(\"adminoff\", False,\r\n nocname=not c.authorized_cname,\r\n target = \"_self\")]\r\n else:\r\n buttons += [NamedButton(\"adminon\", False,\r\n nocname=not c.authorized_cname,\r\n target = \"_self\")]\r\n\r\n buttons += [NamedButton('submit', sr_path = not c.default_sr,\r\n nocname=not c.authorized_cname)]\r\n if c.user.safe_karma >= g.discussion_karma_to_post:\r\n buttons += [NamedButton('meetups/new', False,\r\n nocname=not c.authorized_cname)]\r\n buttons += [NamedButton(\"prefs\", False,\r\n css_class = \"pref-lang\")]\r\n buttons += [NamedButton(\"logout\", False,\r\n nocname=not c.authorized_cname,\r\n target = \"_self\")]\r\n\r\n return NavMenu(buttons, base_path = \"/\", type = \"buttons\")", "def buttonToolTip(self):\n return self.__button.toolTip()", "def DrawPushButton(*args, **kwargs):\n return _gdi_.RendererNative_DrawPushButton(*args, **kwargs)", "def keyboard_popup(self):\n c = self.c\n menu = QtWidgets.QMenu(c.frame.top)\n\n cmds = {}\n\n need_submenu = 'Move', 'Copy', 'Clone', 'Bookmark', 'Link'\n current_kind = None\n current_submenu = None\n todo: Any\n for name, first_last, long, short in quickMove.flavors:\n if first_last:\n todo = 'first child', 'last child', 'next sibling', 'prev sibling'\n else:\n todo = ['']\n for which in todo:\n if which:\n which = \" \" + which.title()\n k = \"Set as \" + long + \" \" + short + which + ' target'\n cmds[k] = {'first': which, 'type': name}\n kind = long.split()[0]\n if kind in need_submenu:\n if current_kind != kind:\n current_submenu = menu.addMenu(kind)\n current_kind = kind\n else:\n current_submenu = menu\n current_submenu.addAction(k)\n\n pos = c.frame.top.window().frameGeometry().center()\n action = menu.exec_(pos)\n if action is None:\n return\n k = str(action.text())\n g.es(k)\n self.keyboard_target = quickMoveButton(\n self, c.p.v, cmds[k]['first'], type_=cmds[k]['type'])", "def exec_(self):\n super().exec_()\n return self.clicked_button", "def get_button(self, key) -> tk.Button:\n try:\n button = self._Buttons[key]\n except KeyError:\n button = self._Buttons[key] = tk.Button()\n return button", "def get_widget(self):\n return self.imgwin" ]

[ "0.6526846", "0.6526846", "0.64482844", "0.6378192", "0.6378192", "0.6378192", "0.63245046", "0.62547964", "0.5730146", "0.56952465", "0.5684308", "0.5434167", "0.53666764", "0.5366605", "0.5349822", "0.5349822", "0.5349822", "0.5344203", "0.5318714", "0.5275598", "0.52448124", "0.52428484", "0.52392846", "0.52208304", "0.5215327", "0.52055764", "0.5183141", "0.51762974", "0.5169628", "0.5162459" ]

[ "def 取选中项索引(self): # real signature unknown; restored from __doc__\n return self.GetSelection()", "def get_selected_index(self) -> int:\n return self._selected_index", "def get_selected_ix( self ):\n selected_ix = self.listbox.curselection()\n\n if selected_ix == tuple( ):\n selected_ix = -1\n else:\n selected_ix = selected_ix[0] # since we allow only 1 selection\n\n return selected_ix", "def selected_index(self):\n return self._selected_index", "def selected_index(self):\r\n return self._index_of_sel_point", "def GetIndex(self,item):\r\n return self.gList.FindItemData(-1,self.GetId(item))", "def get_selected(self):\n\n # if there are items in the list\n if self.currentIndex() != -1:\n modelitem = self._dictmodel.itemFromIndex(\n self._modelindexes[ self.currentIndex() ]\n )\n return modelitem", "def GetItem(self,index):\r\n return self.itemId_item[self.gList.GetItemData(index)]", "def current_val(self):\n try:\n return self.listbox.get(self.listbox.curselection()[0])\n except IndexError:\n raise KeyError(\"Nothing selected\")", "def getSelectedItem(self):\n currentIndex = self.table.selectionModel().currentIndex()\n return self.model.itemFromIndex(currentIndex)", "def getSelectedItem(self):\n return self.selected", "def current_choice(self):\n\t\treturn self.choice_data_list[self.select_index]", "def get_current_index(self):\r\n return self.contents_widget.currentRow()", "def GetSelection(self):\n return self.__selected_item", "def GetSelectedPage(self):\r\n return self._indexMap[self._selectedItem]", "def getSelectedItem(*args):", "def GetClickedItem( ctrl, evt ):\n return ctrl.HitTest( wx.Point( evt.GetX(), evt.GetY() ) )[0]", "def GetSelection(self):\r\n\r\n return self._current", "def index(self):\n return self.frame.index", "def selected_item(self) -> MenuItem | None:\n if self.selected_option == -1:\n return None\n else:\n return self.all_items[self.selected_option]", "def GetSelection(self):\r\n \r\n return self._curpage", "def getListBoxSelectedItem( self, cCtrlName ):\n oControl = self.getControl( cCtrlName )\n return oControl.getSelectedItem()", "def selected(self):\n return self._choices[self._selected][0]", "def get_selected(self):\n return self.selected", "def get_list_index(self):\r\n return self.n", "def get_tkinter_index(self,index):\n if isinstance(index,str):\n if index in self.indexname2index:\n i=self.indexname2index[index]\n else:\n # pass through tkinter to get 'end' etc converted to index\n i=self.index(index)\n else:\n i=index\n return i", "def get_selected(self, item=None):\n if item is None:\n try:\n index = self.ui.listItemList.selectedIndexes()[0]\n except:\n pass\n else:\n item = index.model().listdata[index.row()]\n if item is not None:\n self.selected_item = item", "def getItemAtClick(self, event):\n pos = event.pos()\n obj = self.itemAt(pos)\n return obj", "def getItemAtClick(self, event):\n pos = event.pos()\n obj = self.itemAt(pos)\n return obj", "def index(self, item):\n return self._items.index(item)" ]

[ "0.75485176", "0.74857414", "0.73887503", "0.7338485", "0.73112506", "0.7015429", "0.6953144", "0.6934704", "0.6860859", "0.6768367", "0.67466336", "0.6598296", "0.65866166", "0.656888", "0.65520436", "0.6459978", "0.6419767", "0.64153636", "0.64102745", "0.637221", "0.6344352", "0.6324616", "0.63197577", "0.6316342", "0.63032395", "0.62910557", "0.6273054", "0.62250805", "0.62250805", "0.62084764" ]

[ "def preset_items(self):\r\n\r\n raise NotImplementedError", "def populate_list(self):\n counter = 0\n for group_name in self.parent.all_groups.keys():\n counter += 1\n exec('self.groupItem' + str(counter) + ' = QListWidgetItem()')\n eval('self.groupItem' + str(counter) + '.setText(\"' + group_name + '\")')\n self.group_list.addItem(eval('self.groupItem' + str(counter)))", "def onInit(self):\n self.list_control = self.getControl(6)\n self.getControl(1).setLabel(self.window_title)\n self.getControl(3).setVisible(False)\n try:\n self.getControl(7).setLabel(xbmc.getLocalizedString(222))\n except Exception:\n pass\n\n self.getControl(5).setVisible(False)\n\n # add our items to the listing and focus the control\n self.list_control.addItems(self.listing)\n self.setFocus(self.list_control)", "def repopulate(self):\n new_items = self._list_populate_function()\n\n new_set = set(new_items.values() if isinstance(new_items, dict) else new_items)\n\n if len(new_items) != len(self._display_list):\n if isinstance(new_items, dict):\n # for dictionaries store the key as user role data\n for key in sorted(new_items.keys()):\n item = new_items[key]\n if item not in self._display_list:\n self.list_widget.addItem(item)\n self.list_widget.item(self.list_widget.count() - 1).setData(Qt.UserRole, key)\n else:\n for item in new_items:\n if item not in self._display_list:\n self._add_item(item)\n self._display_list = sorted(set(new_set) | set(self._display_list))", "def _set_items(self, list_text, pic_path):\n print list_text\n self.list_widget = QListWidget()\n ly_vbox = QVBoxLayout()\n if type(pic_path) is not list:\n for item in list_text:\n self._setItem(item[0], item[1], pic_path)\n else:\n for i in range(len(list_text)):\n self._setItem(list_text[i][0], list_text[i][1], pic_path[i])\n ly_vbox.addWidget(self.list_widget)\n self.list_widget.itemDoubleClicked.connect(self.item_doubleclick_slot)\n self.setLayout(ly_vbox)\n self.resize(300, 400)\n\n buttonBox = QDialogButtonBox(QDialogButtonBox.Ok |QDialogButtonBox.Cancel)\n ly_vbox.addWidget(buttonBox)\n buttonBox.accepted.connect(self.check_test)\n buttonBox.rejected.connect(self.reject)\n self.check_test()", "def set_values( self, values ):\n #self.listbox.configure( values )\n # clear\n #for", "def SetMenu(self,valueList,value=None):\n self['menu'].delete(0,'end')\n for item in valueList:\n self['menu'].add_command(label=item,\n command=_setit(self.variable,item,self.command))\n if value:\n self.variable.set(value)", "def on_actions_list(self, e):\n self.PopupMenu(self.popup_menu())", "def save_settings(self, settings):\n settings.set_value('itemlist', pack(self._parentfilter._selected_items))", "def set_items(self) -> None:\n if not self.__repeat:\n self._username: str = input(\"Introduzca el nombre del usuario: \")\n self._ordered_items = self.get_rights()[0]\n if not self._ordered_items:\n if self.__option == 1:\n self.print_error(\"El usuario ya tiene todos los permisos.\")\n return\n self.print_error(\"El usuario no tiene ningún permiso.\")\n return", "def update_item_list(self):\n self.update_listview(content=self.current_feed.get_items(unread_only=self.show_unread_only))\n self.set_selected()\n self.action_fetch_more.setDisabled(not self.can_fetch_more)", "def populating_popup(self, *args):\n return _ida_hexrays.Hexrays_Hooks_populating_popup(self, *args)", "def set_completion_list(self, completion_list):\r\n self._completion_list = sorted(completion_list, key=str.lower) # Work with a sorted list\r\n self._hits = []\r\n self._hit_index = 0\r\n self.position = 0\r\n self.bind('<KeyRelease>', self.handle_keyrelease)\r\n self['values'] = self._completion_list # Setup our popup menu\r", "def add(self, data):\n self.menuItems.update(data)", "def fillData(self):\n self.users = c.getUserNames()\n self.userlist.SetItems(self.users)", "def _refresh(self):\n doc_launchers = [DocumentButtonLauncher(d) for d in getDocumentsMatchingTags(self.filter_tags)]\n self.listbox.body = doc_launchers\n\n if len(self.listbox.body) == 0:\n return\n\n if self.current_selected >= len(self.listbox.body):\n self.current_selected = len(self.listbox.body) - 1\n self.listbox.set_focus(self.current_selected)\n\n for dl in doc_launchers:\n urwid.connect_signal(dl, 'click', self._handle_popup_open)\n urwid.connect_signal(dl, 'close', self._handle_popup_close)", "def set_all(self, value):\n self.__items = value", "def update_namelist_menu(self):\n new_nml = wx.Menu() # build new menu\n\n # populate entries and bind their selection\n for i,nml in enumerate(self.input_file.namelists.keys()):\n item = new_nml.Append(i, self.input_file.namelists[nml].name)\n self.Bind(wx.EVT_MENU, self.SelectNamelist, item, id=i)\n\n # replace old menu in the 1st position with updated one (0-based indexing)\n self.menubar.Replace(self.nml_menu_index, new_nml, '&Namelists')\n\n # reset the namelist entries that are displayed\n self.nmlpanel.reset(unset_namelist=True) # ensure no namelist is currently selected\n\n self.statusbar.SetStatusText(\"Choose a namelist from the menu\", 1)", "def items(self, value):\n if value is None:\n self._items = None\n self.active = None\n else:\n self._items = value\n self.active = [True] * len(self._items)", "def setup_lists(self):\n pass", "def populateList(self):\n self.model = QStandardItemModel()\n for text in self.options:\n item = QStandardItem(text)\n # item.setData(value, Qt.UserRole)\n item.setCheckable(True)\n item.setCheckState(Qt.Unchecked)\n item.setDropEnabled(False)\n self.model.appendRow(item)\n\n self.lstLayers.setModel(self.model)", "def populateList(self):\n self.model = QStandardItemModel()\n for text in self.options:\n item = QStandardItem(text)\n # item.setData(value, Qt.UserRole)\n item.setCheckable(True)\n item.setCheckState(Qt.Unchecked)\n item.setDropEnabled(False)\n self.model.appendRow(item)\n\n self.lstLayers.setModel(self.model)", "def setitems(self, items):\n self.clear()\n # FIXME: this allows you to pass in an OrderedDict as well :-)\n self.update(items)", "def refresh_playlist_menu(self, playlists):\n menu = self.playlist_dropdown[\"menu\"]\n menu.delete(0, \"end\")\n for playlist in playlists:\n name = playlist.playlist_name\n menu.add_command(\n label=name,\n command=lambda value=name: self.intermediate_playlist_select_command(value)\n )\n\n # menu.add_command(\n # label=\"Working Playlist\",\n # command=lambda value=name:\n # self.intermediate_playlist_select_command(\"Working Playlist\")\n # )\n\n self.display_data(self.parent.song_object_list)\n self.user.active_group.playlists = playlists", "def get_popup_menu_items(self):\n model, _, obj = self.popup_data\n menu_items = self.create_popup_menu_items(\"Add Property\", \"Empty Property\",\n model.section, self.add_property,\n lambda sec: sec.properties,\n lambda prop: prop.name,\n stock=\"odml-add-Property\")\n if obj is not None:\n prop = obj\n\n # We are working exclusively with Properties\n if isinstance(obj, value_model.Value):\n prop = obj.parent\n\n for item in self.create_popup_menu_items(\"Add Value\", \"Empty Value\", prop,\n self.add_value, self._value_filter,\n lambda curr_val: curr_val,\n stock=\"odml-add-Value\"):\n menu_items.append(item)\n\n for item in self.create_popup_menu_items(\"Set Value\", \"Empty Value\", prop,\n self.set_value, self._value_filter,\n lambda curr_val: curr_val):\n if item.get_submenu() is None:\n # We don't want a single Set Value item\n continue\n menu_items.append(item)\n\n val = obj\n\n if prop is obj:\n val = prop.pseudo_values[0] if len(prop.pseudo_values) == 1 else None\n\n if val is not None and val.dtype == \"text\":\n menu_items.append(self.create_menu_item(\"Edit text in larger window\",\n self.edit_text, val))\n\n # Cannot delete properties that are linked (they'd be override on next load),\n # instead allow to reset them.\n merged = prop.get_merged_equivalent()\n if prop is obj and merged is not None:\n if merged != obj:\n menu_items.append(self.create_menu_item(\"Reset to merged default\",\n self.reset_property, obj))\n else:\n menu_items.append(self.create_popup_menu_del_item(obj))\n\n return menu_items", "def update_list_view(self):\n # Clear the list/tree view.\n self.list_view.clear()\n\n # Find all the selected things in Maya.\n selected = cmds.ls(selection=True)\n\n # For each of the selected things, create a widget item.\n for thing in selected:\n item = QtGui.QListWidgetItem(thing)\n item.setFlags(item.flags() | QtCore.Qt.ItemIsEditable)\n self.list_view.addItem(item)\n # Set the flags on the widget item so it is editable.", "def test_set_list(buttons):\n app = App()\n app[0, 0] = [buttons[0], buttons[1]]", "def update_(self):\n self.update_listbox()\n self.update_infobox()\n self.update_statusbar()\n self.listbox.select_set(0)\n self.listbox.focus_set()", "def datas(self, newDatas):\n self.__datas = newDatas\n\n self.dropDown.clear()\n self.dropDown.addItems(self.__datas)\n self.update()", "def edit_item(self):\n for item in self.selection():\n origin_name = self.set(item)[\"1\"]\n origin_url = self.set(item)[\"2\"]\n popup = GetItemURLDialogue(self, \"Edit Item\", origin_name, origin_url)\n\n self.item(item, values=(popup.name, popup.url, self.set(item)[\"3\"]))\n self.set(item)[\"2\"] = popup.url\n\n # Edit the item - backend\n for row in s.item:\n if row[\"item\"] == origin_name and row[\"url\"] == origin_url:\n s.item.remove(row)\n s.updateItem({\"item\": popup.name, \"url\": popup.url})" ]

[ "0.63553745", "0.62045294", "0.6187062", "0.6155583", "0.615099", "0.614435", "0.6051566", "0.5928233", "0.59158075", "0.5898852", "0.5891935", "0.58433574", "0.5743328", "0.5739274", "0.5722288", "0.57069904", "0.5697331", "0.5622134", "0.5607024", "0.5606295", "0.5558778", "0.5558778", "0.5556561", "0.5542458", "0.55096453", "0.550356", "0.54827446", "0.5482694", "0.54824877", "0.5452338" ]

[ "def shrink(X, tau):\n V = np.copy(X).reshape(X.size)\n for i in xrange(V.size):\n V[i] = math.copysign(max(abs(V[i]) - tau, 0), V[i])\n if V[i] == -0:\n V[i] = 0\n return V.reshape(X.shape)", "def svt(X, tau):\n U, S, Vt = la.svd(X,full_matrices=False)\n Xs = np.dot(U * st(S,tau), Vt)\n return Xs", "def shrink(self):\n x = np.nan_to_num(self.X.values)\n\n # de-mean returns\n t, n = np.shape(x)\n meanx = x.mean(axis=0)\n x = x - np.tile(meanx, (t, 1))\n xmkt = x.mean(axis=1).reshape(t, 1)\n\n # compute sample covariance matrix\n sample = np.cov(np.append(x, xmkt, axis=1), rowvar=False) * (t - 1) / t\n covmkt = sample[0:n, n].reshape(n, 1)\n varmkt = sample[n, n]\n sample = sample[:n, :n]\n prior = np.dot(covmkt, covmkt.T) / varmkt\n prior[np.eye(n) == 1] = np.diag(sample)\n\n # compute shrinkage parameters\n if self.delta is None:\n c = np.linalg.norm(sample - prior, \"fro\") ** 2\n y = x ** 2\n p = 1 / t * np.sum(np.dot(y.T, y)) - np.sum(sample ** 2)\n # r is divided into diagonal\n # and off-diagonal terms, and the off-diagonal term\n # is itself divided into smaller terms\n rdiag = 1 / t * np.sum(y ** 2) - sum(np.diag(sample) ** 2)\n z = x * np.tile(xmkt, (n,))\n v1 = 1 / t * np.dot(y.T, z) - np.tile(covmkt, (n,)) * sample\n roff1 = (\n np.sum(v1 * np.tile(covmkt, (n,)).T) / varmkt\n - np.sum(np.diag(v1) * covmkt.T) / varmkt\n )\n v3 = 1 / t * np.dot(z.T, z) - varmkt * sample\n roff3 = (\n np.sum(v3 * np.dot(covmkt, covmkt.T)) / varmkt ** 2\n - np.sum(np.diag(v3).reshape(-1, 1) * covmkt ** 2) / varmkt ** 2\n )\n roff = 2 * roff1 - roff3\n r = rdiag + roff\n\n # compute shrinkage constant\n k = (p - r) / c\n shrinkage = max(0, min(1, k / t))\n self.delta = shrinkage\n else:\n # use specified constant\n shrinkage = self.delta\n\n # compute the estimator\n sigma = shrinkage * prior + (1 - shrinkage) * sample\n return self.format_and_annualise(sigma)", "def shrink(self):\n x = np.nan_to_num(self.X.values)\n\n # de-mean returns\n t, n = np.shape(x)\n meanx = x.mean(axis=0)\n x = x - np.tile(meanx, (t, 1))\n\n # compute sample covariance matrix\n sample = (1.0 / t) * np.dot(x.T, x)\n\n # compute prior\n var = np.diag(sample).reshape(-1, 1)\n sqrtvar = np.sqrt(var)\n _var = np.tile(var, (n,))\n _sqrtvar = np.tile(sqrtvar, (n,))\n r_bar = (np.sum(sample / (_sqrtvar * _sqrtvar.T)) - n) / (n * (n - 1))\n prior = r_bar * (_sqrtvar * _sqrtvar.T)\n prior[np.eye(n) == 1] = var.reshape(-1)\n\n # compute shrinkage parameters and constant\n if self.delta is None:\n\n # what we call pi-hat\n y = x ** 2.0\n phi_mat = np.dot(y.T, y) / t - 2 * np.dot(x.T, x) * sample / t + sample ** 2\n phi = np.sum(phi_mat)\n\n # what we call rho-hat\n term1 = np.dot((x ** 3).T, x) / t\n help_ = np.dot(x.T, x) / t\n help_diag = np.diag(help_)\n term2 = np.tile(help_diag, (n, 1)).T * sample\n term3 = help_ * _var\n term4 = _var * sample\n theta_mat = term1 - term2 - term3 + term4\n theta_mat[np.eye(n) == 1] = np.zeros(n)\n rho = sum(np.diag(phi_mat)) + r_bar * np.sum(\n np.dot((1.0 / sqrtvar), sqrtvar.T) * theta_mat\n )\n\n # what we call gamma-hat\n gamma = np.linalg.norm(sample - prior, \"fro\") ** 2\n\n # compute shrinkage constant\n kappa = (phi - rho) / gamma\n shrinkage = max(0.0, min(1.0, kappa / t))\n self.delta = shrinkage\n else:\n # use specified constant\n shrinkage = self.delta\n\n # compute the estimator\n sigma = shrinkage * prior + (1 - shrinkage) * sample\n return self.format_and_annualise(sigma)", "def svdSoft(A, lmbda, k):\n if not scipy.sparse.issparse(A): \n raise ValueError(\"A must be a sparse matrix\")\n \n #U, s, V = scipy.sparse.linalg.svds(A, k)\n U, s, V = sparsesvd(A, k) \n U = U.T\n inds = numpy.flipud(numpy.argsort(s))\n U, s, V = Util.indSvd(U, s, V, inds) \n \n #Soft threshold \n s = s - lmbda\n s = numpy.clip(s, 0, numpy.max(s))\n\n return U, s, V", "def truncated_svd(A,k=None):", "def project_Lnuc_ball(X: \"fasta.linalg.Matrix\", t: float) -> \"fasta.linalg.Matrix\":\n U, s, V = la.svd(X)\n\n # Construct the diagonal matrix of singular values, S, as a shrunken version of the original signal values\n S = np.zeros(X.shape)\n S[:len(s),:len(s)] = np.diag(shrink(s, t))\n return U @ S @ V", "def update_model(X, U, S, k, n, mu,\n svdmethod='full',\n missingmethod='zero'):\n\n if len(X) == 0:\n printt(\"Error: No data in X.\")\n return None, None, None, -1, None\n #print('%d items in X' % X.shape[1])\n #print('init U:', U)\n\n # If there is no previous U, and we just got a single item in X,\n # set U to all 0's (degenerate SVD),\n # and return it with mu.\n # (PR #22 sets first value to 1; see decals implementation)\n if len(U) == 0 and X.shape[1] == 1:\n mu = X\n # Do this no matter what. Let mu get NaNs in it as needed.\n U = np.zeros_like(mu)\n U[0] = 1\n S = np.array([0])\n n = 1\n pcts = [1.0]\n return U, S, mu, n, pcts\n\n ###########################################################################\n # Do full SVD of X if this is requested, regardless of what is in U \n # Also, if n = 0 or U is empty, start from scratch\n output_k = False\n if svdmethod == 'full' or len(U) == 0 or n == 0:\n if n == 0:\n if len(U) == 0:\n printt(\"----- initial SVD -----\")\n output_k = True\n else:\n # Reshape so we don't have an empty dimension (yay python)\n U = U.reshape(-1, 1)\n elif len(U) == 0:\n printt(\"WARNING: N (number of items modeled by U) is %d, not zero, but U is empty!\" % n)\n\n # Bootstrap\n if missingmethod == 'ignore':\n printt(\"ERROR: ignore with full is not possible under ordinary circumstances.\")\n printt(\"Use --increm-brand to impute for NaNs.\")\n printt(\"For now, we are filling NaNs with 0.\")\n X = copy.deepcopy(X)\n z = np.where(np.isnan(X))\n X[z] = 0\n\n mu = np.mean(X, axis=1).reshape(-1,1)\n X = X - mu\n U, S, V = linalg.svd(X, full_matrices=False)\n printt('Just did full SVD on %d items.' % X.shape[1])\n #print('X:', X)\n #print('U:', U)\n # Reset U to all 0's if we only have one item in X (degenerate SVD)\n if X.shape[1] == 1:\n U = np.zeros_like(U)\n \n # Keep only the first k components\n S_full = S\n S = S[0:k]\n U = U[:,0:k]\n\n # Update n to number of new items in X\n n = X.shape[1]\n \n ###########################################################################\n # Incremental SVD from Ross\n elif svdmethod == 'increm-ross':\n # Incremental SVD from Ross et al. 2008\n # \"Incremental Learning for Robust Visual Tracking\"\n # based on Lim and Ross's sklm.m implementation in MATLAB.\n\n # This method DOES NOT handle missing values.\n if missingmethod == 'ignore':\n print('ERROR: increm-ross cannot handle missing values.')\n print('If they are present, try svdmethod=increm-brand')\n print(' or use missingmethod=zero to zero-fill.')\n print('If there are no missing values, specify missingmethod=none.')\n sys.exit(1)\n\n n_new = X.shape[1]\n \n # Compute mean\n # Weirdly, the later 'X-mu_new' is MUCH faster if you reshape as shown.\n # This is because of differences in the way numpy treats a 1d array versus a 2d column.\n mu_new = np.mean(X, axis=1).reshape(-1,1)\n\n # Subtract the mean, append it as a column vector, and update mu\n # X - mu_new will be zero if X has only 1 item\n mu_old = mu\n # New mu is a weighted sum of old and new mus\n mu = (n * mu_old + n_new * mu_new) / (n + n_new)\n B = np.hstack((X - mu,\n math.sqrt(n_new * n/float(n_new+n)) * \\\n (mu_old - mu_new)))\n printt(\"Now tracking mean for %d -> %d items; mu.min %f, mu.max %f \" % \\\n (n, n+n_new, np.nanmin(mu), np.nanmax(mu)))\n n = n + n_new\n\n if S.all() == 0:\n npcs = U.shape[1]\n diagS = np.zeros((npcs, npcs))\n else:\n diagS = np.diag(S)\n\n # I don't think this is right. At this point B is the augmented\n # matrix rather than the single observation.\n proj = np.dot(U.T, B)\n reproj_err = B - np.dot(U, proj)\n\n # to get orthogonal form of reproj_err\n # This should return q with dimensions [d(X) by n_new+1], square\n q, dummy = linalg.qr(reproj_err, mode='full')\n # print('q.shape should be 7x2: ', q.shape)\n Q = np.hstack((U, q))\n\n # From Ross and Lim, 2008\n # R = [ [ Sigma, U.T * X ] [ 0, orthog. component of reproj error ] ]\n k_now = diagS.shape[0]\n new_dim = k_now + n_new + 1\n R = np.zeros((new_dim, new_dim))\n R[0:k_now,0:k_now] = diagS\n R[0:k_now,k_now:] = proj\n orthog_reproj_err = np.dot(q.T, reproj_err)\n R[k_now:, k_now:] = orthog_reproj_err\n \n # Perform SVD of R. Then finally update U.\n U, S, V = linalg.svd(R, full_matrices=False)\n printt('Just did increm-ross SVD on %d items.' % n)\n\n U = np.dot(Q, U)\n \n # Keep only the first k components\n U = U[:,0:min([n,k])]\n S_full = S\n S = S[0:min([n,k])]\n\n ###########################################################################\n # Incremental SVD from Brand\n elif svdmethod == 'increm-brand':\n # Pulled out James's attempt to handle NaNs into\n # increm-brand-james.py. Starting over from scratch here.\n n_new = X.shape[1]\n\n if n_new != 1:\n print(\"WARNING: increm-brand will probably only work by adding one item at a time.\")\n input('\\nPress enter to continue or ^C/EOF to exit. ')\n\n if missingmethod == 'ignore':\n # 1. Update mu\n mu_old = mu\n mu_new = X\n\n # Be careful! For any pre-existing NaNs in mu,\n # let mu_new fill them in. Can't get any worse!\n naninds = np.where(np.isnan(mu_old))[0]\n if naninds.size > 0:\n mu_old[naninds,0] = mu_new[naninds,0]\n # And likewise for mu_new -- fill with good values from mu_old.\n naninds = np.where(np.isnan(mu_new))[0]\n if naninds.size > 0:\n mu_new[naninds,0] = mu_old[naninds,0]\n # At this point, the only NaNs that should appear are\n # values that were NaN for both mu and X to start with.\n # They will stay NaN and that's okay.\n \n # New mu is a weighted sum of old and new mus\n mu = (n * mu_old + n_new * mu_new) / (n + n_new)\n printt(\"Now tracking mean for %d -> %d items; mu.min %f, mu.max %f \" % \\\n (n, n+n_new, np.nanmin(mu), np.nanmax(mu)))\n n = n + n_new\n\n # 2. Subtract off the mean\n X = X - mu\n\n # 3. Compute L, the projection of X onto U\n # Note: this will only work for a single item in X\n goodinds = np.where(~np.isnan(X))[0]\n #print('X: %d of %d are good.' % (len(goodinds), X.shape[0]))\n\n diagS = np.diag(S)\n # This is Brand's method, which involves S:\n L = np.dot(diagS,\n np.dot(np.linalg.pinv(np.dot(U[goodinds,:],\n diagS)),\n X[goodinds,:]))\n # Simplified version that does not use S (but is probably wrong):\n #L = np.dot(U[goodinds,:].T,\n # X[goodinds,:])\n # Top row of the Q matrix (eqn 12, Brand 2002)\n Q1 = np.hstack([diagS, L])\n\n # 4. Compute J, the orthogonal basis of H, which is\n # the component of X orthog to U (i.e., unrepresentable direction)\n # 5. Compute K, the projection of X onto J (i.e., unrep. content)\n K = linalg.norm(X[goodinds,:] - np.dot(U[goodinds,:],\n np.dot(U[goodinds,:].T,\n X[goodinds,:])))\n # H = X - UL\n J = np.zeros((U.shape[0], 1))\n J[goodinds] = np.dot(K,\n np.linalg.pinv(X[goodinds,:] -\n np.dot(U[goodinds,:],\n L))).T\n \n # Bottom row of Q matrix (eqn 12, Brand 2002)\n Q2 = np.hstack([np.zeros([1, len(S)]), np.array(K).reshape(1,1)])\n Q = np.vstack([Q1, Q2])\n\n # 6. Take the SVD of Q\n Uq, Sq, Vq = linalg.svd(Q, full_matrices=False)\n\n # 7. Update U and S (eqn 4, Brand 2002)\n # Note: Since J is zero-filled for badinds, now U is too.\n # Alternatively, we give J NaNs and let them get into U as well.\n # I think that is a worse idea though.\n U = np.dot(np.hstack([U, J]), Uq)\n S = Sq\n # Updating V requires knowing old V,\n # but we don't need the new one either so it's okay to skip.\n\n printt('Just did increm-brand SVD on %d items.' % n)\n \n ############# end ###########\n \n else: # No missing values (or not 'ignore')\n # 1. Update mu\n mu_old = mu\n mu_new = X\n # New mu is a weighted sum of old and new mus\n mu = (n * mu_old + n_new * mu_new) / (n + n_new)\n n = n + n_new\n\n # 2. Subtract off the mean\n X = X - mu\n\n # 3. Compute L, the projection of X onto U\n L = np.dot(U.T, X)\n Q1 = np.hstack([np.diag(S), L])\n\n # 4. Compute J, the orthogonal basis of H, which is\n # the component of X orthog to U (i.e., unrepresentable direction)\n # 5. Compute K, the projection of X onto J (i.e., unrep. content)\n JK = X - np.dot(U, L)\n (J, K) = linalg.qr(JK)\n\n Q2 = np.hstack([np.zeros([1, len(S)]), np.array(K).reshape(1,1)])\n Q = np.vstack([Q1, Q2])\n\n # 6. Take the SVD of Q\n Uq, Sq, Vq = linalg.svd(Q, full_matrices=False)\n\n # 7. Update U and S (eqn 4, Brand 2002)\n U = np.dot(np.hstack([U, J]), Uq)\n S = Sq\n # V requires knowing old V,\n # but we don't need the new one either so it's okay.\n \n printt('Just did regular increm SVD on %d items.' % n)\n\n # Keep only the first k components\n U = U[:,0:min([n,k])]\n S = S[0:min([n,k])]\n\n Usum = U.sum(1)\n\n\n ###########################################################################\n # We have a bad svdmethod, but somehow didn't catch it earlier.\n else:\n printt(\"504: Bad Gateway in protocol <Skynet_authentication.exe>\")\n return None, None, None, None, None\n\n indivpcts = None\n\n # This only works if a full SVD was done\n if (svdmethod == 'full' and output_k and opts['k_var'] == -773038.0):\n # Calculate percent variance captured by each \n cumsum = np.cumsum(S_full)\n #print(cumsum.shape)\n if cumsum[-1] != 0:\n indivpcts = S / cumsum[-1]\n indivpcts = indivpcts[0:k] # truncate to first k\n cumpercents = cumsum / cumsum[-1]\n else:\n indivpcts = []\n\n # Calculate percent variance captured\n if k >= cumsum.shape[0]:\n printt('Cannot estimate data variance; specified k (%d) exceeds the number of SVs (%d).' % (k, cumsum.shape[0]))\n else:\n printt(\"Selected value of k=%d captures %5.2f%% of the data variance\" % \\\n (k, cumpercents[k-1] * 100))\n if opts['pause']: input(\"Press enter to continue\\n\")\n\n #print('U:', U)\n #print('mu:', mu)\n return U, S, mu, n, indivpcts", "def stress2strain(sigma, S):\n s6 = voigt(sigma)\n e6 = np.dot(S, s6)\n e6[3] = 0.5 * e6[3]\n e6[4] = 0.5 * e6[4]\n e6[5] = 0.5 * e6[5]\n e = unvoigt(e6)\n return e", "def shrink_kernel(self, kernel, up_scale):\n up_scale = torch.tensor(up_scale).float()\n # boundary padding based on the scaling law\n pad_in = (torch.ceil(up_scale**2).int())*((kernel.shape[2]-1)//2)\n pad_h = (torch.ceil(up_scale).int())*((kernel.shape[3]-1)//2)\n pad_w = (torch.ceil(up_scale).int())*((kernel.shape[4]-1)//2)\n padded_kernel = F.pad(kernel, (pad_w, pad_w, pad_h, pad_h, pad_in, pad_in))\n delta = up_scale%1\n \n if delta == 0:\n shrink_factor = 1\n else:\n # shrink_factor for coordinates.\n shrink_factor = (((kernel.shape[4]-1))/(padded_kernel.shape[-1]-1)*(up_scale+1))\n \n # Adjustment to deal with weird filtering on the grid sample function.\n shrink_factor = 1.5*(shrink_factor-0.5)**3 + 0.57 \n\n grid = torch.meshgrid(torch.linspace(-1, 1, kernel.shape[2])*(shrink_factor**2),\n torch.linspace(-1, 1, kernel.shape[3])*shrink_factor, \n torch.linspace(-1, 1, kernel.shape[4])*shrink_factor)\n\n grid = torch.cat([grid[2].unsqueeze(0).unsqueeze(-1), \n grid[1].unsqueeze(0).unsqueeze(-1), \n grid[0].unsqueeze(0).unsqueeze(-1)], dim = -1).repeat(kernel.shape[0],1,1,1,1)\n\n new_kernel = F.grid_sample(padded_kernel, grid.to(device))\n if kernel.shape[-1] - 2*up_scale > 0:\n new_kernel = new_kernel * (kernel.shape[-1]**2/((kernel.shape[-1] - 2*up_scale)**2 + 0.01))\n return new_kernel", "def matrix_svd(\n self,\n chis=None,\n eps=0,\n print_errors=\"deprecated\",\n break_degenerate=False,\n degeneracy_eps=1e-6,\n sparse=False,\n trunc_err_func=None,\n ):\n if print_errors != \"deprecated\":\n msg = (\n \"The `print_errors` keyword argument has been deprecated, \"\n \"and has no effect. Rely instead on getting the error as a \"\n \"return value, and print it yourself.\"\n )\n warnings.warn(msg)\n chis = self._matrix_decomp_format_chis(chis, eps)\n maxchi = max(chis)\n assert self.defval == 0\n assert self.invar\n\n # SVD each sector at a time.\n # While doing so, also keep track of a list of all singular values, as\n # well as a heap that gives the negative of the largest singular value\n # in each sector. These will be needed later when deciding how to\n # truncate the decomposition.\n svds = {}\n dims = {}\n minus_next_sings = []\n all_sings = []\n for k, v in self.sects.items():\n if 0 in v.shape:\n shp = v.shape\n m = min(shp)\n u = np.empty((shp[0], m), dtype=self.dtype)\n s = np.empty((m,), dtype=np.float_)\n v = np.empty((m, shp[1]), dtype=self.dtype)\n else:\n if sparse and maxchi < min(v.shape) - 1:\n u, s, v = spsla.svds(\n v, k=maxchi, return_singular_vectors=True\n )\n order = np.argsort(-s)\n u = u[:, order]\n s = s[order]\n v = v[order, :]\n else:\n u, s, v = np.linalg.svd(v, full_matrices=False)\n svd = (s, u, v)\n svds[k] = svd\n dims[k] = 0\n sings = svd[0]\n all_sings.append(sings)\n if 0 not in sings.shape:\n heapq.heappush(minus_next_sings, (-sings[0], k))\n try:\n all_sings = np.concatenate(all_sings)\n except ValueError:\n all_sings = np.array((0,))\n\n if sparse:\n norm_sq = self.norm_sq()\n else:\n norm_sq = None\n\n # Figure out what bond dimension to truncate to, how this bond\n # dimension is distributed over the different sectors, and what the\n # truncation error is.\n chi, dims, rel_err = type(self)._find_trunc_dim(\n all_sings,\n svds,\n minus_next_sings,\n dims,\n chis=chis,\n eps=eps,\n break_degenerate=break_degenerate,\n degeneracy_eps=degeneracy_eps,\n trunc_err_func=trunc_err_func,\n norm_sq=norm_sq,\n )\n\n # Truncate each block and create the dim for the new index.\n new_dim = []\n new_qim = []\n svds = {k: v for k, v in svds.items() if dims[k] > 0}\n for k, v in svds.items():\n d = dims[k]\n if d > 0:\n new_dim.append(d)\n new_qim.append(k[0])\n svds[k] = (v[0][:d], v[1][:, :d], v[2][:d, :])\n else:\n del svds[k]\n\n # Initialize U, S, V.\n d = self.dirs[0]\n U = type(self)(\n [self.shape[0], new_dim],\n qhape=[self.qhape[0], new_qim],\n dirs=[d, -d],\n qodulus=self.qodulus,\n dtype=self.dtype,\n charge=0,\n )\n S = type(self)(\n [new_dim],\n qhape=[new_qim],\n dirs=[d],\n qodulus=self.qodulus,\n dtype=np.float_,\n invar=False,\n charge=0,\n )\n V = type(self)(\n [new_dim, self.shape[1]],\n qhape=[new_qim, self.qhape[1]],\n dirs=[d, self.dirs[1]],\n qodulus=self.qodulus,\n dtype=self.dtype,\n charge=self.charge,\n )\n\n # Set the blocks of U, S and V.\n for k, v in svds.items():\n k_U = (k[0], k[0])\n S[(k[0],)] = v[0]\n U[k_U] = v[1]\n V[k] = v[2]\n\n return U, S, V, rel_err", "def svd(self, X): # [5pts]\n N,D = X.shape[0],X.shape[1]\n if X.ndim == 3:\n U = np.zeros((N,N,3))\n S = np.zeros((min(N,D),3))\n V = np.zeros((D,D,3))\n for i in range(3):\n U_temp,S_temp,V_temp = np.linalg.svd(X[:,:,i],compute_uv=True, full_matrices=True,hermitian=False)\n U[:,:,i] = U_temp\n S[:,i] = S_temp\n V[:,:,i] = V_temp\n else:\n U,S,V = np.linalg.svd(X,compute_uv=True,full_matrices=True, hermitian=False)\n return U,S,V", "def svd(self):\n U, s, Vh = la.svd(self)\n S = np.zeros(self.shape)\n np.fill_diagonal(S, s)\n return (Matrix(U), Matrix(S), Matrix(Vh))", "def truncated_svd(A,k=None):\n \n \n \n AHA=np.conj(A).T.dot(A)\n evals,evecs=la.eig(AHA)\n order=np.argsort(evals)\n\n evals=evals[order][::-1].copy()\n evecs=evecs.T[order][::-1].copy()\n m,n=AHA.shape\n \n tol=1e-12\n Vh=[]\n for i in xrange(0,m):\n\t\t if np.abs(evals[i])>=tol:\n\t \t\tVh+=[evecs[i]]\n \n Vh=np.array(Vh)\n s=np.sqrt(evals[:Vh.shape[0]])\n U=[]\n for i in xrange(0,len(s)):\n U+=[(1./s[i])*A.dot(Vh[i])]\n U=np.array(U).T\n \n return U,s,Vh", "def squash(vectors, axis=-1):\n s_squared_norm = K.sum(K.square(vectors), axis, keepdims=True)\n scale = s_squared_norm / (1 + s_squared_norm) / K.sqrt(s_squared_norm + K.epsilon())\n return scale * vectors", "def squash(vectors, axis=-1):\n s_squared_norm = K.sum(K.square(vectors), axis, keepdims=True)\n scale = s_squared_norm / (1 + s_squared_norm)/ K.sqrt(s_squared_norm)\n return scale * vectors", "def rebuild_svd(self, U, S, V, k): # [5pts]\n \n N,D = U.shape[0],V.shape[0]\n \n \n if U.ndim == 3:\n Xrebuild = np.zeros((N,D,3))\n for i in range(3):\n U_temp = U[:,0:k,i]\n S_temp = S[:,i]\n S_temp = np.diag(S_temp[0:k])\n V_temp = V[0:k,:,i]\n Xrebuild_temp = U_temp@S_temp@V_temp\n Xrebuild[:,:,i] = Xrebuild_temp\n else:\n U_new = U[:,0:k]\n S_new = np.diag(S[0:k])\n V_new = V[0:k,:]\n Xrebuild = U_new@S_new@V_new\n\n return Xrebuild", "def Decompress(U, SingularValues, V):\n Sigma = np.diag(SingularValues)\n VH = V.transpose().conjugate()\n return U @ Sigma @ VH", "def svd(T):\n try:\n U, S, V = splinalg.svd(T, full_matrices=False)\n except splinalg.LinAlgError:\n U, S, V = splinalg.svd(T, full_matrices=False, lapack_driver='gesvd')\n maxU, minU = U.max(0), U.min(0)\n maxV, minV = V.max(1), V.min(1)\n ind = (np.abs(minU) > maxU) & (np.abs(minV) > maxV)\n U[:, ind] *= -1\n V[ind] *= -1\n return U, S, V", "def tsvd(A, threshold=0.99999, avoid_pathological=True):\n M,N = A.shape\n full_matrices = False\n\n if is_int(threshold):\n # Assume specific number is requested\n r = threshold\n assert 1 <= r <= max(M,N)\n if r > min(M,N):\n full_matrices = True\n r = min(M,N)\n\n U,s,VT = sla.svd(A, full_matrices)\n\n if isinstance(threshold,float):\n # Assume proportion is requested\n r = truncate_rank(s,threshold,avoid_pathological)\n\n # Truncate\n U = U [:,:r]\n VT = VT[ :r]\n s = s [ :r]\n return U,s,VT", "def compact_svd(A, tol=1e-6):\r\n eigs, vecs = la.eig(A.conj().T@A)\r\n svs = np.sqrt(eigs)\r\n #sort eigenvalues and eigenvectors accordingly\r\n sorter = list(zip(svs,vecs.T))\r\n sorter.sort(reverse=True, key=lambda tup: tup[0])\r\n svs = [x[0] for x in sorter]\r\n vecs = [x[1] for x in sorter]\r\n #find number of nonzero eigenvalues\r\n r_not = svs.count(0)\r\n r = len(svs) - r_not\r\n svs_1 = np.array(svs[:r])\r\n vecs_1 = np.array(vecs[:r])\r\n u_1 = (A@vecs_1)/svs_1\r\n\r\n return u_1, svs_1, vecs_1.conj().T", "def reduce_svd(embeddings, seed=0):\n svd = TruncatedSVD(n_components=2, n_iter=10, random_state=seed)\n return svd.fit_transform(embeddings)", "def test_squeezing(self, tol):\n r = 0.543\n phi = 0.123\n S = symplectic.squeezing(r, phi)\n out = S @ S.T\n\n # apply to an identity covariance matrix\n rotation = np.array(\n [[np.cos(phi / 2), -np.sin(phi / 2)], [np.sin(phi / 2), np.cos(phi / 2)]]\n )\n expected = rotation @ np.diag(np.exp([-2 * r, 2 * r])) @ rotation.T\n assert np.allclose(out, expected, atol=tol, rtol=0)", "def scale(v: InputTensor) -> t.Tensor:\n v = util.to_tensor(v, dtype=t.float32)\n assert len(v.shape) == 1\n return t.diag(t.cat([v, v.new_ones([1])], dim=0))", "def reduce_dimentions(users):\n\tsvd = TruncatedSVD(n_components=300, n_iter=10, random_state=42)\n\tsvd.fit(users)\n\tusers_svd = svd.transform(users)\n\tusers_svd = pd.DataFrame(users_svd, index=users.index)\n\treturn users_svd", "def singular_decomp(A):\n # Initialization\n n, m = A.shape\n U = np.zeros((n, m), dtype='float64')\n\n # Diagonalization of A^T * A\n rot, e, V = eigen.diag(np.dot(np.transpose(A), A))\n\n # Calculate U\n U = np.dot(A, V)\n for i in range(m):\n e[i] = np.sqrt(e[i])\n U[:, i] /= e[i]\n\n return U, e, V", "def return_diagonal_scalings(self, x):\n u = self.domain.element()\n v = self.domain.one()\n\n # Running the Sinkhorn iterations\n for j in range(self.niter):\n tmp = np.fmax(self.K_op(v), 1e-30)\n u = self.mu0 / tmp\n tmp = np.fmax(self.K_op_adjoint(u), 1e-30)\n v = x / tmp\n\n self.__tmp_u = u\n self.__tmp_v = v\n self.__tmp_x = x\n return u, v", "def svd_approx(A, s):\r\n U, Si, Vh = la.svd(A)\r\n zeros = list(Si).count(0)\r\n #raise error if there are not enough nonzero singular values\r\n if len(Si) - zeros < s:\r\n raise ValueError(\"s > rank(A)\")\r\n #Only save first s singular values for Si\r\n Si_hat = np.diag(Si[:s])\r\n #Save first s columns of U\r\n U_hat = U[:,:s]\r\n #Save first s rows of Vh\r\n Vh_hat = Vh[:s,:]\r\n\r\n # return new A and num of entries needed\r\n return U_hat@Si_hat@Vh_hat, U_hat.size+s+Vh_hat.size", "def compact_svd(A, tol=1e-6):\n #Compute eigenvalues/vectors\n lam, V = la.eig((A.conj().T @ A))\n sig = np.sqrt(lam)\n \n #Sort results\n argB = np.argsort(sig)\n arg = []\n for i in range(0, len(argB)):\n arg.append(argB[len(argB)-1-i])\n sig = sig[arg]\n V = V[:,arg]\n #How many non-zero positive\n r = 0\n for j in range(0, len(sig)):\n if abs(sig[j]) >= tol:\n r += 1\n \n sig1 = sig[:r]\n V1 = np.array(V[:,:r])\n \n# print(np.shape(A))\n# print(np.shape(V1))\n U1 = A@V1\n U1 = U1/sig1\n \n #Return answers\n return U1, sig1, V1.conj().T\n\n raise NotImplementedError(\"Problem 1 Incomplete\")", "def whiten(M):\r\n sigma = util.cov(M)\r\n U,S,V = np.linalg.svd(sigma)\r\n S_1_2 = S**(-0.5)\r\n S = np.diag(S_1_2.T)\r\n Aw = np.dot(V, np.dot(S, V.T))\r\n return np.dot(M, Aw)" ]

[ "0.65727735", "0.6489692", "0.58918875", "0.5725711", "0.56523156", "0.5544449", "0.5430515", "0.54155755", "0.5347083", "0.52910936", "0.5272394", "0.52572405", "0.5206992", "0.51743233", "0.5170114", "0.5169911", "0.5154137", "0.5126522", "0.51069653", "0.5103173", "0.50936884", "0.50882345", "0.50670767", "0.50640196", "0.50225747", "0.49912745", "0.49522358", "0.49448952", "0.49366552", "0.49309313" ]

[ "def shrink(x: np.ndarray, t: float) -> np.ndarray:\n return np.sign(x) * np.maximum(np.abs(x) - t, 0)", "def svd_shrink(X, tau):\n U,s,V = np.linalg.svd(X, full_matrices=False)\n return np.dot(U, np.dot(np.diag(shrink(s, tau)), V))", "def maxmarginal(self, target, out=None):\n return self.__opReduce2(self.v - target,np.max, out=out)", "def shrink(self):\n x = np.nan_to_num(self.X.values)\n\n # de-mean returns\n t, n = np.shape(x)\n meanx = x.mean(axis=0)\n x = x - np.tile(meanx, (t, 1))\n xmkt = x.mean(axis=1).reshape(t, 1)\n\n # compute sample covariance matrix\n sample = np.cov(np.append(x, xmkt, axis=1), rowvar=False) * (t - 1) / t\n covmkt = sample[0:n, n].reshape(n, 1)\n varmkt = sample[n, n]\n sample = sample[:n, :n]\n prior = np.dot(covmkt, covmkt.T) / varmkt\n prior[np.eye(n) == 1] = np.diag(sample)\n\n # compute shrinkage parameters\n if self.delta is None:\n c = np.linalg.norm(sample - prior, \"fro\") ** 2\n y = x ** 2\n p = 1 / t * np.sum(np.dot(y.T, y)) - np.sum(sample ** 2)\n # r is divided into diagonal\n # and off-diagonal terms, and the off-diagonal term\n # is itself divided into smaller terms\n rdiag = 1 / t * np.sum(y ** 2) - sum(np.diag(sample) ** 2)\n z = x * np.tile(xmkt, (n,))\n v1 = 1 / t * np.dot(y.T, z) - np.tile(covmkt, (n,)) * sample\n roff1 = (\n np.sum(v1 * np.tile(covmkt, (n,)).T) / varmkt\n - np.sum(np.diag(v1) * covmkt.T) / varmkt\n )\n v3 = 1 / t * np.dot(z.T, z) - varmkt * sample\n roff3 = (\n np.sum(v3 * np.dot(covmkt, covmkt.T)) / varmkt ** 2\n - np.sum(np.diag(v3).reshape(-1, 1) * covmkt ** 2) / varmkt ** 2\n )\n roff = 2 * roff1 - roff3\n r = rdiag + roff\n\n # compute shrinkage constant\n k = (p - r) / c\n shrinkage = max(0, min(1, k / t))\n self.delta = shrinkage\n else:\n # use specified constant\n shrinkage = self.delta\n\n # compute the estimator\n sigma = shrinkage * prior + (1 - shrinkage) * sample\n return self.format_and_annualise(sigma)", "def apply(cls, x):\n return np.maximum(-1, np.minimum(1, x))", "def action(self, X):\n if self.separate:\n k = np.argmax([np.sum(X[i*self.m:(i+1)*self.m])\n for i in range(int(len(X)/self.m))])\n # k is the maximizing bulk\n return np.arange(k*self.m, (k+1)*self.m)\n else:\n # return m maximizing indices of X\n return np.argpartition(X, -self.m)[-self.m:]", "def apply(cls, x):\n return np.maximum(0, np.minimum(1, 0.2*x + 0.5))", "def apply(self, X):\n \n return T.cast(T.ge(X,\n self.relex_level*T.max(X,\n axis=(1),\n keepdims=True)),\n dtype=\"float32\");", "def softmax(self, x):\n\n out = np.zeros(x.shape)\n for i in range(x.shape[0]):\n max_x = x[i] - np.max(x[i])\n out[i] = np.exp(max_x) / np.sum(np.exp(max_x), axis=0)\n\n return out", "def max_abs_weights(x,\n *,\n axis = None):\n abs_max_x = jnp.max(jnp.abs(x), axis=axis, keepdims=True)\n return abs_max_x", "def minmarginal(self, target, out=None):\n return self.__opReduce2(self.v - target,np.min, out=out)\n\n\n # use ufunc.reduceat? reduce etc seem not good?\n # frompyfunc to make ufunc from python function?\n # use \"externalloop\" flag?\n #return t.max(axis=None,out=None) # use axis to specific dimensions to eliminate; out for IP version", "def maximize(self,x0,method='fmin',**kwargs):\n return self._optimize(x0,'max',method,**kwargs)", "def pred(W, X):\n A = softmax_stable(X.dot(W))\n return np.argmax(A, axis = 1)", "def argmax(X):\n\tN,K,_ = X.shape\n\tg0 = X[0,0]\n\tg = X[1:]\n\n\tB = ones((N,K), dtype=int32) * -1\n\t# compute max-marginals and backtrace matrix\n\tV = g0\n\tfor t in xrange(1,N):\n\t\tU = empty(K)\n\t\tfor y in xrange(K):\n\t\t\tw = V + g[t-1,:,y]\n\t\t\tB[t,y] = b = w.argmax()\n\t\t\tU[y] = w[b]\n\t\tV = U\n\t# extract the best path by brack-tracking\n\ty = V.argmax()\n\ttrace = []\n\tfor t in reversed(xrange(N)):\n\t\ttrace.append(y)\n\t\ty = B[t, y]\n\ttrace.reverse()\n\treturn trace", "def maximize(self, budget, optimizer):\n\n\t\tpass", "def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum(axis=0) # only difference", "def find_max_x(self, Ns=50):\n with self.fix_evaluator():\n x0 = brute(lambda x: -self(x[0])[0], [[0, np.pi]], Ns=Ns,\n finish=None)\n res = minimize_scalar(\n lambda x: -self(x)[0],\n bracket=(x0, np.pi/Ns), bounds=(0, np.pi), method='bounded',\n options=dict(xatol=1e-12)\n )\n return res.x", "def maximize(self):\n raise NotImplementedError", "def pred(W, X):\r\n A = softmax(W.T.dot(X))\r\n return np.argmax(A, axis = 0)", "def softmax(x):\n orig_shape = x.shape\n\n if len(x.shape) > 1:\n # Matrix\n tmp = np.max(x, axis=1)\n x -= tmp.reshape((x.shape[0], 1))\n x = np.exp(x)\n tmp = np.sum(x, axis=1)\n x /= tmp.reshape((x.shape[0], 1))\n else:\n # Vector\n tmp = np.max(x)\n x -= tmp\n x = np.exp(x)\n tmp = np.sum(x)\n x /= tmp\n\n assert x.shape == orig_shape\n return x", "def maxabs_scale(X, *, axis=..., copy=...):\n ...", "def apply_householder(X,beta,v) :\n #pdb.set_trace()\n if X.ndim == 1 :\n X = X.reshape([1,X.shape[0]])\n w = beta * np.dot(X.T,v)\n if X.shape[1] == 1 :\n w = np.array([w])\n rhs = (v * w).T\n else :\n rhs = np.outer(v,w)\n #print \"returning shape: \", (X-rhs).shape, X.shape, rhs.shape\n stdout.flush()\n return X - rhs\n #print \"w: \", w\n #print \"dot: \", np.dot(v,X).shape, v.shape\n #print \"comp\", v.shape, (beta*np.dot(X.T,v)).T.shape\n #if X.shape == 1 :\n\n #print \"returning shape: \", (X - np.dot(v,beta*np.dot(X.T,v).T)).shape\n #return X - np.outer(v,beta*np.dot(v,X).T)", "def softmax(self, x):\n \"\"\" Meaning: avoid very large exponents by reducing the largest to zero\n and everything else to less than that\"\"\"\n ex = np.exp(x - np.max(x))\n return ex / np.sum(ex, axis = 1, keepdims=True) #Sums over rows np.sum([[0, 1], [0, 5]], axis=1) = array([1, 5])", "def maximum(x):\n return np.maximum(x, 0)", "def softmax(X):\n _X = X - np.max(X, axis=1).reshape(-1, 1)\n ep = np.exp(_X)\n return ep / np.sum(ep, axis=1).reshape(-1, 1)", "def softmax(x):\r\n e_x = np.exp(x - np.max(x))\r\n return e_x / e_x.sum(axis=0) # only difference\r", "def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum(axis=0) # only difference", "def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum(axis=0) # only difference", "def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum(axis=0) # only difference", "def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum(axis=0) # only difference" ]

[ "0.60550916", "0.5972582", "0.5969634", "0.59686756", "0.5896139", "0.5784762", "0.5737154", "0.57011837", "0.5677368", "0.5558483", "0.55497855", "0.55328274", "0.54991966", "0.5492068", "0.5474867", "0.5435057", "0.54302967", "0.54115343", "0.5405042", "0.5398064", "0.5384196", "0.53810775", "0.5370654", "0.5364554", "0.532371", "0.5313121", "0.5302391", "0.5302391", "0.5302391", "0.5302391" ]

[ "def normFro(X):\n return norm(X)", "def squared_frobenius_norm(x):\n # http://mathworld.wolfram.com/FrobeniusNorm.html\n # The gradient of KL[p,q] is not defined when p==q. The culprit is\n # tf.norm, i.e., we cannot use the commented out code.\n # return tf.square(tf.norm(x, ord=\"fro\", axis=[-2, -1]))\n return tf.reduce_sum(tf.square(x), axis=[-2, -1])", "def norm(x):\r\n return sqrt(np.numerical.sum(x**2))", "def normF2(X):\r\n # pass\r\n if X.shape[0]*X.shape[1] == 0:\r\n return 0\r\n return LA.norm(X, 'fro')**2", "def norm(x):\n return np.sqrt(np.sum(x ** 2))", "def norm(self):\n C = np.prod([F.T @ F for F in self.factors], axis=0)\n return np.sqrt(np.sum(C))", "def normsq(self):\n return sum(x**2 for x in self.data)", "def norm(x):\n return inner_prod(x, x)[0].sqrt_()", "def norm(x):\n return np.sqrt(norm2(x))", "def norm(alpha, F):\n return inner_product(alpha, F, alpha)", "def norm_sqr(x):\n return inner_prod(x, x)[0]", "def square_norm(x):\n return np.linalg.norm(x) ** 2", "def fast_norm(x):\n return sqrt(dot(x, x.T))", "def get_norm(x):\n return np.sqrt(np.sum(np.square(x)))", "def norm(self):\n mag_squared = self._sum_of_squares()\n return sqrt(mag_squared)", "def norm(self):\n\t\treturn np.sqrt(self.normSq())", "def NormU(x):\n return sum(0.5*x**2)", "def normsq(self):\n return abs(sum(self._ar * self._ar))", "def nuclearnorm(X):\r\n if X.size == 0:\r\n return 0\r\n return LA.norm(X) if is_vector(X) else LA.norm(X, 'nuc')\r\n\r\n\r\n pass", "def norm(self):\n return np.sqrt(np.dot(self._data, self._data))", "def normalisation_l2(x):\n res = np.zeros(x.shape)\n print(x.shape)\n for i in range(x.shape[0]):\n res[i] = x[i]/(np.linalg.norm(x[i],2)+1e-5)\n std = res.std()\n mean = res.mean()\n print(\"normalisation done\")\n return(mean,std,res)", "def squared_norm(self) -> float:\n return self.__real**2 + self.__img[0]**2 + self.__img[1]**2 + self.__img[2]**2", "def element_wise_operation(self, xi_j: Tuple) -> float:\n xi, xj = xi_j\n r = np.dot(xi.T, xj)\n n = np.linalg.norm(r, \"fro\")\n return n * n", "def norm(self) -> float:\n return self.squared_norm()**0.5", "def norm(self):\n norm = self.scalarProduct(self) ** 0.5\n return norm", "def norm(X, eps=1e-8, keepdims=True):\n return X / (np.sqrt(np.sum(X**2, axis=1, keepdims=keepdims)) + eps)", "def _euclidnorm(x):\n \n return(np.sqrt(np.sum(np.square(x))))", "def norm(self):\n return np.linalg.norm(self.values)", "def norm(self):\n return sqrt(self.dot(self))", "def _normalize(X: np.ndarray) -> np.ndarray:\n # return X * np.sqrt(1 / np.sum(X ** 2, axis=1))[:, None]\n return X * np.sqrt(X.shape[1] / np.sum(X ** 2, axis=1))[:, None]" ]

[ "0.7487804", "0.73903", "0.7302113", "0.7199961", "0.7122286", "0.70065945", "0.6957892", "0.6941357", "0.69108367", "0.67138755", "0.6710018", "0.6634665", "0.65393853", "0.6538264", "0.6525256", "0.6451336", "0.64268863", "0.6420409", "0.63798773", "0.63551456", "0.6353465", "0.6338793", "0.63296455", "0.62948257", "0.6280223", "0.6277212", "0.62493056", "0.6220027", "0.62162286", "0.6194278" ]

[ "def norm1(x):\n n, p = x.shape\n if p == 1 or n == 1:\n return np.sum(np.abs(x))\n else:\n return np.max(np.sum(np.abs(x), axis=0))", "def norm1(X):\r\n # pass\r\n if X.shape[0]*X.shape[1] == 0:\r\n return 0\r\n return abs(X).sum()\r\n # return LA.norm(X, 1)\r", "def norm1(x,maxx):\n return (2.0 * x - float(maxx)) / float(maxx)", "def L1(X):\n \n sanitycheck(X,np.ndarray)\n return np.sqrt(np.power(X, 2)).sum(axis=1)", "def max_norm() -> float:\n return 1.0", "def get_L(self, X):\n if issparse(X):\n return slinalg.norm(X, axis=1) ** 2\n else:\n return norm(X, axis=1) ** 2", "def compute_L2_normalization(xx):\r\n\treturn np.sum(xx ** 2, axis=1)", "def l1_normalize(x: np.ndarray) -> np.ndarray: # pylint: disable=invalid-name\n return x / x.sum()", "def _l1m_objective(a,X,*args):\n \n return(np.sum(np.apply_along_axis(_euclidnorm,1,_diffmat_objective(a,X))))", "def func_val_l1_norm(w):\n\treturn np.linalg.norm(w,ord = 1)", "def norm_max(vector):\n return la.norm(vector, np.inf)", "def normalisation_l_inf(x):\n res = np.zeros(x.shape)\n for i in range(x.shape[0]):\n for j in range(x.shape[1]):\n res[i,j] = x[i,j]/(np.max(x[i,j])+1e-5)\n return(res)", "def _norm_along_last_axis(x):\n return np.sqrt(np.sum(np.square(x), axis=x.ndim - 1))", "def l1norm(X, dim=-1, eps=1e-8):\r\n norm = torch.abs(X).sum(dim=dim, keepdim=True) + eps\r\n X = torch.div(X, norm)\r\n return X", "def l2norm(X):\n norm = np.linalg.norm(X, axis=1, keepdims=True)\n return 1.0 * X / norm", "def rough_l_max(L):\r\n # TODO: Check if L is sparse or not, and handle the situation accordingly\r\n\r\n l_max = np.linalg.eigvalsh(L.todense()).max()\r\n\r\n\r\n l_max_ub = 1.01 * l_max\r\n return l_max_ub", "def operator_one_norm(W):\n return torch.max(torch.sum(torch.abs(W), dim=(0, 2, 3)))", "def apply(self, X):\n \n return T.cast(T.ge(X,\n self.relex_level*T.max(X,\n axis=(1),\n keepdims=True)),\n dtype=\"float32\");", "def prox_l1_norm(w, lamb):\n\treturn np.sign(w) * np.maximum( np.abs(w) - lamb, 0)", "def maxnorm(self, priors=None):\n def maxnorm_f(x): return x.max(axis=0)\n return self.utility(maxnorm_f, priors)", "def l1(vec):\n return np.linalg.norm(vec, ord=1)", "def l21_norm_bound(X, Y, loss='square'):\n if loss.lower() == 'square':\n # In this case max_tau := 2/n * max(||[X^T * Y]s||_2)\n # First compute the 2-norm of each row of X^T * Y\n norm2 = map(lambda x: np.linalg.norm(x, ord=2), X.T.dot(Y))\n return np.max(norm2) * (2.0/X.shape[0])\n else:\n print('Only square loss implemented so far.')\n sys.exit(-1)", "def max_normalization(array):\n return 1/np.max(array) * array.squeeze(axis=1)", "def norm(x):\n return inner_prod(x, x)[0].sqrt_()", "def MaxNorm(matrix):\r\n max_norm = 0\r\n for i in range(len(matrix)):\r\n norm = 0\r\n for j in range(len(matrix)):\r\n # Sum of organs per line with absolute value\r\n norm += abs(matrix[i][j])\r\n # Maximum row amount\r\n if norm > max_norm:\r\n max_norm = norm\r\n\r\n return max_norm", "def get_norm(x):\n return np.sqrt(np.sum(np.square(x)))", "def _normalize(X: np.ndarray) -> np.ndarray:\n # return X * np.sqrt(1 / np.sum(X ** 2, axis=1))[:, None]\n return X * np.sqrt(X.shape[1] / np.sum(X ** 2, axis=1))[:, None]", "def norm(x):\r\n return sqrt(np.numerical.sum(x**2))", "def normF2(X):\r\n # pass\r\n if X.shape[0]*X.shape[1] == 0:\r\n return 0\r\n return LA.norm(X, 'fro')**2", "def normsq(self):\n return sum(x**2 for x in self.data)" ]

[ "0.75343716", "0.73331046", "0.7129455", "0.7089392", "0.67368776", "0.6676168", "0.6675522", "0.6635472", "0.6539204", "0.65240026", "0.6478929", "0.6411275", "0.6410474", "0.640039", "0.6349481", "0.6343169", "0.6333034", "0.6278802", "0.62678295", "0.6257422", "0.6254585", "0.624691", "0.62456226", "0.62372595", "0.6237234", "0.623174", "0.6227088", "0.6225207", "0.6214458", "0.62109476" ]

[ "def failIfContainsInstanceOf(self, theClass, params, theList, msg=None):\n\n self.failIfNoMessage(theList)\n\n for item in theList:\n if theClass==Message and isinstance(item,SelfDoesntMatchLocation):\n continue\n if theClass==Message and isinstance(item,MissingSelf):\n continue\n if issubclass(item.__class__, theClass):\n if not params:\n raise self.failureException, \\\n (msg or 'unexpected %s' % (theClass.__name__))\n allmatch = 1\n for k, v in params.items():\n if item.params[k] != v:\n allmatch = 0\n if allmatch:\n raise self.failureException, \\\n \"unexpected %s.%s with a value of %s\" % \\\n (theClass.__name__, k, v)", "def assert_instances(self, collection, count, clazz):\n num = 0\n for item in collection:\n num += 1\n assert isinstance(item, clazz)\n eq_(count, num)", "def process_class_list(self, module, classes):", "def test_create_obj_by_type_from_list(self):\n test_obj = [mock.MagicMock(), \"test_atrt\", {}]\n returned_obj = self.tested_class._create_obj_by_type(test_obj)\n self.assertIsInstance(returned_obj, list)\n self.assertIs(returned_obj[0], test_obj[0])\n self.assertEqual(returned_obj[1], test_obj[1])\n self.assertIsInstance(returned_obj[2], self.tested_class)", "def check_for_list(check):", "def assert_items(self, items, cls):\r\n for item in items:\r\n assert isinstance(item, cls)", "def do_count(self, *args):\n count = 0\n args = [ele for ele in args[0].split(' ')]\n if args[0] == '':\n print(\"** class name missing **\")\n return\n if args[0] not in self.list_classes:\n print(\"** class doesn't exist **\")\n return\n else:\n ''' Get a list of specified instances '''\n for key, obj in storage.all().items():\n key = key.split('.')\n if key[0] == args[0]:\n count += 1\n print(count)", "def index_already_there(index, given_list):\n\n # check if ID already exists\n already_there = False\n if len(given_list)>0:\n for item in given_list:\n if isinstance(item, AutoBaseObject):\n if item.ID == index:\n already_there = True\n break\n else:\n print(\"Issue with list: item is not AutoBaseObject\")\n print(\" index=\\n\",index)\n sys.exit()\n return already_there", "def basic_errs(self, args):\n if len(args) == 0:\n '''if class name is missing'''\n print(\"** class name missing **\")\n\n elif args[0] not in models.classes:\n print(\"** class doesn't exist **\")\n\n elif len(args) == 1:\n print(\"** instance id missing **\")\n\n else:\n return True\n return False", "def PyClassifyList(InchiList):\r\n nr_Classified = 0\r\n nr_Errors = 0\r\n print(\"List length: \"+str(len(InchiList)))\r\n for i in InchiList:\r\n try:\r\n pyclassyfire.client.get_entity(i, 'json')\r\n nr_Classified +=1\r\n except:\r\n nr_Errors += 1\r\n print(\"Classified: \"+str(nr_Classified))\r\n print(\"Errors: \"+str(nr_Errors))\r\n return nr_Classified, nr_Errors", "def test_list_of_non_subclass_objs(self):\n with self.assertRaises(AttributeError):\n self.s1.save_to_file([88, 99])", "def is_instance(instance, expected_types):\n for expected_type in expected_types:\n if isinstance(instance, expected_type):\n return True\n\n return False", "def test_instantiation_with_list():\n vec3 = Vec3([1, 2, 3])\n assert vec3.x1 == 1.0\n assert vec3.x2 == 2.0\n assert vec3.x3 == 3.0\n\n with pytest.raises(Exception):\n vec3 = Vec3([1, 2, 3, 4])\n\n with pytest.raises(Exception):\n vec3 = Vec3([1, 2])", "def check_def(self,data_list):\n\n if type(data_list)!=list:\n data_list=[data_list]\n \n for value in data_list:\n if type(eval('self.'+value))==str:\n print \"failed for\", value\n return 0\n return 1", "def test_instantiate_non_existent_class(self):\n # create test configs\n test_configs = [\n {\"_target_\": \"collections.NonExistentClass\"},\n {\"_target_\": \"collections.OtherNonExistentClass\", \"a\": 1, \"b\": 2}\n ]\n\n # check that instantiate raises AttributeError for each test config\n for test_conf in test_configs:\n self.assertRaises(AttributeError, instantiate, test_conf)", "def verify(self, arg, choose):\n if not arg:\n print(\"** class name missing **\")\n return 0\n args = arg.split(\" \")\n if args[0] not in self.__classes:\n print(\"** class doesn't exist **\")\n return 0\n if len(args) == 1:\n print(\"** instance id missing **\")\n return 0\n obj = storage.all()\n k = \"{}.{}\".format(args[0], args[1])\n for key, val in obj.items():\n if key == k:\n if choose == 1:\n return val\n if choose == 2:\n return k\n print(\"** no instance found **\")", "def test_fromlist(self):\n\n self.assertRaises(TypeError, self.hw, [])", "def unique_classes(srcfile, listfile):\n cls_list = []\n with open(listfile, 'r') as f:\n lines = f.readlines()\n\n for line in lines:\n xml_file = srcfile.format(line.strip())\n\n tree = ET.parse(xml_file)\n objs = tree.findall('object')\n\n for ix, obj in enumerate(objs):\n cls = obj.find('name').text\n if cls in cls_list:\n pass\n else:\n cls_list.append(cls)\n print(cls)", "def do_all(self, *args):\n args = [ele for ele in args[0].split(' ')]\n print_obj = []\n storage.reload()\n if args[0] == '':\n for key, obj in storage.all().items():\n print_obj.append(obj.__str__())\n print(print_obj)\n return\n if args[0] not in self.list_classes:\n print(\"** class doesn't exist **\")\n return\n else:\n ''' Get a list of specified instances '''\n for key, obj in storage.all().items():\n key = key.split('.')\n if key[0] == args[0]:\n print_obj.append(obj.__str__())\n print(print_obj)", "def test_method_list_all(self):\n\n locations_list = Location.list()\n\n # returned object should be a list\n self.assertIsInstance(locations_list, list)\n\n # make sure items returned are not duplicated. \n location_set = set(locations_list)\n self.assertEqual(len(locations_list), len(location_set))\n \n # ensure the types of the returned items are all 'Location'\n types = [type(location) for location in locations_list]\n self.assertEqual(len(set(types)), 1)\n self.assertEqual(types[0], Location)", "def needs_unique_instance(type_):\n return type_ in unique_instance_types", "def get_chromosome_from_list(self,_class,index):\n search_list = self.chromo_list[index]\n #List doesnt exist\n if search_list is None:\n return None\n #List exists\n else:\n search_chromosome = None\n for chromosomes in search_list:\n #Class is found\n if chromosomes._class is _class:\n search_chromosome = chromosomes\n break\n #Class is not found\n else:\n search_chromosome = None\n \n return search_chromosome", "def exists_one_of(self, *args):\n\n if len(args) % 2 != 0:\n raise RuntimeError('Number of args passed to exists_one_of() must be an even number')\n\n # will be overwritten later if they passed in a value for timeout\n timeout = self.default_implicit_wait\n\n # turn list ['a', 'b', 'c', 'd']\n # into dict {'a':'b', 'c':'d'}\n search_list = []\n while args:\n if args[0] in ['class_name', 'id', 'xpath']:\n d = {args[0]: args[1]}\n search_list.append(d)\n elif args[0] == 'timeout':\n timeout = args[1]\n args = args[2:]\n\n start_time = time()\n\n while True:\n # this inner for loop will ensure that we search for all elements at least once.\n for i in range(len(search_list)):\n new_args = {'timeout': 0}\n new_args.update(search_list[i]) # 'timeout'=0 we want exists to return immediately\n\n elem = self.exists(**new_args)\n if elem:\n return elem\n\n if time() - start_time > timeout:\n return False", "def having(cls, *lst):\n cls.runtime.set_having(lst)\n return cls", "def validate_list(types,val,allowed,tname):\n if not len(types): return TYPE_MISMATCH\n if type(val) not in TYPES[tname]: raise Exception('unknown type')\n for v in val:\n result=VALIDATORS[types[-1]](types[:-1],v,allowed,types[-1])\n if not result: return result\n return True", "def test_validation_class(self):\n\n for data in ('tbldata', 'dihedraldata', 'rdcdata', 'danidata', 'tensordata', 'pcsdata'):\n v = self.web.query_nodes(key=data)\n\n if not v.empty():\n self.assertTrue(v.validate())", "def test_all(self):\n self.assertEqual(type(self.vehicle_list), type([]))\n [self.assertEqual(type(i), BusVehicle) for i in self.vehicle_list]", "def isValidTypeForList(self, *args):\n return _libsbml.SBasePlugin_isValidTypeForList(self, *args)", "def filter_by_class(objects, cls):\n if cls is not None:\n filtered = []\n classes = cls if isinstance(cls, tuple) else (cls,)\n for o in objects:\n valid = False\n for c in classes:\n try:\n if o.is_valid(c):\n valid = True\n break\n except AttributeError:\n continue\n if valid:\n filtered.append(o)\n return filtered\n else:\n return list(objects)", "def test_missing_generic_args(self):\n import System\n #TODO specify clearly which exception is appropriate here\n self.assertRaises(Exception, System.Collections.Generic.List)" ]

[ "0.74682057", "0.5826906", "0.56888276", "0.56885767", "0.5665245", "0.5642358", "0.5449294", "0.544411", "0.5437559", "0.5421472", "0.53909975", "0.537806", "0.53212565", "0.5292676", "0.52794766", "0.52672017", "0.5241191", "0.5227246", "0.5198345", "0.5182619", "0.51759696", "0.51742697", "0.51742476", "0.5171732", "0.51598006", "0.515873", "0.5158578", "0.5149782", "0.5149547", "0.513983" ]

[ "def failUnlessContainsInstanceOf(self, theClass, params, theList, msg=None):\n self.failIfNoMessage(theList)\n\n failure=(msg or 'no %s instances in %s' % (theClass.__name__, repr(theList)))\n for item in theList:\n if issubclass(item.__class__, theClass):\n if not params: return\n for k, v in params.items():\n if str(item.params[k]) != v:\n failure=(\"%s.%s value was %s, expected %s\" %\n (theClass.__name__, k, item.params[k], v))\n break\n else:\n return\n raise self.failureException, failure", "def check_for_list(check):", "def assert_items(self, items, cls):\r\n for item in items:\r\n assert isinstance(item, cls)", "def assert_instances(self, collection, count, clazz):\n num = 0\n for item in collection:\n num += 1\n assert isinstance(item, clazz)\n eq_(count, num)", "def index_already_there(index, given_list):\n\n # check if ID already exists\n already_there = False\n if len(given_list)>0:\n for item in given_list:\n if isinstance(item, AutoBaseObject):\n if item.ID == index:\n already_there = True\n break\n else:\n print(\"Issue with list: item is not AutoBaseObject\")\n print(\" index=\\n\",index)\n sys.exit()\n return already_there", "def test_create_obj_by_type_from_list(self):\n test_obj = [mock.MagicMock(), \"test_atrt\", {}]\n returned_obj = self.tested_class._create_obj_by_type(test_obj)\n self.assertIsInstance(returned_obj, list)\n self.assertIs(returned_obj[0], test_obj[0])\n self.assertEqual(returned_obj[1], test_obj[1])\n self.assertIsInstance(returned_obj[2], self.tested_class)", "def process_class_list(self, module, classes):", "def test_list_of_non_subclass_objs(self):\n with self.assertRaises(AttributeError):\n self.s1.save_to_file([88, 99])", "def is_instance(instance, expected_types):\n for expected_type in expected_types:\n if isinstance(instance, expected_type):\n return True\n\n return False", "def basic_errs(self, args):\n if len(args) == 0:\n '''if class name is missing'''\n print(\"** class name missing **\")\n\n elif args[0] not in models.classes:\n print(\"** class doesn't exist **\")\n\n elif len(args) == 1:\n print(\"** instance id missing **\")\n\n else:\n return True\n return False", "def check_def(self,data_list):\n\n if type(data_list)!=list:\n data_list=[data_list]\n \n for value in data_list:\n if type(eval('self.'+value))==str:\n print \"failed for\", value\n return 0\n return 1", "def validate_list(types,val,allowed,tname):\n if not len(types): return TYPE_MISMATCH\n if type(val) not in TYPES[tname]: raise Exception('unknown type')\n for v in val:\n result=VALIDATORS[types[-1]](types[:-1],v,allowed,types[-1])\n if not result: return result\n return True", "def PyClassifyList(InchiList):\r\n nr_Classified = 0\r\n nr_Errors = 0\r\n print(\"List length: \"+str(len(InchiList)))\r\n for i in InchiList:\r\n try:\r\n pyclassyfire.client.get_entity(i, 'json')\r\n nr_Classified +=1\r\n except:\r\n nr_Errors += 1\r\n print(\"Classified: \"+str(nr_Classified))\r\n print(\"Errors: \"+str(nr_Errors))\r\n return nr_Classified, nr_Errors", "def test_instantiation_with_list():\n vec3 = Vec3([1, 2, 3])\n assert vec3.x1 == 1.0\n assert vec3.x2 == 2.0\n assert vec3.x3 == 3.0\n\n with pytest.raises(Exception):\n vec3 = Vec3([1, 2, 3, 4])\n\n with pytest.raises(Exception):\n vec3 = Vec3([1, 2])", "def _check_items(cls, sequence):\n all([cls._check_item(x) for x in sequence])", "def list_should_not_contain_duplicates(self,list_,msg=None):\r\n if not isinstance(list_,list):\r\n list_= list(list_)\r\n dupes = []\r\n for item in list_:\r\n if item not in dupes:\r\n count = list_.count(item)\r\n if count >1:\r\n logger.info(\" '%s' found %d times\" %(item,count))\r\n dupes.append(item)\r\n if dupes:\r\n raise AssertionError(msg or '%s found multiple times' %seq2str(dupes))", "def isValidTypeForList(self, *args):\n return _libsbml.SBasePlugin_isValidTypeForList(self, *args)", "def check_list_exists(this_list=[]):\n if isinstance(this_list, list) and len(this_list) > 0:\n return True\n else:\n return False", "def _validate_list_type(self, name, obj, *args):\n if obj is None:\n return\n if isinstance(obj, list):\n for i in obj:\n self._validate_type_not_null(name, i, *args)\n else:\n self._validate_type(name, obj, *args)", "def check_object_repeated(lists, obj):\n for any_obj in lists:\n if check_tuples(any_obj['indexes'], obj['indexes']):\n return None\n return obj", "def test_fromlist(self):\n\n self.assertRaises(TypeError, self.hw, [])", "def test_validation(self):\r\n\r\n with self.assertRaises(ValidationError):\r\n List().validate({'blake':31, 'something_else':'that'})\r\n\r\n with self.assertRaises(ValidationError):\r\n List().validate('stringy')\r\n\r\n with self.assertRaises(ValidationError):\r\n List().validate(1)", "def test_all(self):\n self.assertEqual(type(self.vehicle_list), type([]))\n [self.assertEqual(type(i), BusVehicle) for i in self.vehicle_list]", "def test_validation(self):\n\n with self.assertRaises(ValidationError):\n List().validate({'blake':31, 'something_else':'that'})\n\n with self.assertRaises(ValidationError):\n List().validate('stringy')\n\n with self.assertRaises(ValidationError):\n List().validate(1)", "def test_method_list_all(self):\n\n locations_list = Location.list()\n\n # returned object should be a list\n self.assertIsInstance(locations_list, list)\n\n # make sure items returned are not duplicated. \n location_set = set(locations_list)\n self.assertEqual(len(locations_list), len(location_set))\n \n # ensure the types of the returned items are all 'Location'\n types = [type(location) for location in locations_list]\n self.assertEqual(len(set(types)), 1)\n self.assertEqual(types[0], Location)", "def list_check(*args, func=None):\n func = func or inspect.stack()[2][3]\n for var in args:\n if not isinstance(var, (list, collections.UserList, collections.abc.MutableSequence)):\n name = type(var).__name__\n raise ListError(\n 'Function {} expected list, {} got instead.'.format(func, name))", "def exists_one_of(self, *args):\n\n if len(args) % 2 != 0:\n raise RuntimeError('Number of args passed to exists_one_of() must be an even number')\n\n # will be overwritten later if they passed in a value for timeout\n timeout = self.default_implicit_wait\n\n # turn list ['a', 'b', 'c', 'd']\n # into dict {'a':'b', 'c':'d'}\n search_list = []\n while args:\n if args[0] in ['class_name', 'id', 'xpath']:\n d = {args[0]: args[1]}\n search_list.append(d)\n elif args[0] == 'timeout':\n timeout = args[1]\n args = args[2:]\n\n start_time = time()\n\n while True:\n # this inner for loop will ensure that we search for all elements at least once.\n for i in range(len(search_list)):\n new_args = {'timeout': 0}\n new_args.update(search_list[i]) # 'timeout'=0 we want exists to return immediately\n\n elem = self.exists(**new_args)\n if elem:\n return elem\n\n if time() - start_time > timeout:\n return False", "def needs_unique_instance(type_):\n return type_ in unique_instance_types", "def isList(memoryManager, paramsList):\n if isEmptyList(paramsList):\n return [1.0]\n A = paramsList[0]\n if validateList(A):\n return [0.0] if len(A) <= 1 else [1.0]\n return [0.0]", "def do_count(self, *args):\n count = 0\n args = [ele for ele in args[0].split(' ')]\n if args[0] == '':\n print(\"** class name missing **\")\n return\n if args[0] not in self.list_classes:\n print(\"** class doesn't exist **\")\n return\n else:\n ''' Get a list of specified instances '''\n for key, obj in storage.all().items():\n key = key.split('.')\n if key[0] == args[0]:\n count += 1\n print(count)" ]

[ "0.82829416", "0.59194654", "0.5835831", "0.5819622", "0.57178164", "0.57031244", "0.5564605", "0.55354965", "0.54351664", "0.5432013", "0.5417413", "0.53615993", "0.5354359", "0.5329314", "0.532291", "0.5317593", "0.52947307", "0.52838063", "0.5276541", "0.5276059", "0.5272538", "0.5266099", "0.5261197", "0.5259522", "0.5249302", "0.52342916", "0.5231293", "0.5227248", "0.5216667", "0.5212623" ]

[ "def test_xml_files_with_missing_info():\n\n # Test when k is missing from constant type reaction\n with pytest.raises(ValueError):\n xml_filename = \"tests/test_xml_files/k_const.xml\"\n parser = XMLParser(xml_filename)\n\n # Test when A is missing from Arrhenius type reaction\n with pytest.raises(ValueError):\n xml_filename = \"tests/test_xml_files/A_arr.xml\"\n parser = XMLParser(xml_filename)\n\n # Test when E is missing from Arrhenius type reaction\n with pytest.raises(ValueError):\n xml_filename = \"tests/test_xml_files/E_arr.xml\"\n parser = XMLParser(xml_filename)\n\n # Test when A is missing from modified Arrhenius type reaction\n with pytest.raises(ValueError):\n xml_filename = \"tests/test_xml_files/A_mod_arr.xml\"\n parser = XMLParser(xml_filename)\n\n # Test when b is missing from modified Arrhenius type reaction\n with pytest.raises(ValueError):\n xml_filename = \"tests/test_xml_files/b_mod_arr.xml\"\n parser = XMLParser(xml_filename)\n\n # Test when E is missing from modified Arrhenius type reaction\n with pytest.raises(ValueError):\n xml_filename = \"tests/test_xml_files/E_mod_arr.xml\"\n parser = XMLParser(xml_filename)", "def test_unhandled_xml_components():\n\n # Test when type of reaction is unhandled\n xml_filename = \"tests/test_xml_files/unhandled_rxn.xml\"\n with pytest.raises(NotImplementedError):\n parser = XMLParser(xml_filename)\n\n # Test when reaction rate coefficient is unhandled\n xml_filename = \"tests/test_xml_files/unhandled_k.xml\"\n with pytest.raises(NotImplementedError):\n parser = XMLParser(xml_filename)\n\n # Test when units are undhandled\n with pytest.raises(NotImplementedError):\n xml_filename = \"tests/test_xml_files/madeup_units_4_A_arr.xml\"\n parser = XMLParser(xml_filename, convert_to_SI_units=True)\n\n with pytest.raises(NotImplementedError):\n xml_filename = \"tests/test_xml_files/madeup_units_4_A_mod_arr.xml\"\n parser = XMLParser(xml_filename, convert_to_SI_units=True)\n\n with pytest.raises(NotImplementedError):\n xml_filename = \"tests/test_xml_files/madeup_units_4_E_arr.xml\"\n parser = XMLParser(xml_filename, convert_to_SI_units=True)\n\n with pytest.raises(NotImplementedError):\n xml_filename = \"tests/test_xml_files/madeup_units_4_E_mod_arr.xml\"\n parser = XMLParser(xml_filename, convert_to_SI_units=True)", "def test_invalid_xml(self):\r\n with self.assertRaises(Exception):\r\n self.build_problem(type=\"invalidtextgroup\")", "def test_script_rejects_bad_xml(self):\n maker = Compilers(test_utils.MockMachines(\"mymachine\", \"SomeOS\"), version=2.0)\n with self.assertRaises(ParseError):\n test_utils.get_macros(maker, \"This is not valid XML.\", \"Makefile\")", "def test_negative_file_and_xml(self):\n xml_object = ET.parse(self.xmlfile)\n with self.assertRaises((IOError, OSError)):\n glymur.jp2box.XMLBox(filename=self.xmlfile, xml=xml_object)", "def test_bad_data(self):\n\n file_path = os.path.join(RESOURCE_PATH, SAMPLE_DATA[0] + '.yml')\n with open(file_path, 'rU') as stream_handle:\n\n with self.assertRaises(SampleException):\n parser = CamdsHtmlParser(stream_handle, self.exception_callback)\n\n parser.get_records(1)", "def test_does_validate_valid_xml_file(self):\n xml_file = join(\n getcwd(), 'testdata', 'newstest2019-defr-src-ts.de.FIXED.xml'\n )\n doc = valitest.ValidatableTestSet(xml_file)\n self.assertEqual(doc.setid, \"newstest2019\")\n self.assertEqual(doc.srclang, \"any\")", "def test_complex_1(self):\n xml_parser = XmlParser()\n xml = load_fixture(\"xml_parser_complex_1.xml\")\n feed = xml_parser.parse(xml)\n self.assertIsNotNone(feed)\n\n assert feed.title == \"Feed Title 1\"\n assert feed.subtitle == \"Feed Subtitle 1\"\n assert feed.description == \"Feed Description 1\"\n assert feed.summary == \"Feed Description 1\"\n assert feed.content == \"Feed Description 1\"\n assert feed.link == \"Feed Link 1\"\n assert feed.published_date == datetime.datetime(\n 2018, 12, 9, 8, 30, tzinfo=datetime.timezone.utc\n )\n assert feed.pub_date == datetime.datetime(\n 2018, 12, 9, 8, 30, tzinfo=datetime.timezone.utc\n )\n assert feed.updated_date == datetime.datetime(\n 2018, 12, 9, 8, 45, tzinfo=datetime.timezone.utc\n )\n assert feed.last_build_date == datetime.datetime(\n 2018, 12, 9, 8, 45, tzinfo=datetime.timezone.utc\n )\n assert feed.copyright == \"Feed Copyright 1\"\n assert feed.rights == \"Feed Copyright 1\"\n assert feed.generator == \"Feed Generator 1\"\n assert feed.language == \"Feed Language 1\"\n assert feed.docs == \"http://docs.url/documentation.html\"\n assert feed.ttl == 42\n assert feed.author == \"Feed Author 1\"\n assert feed.contributor == \"Feed Author 1\"\n assert feed.managing_editor == \"Feed Author 1\"\n assert feed.category == [\"Feed Category 1\"]\n self.assertIsNotNone(feed.image)\n assert feed.image.title == \"Image Title 1\"\n assert feed.image.url == \"http://image.url/image.png\"\n assert feed.image.link == \"http://feed.link/feed.rss\"\n assert feed.image.description == \"Image Description 1\"\n assert feed.image.width == 123\n assert feed.image.height == 234\n assert feed.get_additional_attribute(\"random\") == \"Feed Random 1\"\n assert repr(feed) == \"<Feed(Feed Link 1)>\"\n\n self.assertIsNotNone(feed.entries)\n assert len(feed.entries) == 6\n\n feed_entry = feed.entries[0]\n assert feed_entry.title == \"Title 1\"\n assert feed_entry.description == \"Description 1\"\n assert feed_entry.link == \"Link 1\"\n assert feed_entry.published_date == datetime.datetime(\n 2018, 12, 9, 7, 30, tzinfo=datetime.timezone.utc\n )\n assert feed_entry.updated_date == datetime.datetime(\n 2018, 12, 9, 7, 45, tzinfo=datetime.timezone.utc\n )\n assert feed_entry.guid == \"GUID 1\"\n assert feed_entry.id == \"GUID 1\"\n assert feed_entry.source == \"Source 1\"\n assert feed_entry.category == [\"Category 1\"]\n self.assertIsInstance(feed_entry.geometry, Point)\n assert feed_entry.geometry.latitude == -37.4567\n assert feed_entry.geometry.longitude == 149.3456\n assert feed_entry.get_additional_attribute(\"random\") == \"Random 1\"\n assert repr(feed_entry) == \"<FeedItem(GUID 1)>\"\n\n feed_entry = feed.entries[1]\n assert feed_entry.title == \"Title 2\"\n assert feed_entry.description == \"Description 2\"\n assert feed_entry.link == \"Link 2\"\n assert feed_entry.published_date == datetime.datetime(\n 2018, 12, 9, 7, 35, tzinfo=datetime.timezone.utc\n )\n assert feed_entry.updated_date == datetime.datetime(\n 2018, 12, 9, 7, 50, tzinfo=datetime.timezone.utc\n )\n assert feed_entry.guid == \"GUID 2\"\n assert feed_entry.category == [\"Category 2\"]\n self.assertIsInstance(feed_entry.geometry, Point)\n assert feed_entry.geometry.latitude == -37.5678\n assert feed_entry.geometry.longitude == 149.4567\n\n feed_entry = feed.entries[2]\n assert feed_entry.title == \"Title 3\"\n assert feed_entry.description == \"Description 3\"\n assert feed_entry.published_date == datetime.datetime(\n 2018, 12, 9, 7, 40, tzinfo=datetime.timezone.utc\n )\n assert feed_entry.updated_date == datetime.datetime(\n 2018, 12, 9, 7, 55, tzinfo=datetime.timezone.utc\n )\n assert feed_entry.guid == \"GUID 3\"\n assert feed_entry.category == [\"Category 3A\", \"Category 3B\", \"Category 3C\"]\n self.assertIsInstance(feed_entry.geometry, Point)\n assert feed_entry.geometry.latitude == -37.6789\n assert feed_entry.geometry.longitude == 149.5678\n\n feed_entry = feed.entries[3]\n assert feed_entry.title == \"Title 4\"\n assert feed_entry.description == \"Description 4\"\n assert feed_entry.author == \"Author 4\"\n assert feed_entry.contributor == \"Author 4\"\n assert feed_entry.category == [\"Category 4A\", \"Category 4B\"]\n assert feed_entry.published_date == datetime.datetime(\n 2018,\n 9,\n 30,\n 21,\n 36,\n 48,\n tzinfo=datetime.timezone(datetime.timedelta(hours=10), \"AEST\"),\n )\n self.assertIsInstance(feed_entry.geometry, Point)\n assert feed_entry.geometry.latitude == -37.789\n assert feed_entry.geometry.longitude == 149.6789\n\n feed_entry = feed.entries[4]\n assert feed_entry.title == \"Title 5\"\n assert feed_entry.description == \"Description 5\"\n assert feed_entry.published_date == datetime.datetime(\n 2018,\n 9,\n 20,\n 18,\n 1,\n 55,\n tzinfo=datetime.timezone(datetime.timedelta(hours=2), \"CEST\"),\n )\n self.assertIsInstance(feed_entry.geometry, Polygon)\n assert feed_entry.geometry.centroid.latitude == -30.32\n assert feed_entry.geometry.centroid.longitude == 150.32\n\n feed_entry = feed.entries[5]\n assert feed_entry.title == \"Title 6\"\n assert feed_entry.description == \"Description 6\"\n assert feed_entry.published_date == datetime.datetime(\n 2018,\n 10,\n 7,\n 19,\n 52,\n tzinfo=datetime.timezone(datetime.timedelta(hours=-7), \"PDT\"),\n )\n self.assertIsInstance(feed_entry.geometry, Polygon)\n assert feed_entry.geometry.centroid.latitude == -30.32\n assert feed_entry.geometry.centroid.longitude == 150.32", "def test_valid_xml(self):\r\n self.build_problem()\r\n self.assertTrue(True)", "def test_xml_file(self):\n response = client.result(False, 'xml', 'unittest', file = 'test_file.csv')\n root = ET.fromstring(response)\n first_name = root[0][0][0].text\n self.assertEqual(first_name,'John', 'Should print John')\n nationality = '<nationality>' in response\n self.assertFalse(nationality, 'Nationality should not be present')", "def test_complex_2(self):\n xml_parser = XmlParser()\n xml = load_fixture(\"xml_parser_complex_2.xml\")\n feed = xml_parser.parse(xml)\n self.assertIsNotNone(feed)\n\n assert feed.title == \"Feed Title 1\"\n assert feed.subtitle == \"Feed Subtitle 1\"\n assert feed.ttl == \"INVALID\"\n assert feed.author == \"Author 1\"\n assert feed.last_build_date == datetime.datetime(\n 2018, 12, 9, 9, 0, tzinfo=datetime.timezone.utc\n )\n assert feed.updated_date == datetime.datetime(\n 2018, 12, 9, 9, 0, tzinfo=datetime.timezone.utc\n )\n assert feed.copyright == \"Feed Rights 1\"\n assert feed.rights == \"Feed Rights 1\"\n assert feed.generator == \"Feed Generator 1\"\n self.assertIsNotNone(feed.image)\n assert feed.image.title == \"Image Title 1\"\n assert feed.image.url == \"http://image.url/image.png\"\n assert feed.image.link == \"http://feed.link/feed.rss\"\n self.assertIsNone(feed.image.description)\n self.assertIsNone(feed.image.width)\n self.assertIsNone(feed.image.height)\n self.assertIsNone(feed.docs)\n\n self.assertIsNotNone(feed.entries)\n assert len(feed.entries) == 1\n\n feed_entry = feed.entries[0]\n assert feed_entry.title == \"Title 6\"\n self.assertIsNone(feed_entry.published_date)", "def parse(self):\n\n def parse_testcase(xml_object):\n testcase = xml_object\n\n tc_dict = {\n \"classname\": testcase.attrib.get(\"classname\", \"unknown\"),\n \"file\": testcase.attrib.get(\"file\", \"unknown\"),\n \"line\": int(testcase.attrib.get(\"line\", -1)),\n \"name\": testcase.attrib.get(\"name\", \"unknown\"),\n \"time\": float(testcase.attrib.get(\"time\", -1)),\n }\n\n # The following data is normally a subnode (e.g. skipped/failure).\n # We integrate it right into the testcase for better handling\n if hasattr(testcase, \"skipped\"):\n result = testcase.skipped\n tc_dict[\"result\"] = \"skipped\"\n tc_dict[\"type\"] = result.attrib.get(\"type\", \"unknown\")\n # tc_dict[\"text\"] = re.sub(r\"[\\n\\t]*\", \"\", result.text) # Removes newlines and tabs\n # result.text can be None for pytest xfail test cases\n tc_dict[\"text\"] = result.text or \"\"\n tc_dict[\"message\"] = result.attrib.get(\"message\", \"unknown\")\n elif hasattr(testcase, \"failure\"):\n result = testcase.failure\n tc_dict[\"result\"] = \"failure\"\n tc_dict[\"type\"] = result.attrib.get(\"type\", \"unknown\")\n # tc_dict[\"text\"] = re.sub(r\"[\\n\\t]*\", \"\", result.text) # Removes newlines and tabs\n tc_dict[\"text\"] = result.text\n tc_dict[\"message\"] = \"\"\n else:\n tc_dict[\"result\"] = \"passed\"\n tc_dict[\"type\"] = \"\"\n tc_dict[\"text\"] = \"\"\n tc_dict[\"message\"] = \"\"\n\n if hasattr(testcase, \"system-out\"):\n tc_dict[\"system-out\"] = testcase[\"system-out\"].text\n else:\n tc_dict[\"system-out\"] = \"\"\n\n return tc_dict\n\n def parse_testsuite(xml_object):\n testsuite = xml_object\n\n tests = int(testsuite.attrib.get(\"tests\", -1))\n errors = int(testsuite.attrib.get(\"errors\", -1))\n failures = int(testsuite.attrib.get(\"failures\", -1))\n\n # fmt: off\n skips = int(\n testsuite.attrib.get(\"skips\") or testsuite.attrib.get(\"skip\") or testsuite.attrib.get(\"skipped\") or -1\n )\n # fmt: on\n\n passed = int(tests - sum(x for x in [errors, failures, skips] if x > 0))\n\n ts_dict = {\n \"name\": testsuite.attrib.get(\"name\", \"unknown\"),\n \"tests\": tests,\n \"errors\": errors,\n \"failures\": failures,\n \"skips\": skips,\n \"passed\": passed,\n \"time\": float(testsuite.attrib.get(\"time\", -1)),\n \"testcases\": [],\n \"testsuite_nested\": [],\n }\n\n # add nested testsuite objects to\n if hasattr(testsuite, \"testsuite\"):\n for ts in testsuite.testsuite:\n # dict from inner parse\n inner_testsuite = parse_testsuite(ts)\n ts_dict[\"testsuite_nested\"].append(inner_testsuite)\n\n elif hasattr(testsuite, \"testcase\"):\n for tc in testsuite.testcase:\n new_testcase = parse_testcase(tc)\n ts_dict[\"testcases\"].append(new_testcase)\n\n return ts_dict\n\n # main flow starts here\n\n junit_dict = []\n\n if self.junit_xml_object.tag == \"testsuites\":\n for testsuite_xml_object in self.junit_xml_object.testsuite:\n complete_testsuite = parse_testsuite(testsuite_xml_object)\n junit_dict.append(complete_testsuite)\n else:\n complete_testsuite = parse_testsuite(self.junit_xml_object)\n junit_dict.append(complete_testsuite)\n\n return junit_dict", "def test_xml_dielectrics(xml_parser):\n\n assert xml_parser.get_dielectrics() == None", "def test_parse_source_xml(self):\n\n # Path to the source xml\n file = self.xmlfilepath + os.sep + \"sourcefile.xml\"\n\n # Path to non existent source file\n in_file = self.xmlfilepath + os.sep + \"sourcefile.pwg\"\n\n # Test for correct data\n # NOTE : For this test case to pass the source xml file should be\n # present in the download path\n self.assertEqual(\n parse_source_xml(file),\n (\n \"DLTINS_20210117_01of01.zip\",\n \"http://firds.esma.europa.eu/firds/DLTINS_20210117_01of01.zip\",\n ),\n )\n\n # Test for incorrect data\n self.assertEqual(parse_source_xml(in_file), None)", "def test_extract_instructions(self):\r\n xmltree = etree.fromstring(self.sample_xml)\r\n\r\n expected_xml = u\"<div><p>Video Test Instructions.</p></div>\"\r\n actual_xml = self.mod._extract_instructions(xmltree) # pylint: disable=W0212\r\n self.assertIsNotNone(actual_xml)\r\n self.assertEqual(expected_xml.strip(), actual_xml.strip())\r\n\r\n xmltree = etree.fromstring('<annotatable>foo</annotatable>')\r\n actual = self.mod._extract_instructions(xmltree) # pylint: disable=W0212\r\n self.assertIsNone(actual)", "def test_extract_instructions(self):\r\n xmltree = etree.fromstring(self.sample_xml)\r\n\r\n expected_xml = u\"<div><p>Image Test Instructions.</p></div>\"\r\n actual_xml = self.mod._extract_instructions(xmltree) # pylint: disable=protected-access\r\n self.assertIsNotNone(actual_xml)\r\n self.assertEqual(expected_xml.strip(), actual_xml.strip())\r\n\r\n xmltree = etree.fromstring('<annotatable>foo</annotatable>')\r\n actual = self.mod._extract_instructions(xmltree) # pylint: disable=protected-access\r\n self.assertIsNone(actual)", "def test_InvalidXML(self):\n #1)\n testPassed = 1\n try:\n temp = builder.build(\"\")\n testPassed = 0\n except:\n pass\n if testPassed == 0:\n self.fail(\"Could build Machine Settings from the empty string.\")\n try:\n temp = builder.build(\"<xml></xml>\")\n testPassed = 0\n except:\n pass\n if (testPassed == 0):\n self.fail(\"Could build Machine Settings from empty xml.\")\n try:\n temp = builder.build(\"!@#$%^&*()_+\")\n testPassed = 0\n except:\n pass\n if (testPassed == 0):\n self.fail(\"Could build Machine Settings from completely invalid string.\")\n try:\n temp = builder.build(\"123467\")\n testPassed = 0\n except:\n pass\n if testPassed == 0:\n self.fail(\"Could build Machine Settings from \\\"123467\\\".\")\n #2)\n try:\n temp = builder.build('<?xml version=\"1.0\" ?><machinesettings><othervars>\\\n<timecommand>time -p</timecommand></othervars><casdictionary></casdictionary></machinesettings>')\n testPassed = 0\n except:\n pass\n if (testPassed == 0):\n self.fail(\"Could build Machine Settings from string without computer algebra systems.\")", "def test_receiveBadXML(self):\n streamError = []\n streamEnd = []\n\n def streamErrorEvent(reason):\n streamError.append(reason)\n\n def streamEndEvent(_):\n streamEnd.append(None)\n\n self.xmlstream.addObserver(xmlstream.STREAM_ERROR_EVENT, streamErrorEvent)\n self.xmlstream.addObserver(xmlstream.STREAM_END_EVENT, streamEndEvent)\n self.xmlstream.connectionMade()\n\n self.xmlstream.dataReceived(\"<root>\")\n self.assertEqual(0, len(streamError))\n self.assertEqual(0, len(streamEnd))\n\n self.xmlstream.dataReceived(\"<child><unclosed></child>\")\n self.assertEqual(1, len(streamError))\n self.assertTrue(streamError[0].check(domish.ParserError))\n self.assertEqual(1, len(streamEnd))", "def parse_xml(filename):\n \n handler = TestFileHandler()\n handler.file = filename\n \n parser = sax.make_parser()\n parser.setContentHandler(handler)\n \n with open(filename) as file:\n parser.parse(file)\n \n return handler.tests", "def test_recover_from_bad_xml(self):\n with warnings.catch_warnings():\n warnings.simplefilter('ignore')\n jp2 = Jp2k(self._bad_xml_file)\n\n self.assertEqual(jp2.box[3].box_id, 'xml ')\n self.assertEqual(jp2.box[3].offset, 77)\n self.assertEqual(jp2.box[3].length, 64)\n self.assertEqual(ET.tostring(jp2.box[3].xml.getroot()),\n b'<test>this is a test</test>')", "def test_extract_instructions(self):\r\n xmltree = etree.fromstring(self.sample_xml)\r\n\r\n expected_xml = u\"<div><p>Test Instructions.</p></div>\"\r\n actual_xml = self.mod._extract_instructions(xmltree) # pylint: disable=W0212\r\n self.assertIsNotNone(actual_xml)\r\n self.assertEqual(expected_xml.strip(), actual_xml.strip())\r\n\r\n xmltree = etree.fromstring('<annotatable>foo</annotatable>')\r\n actual = self.mod._extract_instructions(xmltree) # pylint: disable=W0212\r\n self.assertIsNone(actual)", "def test_simple_3(self):\n xml_parser = XmlParser()\n xml = load_fixture(\"xml_parser_simple_3.xml\")\n feed = xml_parser.parse(xml)\n self.assertIsNone(feed)", "def recipe12_8():\n from xml.parsers.xmlproc import utils, xmlval, xmldtd\n def validate_xml_file(xml_filename, app=None, dtd_filename=None):\n # build validating parser object with appropriate error handler\n parser=xmlval.Validator()\n parser.set_error_handler(utils.ErrorPrinter(parser))\n if dtd_filename is None:\n # DTD fiel specified, laod and set it as the DTD to use\n dtd=xmldtd.load_dtd(dtd_filename)\n parser.val.dtd = parser.dtd = parser.ent = dtd\n if app is not None:\n # Application processing requested, set application object\n parser.set_application(app)\n # everything being set correctly, finally perform the parsing\n parser.parse_resource(xml_filename) \n # if XML data is in a string s, use instead\n # parser.feed(s)\n # parser.close(s)", "def test_failures(self):\n reader = TextReader('jacksheet', subject='R1XXX', localization=0)\n with pytest.raises(FileNotFoundError):\n reader.load()", "def test_simple_2(self):\n xml_parser = XmlParser()\n xml = load_fixture(\"xml_parser_simple_2.xml\")\n feed = xml_parser.parse(xml)\n self.assertIsNotNone(feed)\n self.assertIsNotNone(feed.entries)\n assert len(feed.entries) == 1", "def test_invalid_component_values():\n\n # Test Arrhenius-type reaction when nonsensical R value (e.g. string)\n xml_filename = \"tests/test_xml_files/unit_conversion_fail_arr_invalidR.xml\"\n with pytest.raises(ValueError):\n parser = XMLParser(xml_filename, convert_to_SI_units=False)\n\n # Test Arrhenius-type reaction when nonsensical A value (e.g. string)\n xml_filename = \"tests/test_xml_files/unit_conversion_fail_arr_A.xml\"\n with pytest.raises(ValueError):\n parser = XMLParser(xml_filename, convert_to_SI_units=True)\n\n # Test Arrhenius-type reaction when nonsensical E value (e.g. string)\n xml_filename = \"tests/test_xml_files/unit_conversion_fail_arr_E.xml\"\n with pytest.raises(ValueError):\n parser = XMLParser(xml_filename, convert_to_SI_units=True)\n\n # Test modified Arrhenius-type reaction when nonsensical R value (e.g. string)\n xml_filename = \"tests/test_xml_files/unit_conversion_fail_modarr_invalidR.xml\"\n with pytest.raises(ValueError):\n parser = XMLParser(xml_filename, convert_to_SI_units=False)\n\n # Test modified Arrhenius-type reaction when nonsensical A value (e.g. string)\n xml_filename = \"tests/test_xml_files/unit_conversion_fail_modarr_A.xml\"\n with pytest.raises(ValueError):\n parser = XMLParser(xml_filename, convert_to_SI_units=True)\n\n # Test modified Arrhenius-type reaction when nonsensical b value (e.g. string) \n xml_filename = \"tests/test_xml_files/unit_conversion_fail_modarr_b.xml\"\n with pytest.raises(ValueError):\n parser = XMLParser(xml_filename, convert_to_SI_units=True)\n\n # Test modified Arrhenius-type reaction when nonsensical E value (e.g. string)\n xml_filename = \"tests/test_xml_files/unit_conversion_fail_modarr_E.xml\"\n with pytest.raises(ValueError):\n parser = XMLParser(xml_filename, convert_to_SI_units=True)", "def test_none(self):\n\n feed = parseFeed()\n issues = []\n for item in feed.getElementsByTagName(\"entry\"):\n for description in item.getElementsByTagName(\"title\"):\n issues.append(description.firstChild.wholeText)\n self.assertEqual([], issues)", "def test_validate_invalid(self):\r\n self.assertEqual(get_tree_and_validate(self.invalid_xml, open(self.SCHEMA, 'r').read()), 0)", "def test_XMLParser_file_not_found():\n with pytest.raises(OSError):\n parser = XMLParser(\"no_such_file\")", "def test_incomplete_xml(self):\n self.__opener.contents = '<Report></Report>>'\n self.assertEqual(-1, self.__uft.failed_tests('url'))" ]

[ "0.65230197", "0.632303", "0.59146357", "0.5833376", "0.5792351", "0.5747134", "0.5722811", "0.5718106", "0.571344", "0.57032037", "0.56968766", "0.5693936", "0.56484044", "0.56384706", "0.563128", "0.5619023", "0.5594202", "0.55784297", "0.55595875", "0.5551427", "0.5536601", "0.55221903", "0.5518082", "0.54944736", "0.5493959", "0.5489738", "0.5465611", "0.5433003", "0.54300797", "0.5408021" ]

[ "def cell(x, y):\n try:\n if cells[y][x]['filled'] == 1:\n return # this has already been processed\n except IndexError:\n return\n cells[y][x]['filled'] = 1 # this cell is now filled\n\n nn = []\n for nx, ny in neighbours(x, y):\n try:\n if cells[ny][nx]['filled']:\n nn.append(cells[ny][nx])\n except IndexError:\n continue\n \n c = 0 # colour weighting\n \n #------ Flippedness\n flipped = sum([i['inverted'] for i in nn if i['inverted']])\n cells[y][x]['inverted'] = (randint(0, 3) + flipped) % 4\n \n #------- Colour calculation\n avg_colour = sum([i['colour'][0] for i in nn]) / len(nn)\n avg_sat = sum([i['colour'][1] for i in nn]) / len(nn)\n avg_bri = sum([i['colour'][2] for i in nn]) / len(nn)\n \n # small chance of going totally random otherwise small variation from neighbours\n if random(100) > 90:\n h = randint(0, 100)\n s = randint(0, 100)\n b = randint(0, 100)\n else:\n h = (avg_colour + randint(-15, 15)) % 100\n s = (avg_sat + randint(-15, 15)) % 100\n b = (avg_bri + randint(-15, 15)) % 100\n cells[y][x]['colour'] = (h, s, b)\n \n #------- Alpha calculation\n d = sqrt((x*cell_size - rx)**2 + (y*cell_size - ry)**2) # distance from epicenter\n mx = sqrt((w-rx*cell_size)**2 + (h-ry*cell_size)**2)\n a = d/sqrt(w**2+h**2)*255\n cells[y][x]['alpha'] = a\n \n for cx,cy in neighbours(x, y):\n cell(cx, cy)", "def zoning_example(data):\n\n # account all outer walls not adjacent to the ambient to the entity\n # \"inner wall\"\n # !right now the wall construction of the added wall is not respected,\n # the same wall construction as regular\n # inner wall is set\n for index, line in data.iterrows():\n if not pd.isna(line[\"WallAdjacentTo\"]):\n data.at[index, \"InnerWallArea[m²]\"] = (\n data.at[index, \"OuterWallArea[m²]\"]\n + data.at[index, \"WindowArea[m²]\"]\n + data.at[index, \"InnerWallArea[m²]\"]\n )\n data.at[index, \"WindowOrientation[°]\"] = np.NaN\n data.at[index, \"WindowArea[m²]\"] = np.NaN\n data.at[index, \"WindowConstruction\"] = np.NaN\n data.at[index, \"OuterWallOrientation[°]\"] = np.NaN\n data.at[index, \"OuterWallArea[m²]\"] = np.NaN\n data.at[index, \"OuterWallConstruction\"] = np.NaN\n\n # make all rooms that belong to a certain room have the same room identifier\n _list = []\n for index, line in data.iterrows():\n if pd.isna(line[\"BelongsToIdentifier\"]):\n _list.append(line[\"RoomIdentifier\"])\n else:\n _list.append(line[\"BelongsToIdentifier\"])\n data[\"RoomCluster\"] = _list\n\n # check for lines in which the net area is zero, marking an second wall\n # or window\n # element for the respective room, and in which there is still stated a\n # UsageType which is wrong\n # and should be changed in the file\n for i, row in data.iterrows():\n if row[\"NetArea[m²]\"] == 0 and not pd.isna(row[\"UsageType\"]):\n warnings.warn(\n \"In line %s the net area is zero, marking an second wall or \"\n \"window element for the respective room, \"\n \"and in which there is still stated a UsageType which is \"\n \"wrong and should be changed in the file\" % i\n )\n\n # make all rooms of the cluster having the usage type of the main usage type\n _groups = data.groupby([\"RoomCluster\"])\n for index, cluster in _groups:\n count = 0\n for line in cluster.iterrows():\n if pd.isna(line[1][\"BelongsToIdentifier\"]) and not pd.isna(\n line[1][\"UsageType\"]\n ):\n main_usage = line[1][\"UsageType\"]\n for i, row in data.iterrows():\n if row[\"RoomCluster\"] == line[1][\"RoomCluster\"]:\n data.at[i, \"RoomClusterUsage\"] = main_usage\n count += 1\n if count != 1:\n warnings.warn(\n \"This cluster has more than one main usage type or none, \"\n \"check your excel file for mistakes! \\n\"\n \"Common mistakes: \\n\"\n \"-NetArea of a wall is not equal to 0 \\n\"\n \"-UsageType of a wall is not empty \\n\"\n \"Explanation: Rooms may have outer walls/windows on different orientations.\\n\"\n \"Every row with an empty slot in the column UsageType, \"\n \"marks another direction of an outer wall and/or\"\n \"window entity of the same room.\\n\"\n \"The connection of the same room is realised by an \"\n \"RoomIdentifier equal to the respective \"\n \"BelongsToIdentifier. \\n Cluster = %s\" % cluster\n )\n\n # name usage types after usage types available in the json\n usage_to_json_usage = {\n \"IsolationRoom\": \"Bed room\",\n \"PatientRoom\": \"Bed room\",\n \"Aisle\": \"Corridors in the general care area\",\n \"Technical room\": \"Stock, technical equipment, archives\",\n \"Washing\": \"WC and sanitary rooms in non-residential buildings\",\n \"Stairway\": \"Corridors in the general care area\",\n \"WC\": \"WC and sanitary rooms in non-residential buildings\",\n \"Storage\": \"Stock, technical equipment, archives\",\n \"Lounge\": \"Meeting, Conference, seminar\",\n \"Office\": \"Meeting, Conference, seminar\",\n \"Treatment room\": \"Examination- or treatment room\",\n \"StorageChemical\": \"Stock, technical equipment, archives\",\n \"EquipmentServiceAndRinse\": \"WC and sanitary rooms in non-residential buildings\",\n }\n\n # rename all zone names from the excel to the according zone name which\n # is in the UseConditions.json files\n usages = get_list_of_present_entries(data[\"RoomClusterUsage\"])\n for usage in usages:\n data[\"RoomClusterUsage\"] = np.where(\n data[\"RoomClusterUsage\"] == usage,\n usage_to_json_usage[usage],\n data[\"RoomClusterUsage\"],\n )\n\n # name the column where the zones are defined \"Zone\"\n data[\"Zone\"] = data[\"RoomClusterUsage\"]\n\n return data", "def generate_space_cells(cell_number, min_cell_distance=1.0, \n x_range=None, y_range=None, z_range=None,\n space_x_prob_distribution=[1.],\n x_hist=1000000\n ):\n space_ranges = [x_range,y_range,z_range]\n \n # check that the given number of cells fits within the span range\n assert check_cells_fit(cell_number, min_cell_distance, space_ranges)\n del space_ranges\n \n # create initial storage arrays \n coords_array = np.zeros([cell_number, 3])\n \n # works only for x and y axis now; for circular cells\n radius=min_cell_distance*0.5 \n x1_raw = generate_possible_coords(radius,x_range,min_cell_distance)\n x2_raw = generate_possible_coords(min_cell_distance,x_range,min_cell_distance)\n y_space_cell = min_cell_distance/2.*np.sqrt(3.) # from pitagoras\n y_raw=generate_possible_coords(radius,y_range,y_space_cell)\n z_raw = generate_possible_coords(radius,z_range,min_cell_distance)\n \n x1 = True\n all_coords = []\n for next_depth in z_raw:\n if x1 == True:\n x1= False\n else:\n x1 = True\n for next_raw in range(len(y_raw)):\n if x1 == True:\n x1 = False\n for next_coord in range(len(x1_raw)):\n all_coords.append([x1_raw[next_coord],y_raw[next_raw],next_depth])\n else:\n for next_coord in range(len(x2_raw)):\n all_coords.append([x2_raw[next_coord],y_raw[next_raw],next_depth])\n x1 = True\n \n # randomly choose the cell coords number which are needed\n from random import choice\n cumsum_layer_syn_prob = np.cumsum(space_x_prob_distribution)\n # normalize\n cumsum_layer_syn_prob = cumsum_layer_syn_prob/np.max(cumsum_layer_syn_prob) # this line was added, might need to be tested for inh neurons\n\n all_x_layers = np.arange(x_range[0], x_range[1]+x_hist, x_hist)-(0.5*x_hist)\n # first and last 'layer' will have half-width\n all_x_layers[0] = x_range[0]\n all_x_layers[-1] = x_range[1]\n assert len(space_x_prob_distribution) == len(all_x_layers)-1, 'there are '+ str(len(space_x_prob_distribution)) + ' values for probability within x-space, allowed: ' +str(len(all_x_layers)-1)\n for next_cell in range(cell_number):\n all_coords_in_arr = np.array(all_coords)\n\n # choose how far in x-range\n x = np.random.rand()\n layer_idx = np.searchsorted(cumsum_layer_syn_prob, x)\n layer_idx = np.where(cumsum_layer_syn_prob == cumsum_layer_syn_prob[layer_idx])[0][0]\n\n '''\n # choose which # here it was always symmetric, let's now change it so the distribution may not be symmetric\n possible = np.where((all_coords_in_arr[:,0] > (x_hist*layer_idx)) & (all_coords_in_arr[:,0] < x_hist*(layer_idx+1)))[0]\n possible_negative = np.where((all_coords_in_arr[:,0] < (-1*x_hist*layer_idx)) & (all_coords_in_arr[:,0] > x_hist*(-1)*(layer_idx+1)))[0]\n\n possible_all = np.hstack([possible_negative, possible])\n\n next_choice = choice(possible_all) # possibly there is not enough space for the parameters given to fit all the cells\n '''\n\n possible = np.where((all_coords_in_arr[:,0] > all_x_layers[layer_idx]) & (all_coords_in_arr[:,0] < all_x_layers[layer_idx+1]))[0]\n next_choice = choice(possible)\n\n #possible = np.setdiff1d(possible, np.array(next_choice))\n #possible.delete(next_choice)\n\n coords_array[next_cell] = all_coords[next_choice]\n all_coords.pop(next_choice)\n\n return coords_array", "def main_loop(self):\n for iteration in xrange(1, self.num_iterations + 1):\n print \"At iteration %d\" % iteration\n self.it_num = iteration\n \n ### Select cells randomly without replacement\n x, y = np.meshgrid(np.arange(self.x_len), np.arange(self.y_len))\n \n x = x.flat\n y = y.flat\n \n shuffled_indices = np.random.permutation(np.arange(self.x_len * self.y_len))\n \n for index in shuffled_indices:\n # Get the current y and x indices\n cur_y, cur_x = y[index], x[index]\n \n \n if self.altered == False:\n # Use the standard version\n if self.grid[cur_y, cur_x] == 0:\n # If there's no slab there then we can't erode it!\n continue\n else:\n # Use the altered version of checking if we can erde\n if self.grid[cur_y, cur_x] == self.depth[cur_y, cur_x]:\n # We can't erode it, so continue\n continue\n \n # Check to see if the cell is in shadow.\n if self.cell_in_shadow(cur_y, cur_x):\n # If it's in shadow then we can't erode it, so go to the next random cell \n continue\n \n if True:\n # Move a slab\n self.grid[cur_y, cur_x] -= 1\n \n orig_y, orig_x = cur_y, cur_x\n \n # Loop forever - until we break out of it\n while True:\n new_y, new_x = cur_y, self.add_x(cur_x, self.jump_length)\n \n if self.grid[new_y, new_x] == 0:\n prob = self.pd_ns\n else:\n prob = self.pd_s\n \n if np.random.random_sample() <= prob:\n # Drop cell\n break\n else:\n cur_y, cur_x = new_y, new_x\n \n #print \"Dropping on cell\"\n #print new_y, new_x\n # Drop the slab on the cell we've got to\n self.grid[new_y, new_x] += 1\n \n self.do_repose(orig_y, orig_x)\n \n self.do_repose(new_y, new_x)\n \n self.write_file()", "def cell_create(game_set, screen, covids, cells):\n cell_create_flag = True\n cell = Cell(game_set, screen)\n for old_cell in cells.sprites():\n if old_cell.rect.y < game_set.cell_number_adjust:\n cell_create_flag = False\n break\n if (not pygame.sprite.spritecollide(cell, cells, 0) and\n not pygame.sprite.spritecollide(cell, covids, 0) and\n cell_create_flag):\n cells.add(cell)", "def cell_merge(wsh, pred):\n wshshape=wsh.shape\n \n # masks for the original cells\n objs = np.zeros((wsh.max()+1,wshshape[0],wshshape[1]), dtype=bool)\t\n \n # masks for dilated cells\n dil_objs = np.zeros((wsh.max()+1,wshshape[0],wshshape[1]), dtype=bool)\n \n # bounding box coordinates\t\n obj_coords = np.zeros((wsh.max()+1,4))\n \n # cleaned watershed, output of function\t\n wshclean = np.zeros((wshshape[0],wshshape[1]))\n \n # kernel to dilate objects\n kernel = np.ones((3,3), dtype=bool)\t\n \n for obj1 in range(wsh.max()):\n # create masks and dilated masks for obj\n objs[obj1,:,:] = wsh==(obj1+1)\t\n dil_objs[obj1,:,:] = dilation(objs[obj1,:,:], kernel)\t\n \n # bounding box\n obj_coords[obj1,:] = get_bounding_box(dil_objs[obj1,:,:])\n \n objcounter = 0\t# counter for new watershed objects\n \n for obj1 in range(wsh.max()):\t\n dil1 = dil_objs[obj1,:,:]\n\n # check if mask has been deleted\n if np.sum(dil1) == 0:\n continue\n \n objcounter = objcounter + 1\n orig1 = objs[obj1,:,:]\n\n for obj2 in range(obj1+1,wsh.max()):\n dil2 = dil_objs[obj2,:,:]\n \n # only check border if bounding box overlaps, and second mask \n # is not yet deleted\n if (do_box_overlap(obj_coords[obj1,:], obj_coords[obj2,:])\n and np.sum(dil2) > 0):\n \n border = dil1 * dil2\t\n border_pred = pred[border]\n \n # Border is too small to be considered\n if len(border_pred) < 32:\n continue\n \n # Sum of top 25% of predicted border values\n q75 = np.quantile(border_pred, .75)\n top_border_pred = border_pred[border_pred >= q75]\n top_border_height = top_border_pred.sum()\n top_border_area = len(top_border_pred)\n \n # merge cells\n if top_border_height / top_border_area > .99:\n orig1 = np.logical_or(orig1, objs[obj2,:,:])\n dil_objs[obj1,:,:] = np.logical_or(dil1, dil2)\n dil_objs[obj2,:,:] = np.zeros((wshshape[0], wshshape[1]))\n obj_coords[obj1,:] = get_bounding_box(dil_objs[obj1,:,:])\n \n wshclean = wshclean + orig1*objcounter\n \n return wshclean", "def generate_grains(self, cells):\n\t\tfor cell_num in range(cells):\n\t\t\trandom_row = random.randrange(0,self.space.shape[0],1)\n\t\t\tsample_cell = np.random.choice(self.space[random_row],1)\n\t\t\tsample_cell = sample_cell[0]\n\t\t\twhile sample_cell.state != 0:\n\t\t\t\trandom_row = random.randrange(0,self.space.shape[0],1)\n\t\t\t\tsample_cell = np.random.choice(self.space[random_row],1)\n\t\t\t\tsample_cell = sample_cell[0]\n\t\t\tsample_cell.change_state(self.init_time ,cell_num)", "def set_cell_to_hole(self):\n self.tick = \"H\"\n self.is_hole = True\n self.is_active = False", "def island_procreate(self):\n for y in self.island_map:\n for cell in y:\n cell.procreate()", "def update_shadow(self, board):\n # where this piece will land\n shadow = copy.deepcopy(board.falling_shape)\n if shadow:\n while not board.shape_cannot_be_placed(shadow):\n shadow.lower_shape_by_one_row()\n shadow.raise_shape_by_one_row()\n for block in shadow.blocks:\n self.stdscr.addstr(\n block.row_position+BORDER_WIDTH,\n BLOCK_WIDTH*block.column_position+BORDER_WIDTH,\n ' '*BLOCK_WIDTH,\n curses.color_pair(8))", "def create_periodic_cell_face_map():\n for f0, f1 in periodic_face_map.iteritems():\n # f0, f1 = periodic face0 - face1\n face0 = face_list[f0 - 1]\n face1 = face_list[f1 - 1] # shadow\n nd, nds, cells, bc_type, zone_id = [0,]*2, [0,]*2, [0,]*2, [0,]*2, [0,]*2\n for i, ff in enumerate([face0, face1]):\n nd[i], nds[i], cells[i], bc_type[i], zone_id[i] = ff\n \n cell_face_pair = []\n for i in range(2):\n c = max(cells[i])\n if len(nds[i]) == 2:\n cell_face_pair.append((c, face_map[c][(nds[i][0], nds[i][1])]))\n else:\n cell_face_pair.append((c, face_map[c][eval('f'+str(i))]))\n \n periodic_cell_face_map[cell_face_pair[0]] = cell_face_pair[1]\n periodic_cell_face_map[cell_face_pair[1]] = cell_face_pair[0]", "def build_grains(self):\n\t\ttime = datetime.datetime.now()\n\t\tif self.probability == 0:\n\t\t\tfor cell in self.space.flat:\n\t\t\t\tif cell.state != 0 :\n\t\t\t\t\tcontinue\n\t\t\t\telif self.check_empty_neighbours(cell):\n\t\t\t\t\tcontinue\n\t\t\t\telse:\t\n\t\t\t\t\tneighbours = self.get_neighbours(cell)\n\t\t\t\t\tgrains = [0 for i in range(self.grains)]\n\t\t\t\t\tfor i in range(1,self.grains+1):\n\t\t\t\t\t\tfor neighbour in neighbours:\n\t\t\t\t\t\t\tif neighbour.state == i and neighbour.timestamp < time:\n\t\t\t\t\t\t\t\tgrains[i] = grains[i] + 1\n\t\t\t\t\tif grains == [0 for i in range(self.grains)]:\n\t\t\t\t\t\tcontinue\n\t\t\t\t\tnew_grain = 0\n\t\t\t\t\tfor i in range(self.grains):\n\t\t\t\t\t\tif grains[i] >= new_grain:\n\t\t\t\t\t\t\tnew_grain = i\n\t\t\t\t\tcell.change_state(time, new_grain)\n\t\t\t\t\tself.empty_cells = self.empty_cells - 1\n\t\telse:\n\t\t\tfor cell in self.space.flat:\n\t\t\t\tif cell.state != 0 :\n\t\t\t\t\tcontinue\n\t\t\t\telif self.check_empty_neighbours(cell):\n\t\t\t\t\tcontinue\n\t\t\t\telse:\n\t\t\t\t\tneighbours = self.get_neighbours(cell)\n\t\t\t\t\tif self.decide_changing(cell,neighbours,5, time):\n\t\t\t\t\t\tneighbours = self.get_nearest_neighbours(cell)\n\t\t\t\t\t\tif self.decide_changing(cell,neighbours,3, time):\n\t\t\t\t\t\t\tneighbours = self.get_further_neighbours(cell)\n\t\t\t\t\t\t\tif self.decide_changing(cell,neighbours,3, time):\n\t\t\t\t\t\t\t\tneighbours = self.get_neighbours(cell)\n\t\t\t\t\t\t\t\tgrains = [0 for i in range(self.grains)]\n\t\t\t\t\t\t\t\tfor i in range(1,self.grains+1):\n\t\t\t\t\t\t\t\t\tfor neighbour in neighbours:\n\t\t\t\t\t\t\t\t\t\tif neighbour.state == i and neighbour.timestamp < time:\n\t\t\t\t\t\t\t\t\t\t\tgrains[i] = grains[i] + 1\n\t\t\t\t\t\t\t\tif grains == [0 for i in range(self.grains)]:\n\t\t\t\t\t\t\t\t\tcontinue\n\t\t\t\t\t\t\t\tnew_grain = 0\n\t\t\t\t\t\t\t\tfor i in range(self.grains):\n\t\t\t\t\t\t\t\t\tif grains[i] >= new_grain:\n\t\t\t\t\t\t\t\t\t\tnew_grain = i\n\t\t\t\t\t\t\t\trandom_number = random.random() * 100\n\t\t\t\t\t\t\t\tif random_number <= self.probability:\n\t\t\t\t\t\t\t\t\tcell.change_state(time, new_grain)\n\t\t\t\t\t\t\t\t\tself.empty_cells = self.empty_cells - 1\n\t\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\t\tcontinue", "def populate_region(mask, layer_params):\n\n from .speedups import (\n NEW_CELL_MASK, CAN_OSCILLATE_MASK, INCLUDE_VIOLATIONS_MASK)\n\n border = ndimage.maximum_filter(mask, size=3, mode='wrap') ^ mask\n interior = ndimage.minimum_filter(mask, size=3, mode='wrap')\n gen_mask = mask * (\n NEW_CELL_MASK |\n CAN_OSCILLATE_MASK |\n INCLUDE_VIOLATIONS_MASK\n ) + border * (\n INCLUDE_VIOLATIONS_MASK\n )\n board = np.zeros(mask.shape, dtype=np.uint16)\n foreground = np.zeros(mask.shape, dtype=bool)\n background = np.zeros(mask.shape, dtype=bool)\n background_color = np.zeros(mask.shape, dtype=bool)\n seeds = None\n max_period = 1\n\n for layer in layer_params:\n if not isinstance(layer, dict):\n raise ValueError(\n \"'layer_params' should be a list of parameter dictionaries.\")\n layer = _fix_random_values(layer)\n old_board = board.copy()\n gen_mask0 = gen_mask.copy()\n interior = ndimage.minimum_filter(\n gen_mask & NEW_CELL_MASK > 0, size=3, mode='wrap')\n color = COLORS.get(layer.get('color'), 0)\n\n fence_frac = layer.get('fences', 0.0)\n if fence_frac > 0:\n fences = build_fence(gen_mask & speedups.NEW_CELL_MASK)\n fences *= coinflip(fence_frac, fences.shape)\n gen_mask &= ~(fences * (NEW_CELL_MASK | CAN_OSCILLATE_MASK))\n board += fences.astype(np.uint16) * CellTypes.wall\n\n spawners = layer.get('spawners', 0)\n if spawners > 0:\n _mask = (gen_mask0 & NEW_CELL_MASK > 0) & interior\n new_cells = _mask & coinflip(spawners, board.shape)\n if not new_cells.any() and _mask.any():\n i, j = np.nonzero(_mask)\n k = get_rng().choice(len(i)) # ensure at least one spawner\n new_cells[i[k], j[k]] = True\n gen_mask[new_cells] ^= NEW_CELL_MASK\n board[new_cells] = CellTypes.spawner + color\n\n tree_lattice = layer.get('tree_lattice')\n # Create a lattice of trees that are spread throughout the region\n # such that every empty cell touches one (and only one) tree\n # (modulo edge effects).\n # Such a lattice tends to make the resulting board very chaotic.\n # Note that this will disrupt any pre-existing patterns.\n if tree_lattice is not None:\n if not isinstance(tree_lattice, dict):\n tree_lattice = {}\n h, w = board.shape\n stagger = tree_lattice.get('stagger', True)\n spacing = float(tree_lattice.get('spacing', 5))\n if not stagger:\n new_cells = _make_lattice(h, w, spacing, spacing, 0)\n elif spacing <= 3:\n new_cells = _make_lattice(h, w, 3, 3, 1)\n elif spacing == 4:\n new_cells = _make_lattice(h, w, 10, 1, 3)\n elif spacing == 5:\n new_cells = _make_lattice(h, w, 13, 1, 5)\n else:\n # The following gets pretty sparse.\n new_cells = _make_lattice(h, w, 6, 3, 3)\n\n new_cells &= gen_mask & NEW_CELL_MASK > 0\n board[new_cells] = CellTypes.tree + color\n\n period = 1\n if 'pattern' in layer:\n pattern_args = layer['pattern'].copy()\n period = pattern_args.get('period', 1)\n if period == 1:\n gen_mask2 = gen_mask & ~CAN_OSCILLATE_MASK\n pattern_args.update(period=max_period, osc_bonus=0)\n elif period == 0:\n gen_mask2 = gen_mask & ~INCLUDE_VIOLATIONS_MASK\n pattern_args.update(period=max_period, osc_bonus=0)\n elif period < max_period:\n raise ValueError(\n \"Periods for sequential layers in a region must be either 0, 1,\"\n \" or at least as large as the largest period in prior layers.\")\n else:\n gen_mask2 = gen_mask\n max_period = period\n\n board = _gen_pattern(board, gen_mask2, seeds, **pattern_args)\n\n # We need to update the mask for subsequent layers so that they\n # do not destroy the pattern in this layer.\n # First get a list of board states throughout the oscillation cycle.\n boards = [board]\n for _ in range(1, max_period):\n boards.append(speedups.advance_board(boards[-1]))\n non_empty = np.array(boards) != 0\n still_cells = non_empty.all(axis=0)\n osc_cells = still_cells ^ non_empty.any(axis=0)\n # Both still life cells and oscillating cells should disallow\n # any later changes. We also want to disallow changes to the cells\n # that are neighboring the oscillating cells, because any changes\n # there would propogate to the oscillating cells at later time\n # steps.\n # Note that it doesn't really matter whether the oscillating mask\n # is set for the currently oscillating cells, because we're not\n # checking for violations in them anyways, and we don't allow any\n # changes that would affect them.\n osc_neighbors = ndimage.maximum_filter(osc_cells, size=3, mode='wrap')\n gen_mask[osc_cells] &= ~(NEW_CELL_MASK | INCLUDE_VIOLATIONS_MASK)\n gen_mask[still_cells | osc_neighbors] &= ~(NEW_CELL_MASK | CAN_OSCILLATE_MASK)\n\n new_mask = board != old_board\n life_mask = ((board & CellTypes.alive) > 0) & new_mask\n board += color * new_mask * life_mask\n # The seeds are starting points for the next layer of patterns.\n # This just makes the patterns more likely to end up close together.\n seeds = ((board & CellTypes.alive) > 0) & mask\n\n new_mask = board != old_board\n\n movable_walls = layer.get('movable_walls', 0)\n if movable_walls > 0:\n new_cells = coinflip(movable_walls, board.shape) * new_mask\n new_cells *= (board & ~CellTypes.rainbow_color) == CellTypes.wall\n board += new_cells * CellTypes.movable\n\n movable_trees = layer.get('movable_trees', 0)\n if movable_trees > 0:\n new_cells = coinflip(movable_trees, board.shape) * new_mask\n new_cells *= (board & ~CellTypes.rainbow_color) == CellTypes.tree\n board += new_cells * CellTypes.movable\n\n hardened_life = layer.get('hardened_life', 0)\n if hardened_life > 0:\n new_cells = coinflip(hardened_life, board.shape) * new_mask\n new_cells *= (board & ~CellTypes.rainbow_color) == CellTypes.life\n board -= new_cells * CellTypes.destructible\n\n buffer_size = layer.get('buffer_zone', 0) * 2 + 1\n life_cells = board & CellTypes.alive > 0\n buf = ndimage.maximum_filter(life_cells, size=buffer_size, mode='wrap')\n gen_mask[buf] &= ~NEW_CELL_MASK\n\n target = layer.get('target', 'board')\n if target == 'board':\n foreground[new_mask] = True\n if period > 0:\n background[new_mask] = True\n elif target == 'goals':\n background[new_mask] = True\n background_color[new_mask] = True\n # Make sure to add walls and such to the foreground\n foreground[new_mask & (board & CellTypes.alive == 0)] = True\n elif target == 'both':\n foreground[new_mask] = True\n if period > 0:\n background[new_mask] = True\n background_color[new_mask] = True\n else:\n raise ValueError(\"Unexpected value for 'target': %s\" % (target,))\n\n fountains = layer.get('fountains', 0)\n if fountains > 0:\n new_cells = coinflip(fountains, board.shape)\n new_cells *= gen_mask & NEW_CELL_MASK > 0\n neighbors = ndimage.maximum_filter(new_cells, size=3, mode='wrap')\n neighbors *= gen_mask & NEW_CELL_MASK > 0\n gen_mask[neighbors] = INCLUDE_VIOLATIONS_MASK\n if buffer_size > 1:\n buf = ndimage.maximum_filter(neighbors, size=buffer_size, mode='wrap')\n gen_mask[buf] &= ~NEW_CELL_MASK\n board[neighbors] = CellTypes.wall + color\n board[new_cells] = CellTypes.fountain + color\n foreground[new_cells] = True\n background[neighbors] = True\n background_color[neighbors] = True\n\n goals = board.copy()\n board *= foreground\n goals *= background\n goals &= ~CellTypes.spawning\n goals &= ~(CellTypes.rainbow_color * ~background_color)\n\n return board, goals", "def makeTheHouse(pos, blockTypeMain= wool, blockTypeSecond= wool,\n mainColor= wMagenta, secondColor= wWhite,\n myDoor= wDoorWood):\n\n ### FRONT (& BACK )###\n for Front in range(0,22,21): #This is the trick for the back copy...\n \n mc.setBlocks(pos.x-4, pos.y,pos.z+6+Front,\n pos.x+7, pos.y+9, pos.z+6+Front, blockTypeMain, mainColor)\n mc.setBlocks(pos.x-3, pos.y+1,pos.z+6+Front,\n pos.x+6, pos.y+8, pos.z+6+Front, blockTypeSecond, secondColor)\n # FRONT - Remove blocks\n # Small trick to remove the 6 empty space by a loop\n #[[x,y],[x,y],[x,y],...]\n for i in [[-1,+1],[5,+1],[+2,0],[-1,+5],[2,+5],[5,+5]]:\n mc.setBlocks(pos.x+i[0], pos.y+i[1],pos.z+6+Front,\n pos.x+i[0]-1, pos.y+i[1]+2, pos.z+6+Front, air)\n #let's put the Glasses (that's almost the same than remove actually...)\n for i in [[-1,+1],[5,+1],[-1,+5],[2,+5],[5,+5]]:\n mc.setBlocks(pos.x+i[0], pos.y+i[1],pos.z+6+Front,\n pos.x+i[0]-1, pos.y+i[1]+2, pos.z+6+Front, wGlass_Pane)\n # The door at Entrance\n mc.setBlock(pos.x+1, pos.y, pos.z+6+Front, myDoor,4)\n mc.setBlock(pos.x+1, pos.y+1, pos.z+6+Front, myDoor,8)\n mc.setBlock(pos.x+2, pos.y, pos.z+6+Front, myDoor,1)\n mc.setBlock(pos.x+2, pos.y+1, pos.z+6+Front, myDoor,8)\n \n # ************\n \n # FRONT - Small top\n mc.setBlocks(pos.x-3, pos.y+10,pos.z+6+Front,\n pos.x+6, pos.y+14, pos.z+6+Front, blockTypeSecond, secondColor)\n mc.setBlocks(pos.x-1, pos.y+10,pos.z+6+Front,\n pos.x+4, pos.y+13, pos.z+6+Front, blockTypeMain, mainColor)\n mc.setBlocks(pos.x, pos.y+10,pos.z+6+Front,\n pos.x+3, pos.y+12, pos.z+6+Front, blockTypeSecond, secondColor)\n # FRONT-Small top Remove Blocks\n mc.setBlocks(pos.x+1, pos.y+11,pos.z+6+Front,\n pos.x+2, pos.y+12, pos.z+6+Front, air)\n # small trick to remove as \"stairs\" - funny ? no ?\n for i in range(0,10,1):\n iy = i\n if i > 5:\n iy=9-i\n #print i, iy\n mc.setBlocks(pos.x-3+i, pos.y+11+iy,pos.z+6+Front,\n pos.x-3+i, pos.y+15, pos.z+6+Front, air)\n # FRONT-Small Top put Glass\n mc.setBlocks(pos.x+1, pos.y+11,pos.z+6+Front,\n pos.x+2, pos.y+12, pos.z+6+Front, wGlass_Pane)\n\n\n # FRONT-Right & Left side \n for i in range(0,19,18):\n #print i\n mc.setBlocks(pos.x-4+i, pos.y,pos.z+7+Front,\n pos.x-11+i, pos.y+8, pos.z+7+Front, blockTypeMain, mainColor)\n mc.setBlocks(pos.x-5+i, pos.y+1,pos.z+7+Front,\n pos.x-10+i, pos.y+7, pos.z+7+Front, blockTypeSecond, secondColor)\n # blocks removal\n mc.setBlocks(pos.x-6+i, pos.y+1,pos.z+7+Front,\n pos.x-9+i, pos.y+7, pos.z+7+Front, wGlass_Pane)\n # the line\n mc.setBlocks(pos.x-5+i, pos.y+4,pos.z+7+Front,\n pos.x-11+i, pos.y+4, pos.z+7+Front, blockTypeMain, mainColor)\n \n #remove 2 extra columns\n mc.setBlocks(pos.x-4, pos.y, pos.z+7,\n pos.x-4, pos.y+8, pos.z+7, air)\n mc.setBlocks(pos.x-4+11, pos.y, pos.z+7,\n pos.x-4+11, pos.y+8, pos.z+7, air)\n\n\n ### MAIN WALLS RIGHT & LEFT SIDE ###\n for wall in range(0,26,25):\n mc.setBlocks(pos.x-11+wall, pos.y, pos.z+8,\n pos.x-11+wall, pos.y+8, pos.z+28, blockTypeMain, mainColor)\n\n mc.setBlocks(pos.x-11+wall, pos.y+1, pos.z+8,\n pos.x-11+wall, pos.y+7, pos.z+27, blockTypeSecond, secondColor)\n\n for i in range(0,15,7):\n mc.setBlocks(pos.x-11+wall, pos.y+1,pos.z+9+i,\n pos.x-11+wall, pos.y+7, pos.z+12+i, wGlass_Pane)\n \n # the 3 lines\n mc.setBlocks(pos.x-11+wall, pos.y, pos.z+14,\n pos.x-11+wall, pos.y+8, pos.z+14, blockTypeMain, mainColor)\n mc.setBlocks(pos.x-11+wall, pos.y, pos.z+21,\n pos.x-11+wall, pos.y+8, pos.z+21, blockTypeMain, mainColor)\n mc.setBlocks(pos.x-11+wall, pos.y+4, pos.z+8,\n pos.x-11+wall, pos.y+4, pos.z+28, blockTypeMain, mainColor)\n\n\n \n\n #same \n #removeBlocks(pos.x-1, pos.y+2, pos.z+6, 2, \n pass", "def Breakwalls(self):\n \n \n if len(self.VisitedCoord)==self.TotalCells: #Base case for the recursive call.\n \n return self.VisitedCoord #When base case is hit, returns the list of all the visited cells. [[x,y],[x,y],[x,y],[x,y]]\n xval=self.CurrentCell[0] #Breaks Current Cell up, xval is the x value \n yval=self.CurrentCell[1] #yval is the y value\n \n \n if (yval+1==self.N+1 or [xval,yval+1] in self.VisitedCoord) and (yval-1==0 or [xval,yval-1] in self.VisitedCoord) \\\n and (xval+1==self.N+1 or [xval+1,yval] in self.VisitedCoord) and (xval-1==0 or [xval-1,yval] in self.VisitedCoord): #If the Cell is surrounded\n #and can't move \n self.CurrentCell=self.track.pop(self.CellStack) #Pop the last coord from the cell stack and make that current cell.\n #print(\"Current: \", self.CurrentCell)\n return self.Breakwalls() #Recursive call to Breakwalls \n \n self.track.push(self.CurrentCell,self.CellStack) #If cell not surrounded push the current cell onto the cellstack and begin looking for a neighbour \n while True: #Remember Cell stack is where you out your foot down.\n Directions=[\"North\",\"South\",\"East\",\"West\"]\n randir=randrange(0,len(Directions))\n dir=Directions[randir] #Choose a random direction \n #print(dir,yval+1,self.CurrentCell,self.VisitedCoord)\n \n if dir== \"North\" and yval+1<self.N+1 and [xval,yval+1] not in self.VisitedCoord: #if direction and not out of bounds. Self.N+ is the border.\n self.North[xval][yval]=self.South[xval][yval+1] = False #if less than that, you are within the border \n yval+=1;break \n elif dir ==\"South\" and yval-1>0 and [xval,yval-1] not in self.VisitedCoord: #in the southern part, 0 is the border.if >0, within actual maze.\n self.South[xval][yval]=self.North[xval][yval-1] = False \n yval-=1;break \n elif dir ==\"East\" and xval+1 <self.N+1 and [xval+1,yval] not in self.VisitedCoord:\n self.East[xval][yval]=self.West[xval+1][yval] = False\n xval+=1;break \n elif dir ==\"West\" and xval-1 > 0 and [xval-1,yval] not in self.VisitedCoord:\n self.West[xval][yval]=self.East[xval-1][yval] =False\n xval-=1;break\n\n #Above chooses a random direction and if condition checks out, breaks the wall by setting it to false and increments/decrements the respective value\n #to reflect N/S/E/W.\n self.CurrentCell=[xval,yval] #xval/yval was incremented so the new value remains, all thats left is to make the current cell that new coord.\n \n self.track.push(self.CurrentCell,self.VisitedCoord) #The new current cell is now pushed onto the visited coordinates stack \n \n return self.Breakwalls() ##Recursive call on the current cell. Everything happens again on that new coordinate. ", "def ignite(cell, neighbours, wind):\n\n cell = int(cell)\n ignition_factor = 0\n if cell in [LAKE, BURNING, BURNT, END_BURN]: return ignition_factor\n neighbours = neighbours.astype(int)\n fully_burning_threshhold = [0.04, 0.01, 0, 0.1, 0, 0, 0.04]\n fully_burning_factor = 20\n start_burning_threshhold = [0.02, 0.005, 0, 0.05, 0, 0, 0.04]\n start_burning_factor = 10\n\n # add to cell ignition factor by multiplying\n # windspeed modifier and the cells burning threshhold\n # if a random number is less than the resulting number add\n # the burning factor multiplied by the wind speed modifier\n\n for index, neighbour in enumerate(neighbours):\n if neighbour == BURNING:\n if fully_burning_threshhold[cell] * wind[index] >= random.uniform(\n 0, 1):\n ignition_factor += int(\n math.floor(wind[index] * fully_burning_factor))\n if neighbour in [START_BURN,END_BURN] and \\\n start_burning_threshhold[cell] * wind[index] >= random.uniform(0,1):\n ignition_factor += int(\n math.floor(wind[index] * start_burning_factor))\n\n # if the cell is has already started to burn then a burning factor is\n # automatically applied\n\n if cell == START_BURN: ignition_factor += start_burning_factor\n return int(ignition_factor)", "def cell_in_shadow(self, y, x):\n orig_x = x\n orig_value = self.grid[y, orig_x]\n \n # Move to the left\n x = self.add_x(orig_x, -1)\n \n max_in_row = self.grid[y].max()\n \n while x != orig_x:\n # Get the height difference that's needed from the shadow map\n height_needed = self.shadow_map[ (orig_x - x) % self.x_len]\n if self.grid[y, x] - orig_value >= height_needed:\n return True\n elif orig_value + height_needed > max_in_row:\n return False\n # Move to the left\n x = self.add_x(x, -1)\n \n return False", "def update_cell_membranes(cells):\r\n membrane_polys = [Polygon(cell['membrane']).buffer(0) for cell in cells]\r\n membrane_bounds = [p.bounds for p in membrane_polys]\r\n\r\n # Get normal vectors for membrane vertices\r\n vert_normals = [geometry.get_vert_normals(\r\n geometry.get_edge_normals(cell['membrane'])) for cell in cells]\r\n\r\n all_membranes = np.concatenate([cell['membrane'] for cell in cells], axis=0)\r\n # [(cell idx, vert idx), ...]\r\n all_membrane_map = np.concatenate([\r\n np.stack([\r\n np.repeat([i], cell['membrane'].shape[0]),\r\n np.arange(cell['membrane'].shape[0],)\r\n ], axis=1)\r\n for i, cell in enumerate(cells)\r\n ], axis=0).astype(np.int32)\r\n\r\n # Find inter-cell membrane vertices that are close enough for adhesion/diffusion\r\n nearby_membranes, nearby_membrane_map = find_nearby_membranes(\r\n all_membranes, all_membrane_map, vert_normals)\r\n\r\n # Change membrane rest length according with the cell volume\r\n membrane_rdists = []\r\n for i, cell in enumerate(cells):\r\n # Get all the pairwise distances between membrane vertices\r\n membrane_dists = scipy.spatial.distance.squareform(\r\n scipy.spatial.distance.pdist(cell['membrane']))\r\n membrane_rdists_i = 1.0 / (membrane_dists + 1e-6)\r\n membrane_rdists_i[np.where(membrane_dists == 0)] = 0\r\n membrane_rdists.append(membrane_rdists_i)\r\n\r\n return membrane_bounds, membrane_polys, vert_normals, \\\r\n all_membranes, all_membrane_map, \\\r\n nearby_membranes, nearby_membrane_map, \\\r\n membrane_rdists", "def create_foothold(self):\n sel = self.selected()\n cell = sel[0]\n if cell.contents == Contents.bomb:\n cell.contents = Contents.empty\n for adj in cell.get_adjacent():\n if adj.contents == Contents.bomb:\n adj.contents = Contents.empty\n self.set_bomb_contacts()", "def constructCell():\n\t\tself.weightGenerate()", "def new_tile(self):\n zero_list = []\n zero_cell = ()\n # self._cells = [[0 for col in range(self._grid_width)] for row in range(self._grid_height)]\n for row in range(self._grid_height):\n for col in range(self._grid_width):\n if self._cells[row][col] == 0:\n zero_cell = (row, col)\n zero_list.append(zero_cell)\n if len(zero_list) > 0:\n chance = random.randrange(0,10)\n cell_idx = random.randrange(len(zero_list))\n if chance == 9:\n self._cells[zero_list[cell_idx][0]][zero_list[cell_idx][1]] = 4\n else:\n self._cells[zero_list[cell_idx][0]][zero_list[cell_idx][1]] = 2\n else:\n print(\"You lost! Better luck next time!\")", "def make_random_tiles(sx=500, sy=500, sz=0, nb=50, noise_sigma=None,\n regular=True, double_pattern_y=False, double_pattern_z=False, \n assym_y=True, assym_z=True, return_image=False):\n \n if sz == 0:\n image = np.zeros((sy, sx))\n # to overcome an issue with odd nb:\n nb = int(np.ceil(nb / 2) * 2)\n \n if regular:\n x = np.linspace(start=0, stop=sx-1, num=nb, dtype=int)\n x = np.hstack((x[::2], x[1::2]))\n if assym_y:\n nb = nb*2\n y = np.linspace(start=0, stop=sy-1, num=nb, dtype=int)\n if double_pattern_y:\n y = np.hstack((y[::2], y[1::2]))\n x_id = np.tile(x, y.size//2)\n y_id = np.repeat(y, x.size//2)\n else:\n x_id = np.random.randint(sx, size=nb)\n y_id = np.random.randint(sy, size=nb)\n \n if noise_sigma is not None:\n x_id = x_id + np.random.normal(loc=0.0, scale=noise_sigma, size=x_id.size)\n x_id[x_id<0] = 0\n x_id[x_id>sx-1] = sx-1\n x_id = np.round(x_id).astype(int)\n y_id = y_id + np.random.normal(loc=0.0, scale=noise_sigma, size=y_id.size)\n y_id[y_id<0] = 0\n y_id[y_id>sy-1] = sy-1\n y_id = np.round(y_id).astype(int)\n \n coords = np.vstack((x_id, y_id)).T\n image[y_id, x_id] = 1\n masks = segmentation.watershed(-image)\n else:\n # make 3D simulation\n image = np.zeros((sz, sy, sx))\n # to overcome an issue with odd nb:\n nb = int(np.ceil(nb / 2) * 2)\n \n if regular:\n x = np.linspace(start=0, stop=sx-1, num=nb, dtype=int)\n x = np.hstack((x[::2], x[1::2]))\n if assym_y:\n nb_y = nb*2\n y = np.linspace(start=0, stop=sy-1, num=nb_y, dtype=int)\n if assym_z:\n nb_z = nb*2\n z = np.linspace(start=0, stop=sz-1, num=nb_z, dtype=int)\n if double_pattern_y:\n y = np.hstack((y[::2], y[1::2]))\n if double_pattern_z:\n z = np.hstack((z[::2], z[1::2]))\n x_id = np.tile(x, y.size//2)\n y_id = np.repeat(y, x.size//2)\n z_id = np.repeat(z, x.size//2)\n else:\n x_id = np.random.randint(sx, size=nb)\n y_id = np.random.randint(sy, size=nb)\n z_id = np.random.randint(sz, size=nb)\n \n if noise_sigma is None:\n print(\"For 3D simulations noise_sigma needs to be > 0\")\n print(\"Setting noise_sigma to 1\")\n noise_sigma = 1\n # x\n x_id = x_id + np.random.normal(loc=0.0, scale=noise_sigma, size=x_id.size)\n x_id[x_id<0] = 0\n x_id[x_id>sx-1] = sx-1\n x_id = np.round(x_id).astype(int)\n # y\n y_id = y_id + np.random.normal(loc=0.0, scale=noise_sigma, size=y_id.size)\n y_id[y_id<0] = 0\n y_id[y_id>sy-1] = sy-1\n y_id = np.round(y_id).astype(int)\n # z\n z_id = z_id + np.random.normal(loc=0.0, scale=noise_sigma, size=z_id.size)\n z_id[z_id<0] = 0\n z_id[z_id>sz-1] = sz-1\n z_id = np.round(z_id).astype(int)\n \n coords = np.vstack((x_id, y_id, z_id)).T\n image[z_id, y_id, x_id] = 1\n masks = segmentation.watershed(-image)\n\n if return_image:\n return coords, masks, image\n else:\n return coords, masks", "def mark_mines(self, cells):\r\n for cell in cells:\r\n row, col = cell\r\n self.mine_field[row][col] = 'x'\r\n self.mines_left -= 1\r\n return", "def generate_nearby_cells(self):\n for y in range(len(self.island_map)):\n for x in range(len(self.island_map[y])):\n list_of_nearby_cells = []\n\n if y != 0:\n self.generate_cell_above(x, y, list_of_nearby_cells)\n\n if x != 0:\n self.generate_cell_left(x, y, list_of_nearby_cells)\n\n if y != len(self.island_map)-1:\n self.generate_cell_below(x, y, list_of_nearby_cells)\n\n if x != len(self.island_map[y])-1:\n self.generate_cell_right(x, y, list_of_nearby_cells)\n\n self.island_map[y][x].nearby_cells = list_of_nearby_cells", "def check_border_cells(self):\n for row, col in self.land_cells:\n if row == 1 or row == self.unique_rows[-1] or col == 1 or col == self.unique_cols[-1]:\n raise ValueError(\"Only water cells may be border cells!\")", "def test_two_cell_repel():\n space = c6.Space()\n c6.Cell(space, [0, 0], 1)\n c6.Cell(space, [0, 1.9], 1)\n for i in range(2):\n space.step()", "def create_cells(self):\n raise NotImplementedError(\n \"create_cells function not reimplemented from base class\")", "def setNeighbors(self):\n for cellIndex in range(len(self.cells)):\n cell = self.cells[cellIndex]\n\n #Checks the 8 cells around the living one. \n for neighborsX in range(cell.x - 1, cell.x + 2):\n for neighborsY in range(cell.y - 1, cell.y + 2):\n\n #If the position is outside the world, loop around.\n neighborsX = neighborsX % self.screen.worldSize\n neighborsY = neighborsY % self.screen.worldSize\n\n #Skipping itself. Becouse we do not want to calculate itself as a neighbor\n if(neighborsX == cell.x and neighborsY == cell.y):\n continue\n else:\n #Checks if a cell exist at neighborsX, neighborsY\n cellToCheck = self.getCellFromPosition(neighborsX, neighborsY)\n if(cellToCheck != False):\n #Add one to the neighbor var if there already exist and cell for the given position.\n cellToCheck.numOfNeighbor += 1\n else:\n #Creates a new cell if it do not exist any.\n newCell = Cell(self.screen, neighborsX, neighborsY, True)\n newCell.numOfNeighbor += 1\n self.cells.append(newCell)", "def cell_edges(self):", "def cell_setup(self):\n p = self.project\n c = p.NewCell(0, area=1000, with_surfacewater=True)\n vgm = cmf.VanGenuchtenMualem()\n vgm.fit_w0()\n for d in self.depth:\n vgm.Ksat = 10 * 2 ** -d\n c.add_layer(d, vgm)\n c.install_connection(cmf.Richards)\n c.install_connection(cmf.GreenAmptInfiltration)\n return CmfConnector(c, 5)" ]

[ "0.62244296", "0.60063124", "0.58079845", "0.58031946", "0.5771031", "0.5768273", "0.57047147", "0.56749296", "0.56458306", "0.5631052", "0.5592751", "0.55902314", "0.55531824", "0.5511874", "0.55042386", "0.55030495", "0.5474308", "0.54628766", "0.5454802", "0.54457825", "0.54068065", "0.5399023", "0.53763616", "0.53671163", "0.5358668", "0.5351684", "0.5348857", "0.5331169", "0.53292423", "0.53220904" ]

[ "def gen_empty_statement(self, statement) -> None:\n pass", "def build_statement(\n user: AbstractUser,\n verb: Verb,\n obj: Activity,\n context: Context,\n statement_id: Optional[uuid.UUID] = None,\n) -> Optional[Statement]:\n timestamp = timezone.now().isoformat()\n actor = _get_actor_from_user(user)\n if statement_id is None:\n statement_id = uuid.uuid4()\n if actor is None:\n logger.warning(\"Unable to get an XAPI actor definition for user %s\", user.id)\n return None\n return Statement(\n actor=actor,\n context=context,\n id=statement_id,\n object=obj,\n timestamp=timestamp,\n verb=verb,\n )", "def precmd(self, statement):\n return statement", "def to_sql(self):\n\n if not self._action:\n self.set_action(\"select\")\n for scope in self._global_scopes.get(self.owner, {}).get(self._action, []):\n if not scope:\n continue\n\n scope(self.owner, self)\n\n grammar = self.get_grammar()\n sql = grammar.compile(self._action).to_sql()\n self.boot()\n return sql", "def create_statement(self):\n query = self.commands.get_table_create_statement(self.name)\n if self.db.table_exists(self.name):\n statement = self.execute(query)[0][0]\n statement = re.sub('\\s+', ' ', statement)\n return statement\n raise ValueError('Table does not exist, no create statement')", "def dbAction(tableName, action, data = None):\n return dbAction(tableName, action, data)", "def to_sql(self):\n if self._action == \"create\":\n return self.platform().compile_create_sql(self.table)\n else:\n if not self._dry:\n # get current table schema\n table = self.platform().get_current_schema(\n self.connection, \"table_schema\"\n )\n self.table.from_table = table\n\n return self.platform().compile_alter_sql(self.table)", "def from_statement(cls, statement):\r\n return cls('\\n'.join(textwrap.dedent(statement).splitlines()[1:]))", "def construct_statement(*args):\n\n INPUT_STATEMENT = \"\"\n for statement in args:\n INPUT_STATEMENT += statement\n \n\n return INPUT_STATEMENT", "def pddl_rep(self):\n rep = ''\n rep += \"(:action \" + self.name + \"\\n\"\n rep += \"\\t:parameters \" + str(self.parameters) + \"\\n\"\n if len(self.precondition) > 1:\n rep += \"\\t:precondition (and\\n\"\n else:\n rep += \"\\t:precondition \\n\"\n for precon in self.precondition:\n rep += \"\\t\\t\" + str(precon) + \"\\n\"\n if len(self.precondition) > 1:\n rep += \"\\t)\\n\"\n if len(self.effect) > 1:\n rep += \"\\t:effect (and\\n\"\n else:\n rep += \"\\t:effect \\n\"\n for eff in self.effect:\n rep += \"\\t\\t\" + str(eff) + \"\\n\"\n if len(self.effect) > 1:\n rep += \"\\t)\\n\"\n rep += \")\\n\"\n return rep", "def PolicyStatement(self) -> PolicyStatement:", "def verbatim(self, stmt, suppress=False):\n if not suppress:\n self.statements.append(stmt)\n\n return stmt", "def Generate(self):\n clauses = [self.main_clause] + self.use_clauses + self.join_clauses\n if self.where_conds:\n if self.or_where_conds:\n clauses.append('WHERE ' + '\\n OR '.join(self.where_conds))\n else:\n clauses.append('WHERE ' + '\\n AND '.join(self.where_conds))\n if self.group_by_terms:\n clauses.append('GROUP BY ' + ', '.join(self.group_by_terms))\n if self.having_conds:\n assert self.group_by_terms\n clauses.append('HAVING %s' % ','.join(self.having_conds))\n if self.order_by_terms:\n clauses.append('ORDER BY ' + ', '.join(self.order_by_terms))\n\n if self.limit and self.offset:\n clauses.append('LIMIT %d OFFSET %d' % (self.limit, self.offset))\n elif self.limit:\n clauses.append('LIMIT %d' % self.limit)\n elif self.offset:\n clauses.append('LIMIT %d OFFSET %d' % (sys.maxint, self.offset))\n\n if self.insert_args:\n clauses.append('VALUES (' + PlaceHolders(self.insert_args[0]) + ')')\n args = self.insert_args\n if self.duplicate_update_cols:\n clauses.append('ON DUPLICATE KEY UPDATE %s' % (\n ', '.join(['%s=VALUES(%s)' % (col, col)\n for col in self.duplicate_update_cols])))\n assert not (self.join_args + self.update_args + self.where_args +\n self.group_by_args + self.order_by_args + self.having_args)\n else:\n args = (self.join_args + self.update_args + self.where_args +\n self.group_by_args + self.having_args + self.order_by_args)\n assert not (self.insert_args + self.duplicate_update_cols)\n\n args = _BoolsToInts(args)\n stmt_str = '\\n'.join(clause for clause in clauses if clause)\n\n assert _IsValidStatement(stmt_str), stmt_str\n return stmt_str, args", "def prepare(self, connection, stmt):\n return Statement(connection, stmt)", "def prepare(self, connection, stmt):\n return Statement(connection, stmt)", "def Statements(self):\n states = list()\n while self.currtok[1].name in {\"SEMI\", \"LCURLY\", \"IDENT\", \"if\", \"print\", \"while\", \"return\"}:\n state = self.Statement()\n states.append(state)\n return StatementsStmt(states)", "def _formulate_action(Action, **kwargs):\n\n return Action(**kwargs)", "def _getStatementForEffect(self, effect, methods):\n statements = []\n\n if len(methods) > 0:\n statement = self._getEmptyStatement(effect)\n\n for curMethod in methods:\n if curMethod['conditions'] is None or len(curMethod['conditions']) == 0:\n statement['Resource'].append(curMethod['resourceArn'])\n else:\n conditionalStatement = self._getEmptyStatement(effect)\n conditionalStatement['Resource'].append(\n curMethod['resourceArn'])\n conditionalStatement['Condition'] = curMethod['conditions']\n statements.append(conditionalStatement)\n\n statements.append(statement)\n\n return statements", "def to_action(self, node):\n\n name = node.children[0].name\n parameter_map = {}\n\n if \":parameters\" in node:\n params = PDDL_Utils.read_type(node[\":parameters\"])\n parameter_map = {p[0]: p[1] for p in params} # map of variable-names to types\n else:\n params = []\n\n\n assert \":derive-condition\" in node, \"Error: You must include the :derive-condition value for every action.\"\n\n dcond_ind = [n.name for n in node.children].index(':derive-condition')\n dcond = self.to_formula(node.children[dcond_ind+1], parameter_map)\n\n\n if \":precondition\" in node:\n assert len(node[\":precondition\"].children) == 1,\\\n \"precondition should have one top-level child\"\n precond = self.to_formula(node[\":precondition\"].children[0], parameter_map)\n else:\n precond = None\n\n if \":observe\" in node:\n assert len(node[\":observe\"].children) == 1,\\\n \"observe should have one top-level child\"\n observe = self.to_predicate(node[\":observe\"].children[0], map=parameter_map)\n else:\n observe = None\n\n if \":effect\" in node:\n assert len(node[\":effect\"].children) == 1,\\\n \"effect should have one top-level child\"\n effect = self.to_formula(node[\":effect\"].children[0], parameter_map)\n else:\n effect = None\n\n return Action(name, params, precond, observe, effect, dcond)", "def __init__(self):\n self.Statement = []", "def Statement(self):\n t = self.token\n if t.stmt_begin:\n self._advance()\n return t.std()\n ex = self.expression(0)\n self._advance([\"NEWLINE\", \"END\", \"DEDENT\"])\n return ex", "def Statement(self, default=None):\n return self.data.get('statement', default)", "def stmts_to_stmt(statements):\n if len(statements) == 1:\n return statements[0]\n array = FakeArray(statements, arr_type=pr.Array.NOARRAY)\n return FakeStatement([array])", "def at(self, state):\n self.complete_data(state)\n self.check_duplicate(state)\n action = entities.Action(\n action_id=new_id(state),\n type=self.get_type_name(),\n data=pmap(self.data),\n time=state.context.time,\n randomness=state.context.randomness,\n version=state.context.version,\n )\n return action", "def _build_statement(self, document, statement, homepage, user=None, user_id=None):\n\n if re.match(r\"^http(s?):\\/\\/.*\", homepage) is None:\n homepage = f\"http://{homepage}\"\n\n statement = self.build_common_statement_properties(\n statement, homepage, user=user, user_id=user_id\n )\n\n statement[\"context\"].update(\n {\"contextActivities\": {\"category\": [{\"id\": \"https://w3id.org/xapi/lms\"}]}}\n )\n\n statement[\"object\"] = {\n \"definition\": {\n \"type\": \"http://id.tincanapi.com/activitytype/document\",\n \"name\": {self.get_locale(): document.title},\n },\n \"id\": f\"uuid://{document.id}\",\n \"objectType\": \"Activity\",\n }\n\n return statement", "def test_statement_initialized_by_assignment_with_some_none():\n shap = Statement()\n shap.prop_id = \"dcterms:creator\"\n shap.value_type = \"URI\"\n assert shap == Statement(shape_id=None, prop_id=\"dcterms:creator\", value_type=\"URI\")\n assert not shap.shape_id\n assert not shap.mand", "def _initialize_statements(self):\n return [SqlStatement(x) for x in self._raw_statements]", "def to_statement(self):\n if self.cause_polarity != 'Positive' or \\\n self.effect_polarity != 'Positive':\n return None\n\n # The cause and effect events list both the full text and the text\n # identified as the cause/effect. Get the relevant text by getting\n # the shortest string.\n cause_text = shortest_string_in_list(self.cause_texts)\n effect_text = shortest_string_in_list(self.effect_texts)\n\n # Add an evidence object with the full text. There should be exactly\n # only full text string, but if there is more than one, list them all.\n # Note how we're careful to convert from rdflib's string representation\n # to a python string with str().\n evidence_texts = list(self.evidence_texts)\n if len(evidence_texts) == 1:\n evidence_text = evidence_texts[0]\n else:\n evidence_text = repr(evidence_texts)\n ev = Evidence(source_api='bbn', text=str(evidence_text))\n\n # Convert from rdf literal to python string\n cause_text = str(cause_text)\n effect_text = str(effect_text)\n\n # Make cause concept\n cause_db_refs = {'TEXT': cause_text}\n if self.cause_type is not None:\n cause_db_refs['BBN'] = self.cause_type\n cause_concept = Concept(cause_text, db_refs=cause_db_refs)\n\n # Make effect concept\n effect_db_refs = {'TEXT': effect_text}\n if self.effect_type is not None:\n effect_db_refs['BBN'] = self.effect_type\n effect_concept = Concept(effect_text, db_refs=effect_db_refs)\n\n return Influence(cause_concept, effect_concept, evidence=ev)", "def _assemble(self):\n assert self._kw, \"Call values() first\"\n names = ','.join(list(self._kw))\n holders = ','.join(f'%({name})s' for name in self._kw)\n return (\n f'insert into {self._table} '\n f'({names}) values ({holders}) '\n f'returning {self._returning}'\n ), self._kw.copy()", "def test_statement_initialized_without_property_id():\n shap = Statement()\n assert not shap.start\n assert shap.shape_id is None\n assert shap.shape_label is None\n assert shap.prop_id is None\n assert shap.prop_label is None\n assert shap.mand is None\n assert shap.repeat is None\n assert shap.value_type is None\n assert shap.value_datatype is None\n assert shap.constraint_value is None\n assert shap.constraint_type is None\n assert shap.shape_ref is None\n assert shap.annot is None" ]

[ "0.61875755", "0.5945088", "0.5859864", "0.57459265", "0.5473468", "0.54569197", "0.54220784", "0.53668594", "0.5349767", "0.5299655", "0.5270274", "0.52688295", "0.5244726", "0.5232134", "0.5232134", "0.515628", "0.5091806", "0.5071736", "0.50493217", "0.50363576", "0.5005468", "0.49961653", "0.49585876", "0.4955566", "0.49548224", "0.49474946", "0.49324977", "0.492116", "0.49186152", "0.4911438" ]

[ "def role_policy_statements(role_name):\n policies = []\n role = iam.Role(role_name)\n \n role_policies = [p.policy_document['Statement'] for p in role.policies.all()]\n for p in role_policies:\n policies.extend(p)\n \n attached_policies = [p.default_version.document['Statement'] for p in role.attached_policies.all()]\n for p in attached_policies:\n policies.extend(p)\n\n return policies", "def all_iam_statements(self):\n statements = []\n for managed_policy in self.attached_managed_policies:\n statements.extend(managed_policy.policy_document.statements)\n for inline_policy in self.inline_policies:\n statements.extend(inline_policy.policy_document.statements)\n for group in self.groups:\n statements.extend(group.all_iam_statements)\n return statements", "def compile_statement(statements: List[Any]) -> List[Any]:\n properties = ['action', 'resource', 'notresource', 'notaction']\n for statement in statements:\n for statement_property in properties:\n if statement_property in statement:\n statement[statement_property] = [compile_regex(item) for item in statement[statement_property]]\n return statements", "def expand_statements(statements, all_actions):\n policy_actions = []\n allowed_actions = []\n\n # collect the actions\n for p in statements:\n if isinstance(p['Action'], list):\n policy_actions.extend(p['Action'])\n else:\n policy_actions.append(p['Action'])\n \n # expand the actions\n for pa in policy_actions:\n for a in all_actions:\n if match_action(pa, a):\n allowed_actions.append(a)\n\n return allowed_actions", "def user_policy_statements(user_name):\n policies = []\n user = iam.User(user_name)\n \n # add user inline policies\n user_policies = [p.policy_document['Statement'] for p in user.policies.all()]\n for p in user_policies:\n policies.extend(p)\n\n # add user attached policies\n user_attached_policies = [p.default_version.document['Statement'] for p in user.attached_policies.all()]\n for p in user_attached_policies:\n policies.extend(p)\n\n # add policies from the groups the user belongs to\n for g in user.groups.all():\n \n group_policies = [p.policy_document['Statement'] for p in g.policies.all()]\n for p in group_policies:\n policies.extend(p)\n\n group_attached_policies = [p.default_version.document['Statement'] for p in g.attached_policies.all()]\n for p in group_attached_policies:\n policies.extend(p)\n\n return policies", "def scan_policy(policy_json, policy_name, exclusions=DEFAULT_EXCLUSIONS):\n actions_missing_resource_constraints = []\n\n policy_document = PolicyDocument(policy_json)\n\n findings = Findings(exclusions)\n\n for statement in policy_document.statements:\n logger.debug(\"Evaluating statement: %s\", statement.json)\n if statement.effect == \"Allow\":\n actions_missing_resource_constraints.extend(\n statement.missing_resource_constraints_for_modify_actions(exclusions)\n )\n if actions_missing_resource_constraints:\n these_results = list(\n dict.fromkeys(actions_missing_resource_constraints)\n ) # remove duplicates\n these_results.sort()\n finding = PolicyFinding(\n policy_name=policy_name,\n arn=policy_name,\n actions=these_results,\n policy_document=policy_document,\n exclusions=exclusions,\n )\n findings.add_policy_finding(finding)\n findings.single_use = True\n return finding.json\n else:\n return []", "def build(self):\n if ((self.allowMethods is None or len(self.allowMethods) == 0) and\n (self.denyMethods is None or len(self.denyMethods) == 0)):\n raise NameError(\"No statements defined for the policy\")\n\n policy = {\n 'principalId': self.principalId,\n 'policyDocument': {\n 'Version': self.version,\n 'Statement': []\n }\n }\n\n policy['policyDocument']['Statement'].extend(\n self._getStatementForEffect(\"Allow\", self.allowMethods))\n policy['policyDocument']['Statement'].extend(\n self._getStatementForEffect(\"Deny\", self.denyMethods))\n\n return policy", "def evaluate_statements_for_permission(statements: List[Dict], permission: str, resource_arn: str) -> bool:\n allowed = False\n for statement in statements:\n if not evaluate_notaction_for_permission(statement, permission):\n if evaluate_action_for_permission(statement, permission):\n if evaluate_resource_for_permission(statement, resource_arn):\n if not evaluate_notresource_for_permission(statement, resource_arn):\n return True\n\n return allowed", "def evaluate_policy_for_permissions(\n statements: List[Dict], permissions: List[str], resource_arn: str,\n) -> Tuple[bool, bool]:\n allow_statements = [s for s in statements if s[\"effect\"] == \"Allow\"]\n deny_statements = [s for s in statements if s[\"effect\"] == \"Deny\"]\n for permission in permissions:\n if evaluate_statements_for_permission(deny_statements, permission, resource_arn):\n # The action explicitly denied then no other policy can override it\n return False, True\n else:\n if evaluate_statements_for_permission(allow_statements, permission, resource_arn):\n # The action is allowed by this policy\n return True, False\n # The action is not allowed by this policy, but not specifically denied either\n return False, False", "def _custom_policy(resource, expires=None, valid_after=None, ip_address=None):\r\n condition = {}\r\n if expires:\r\n condition[\"DateLessThan\"] = {\"AWS:EpochTime\": expires}\r\n if valid_after:\r\n condition[\"DateGreaterThan\"] = {\"AWS:EpochTime\": valid_after}\r\n if ip_address:\r\n if '/' not in ip_address:\r\n ip_address += \"/32\"\r\n condition[\"IpAddress\"] = {\"AWS:SourceIp\": ip_address}\r\n policy = {\"Statement\": [{\r\n \"Resource\": resource,\r\n \"Condition\": condition}]}\r\n return json.dumps(policy, separators=(\",\", \":\"))", "def _create_list_of_mock_iam_resources():\n policy_resources = []\n for data in fasd.IAM_POLICY_RESOURCES:\n policy = mock.MagicMock()\n policy.data = json.dumps(data['iam_policy'])\n policy.parent = mock.MagicMock()\n policy.parent.type = data['parent_type']\n policy.parent.name = data['parent_name']\n policy.parent.full_name = data['parent_full_name']\n policy_resources.append(policy)\n return policy_resources", "def policy_json_to_txt(policy_json):\n ret = []\n if policy_json and policy_json.get('version', None) == '1_0':\n for item in policy_json['rules']:\n line = policy_line_format.format(gate=item['gate'], trigger=item['trigger'], action=item['action'])\n if 'params' in item:\n line += ':'\n for param in item['params']:\n line += param_format.format(name=param['name'], value=param['value'])\n ret.append(line)\n\n return ret", "def policy_tables_generator_inputs(wildcards):\n\n # Which policies go into the table?\n # This isn't set in stone; could add or remove if you want.\n if wildcards.table_type == \"expected_fee\":\n audit_policies = [\"uniform\", \"target_x\", \"target_e_low\", \"target_e_high\"]\n\n elif wildcards.table_type in (\"outcome_dwl\", \"outcome_emis\"):\n audit_policies = [\"uniform\", \"target_x\", \"target_e_low\", \"target_e_high\", \"remote_low\", \"remote_high\"]\n else:\n raise ValueError(\"Unknown table_type: \", wildcards.table_type)\n\n if wildcards.audit_tau == \"all-\":\n tau_list = [\"low-\", \"med-\", \"high-\"]\n else:\n # Here audit_tau includes the trailing \"-\"\n assert wildcards.audit_tau.endswith(\"-\")\n tau_list = [wildcards.audit_tau]\n\n input_file_part = []\n for pol in audit_policies:\n if pol in [\"none\", \"remote_low\", \"remote_high\"]:\n amt = \"0pct\"\n else:\n amt = wildcards.audit_amount\n for tau in tau_list:\n tauT = f\"{tau}{wildcards.audit_T}\"\n input_file_part.append(\n f\"audit_outcome_summary_rule={pol}_frac={amt}_tauT={tauT}.parquet\"\n )\n model_dir = STAN_FITS / \"08_twopart_lognormal_heterog_alpha-bootstrap-period_8760_hours\"\n input_files = {\n \"outcome_summaries\": [model_dir / f for f in input_file_part],\n }\n return input_files", "def consolidated_risks(self):\n privilege_escalation_results = {}\n resource_exposure_results = []\n data_exfiltration_results = []\n\n # Get it from each inline policy\n if self.inline_policies:\n for inline_policy in self.inline_policies:\n # Privilege Escalation\n if inline_policy.policy_document.allows_privilege_escalation:\n for entry in inline_policy.policy_document.allows_privilege_escalation:\n if entry[\"type\"] not in privilege_escalation_results.keys():\n privilege_escalation_results[entry[\"type\"]] = entry[\"actions\"]\n # Resource Exposure\n if inline_policy.policy_document.permissions_management_without_constraints:\n for action in inline_policy.policy_document.permissions_management_without_constraints:\n if action not in resource_exposure_results:\n resource_exposure_results.append(action)\n # Data Exfiltration\n if inline_policy.policy_document.allows_data_exfiltration_actions:\n for action in inline_policy.policy_document.allows_data_exfiltration_actions:\n if action not in data_exfiltration_results:\n data_exfiltration_results.append(action)\n\n if self.attached_managed_policies:\n for managed_policy in self.attached_managed_policies:\n # Privilege Escalation\n if managed_policy.policy_document.allows_privilege_escalation:\n for entry in managed_policy.policy_document.allows_privilege_escalation:\n if entry[\"type\"] not in privilege_escalation_results.keys():\n privilege_escalation_results[entry[\"type\"]] = entry[\"actions\"]\n # Resource Exposure\n if managed_policy.policy_document.permissions_management_without_constraints:\n for action in managed_policy.policy_document.permissions_management_without_constraints:\n if action not in resource_exposure_results:\n resource_exposure_results.append(action)\n # Data Exfiltration\n if managed_policy.policy_document.allows_data_exfiltration_actions:\n for action in managed_policy.policy_document.allows_data_exfiltration_actions:\n if action not in data_exfiltration_results:\n data_exfiltration_results.append(action)\n\n # turn it into a list because we want to be able to count the number of results\n these_privilege_escalation_results = []\n\n for key in privilege_escalation_results:\n result = {\n \"type\": key,\n \"actions\": privilege_escalation_results[key]\n }\n these_privilege_escalation_results.append(result)\n\n resource_exposure_results.sort()\n data_exfiltration_results.sort()\n\n results = {\n \"PrivilegeEscalation\": these_privilege_escalation_results,\n \"ResourceExposure\": resource_exposure_results,\n \"DataExfiltration\": data_exfiltration_results,\n }\n return results", "def apply_policy(self, policy):\n tenant_name = policy['tenant_name']\n fw_id = policy['fw_id']\n fw_name = policy['fw_name']\n LOG.debug(\"asa_apply_policy: tenant=%s fw_id=%s fw_name=%s\",\n tenant_name, fw_id, fw_name)\n cmds = [\"conf t\", \"changeto context \" + tenant_name]\n\n rule_dict = policy['rules']\n for rule_id in rule_dict:\n rule = rule_dict[rule_id]\n protocol = rule['protocol']\n name = rule['name']\n enabled = rule['enabled']\n dst_port = rule['destination_port']\n src_port = rule['source_port']\n\n if (rule['source_ip_address'] is not None):\n src_ip = IPNetwork(rule['source_ip_address'])\n else:\n src_ip = IPNetwork('0.0.0.0/0')\n\n if (rule['destination_ip_address'] is not None):\n dst_ip = IPNetwork(rule['destination_ip_address'])\n else:\n dst_ip = IPNetwork('0.0.0.0/0')\n\n if rule['action'] == 'allow':\n action = 'permit'\n else:\n action = 'deny'\n\n LOG.debug(\"rule[%s]: name=%s enabled=%s prot=%s dport=%s sport=%s \\\n dip=%s %s sip=%s %s action=%s\",\n rule_id, name, enabled, protocol, dst_port, src_port,\n dst_ip.network, dst_ip.netmask,\n src_ip.network, src_ip.netmask, action)\n\n acl = \"access-list \"\n acl = (acl + tenant_name + \" extended \" + action + \" \" +\n protocol + \" \")\n if (rule['source_ip_address'] is None):\n acl = acl + \"any \"\n else:\n acl = acl + str(src_ip.network) + \" \" + (\n str(src_ip.netmask) + \" \")\n if (src_port is not None):\n if (':' in src_port):\n range = src_port.replace(':', ' ')\n acl = acl + \"range \" + range + \" \"\n else:\n acl = acl + \"eq \" + src_port + \" \"\n if (rule['destination_ip_address'] is None):\n acl = acl + \"any \"\n else:\n acl = acl + str(dst_ip.network) + \" \" + \\\n str(dst_ip.netmask) + \" \"\n if (dst_port is not None):\n if (':' in dst_port):\n range = dst_port.replace(':', ' ')\n acl = acl + \"range \" + range + \" \"\n else:\n acl = acl + \"eq \" + dst_port + \" \"\n if (enabled is False):\n acl = acl + 'inactive'\n\n # remove the old ace for this rule\n if (rule_id in self.rule_tbl):\n cmds.append('no ' + self.rule_tbl[rule_id])\n\n self.rule_tbl[rule_id] = acl\n if tenant_name in self.tenant_rule:\n if rule_id not in self.tenant_rule[tenant_name]['rule_lst']:\n self.tenant_rule[tenant_name]['rule_lst'].append(rule_id)\n cmds.append(acl)\n cmds.append(\"access-group \" + tenant_name + \" global\")\n cmds.append(\"write memory\")\n\n LOG.debug(cmds)\n data = {\"commands\": cmds}\n return self.rest_send_cli(data)", "def gen_compound_statement(self, statement) -> None:\n for inner_statement in statement.statements:\n self.gen_stmt(inner_statement)", "def PolicyStatement(self) -> PolicyStatement:", "def _canned_policy(resource, expires):\r\n policy = ('{\"Statement\":[{\"Resource\":\"%(resource)s\",'\r\n '\"Condition\":{\"DateLessThan\":{\"AWS:EpochTime\":'\r\n '%(expires)s}}}]}' % locals())\r\n return policy", "def evaluate_resource_for_permission(statement: Dict, resource_arn: str) -> bool:\n if 'resource' not in statement:\n return False\n for clause in statement['resource']:\n if evaluate_clause(clause, resource_arn):\n return True\n return False", "def Attributes(self) -> PolicyStatementAttribute:", "def build_post_policy(self, expiration_time, conditions):\r\n assert type(expiration_time) == time.struct_time, \\\r\n 'Policy document must include a valid expiration Time object'\r\n\r\n # Convert conditions object mappings to condition statements\r\n\r\n return '{\"expiration\": \"%s\",\\n\"conditions\": [%s]}' % \\\r\n (time.strftime(boto.utils.ISO8601, expiration_time), \",\".join(conditions))", "def test_get_resource_policy(self):\n test_resource = ResourceTypeName.get()\n resp = self.app.post(f'/v1/resource/{test_resource}', data=json.dumps({'actions': ['trp:action1']}),\n headers=admin_headers)\n self.assertEqual(resp.status_code, 201)\n for i in range(11):\n resp = self.app.post(f'/v1/resource/{test_resource}/policy/tp{i}',\n data=json.dumps(\n {'policy': create_test_ResourcePolicy('tp{i}', actions=['trp:action1'])}),\n headers=admin_headers)\n self.assertEqual(resp.status_code, 201)\n self._test_paging(f'/v1/resource/{test_resource}/policies', admin_headers, 10, 'policies')", "def get_policy_attribute_list(self,\n policy_type: str,\n statement: Dict[str, Any],\n **kwargs) -> List[Dict[str, Any]]:\n attributes = self.get_object_attribute_list(facet='IAMPolicy', **kwargs)\n statement.update(Version=\"2012-10-17\")\n attributes.extend([\n dict(\n Key=dict(\n SchemaArn=self.node_schema,\n FacetName='POLICY',\n Name='policy_type'),\n Value=dict(\n StringValue=policy_type)),\n dict(\n Key=dict(\n SchemaArn=self.node_schema,\n FacetName='POLICY',\n Name=\"policy_document\"),\n Value=dict(\n BinaryValue=self.format_policy(statement)))\n ])\n return attributes", "def _run_policy(env, policy, num_rollouts):\n start_states, final_states, goal_states, actions, paths = [], [], [], [], []\n\n for i in range(num_rollouts):\n path = rollout(\n env,\n policy,\n max_path_length=100,\n animated=False,\n )\n obs = path[\"observations\"]\n acts = path[\"actions\"]\n\n goal_idx = np.argmax(obs[0, 2:])\n start_x, start_y = obs[0, 0], obs[0, 1]\n acts_x, acts_y = acts[:, 0], acts[:, 1]\n final_x, final_y = obs[len(obs) - 1, 0], obs[len(obs) - 1, 1]\n goal = env.goals[goal_idx]\n goal_x, goal_y = goal[0], goal[1]\n\n start_states.append(np.array([start_x, start_y]))\n final_states.append(np.array([final_x, final_y]))\n goal_states.append(np.array([goal_x, goal_y]))\n actions.append(np.array([acts_x, acts_y]))\n paths.append(path)\n\n return dict(\n start_states=np.array(start_states),\n final_states=np.array(final_states),\n goal_states=np.array(goal_states),\n actions=np.array(actions),\n paths=paths,\n env=env\n )", "def update_execution_policies(\n target_role: iam.Role, project_name: str, project_id: str\n):\n target_role.add_to_principal_policy(\n iam.PolicyStatement(\n actions=[\n # \"sts:AssumeRole\"\n \"iam:PassRole\"\n ],\n resources=[\n f\"arn:aws:iam::{cdk.Aws.ACCOUNT_ID}:role/cdk*\",\n ],\n )\n )\n\n policy = target_role.add_to_principal_policy(\n iam.PolicyStatement(\n actions=[\n \"sts:AssumeRole\",\n \"iam:PassRole\",\n ],\n resources=[\n target_role.role_arn,\n ],\n )\n )\n\n target_role.add_to_principal_policy(\n iam.PolicyStatement(\n actions=[\n \"cloudformation:DescribeStackEvents\",\n \"cloudformation:GetTemplate\",\n \"cloudformation:CreateChangeSet\",\n \"cloudformation:DescribeChangeSet\",\n \"cloudformation:ExecuteChangeSet\",\n \"cloudformation:DeleteChangeSet\",\n \"cloudformation:DescribeStacks\",\n \"cloudformation:DeleteStack\",\n ],\n resources=[\n f\"arn:aws:cloudformation:{cdk.Aws.REGION}:{cdk.Aws.ACCOUNT_ID}:stack/{project_name}*/*\",\n ],\n )\n )\n target_role.add_to_principal_policy(\n iam.PolicyStatement(\n actions=[\n \"cloudformation:DescribeStackEvents\",\n \"cloudformation:GetTemplate\",\n \"cloudformation:DescribeStacks\",\n ],\n resources=[\n f\"arn:aws:cloudformation:{cdk.Aws.REGION}:{cdk.Aws.ACCOUNT_ID}:stack/CDKToolkit/*\",\n ],\n )\n )\n target_role.add_to_principal_policy(\n iam.PolicyStatement(\n actions=[\n \"ssm:GetParameter\",\n ],\n resources=[\n f\"arn:aws:ssm:{cdk.Aws.REGION}:{cdk.Aws.ACCOUNT_ID}:parameter/cdk-bootstrap/*\",\n f\"arn:aws:ssm:{cdk.Aws.REGION}:{cdk.Aws.ACCOUNT_ID}:parameter/sagemaker-{project_name}*\",\n ],\n )\n )\n\n target_role.add_to_principal_policy(\n iam.PolicyStatement(\n actions=[\"*\"],\n resources=[\"*\"],\n conditions={\n \"ForAnyValue:StringEquals\": {\n \"aws:CalledVia\": [\"cloudformation.amazonaws.com\"]\n }\n },\n )\n )\n\n target_role.add_to_principal_policy(\n iam.PolicyStatement(\n actions=[\n \"logs:CreateLogGroup\",\n \"logs:CreateLogStream\",\n \"logs:PutLogEvents\",\n ],\n resources=[\n f\"arn:aws:logs:{cdk.Aws.REGION}:{cdk.Aws.ACCOUNT_ID}:log-group:/aws/codebuild/sagemaker-{project_id}*\",\n f\"arn:aws:logs:{cdk.Aws.REGION}:{cdk.Aws.ACCOUNT_ID}:/aws/codebuild/sagemaker-{project_id}*:*\",\n ],\n )\n )\n\n target_role.add_to_principal_policy(\n iam.PolicyStatement(\n actions=[\n \"codebuild:CreateReportGroup\",\n \"codebuild:CreateReport\",\n \"codebuild:UpdateReport\",\n \"codebuild:BatchPutTestCases\",\n \"codebuild:BatchPutCodeCoverages\",\n ],\n resources=[\n f\"arn:aws:codebuild:{cdk.Aws.REGION}:{cdk.Aws.ACCOUNT_ID}:report-group/sagemaker-{project_id}*\",\n ],\n )\n )\n\n target_role.add_to_principal_policy(\n iam.PolicyStatement(\n actions=[\n \"codepipeline:PutApprovalResult\",\n ],\n resources=[\n f\"arn:aws:codepipeline:{cdk.Aws.REGION}:{cdk.Aws.ACCOUNT_ID}:sagemaker-{project_id}*\",\n ],\n )\n )\n\n target_role.add_to_principal_policy(\n iam.PolicyStatement(\n actions=[\n \"codebuild:BatchGetBuilds\",\n \"codebuild:StartBuild\",\n \"codebuild:StopBuild\",\n ],\n resources=[\n f\"arn:aws:codebuild:{cdk.Aws.REGION}:{cdk.Aws.ACCOUNT_ID}:project/sagemaker-{project_id}*\",\n ],\n )\n )\n\n target_role.add_to_principal_policy(\n iam.PolicyStatement(\n actions=[\n \"glue:SearchTables\",\n \"glue:BatchCreatePartition\",\n \"athena:StartQueryExecution\",\n \"glue:CreateTable\",\n \"glue:GetTables\",\n \"glue:GetTableVersions\",\n \"glue:GetPartitions\",\n \"glue:BatchDeletePartition\",\n \"glue:UpdateTable\",\n \"glue:DeleteTableVersion\",\n \"glue:BatchGetPartition\",\n \"glue:DeleteTable\",\n \"cloudformation:DescribeStacks\",\n \"glue:GetTable\",\n \"glue:GetDatabase\",\n \"glue:GetPartition\",\n \"glue:GetTableVersion\",\n \"glue:CreateDatabase\",\n \"glue:BatchDeleteTableVersion\",\n \"athena:GetQueryExecution\",\n \"glue:BatchDeleteTable\",\n \"glue:CreatePartition\",\n \"glue:DeletePartition\",\n \"glue:UpdatePartition\",\n ],\n resources=[\n \"arn:aws:glue:*:*:catalog\",\n \"arn:aws:glue:*:*:database/default\",\n \"arn:aws:glue:*:*:database/global_temp\",\n \"arn:aws:glue:*:*:database/sagemaker*\",\n \"arn:aws:glue:*:*:table/sagemaker*\",\n \"arn:aws:glue:*:*:tableVersion/sagemaker*\",\n f\"arn:aws:athena:*:{cdk.Aws.ACCOUNT_ID}:workgroup/*\",\n ],\n )\n )\n target_role.add_to_principal_policy(\n iam.PolicyStatement(\n actions=[\"glue:StartJobRun\"],\n resources=[\n f\"arn:aws:glue:{cdk.Aws.REGION}:{cdk.Aws.ACCOUNT_ID}:job/sagemaker-*\"\n ],\n )\n )\n\n target_role.add_to_principal_policy(\n iam.PolicyStatement(\n actions=[\"glue:GetJobRun\", \"glue:GetJobRuns\", \"glue:GetJobs\"],\n resources=[f\"*\"],\n )\n )\n\n target_role.add_to_principal_policy(\n iam.PolicyStatement(\n actions=[\n \"dynamodb:BatchGetItem\",\n \"dynamodb:GetRecords\",\n \"dynamodb:GetShardIterator\",\n \"dynamodb:Query\",\n \"dynamodb:GetItem\",\n \"dynamodb:Scan\",\n \"dynamodb:ConditionCheckItem\",\n \"dynamodb:DescribeTable\",\n ],\n resources=[\n f\"arn:aws:dynamodb:{cdk.Aws.REGION}:{cdk.Aws.ACCOUNT_ID}:table/sagemaker-{project_id}*\"\n ],\n )\n )\n\n return policy", "def provision_create(ec2_conn, iam_conn, interana_account_id, s3_bucket_path, interana_user):\n try:\n user, all_policies = check_account_setup(iam_conn, interana_user)\n except Exception, e:\n print \"Warning could not verify user interana_user {} because {}\".format(interana_user, e)\n\n infile = 's3_bucket_list.policy.template'\n outfile = 's3_bucket_list.policy'\n\n bucket_name, bucket_prefix = get_bucket_name_prefix(s3_bucket_path)\n\n all_lines = ''\n with open(infile, 'r') as tmp_fh, open(outfile, 'w') as out_fh:\n for line in tmp_fh:\n re_proxy = re.compile('<INTERANA_ACCOUNT_ID>')\n translate = re_proxy.sub(interana_account_id, line)\n\n re_proxy = re.compile('<BUCKET_NAME>')\n translate = re_proxy.sub(bucket_name, translate)\n\n re_proxy = re.compile('<BUCKET_PREFIX>')\n translate = re_proxy.sub(bucket_prefix, translate)\n\n out_fh.write(translate)\n all_lines += translate.strip()\n\n if len(bucket_prefix) < 1:\n with open(outfile, 'r') as in_fh:\n policy = json.load(in_fh)\n del policy['Statement'][1]['Condition']\n all_lines = json.dumps(policy)\n print \"Download file to check GetObject Access {}\".format(outfile)\n with open(outfile, 'w') as out_fh:\n json.dump(policy, out_fh, indent=4)\n\n print \"****policy file {}***\".format(outfile)\n\n print json.dumps(json.loads(all_lines), indent=True)", "def apply_conditions_on_dataset(dataset, conditions, min_index=None, max_index=None):\n if max_index is not None or min_index is not None:\n if max_index is None:\n dataset = dataset.iloc[min_index:]\n elif min_index is None:\n dataset = dataset.iloc[:max_index]\n else:\n dataset = dataset.iloc[min_index:max_index]\n for p_c in conditions:\n if type(p_c) == list:\n if len(p_c[0]) == 3:\n snap = apply_conditions_on_dataset(dataset, p_c)\n else:\n temp_var = p_c[0][0]\n p_c[0] = p_c[0][1:]\n temp_snap = apply_conditions_on_dataset(dataset, p_c)\n snap = operator_dict[temp_var](snap.copy(), temp_snap)\n elif len(p_c) == 3:\n snap = operator_dict[p_c[1]](dataset.copy()[p_c[0]], p_c[2])\n elif len(p_c) == 4:\n snap = operator_dict[p_c[0]]((snap.copy()), (operator_dict[p_c[2]](dataset.copy()[p_c[1]], p_c[3])))\n return snap", "def get_response_statements(self, input_statement):\r\n #print \"using the override storage adapter\"\r\n response_query = self.statements.find({\"$text\":{\"$search\": input_statement}})\r\n statement_query = []\r\n for item in response_query:\r\n for question in item['in_response_to']:\r\n statement_query.append(question)\r\n \r\n statement_objects = []\r\n for statement in list(statement_query):\r\n statement_objects.append(self.mongo_to_object(statement)) \r\n \r\n return statement_objects", "def batch_attach_policy(policy: str, object_ref: str) -> Dict[str, Any]:\n return {\n 'AttachPolicy': {\n 'PolicyReference': {\n 'Selector': policy\n },\n 'ObjectReference': {\n 'Selector': object_ref\n }\n }\n }", "def inline_policies_json(self):\n policies = {}\n for policy in self.inline_policies:\n policies[policy.policy_id] = policy.json\n return policies" ]

[ "0.6252711", "0.6066124", "0.5917153", "0.57497823", "0.5632386", "0.55001336", "0.54665285", "0.5361675", "0.53571266", "0.5334229", "0.5300288", "0.5228003", "0.5077554", "0.5066187", "0.5017407", "0.500456", "0.4999616", "0.49988353", "0.4989274", "0.4978008", "0.49254087", "0.48828536", "0.4809764", "0.48074532", "0.47400522", "0.47215796", "0.46999186", "0.46541506", "0.46519014", "0.4647917" ]

[ "def allowMethod(self, verb, resource):\n self._addMethod(\"Allow\", verb, resource, [])", "def allowMethodWithConditions(self, verb, resource, conditions):\n self._addMethod(\"Allow\", verb, resource, conditions)", "def __acl__(self):\n yield 'Allow', 'system.Everyone', 'none'\n yield security.DENY_ALL", "def enforce_policy(self, method_name, request):\n context_dict = request.context.to_dict()\n if method_name in [\"detail\", \"get_all\", \"get_one\"]:\n policy.authorize(event_log_policy.POLICY_ROOT % \"get\", {},\n context_dict)\n else:\n raise exceptions.PolicyNotFound()", "def denyAllMethods(self):\n self._addMethod(\"Deny\", HttpVerb.ALL, \"*\", [])", "def allow_method (self, method, user, ** kw) :\n if self.auth_required and not \\\n (user and user.authenticated and user.active) :\n return False\n if isinstance (method, pyk.string_types) :\n try :\n method = GTW.RST.HTTP_Method.Table [method]\n except KeyError :\n raise self.Status.Method_Not_Allowed \\\n ( _T (\"Unknown HTTP method `%s` requested\") % (method, )\n , valid_methods = sorted (self.SUPPORTED_METHODS)\n )\n if method and not (user and user.superuser) :\n pn = method.mode + \"_permissions\"\n permissions = getattr (self, pn)\n for p in permissions :\n if not p (user, self, ** kw) :\n if p.auth_required :\n return False\n else :\n raise self.Status.Forbidden \\\n (p.message (user, self, ** kw))\n return True", "def allow_methods(self, allow_methods):\n\n self._allow_methods = allow_methods", "def test_allow(self) -> None:\n response = self.request(\"/\", method=\"HEAD\")\n self.assert_allowed(response, (\"GET\", \"POST\"))", "def _enforce(self, req, action):\n try:\n self.policy.enforce(req.context, action, {})\n except exception.Forbidden:\n raise HTTPForbidden()", "def __base_acl__(self) -> list:\n _acls = [\n (Allow, 'g:briefy_qa', ['add', 'delete', 'edit', 'list', 'view'])\n ]\n return _acls", "def verbs_allowed(self, cls, verbs):\n verbs = {v.upper() for v in verbs}\n verbs.add('OPTIONS')\n assert not set(cls._allowed_methods(cls())).difference(verbs)", "def method_check(self, request, allowed=None):\r\n if allowed is None:\r\n allowed = []\r\n \r\n request_method = request.method.lower()\r\n allows = ','.join(map(lambda s: s.upper(), allowed))\r\n \r\n if request_method == 'options':\r\n response = HttpResponse(allows)\r\n response['Access-Control-Allow-Origin'] = '*'\r\n response['Access-Control-Allow-Headers'] = 'Content-Type, Authorization'\r\n response['Access-Control-Allow-Methods'] = \"GET, PUT, POST, PATCH\"\r\n response['Allow'] = allows\r\n raise ImmediateHttpResponse(response=response)\r\n \r\n if not request_method in allowed:\r\n response = http.HttpMethodNotAllowed(allows)\r\n response['Allow'] = allows\r\n raise ImmediateHttpResponse(response=response)\r\n \r\n return request_method", "def get_access_control_allow_methods(self):\n if self.access_control_allow_methods is None:\n return [\n method\n for method\n in self.http_method_names\n if hasattr(self, method)\n ]\n return self.access_control_allow_methods()", "def authorizeClients(self):\n pass", "def __init__(self):\n\n self._authorize()", "def denyMethod(self, verb, resource):\n self._addMethod(\"Deny\", verb, resource, [])", "def method_check(self, request, allowed=None):\n if allowed is None:\n allowed = []\n \n request_method = request.method.lower()\n allows = ','.join(map(lambda s: s.upper(), allowed))\n \n if request_method == 'options':\n response = HttpResponse(allows)\n response['Access-Control-Allow-Origin'] = '*'\n response['Access-Control-Allow-Headers'] = 'Content-Type', 'Authorization'\n response['Access-Control-Allow-Methods'] = \"GET, PUT, POST, PATCH\"\n response['Allow'] = allows\n raise ImmediateHttpResponse(response=response)\n \n if not request_method in allowed:\n response = http.HttpMethodNotAllowed(allows)\n response['Allow'] = allows\n raise ImmediateHttpResponse(response=response)\n \n return request_method", "def authorize(self, http):\n return http", "def authorize(self, request, **kwargs):\n return True", "def permits(identity, obj, permission):\n return False", "def _enforce(self, req, action, target=None):\n if target is None:\n target = {}\n try:\n self.policy.enforce(req.context, action, target)\n except exception.Forbidden as e:\n LOG.debug(\"User not permitted to perform '%s' action\", action)\n raise webob.exc.HTTPForbidden(explanation=e.msg, request=req)", "def __base_acl__(self) -> list:\n _acls = [\n (Allow, 'g:professionals', ['list', 'view', 'edit']),\n ]\n return _acls", "def allow(self, role, operation, resource, assertion=None):\r\n assert not role or role in self._roles\r\n assert not resource or resource in self._resources\r\n self._allowed[role, operation, resource] = assertion", "def authorization():\n pass", "def allow_methods(methods):\n methods = [method.lower() for method in methods]\n\n def wrapper(func):\n @functools.wraps(func)\n def wrapped(self, *args, **kwargs):\n if self.request.method.lower() not in methods:\n return None\n return func(self, *args, **kwargs)\n return wrapped\n return wrapper", "def options(self, request, *args, **kwargs):\r\n response = cake_http.HttpResponse()\r\n response['Allow'] = ', '.join(self.allowed_methods)\r\n response['Content-Length'] = '0'\r\n return response", "def test_only_add_perm(self):\n self.assertStatusCode(self.url, 403)", "def _operation_allowed(self, headers_dict, operation):\n\n if 'allow' in headers_dict:\n if operation in headers_dict['allow']:\n return True\n return False", "def SetIamPolicy(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')", "def test_authorization_is_enforced(self):\n new_client = APIClient()\n response = new_client.get('/posts/', kwargs={'pk': 3}, format=\"json\")\n self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)" ]

[ "0.7216631", "0.6613155", "0.64923126", "0.6455998", "0.6446395", "0.6407103", "0.6355493", "0.63049835", "0.6148039", "0.60514975", "0.599496", "0.598555", "0.59486866", "0.5947886", "0.5905025", "0.58962584", "0.5878088", "0.5875807", "0.5761485", "0.572492", "0.57181853", "0.56929576", "0.5672474", "0.5645347", "0.56181705", "0.5588741", "0.55877745", "0.5587326", "0.55812305", "0.5574905" ]

[ "def allowMethod(self, verb, resource):\n self._addMethod(\"Allow\", verb, resource, [])", "def denyMethod(self, verb, resource):\n self._addMethod(\"Deny\", verb, resource, [])", "def __acl__(self):\n yield 'Allow', 'system.Everyone', 'none'\n yield security.DENY_ALL", "def allowAllMethods(self):\n self._addMethod(\"Allow\", HttpVerb.ALL, \"*\", [])", "def denyMethodWithConditions(self, verb, resource, conditions):\n self._addMethod(\"Deny\", verb, resource, conditions)", "def allowMethodWithConditions(self, verb, resource, conditions):\n self._addMethod(\"Allow\", verb, resource, conditions)", "def allow_methods(self, allow_methods):\n\n self._allow_methods = allow_methods", "def handle_webdefaultdeny(bot, ievent):\n cfg.set('whitelistenable', 1)\n ievent.reply('ok')", "def _enforce(self, req, action):\n try:\n self.policy.enforce(req.context, action, {})\n except exception.Forbidden:\n raise HTTPForbidden()", "def test_disabled_method(api_client):\n\n response = api_client().get(\"/anything/disabled_method\")\n assert response.status_code == 403", "def forbidden():\n return HttpError(403)", "def enforce_policy(self, method_name, request):\n context_dict = request.context.to_dict()\n if method_name in [\"detail\", \"get_all\", \"get_one\"]:\n policy.authorize(event_log_policy.POLICY_ROOT % \"get\", {},\n context_dict)\n else:\n raise exceptions.PolicyNotFound()", "def test_allow(self) -> None:\n response = self.request(\"/\", method=\"HEAD\")\n self.assert_allowed(response, (\"GET\", \"POST\"))", "def verbs_allowed(self, cls, verbs):\n verbs = {v.upper() for v in verbs}\n verbs.add('OPTIONS')\n assert not set(cls._allowed_methods(cls())).difference(verbs)", "def allow_method (self, method, user, ** kw) :\n if self.auth_required and not \\\n (user and user.authenticated and user.active) :\n return False\n if isinstance (method, pyk.string_types) :\n try :\n method = GTW.RST.HTTP_Method.Table [method]\n except KeyError :\n raise self.Status.Method_Not_Allowed \\\n ( _T (\"Unknown HTTP method `%s` requested\") % (method, )\n , valid_methods = sorted (self.SUPPORTED_METHODS)\n )\n if method and not (user and user.superuser) :\n pn = method.mode + \"_permissions\"\n permissions = getattr (self, pn)\n for p in permissions :\n if not p (user, self, ** kw) :\n if p.auth_required :\n return False\n else :\n raise self.Status.Forbidden \\\n (p.message (user, self, ** kw))\n return True", "def forbidden(*args, **kwargs):\n return HttpResponseBehaviour(HttpResponseForbidden, *args, **kwargs)", "def _enforce(self, req, action, target=None):\n if target is None:\n target = {}\n try:\n self.policy.enforce(req.context, action, target)\n except exception.Forbidden as e:\n LOG.debug(\"User not permitted to perform '%s' action\", action)\n raise webob.exc.HTTPForbidden(explanation=e.msg, request=req)", "def deny(self, deny):\n if self.local_vars_configuration.client_side_validation and deny is None: # noqa: E501\n raise ValueError(\"Invalid value for `deny`, must not be `None`\") # noqa: E501\n\n self._deny = deny", "def deny(ip):\n return __apf_cmd(\"-d {}\".format(ip))", "def disable_cmd_restricted(self, cls):\n whitelist = self.get_availables_cmd(cls)\n if not whitelist:\n return True\n acessmethods = AcessMethods(cls, whitelist)\n setattr(self.cls, \"__getattribute__\", acessmethods.disabled_method)", "def handle_webdefaultallow(bot, ievent):\n cfg.set('whitelistenable', 0)\n ievent.reply('ok')", "def get_everyone_denied(self):", "def denyRequest(self, json):\n uID = json.get('uID')\n if not RequestsDAO().getRequestByuID(uID):\n return jsonify(Error=\"User speak request not found\"), 404\n else:\n approval = RequestsDAO().denyTurn(uID)\n mapped_result = self.buildGrantDenyToDict(uID, approval[0])\n return jsonify(TURN=mapped_result), 200", "def test_view_disabled(self, method, url):\n response = getattr(self.client, method)(url)\n assert response.status_code == 403", "def test_only_add_perm(self):\n self.assertStatusCode(self.url, 403)", "def test_review_list_other_method_not_allowed(self):\n client = Client()\n client.login(username='TEST_USER_1',\n email='TEST_EMAIL_1', password='TEST_PW_1')\n response = client.put('/api/review/')\n\n self.assertEqual(response.status_code, 405)", "def http_method_not_allowed(self, *args, **kwargs):\n\t\treturn self.abort(status.HTTP_405_METHOD_NOT_ALLOWED)", "def allow_methods(methods):\n methods = [method.lower() for method in methods]\n\n def wrapper(func):\n @functools.wraps(func)\n def wrapped(self, *args, **kwargs):\n if self.request.method.lower() not in methods:\n return None\n return func(self, *args, **kwargs)\n return wrapped\n return wrapper", "def test_verbs_not_allowed(self, verb, public_omis_api_client):\n order = OrderPaidFactory()\n\n url = reverse(\n 'api-v3:public-omis:payment:collection',\n kwargs={'public_token': order.public_token},\n )\n response = getattr(public_omis_api_client, verb)(url, json_={})\n assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED", "def test_forbidden(self):\n self._error_test(fitbit_exceptions.HTTPForbidden)" ]

[ "0.71312696", "0.7063275", "0.67070395", "0.6678199", "0.6510527", "0.64685214", "0.63343185", "0.62958235", "0.62838495", "0.6273429", "0.6226591", "0.6207807", "0.61567885", "0.6132413", "0.61106557", "0.60410565", "0.5937659", "0.59356344", "0.5866076", "0.5838073", "0.58128184", "0.57969797", "0.57882077", "0.57428277", "0.5735749", "0.57008857", "0.5692362", "0.5687685", "0.5674916", "0.5657868" ]

[ "def _addMethod(self, effect, verb, resource, conditions):\n if verb != '*' and not hasattr(HttpVerb, verb):\n raise NameError('Invalid HTTP verb ' + verb + '. Allowed verbs in HttpVerb class')\n resourcePattern = re.compile(self.pathRegex)\n if not resourcePattern.match(resource):\n raise NameError('Invalid resource path: ' + resource + '. Path should match ' + self.pathRegex)\n\n if resource[:1] == '/':\n resource = resource[1:]\n\n resourceArn = 'arn:aws:execute-api:{}:{}:{}/{}/{}/{}'.format(self.region, self.awsAccountId, self.restApiId, self.stage, verb, resource)\n\n if effect.lower() == 'allow':\n self.allowMethods.append({\n 'resourceArn': resourceArn,\n 'conditions': conditions\n })\n elif effect.lower() == 'deny':\n self.denyMethods.append({\n 'resourceArn': resourceArn,\n 'conditions': conditions\n })", "def allowAllMethods(self):\n self._addMethod(\"Allow\", HttpVerb.ALL, \"*\", [])", "def _addMethod(self, effect, verb, resource, conditions):\n if verb != \"*\" and not hasattr(HttpVerb, verb):\n raise NameError(\"Invalid HTTP verb \" + verb +\n \". Allowed verbs in HttpVerb class\")\n resourcePattern = re.compile(self.pathRegex)\n if not resourcePattern.match(resource):\n raise NameError(\"Invalid resource path: \" + resource +\n \". Path should match \" + self.pathRegex)\n\n if resource[:1] == \"/\":\n resource = resource[1:]\n\n resourceArn = (\"arn:aws:execute-api:\" +\n self.region + \":\" +\n self.awsAccountId + \":\" +\n self.restApiId + \"/\" +\n self.stage + \"/\" +\n verb + \"/\" +\n resource)\n\n if effect.lower() == \"allow\":\n self.allowMethods.append({\n 'resourceArn': resourceArn,\n 'conditions': conditions\n })\n elif effect.lower() == \"deny\":\n self.denyMethods.append({\n 'resourceArn': resourceArn,\n 'conditions': conditions\n })", "def allowed_methods(self) -> typing.List[\"HttpMethods\"]:\n return self._values.get('allowed_methods')", "def get_access_control_allow_methods(self):\n if self.access_control_allow_methods is None:\n return [\n method\n for method\n in self.http_method_names\n if hasattr(self, method)\n ]\n return self.access_control_allow_methods()", "def _check_existing_methods(api_id, resource_id, resource_path, resource_meta,\n enable_cors, authorizers_mapping, api_resp=None,\n api_integration_resp=None):\n for method in resource_meta:\n if method == 'enable_cors':\n continue\n if _API_GATEWAY_CONN.get_method(api_id, resource_id, method):\n _LOG.info('Method %s exists.', method)\n continue\n else:\n _LOG.info('Creating method %s for resource %s...',\n method, resource_id)\n _create_method_from_metadata(\n api_id=api_id,\n resource_id=resource_id,\n resource_path=resource_path,\n method=method,\n method_meta=resource_meta[method],\n authorizers_mapping=authorizers_mapping,\n api_resp=api_resp,\n api_integration_resp=api_integration_resp,\n enable_cors=enable_cors)\n if enable_cors and not _API_GATEWAY_CONN.get_method(api_id,\n resource_id,\n 'OPTIONS'):\n _LOG.info('Enabling CORS for resource %s...', resource_id)\n _API_GATEWAY_CONN.enable_cors_for_resource(api_id, resource_id)", "def method_check(self, request, allowed=None):\r\n if allowed is None:\r\n allowed = []\r\n \r\n request_method = request.method.lower()\r\n allows = ','.join(map(lambda s: s.upper(), allowed))\r\n \r\n if request_method == 'options':\r\n response = HttpResponse(allows)\r\n response['Access-Control-Allow-Origin'] = '*'\r\n response['Access-Control-Allow-Headers'] = 'Content-Type, Authorization'\r\n response['Access-Control-Allow-Methods'] = \"GET, PUT, POST, PATCH\"\r\n response['Allow'] = allows\r\n raise ImmediateHttpResponse(response=response)\r\n \r\n if not request_method in allowed:\r\n response = http.HttpMethodNotAllowed(allows)\r\n response['Allow'] = allows\r\n raise ImmediateHttpResponse(response=response)\r\n \r\n return request_method", "def check_method_allowed(cls, request):\r\n if not request.method in cls._meta.allowed_methods:\r\n raise HttpError(\r\n 'Method \\'%s\\' not allowed on this resource.' % request.method,\r\n status=status.HTTP_405_METHOD_NOT_ALLOWED)", "def method_check(self, request, allowed=None):\n if allowed is None:\n allowed = []\n \n request_method = request.method.lower()\n allows = ','.join(map(lambda s: s.upper(), allowed))\n \n if request_method == 'options':\n response = HttpResponse(allows)\n response['Access-Control-Allow-Origin'] = '*'\n response['Access-Control-Allow-Headers'] = 'Content-Type', 'Authorization'\n response['Access-Control-Allow-Methods'] = \"GET, PUT, POST, PATCH\"\n response['Allow'] = allows\n raise ImmediateHttpResponse(response=response)\n \n if not request_method in allowed:\n response = http.HttpMethodNotAllowed(allows)\n response['Allow'] = allows\n raise ImmediateHttpResponse(response=response)\n \n return request_method", "def _method_check(self, request, allowed=None):\n if allowed is None:\n allowed = []\n\n request_method = request.method.lower()\n allows = ','.join(map(str.upper, allowed))\n\n if request_method == \"options\":\n response = HttpResponse(allows)\n response['Allow'] = allows\n raise ImmediateHttpResponse(response=response)\n\n if not request_method in allowed:\n response = http.HttpMethodNotAllowed(allows)\n response['Allow'] = allows\n raise ImmediateHttpResponse(response=response)\n\n return request_method", "def allow_methods(self, allow_methods):\n\n self._allow_methods = allow_methods", "def route_methods(self, route):\n return [route.method]", "def allow_method (self, method, user, ** kw) :\n if self.auth_required and not \\\n (user and user.authenticated and user.active) :\n return False\n if isinstance (method, pyk.string_types) :\n try :\n method = GTW.RST.HTTP_Method.Table [method]\n except KeyError :\n raise self.Status.Method_Not_Allowed \\\n ( _T (\"Unknown HTTP method `%s` requested\") % (method, )\n , valid_methods = sorted (self.SUPPORTED_METHODS)\n )\n if method and not (user and user.superuser) :\n pn = method.mode + \"_permissions\"\n permissions = getattr (self, pn)\n for p in permissions :\n if not p (user, self, ** kw) :\n if p.auth_required :\n return False\n else :\n raise self.Status.Forbidden \\\n (p.message (user, self, ** kw))\n return True", "def allowed_methods(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:\n return pulumi.get(self, \"allowed_methods\")", "def route_methods(self, route: web.Route):\n return [route.method]", "def allowed_methods(self):\n ret = super(RestfulGenericViewSet, self).allowed_methods\n if hasattr(self, 'filter_allowed_methods'):\n ret = self.filter_allowed_methods(ret)\n return ret", "def is_method_allowed(self):\n if self.request.method.upper() not in self.http_methods:\n raise exceptions.MethodNotAllowed(self.http_methods)\n return True", "def allow_methods(methods):\n methods = [method.lower() for method in methods]\n\n def wrapper(func):\n @functools.wraps(func)\n def wrapped(self, *args, **kwargs):\n if self.request.method.lower() not in methods:\n return None\n return func(self, *args, **kwargs)\n return wrapped\n return wrapper", "def verbs_allowed(self, cls, verbs):\n verbs = {v.upper() for v in verbs}\n verbs.add('OPTIONS')\n assert not set(cls._allowed_methods(cls())).difference(verbs)", "def denyAllMethods(self):\n self._addMethod(\"Deny\", HttpVerb.ALL, \"*\", [])", "def method_check(self, request, allowed=None):\n if allowed is None:\n allowed = []\n\n # Normally we'll just use request.method to determine the request\n # method. However, since some bad clients can't support all HTTP\n # methods, we allow overloading POST requests with a\n # X-HTTP-Method-Override header. This allows POST requests to\n # masquerade as different methods.\n request_method = request.method.lower()\n if request_method == 'post' and 'HTTP_X_HTTP_METHOD_OVERRIDE' in request.META:\n request_method = request.META['HTTP_X_HTTP_METHOD_OVERRIDE'].lower()\n\n allows = ','.join(map(str.upper, allowed))\n\n if request_method == \"options\":\n response = HttpResponse(allows)\n response['Allow'] = allows\n raise ImmediateHttpResponse(response=response)\n\n if not request_method in allowed:\n response = http.HttpMethodNotAllowed(allows)\n response['Allow'] = allows\n raise ImmediateHttpResponse(response=response)\n\n return request_method", "def methods(self):\n methods = {}\n for http_method in self.callback().allowed_methods:\n methods[http_method] = self._get_action_from_http_method(http_method)\n return methods", "def _check_existing_methods(api_id, resource_id, resource_path, resource_meta,\n enable_cors, authorizers_mapping, api_resp=None,\n api_integration_resp=None):\n for method in resource_meta:\n if method == 'enable_cors':\n continue\n if _API_GATEWAY_CONN.get_method(api_id, resource_id, method):\n _LOG.info('Method %s exists.', method)\n continue\n else:\n _LOG.info('Creating method %s for resource %s...',\n method, resource_id)\n _create_method_from_metadata(\n api_id=api_id,\n resource_id=resource_id,\n resource_path=resource_path,\n method=method,\n method_meta=resource_meta[method],\n authorizers_mapping=authorizers_mapping,\n api_resp=api_resp,\n api_integration_resp=api_integration_resp,\n enable_cors=enable_cors)\n if enable_cors and not _API_GATEWAY_CONN.get_method(api_id,\n resource_id,\n 'OPTIONS'):\n _LOG.info('Enabling CORS for resource %s...', resource_id)\n _API_GATEWAY_CONN.enable_cors_for_resource(api_id, resource_id)\n\n @unpack_kwargs\n def _create_resource_from_metadata(api_id, resource_path, resource_meta,\n authorizers_mapping):\n _API_GATEWAY_CONN.create_resource(api_id, resource_path)\n _LOG.info('Resource %s created.', resource_path)\n resource_id = _API_GATEWAY_CONN.get_resource_id(api_id, resource_path)\n enable_cors = resource_meta.get('enable_cors')\n for method in resource_meta:\n try:\n if method == 'enable_cors' or method not in SUPPORTED_METHODS:\n continue\n\n method_meta = resource_meta[method]\n _LOG.info('Creating method %s for resource %s...',\n method, resource_path)\n _create_method_from_metadata(\n api_id=api_id,\n resource_id=resource_id,\n resource_path=resource_path,\n method=method,\n method_meta=method_meta,\n enable_cors=enable_cors,\n authorizers_mapping=authorizers_mapping)\n except Exception as e:\n _LOG.error('Resource: {0}, method {1}.'\n .format(resource_path, method), exc_info=True)\n raise e\n _LOG.info('Method %s for resource %s created.', method,\n resource_path)\n # create enable cors only after all methods in resource created\n if enable_cors:\n _API_GATEWAY_CONN.enable_cors_for_resource(api_id, resource_id)\n _LOG.info('CORS enabled for resource %s', resource_path)", "def methods(domain, resource, pathtype, param=None):\n ret = {}\n if pathtype == 'additional_lookup':\n method = 'GET'\n ret[method] = {}\n ret[method]['label'] = get_label(domain, pathtype, method)\n ret[method]['params'] = schema(resource, param)\n else:\n key = '{0}_methods'.format(pathtype)\n methods = resource[key]\n for method in methods:\n ret[method] = {}\n ret[method]['label'] = get_label(domain, pathtype, method)\n ret[method]['params'] = []\n if method == 'POST':\n ret[method]['params'].extend(schema(resource))\n elif method == 'PATCH':\n ret[method]['params'].append(identifier(resource))\n ret[method]['params'].extend(schema(resource))\n elif pathtype == 'item':\n ret[method]['params'].append(identifier(resource))\n return ret", "def allowMethodWithConditions(self, verb, resource, conditions):\n self._addMethod(\"Allow\", verb, resource, conditions)", "def test_get_allowed_methods(self):\n from django.contrib.auth.models import User\n\n class MyViewSet(ModelViewSet):\n serializer_class = CommentSerializer\n model = User\n\n docgen = DocumentationGenerator()\n\n # Test a list endpoint\n allowed_methods = docgen.__get_allowed_methods__(MyViewSet, '/api/endpoint')\n self.assertEqual(2, len(allowed_methods))\n self.assertIn('POST', allowed_methods)\n self.assertIn('GET', allowed_methods)\n\n # Test an object endpoint\n allowed_methods = docgen.__get_allowed_methods__(MyViewSet, '/api/endpoint/{pk}')\n self.assertEqual(4, len(allowed_methods))\n self.assertIn('POST', allowed_methods)\n self.assertIn('PATCH', allowed_methods)\n self.assertIn('DELETE', allowed_methods)\n self.assertIn('GET', allowed_methods)", "def set_method(\n self, method: MethodStr | QtWebEngineCore.QWebEngineHttpRequest.Method\n ):\n self.setMethod(METHODS.get_enum_value(method))", "def _create_method_not_allowed(self):\n body = self.server.create_error(\n 405, 'Method Not Allowed',\n f'No method \\'{self.path}\\' exist.',\n bad=True)\n self._write_response(405, body, content_type=CONTENT_TYPE_ERROR)", "def add(self, method: str, pattern: str, handler: Callable) -> None:", "def assertAllowedMethods(self, uri, expected_methods):\r\n resp = self.request_with_auth(\"options\", uri)\r\n self.assertHttpOK(resp)\r\n allow_header = resp.get(\"Allow\")\r\n self.assertIsNotNone(allow_header)\r\n allowed_methods = re.split('[^A-Z]+', allow_header)\r\n self.assertItemsEqual(allowed_methods, expected_methods)" ]

[ "0.69362235", "0.69090146", "0.6906327", "0.6576892", "0.64880985", "0.63947076", "0.6353988", "0.63424957", "0.6294204", "0.6255156", "0.6255058", "0.6137722", "0.6134042", "0.6133043", "0.61138725", "0.6084404", "0.6029374", "0.6018546", "0.598662", "0.59777766", "0.5936681", "0.59283245", "0.59267586", "0.5836513", "0.5792693", "0.57717395", "0.57351637", "0.571619", "0.57039315", "0.56983924" ]

[ "def _get_policies(self, cr, uid, context=None):\n return [('optional', _('Optional')),\n ('always', _('Always')),\n ('never', _('Never'))]", "def _get_fake_policy_document():\n return {\n \"Version\": \"2000-01-01\",\n \"Statement\": [\n {\n \"Effect\": \"Allow\",\n \"Action\": [\"fakeservice:*\"],\n \"Resource\": [\n \"arn:aws:fakeservice:us-east-1:861229788715:foo:bar*\",\n \"arn:aws:fakeservice:us-east-1:861229788715:foo:bar/baz*\",\n ],\n }\n ],\n }", "def policy(agent):", "def build_policies_report(**kwargs):\n # All report functions support kwargs to support a unified interface,\n # even if they don't use them.\n _ = kwargs\n jss_connection = JSSConnection.get()\n all_policies = jss_connection.Policy().retrieve_all(\n subset=[\"general\", \"scope\"])\n if not all_policies:\n return Report(\"Policy\", [], \"Policy Usage Report\", {})\n\n all_policies_result = Result([(policy.id, policy.name) for policy in\n all_policies], False, \"All Policies\")\n unscoped_policies = [(policy.id, policy.name) for policy in all_policies if\n policy.findtext(\"scope/all_computers\") == \"false\" and\n not policy.findall(\"scope/computers/computer\") and\n not policy.findall(\n \"scope/computer_groups/computer_group\") and\n not policy.findall(\"scope/buildings/building\") and\n not policy.findall(\"scope/departments/department\")]\n desc = (\"Policies which are not scoped to any computers, computer groups, \"\n \"buildings, departments, or to the all_computers meta-scope.\")\n unscoped = Result(unscoped_policies, True, \"Policies not Scoped\", desc)\n unscoped_cruftiness = calculate_cruft(unscoped_policies, all_policies)\n\n disabled_policies = [(policy.id, policy.name) for policy in all_policies if\n policy.findtext(\"general/enabled\") == \"false\"]\n disabled = Result(disabled_policies, True, \"Disabled Policies\",\n \"Policies which are currently disabled \"\n \"(Policy/General/Enabled toggle).\")\n disabled_cruftiness = calculate_cruft(disabled_policies, all_policies)\n\n report = Report(\"Policy\", [unscoped, disabled, all_policies_result],\n \"Policy Report\", {\"Cruftiness\": {}})\n\n report.metadata[\"Cruftiness\"][\"Unscoped Policy Cruftiness\"] = (\n get_cruft_strings(unscoped_cruftiness))\n report.metadata[\"Cruftiness\"][\"Disabled Policy Cruftiness\"] = (\n get_cruft_strings(disabled_cruftiness))\n\n return report", "def to_xml(self):\n\n policy_element = create_element('policy')\n create_element('name', text=self.name, parent=policy_element)\n match_element = create_element('match', parent=policy_element)\n for s in self.src_addresses:\n create_element('source-address', text=s.name, parent=match_element)\n for d in self.dst_addresses:\n create_element('destination-address', text=d.name, parent=match_element)\n then_element = create_element('then', parent=policy_element)\n create_element(JuniperSRXPolicy.ActionMap[self.action], parent=then_element)\n log_element = create_element('log', parent=then_element)\n for log_type in self.logging:\n create_element(JuniperSRXPolicy.LoggingMap[log_type], parent=log_element)\n\n return policy_element", "def policy_str(self): # -> str:\n ...", "def DefaultGrantSet(self) -> PolicyStatement:", "def grants_to_asciidoc(obj):\r\n\r\n if not obj.permits:\r\n return u''\r\n\r\n coldesctbl_attributes = '[cols=\"8m,%d*^3m\",options=\"header\",width=\"70%%\"]' % len(PERMITS_LIST)\r\n coldesctbl_header = \"|User or Role \" + ' '.join(['|%s' % k for k in PERMITS_LIST])\r\n \r\n # Some globals to locals\r\n table_sep = TABLE_SEP\r\n\r\n grt_rows = []\r\n for k,v in obj.permits.iteritems():\r\n s = '|**%s**' % k\r\n for p in PERMITS_LIST:\r\n s += '|%s' % {True:'GRANT',False:'REVOKE',None:''}[v[p]]\r\n grt_rows.append(s)\r\n grt_rows = '\\n'.join(grt_rows)\r\n\r\n return \"\"\"\r\n.Privileges\r\n%(coldesctbl_attributes)s\r\n%(table_sep)s\r\n%(coldesctbl_header)s\r\n%(grt_rows)s\r\n%(table_sep)s\r\n\"\"\" % locals()", "def _wrap_policy(policy_doc):\n return {\"IAMPolicy\": policy_doc}", "def get_policies():\r\n policy = policies.values()\r\n return policy", "def policy(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"policy\")", "def policy(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"policy\")", "def policy(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"policy\")", "def list_policies(policies, verbosity):\n print()\n if verbosity < 1:\n rows = []\n for p in sorted_by_name(policies):\n rows.append((p.name, p.generator, p.length, p.frequency))\n print_table(('NAME', 'GEN', 'LEN', 'FREQ'), rows)\n else:\n for policy in sorted_by_name(policies):\n chars = NONE\n if policy.disallowed_characters:\n chars = ''.join(sorted(policy.disallowed_characters))\n print_detail(\n policy.name, (\n ('description', nullable(policy.description)),\n ('specs', get_policy_specs(policy)),\n ('∅ chars', chars),\n ),\n )\n print()", "def consolidated_risks(self):\n privilege_escalation_results = {}\n resource_exposure_results = []\n data_exfiltration_results = []\n\n # Get it from each inline policy\n if self.inline_policies:\n for inline_policy in self.inline_policies:\n # Privilege Escalation\n if inline_policy.policy_document.allows_privilege_escalation:\n for entry in inline_policy.policy_document.allows_privilege_escalation:\n if entry[\"type\"] not in privilege_escalation_results.keys():\n privilege_escalation_results[entry[\"type\"]] = entry[\"actions\"]\n # Resource Exposure\n if inline_policy.policy_document.permissions_management_without_constraints:\n for action in inline_policy.policy_document.permissions_management_without_constraints:\n if action not in resource_exposure_results:\n resource_exposure_results.append(action)\n # Data Exfiltration\n if inline_policy.policy_document.allows_data_exfiltration_actions:\n for action in inline_policy.policy_document.allows_data_exfiltration_actions:\n if action not in data_exfiltration_results:\n data_exfiltration_results.append(action)\n\n if self.attached_managed_policies:\n for managed_policy in self.attached_managed_policies:\n # Privilege Escalation\n if managed_policy.policy_document.allows_privilege_escalation:\n for entry in managed_policy.policy_document.allows_privilege_escalation:\n if entry[\"type\"] not in privilege_escalation_results.keys():\n privilege_escalation_results[entry[\"type\"]] = entry[\"actions\"]\n # Resource Exposure\n if managed_policy.policy_document.permissions_management_without_constraints:\n for action in managed_policy.policy_document.permissions_management_without_constraints:\n if action not in resource_exposure_results:\n resource_exposure_results.append(action)\n # Data Exfiltration\n if managed_policy.policy_document.allows_data_exfiltration_actions:\n for action in managed_policy.policy_document.allows_data_exfiltration_actions:\n if action not in data_exfiltration_results:\n data_exfiltration_results.append(action)\n\n # turn it into a list because we want to be able to count the number of results\n these_privilege_escalation_results = []\n\n for key in privilege_escalation_results:\n result = {\n \"type\": key,\n \"actions\": privilege_escalation_results[key]\n }\n these_privilege_escalation_results.append(result)\n\n resource_exposure_results.sort()\n data_exfiltration_results.sort()\n\n results = {\n \"PrivilegeEscalation\": these_privilege_escalation_results,\n \"ResourceExposure\": resource_exposure_results,\n \"DataExfiltration\": data_exfiltration_results,\n }\n return results", "def apply_policy(self, policy):\n tenant_name = policy['tenant_name']\n fw_id = policy['fw_id']\n fw_name = policy['fw_name']\n LOG.debug(\"asa_apply_policy: tenant=%s fw_id=%s fw_name=%s\",\n tenant_name, fw_id, fw_name)\n cmds = [\"conf t\", \"changeto context \" + tenant_name]\n\n rule_dict = policy['rules']\n for rule_id in rule_dict:\n rule = rule_dict[rule_id]\n protocol = rule['protocol']\n name = rule['name']\n enabled = rule['enabled']\n dst_port = rule['destination_port']\n src_port = rule['source_port']\n\n if (rule['source_ip_address'] is not None):\n src_ip = IPNetwork(rule['source_ip_address'])\n else:\n src_ip = IPNetwork('0.0.0.0/0')\n\n if (rule['destination_ip_address'] is not None):\n dst_ip = IPNetwork(rule['destination_ip_address'])\n else:\n dst_ip = IPNetwork('0.0.0.0/0')\n\n if rule['action'] == 'allow':\n action = 'permit'\n else:\n action = 'deny'\n\n LOG.debug(\"rule[%s]: name=%s enabled=%s prot=%s dport=%s sport=%s \\\n dip=%s %s sip=%s %s action=%s\",\n rule_id, name, enabled, protocol, dst_port, src_port,\n dst_ip.network, dst_ip.netmask,\n src_ip.network, src_ip.netmask, action)\n\n acl = \"access-list \"\n acl = (acl + tenant_name + \" extended \" + action + \" \" +\n protocol + \" \")\n if (rule['source_ip_address'] is None):\n acl = acl + \"any \"\n else:\n acl = acl + str(src_ip.network) + \" \" + (\n str(src_ip.netmask) + \" \")\n if (src_port is not None):\n if (':' in src_port):\n range = src_port.replace(':', ' ')\n acl = acl + \"range \" + range + \" \"\n else:\n acl = acl + \"eq \" + src_port + \" \"\n if (rule['destination_ip_address'] is None):\n acl = acl + \"any \"\n else:\n acl = acl + str(dst_ip.network) + \" \" + \\\n str(dst_ip.netmask) + \" \"\n if (dst_port is not None):\n if (':' in dst_port):\n range = dst_port.replace(':', ' ')\n acl = acl + \"range \" + range + \" \"\n else:\n acl = acl + \"eq \" + dst_port + \" \"\n if (enabled is False):\n acl = acl + 'inactive'\n\n # remove the old ace for this rule\n if (rule_id in self.rule_tbl):\n cmds.append('no ' + self.rule_tbl[rule_id])\n\n self.rule_tbl[rule_id] = acl\n if tenant_name in self.tenant_rule:\n if rule_id not in self.tenant_rule[tenant_name]['rule_lst']:\n self.tenant_rule[tenant_name]['rule_lst'].append(rule_id)\n cmds.append(acl)\n cmds.append(\"access-group \" + tenant_name + \" global\")\n cmds.append(\"write memory\")\n\n LOG.debug(cmds)\n data = {\"commands\": cmds}\n return self.rest_send_cli(data)", "def PolicyStatement(self) -> PolicyStatement:", "def test_allowed_list(self):\n val = DwcaValidator(yaml.load(self.yaml_allowed_list, Loader=yaml.FullLoader),\n error_handler=WhipErrorHandler)\n document = {'rightsHolder': 'INBO'}\n self.assertTrue(val.validate(document))\n document = {'rightsHolder': 'ILVO'}\n self.assertFalse(val.validate(document))\n document = {'sex': 'male'}\n self.assertTrue(val.validate(document))\n document = {'sex': 'female'}\n self.assertTrue(val.validate(document))\n document = {'sex': 'Female'}\n self.assertFalse(val.validate(document))\n document = {'age': 'adult'}\n self.assertTrue(val.validate(document))\n document = {'age': 'juvenile'}\n self.assertTrue(val.validate(document))\n document = {'age': 'adult | juvenile'}\n self.assertTrue(val.validate(document))\n document = {'age': 'adult|juvenile'}\n self.assertFalse(val.validate(document))", "def create_policy_request():\n return {\n 'public_key':\n r'BBLewg4VqLR38b38daE7Fj\\/uhr543uGrEpyoPFgmFZK6EZ9g2XdK\\/i65RrSJ6sJ96aXD3DJHY3Me2GJQO9\\/ifjE=',\n 'label':\n 'Integration Test Policy',\n 'operations': [{\n 'sensor_id': 10,\n 'action': 'SHARE',\n }, {\n 'sensor_id': 53,\n 'action': 'BIN',\n 'bins': [30.0, 60.0, 90.0]\n }, {\n 'sensor_id': 55,\n 'action': 'MOVING_AVG',\n 'interval': 300\n }]\n }", "def get_lambda_default_policy_doc(self, extra_statement):\n policy_doc = {\n \"Version\":\"2012-10-17\",\n \"Statement\": [\n {\n \"Effect\":\"Allow\",\n \"Action\":[\n \"lambda:InvokeFunction\",\n \"lambda:AddPermission\",\n \"lambda:RemovePermission\"\n ],\n \"Resource\": \"arn:aws:lambda:$region:$accountId:function:*\"\n },\n {\n \"Effect\":\"Allow\",\n \"Action\":[\n \"logs:CreateLogGroup\",\n \"logs:CreateLogStream\",\n \"logs:PutLogEvents\",\n \"ec2:DescribeNetworkInterfaces\",\n \"ec2:CreateNetworkInterface\",\n \"ec2:DeleteNetworkInterface\"\n ],\n \"Resource\": \"*\"\n }\n ]\n }\n\n policy_doc['Statement'] += extra_statement or [] \n\n return policy_doc", "def policies(self, request):\n policies = OtterPolicies(self.store, self.tenant_id, self.group_id,\n self.dispatcher)\n return policies.app.resource()", "def access_granted(valid_token_dict, template, title):\n policy = config_get('policy', 'permission')\n return render_template(template, token=valid_token_dict['token'], account=valid_token_dict['account'], vo=valid_token_dict['vo'], policy=policy, title=title)", "def policies(self):\n return self._data.get('policies')", "def create_iam_policies(context):\n policies = []\n\n # First, we pre-fill the policy list with Firecloud-wide role grants. These\n # include roles given to the Rawls / Cromwell service accounts, as well as the\n # global Firecloud project owners group (used for administration / maintenance\n # by Firecloud devops).\n fc_project_editors = []\n fc_project_owners = []\n\n if 'fcBillingGroup' in context.properties:\n fc_project_owners.append('group:{}'.format(\n context.properties['fcBillingGroup']))\n\n if 'fcProjectEditors' in context.properties:\n fc_project_editors.extend(context.properties['fcProjectEditors'])\n\n if 'fcProjectOwners' in context.properties:\n fc_project_owners.extend(context.properties['fcProjectOwners'])\n\n if fc_project_editors:\n policies.append({\n 'role': 'roles/editor',\n 'members': fc_project_editors,\n })\n\n if fc_project_owners:\n policies.append({\n 'role': 'roles/owner',\n 'members': fc_project_owners,\n })\n\n # Now we handle granting IAM permissions that apply to Firecloud-managed\n # owners and viewers. We generally expect the 'projectOwnersGroup' and\n # 'projectViewersGroup' to be non-empty, but this code handles an empty value\n # for either in case that changes in the future.\n #\n # This list is populated with both the FC project OWNERS proxy group and the\n # FC project VIEWERS proxy group.\n owners_and_viewers = []\n # This list will contain the OWNERS proxy group only.\n owners_only = []\n\n if 'projectOwnersGroup' in context.properties:\n owners_and_viewers.append('group:{}'.format(\n context.properties['projectOwnersGroup']))\n owners_only.append('group:{}'.format(\n context.properties['projectOwnersGroup']))\n\n if 'projectViewersGroup' in context.properties:\n owners_and_viewers.append('group:{}'.format(\n context.properties['projectViewersGroup']))\n\n if owners_only:\n policies.extend([\n {\n # Only FireCloud project owners are allowed to view the GCP project.\n 'role': 'roles/viewer',\n 'members': owners_only,\n },\n ])\n\n if owners_and_viewers:\n policies.extend([\n {\n # Owners & viewers are allowed to run BigQuery queries in the\n # project (required for running BQ queries within notebooks).\n 'role': 'roles/bigquery.jobUser',\n 'members': owners_and_viewers,\n },\n {\n # Owners & viewers are allowed to write logs in the\n # project (required for gathering logs for user VMs).\n 'role': 'roles/logging.logWriter',\n 'members': owners_and_viewers,\n },\n {\n # Owners & viewers are allowed to write metrics in the\n # project (required for gathering metrics for user VMs).\n 'role': 'roles/monitoring.metricWriter',\n 'members': owners_and_viewers,\n }\n ])\n\n # The requester pays role is an organization-wide role ID that should be\n # granted to both project owners and viewers.\n if 'requesterPaysRole' in context.properties and owners_and_viewers:\n policies.append({\n 'role': context.properties['requesterPaysRole'],\n 'members': owners_and_viewers,\n })\n\n return policies", "def get_policy_info(self):\n policy_info = []\n for pol in self:\n # delete from /info if deprecated\n if pol.is_deprecated:\n continue\n policy_entry = {}\n policy_entry['name'] = pol.name\n if pol.is_default:\n policy_entry['default'] = pol.is_default\n policy_info.append(policy_entry)\n return policy_info", "def get_policy_document_output(output_file: Optional[pulumi.Input[Optional[str]]] = None,\n statements: Optional[pulumi.Input[Optional[Sequence[pulumi.InputType['GetPolicyDocumentStatementArgs']]]]] = None,\n version: Optional[pulumi.Input[Optional[str]]] = None,\n opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetPolicyDocumentResult]:\n ...", "def get_export_policy(cls) -> Dict[str, base_models.EXPORT_POLICY]:\n return dict(super(cls, cls).get_export_policy(), **{\n 'value': base_models.EXPORT_POLICY.NOT_APPLICABLE\n })", "def get_export_policy(cls) -> Dict[str, base_models.EXPORT_POLICY]:\n return dict(super(cls, cls).get_export_policy(), **{\n 'rules': base_models.EXPORT_POLICY.NOT_APPLICABLE,\n 'rule_schema_version': base_models.EXPORT_POLICY.NOT_APPLICABLE,\n 'default_value': base_models.EXPORT_POLICY.NOT_APPLICABLE\n })", "def get_policies_default(config, n_policies, obs_space, act_space, policy_template=\"player_%d\"):\r\n policies = {policy_template % i: get_agent_config(agent_id=i, which=config['_policies'][i],\r\n config=config,\r\n obs_space=obs_space, act_space=act_space)\r\n for i in range(1, 1 + n_policies)}\r\n return policies", "def build_permissions(self):\n\t\tself.build_doctype_map()\n\t\tself.build_perm_map()\n\t\tuser_shared = frappe.share.get_shared_doctypes()\n\t\tno_list_view_link = []\n\t\tactive_modules = get_active_modules() or []\n\t\tfor dt in self.doctype_map:\n\t\t\tdtp = self.doctype_map[dt]\n\n\t\t\tp = self.perm_map.get(dt, {})\n\n\t\t\tif not p.get(\"read\") and (dt in user_shared):\n\t\t\t\tp[\"read\"] = 1\n\n\t\t\tif p.get(\"select\"):\n\t\t\t\tself.can_select.append(dt)\n\n\t\t\tif not dtp.get(\"istable\"):\n\t\t\t\tif p.get(\"create\") and not dtp.get(\"issingle\"):\n\t\t\t\t\tif dtp.get(\"in_create\"):\n\t\t\t\t\t\tself.in_create.append(dt)\n\t\t\t\t\telse:\n\t\t\t\t\t\tself.can_create.append(dt)\n\t\t\t\telif p.get(\"write\"):\n\t\t\t\t\tself.can_write.append(dt)\n\t\t\t\telif p.get(\"read\"):\n\t\t\t\t\tif dtp.get(\"read_only\"):\n\t\t\t\t\t\t# read_only = \"User Cannot Search\"\n\t\t\t\t\t\tself.all_read.append(dt)\n\t\t\t\t\t\tno_list_view_link.append(dt)\n\t\t\t\t\telse:\n\t\t\t\t\t\tself.can_read.append(dt)\n\n\t\t\tif p.get(\"cancel\"):\n\t\t\t\tself.can_cancel.append(dt)\n\n\t\t\tif p.get(\"delete\"):\n\t\t\t\tself.can_delete.append(dt)\n\n\t\t\tif p.get(\"read\") or p.get(\"write\") or p.get(\"create\"):\n\t\t\t\tif p.get(\"report\"):\n\t\t\t\t\tself.can_get_report.append(dt)\n\t\t\t\tfor key in (\"import\", \"export\", \"print\", \"email\"):\n\t\t\t\t\tif p.get(key):\n\t\t\t\t\t\tgetattr(self, \"can_\" + key).append(dt)\n\n\t\t\t\tif not dtp.get(\"istable\"):\n\t\t\t\t\tif not dtp.get(\"issingle\") and not dtp.get(\"read_only\"):\n\t\t\t\t\t\tself.can_search.append(dt)\n\t\t\t\t\tif dtp.get(\"module\") not in self.allow_modules:\n\t\t\t\t\t\tif active_modules and dtp.get(\"module\") not in active_modules:\n\t\t\t\t\t\t\tpass\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\tself.allow_modules.append(dtp.get(\"module\"))\n\n\t\tself.can_write += self.can_create\n\t\tself.can_write += self.in_create\n\t\tself.can_read += self.can_write\n\n\t\tself.shared = frappe.get_all(\n\t\t\t\"DocShare\", {\"user\": self.name, \"read\": 1}, distinct=True, pluck=\"share_doctype\"\n\t\t)\n\t\tself.can_read = list(set(self.can_read + self.shared))\n\t\tself.all_read += self.can_read\n\n\t\tfor dt in no_list_view_link:\n\t\t\tif dt in self.can_read:\n\t\t\t\tself.can_read.remove(dt)\n\n\t\tif \"System Manager\" in self.get_roles():\n\t\t\tself.can_import += frappe.get_all(\"DocType\", {\"allow_import\": 1}, pluck=\"name\")\n\t\t\tself.can_import += frappe.get_all(\n\t\t\t\t\"Property Setter\",\n\t\t\t\tpluck=\"doc_type\",\n\t\t\t\tfilters={\"property\": \"allow_import\", \"value\": \"1\"},\n\t\t\t)\n\n\t\tfrappe.cache.hset(\"can_import\", frappe.session.user, self.can_import)" ]

[ "0.6304702", "0.58589256", "0.5853127", "0.58469373", "0.5558938", "0.5537385", "0.5523633", "0.55235267", "0.55221826", "0.54749024", "0.54417336", "0.54417336", "0.54417336", "0.5441389", "0.5411109", "0.5367578", "0.535472", "0.5340589", "0.53121686", "0.53085357", "0.5283647", "0.5280801", "0.52644193", "0.52633125", "0.52386266", "0.52287793", "0.52201784", "0.5209166", "0.5176241", "0.5170215" ]

[ "def load_sentences(path, lower, zeros=True):\n sentences = []\n sentence = []\n for line in codecs.open(path, 'r', 'utf8'):\n line = zero_digits(line.rstrip()) if zeros else line.rstrip()\n if not line:\n if len(sentence) > 0:\n if 'DOCSTART' not in sentence[0][0]:\n sentences.append(sentence)\n sentence = []\n else:\n word = line.split()\n assert len(word) >= 2\n sentence.append(word)\n if len(sentence) > 0:\n if 'DOCSTART' not in sentence[0][0]:\n sentences.append(sentence)\n return sentences", "def load_sentences(path, zeros):\n sentences = []\n sentence = []\n for line in codecs.open(path, 'r', 'utf8'):\n line = zero_digits(line.rstrip()) if zeros else line.rstrip()\n if not line:\n if len(sentence) > 0:\n if 'DOCSTART' not in sentence[0][0]:\n sentences.append(sentence)\n sentence = []\n else:\n word = line.split()\n sentence.append(word)\n if len(sentence) > 0:\n if 'DOCSTART' not in sentence[0][0]:\n sentences.append(sentence)\n return sentences", "def load_sentences(args):\n logger = logging.getLogger('logger')\n sentence_list = []\n for file_name in os.listdir(args['data_path']):\n if file_name.endswith('.jsonl'):\n file_path = os.path.join(args['data_path'], file_name)\n logger.info('Loading sentences from file {}.'.format(file_path))\n with open(file_path) as data_file:\n data_lines = data_file.readlines()\n data_json = list(map(lambda x: json.loads(x), data_lines))\n if not args['no_premise']:\n sentence_list += list(map(lambda x: x['sentence1'], data_json))\n if not args['no_hypothesis']:\n sentence_list += list(map(lambda x: x['sentence2'], data_json))\n\n logger.info('Starting to remove duplicates from {} sentences loaded.'.format(len(sentence_list)))\n unique_sent_list = list(set(sentence_list))\n logger.info('Done removing duplicates. Loaded {} unique sentences.'.format(len(unique_sent_list)))\n return unique_sent_list", "def _split_into_sentences(self):\n EOL_CHARS = \".!?\"\n allSentences = []\n with open(self.filename, 'r') as f:\n sentence = []\n for line in f:\n try:\n word, label = line.split()\n except:\n continue\n #no the end of the sentence\n sentence += [word]\n intLabel = 1 if label == \"PERSON\" else 0\n self.labels += [intLabel]\n if word in EOL_CHARS:\n allSentences += [sentence]\n sentence = []\n\n #in case the last sentence doesn't end with proper punctuation!\n if sentence != []:\n allSentences += [sentence]\n self.allSentences = allSentences", "def _load_sentence_list(self, path):\n\n result = {}\n\n for entry in textfile.read_separated_lines_generator(path, separator='\\t', max_columns=3):\n if self.include_languages is None or entry[1] in self.include_languages:\n result[entry[0]] = entry[1:]\n\n return result", "def make_sentences(self):\n\n if self.document == None:\n return\n\n sent = sent_tokenize(self.document) # contains raw sentences\n\n\n # Create parameters for NER and Dependency Parsing a\n # and pass it to the sentence objcet\n\n # set config file\n config = CP.RawConfigParser()\n config = config\n config.read('config.py')\n\n # Server for dependency parsing\n\n server = ServerProxy(JsonRpc20(),TransportTcpIp(addr=(\"127.0.0.1\", 8080), timeout=200.0))\n\n # Parameters for Named entitye recognition\n\n # get the classifier and tagger location from config file\n tagger = config.get('NER','tagger') # gets the path of the stanford tagger\n classifier = config.get('NER','classifier') # gets the path of the stanford classifier\n st = StanfordNERTagger(classifier,tagger)\n for i in range(len(sent)):\n s = Sentence(sent[i],i,server, st, 'test')\n self.sentences.append(s)", "def extract_sentences(file_path):\n\n with open(file_path, \"r\") as file:\n\n lines = list()\n\n for line in file:\n line_stripped = line.strip()\n\n if line_stripped == \"\":\n continue\n\n lines.append(line_stripped)\n\n text = \" \".join(lines)\n sentences = token_to_sentence(text)\n\n return sentences", "def process_corpus(self):\n sentences = []\n sentence = []\n with open(str(self.file), encoding=self.encoding) as f:\n\n line = f.readline()\n\n while line:\n\n if line.startswith(\"#\"):\n line = f.readline()\n continue\n\n if line.strip().replace(\"\", \"\") == \"\":\n if len(sentence) > 0:\n self.infer_space_after(sentence)\n if self.tagging_scheme is not None:\n self.convert_tag_scheme(\n sentence, target_scheme=\"iobes\"\n )\n\n sentences.append(sentence)\n sentence = []\n\n else:\n fields = re.split(r\"\\s+\", line)\n token = fields[0] # text column\n token_tags = {\n v: fields[k]\n for k, v in self.columns.items()\n if v != \"text\"\n }\n sentence.append({\"name\": token, \"tags\": token_tags})\n\n line = f.readline()\n\n return sentences", "def load_data_sentences(dirname):\n sentence_list = []\n for fname in os.listdir(dirname):\n with open(os.path.join(dirname, fname)) as file:\n #sentence_list.append(gensim.models.word2vec.LineSentence(file))\n sentence_list.append(file)\n return sentence_list", "def sent_tokenize(line):\n sentences = []\n cur_pos = 0\n if not re.search(r\"\\.\", line):\n return [line]\n\n for match in re.finditer(r\"\\.\", line):\n _pos = match.start()\n end_pos = match.end()\n if is_end_of_sentence(_pos, line):\n tmpsent = line[cur_pos:end_pos]\n tmpsent = tmpsent.strip()\n if is_valid_xml(tmpsent):\n cur_pos = end_pos\n sentences.append(tmpsent)\n\n if len(sentences) == 0:\n sentences.append(line)\n elif cur_pos < len(line)-1:\n sentences.append(line[cur_pos+1:])\n return sentences", "def read_sentences():\r\n f = open(\"data.txt\", \"r\")\r\n gram = f.read().splitlines()\r\n gram = [sentence for sentence in gram if sentence != \"\"]\r\n return gram", "def _read_sentences(filename):\n with tf.gfile.GFile(filename, \"r\") as f:\n return [sentence.split() for sentence in f.read().split('\\n')]", "def read_file(path, tok=False):\n with open_file(path) as f:\n for line in f.readlines():\n words = split_sentence(line.strip(), tok)\n yield words", "def readWhole(self):\n try:\n if os.path.isfile(self.filename) == False:\n raise dse.DocumentStreamError(\"Not a file!\")\n except dse.DocumentStreamError as E:\n print(E.data)\n exit()\n\n f = open(self.filename, 'r')\n\n fileString = f.read()\n f.close()\n\n #fileString = [c for c in fileString if c not in ['\\n', '\\t']] # Remove all returns in the string\n\n sentenceList = []\n sent = ''\n spaceState = False\n\n\n ### If char is .!?; or new line, append sentence to sentenceList\n ### and reset sentence to empty string.\n\n for char in fileString:\n if char in ['\\n', '\\t']:\n char = ' '\n\n if char == ' ':\n if spaceState == True and sent != '':\n sentenceList.append(sentence.Sentence(sent))\n sent = ''\n elif spaceState == False:\n sent += char\n spaceState = True\n else:\n spaceState = False\n sent += char\n if char in '.!?;' and sent != '':\n sentenceList.append(sentence.Sentence(sent))\n sent = ''\n\n if sent != '':\n sentenceList.append(sentence.Sentence(sent))\n\n ### Handles the case that a sentence begins or ends with a space character.\n '''\n for i in sentenceList:\n if i.sentence[0] == ' ':\n i = sentence.Sentence(i.sentence[1:])\n if i.sentence[-1] == ' ':\n i = sentence.Sentence(i.sentence[:-1])\n '''\n\n return sentenceList", "def __read_data__(self):\n with open(self.file, 'r') as data:\n sentence = []\n tags = []\n for line in data:\n terms = line.rstrip().split(WHITESPACE)\n for term in terms:\n word_tag = tuple(term.split(TAGCHAR))\n word = word_tag[0]\n tag = word_tag[1]\n self.word_tag_dict[word_tag] += 1\n self.tag_dict[tag] += 1\n self.__add_to_word_dict__(word, tag)\n if self.isNumberWord(word):\n self.numbers += 1\n if word[0].isupper() and len(sentence) > 0:\n self.cap_no_start += 1\n sentence.append(word)\n tags.append(tag)\n if tag == ENDOFSENTENCE:\n self.sentences.append(tuple(sentence))\n self.tags.append(tuple(tags))\n sentence = []\n tags = []", "def get_enron_sentences(self):\n helper._print_subheader('Reading ' + directories.ENRON_TRAIN_SENTENCES_TXT_PATH + '...')\n with open(directories.ENRON_TRAIN_SENTENCES_TXT_PATH, 'r', encoding='utf-8') as txt_file:\n for index, line in enumerate(txt_file):\n if index % 1000000 == 0 and index != 0:\n helper._print(f'{index} sentences read')\n break\n preproccesed_line = simple_preprocess(line)\n if preproccesed_line != []:\n yield preproccesed_line\n helper._print(f'{index} sentences read')\n helper._print_subheader('Done reading Enron email data!')", "def sentences(self, text):\n if not self.__isValidInput(text):\n return [Sentence(text, Sentence.NONE)]\n\n uniText = unicode_str(text)\n result = []\n textLen = len(uniText)\n sentenceLen = c_size_t()\n position = 0\n while textLen > 0:\n sentenceType = self.__lib.voikkoNextSentenceStartUcs4(\n self.__handle,\n uniText[position:],\n textLen,\n byref(sentenceLen),\n )\n sentenceText = uniText[position:position + sentenceLen.value]\n result.append(Sentence(sentenceText, sentenceType))\n if sentenceType == Sentence.NONE:\n break\n position = position + sentenceLen.value\n textLen = textLen - sentenceLen.value\n return result", "def split_to_sentences(data):\r\n sentences = data.split(\"\\n\")\r\n \r\n sentences = [s.strip() for s in sentences]\r\n sentences = [s for s in sentences if len(s) > 0]\r\n \r\n return sentences", "def read_sents_from_file(f):\r\n sent = []\r\n for line in f:\r\n line = line.strip()\r\n if line == \"\":\r\n if sent != []:\r\n yield 'SENT', Sentence(sent)\r\n sent = []\r\n elif line.startswith('#'):\r\n yield 'COMMENT', line\r\n else:\r\n sent.append(line)\r\n if sent != []:\r\n yield 'SENT', Sentence(sent)\r\n f.close()", "def sentences(self, tag=False, tag_method=None):\n self.__set_text_node(self.root_)\n sentence_nodes = filter(lambda n: n.nodeType == n.ELEMENT_NODE and n.tagName == 's',\n list(self.text_node.childNodes))\n sentences = []\n for s in sentence_nodes:\n current = []\n TimeMLDoc.__get_text(s, current, False)\n #print(current)\n if not tag:\n sentences.append(''.join([ c[0] for c in current]))\n else:\n sentences.append(tag_method(current))\n return sentences", "def load_file(self, file_path):\n f = open(file_path, \"r\")\n sentences = f.readlines()\n \n word_count = 0\n\n for sentence in sentence: \n for word in sentence.strip().split(\" \"):\n if not (word in self.word_id): #word not in dictionary\n word_id[word] = word_count\n word_count += 1\n\n #self.doc = [[self.word_id[word] for word in sentence.strip().split(\" \")] for sentence in sentences]", "def get_sentences(text):\n \n return text.split('.')", "def gather_sentences(self):\n sentences = Sentence.objects.all()\n return sentences", "def get_sentences(self):\n return [s for s in self.text.split('\\n')]", "def doc2sentence(doc):\n sentences = doc.split('\\n')\n sentences = list(filter(lambda sentence: sentence not in(\"\", \" \", \"\\n\"), sentences))\n return sentences", "def extract_sentences_from_text(self, text_data):\n pass", "def get_plain_sentences(self, type):\n if type == \"translation\":\n fn = self.translationfile()\n elif type == \"source\":\n fn = self.sourcefile()\n elif type == \"reference\":\n fn = self.referencefile()\n else:\n raise ValueError\n with open(fn, \"r\") as f:\n lines = f.readlines()\n return lines", "def tokenize(self, path):\n assert os.path.exists(path)\n with open(path, 'r') as f:\n sentences = []\n for sentence in tqdm(f, desc='Processing file: {}'.format(path)):\n sentences.append(sentence.split())\n self.data = sentences", "def testSentences(self):\n\n textractor = Textractor(sentences=True)\n\n # Extract text as sentences\n sentences = textractor(Utils.PATH + \"/article.pdf\")\n\n # Check number of sentences is as expected\n self.assertEqual(len(sentences), 17)", "def read_file(input_file):\n with open(input_file, \"r\", encoding=\"utf-8-sig\") as f:\n sentences = f.read().splitlines()\n return sentences" ]

[ "0.73260915", "0.72926795", "0.6630065", "0.65276825", "0.6465343", "0.6369665", "0.63562053", "0.63426006", "0.6305672", "0.6272708", "0.6236807", "0.6198804", "0.61588985", "0.6153663", "0.608253", "0.6081131", "0.60524327", "0.6020787", "0.6013786", "0.60017645", "0.59900844", "0.5979665", "0.5978955", "0.59786713", "0.5965345", "0.5962829", "0.5952394", "0.5947396", "0.59316945", "0.5920771" ]

[ "def update_tag_scheme(sentences, tag_scheme):\n for i, s in enumerate(sentences):\n tags = [w[-1] for w in s]\n # Check that tags are given in the IOB format\n if not iob2(tags):\n s_str = '\\n'.join(' '.join(w) for w in s)\n raise Exception('Sentences should be given in IOB format! ' +\n 'Please check sentence %i:\\n%s' % (i, s_str))\n if tag_scheme == 'iob':\n # If format was IOB1, we convert to IOB2\n for word, new_tag in zip(s, tags):\n word[-1] = new_tag\n elif tag_scheme == 'iobes':\n new_tags = iob_iobes(tags)\n for word, new_tag in zip(s, new_tags):\n word[-1] = new_tag\n else:\n raise Exception('Unknown tagging scheme!')", "def ensure_iob2(tags):\n tags = list(tags)\n for i, tag in enumerate(tags):\n if tag == 'O':\n continue\n split = tag.split('-')\n if len(split) != 2 or split[0] not in ['I', 'B']:\n return False\n if split[0] == 'B':\n continue\n elif i == 0 or tags[i - 1] == 'O': # conversion IOB1 to IOB2\n tags[i] = 'B' + tag[1:]\n elif tags[i - 1][1:] == tag[1:]:\n continue\n else: # conversion IOB1 to IOB2\n tags[i] = 'B' + tag[1:]\n return tags", "def iob2(tags):\n for i, tag in enumerate(tags):\n if tag == \"O\":\n continue\n split = tag.split(\"-\")\n if len(split) != 2 or split[0] not in [\"I\", \"B\"]:\n return False\n if split[0] == \"B\":\n continue\n elif i == 0 or tags[i - 1] == \"O\": # conversion IOB1 to IOB2\n tags[i] = \"B\" + tag[1:]\n elif tags[i - 1][1:] == tag[1:]:\n continue\n else: # conversion IOB1 to IOB2\n tags[i] = \"B\" + tag[1:]\n return True", "def iob2(tags):\n for i, tag in enumerate(tags):\n if tag == 'O':\n continue\n split = tag.split('-')\n if len(split) != 2 or split[0] not in ['I', 'B']:\n return False\n if split[0] == 'B':\n continue\n elif i == 0 or tags[i - 1] == 'O': # conversion IOB1 to IOB2\n tags[i] = 'B' + tag[1:]\n elif tags[i - 1][1:] == tag[1:]:\n continue\n else: # conversion IOB1 to IOB2\n tags[i] = 'B' + tag[1:]\n return True", "def iob2iobes(sentence_iob):\n sentence_iobes = copy.deepcopy(sentence_iob)\n for tag in ['chunk', 'ner']:\n sentence_iobes = I2S(sentence_iob, sentence_iobes, tag)\n sentence_iobes = I2B(sentence_iob, sentence_iobes, tag)\n sentence_iobes = I2E(sentence_iob, sentence_iobes, tag)\n sentence_iobes = B2S(sentence_iob, sentence_iobes, tag)\n return sentence_iobes", "def bio2ot_ote(ote_tag_sequence):\n new_ote_sequence = []\n n_tags = len(ote_tag_sequence)\n for i in range(n_tags):\n ote_tag = ote_tag_sequence[i]\n if ote_tag == 'B' or ote_tag == 'I':\n new_ote_sequence.append('T')\n else:\n new_ote_sequence.append('I')\n return new_ote_sequence", "def iobes2iob(sentence_iobes):\n sentence_iob = copy.deepcopy(sentence_iobes)\n for tag in ['chunk', 'ner']:\n sentence_iob = E2I(sentence_iobes, sentence_iob, tag)\n sentence_iob = S2I(sentence_iobes, sentence_iob, tag)\n sentence_iob = B2I(sentence_iobes, sentence_iob, tag)\n sentence_iob = S2B(sentence_iobes, sentence_iob, tag)\n return sentence_iob", "def make_iob(txt, ents, etypes):\r\n index = 0\r\n for i in ents:\r\n start = txt.index(i, index) #get the start of the entity\r\n tmp1, tmp2 = txt[:start], txt[start:]\r\n tmp1 += \" eeeeeeeeeeeeeeeeeeee \"\r\n txt = ' '.join([tmp1, tmp2])\r\n index = start + len(i) + len(\" eeeeeeeeeeeeeeeeeeee \")\r\n \r\n line_tokens = word_tokenize(txt)#tokenize the text\r\n \r\n #get the starting positions of the entities\r\n starts = []\r\n try: #in order to handle the last case where list.index doesnt finds anything\r\n while line_tokens.index(\"eeeeeeeeeeeeeeeeeeee\") > -1:\r\n tmp = line_tokens.index(\"eeeeeeeeeeeeeeeeeeee\")\r\n starts.append(tmp)\r\n del line_tokens[tmp]\r\n except ValueError:\r\n pass\r\n \r\n line_iob = ['O'] * len(line_tokens)# the iob tags of the whole text\r\n \r\n for i in range(0, len(ents)):\r\n #tokenize the entities\r\n entity_tokens = word_tokenize(ents[i])\r\n tmp = 'I-'+etypes[i]\r\n entity_iob = [tmp] * len(entity_tokens)\r\n entity_iob[0] = \"B-\" + etypes[i]\r\n \r\n #make changes to the iob tags to match the entities\r\n for j in range(0, len(entity_iob)):\r\n line_iob[starts[i] + j] = entity_iob[j]\r\n \r\n #the format is: token IOB-etypes\r\n for i in range(0, len(line_tokens)):\r\n output.write(\"{}\\t{}\\n\".format(line_tokens[i], line_iob[i]))\r\n output.write('\\n')#new document\r", "def ud_verb_heuristics(self, ud_tags, tokens, lemmas):\n ud_tags = list(ud_tags)\n n = len(ud_tags)\n for i in range(n):\n if ud_tags[i] == 'AUX':\n if lemmas[i] == 'vara':\n # Trust the copula classifier\n continue\n for j in range(i + 1, n):\n if ud_tags[j] in ('AUX', 'VERB'):\n # If followed by AUX or VERB, do nothing\n break\n if (ud_tags[j] in ('SCONJ', 'PUNCT')) \\\n or tokens[j].lower() == 'som' or j == n - 1:\n # If no AUX/VERB before SCONJ, PUNCT, \"som\" or end of\n # sentence, change to VERB\n ud_tags[i] = 'VERB'\n break\n return ud_tags", "def tag2predictions(ote_tag_sequence, ts_tag_sequence):\n n_tag = len(ote_tag_sequence)\n # opinion target sequence and targeted sentiment sequence\n ot_sequence, ts_sequence = [], []\n beg, end = -1, -1\n for i in range(n_tag):\n tag = ote_tag_sequence[i]\n if tag == 'S':\n ot_sequence.append((i, i))\n elif tag == 'B':\n beg = i\n elif tag == 'E':\n end = i\n if end > beg and beg != -1:\n ot_sequence.append((beg, end))\n beg, end = -1, -1\n sentiments = []\n beg, end = -1, -1\n for i in range(n_tag):\n ts_tag = ts_tag_sequence[i]\n # current position and sentiment\n eles = ts_tag.split('-')\n if len(eles) == 2:\n pos, sentiment = eles\n else:\n pos, sentiment = 'O', 'O'\n if sentiment != 'O':\n # current word is a subjective word\n sentiments.append(sentiment)\n if pos == 'S':\n # singleton\n ts_sequence.append((i, i, sentiments[0]))\n sentiments = []\n elif pos == 'B':\n beg = i\n elif pos == 'E':\n end = i\n # schema1: only the consistent sentiment tags are accepted\n # that is, all of the sentiment tags are the same\n if end > beg > -1 and len(set(sentiments)) == 1:\n ts_sequence.append((beg, end, sentiment))\n sentiments = []\n beg, end = -1, -1\n\n # schema2: only consider the sentiment at the beginning of the aspect span\n # if end > beg > -1:\n # ts_sequence.append((beg, end, sentiments[0]))\n # sentiments = []\n # beg, end = -1, -1\n return ot_sequence, ts_sequence", "def bio2ot(ote_tag_sequence, ts_tag_sequence):\n assert len(ote_tag_sequence) == len(ts_tag_sequence)\n new_ote_sequence = bio2ot_ote(ote_tag_sequence=ote_tag_sequence)\n new_ts_sequence = bio2ot_ts(ts_tag_sequence=ts_tag_sequence)\n assert len(new_ote_sequence) == len(ote_tag_sequence)\n assert len(new_ts_sequence) == len(ts_tag_sequence)\n return new_ote_sequence, new_ts_sequence", "def _step2(self, word):\n\n if self.mode == self.NLTK_EXTENSIONS:\n # Instead of applying the ALLI -> AL rule after '(a)bli' per\n # the published algorithm, instead we apply it first, and,\n # if it succeeds, run the result through step2 again.\n if word.endswith(\"alli\") and self._has_positive_measure(\n self._replace_suffix(word, \"alli\", \"\")\n ):\n return self._step2(self._replace_suffix(word, \"alli\", \"al\"))\n\n bli_rule = (\"bli\", \"ble\", self._has_positive_measure)\n abli_rule = (\"abli\", \"able\", self._has_positive_measure)\n\n rules = [\n (\"ational\", \"ate\", self._has_positive_measure),\n (\"tional\", \"tion\", self._has_positive_measure),\n (\"enci\", \"ence\", self._has_positive_measure),\n (\"anci\", \"ance\", self._has_positive_measure),\n (\"izer\", \"ize\", self._has_positive_measure),\n abli_rule if self.mode == self.ORIGINAL_ALGORITHM else bli_rule,\n (\"alli\", \"al\", self._has_positive_measure),\n (\"entli\", \"ent\", self._has_positive_measure),\n (\"eli\", \"e\", self._has_positive_measure),\n (\"ousli\", \"ous\", self._has_positive_measure),\n (\"ization\", \"ize\", self._has_positive_measure),\n (\"ation\", \"ate\", self._has_positive_measure),\n (\"ator\", \"ate\", self._has_positive_measure),\n (\"alism\", \"al\", self._has_positive_measure),\n (\"iveness\", \"ive\", self._has_positive_measure),\n (\"fulness\", \"ful\", self._has_positive_measure),\n (\"ousness\", \"ous\", self._has_positive_measure),\n (\"aliti\", \"al\", self._has_positive_measure),\n (\"iviti\", \"ive\", self._has_positive_measure),\n (\"biliti\", \"ble\", self._has_positive_measure),\n ]\n\n if self.mode == self.NLTK_EXTENSIONS:\n rules.append((\"fulli\", \"ful\", self._has_positive_measure))\n\n # The 'l' of the 'logi' -> 'log' rule is put with the stem,\n # so that short stems like 'geo' 'theo' etc work like\n # 'archaeo' 'philo' etc.\n rules.append(\n (\"logi\", \"log\", lambda stem: self._has_positive_measure(word[:-3]))\n )\n\n if self.mode == self.MARTIN_EXTENSIONS:\n rules.append((\"logi\", \"log\", self._has_positive_measure))\n\n return self._apply_rule_list(word, rules)", "def ot2bio_ote(ote_tag_sequence):\n new_ote_sequence = []\n n_tag = len(ote_tag_sequence)\n prev_ote_tag = '$$$'\n for i in range(n_tag):\n cur_ote_tag = ote_tag_sequence[i]\n assert cur_ote_tag == 'O' or cur_ote_tag == 'T'\n if cur_ote_tag == 'O':\n new_ote_sequence.append(cur_ote_tag)\n else:\n # cur_ote_tag is T\n if prev_ote_tag == 'T':\n new_ote_sequence.append('I')\n else:\n # cur tag is at the beginning of the opinion target\n new_ote_sequence.append('B')\n prev_ote_tag = cur_ote_tag\n return new_ote_sequence", "def step2(self):\n\t\tif self.b[self.k - 1] == 'a':\n\t\t\tif self.ends(\"ational\"): self.r(\"ate\")\n\t\t\telif self.ends(\"tional\"): self.r(\"tion\")\n\t\telif self.b[self.k - 1] == 'c':\n\t\t\tif self.ends(\"enci\"):\t self.r(\"ence\")\n\t\t\telif self.ends(\"anci\"): self.r(\"ance\")\n\t\telif self.b[self.k - 1] == 'e':\n\t\t\tif self.ends(\"izer\"):\t self.r(\"ize\")\n\t\telif self.b[self.k - 1] == 'l':\n\t\t\tif self.ends(\"bli\"):\t self.r(\"ble\") # --DEPARTURE--\n\t\t\t# To match the published algorithm, replace this phrase with\n\t\t\t#\tif self.ends(\"abli\"):\t self.r(\"able\")\n\t\t\telif self.ends(\"alli\"): self.r(\"al\")\n\t\t\telif self.ends(\"entli\"): self.r(\"ent\")\n\t\t\telif self.ends(\"eli\"):\t self.r(\"e\")\n\t\t\telif self.ends(\"ousli\"): self.r(\"ous\")\n\t\telif self.b[self.k - 1] == 'o':\n\t\t\tif self.ends(\"ization\"): self.r(\"ize\")\n\t\t\telif self.ends(\"ation\"): self.r(\"ate\")\n\t\t\telif self.ends(\"ator\"): self.r(\"ate\")\n\t\telif self.b[self.k - 1] == 's':\n\t\t\tif self.ends(\"alism\"):\t self.r(\"al\")\n\t\t\telif self.ends(\"iveness\"): self.r(\"ive\")\n\t\t\telif self.ends(\"fulness\"): self.r(\"ful\")\n\t\t\telif self.ends(\"ousness\"): self.r(\"ous\")\n\t\telif self.b[self.k - 1] == 't':\n\t\t\tif self.ends(\"aliti\"):\t self.r(\"al\")\n\t\t\telif self.ends(\"iviti\"): self.r(\"ive\")\n\t\t\telif self.ends(\"biliti\"): self.r(\"ble\")\n\t\telif self.b[self.k - 1] == 'g': # --DEPARTURE--\n\t\t\tif self.ends(\"logi\"):\t self.r(\"log\")\n\t\t# To match the published algorithm, delete this phrase", "def post(self):\n args = change_tag_or_sentiment_parser.parse_args() \n sentence = args[\"sentence\"]\n value = args[\"value\"]\n whether_allowed = args[\"whether_allowed\"]\n\n if not whether_allowed:\n return {\"success\": False,\n \"error\": True,\n \"messege\": \"Right now, Updating Tags or sentiments are not allowed\",\n }\n\n\n tag_list = [\"food\", \"service\", \"cost\", \"null\", \"ambience\", \"overall\"]\n sentiment_list = [\"positive\", \"super-positive\", \"neutral\", \"negative\", \"super-negative\", \"mixed\"]\n\n print value, sentence\n if not value in (tag_list+sentiment_list):\n return {\"success\": False,\n \"error\": True,\n \"messege\": \"Error occured\",\n }\n\n if value in [\"food\", \"service\", \"cost\", \"null\", \"ambience\", \"overall\"]:\n training_tag_collection.update({\"sentence\": sentence}, {\"$set\": {\n \"review_id\": \"misc\",\n \"tag\": value, }}, upsert=True)\n print \"tag updated\"\n\n if value in [\"positive\", \"super-positive\", \"neutral\", \"negative\", \"super-negative\"]:\n training_sentiment_collection.update({\"sentence\": sentence}, {\"$set\": {\n \"review_id\": \"misc\",\n \"sentiment\": value,\n }}, upsert=True)\n print \"sentiment updated\"\n return {\"success\": True,\n \"error\": False,\n \"messege\": \"Updated!!!\",\n }", "def set_labels(dataset, tagging_schema='BIO'):\n if tagging_schema == 'OT':\n ote_tag_vocab = {'O': 0, 'T': 1}\n ts_tag_vocab = {'O': 0, 'T-POS': 1, 'T-NEG': 2, 'T-NEU': 3}\n elif tagging_schema == 'BIO':\n ote_tag_vocab = {'O': 0, 'B': 1, 'I': 2}\n ts_tag_vocab = {'O': 0, 'B-POS': 1, 'I-POS': 2, 'B-NEG': 3, 'I-NEG': 4,\n 'B-NEU': 5, 'I-NEU': 6}\n elif tagging_schema == 'BIEOS':\n ote_tag_vocab = {'O': 0, 'B': 1, 'I': 2, 'E': 3, 'S': 4}\n ts_tag_vocab = {'O': 0, 'B-POS': 1, 'I-POS': 2, 'E-POS': 3, 'S-POS': 4,\n 'B-NEG': 5, 'I-NEG': 6, 'E-NEG': 7, 'S-NEG': 8,\n 'B-NEU': 9, 'I-NEU': 10, 'E-NEU': 11, 'S-NEU': 12}\n else:\n raise Exception(\"Invalid tagging schema %s\" % tagging_schema)\n n_records = len(dataset)\n for i in range(n_records):\n ote_tags = dataset[i]['ote_raw_tags']\n ts_tags = dataset[i]['ts_raw_tags']\n if tagging_schema == 'OT':\n pass\n elif tagging_schema == 'BIO':\n ote_tags, ts_tags = ot2bio(ote_tag_sequence=ote_tags, ts_tag_sequence=ts_tags)\n elif tagging_schema == 'BIEOS':\n ote_tags, ts_tags = ot2bieos(ote_tag_sequence=ote_tags, ts_tag_sequence=ts_tags)\n else:\n raise Exception(\"Invalid tagging schema %s\" % tagging_schema)\n ote_labels = [ote_tag_vocab[t] for t in ote_tags]\n ts_labels = [ts_tag_vocab[t] for t in ts_tags]\n dataset[i]['ote_tags'] = list(ote_tags)\n dataset[i]['ts_tags'] = list(ts_tags)\n dataset[i]['ote_labels'] = list(ote_labels)\n dataset[i]['ts_labels'] = list(ts_labels)\n return dataset, ote_tag_vocab, ts_tag_vocab", "def TagWithViterbi(_out, _file, _model, _emission_df, _transition_df, _2nd_order_df=None):\n\n # Generate array for possible words\n word_bag = _model.x_y_count\n reader = open(_file, 'r', encoding='utf-8')\n\n # Generate array of arrays for sentences in document\n unlabelled_tweets = []\n temp_data = []\n for line in reader:\n word = line.strip()\n word = word.lower()\n if word == \"\":\n if temp_data: # catch any multiple line breaks\n unlabelled_tweets.append(temp_data)\n temp_data = []\n else:\n temp_data.append(word)\n unlabelled_tweets.append(temp_data)\n\n # Keep a global array of array of results for final\n # most likely states\n results = []\n\n # execute viterbi for each sentence\n for sentence in unlabelled_tweets:\n parsed_sentence = []\n # parse and replace unknowns with #UNK#\n for i in range(len(sentence)):\n if sentence[i] in word_bag:\n parsed_sentence.append(sentence[i])\n else:\n parsed_sentence.append('#UNK#')\n if _2nd_order_df is None:\n result = Viterbi(parsed_sentence, _model, _emission_df, _transition_df)\n else:\n result = Modified_Viterbi(parsed_sentence, _model, _emission_df, _transition_df, _2nd_order_df)\n\n results.append(result)\n\n # write results array into generated file\n writer = open(_out, 'w', encoding='utf-8')\n for i in range(len(unlabelled_tweets)):\n for j in range(len(unlabelled_tweets[i])):\n tweet = unlabelled_tweets[i][j]\n sentiment = results[i][j]\n writer.write('{} {}\\n'.format(tweet, sentiment))\n writer.write('\\n') # empty line denoting end of tweet sentence\n writer.close()\n reader.close()", "def parse_question(question):\n\tcontext = question['support']\n\tanswer = question['correct_answer']\n\ttarget = question['question']\n\n\tcontext_words = context.split(\" \")[0: 510]\n\ttarget_words = target.split(\" \")\n\n\tpunc_filter = str.maketrans('', '', string.punctuation)\n\n\tcontext_words = [word.translate(punc_filter) for word in context_words]\n\ttarget_words = [word.translate(punc_filter) for word in target_words]\n\tanswer_words = [word.translate(punc_filter) for word in answer.split(\" \")]\n\n\tbio_embeddings = [EMBEDER['O']]\n\tinside_answer = False\n\tanswer_index = 0\n\tcan_be_inside_answer = True\n\n\t# The following loop and above code does:\n\t# -Find where the answer is and place a B tag\n\t# -While still in the answer (the answer is more than one word) put an I tag\n\t# -Outside of the answer place a O tag\n\t# -Start and end with an O tag for BERT's automatic\n\t# -start token and end token representing the start and end of a sentence.\n\tfor word in context_words:\n\t\tif word.lower() == answer_words[0].lower() and can_be_inside_answer:\n\t\t\tbio_embeddings.append(EMBEDER[\"B\"])\n\t\t\tanswer_index += 1\n\t\t\tinside_answer = True\n\t\t\tcan_be_inside_answer = False\n\t\telif inside_answer:\n\t\t\tif len(answer_words) > 1:\n\t\t\t\tif word.lower() != answer_words[answer_index]:\n\t\t\t\t\tinside_answer = False\n\t\t\t\t\tbio_embeddings.append(EMBEDER[\"O\"])\n\t\t\t\telse:\n\t\t\t\t\tbio_embeddings.append(EMBEDER[\"I\"])\n\t\t\telse:\n\t\t\t\tinside_answer = False\n\t\t\t\tbio_embeddings.append(EMBEDER[\"O\"])\n\t\telse:\n\t\t\tbio_embeddings.append(EMBEDER[\"O\"])\n\tbio_embeddings.append(EMBEDER[\"O\"])\n\n\tground_truth = torch.tensor([BERT_TOKENIZER.encode(target_words)])\n\tcontext_words = torch.tensor([BERT_TOKENIZER.encode(context_words)])\n\n\tassert len(bio_embeddings) == len(context_words[0]), f'The BIO tags are not equal in length to the embeddings! ' \\\n\t f'{None} & {len(bio_embeddings)} & {len(context_words[0])}'\n\treturn context_words, bio_embeddings, ground_truth", "def _step1b(self, word):\n # this NLTK-only block extends the original algorithm, so that\n # 'spied'->'spi' but 'died'->'die' etc\n if self.mode == self.NLTK_EXTENSIONS:\n if word.endswith(\"ied\"):\n if len(word) == 4:\n return self._replace_suffix(word, \"ied\", \"ie\")\n else:\n return self._replace_suffix(word, \"ied\", \"i\")\n\n # (m>0) EED -> EE\n if word.endswith(\"eed\"):\n stem = self._replace_suffix(word, \"eed\", \"\")\n if self._measure(stem) > 0:\n return stem + \"ee\"\n else:\n return word\n\n rule_2_or_3_succeeded = False\n\n for suffix in [\"ed\", \"ing\"]:\n if word.endswith(suffix):\n intermediate_stem = self._replace_suffix(word, suffix, \"\")\n if self._contains_vowel(intermediate_stem):\n rule_2_or_3_succeeded = True\n break\n\n if not rule_2_or_3_succeeded:\n return word\n\n return self._apply_rule_list(\n intermediate_stem,\n [\n (\"at\", \"ate\", None), # AT -> ATE\n (\"bl\", \"ble\", None), # BL -> BLE\n (\"iz\", \"ize\", None), # IZ -> IZE\n # (*d and not (*L or *S or *Z))\n # -> single letter\n (\n \"*d\",\n intermediate_stem[-1],\n lambda stem: intermediate_stem[-1] not in (\"l\", \"s\", \"z\"),\n ),\n # (m=1 and *o) -> E\n (\n \"\",\n \"e\",\n lambda stem: (self._measure(stem) == 1 and self._ends_cvc(stem)),\n ),\n ],\n )", "def ot2bieos(ote_tag_sequence, ts_tag_sequence):\n # new tag sequences of opinion target extraction and targeted sentiment\n new_ote_sequence = ot2bieos_ote(ote_tag_sequence=ote_tag_sequence)\n new_ts_sequence = ot2bieos_ts(ts_tag_sequence=ts_tag_sequence)\n assert len(ote_tag_sequence) == len(new_ote_sequence)\n assert len(ts_tag_sequence) == len(new_ts_sequence)\n return new_ote_sequence, new_ts_sequence", "def tags_to_spans(tags):\n spans = set()\n span_start = 0\n span_end = 0\n active_conll_tag = None\n for index, string_tag in enumerate(tags):\n # Actual BIO tag.\n bio_tag = string_tag[0]\n assert bio_tag in [\"B\", \"I\", \"O\"], \"Invalid Tag\"\n conll_tag = string_tag[2:]\n if bio_tag == \"O\":\n # The span has ended.\n if active_conll_tag:\n spans.add((active_conll_tag, (span_start, span_end)))\n active_conll_tag = None\n # We don't care about tags we are\n # told to ignore, so we do nothing.\n continue\n elif bio_tag == \"B\":\n # We are entering a new span; reset indices and active tag to new span.\n if active_conll_tag:\n spans.add((active_conll_tag, (span_start, span_end)))\n active_conll_tag = conll_tag\n span_start = index\n span_end = index\n elif bio_tag == \"I\" and conll_tag == active_conll_tag:\n # We're inside a span.\n span_end += 1\n else:\n # This is the case the bio label is an \"I\", but either:\n # 1) the span hasn't started - i.e. an ill formed span.\n # 2) We have IOB1 tagging scheme.\n # We'll process the previous span if it exists, but also include this\n # span. This is important, because otherwise, a model may get a perfect\n # F1 score whilst still including false positive ill-formed spans.\n if active_conll_tag:\n spans.add((active_conll_tag, (span_start, span_end)))\n active_conll_tag = conll_tag\n span_start = index\n span_end = index\n # Last token might have been a part of a valid span.\n if active_conll_tag:\n spans.add((active_conll_tag, (span_start, span_end)))\n # Return sorted list of spans\n return sorted(list(spans), key=lambda x: x[1][0])", "def xml2tokens(xml_tagged_sent, tokenized_sent, raw_sent):\n raw, entities = get_entities(xml_tagged_sent)\n if re.search(r\"ENAMEX\", raw):\n print(xml_tagged_sent)\n print(raw)\n # count += 1\n\n tokens, syllables = word_tokenize(tokenized_sent, raw_sent)\n level1_syl_tags = [\"O\" for i in range(len(syllables))]\n level2_syl_tags = [\"O\" for i in range(len(syllables))]\n level3_syl_tags = [\"O\" for i in range(len(syllables))]\n\n level1_token_tags = [\"O\" for i in range(len(tokens))]\n level2_token_tags = [\"O\" for i in range(len(tokens))]\n level3_token_tags = [\"O\" for i in range(len(tokens))]\n\n flag = False\n for entity in entities:\n value = entity[\"value\"]\n start = entity[\"start\"]\n end = entity[\"end\"]\n entity_type = entity[\"type\"]\n start_syl_id, end_syl_id = find_syl_index(start, end, syllables)\n start_tok_id, end_tok_id = find_tok_index(start_syl_id, end_syl_id, tokens)\n\n if start_syl_id != None and end_syl_id != None:\n if entity[\"level\"] == 1:\n level1_syl_tags[start_syl_id] = \"B-\" + entity_type\n for i in range(start_syl_id + 1, end_syl_id):\n level1_syl_tags[i] = \"I-\" + entity_type\n elif entity[\"level\"] == 2:\n level2_syl_tags[start_syl_id] = \"B-\" + entity_type\n for i in range(start_syl_id + 1, end_syl_id):\n level2_syl_tags[i] = \"I-\" + entity_type\n else:\n level3_syl_tags[start_syl_id] = \"B-\" + entity_type\n for i in range(start_syl_id + 1, end_syl_id):\n level3_syl_tags[i] = \"I-\" + entity_type\n else:\n print(\"{},{},\\\"{}\\\" in '{}' ({})\".format(start,end,value,raw,xml_tagged_sent))\n flag = True\n\n if start_tok_id != None and end_tok_id != None:\n if entity[\"level\"] == 1:\n level1_token_tags[start_tok_id] = \"B-\" + entity_type\n for i in range(start_tok_id+1, end_tok_id):\n level1_token_tags[i] = \"I-\" + entity_type\n elif entity[\"level\"] == 2:\n level2_token_tags[start_tok_id] = \"B-\" + entity_type\n for i in range(start_tok_id + 1, end_tok_id):\n level2_token_tags[i] = \"I-\" + entity_type\n else:\n level3_token_tags[start_tok_id] = \"B-\" + entity_type\n for i in range(start_tok_id + 1, end_tok_id):\n level3_token_tags[i] = \"I-\" + entity_type\n else:\n pass\n # print(\"{},{},\\\"{}\\\" in '{}' ({})\".format(start_syl_id, end_syl_id, value, raw, xml_tagged_sent))\n\n ret_syllables = list(zip([ s.text for s in syllables], level1_syl_tags, level2_syl_tags, level3_syl_tags))\n ret_tokens = list(zip( [tk.text for tk in tokens], level1_token_tags, level2_token_tags, level3_token_tags))\n return ret_syllables, ret_tokens, raw, flag", "def to_conll_iob(annotated_sentence):\n proper_iob_tokens = []\n for idx, annotated_token in enumerate(annotated_sentence):\n tag, word, ner = annotated_token\n\n if ner != 'O':\n if idx == 0:\n ner = \"B-\" + ner\n elif annotated_sentence[idx - 1][2] == ner:\n ner = \"I-\" + ner\n else:\n ner = \"B-\" + ner\n proper_iob_tokens.append((tag, word, ner))\n return proper_iob_tokens", "def to_conll_iob(annotated_sentence):\n proper_iob_tokens = []\n for idx, annotated_token in enumerate(annotated_sentence):\n tag, word, ner = annotated_token\n\n if ner != 'O':\n if idx == 0:\n ner = \"B-\" + ner\n elif annotated_sentence[idx - 1][2] == ner:\n ner = \"I-\" + ner\n else:\n ner = \"B-\" + ner\n proper_iob_tokens.append((tag, word, ner))\n return proper_iob_tokens", "def upgradeToVersion2(self):\n log.debug(u\"Upgrading iDevice\")\n self.emphasis = Idevice.SomeEmphasis", "def process_tags(self):\n nolf = self.unixtext.replace(\"\\n\", \" \")\n res = EMERGENCY_RE.findall(nolf)\n if res:\n # TODO: this can be based off the IBW Tags too\n self.is_emergency = True\n match = WINDHAIL.match(nolf)\n if match:\n gdict = match.groupdict()\n self.windtag = gdict['wind']\n self.windtagunits = gdict['windunits']\n self.haildirtag = gdict['haildir']\n self.winddirtag = gdict['winddir']\n self.hailtag = gdict['hail']\n\n match = WINDTAG.match(nolf)\n if match:\n gdict = match.groupdict()\n self.winddirtag = gdict['winddir']\n self.windtag = gdict['wind']\n self.windtagunits = gdict['windunits']\n\n match = HAILTAG.match(nolf)\n if match:\n gdict = match.groupdict()\n self.haildirtag = gdict['haildir']\n self.hailtag = gdict['hail']\n\n match = TORNADOTAG.match(nolf)\n if match:\n gdict = match.groupdict()\n self.tornadotag = gdict['tornado']\n\n match = TORNADODAMAGETAG.match(nolf)\n if match:\n gdict = match.groupdict()\n self.tornadodamagetag = gdict['damage']\n\n match = WATERSPOUTTAG.match(nolf)\n if match:\n gdict = match.groupdict()\n self.waterspouttag = gdict['waterspout']\n\n for token in FLOOD_TAGS.findall(self.unixtext):\n self.flood_tags[token[0]] = token[1]", "def word2features(self,sent, i):\n word = sent[i][0]\n #postag = sent[i][1]\n\n features = {\n 'bias': 1.0,\n 'word.lower()': word.lower(),\n 'word.isupper()': word.isupper(),\n 'word.istitle()': word.istitle(),\n 'word.isdigit()': word.isdigit(),\n 'word.shape()':self.shape(word),\n 'word.isalnum()':word.isalnum(),\n 'word.isalpha()':word.isalpha(),\n # 'postag': postag,\n # 'postag[:2]': postag[:2],\n }\n if i > 0:\n word1 = sent[i - 1][0]\n #postag1 = sent[i - 1][1]\n features.update({\n '-1:word.lower()': word1.lower(),\n '-1:word.istitle()': word1.istitle(),\n '-1:word.isupper()': word1.isupper(),\n '-1:word.isdigit()': word1.isdigit(),\n '-1:word.isalnum()':word1.isalnum(),\n '-1:word.isalpha()':word1.isalpha(),\n # '-1:postag': postag1,\n # '-1:postag[:2]': postag1[:2],\n })\n else:\n features['BOS'] = True\n\n if i > 1:\n word2 = sent[i - 2][0]\n #postag2 = sent[i - 2][1]\n features.update({\n '-2:word.lower()': word2.lower(),\n '-2:word.istitle()': word2.istitle(),\n '-2:word.isupper()': word2.isupper(),\n '-2:word.isdigit()': word2.isdigit(),\n '-2:word.isalnum()': word2.isalnum(),\n '-2:word.isalpha()': word2.isalpha(),\n # '-2:postag': postag2,\n # '-2:postag[:2]': postag2[:2],\n })\n else:\n features['BOS1'] = True\n if i > 2:\n word3 = sent[i - 3][0]\n #postag3 = sent[i - 3][1]\n features.update({\n '-3:word.lower()': word3.lower(),\n '-3:word.istitle()': word3.istitle(),\n '-3:word.isupper()': word3.isupper(),\n '-3:word.isdigit()': word3.isdigit(),\n '-3:word.isalnum()': word3.isalnum(),\n '-3:word.isalpha()': word3.isalpha(),\n # '-3:postag': postag3,\n # '-3:postag[:2]': postag3[:2],\n })\n else:\n features['BOS2'] = True\n\n if i > 3:\n word4 = sent[i - 4][0]\n #postag4 = sent[i - 4][1]\n features.update({\n '-4:word.lower()': word4.lower(),\n '-4:word.istitle()': word4.istitle(),\n '-4:word.isupper()': word4.isupper(),\n '-4:word.isdigit()': word4.isdigit(),\n '-4:word.isalnum()': word4.isalnum(),\n '-4:word.isalpha()': word4.isalpha(),\n # '-4:postag': postag4,\n # '-4:postag[:2]': postag4[:2],\n })\n else:\n features['BOS2'] = True\n\n if i < len(sent) - 1:\n word1 = sent[i + 1][0]\n features.update({\n '+1:word.lower()': word1.lower(),\n '+1:word.istitle()': word1.istitle(),\n '+1:word.isupper()': word1.isupper(),\n '+1:word.isdigit()': word1.isdigit(),\n '+1:word.isalnum()': word1.isalnum(),\n '+1:word.isalpha()': word1.isalpha(),\n # '+1:postag': postag1,\n # '+1:postag[:2]': postag1[:2],\n })\n else:\n features['EOS'] = True\n if i < len(sent) - 2:\n word12 = sent[i + 2][0]\n #postag12 = sent[i + 2][1]\n features.update({\n '+2:word.lower()': word12.lower(),\n '+2:word.istitle()': word12.istitle(),\n '+2:word.isupper()': word12.isupper(),\n '+2:word.isdigit()': word12.isdigit(),\n '+2:word.isalnum()': word12.isalnum(),\n '+2:word.isalpha()': word12.isalpha(),\n # '+2:postag': postag12,\n # '+2:postag[:2]': postag12[:2],\n })\n else:\n features['EOS2'] = True\n if i < len(sent) - 3:\n word13 = sent[i + 3][0]\n #postag13 = sent[i + 3][1]\n features.update({\n '+3:word.lower()': word13.lower(),\n '+3:word.istitle()': word13.istitle(),\n '+3:word.isupper()': word13.isupper(),\n '+3:word.isdigit()': word13.isdigit(),\n '+3:word.isalnum()': word13.isalnum(),\n '+3:word.isalpha()': word13.isalpha(),\n # '+3:postag': postag13,\n # '+3:postag[:2]': postag13[:2],\n })\n else:\n features['EOS2'] = True\n if i < len(sent) - 4:\n word14 = sent[i + 4][0]\n #postag14 = sent[i + 4][1]\n features.update({\n '+4:word.lower()': word14.lower(),\n '+4:word.istitle()': word14.istitle(),\n '+4:word.isupper()': word14.isupper(),\n '+4:word.isdigit()': word14.isdigit(),\n '+4:word.isalnum()': word14.isalnum(),\n '+4:word.isalpha()': word14.isalpha(),\n # '+4:postag': postag14,\n # '+4:postag[:2]': postag14[:2],\n })\n else:\n features['EOS2'] = True\n return features", "def ot2bio_ts(ts_tag_sequence):\n new_ts_sequence = []\n n_tag = len(ts_tag_sequence)\n prev_pos = '$$$'\n for i in range(n_tag):\n cur_ts_tag = ts_tag_sequence[i]\n if cur_ts_tag == 'O':\n new_ts_sequence.append('O')\n cur_pos = 'O'\n else:\n # current tag is subjective tag, i.e., cur_pos is T\n # print(cur_ts_tag)\n cur_pos, cur_sentiment = cur_ts_tag.split('-')\n if cur_pos == prev_pos:\n # prev_pos is T\n new_ts_sequence.append('I-%s' % cur_sentiment)\n else:\n # prev_pos is O\n new_ts_sequence.append('B-%s' % cur_sentiment)\n prev_pos = cur_pos\n return new_ts_sequence", "def disambiguateWordsOld(self, word_list, tag_list):\n\t\t# print u\" \".join(word_list).encode('utf8');\n\t\t# print u\" \".join(tag_list).encode('utf8');\t\t\t\n\t\n\t\tif len(word_list)==0 or len(word_list)!=len(tag_list):\n\t\t\treturn word_list;\n\t\telse:\n\t\t\tnewwordlist=[];\n\t\t\twordtaglist=zip(word_list,tag_list);\n\t\t\t# print wordtaglist\n\t\t\tfor i in range(len(wordtaglist)):\n\t\t\t\tif i+1<=len(wordtaglist):\n\t\t\t\t\t# do tests with next word\n\t\t\t\t\t# إذا كانت الكلمة الحالية \"أن\" تكون \"أنْ\" حرف نصب إذا سبقت فعلا\n\t\t\t\t\t# وتكون أنّ، من أخوات إنّ إذا كان ما بعدها اسما\n\t\t\t\t\tif wordtaglist[i][0]==u'أن' and self.tagger.isVerbTag(wordtaglist[i+1][1]):\n\t\t\t\t\t\t# print' case1';\n\t\t\t\t\t\twordtaglist[i]=(u'أَنْ','t');\n\t\t\t\t\telif wordtaglist[i][0]==u'أن' and self.tagger.isNounTag(wordtaglist[i+1][1]):\n\t\t\t\t\t\t# print' case 2';\n\t\t\t\t\t\twordtaglist[i]=(u'أَنَّ','t');\n\t\t\t\tnewwordlist.append(wordtaglist[i][0]);\n\t\t\treturn newwordlist;", "def intf_ENTTAG(E):\n if not inc.entid_or_LST_of_entids(E.The,2) or not inc.TXT_or_LST_of_TXTs(E.The,1):\n print(\"Input Error: tag\")\n print(intf_ENTTAG.__doc__)\n return # Without doing much of anything.\n refreshview= False # No need unless view attributes (@) have been set.\n mytags= E.The.StackPop().val\n if type(mytags)==type(list()):\n #mytags= map(lambda x:x.val, mytags) # Should now be a list of TXTs.\n mytags= [x.val for x in mytags] # Should now be a list of TXTs.\n else:\n mytags= [ mytags ] # Also a (1 item) list of ints.\n myeids= E.The.StackPop().val\n if type(myeids)==type(list()):\n #myeids= map(lambda x:x.val, myeids) # Should now be a list of VALs.\n myeids= [x.val for x in myeids] # Should now be a list of VALs.\n else:\n myeids= [ myeids ] # Also a (1 item) list of ints.\n for myeid in myeids:\n if myeid in MMEL.El: # Check if eid exists.\n for mytag in mytags:\n if len(mytag) > 1 and '@' == mytag[1]:\n refreshview= True\n existing_att_tags= MMEL.El[myeid].has_tag_starting_with(mytag[0:2])\n if existing_att_tags:\n for et in existing_att_tags:\n MMEL.El[myeid].del_tag(et)\n print(\"Tagging entity #%d with tag ''%s''\" % (myeid,mytag))\n if not MMEL.El[myeid].has_tag(mytag):\n MMEL.El[myeid].add_tag(mytag)\n else:\n print(\"Warning: No entity #%d. Skipping.\" % myeid)\n if refreshview: OUT.default(MMEL,E) # AUTODUMP " ]

[ "0.75835204", "0.6604394", "0.6375619", "0.63179696", "0.5746531", "0.55641425", "0.5533739", "0.5410123", "0.53316265", "0.5255677", "0.5166876", "0.5161488", "0.5138688", "0.5126411", "0.5123757", "0.5066761", "0.50608045", "0.5048021", "0.50355095", "0.502674", "0.5022408", "0.50045365", "0.49989477", "0.49989477", "0.4996606", "0.4994544", "0.49691132", "0.49617973", "0.494079", "0.4908185" ]

[ "def ask_again(self, wrong_info):\n return input(f\"Wrong {wrong_info}, please try again: \")", "def on_fail(utterance):\n\n self.log.info(\"Utterance: {}\".format(utterance))\n\n user_response = self.ask_yesno('try.again')\n\n return 'try.again' if user_response is None else 'okay'", "def to_main(self):\n num_attempts = 0\n max_try = 10\n\n while not self._in_main():\n if self._in_exam():\n self._exit_exam()\n else:\n self.finger.back()\n num_attempts += 1\n if num_attempts >= max_try: # failsafe\n input(\"I'm lost! Please help me go to main page! Hit Enter to continue\")", "def again():\r\n\tif_again = ask_yes_no(\"\\nDo you want play again (press y or n) \")\r\n\tif if_again == \"y\":\r\n\t\tprint(\"\\n\\n\")\r\n\t\tmain()\r\n\telif if_again == \"n\":\r\n\t\tprint(\"\\nThank you for your time spared for this game. Good bye!\")", "def build_faillure(request, string):\n return HttpResponseRedirect(\"{}?why={}\".format(settings.TEQUILA_FAILURE, string))", "def game_over(user_name, answer, correct_answer):\n print(\"'{0}' is wrong answer ;(. Correct answer was '{1}'.\"\n .format(answer, correct_answer))\n print(\"Let's try again, {0}!\".format(user_name))", "def tryAgain(): \n\tglobal toGuess\n\tglobal output\n\ttryAgain = raw_input(\"Try again? y/n\\n\")\n\tif tryAgain == \"y\" or tryAgain == \"Y\":\n\t\ttoGuess = wordLook()\n\t\tplayer.guessedLetters = []\n\t\tplayer.correctLetters = []\n\t\tplayer.triesLeft = 10\n\t\toutput = ['_'] * len(toGuess)\n\t\thangMan()\n\telif tryAgain == \"n\" or tryAgain == \"N\":\n\t\tprint \"That's a shame! See you next time :)\"\n\t\tquit()\n\telse:\n\t\tprint \"Input not accepted...\"\n\t\ttryAgain()", "def forgot_passwd_done(request):\n return render(request, 'gui/note.html', {\n 'header': _('Password reset instructions!'),\n 'blocks': (\n _('We\\'ve emailed you instructions for setting your password. You should be receiving them shortly.'),\n _('If you don\\'t receive an email, please make sure you\\'ve entered the address you registered with, and '\n 'check your spam folder.'),\n )\n })", "def try_again(self):\n font = pygame.font.Font(None, CASE_SIZE)\n text = font.render('Press (y) to play again or' \\\n , True,(255, 255, 255), (0, 0, 0))\n self.screen.blit(text,(CASE_SIZE * 4, CASE_SIZE * 8))\n font = pygame.font.Font(None, CASE_SIZE)\n text = font.render('press (n) to quit' \\\n , True,(255, 255, 255), (0, 0, 0))\n self.screen.blit(text,(CASE_SIZE * 5, CASE_SIZE * 9))", "def page_not_found(e):\n flash(\"Error: Try Something Different This Time\")\n return redirect(url_for('login'))", "def forgot_passwd_check_done(request):\n dc1_settings = DefaultDc().settings\n\n if dc1_settings.SMS_REGISTRATION_ENABLED:\n text_blocks = (_('Your password has been reset and send to your phone number via text message (SMS).'),)\n else:\n text_blocks = ()\n\n return render(request, 'gui/note.html', {\n 'header': _('Password reset!'),\n 'blocks': text_blocks,\n 'links': ({'label': 'You may go ahead and log in now.', 'url': reverse('login')},),\n })", "def errorview(request):\n \n #return a page indicating an error has occured\n return render(request, 'SmellGuessTemplate/error.html')", "def welcome(request):\n return render(request, 'code_challenge/welcome.html', {})", "def incorrect_guess(rand_number):\n \n print(\"\\nSorry! You are out of attempts. The number I was thinking of was \"\n + str(rand_number) + \".\")\n print(\"You can try again starting at the menu...\")\n \n # Clears the console after a 3 second delay, then restarts game\n console_clear(3) \n game_start()", "def login_index():\n try:\n err_id = request.args['err_id']\n except:\n err_id = '0'\n if err_id == '1':\n error_message = 'Wrong username! Please make sure your username is right or you have registered before.'\n elif err_id == '2':\n error_message = 'Wrong password! Please type again with correct one!'\n else:\n error_message = ''\n if check_login():\n did_login = True\n else:\n did_login = False\n if not did_login: \n \"\"\"show login page\"\"\"\n return render_template(\"login/login.html\", message=error_message)\n else:\n \"\"\"jump to manage page\"\"\"\n return redirect(url_for('manage.manage_index'))", "def hello():\n return redirect( 'http://plus.google.com/hangouts/_?gid=504880202642')", "def display_help_screen():\r\n\tsys.exit(0)", "def page_not_found(e):\n\treturn 'Sorry, No Valid Game There.', 404", "def play_again(s):\r\n again = input(\"Do you want to play again? \\ntype yes or no \\n\")\r\n if again == 'yes':\r\n duck_shooting1()\r\n elif again == 'no':\r\n print(\"Your final score was:\", s, \" \\nGoodbye, have a nice life\")\r\n else:\r\n print(\"Incorrect input. Please start from the beginning\")\r\n introduction()", "def try_again(niv):\n wait = True\n answer = 0 #(0 = Yes , 1 = No)\n sense.show_message('Try again?',\n text_colour=WHITE,scroll_speed=0.05)\n sense.show_letter('Y',\n text_colour=WHITE)\n while wait == True:\n for event in sense.stick.get_events():\n if event.action == 'pressed':\n if event.direction == 'left': #select to try again by clicking on the left\n if answer >= 1:\n answer = answer - 1\n sense.show_letter('Y',\n text_colour=WHITE)\n else:\n pass\n elif event.direction == 'right': #select to go back to main menuby clicking on the right\n if answer <= 0:\n answer = answer + 1\n sense.show_letter('N',\n text_colour=WHITE)\n else:\n pass\n elif event.direction == 'middle': #applies the selection by clicking on the middle.\n wait = False\n if answer == 0:\n start_level(niv)\n elif answer == 1:\n main()\n else: #If the player moves up or down, it goes back to main menu.\n main()", "def regularpage(pagename=None): \n return \"You've arrived at \" + pagename\n #if pagename==None: \n # raise Exception, 'page_not_found' \n #return render_template(pagename) ", "def thank_you():\n\n return redirect('/thankyou')", "def say_thanks():\n return render_template(\"completion.html\")", "def determine_attempts():\r\n #Inputs: # of attempts requested by user\r\n #Outputs: game gives number of attempts user selected before ending \r\n how_many_tries = int(raw_input(\"How many attempts do you want to answer a blank correctly before the answer is provided to you? Please provide a number, such as 2.\\n\"))\r\n attempts = how_many_tries\r\n number_of_tries = 5\r\n while how_many_tries < 1:\r\n print \"Please try again.\"\r\n determine_attempts\r\n attempts = attempts + 1\r\n if attempts == number_of_tries:\r\n break \r\n else:\r\n print \"Please read the paragraph below and provide the answers to fill in the numbered blanks.\\nYou will be given \" + str(attempts) + \" chances to enter the correct answer before it is provided to you.\\n\"\r\n return how_many_tries", "def playagain():\n if input(\"Would you like to play again (Yes/No)? \").lower().startswith(\"y\"):\n main()\n else:\n print(\"Leaving soon, we will miss you\", \"\\U0001F97A\")\n print(colored(\"Thanks for playing, Made with \\u2665 by g-paras\", \"blue\"))", "def loseGame():\n\tif player.triesLeft == 0:\n\t\tprint \"You lose! the word was: %s\" % strings\n\t\ttryAgain()\n\telif player.triesLeft > 0:\n\t\thangMan()\n\telse:\n\t\tprint \"Error in loseGame()\"", "def show_lucky_num():\r\n num = random.randint(1, 10)\r\n\r\n return render_template(\"lucky.html\", lucky_num=num, msg=\"Hello this is a message!\")", "def restart():\n msg = messagebox.showinfo('YES!', \"You're Right\")\n window.destroy()\n game()", "def game():\n\tif \"username\" in session:\n\t\treturn render_template(\"index.html\")\n\telse:\n\t\treturn redirect(url_for(\"default\"))", "def default(self, *args, **kwargs):\n Page = startHTML + \"I don't know where you're trying to go, so have a 404 Error.\"\n cherrypy.response.status = 404\n return Page" ]

[ "0.6091591", "0.60179615", "0.60155046", "0.5943941", "0.59362453", "0.58752775", "0.5838683", "0.5830095", "0.58006173", "0.5692293", "0.5689304", "0.5579053", "0.5545659", "0.55337924", "0.5531429", "0.5526757", "0.5498794", "0.54846203", "0.5453377", "0.54490054", "0.537795", "0.53756917", "0.53742325", "0.5337637", "0.5321826", "0.53193134", "0.5295567", "0.5288144", "0.5287471", "0.52845174" ]

[ "def getschool(s,refconvdf,schooltaglist): \r\n taglist=gettotaltags(s,refconvdf) \r\n schoolname=list(set(schooltaglist.name.values).intersection(taglist)) \r\n if not schoolname:#check if empty \r\n return 'None'\r\n else:\r\n return schoolname\r\n \r\n #some conversation might be forward by admin through email and thus not suitable to check user for details.\r\n #KIV for further work \r\n #userid=convdf[(convdf.convid==s)& (convdf.idx_conv==0)].author.values[0]\r\n #print('Missing schoolname - trying to get')\r\n #try: \r\n # schoolname=User.find(id=userid).custom_attributes['School Name']\r\n # return schoolname\r\n #except KeyError:\r\n # return None\r\n \r\n #if numtags==0:# check user if empty tag list\r\n # userid=convdf[(convdf.convid==s)& (convdf.idx_conv==0)].author.values[0]\r\n # return User.find(id=userid).custom_attributes['School Name']\r\n #else:\r\n # schoolname=list(set(schooltag.name.values).intersection(taglist))\r\n # return schoolname\r", "async def school(self, ctx:commands.Context, *school_name):\r\n\r\n school_name = ' '.join(school_name)\r\n if not school_name in list(self.fish_schools.keys()):\r\n await ctx.send(f'{school_name} is not a valid school')\r\n return\r\n\r\n curr_school = self.fish_schools[school_name]\r\n member_school = (await self.config.member(ctx.message.author).schools()).get(school_name, {})\r\n description = ''\r\n for i in curr_school:\r\n description += (f'{i}: {member_school[i]} inches' if i in member_school else '???') + '\\n'\r\n embed = Embed(title=school_name, description=description[:-1])\r\n embed.set_thumbnail(url=schools_image)\r\n await ctx.send(embed=embed)", "def get_team_slug_name(project_name, role):\n sanitized_role = pluralized(role).replace(\"Project \", \"\")\n team_name = f\"CT: {project_name} {sanitized_role}\"\n team_slug = slugified(team_name)\n return team_slug, team_name", "def college_names(soup):\n\n school_name_selector = (\n 'html #search-profile #page-wrapper '\n 'div#content-wrapper div#searchleftcol div.searchcontent '\n 'table.tbl-profile tbody.basic-info tr th')\n\n th_elements = soup.select(school_name_selector)\n try:\n school_name = th_elements[-1].text\n # For a handfull of files, a semicolon is not\n # present in the html file, but gets inserted.\n school_name = school_name.replace(\";\", \"\")\n except IndexError:\n return None\n\n return school_name.strip()", "def school_from_short_name(function):\n def wrapped(request, school_short_name):\n try:\n school = SchoolAccount.objects.get(short_name=school_short_name)\n except SchoolAccount.DoesNotExist:\n return HttpResponseNotFound('No school registered with given name (%s)' % school_short_name)\n except SchoolAccount.MultipleObjectsReturned:\n django.core.mail.mail_admins('School registration conflict', 'Multiple schools registered with name %s.' % school_short_name, fail_silently=True)\n return HttpResponseServerError('Internal error: multiple schools registered with given name')\n\n return function(request, school)\n\n return wrapped", "def get_school(self, name: str) -> School:\n\n schools = self.get_schools()\n f = lambda school, name: school.name == name\n\n idx = [idx for idx, school in enumerate(schools) if f(school, name)]\n\n return schools[idx[0]] if idx else None", "def team_name(self):\n return 'Team Name'", "def describe_workteam(WorkteamName=None):\n pass", "def get_team_names(self, year1, year2):\n\n base_url = 'http://www.sports-reference.com/cbb/schools/'\n response = urllib2.urlopen(base_url)\n content = response.read()\n soup = BeautifulSoup(content, 'html.parser')\n soup_results = soup.findAll('tr', {'class':''})\n extract_name = lambda name: name.split('/')[3]\n team_names = []\n \n for result in soup_results[1::]:\n year_span = result.findAll('td', {'align':'center'}) \n year_span = map(int, [year.string for year in year_span])\n\n if year_span[0] <= year1 and year_span[1] >= year2:\n team_name = result.find('a', href = True).get('href')\n team_name = extract_name(team_name)\n team_names.append(str(team_name))\n\n self.team_names = team_names", "def get_team(team):\n if team == \"left\":\n return \"0\"\n elif team == \"right\":\n return \"1\"\n elif team == \"spec\":\n return \"-1\"", "def teamname(record):\n\n tname = \"\"\n if record and record.name:\n tname = \"%s \" % record.name.strip()\n return tname", "def get_school_name_urls():\n\tschools_tree = get_tree(\"http://www.gla.ac.uk/schools/\")\n\tns = 'http://exslt.org/regular-expressions'\n\tpath = '//div[@class=\"row standardContent\"]//a[re:match(@href, \"schools/[A-Za-z]+/\")]'\n\t# Get all the <a> elements on the page which link to a school page\n\ta_elems = schools_tree.xpath(path, namespaces={'re':ns})\n\tbase_url = \"http://www.gla.ac.uk\"\n\turls = []\n\tnames = []\n\n\tfor a in a_elems:\n\t\t# make school staff page url\n\t\tstaff_page_url = base_url + a.get(\"href\") + \"staff/\"\n\t\turls.append(staff_page_url)\n\t\t# get name of school\n\t\tschool_name = a.text\n\t\tnames.append(school_name)\n\n\t# create list of tuples\n\tschool_names_urls = zip(names, urls)\n\treturn school_names_urls", "def ParseTeam(team_str):\n fd_team_code = team_str[3:-4] if '<b>' in team_str else team_str\n return {\n 'SA': 'SAS',\n 'NO': 'NOP',\n 'GS': 'GSW',\n 'NY': 'NYK',\n 'BKN': 'BRK',\n 'CHA': 'CHO',\n }.get(fd_team_code, fd_team_code)", "def get_team_roster(league):\n pass", "def code_to_name(code):\n upper_code = code.upper()\n if upper_code in code_dict:\n return code_dict[upper_code]\n else:\n return code", "def county_name(zipcode): \n search = SearchEngine(simple_zipcode=True) # set simple_zipcode=False to use rich info database\n zipcode_query = search.by_zipcode(str(zipcode))\n zipcode_query_dict = zipcode_query.to_dict()\n county = zipcode_query_dict['county']\n if county is None:\n print('Invalid County')\n else :\n if 'County' in county:\n county = county[:-7]\n if county in county_list:\n print('County is County List')\n print(county)\n return county", "def get_league_name(wd):\n try:\n league = wd.find_element_by_xpath('/html/body/div[4]/div[5]/div/div/div[1]/section/header/h1/a').text\n # There used to be cleaning to letters but there can be years of league (and endings like league 1)\n return league\n except:\n return \"N/A League\"", "def choose_school():\n if current_user.is_administrator():\n schools = School.query.order_by(School.long_name)\n else:\n schools = current_user.schools_coached\n\n # if initial get request, render add_school.html\n return render_template('choose_school.html', schools=schools)", "def get_paper_school_info(paper_url):\n\n\tpaper_tree = get_tree(paper_url)\n\t# XPath to extract the school info\n\tpath = '//table/tr/th[text() = \"College/School:\"]/following-sibling::td/a/text()'\n\t# This gives us a list of strings with school info (a paper may be associated to more than one school)\n\tschool_info = paper_tree.xpath(path)\n\t# Join list to return the information as a single string string\n\tschl_info_string = \"\\n\".join(school_info)\n\n\treturn schl_info_string", "def get_student():\n\n github = request.args.get('github')\n if not github:\n return \"Please enter a student!\"\n\n student = hackbright.get_student_by_github(github)\n\n grades = hackbright.get_grades_by_github(github)\n\n if not student:\n return \"There is no student with github \\\"{}\\\".\".format(github)\n\n first, last, github = student\n # return \"{acct} is the GitHub account for {first} {last}\".format(\n # acct=github, first=first, last=last)\n html = render_template(\"student_info.html\",\n first=first,\n last=last,\n github=github,\n grades=grades)\n return html", "def get_team_id(team_name):\n\n team_name = team_name.lower()\n endpoint = \"/teams\"\n response = api.nhl_api(endpoint)\n\n if not response:\n raise ConnectionError(\"An invalid response was returned from the NHL Teams API.\")\n\n teams_json = response.json()\n teams = teams_json[\"teams\"]\n\n team_id = None\n for team in teams:\n if team[\"name\"].lower() == team_name:\n team_id = team[\"id\"]\n break\n\n if not team_id:\n raise ValueError(\"{} is not a valid NHL team. Check your configuraiton file!\".format(team_name))\n\n return team_id", "def get_student_name(student_information):\n return student_information[0]", "def get_name_of_same_named_teams(sname, sid):\n\n if sname == 'Zamora':\n if sid == 9404:\n return 'Zamora FC' # Venezuela\n elif sid == 26394:\n return 'Zamora CF' # Spain\n else:\n logger.error('Sportmonk ids for same named teams \"%s\" have changed', sname)\n return sname\n elif sname == 'Atromitos':\n if sid == 9849:\n return 'Atromitos A.' # Greece\n elif sid == 2953:\n return 'Atromitos Yeroskipou' # Cyprus\n else:\n logger.error('Sportmonk ids for same named teams \"%s\" have changed', sname)\n return sname\n elif sname == 'Atromitos/H.': # sid 9842\n return None\n elif sname == 'Libertas':\n if sid == 11019:\n return 'Libertas Novska' # Croatia\n elif sid == 19357:\n return 'A.C Libertas' # San Marino\n else:\n logger.error('Sportmonk ids for same named teams \"%s\" have changed', sname)\n return sname\n elif sname == 'Irtysh':\n if sid == 4000:\n return 'Irtysh Omsk' # Russia\n elif sid == 11058:\n return 'Irtysh Pavlodar' # Kazakstan\n else:\n logger.error('Sportmonk ids for same named teams \"%s\" have changed', sname)\n return sname\n elif sname == 'Linense':\n if sid == 7812:\n return 'Atletico Linense' # Brazil\n elif sid == 26006:\n return 'Real Balompedica Linense' # SPain\n else:\n logger.error('Sportmonk ids for same named teams \"%s\" have changed', sname)\n return sname\n elif sname == 'Sorrento':\n if sid == 10773:\n return 'Sorrento FC' # Australia\n elif sid == 24305:\n return 'F.C. Sorrento' # Italy\n else:\n logger.error('Sportmonk ids for same named teams \"%s\" have changed', sname)\n return sname\n else:\n return sname", "def ask_for_valid_school_id(name: str, classroom: Classroom) -> Optional[Student]:\n msg = f'<b>{name}</b> not found.'\n echo(msg, format=True)\n\n while True:\n school_id = ask('School id: ', default=None)\n if school_id is None:\n if ask('Skip student? ', type=bool):\n echo()\n return None\n else:\n continue\n\n try:\n student = Student(name, school_id)\n classroom.students.add(student)\n classroom.save()\n return student\n except ValueError:\n echo(f'School id exists for {student.display}')\n if ask('Reuse? ', type=bool):\n student = classroom.students.get(school_id=school_id)\n student.aliases.append(student.name)\n classroom.save()\n echo()\n return None", "def validate_register_team():\n team = request.args.get('team')\n school_name = request.args.get('school')\n if not team:\n # No team name\n return jsonify({'valid': False, 'error': 'Please specify a team name'})\n\n school = School.query.filter(School.name.ilike(school_name)).first()\n team = Team.query.filter(Team.name.ilike(team)).first()\n if team and school:\n if team.school.id != school.id:\n # The team is already registered to another school\n return jsonify({'valid': False, 'error': 'Sorry, that team name is already registered at another school'})\n if team and len(team.users) == 2:\n # The team alread is full\n return jsonify({'valid': False, 'error': 'Sorry, that team is already full (limit of 2 students per team)'})\n return jsonify({'valid': True})", "def name_lookup(first_name):\n if first_name == \"Joe\": \n last_name = \"Warren\"\n elif first_name == \"Scott\": \n last_name = \"Rixner\"\n elif first_name == \"John\": \n last_name = \"Greiner\"\n elif first_name == \"Stephen\":\n last_name = \"Wong\"\n else: \n last_name = \"Error: Not an instructor\"\n return last_name", "def schools(self):\n if \"schools\" in self._prop_dict:\n return self._prop_dict[\"schools\"]\n else:\n return None", "def username(self):\n return self.idnumber\n # if self._grade in ['6', '7', '8', '9', '10', '11', '12']:\n # return self.idnumber\n # mapping = ssis_synctree_settings[STUDENT_PSIDUSERNAME_MAPPINGS].get(self.idnumber)\n # return (self.name + self._year_of_graduation).lower().replace(' ', '').replace('-', '') if not mapping else mapping", "def school_dropdown_func(self, width=100):\n schools = self.data[self.data.agent_type == 'school']\n school_locs = [str(num) for num in range(len(schools))]\n self.school_dropdown = Dropdown(label='Select School',\n menu=school_locs,\n width=width)\n self.school_dropdown.on_click(self.dropdown_select)", "def get_student_name(self):\n return self.__student_name" ]

[ "0.602459", "0.56425226", "0.56172824", "0.5562424", "0.5503714", "0.549422", "0.54849327", "0.5414529", "0.5342843", "0.5312967", "0.52557176", "0.5190712", "0.5178283", "0.51297957", "0.5119001", "0.51174057", "0.5111106", "0.5100947", "0.506486", "0.5032186", "0.5019904", "0.5018257", "0.5000173", "0.49820238", "0.49471933", "0.49295977", "0.49255428", "0.4906206", "0.4901469", "0.4890466" ]

[ "def users_page(request):", "def addUser():\n if request.method == \"POST\":\n (result, status) = parse_user_data(request)\n return jsonify(result), status # HTTP Status Created [201]\n if request.method == \"DELETE\":\n (result, status) = delete_user_data(request)\n return jsonify(result), status # HTTP Status Created [201]", "def on_GET(self, request, target_user_id):\n target_user = UserID.from_string(target_user_id)\n requester = yield self.auth.get_user_by_req(request)\n is_admin = yield self.auth.is_server_admin(requester.user)\n\n if not is_admin:\n raise AuthError(403, \"You are not a server admin\")\n\n # To allow all users to get the users list\n # if not is_admin and target_user != auth_user:\n # raise AuthError(403, \"You are not a server admin\")\n\n if not self.hs.is_mine(target_user):\n raise SynapseError(400, \"Can only users a local user\")\n\n term = request.args.get(\"term\")[0]\n if not term:\n raise SynapseError(400, \"Missing 'term' arg\")\n\n logger.info(\"term: %s \", term)\n\n ret = yield self.handlers.admin_handler.search_users(\n term\n )\n defer.returnValue((200, ret))", "def get(self, request):\n pass", "def requestURL(userID): #@NoSelf", "def user(request, user_id):\n raise NotImplementedError", "def add():\n if request.method == \"GET\":\n return render_template(\"add.html\")\n else:\n #Get amount to add from user\n cashAdd = request.form.get(\"amount\")\n\n #Check for issues\n if not cashAdd:\n return apology(\"Cheap\")\n elif float(cashAdd) <= 0:\n return apology(\"sneaky\")\n else:\n cashAdd = float(cashAdd)\n\n #Get user's existing cash\n cash = db.execute(\"SELECT cash FROM users WHERE id = :userid\", userid = session[\"user_id\"])[0][\"cash\"]\n\n #Update user's cash\n db.execute(\"UPDATE users SET cash = :cash WHERE id = :userid\", userid = session[\"user_id\"], cash = cash+ cashAdd)\n\n return redirect('/')", "def get(self):\r\n return_url = self.request.get(\"return_url\")\r\n template_values = {\r\n \"user_form\" : User.to_form(return_url, mode=\"add\")\r\n }\r\n self.render_out(\"templates/register.html\", template_values)", "def add():\n user_id = session[\"user_id\"]\n if not user_id:\n session.clear()\n redirect(\"/\")\n database = db.db_connect()\n user = database.execute(\"SELECT * FROM Users where id = ?\", (user_id,)).fetchone()\n if not user:\n session.clear()\n redirect(\"/\")\n\n if request.method == \"POST\":\n title = request.form.get(\"title\")\n deadline = request.form.get(\"deadline\")\n importance = request.form.get(\"importance\")\n try:\n print((int(user_id), title, deadline, importance))\n database = db.db_connect()\n database.execute(\"INSERT INTO Tasks (author, description, deadline, importance) VALUES\"\n \"(?, ?, ?, ?)\", (int(user_id), title, deadline, importance))\n database.commit()\n resp = redirect(\"/menu/\")\n except Exception as e:\n resp = render_template(\"add_item.html\", warn=True, warnmessage=e)\n return resp\n return render_template(\"add_item.html\", warn=False, warnmessage=\"\")", "def add_new_user():\n return render_template('new.html')", "def add_friend():\n if request.method == 'POST':\n username = get_username()\n user_id = get_id_from_username(username)\n friend_to_add = get_id_from_username(request.form['add_user'])\n if not friend_to_add or friend_to_add==user_id:\n return redirect(url_for('message.converse'))\n add_friend_db(user_id, friend_to_add)\n return redirect(url_for('message.converse'))", "def test_add_user_view(self):\n target_url = url_for('users.add_user')\n redirect_url = url_for('users.login', next=target_url)\n response = self.client.get(target_url)\n self.assertEqual(response.status_code, 302)\n self.assertRedirects(response, redirect_url)", "def handle_req(reqid):\n req = hl.retrieveRequest(reqid)\n \n if request.method == 'POST':\n if request.form['reqOption'] == 'Approve':\n hl.acceptRequest(req)\n elif request.form['reqOption'] == 'Decline':\n hl.declineRequest(req)\n \n return redirect('/users')", "def _get(self, url ='/administrarrol'):\n return self.client.get(url, follow_redirects=True)", "def do_GET(self):\r\n self._send_handler_response('GET')", "def get(self):\n if self.user:\n self.redirect_to('secure', id=self.user_id)\n params = {\n \"action\": self.request.url,\n }\n return self.render_template('create_user.html', **params)", "def add(self, user: U) -> None:\n ...", "def get(self):\n self.get_or_post(method='GET')", "def get(self):\n self.response.headers.add_header(\"Set-Cookie\", \"user_id=; Path=/\")\n self.redirect(\"/signup\")", "def get(self):\n self.post()", "def do_POST(self):\r\n self.do_GET()", "def get(self,request,*args,**kwargs):\n\t\treturn HttpResponseRedirect(reverse('inicio:login'))", "def get(self):\n self.post()", "def get(self):\n self.post()", "def get(self):\r\n self.checkSession(self.request.headers.get('Cookie'))\r\n try:\r\n self.insertMenu()\r\n self.getSentMSG(self.Session['userid'])\r\n except:\r\n self.response.out.write(\"Some error occured\")", "def add():\n if request.method == 'GET':\n return render_template('add.html')\n elif request.method == 'POST':\n data = {}\n for key in ('h', 'name', 'summary', 'content', 'published', 'updated', 'category',\n 'slug', 'location', 'in-reply-to', 'repost-of', 'syndication'):\n data[key] = None\n\n for title in request.form:\n data[title] = request.form[title]\n\n for title in request.files:\n data[title] = request.files[title].read()\n\n try:\n photo = request.files['photo']\n except:\n photo = None\n\n for key in data:\n if data[key] == \"\":\n data[key] = None\n\n data['published'] = datetime.now()\n\n location = create_entry(data, image=data['photo'], g=g)\n\n if data['in-reply-to']:\n send_mention('http://' + DOMAIN_NAME + '/e/'+location, data['in-reply-to'])\n\n if request.form.get('twitter'):\n t = Timer(30, bridgy_twitter, [location])\n t.start()\n\n if request.form.get('facebook'):\n t = Timer(30, bridgy_facebook, [location])\n t.start()\n return redirect(location)\n else:\n return redirect('/404'), 404", "def handle_add_user():\n new_user = User(first_name=request.form['first_name'], last_name=request.form['last_name'], image_url=request.form['image_url'])\n db.session.add(new_user)\n db.session.commit()\n\n return redirect('/')", "def add_user_process():\n\n # extract form data, add, commit, then redirect to /users\n first_name = request.form[\"first-name\"]\n last_name = request.form[\"last-name\"]\n image_url = request.form[\"image-url\"]\n\n msg = db_add_user(first_name, last_name, image_url)\n\n flash(msg[\"text\"], msg[\"severity\"])\n\n return redirect(\"/users\")", "def on_GET(self, request, target_user_id):\n target_user = UserID.from_string(target_user_id)\n requester = yield self.auth.get_user_by_req(request)\n is_admin = yield self.auth.is_server_admin(requester.user)\n\n if not is_admin:\n raise AuthError(403, \"You are not a server admin\")\n\n # To allow all users to get the users list\n # if not is_admin and target_user != auth_user:\n # raise AuthError(403, \"You are not a server admin\")\n\n if not self.hs.is_mine(target_user):\n raise SynapseError(400, \"Can only users a local user\")\n\n order = \"name\" # order by name in user table\n start = request.args.get(\"start\")[0]\n limit = request.args.get(\"limit\")[0]\n if not limit:\n raise SynapseError(400, \"Missing 'limit' arg\")\n if not start:\n raise SynapseError(400, \"Missing 'start' arg\")\n logger.info(\"limit: %s, start: %s\", limit, start)\n\n ret = yield self.handlers.admin_handler.get_users_paginate(\n order, start, limit\n )\n defer.returnValue((200, ret))", "def new_address():\n user = dbwrangler.get_current_user()\n if user:\n return render_template(\"new_user_more.html\")\n else:\n return redirect(\"/\")" ]

[ "0.6340799", "0.60597724", "0.59811425", "0.59551364", "0.59493613", "0.5945991", "0.5883485", "0.58578", "0.5839479", "0.5800304", "0.57811564", "0.5772578", "0.5767761", "0.576326", "0.5717431", "0.5711894", "0.5692957", "0.5684099", "0.56637645", "0.56426305", "0.5640269", "0.5626084", "0.5625065", "0.5625065", "0.5624334", "0.5607824", "0.5596601", "0.55729914", "0.55688685", "0.55645066" ]

[ "def addUser():\n if request.method == \"POST\":\n (result, status) = parse_user_data(request)\n return jsonify(result), status # HTTP Status Created [201]\n if request.method == \"DELETE\":\n (result, status) = delete_user_data(request)\n return jsonify(result), status # HTTP Status Created [201]", "def add_user_process():\n\n # extract form data, add, commit, then redirect to /users\n first_name = request.form[\"first-name\"]\n last_name = request.form[\"last-name\"]\n image_url = request.form[\"image-url\"]\n\n msg = db_add_user(first_name, last_name, image_url)\n\n flash(msg[\"text\"], msg[\"severity\"])\n\n return redirect(\"/users\")", "def post_user():\n\tuser = User.add(request.json)\n\tif user == None:\n\t\tabort(404)\n\treturn jsonify({'user': user.output()})", "def handle_add_user():\n new_user = User(first_name=request.form['first_name'], last_name=request.form['last_name'], image_url=request.form['image_url'])\n db.session.add(new_user)\n db.session.commit()\n\n return redirect('/')", "def response_add(self, request, obj, post_url_continue=None):\n # We should allow further modification of the user just added i.e. the\n # 'Save' button should behave like the 'Save and continue editing'\n # button except in two scenarios:\n # * The user has pressed the 'Save and add another' button\n # * We are adding a user in a popup\n if '_addanother' not in request.POST and IS_POPUP_VAR not in request.POST:\n request.POST['_continue'] = 1\n return super(UserAdmin, self).response_add(request, obj,\n post_url_continue)", "def post(self):\n DA = DataAccessor()\n\n session = getSessionByRequest(self)\n\n uid = self.request.get('uid')\n pw = self.request.get('pw')\n pw2 = self.request.get('pw2')\n\n if pw != pw2:\n setSessionMessage(session, \"Your new passwords did not match. Please try again.\", True)\n self.redirect('/admin')\n return\n\n try:\n DA.addAdmin(uid, pw)\n except Usage:\n setSessionMessage(session, \"A user with that uid exists already\", True)\n self.redirect('/admin')\n return\n \n setSessionMessage(session, \"Admin: \" + uid + \" successfully added.\", False)\n self.redirect('/admin')", "def post(self):\n user_id = request.args.get('user_id')\n lastname = request.args.get('lastname')\n return post_new_sukunimi(user_id, lastname)", "def addUsersSuccess(request):\n \n if request.method == 'POST':\n return HttpResponseRedirect('/addusers/')\n \n return render_to_response('adduserssuccess.html', \n context_instance=RequestContext(request))", "def add_post_process(user_id):\n\n # extract form data, add post, commit, then redirect to /users\n post_title = request.form[\"post-title\"]\n post_content = request.form[\"post-content\"]\n\n msg = db_add_post(post_title, post_content, user_id)\n\n flash(msg[\"text\"], msg[\"severity\"])\n\n return redirect(f\"/users/{ user_id }\")", "def post(self):\n user_id = request.args.get('user_id')\n firstname = request.args.get('firstname')\n return post_new_etunimi(user_id, firstname=firstname)", "async def post(self):\n await self.handle_request(self.users_api, 1)", "def post(self):\n return self.get_request_handler(request.headers).create_new_user(request)", "def register_post():\n logger.info(\"entering function register_post\")\n response = register_user(request.json)\n logger.info(\"exiting function register_post\")\n return jsonify(response)", "def post(self, request):\n pass", "def post(self):\n\n self.username = self.request.get('username').lower()\n self.pwd = self.request.get('pwd')\n self.verify_pwd = self.request.get('verify_pwd')\n self.email = self.request.get('email')\n have_errors = False\n params = dict(username=self.username,\n email=self.email)\n if not valid_username(self.username):\n params['error_username'] = \"That's not a valid username\"\n have_errors = True\n elif User.by_name(self.username):\n params['error_username'] = \"That username is taken. Try another. \"\n have_errors = True\n\n if not valid_pwd(self.pwd):\n params['error_pwd'] = \"That's not a valid password\"\n have_errors = True\n elif self.pwd != self.verify_pwd:\n params['error_verify_pwd'] = \"Your passwords doesn't match\"\n have_errors = True\n\n if self.email and not valid_email(self.email):\n params['error_email'] = \"That's not a valid email\"\n have_errors = True\n\n if have_errors:\n self.render('signup.html', **params)\n else:\n user = User.register(self.username, self.pwd, self.email)\n user.put()\n\n self.login(user)\n welcome_msg = 'Welcome, %s' % (self.username)\n self.redirect('/blog?welcome_msg=%s' % (welcome_msg))", "def add_user():\n if request.method == 'POST':\n print('In Adduser post method')\n data = request.form\n pics=[]\n try:\n #save in database here, use userid when actually saving\n for name in request.files:\n f = request.files[name]\n filename = secure_filename(f.filename)\n pics.append(filename)\n\n userid=data.get('userid',None)\n resp = AddUpdateUser(data['name'], data['dob'], data['email'], data['mentorfor'], \\\n data['learn'], data['about'], str(pics), userid)\n #error, return message\n if resp == -1:\n print('In Adduser post method: returning -1')\n return json.dumps({'msg':'error', 'code':-1})\n #else return userid\n else:\n #del pics[:]\n print('In Adduser post method: returning 200')\n for name in request.files:\n f = request.files[name]\n filename = str(resp) + '_' + secure_filename(f.filename)\n #pics.append(\"http://tushki1405.pythonanywhere.com/pics/\" + filename)\n f.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))\n return json.dumps({'msg':'success', 'code':200, 'userid':resp, 'name':data['name']})\n except Exception as e:\n return json.dumps({'msg':str(e), 'code':-1})\n return 'add user'", "def add_user():\n\n if request.method == 'POST':\n add_new_user_schema = AddNewUser()\n\n errors = add_new_user_schema.validate(data=request.form)\n\n if errors:\n abort(400, str(errors))\n\n args = add_new_user_schema.dump(request.form)\n\n user = User(connection=connection, cursor=cursor)\n user.add_user(\n first_name=args['first_name'],\n second_name=args['second_name'],\n is_internal=args['is_internal'],\n\n position=args['position'],\n email=args['email'],\n phone_number=args['phone_number']\n )\n\n return redirect(url_for('documentation.home'))\n\n return render_template('pages/inputs/add_user.html')", "def response_add(self, request, obj):\n if '_custom_action' in request.POST:\n pass\n return super().response_add(request, obj)", "def post(self):\r\n return create_user(request)", "def add():\n user_id = session[\"user_id\"]\n if not user_id:\n session.clear()\n redirect(\"/\")\n database = db.db_connect()\n user = database.execute(\"SELECT * FROM Users where id = ?\", (user_id,)).fetchone()\n if not user:\n session.clear()\n redirect(\"/\")\n\n if request.method == \"POST\":\n title = request.form.get(\"title\")\n deadline = request.form.get(\"deadline\")\n importance = request.form.get(\"importance\")\n try:\n print((int(user_id), title, deadline, importance))\n database = db.db_connect()\n database.execute(\"INSERT INTO Tasks (author, description, deadline, importance) VALUES\"\n \"(?, ?, ?, ?)\", (int(user_id), title, deadline, importance))\n database.commit()\n resp = redirect(\"/menu/\")\n except Exception as e:\n resp = render_template(\"add_item.html\", warn=True, warnmessage=e)\n return resp\n return render_template(\"add_item.html\", warn=False, warnmessage=\"\")", "def add():\n if request.method == \"POST\":\n result = add_post(\n request.form[\"title\"],\n request.form[\"body\"]\n )\n flash(result)\n return redirect(url_for(\"show\"))\n else:\n return render_template(\"add.html\")", "def post(self):\n data = request.json\n return save_new_user(data)", "def post(self, request, *args, **kwargs):\n\n data = {}\n form = self.form_class(request.POST)\n # import pdb\n # pdb.set_trace()\n if form.is_valid():\n data['first_name'] = form.cleaned_data['first_name']\n data['last_name'] = form.cleaned_data['last_name']\n data['email'] = form.cleaned_data['email']\n data['username'] = form.cleaned_data['username']\n password = form.cleaned_data['password']\n password_cnf = form.cleaned_data['password_cnf']\n\n if password == password_cnf:\n try:\n data['password'] = make_password(password, salt=\"blog\")\n user = User.objects.create(**data)\n except:\n import sys\n print sys.exc_value\n # user.delete()\n messages.error(request, \"Something went wrong. Please try again.\")\n return self.form_invalid(form)\n\n else:\n messages.error(request, \"Passwords did not match.\")\n return self.form_invalid(form)\n\n if user is not None:\n user = authenticate(username=data['username'], password=password)\n login(request, user)\n request.session['USER_ID'] = user.pk\n request.session['USER_NAME'] = user.first_name\n\n return HttpResponseRedirect(reverse('index'))\n messages.error(request, \"Wrong username and Password combination.\")\n return self.form_invalid(form)\n\n else:\n return self.form_invalid(form)", "def post(self):\n data = request.json\n return save_new_user(data=data)", "def post(self, request, *args, **kwargs):\n form = self.get_form(self.form_class)\n if form.is_valid():\n return self.form_valid(form)\n else:\n return self.form_invalid(form)", "def do_POST(self): # pylint: disable=invalid-name\n self.handle_request()", "def post(self):", "def post(self, request, *args, **kwargs):\n form = self.get_form()\n if form.is_valid():\n return self.form_valid(form)\n else:\n self.form_invalid_init(form=form)\n self.form_invalid_add_global_errormessages(form=form)\n return self.form_invalid(form)", "def on_post(self, req: falcon.Request, resp: falcon.Response):\n body = req.context[\"body\"].json\n try:\n username = body[\"username\"]\n except KeyError:\n raise falcon.HTTPBadRequest(\"Missing required parameter\", \"Must provide a username\")\n try:\n password = body[\"password\"]\n except KeyError:\n raise falcon.HTTPBadRequest(\"Missing required parameter\", \"Must provide a password\")\n try:\n email = body[\"email\"]\n except KeyError:\n raise falcon.HTTPBadRequest(\"Missing required parameter\", \"Must provide an email\")\n\n hashed = passwords.hash(password=password, rounds=passwords.DEFAULT_SALT_ROUNDS)\n\n try:\n user = self.user_manager.new(username, email, hashed)\n except AlreadyExists:\n raise falcon.HTTPBadRequest(\"Invalid parameter\", \"Username {!r} is taken\".format(username))\n\n self.async_tasks.send_verification(username)\n\n req.context[\"response\"] = {\"user_id\": str(user.user_id)}\n resp.status = falcon.HTTP_200", "def add_user():\n\n # get JSON from post request\n post_data = request.get_json()\n\n # enforce input\n if not post_data:\n response_object = {\n 'status': 'fail',\n 'message': 'Invalid payload'\n }\n return jsonify(response_object), 400\n\n # remember fields\n username = post_data.get('username')\n email = post_data.get('email')\n\n # check for duplicate users and add to db\n try:\n user = User.query.filter_by(email=email).first()\n if not user:\n db.session.add(User(username=username, email=email))\n db.session.commit()\n reponse_object = {\n 'status': 'success',\n 'message': f'{email} was added!'\n }\n return jsonify(reponse_object), 201\n else:\n response_object = {\n 'status': 'fail',\n 'message': 'Sorry, that email already exists'\n }\n return jsonify(response_object), 400\n\n # if missing fields\n except exc.IntegrityError as e:\n # rollback current transaction and close any subtransactions\n db.session.rollback()\n response_object = {\n 'status': 'fail',\n 'message': 'Invalid payload'\n }\n return jsonify(response_object), 400" ]

[ "0.7210867", "0.71598583", "0.69765174", "0.6758249", "0.67008495", "0.66891205", "0.66871625", "0.6586135", "0.6584424", "0.65641356", "0.6499921", "0.64976716", "0.6490107", "0.64696383", "0.6460626", "0.6412279", "0.63844705", "0.63715136", "0.63650995", "0.6359513", "0.6352095", "0.6346895", "0.6260407", "0.625645", "0.62482953", "0.62474173", "0.62422824", "0.62362635", "0.6227134", "0.62247175" ]

[ "def show_add_actor(self):\n\t\tformulario = view_form_actor.Form(self)\n\t\tformulario.exec_()\n\t\tself.load_data()", "def get_project_add_form():\n\n return render_template(\"project_add.html\")", "def get_form(self):\n # setup request layer\n self.request = TestRequest()\n # get add view\n form = getMultiAdapter((self.experiments, self.request),\n name=\"newProjection\")\n # update the form once to initialise all widgets\n form.update()\n # go through all widgets on the form and update the request with default values\n data = {}\n for widget in form.widgets.values():\n data[widget.name] = widget.value\n data.update({\n 'form.widgets.IDublinCore.title': u\"My CC Experiment\",\n 'form.widgets.IDublinCore.description': u'This is my experiment description',\n 'form.widgets.species_distribution_models': unicode(self.sdmexp.UID()),\n 'form.widgets.species_distribution_models.model': [unicode(self.sdmmodel.UID())],\n 'form.widgets.future_climate_datasets': [unicode(self.future.UID())]\n })\n self.request.form.update(data)\n form = getMultiAdapter((self.experiments, self.request),\n name=\"newProjection\")\n return form", "def show_create_form(self):\n # if there is no add permission then does not show the form\n if not self.has_add_permissions(): return\n\n params = {\n 'title':'Create',\n 'model':self.model,\n 'parent_model':self.parent_model,\n 'parent_pk':self.parent_pk,\n 'parent_win': self\n }\n\n if self.INLINES: params.update({'inlines':self.INLINES})\n if self.FIELDSETS: params.update({'fieldsets':self.FIELDSETS})\n if self.READ_ONLY: params.update({'readonly':self.READ_ONLY})\n\n createform = self.addmodel_class(**params)\n\n if hasattr(self, '_details') and self.USE_DETAILS_TO_ADD:\n self._list.hide()\n self._details.show()\n self._details.value = createform\n toolbar = [self.toolbar] if isinstance(self.toolbar, str) else self.toolbar\n if toolbar:\n for o in toolbar:\n if o and hasattr(self, o):\n getattr(self, o).hide()\n else:\n self._list.show()\n if hasattr(self, '_details'):\n self._details.hide()", "def get_add_project_form():\n\n return render_template(\"project_add.html\")", "def get_form(self):\n # setup request layer\n self.request = TestRequest()\n # get add view\n form = getMultiAdapter((self.experiments, self.request),\n name=\"newBiodiverse\")\n # update the form once to initialise all widgets\n form.update()\n # go through all widgets on the form and update the request with default values\n data = {}\n for widget in form.widgets.values():\n data[widget.name] = widget.value\n data.update({\n 'form.widgets.IDublinCore.title': u\"My BD Experiment\",\n 'form.widgets.IDublinCore.description': u'This is my experiment description',\n 'form.widgets.projection.count': '1',\n 'form.widgets.projection.experiment.0': unicode(self.sdmexp.UID()),\n 'form.widgets.projection.dataset.0.count': 1,\n 'form.widgets.projection.dataset.0.0.uuid': unicode(self.sdmproj.UID()),\n 'form.widgets.projection.dataset.0.0.threshold': '0.0',\n 'form.widgets.cluster_size': '5000',\n })\n self.request.form.update(data)\n form = getMultiAdapter((self.experiments, self.request),\n name=\"newBiodiverse\")\n return form", "def get_form(self):\n # setup request layer\n self.request = TestRequest()\n # get add view\n form = getMultiAdapter((self.experiments, self.request),\n name=\"newEnsemble\")\n # update the form once to initialise all widgets\n form.update()\n # go through all widgets on the form and update the request with default values\n data = {}\n for widget in form.widgets.values():\n data[widget.name] = widget.value\n data.update({\n 'form.widgets.IDublinCore.title': u\"My EN Experiment\",\n 'form.widgets.IDublinCore.description': u'This is my experiment description',\n 'form.widgets.experiment_type': ISDMExperiment.__identifier__,\n 'form.widgets.datasets.count': '1',\n 'form.widgets.datasets.experiment.0': unicode(self.sdmexp.UID()),\n 'form.widgets.datasets.dataset.0': [unicode(self.sdmproj.UID())],\n })\n self.request.form.update(data)\n form = getMultiAdapter((self.experiments, self.request),\n name=\"newEnsemble\")\n return form", "def add_user_form():\n\n return render_template(\"add_user.html\", headline=\"Add New Blogly User\")", "def add_bus():\n\n return render_template('bus-add-form.html')", "def show_add_student_form():\n\n return render_template(\"add_student_form.html\")", "def add():\n if request.method == \"POST\":\n result = add_post(\n request.form[\"title\"],\n request.form[\"body\"]\n )\n flash(result)\n return redirect(url_for(\"show\"))\n else:\n return render_template(\"add.html\")", "def populateUI():\n \n # Main form layout\n form = cmds.formLayout()\n\n # Tab Layout\n tabs = cmds.tabLayout(innerMarginWidth=5, innerMarginHeight=5)\n # Form attachment config\n cmds.formLayout( form, edit=True, attachForm=((tabs, 'top', 0), (tabs, 'left', 0), (tabs, 'bottom', 0), (tabs, 'right', 0)) )\n\n # The different Tabs on the window\n spawnTab = SpawnObjectsTab()\n roadTab = RoadRiverTab()\n environmentTab = EnvironmentTab()\n\n # Tab creation\n cmds.tabLayout( tabs, edit=True, tabLabel=((spawnTab, 'Spawn Buildings'), (roadTab, 'Create Roads / Rivers'), (environmentTab, \"Create Environment\") ))", "def get_form(self):\n # setup request layer\n self.request = TestRequest()\n # get add view\n form = getMultiAdapter((self.experiments, self.request),\n name=\"newSpeciesDistribution\")\n # update the form once to initialise all widgets\n form.update()\n # go through all widgets on the form and update the request with default values\n data = {}\n for widget in chain(\n form.widgets.values(),\n # skip standard plone groups\n #chain.from_iterable(g.widgets.values() for g in form.groups),\n chain.from_iterable(g.widgets.values() for g in form.param_groups)):\n data[widget.name] = widget.value\n data.update({\n 'form.widgets.IDublinCore.title': u\"My Experiment\",\n 'form.widgets.IDublinCore.description': u'This is my experiment description',\n 'form.widgets.functions': [self.algorithm.UID()], # BIOCLIM\n 'form.widgets.species_occurrence_dataset': [unicode(self.occur.UID())], # ABT\n 'form.widgets.species_absence_dataset': [unicode(self.absen.UID())],\n 'form.widgets.species_pseudo_absence_points': [],\n 'form.widgets.resolution': ('Resolution2_5m', ),\n # FIXME: shouldn't be necessary to use unicode here,... widget converter should take care of it\n 'form.widgets.environmental_datasets.item.0': unicode(self.current.UID()),\n 'form.widgets.environmental_datasets.item.0.item': [u'B01'],\n 'form.widgets.environmental_datasets.item.1': unicode(self.current.UID()),\n 'form.widgets.environmental_datasets.item.1.item': [u'B02'],\n 'form.widgets.environmental_datasets.count': '2',\n })\n self.request.form.update(data)\n form = getMultiAdapter((self.experiments, self.request),\n name=\"newSpeciesDistribution\")\n return form", "def display_form():\n\n return render_template('add_new_student.html')", "def addComponents(self):\n self.mainLayout = QFormLayout()\n self.setLayout(self.mainLayout)\n # title\n self.lblTitle = QLabel(\"Operator Details\")\n self.lblEmpty = QLabel()\n\n # enrolmentNumber\n self.lblID = QLabel(\"ID: \")\n self.editID = QLineEdit()\n\n # firstName\n self.lblCode = QLabel(\"Code: \")\n self.editCode = QLineEdit()\n\n\n # lastName\n self.lblLastName = QLabel(\"LastName: \")\n self.editLastName = QLineEdit()\n\n # dob\n self.lblValidation = QLabel(\"Validation: \")\n self.editValidation = QLineEdit()\n\n # faculty\n self.lblRemark = QLabel(\"Remark: \")\n self.editRemark = QLineEdit()\n\n # buttons\n self.btnClose = QPushButton(\"Close\")\n\n # add all rows to mainLayout\n self.mainLayout.addRow(self.lblEmpty, self.lblTitle)\n self.mainLayout.addRow(self.lblID, self.editID)\n self.mainLayout.addRow(self.lblCode, self.editCode)\n self.mainLayout.addRow(self.lblLastName, self.editLastName)\n self.mainLayout.addRow(self.lblValidation, self.editValidation)\n self.mainLayout.addRow(self.lblRemark, self.editRemark)\n self.mainLayout.addRow(QLabel(), self.btnClose)\n\n self.editID.setText(self.data[0])\n self.editCode.setText(self.data[9])\n self.editLastName.setText(self.data[10])\n self.editValidation.setText(self.data[11])\n self.editRemark.setText(self.data[12])\n\n self.editID.setReadOnly(True)\n self.editCode.setReadOnly(True)\n self.editLastName.setReadOnly(True)\n self.editValidation.setReadOnly(True)\n self.editRemark.setReadOnly(True)", "def add_widget():\n\n return render_template('add_widget.html', widget=None)", "def add_row() -> str:\r\n return render_template(\"add_row.html\")", "def get(self):\n return render_template('add.html')", "def get_form(self):\n # setup request layer\n self.request = TestRequest()\n # get add view\n form = getMultiAdapter((self.experiments, self.request),\n name=\"newSpeciesTraits\")\n # update the form once to initialise all widgets\n form.update()\n # go through all widgets on the form and update the request with default values\n data = {}\n for widget in chain(\n form.widgets.values(),\n # skip standard plone groups\n #chain.from_iterable(g.widgets.values() for g in form.groups),\n chain.from_iterable(g.widgets.values() for g in form.param_groups)):\n data[widget.name] = widget.value\n data.update({\n 'form.widgets.IDublinCore.title': u\"My ST Experiment\",\n 'form.widgets.IDublinCore.description': u'This is my experiment description',\n 'form.widgets.algorithm': [self.algorithm.UID()],\n 'form.widgets.formula': u'Z ~ X + Y',\n 'form.widgets.data_table': [unicode(self.traitsds.UID())]\n })\n self.request.form.update(data)\n form = getMultiAdapter((self.experiments, self.request),\n name=\"newSpeciesTraits\")\n return form", "def handleActionAdd(self):\n self.fDialog.show()", "def build_ui(self):\n self.ui = UI_procstep.Ui_Form()#.Ui_USGSContactInfoWidgetMain()\n self.ui.setupUi(self)\n self.setup_dragdrop(self)\n\n self.proc_step = RepeatingElement(which='tab',\n tab_label='Step', add_text='Additional Step',\n widget=ProcessStep, remove_text='Remove Step', italic_text='Processing Steps Taken')\n\n #self.proc_step = RepeatingElement(params=params, which='tab', tab_label='Source',)\n self.proc_step.add_another()\n self.ui.widget_procstep.layout().addWidget(self.proc_step)", "def add_form():\r\n\r\n if request.args['collection'] == 'recipe':\r\n # initializes page title and header\r\n page_title = 'Add recipe'\r\n page_header = 'Add a new recipe:'\r\n\r\n # returns the add recipe template\r\n return render_template(\r\n 'add_form.html',\r\n collection=mongo.db.recipe_categories.find().sort('name'),\r\n categories=mongo.db.appliance_categories.find().sort('name'),\r\n page_title=page_title,\r\n page_header=page_header\r\n )\r\n\r\n elif request.args['collection'] == 'category':\r\n # initializes page title and header\r\n page_title = 'Add recipe category'\r\n page_header = 'Add a new recipe category:'\r\n\r\n # returns the add recipe category template\r\n return render_template(\r\n 'add_form.html',\r\n page_title=page_title,\r\n page_header=page_header\r\n )\r\n\r\n else:\r\n # returns an error message on incorrect argument\r\n return render_template(\r\n 'error.html',\r\n msg='Bad argument error! (/add_form)'\r\n )", "def get_student_add_form():\n\n return render_template(\"student_add.html\")", "def enterParameters(self,**kwargs):\n\n members = self.bl.getAllParameters().keys() \n entries={}\n\n for param in members:\n entries[param] = getattr(self.bl, 'paramSelection') # save param names in entries\n entries['view selection'] = [getattr(self.bl, 'displayText'), str(self.bl.getAllParameters())]\n entries['reset selection'] = getattr(self.bl, 'paramReset')\n self.mm.addGenericMenu(\"param\",self.mm.cur_page,\"Select your desired params for this operation\", entries)\n self.mm.loadMenu(\"param\")", "def customer_add_view_new(h):\n global html\n html = h\n common_elements = customer_common_elements()\n \n css_list = common_elements[\"css_list\"]\n\n javascript_list = [\"js/commonFunctions.js\"]\n javascript_list += common_elements[\"javascript_list\"]\n\n all_btn = common_elements[\"all_btn\"]\n\n html.new_header(\"Add Customers\", \"customer_management.py\", all_btn, css_list, javascript_list)\n\n customer_add_html = \"\"\"\n <table width=\"100%\" class=\"content_tbl\" border=\"0\" cellspacing=\"0\" cellpadding=\"0\">\n <tbody>\n <tr>\n <th>Customer Details</th>\n </tr>\n <tr>\n <td>\n <table width=\"100%\" class=\"deatil_tbl\" border=\"0\" cellspacing=\"0\" cellpadding=\"0\">\n <tbody>\n <tr>\n <td class=\"label\">Organization Name</td>\n <td colspan=\"3\"><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n </tr>\n <tr>\n <td>Telephone Number</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n <td class=\"label\">Fax</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n </tr>\n <tr>\n <td>Website</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n <td>Email</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n </tr>\n <tr>\n <td>Business Type</td>\n <td><select class=\"txt_bx\"><option> Auction </option></select></td>\n <td>Submission</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n </tr>\n <tr>\n <td>Address</td>\n <td colspan=\"3\"><textarea rows=\"4\" cols=\"27\"></textarea></td>\n </tr>\n </tbody>\n </table>\n </td>\n </tr>\n <tr>\n <td>\n <table width=\"100%\" id=\"iDetails_table\" class=\"individual_tbl\" border=\"0\" cellspacing=\"0\" cellpadding=\"0\">\n <tbody>\n <tr>\n <th colspan=\"4\">Individual Details <a href=\"\" class=\"addChildTr\"><img class=\"add\" src=\"images/add-gray.png\" align=\"right\" alt=\"\" border=\"0\"></a></th>\n </tr>\n <tr class=\"findInnerHTML\"><td colspan=\"4\"></td></tr>\n <tr class=\"findInnerHTML\">\n <td class=\"label\">Contact Person Name</td>\n <td colspan=\"3\"><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n </tr>\n <tr class=\"findInnerHTML\">\n <td>Email</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n <td class=\"label\">Contact Number</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n </tr>\n <tr class=\"findInnerHTML\">\n <td>Department</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n <td>Designation</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n </tr>\n <tr><td colspan=\"4\"></td></tr>\n </tbody>\n </table>\n </td>\n </tr>\n <tr>\n <td>\n <table width=\"100%\" class=\"individual_tbl\" border=\"0\" cellspacing=\"0\" cellpadding=\"0\">\n <tbody>\n <tr>\n <th colspan=\"4\">Customer Portal Configration</th>\n </tr>\n <tr><td colspan=\"4\"></td></tr>\n <tr>\n <td class=\"label\">Portal ID</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n <td class=\"label\">Portal Link</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n </tr>\n <tr>\n <td>Set Theme</td>\n <td><select class=\"txt_bx\"><option> Theme </option></select></td>\n <td>Port Number</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n </tr>\n <tr><td colspan=\"4\"></td></tr>\n <tr>\n <td colspan=\"4\">\n <table border=\"0\" class=\"add_user_tbl\" width=\"90%\" cellpadding=\"0\" cellspacing=\"0\">\n <tbody>\n <tr>\n <th colspan=\"6\">Add Customer Users <a href=\"#\" class=\"addChildTr\"><img class=\"add\" src=\"images/add-gray.png\" align=\"right\" alt=\"\" border=\"0\"></a></th>\n </tr>\n <tr><td colspan=\"6\"></td></tr>\n <tr>\n <td>User Name</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n <td>Password</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n <td>Email</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n </tr>\n <tr class=\"findInnerHTML\">\n <td>User Name</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n <td>Password</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n <td>Email</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n </tr>\n <tr><td colspan=\"6\"></td></tr>\n </tbody>\n </table>\n </td>\n </tr>\n <tr><td>&nbsp;</td></tr>\n </tbody></table>\n </td>\n </tr>\n <tr>\n <td>\n <table width=\"100%\" id=\"billing_dept_table\" class=\"individual_tbl endof_tbl\" border=\"0\" cellspacing=\"0\" cellpadding=\"0\">\n <tbody><tr>\n <th colspan=\"4\">Billing Departments</th>\n </tr>\n <tr><td colspan=\"4\"></td></tr>\n <tr>\n <td class=\"width_150\">\n Select Billing Department \n <br> \n <em class=\"fs10\">(If TPS selected)</em>\n </td>\n <td colspan=\"3\">\n <select id=\"billing_determinant_select_box\" class=\"txt_bx\">\n <option>TPS</option>\n <option>Bandwidth</option>\n <option>Sim Subscription</option>\n </select>\n </td>\n </tr>\n <tr>\n <td class=\"width_150\">Max TPS</td>\n <td colspan=\"3\"><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n </tr>\n <tr>\n <td class=\"width_150\">Billing Cycle</td>\n <td colspan=\"3\"><select class=\"txt_bx\"><option> Monthly </option></select></td>\n </tr>\n <tr>\n <td class=\"width_150\">Billing Start Date</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n <td class=\"width_150\">Billing Amount</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n </tr>\n <tr><td colspan=\"4\"></td></tr>\n </tbody></table>\n </td>\n </tr>\n </tbody></table>\n \n \"\"\"\n html.write(customer_add_html)\n html.write(\"\"\"\n <script>\n customer_add_view_new();\n </script>\n \"\"\")\n html.new_footer()", "def get(self, request):\n self.context[\"form\"] = AddUserForm()\n return render(request, \"dbkeeper/add.html\", self.context)", "def get(self, request):\n form = AddSecureParamsForm()\n #form.setFixedFields()\n try:\n secureParams = Setting.getSecureParams()\n form.setFields(len(secureParams[\"sets\"]))\n except:\n self.context[\"data\"] = { \"numRows\": 0 }\n self.context[\"form\"] = form\n return render(request, \"dbkeeper/add_secure_params.html\", self.context)", "def show_user_detail_form():\n\n return render_template(\"add-user-details.html\")", "def click_add():\n # TODO: 1. In frontend_script.py, create function \"create_window()\" that takes a Toplevel() as a parameter.\n # TODO: 2. In this file, implement the code below\n # new_window = Toplevel(root)\n # frontend_script.create_window(new_window)", "def get_add_form(self):\n rv = self.get(self.add_url)\n assert not is_404(rv)\n assert in_response(rv, 'Add {}'.format(self.nice_name))\n for field, name in self.fields:\n assert in_response(rv, name)\n return rv" ]

[ "0.63401496", "0.62683624", "0.6101274", "0.60733443", "0.60659564", "0.59358907", "0.5907794", "0.58550936", "0.5840284", "0.5796411", "0.5787442", "0.575894", "0.5718366", "0.5710715", "0.5703746", "0.57016623", "0.56800807", "0.56598663", "0.5647814", "0.56415087", "0.56193006", "0.55655617", "0.5561698", "0.5552188", "0.5532369", "0.55269027", "0.5524097", "0.55118597", "0.5477587", "0.54658103" ]

[ "def show_add_student_form():\n\n return render_template(\"add_student_form.html\")", "def get_student_add_form():\n\n return render_template(\"student_add.html\")", "def display_form():\n\n return render_template('add_new_student.html')", "def get(self, request):\n self.context[\"form\"] = AddUserForm()\n return render(request, \"dbkeeper/add.html\", self.context)", "def get_add_student_form():\n\n return render_template(\"student_add.html\")", "def add_user_form():\n\n return render_template(\"add_user.html\", headline=\"Add New Blogly User\")", "def add():\n if request.method == \"POST\":\n result = add_post(\n request.form[\"title\"],\n request.form[\"body\"]\n )\n flash(result)\n return redirect(url_for(\"show\"))\n else:\n return render_template(\"add.html\")", "def add():\n add_form = AddCourseForm(request.form)\n if request.method == 'POST':\n Course.new(name=add_form.name.data,\n owner_id=g.user.id,\n visibility=add_form.visibility.data,\n term=add_form.term.data)\n flash('New course added')\n return redirect(url_for('courses.index'))\n return render_template('courses/add.html', add_form=add_form)", "def add_user():\n\n return render_template('register-form.html')", "def show_user_detail_form():\n\n return render_template(\"add-user-details.html\")", "def cassh_add(current_user=None):\n return render_template('add.html', username=current_user['name'], \\\n logged_in=current_user['is_authenticated'])", "def student_add():\n\n html = render_template(\"student_add.html\")\n\n return html", "def get(self):\n return render_template('add.html')", "def get_add_grade_form():\n\n students = hackbright.get_students()\n\n projects = hackbright.get_projects()\n\n return render_template(\"grade_add.html\",\n students=students,\n projects=projects)", "def get_add_form(self):\n rv = self.get(self.add_url)\n assert not is_404(rv)\n assert in_response(rv, 'Add {}'.format(self.nice_name))\n for field, name in self.fields:\n assert in_response(rv, name)\n return rv", "def show_create_form(self):\n # if there is no add permission then does not show the form\n if not self.has_add_permissions(): return\n\n params = {\n 'title':'Create',\n 'model':self.model,\n 'parent_model':self.parent_model,\n 'parent_pk':self.parent_pk,\n 'parent_win': self\n }\n\n if self.INLINES: params.update({'inlines':self.INLINES})\n if self.FIELDSETS: params.update({'fieldsets':self.FIELDSETS})\n if self.READ_ONLY: params.update({'readonly':self.READ_ONLY})\n\n createform = self.addmodel_class(**params)\n\n if hasattr(self, '_details') and self.USE_DETAILS_TO_ADD:\n self._list.hide()\n self._details.show()\n self._details.value = createform\n toolbar = [self.toolbar] if isinstance(self.toolbar, str) else self.toolbar\n if toolbar:\n for o in toolbar:\n if o and hasattr(self, o):\n getattr(self, o).hide()\n else:\n self._list.show()\n if hasattr(self, '_details'):\n self._details.hide()", "def add():\n form = RegisterForm(request.form)\n if form.validate_on_submit():\n username = form.username.data\n password = form.password.data\n email = form.email.data\n \n save_result = add_user(username, password, email)\n if save_result['status']:\n # create a starter project\n save_result_project = add_project(save_result['entry'], 'my first project', [], 'an example project', True, 2)\n save_result_task = add_task(save_result['entry'].id, 'this is an example task', save_result_project['entry'].id, 'you can edit these notes', False, False, 2, '1970-01-01')\n flash(u'thanks for joining, %s. please login!' % username, 'success')\n else:\n flash(u'cannot register \"%s\". try a different username or email.' % username, 'error')\n return redirect(url_for('.add'))\n\n return redirect(url_for('login'))\n\n return render_template('users/register.html'\n ,form=form\n ,t=t\n ,m=m)", "def addComponents(self):\n self.mainLayout = QFormLayout()\n self.setLayout(self.mainLayout)\n # title\n self.lblTitle = QLabel(\"Save New Student\")\n self.lblEmpty = QLabel()\n\n # enrolmentNumber\n self.lblEnrolmentNumber = QLabel(\"EnrolmentNumber: \")\n self.editEnrolmentNumber = QLineEdit()\n\n # firstName\n self.lblFirstName = QLabel(\"FirstName: \")\n self.editFirstName = QLineEdit()\n\n\n # lastName\n self.lblLastName = QLabel(\"LastName: \")\n self.editLastName = QLineEdit()\n\n # dob\n self.lblDob = QLabel(\"DateOfBirth: \")\n self.editDob = QLineEdit()\n\n # faculty\n self.lblFaculty = QLabel(\"Faculty: \")\n self.editFaculty = QLineEdit()\n\n # email\n self.lblEmail = QLabel(\"Email: \")\n self.editEmail = QLineEdit()\n\n # buttons\n self.btnSave = QPushButton(\"Save\")\n self.btnCancel = QPushButton(\"Cancel\")\n\n # add all rows to mainLayout\n self.mainLayout.addRow(self.lblEmpty, self.lblTitle)\n self.mainLayout.addRow(self.lblEnrolmentNumber, self.editEnrolmentNumber)\n self.mainLayout.addRow(self.lblFirstName, self.editFirstName)\n self.mainLayout.addRow(self.lblLastName, self.editLastName)\n self.mainLayout.addRow(self.lblDob, self.editDob)\n self.mainLayout.addRow(self.lblFaculty, self.editFaculty)\n self.mainLayout.addRow(self.lblEmail, self.editEmail)\n self.mainLayout.addRow(self.btnSave, self.btnCancel)", "def add_bus():\n\n return render_template('bus-add-form.html')", "def show_add_actor(self):\n\t\tformulario = view_form_actor.Form(self)\n\t\tformulario.exec_()\n\t\tself.load_data()", "def get_project_add_form():\n\n return render_template(\"project_add.html\")", "def add_student():\n\n return render_template(\"student_add.html\")", "def save_add(request):\n if request.method == \"POST\":\n initial_data, data = process_request(request)\n return render(request,\n \"invoice/invoice_create.html\",\n {\n \"form\": ItemForm(),\n \"stage\": \"2\",\n \"prev_data\": data,\n \"initial_data\": initial_data\n })", "def addComponents(self):\n self.mainLayout = QFormLayout()\n self.setLayout(self.mainLayout)\n # title\n self.lblTitle = QLabel(\"Operator Details\")\n self.lblEmpty = QLabel()\n\n # enrolmentNumber\n self.lblID = QLabel(\"ID: \")\n self.editID = QLineEdit()\n\n # firstName\n self.lblCode = QLabel(\"Code: \")\n self.editCode = QLineEdit()\n\n\n # lastName\n self.lblLastName = QLabel(\"LastName: \")\n self.editLastName = QLineEdit()\n\n # dob\n self.lblValidation = QLabel(\"Validation: \")\n self.editValidation = QLineEdit()\n\n # faculty\n self.lblRemark = QLabel(\"Remark: \")\n self.editRemark = QLineEdit()\n\n # buttons\n self.btnClose = QPushButton(\"Close\")\n\n # add all rows to mainLayout\n self.mainLayout.addRow(self.lblEmpty, self.lblTitle)\n self.mainLayout.addRow(self.lblID, self.editID)\n self.mainLayout.addRow(self.lblCode, self.editCode)\n self.mainLayout.addRow(self.lblLastName, self.editLastName)\n self.mainLayout.addRow(self.lblValidation, self.editValidation)\n self.mainLayout.addRow(self.lblRemark, self.editRemark)\n self.mainLayout.addRow(QLabel(), self.btnClose)\n\n self.editID.setText(self.data[0])\n self.editCode.setText(self.data[9])\n self.editLastName.setText(self.data[10])\n self.editValidation.setText(self.data[11])\n self.editRemark.setText(self.data[12])\n\n self.editID.setReadOnly(True)\n self.editCode.setReadOnly(True)\n self.editLastName.setReadOnly(True)\n self.editValidation.setReadOnly(True)\n self.editRemark.setReadOnly(True)", "def get_form(self):\n # setup request layer\n self.request = TestRequest()\n # get add view\n form = getMultiAdapter((self.experiments, self.request),\n name=\"newProjection\")\n # update the form once to initialise all widgets\n form.update()\n # go through all widgets on the form and update the request with default values\n data = {}\n for widget in form.widgets.values():\n data[widget.name] = widget.value\n data.update({\n 'form.widgets.IDublinCore.title': u\"My CC Experiment\",\n 'form.widgets.IDublinCore.description': u'This is my experiment description',\n 'form.widgets.species_distribution_models': unicode(self.sdmexp.UID()),\n 'form.widgets.species_distribution_models.model': [unicode(self.sdmmodel.UID())],\n 'form.widgets.future_climate_datasets': [unicode(self.future.UID())]\n })\n self.request.form.update(data)\n form = getMultiAdapter((self.experiments, self.request),\n name=\"newProjection\")\n return form", "def make_form(self):", "def add_student():\n if request.method == 'POST':\n db.add_student(request.form)\n return redirect('/registry')\n else:\n return render_template('add.html')", "def addbutton_click(self):\n pais = self.ui.qlinepais.text()\n nome = self.ui.qlinenome.text()\n presidente = self.ui.qlinepres.text()\n email_contato = self.ui.qlineemail.text()\n endereco = self.ui.qlineend.text()\n if pais and nome and presidente:\n kwargs = {'pais': \"'\" + pais + \"'\",\n 'nome': \"'\" + nome + \"'\",\n 'presidente': \"'\" + presidente + \"'\"}\n if email_contato:\n kwargs['email_contato'] = \"'\" + email_contato + \"'\"\n if endereco:\n kwargs['endereco'] = \"'\" + endereco + \"'\"\n if(insert('comite', kwargs)):\n self.parent().hide()\n self.parent().parent().setWindowTitle(self.parent().parent().title)\n else:\n showdialog ('Erro', \"Erro na inserção, verifique se o comite já não está cadastrado\");\n \n else:\n showdialog('Erro', 'Os campos país, nome e presidente são obrigatórios')", "def add_form():\r\n\r\n if request.args['collection'] == 'recipe':\r\n # initializes page title and header\r\n page_title = 'Add recipe'\r\n page_header = 'Add a new recipe:'\r\n\r\n # returns the add recipe template\r\n return render_template(\r\n 'add_form.html',\r\n collection=mongo.db.recipe_categories.find().sort('name'),\r\n categories=mongo.db.appliance_categories.find().sort('name'),\r\n page_title=page_title,\r\n page_header=page_header\r\n )\r\n\r\n elif request.args['collection'] == 'category':\r\n # initializes page title and header\r\n page_title = 'Add recipe category'\r\n page_header = 'Add a new recipe category:'\r\n\r\n # returns the add recipe category template\r\n return render_template(\r\n 'add_form.html',\r\n page_title=page_title,\r\n page_header=page_header\r\n )\r\n\r\n else:\r\n # returns an error message on incorrect argument\r\n return render_template(\r\n 'error.html',\r\n msg='Bad argument error! (/add_form)'\r\n )", "def customer_add_view_new(h):\n global html\n html = h\n common_elements = customer_common_elements()\n \n css_list = common_elements[\"css_list\"]\n\n javascript_list = [\"js/commonFunctions.js\"]\n javascript_list += common_elements[\"javascript_list\"]\n\n all_btn = common_elements[\"all_btn\"]\n\n html.new_header(\"Add Customers\", \"customer_management.py\", all_btn, css_list, javascript_list)\n\n customer_add_html = \"\"\"\n <table width=\"100%\" class=\"content_tbl\" border=\"0\" cellspacing=\"0\" cellpadding=\"0\">\n <tbody>\n <tr>\n <th>Customer Details</th>\n </tr>\n <tr>\n <td>\n <table width=\"100%\" class=\"deatil_tbl\" border=\"0\" cellspacing=\"0\" cellpadding=\"0\">\n <tbody>\n <tr>\n <td class=\"label\">Organization Name</td>\n <td colspan=\"3\"><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n </tr>\n <tr>\n <td>Telephone Number</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n <td class=\"label\">Fax</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n </tr>\n <tr>\n <td>Website</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n <td>Email</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n </tr>\n <tr>\n <td>Business Type</td>\n <td><select class=\"txt_bx\"><option> Auction </option></select></td>\n <td>Submission</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n </tr>\n <tr>\n <td>Address</td>\n <td colspan=\"3\"><textarea rows=\"4\" cols=\"27\"></textarea></td>\n </tr>\n </tbody>\n </table>\n </td>\n </tr>\n <tr>\n <td>\n <table width=\"100%\" id=\"iDetails_table\" class=\"individual_tbl\" border=\"0\" cellspacing=\"0\" cellpadding=\"0\">\n <tbody>\n <tr>\n <th colspan=\"4\">Individual Details <a href=\"\" class=\"addChildTr\"><img class=\"add\" src=\"images/add-gray.png\" align=\"right\" alt=\"\" border=\"0\"></a></th>\n </tr>\n <tr class=\"findInnerHTML\"><td colspan=\"4\"></td></tr>\n <tr class=\"findInnerHTML\">\n <td class=\"label\">Contact Person Name</td>\n <td colspan=\"3\"><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n </tr>\n <tr class=\"findInnerHTML\">\n <td>Email</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n <td class=\"label\">Contact Number</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n </tr>\n <tr class=\"findInnerHTML\">\n <td>Department</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n <td>Designation</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n </tr>\n <tr><td colspan=\"4\"></td></tr>\n </tbody>\n </table>\n </td>\n </tr>\n <tr>\n <td>\n <table width=\"100%\" class=\"individual_tbl\" border=\"0\" cellspacing=\"0\" cellpadding=\"0\">\n <tbody>\n <tr>\n <th colspan=\"4\">Customer Portal Configration</th>\n </tr>\n <tr><td colspan=\"4\"></td></tr>\n <tr>\n <td class=\"label\">Portal ID</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n <td class=\"label\">Portal Link</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n </tr>\n <tr>\n <td>Set Theme</td>\n <td><select class=\"txt_bx\"><option> Theme </option></select></td>\n <td>Port Number</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n </tr>\n <tr><td colspan=\"4\"></td></tr>\n <tr>\n <td colspan=\"4\">\n <table border=\"0\" class=\"add_user_tbl\" width=\"90%\" cellpadding=\"0\" cellspacing=\"0\">\n <tbody>\n <tr>\n <th colspan=\"6\">Add Customer Users <a href=\"#\" class=\"addChildTr\"><img class=\"add\" src=\"images/add-gray.png\" align=\"right\" alt=\"\" border=\"0\"></a></th>\n </tr>\n <tr><td colspan=\"6\"></td></tr>\n <tr>\n <td>User Name</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n <td>Password</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n <td>Email</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n </tr>\n <tr class=\"findInnerHTML\">\n <td>User Name</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n <td>Password</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n <td>Email</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n </tr>\n <tr><td colspan=\"6\"></td></tr>\n </tbody>\n </table>\n </td>\n </tr>\n <tr><td>&nbsp;</td></tr>\n </tbody></table>\n </td>\n </tr>\n <tr>\n <td>\n <table width=\"100%\" id=\"billing_dept_table\" class=\"individual_tbl endof_tbl\" border=\"0\" cellspacing=\"0\" cellpadding=\"0\">\n <tbody><tr>\n <th colspan=\"4\">Billing Departments</th>\n </tr>\n <tr><td colspan=\"4\"></td></tr>\n <tr>\n <td class=\"width_150\">\n Select Billing Department \n <br> \n <em class=\"fs10\">(If TPS selected)</em>\n </td>\n <td colspan=\"3\">\n <select id=\"billing_determinant_select_box\" class=\"txt_bx\">\n <option>TPS</option>\n <option>Bandwidth</option>\n <option>Sim Subscription</option>\n </select>\n </td>\n </tr>\n <tr>\n <td class=\"width_150\">Max TPS</td>\n <td colspan=\"3\"><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n </tr>\n <tr>\n <td class=\"width_150\">Billing Cycle</td>\n <td colspan=\"3\"><select class=\"txt_bx\"><option> Monthly </option></select></td>\n </tr>\n <tr>\n <td class=\"width_150\">Billing Start Date</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n <td class=\"width_150\">Billing Amount</td>\n <td><input type=\"text\" value=\"\" class=\"txt_bx\"></td>\n </tr>\n <tr><td colspan=\"4\"></td></tr>\n </tbody></table>\n </td>\n </tr>\n </tbody></table>\n \n \"\"\"\n html.write(customer_add_html)\n html.write(\"\"\"\n <script>\n customer_add_view_new();\n </script>\n \"\"\")\n html.new_footer()" ]

[ "0.6632061", "0.64132214", "0.639975", "0.6244252", "0.62157214", "0.612753", "0.6044558", "0.60000664", "0.5979012", "0.59370697", "0.5908866", "0.58461404", "0.5841678", "0.5826378", "0.58164346", "0.57106", "0.57002246", "0.56978536", "0.5674832", "0.56701356", "0.5669822", "0.5662506", "0.5659078", "0.56161475", "0.56012106", "0.55892134", "0.5579501", "0.5559838", "0.5530115", "0.54936224" ]

[ "def display_window(self):\n frame = tk.Frame(master=self.param_window)\n frame.grid(padx=10, pady=20, columnspan=2)\n tk.Label(master=frame, text=\"Enter simulation parameters\").pack()\n\n self.status_text = tk.StringVar()\n self.status_text.set(\"Status message\")\n \n self.rows = 1\n for input_key in self.inputs.keys():\n input_dict = self.inputs[input_key]\n \n frame = tk.Frame(master=self.param_window)\n frame.grid(row=self.rows, column=0, padx=10, pady=1)\n input_dict['label'] = tk.Label(master=frame, text=input_dict['label'])\n input_dict['label'].pack()\n\n frame = tk.Frame(master=self.param_window)\n frame.grid(row=self.rows, column=1, padx=10, pady=1)\n input_dict['entry'] = tk.Entry(master=frame, width=10)\n input_dict['entry'].insert(0, input_dict['default'])\n input_dict['entry'].pack()\n \n self.rows += 1\n\n frame = tk.Frame(master=self.param_window)\n frame.grid(padx=10, pady=20, columnspan = 2)\n self.submit_btn = tk.Button(master=frame, text=\"Submit\", width=10)\n self.submit_btn.pack()\n self.submit_btn.bind(\"<Button-1>\", self.submit_values)\n\n self.param_window.mainloop()\n return self.parameters", "def display_return_car(self):\n self.is_return = True\n self.login_menu()", "def get(self, request):\n form = AddSecureParamsForm()\n #form.setFixedFields()\n try:\n secureParams = Setting.getSecureParams()\n form.setFields(len(secureParams[\"sets\"]))\n except:\n self.context[\"data\"] = { \"numRows\": 0 }\n self.context[\"form\"] = form\n return render(request, \"dbkeeper/add_secure_params.html\", self.context)", "def display_record_update_form_and_return_data(record, trx_type: str) -> Dict:\n artist = st.text_input(\n \"Artist\",\n value=\"; \".join([artist.artist_name for artist in record.artists]),\n )\n artist_country = st.text_input(\n \"(Artist) Country\",\n value=\"; \".join([artist.artist_country for artist in record.artists]),\n )\n title = st.text_input(\"Title\", value=record.title)\n genre = st.text_input(\"Genre\", value=record.genre.genre_name)\n label = st.text_input(\n \"Label\", value=\"; \".join([label.label_name for label in record.labels]),\n )\n year = st.number_input(\"Year\", value=record.year)\n record_format = st.text_input(\n \"Format\", value=record.record_format.format_name\n )\n vinyl_color = st.text_input(\"Vinyl Color\", value=record.vinyl_color)\n lim_edition = st.text_input(\"Lim Edition\", value=record.lim_edition)\n number = st.text_input(\"Number\", value=record.number)\n remarks = st.text_input(\"Remarks\", value=record.remarks)\n price = st.number_input(\n \"Price\",\n value=float(record.price),\n min_value=0.00,\n step=5.00,\n format=\"%f\",\n )\n is_digitized = st.number_input(\"is digitized\", value=record.is_digitized)\n rating = st.text_input(\"Rating\", value=record.rating)\n is_active = st.number_input(\"is active\", value=record.is_active)\n purchase_date = st.date_input(\"Purchase Date\", value=record.purchase_date)\n\n record_data = {\n \"trx_type\": trx_type,\n \"artist\": artist if artist != \"\" else \"NA\",\n \"artist_country\": artist_country if artist_country != \"\" else \"NA\",\n \"title\": title if title != \"\" else None,\n \"genre\": genre,\n \"label\": label if label != \"\" else \"NA\",\n \"year\": year,\n \"record_format\": record_format,\n \"vinyl_color\": vinyl_color if vinyl_color != \"\" else None,\n \"lim_edition\": lim_edition if lim_edition != \"\" else None,\n \"number\": number if number != \"\" else None,\n \"remarks\": remarks if remarks != \"\" else None,\n \"purchase_date\": purchase_date,\n \"price\": price,\n \"rating\": rating if rating != \"\" else None,\n \"is_digitized\": is_digitized,\n \"is_active\": is_active,\n # \"credit_value\": credit_value, # we dont return a cretid value yet\n }\n return record_data", "def display_form():\n\n return render_template('add_new_student.html')", "def display_record_purchase_form_return_data(trx_type: str) -> Dict:\n artist = st.text_input(\"Artist (separate multiple artists with ';')\")\n artist_country = st.text_input(\n \"(Artist) Country (one for each artist, separate with ';')\"\n )\n title = st.text_input(\"Title\")\n genre = st.selectbox(\"Genre\", app_utils.genre_list, 3)\n label = st.text_input(\"Label (separate multiple labels with ';')\")\n year = st.number_input(\"Year\", value=dt.date.today().year, format=\"%d\")\n record_format = st.selectbox(\"Format\", app_utils.record_format_list, 4)\n vinyl_color = st.text_input(\"Vinyl Color\", value=\"black\").lower()\n lim_edition = st.text_input(\"Lim Edition\")\n number = st.text_input(\"Number\")\n remarks = st.text_input(\"Remarks\")\n purchase_date = st.date_input(\"Purchase Date\", value=dt.date.today())\n price = st.number_input(\n \"Price\", value=20.00, min_value=0.00, step=5.00, format=\"%f\"\n )\n rating = st.text_input(\"Rating\")\n is_digitized = st.number_input(\n \"is digitized\", value=0, min_value=0, max_value=1, step=1, format=\"%i\",\n )\n is_active = st.number_input(\n \"is active\", value=1, min_value=0, max_value=1, step=1, format=\"%d\"\n )\n credit_value = st.number_input(\n \"Credits\", value=1, min_value=0, max_value=1, step=1, format=\"%d\"\n )\n\n record_data = {\n \"trx_type\": trx_type,\n \"artist\": artist if artist != \"\" else \"NA\",\n \"artist_country\": artist_country if artist_country != \"\" else \"NA\",\n \"title\": title if title != \"\" else None,\n \"genre\": genre,\n \"label\": label if label != \"\" else \"NA\",\n \"year\": year,\n \"record_format\": record_format,\n \"vinyl_color\": vinyl_color if vinyl_color != \"\" else None,\n \"lim_edition\": lim_edition if lim_edition != \"\" else None,\n \"number\": number if number != \"\" else None,\n \"remarks\": remarks if remarks != \"\" else None,\n \"purchase_date\": purchase_date,\n \"price\": price,\n \"rating\": rating\n if rating not in [\"\", \"None\"]\n else None, # TODO Check if that has solved the None problem\n \"is_digitized\": is_digitized,\n \"is_active\": is_active,\n \"credit_value\": credit_value,\n }\n return record_data", "def show_injection_results(self):\r\n #save data\r\n store = get_store()\r\n try:\r\n store.put('Capillary', value=float(self.ids.Capillary.text),\r\n unit=self.ids.CapillaryUnit.text)\r\n store.put('Towindow', value=float(self.ids.Towindow.text),\r\n unit=self.ids.TowindowUnit.text)\r\n store.put('Idiameter', value=float(self.ids.Idiameter.text),\r\n unit=self.ids.IdiameterUnit.text)\r\n store.put('Pressure', value=float(self.ids.Pressure.text),\r\n unit=self.ids.PressureUnit.text)\r\n store.put('Time', value=float(self.ids.Time.text),\r\n unit=self.ids.TimeUnit.text)\r\n store.put('Viscosity', value=float(self.ids.Viscosity.text),\r\n unit=self.ids.ViscosityUnit.text)\r\n store.put('Concentration', \r\n value=float(self.ids.Concentration.text), \r\n unit=self.ids.ConcentrationUnit.text)\r\n store.put('Molweight', value=float(self.ids.Molweight.text),\r\n unit=self.ids.MolweightUnit.text)\r\n store.put('Voltage', value=float(self.ids.Voltage.text),\r\n unit=self.ids.VoltageUnit.text)\r\n except ValueError:\r\n data = {}\r\n data[\"errcode\"] = 1\r\n data[\"errtext\"] = \"Empty field not allowed\"\r\n self._popup = ErrorPopup()\r\n self._popup.show_popup(data)\r\n return\r\n #add data \r\n computation = Capillary()\r\n errcode, errtext = computation.save_injection_result()\r\n data = {}\r\n data[\"errcode\"] = errcode\r\n data[\"errtext\"] = errtext\r\n if data[\"errcode\"] == 1:\r\n self._popup = ErrorPopup()\r\n else:\r\n self._popup = InjectionPopup()\r\n self._popup.show_popup(data)", "def enterParameters(self,**kwargs):\n\n members = self.bl.getAllParameters().keys() \n entries={}\n\n for param in members:\n entries[param] = getattr(self.bl, 'paramSelection') # save param names in entries\n entries['view selection'] = [getattr(self.bl, 'displayText'), str(self.bl.getAllParameters())]\n entries['reset selection'] = getattr(self.bl, 'paramReset')\n self.mm.addGenericMenu(\"param\",self.mm.cur_page,\"Select your desired params for this operation\", entries)\n self.mm.loadMenu(\"param\")", "def get(self, request):\n try:\n launchParams = Setting.getLaunchParams()\n d = {}\n for tri,color in ((0,\"r\"), (1,\"g\"), (2,\"b\")):\n for vert in (0, 1, 2):\n v = color + \"v{}\".format(vert)\n name,lat,lon,angle = launchParams[tri][vert]\n d[v + \"name\"] = name\n d[v + \"lat\"] = lat\n d[v + \"lon\"] = lon\n d[v + \"angle\"] = angle\n cname,sidelen = launchParams[tri][3]\n d[color + \"vcname\"] = cname\n d[color + \"sidelen\"] = sidelen\n self.context[\"form\"] = AddLaunchParamsForm(initial=d)\n except:\n self.context[\"form\"] = AddLaunchParamsForm()\n form = self.context[\"form\"]\n\n return render(request, \"dbkeeper/add_launch_params.html\", self.context)", "def add(self):\n try:\n self.active_table.add_row(Row.Row([obj.get() for obj in self.enter_values]))\n self.parent.display_content()\n self.master.withdraw()\n except UnableToCastException as err:\n messagebox.showerror(\"Error\", err)", "def form_success_return(result):\n return { 'code' : 0, 'value' : result, 'output' : None }", "def return_book():\n return_book_tk = ReturnBookDialog()\n entries_args = [\n (\"Book ID : \", 0.5),\n ]\n return_book_tk.create_components(entries_args)\n return_book_tk.mainloop()", "def add_return(self, input_name, name=None):\n return self._build_op('return', [input_name], name=name)", "def get(self):\n return render_template('add.html')", "def get_return_fields(self, all_types: \"Dict[str, SchemaType]\") -> Tuple[SelectedField]:\n if self._return_fields is None:\n from qlient import helpers\n self._return_fields = helpers.adapt_return_fields(\n self.return_type,\n all_types,\n self.settings.max_recursion_depth\n )\n return self._return_fields", "def add_response():\n a = int(request.args[\"a\"])\n b = int(request.args[\"b\"])\n\n result = add(a,b)\n return f\"<h1>{result}</h1>\"", "def process_selected(self):\n self.processTableWidget.clear()\n pr = self.backend.get_process(str(self.processBox.currentText()))\n\n myFont = QtGui.QFont()\n myFont.setBold(True)\n self.label_9.setFont(myFont)\n\n if not pr:\n self.label_9.setText(\"Returns:\")\n return\n\n self.label_9.setText(\"Returns: {}\".format(str(pr.get_return_type())))\n\n self.processTableWidget.setRowCount(len(pr.parameters))\n self.processTableWidget.setColumnCount(3)\n self.processTableWidget.setHorizontalHeaderLabels(['Parameter', 'Type', 'Description'])\n header = self.processTableWidget.horizontalHeader()\n header.setSectionResizeMode(0, QtWidgets.QHeaderView.ResizeToContents)\n header.setSectionResizeMode(1, QtWidgets.QHeaderView.ResizeToContents)\n header.setSectionResizeMode(2, QtWidgets.QHeaderView.Stretch)\n\n counter = 0\n for param in pr.parameters:\n qitem = QTableWidgetItem(param.name)\n qitem.setFlags(QtCore.Qt.ItemIsEnabled)\n\n if not param.optional:\n bold_font = QtGui.QFont()\n bold_font.setBold(True)\n qitem.setFont(bold_font)\n\n self.processTableWidget.setItem(counter, 0, qitem)\n\n param_type = QTableWidgetItem(str(param.get_type()))\n param_type.setFlags(QtCore.Qt.ItemIsEnabled)\n self.processTableWidget.setItem(counter, 1, param_type)\n\n if param.description:\n desc = QTableWidgetItem(str(param.description))\n desc.setFlags(QtCore.Qt.ItemIsEnabled)\n self.processTableWidget.setItem(counter, 2, desc)\n else:\n desc = QTableWidgetItem(\"\")\n desc.setFlags(QtCore.Qt.ItemIsEnabled)\n self.processTableWidget.setItem(counter, 2, desc)\n\n counter += 1", "def get(self):\r\n return_url = self.request.get(\"return_url\")\r\n template_values = {\r\n \"user_form\" : User.to_form(return_url, mode=\"add\")\r\n }\r\n self.render_out(\"templates/register.html\", template_values)", "def newParameter(self):\n numParams = self.ui.parameterList.rowCount()\n self.ui.parameterList.insertRow(numParams)", "def response_add(self, request, obj, post_url_continue=None):\n # We should allow further modification of the user just added i.e. the\n # 'Save' button should behave like the 'Save and continue editing'\n # button except in two scenarios:\n # * The user has pressed the 'Save and add another' button\n # * We are adding a user in a popup\n if '_addanother' not in request.POST and IS_POPUP_VAR not in request.POST:\n request.POST['_continue'] = 1\n return super(UserAdmin, self).response_add(request, obj,\n post_url_continue)", "def get_project_add_form():\n\n return render_template(\"project_add.html\")", "def render_form():", "def displayInput(self):\n\n ## Before changes are committed the user can see all changes made\n print(\"\\nCurrent Record:\\n===============\\nName: \" + self.first_name.title() + \" \" + self.last_name.title() + \"\\nCompany: \" + self.company_name.title() + \"\\nAddress: \" + self.address.title() + \"\\nCity: \" + self.city.title() + \"\\nState: \" + self.state_code.upper() + \"\\nZip Code: \" + str(self.zip_code) + \"\\nPrimary Phone: \" + self.phone_number + \"\\nSecondary Phone: \" + self.phone_number_2 + \"\\nEmail: \" + self.email_address)", "def add_row() -> str:\r\n return render_template(\"add_row.html\")", "def get_student_add_form():\n\n return render_template(\"student_add.html\")", "def show_add_student_form():\n\n return render_template(\"add_student_form.html\")", "def get_add_form(self):\n rv = self.get(self.add_url)\n assert not is_404(rv)\n assert in_response(rv, 'Add {}'.format(self.nice_name))\n for field, name in self.fields:\n assert in_response(rv, name)\n return rv", "def display_record_removal_form_and_return_data():\n removal_date = st.date_input(\"Removal Date\", value=dt.date.today())\n credit_value: int = st.number_input(\n \"Credits\", value=0, min_value=0, max_value=1, step=1, format=\"%d\",\n )\n return removal_date, credit_value", "def choice_of_param():\n global output1, confirmation, win_create_delete_str, result\n result = get_result_from_db()\n if result == 'Значение не найдено в базе данных!':\n output1.delete(1.0, END)\n mistake_not_found()\n\n output1.delete(1.0, END)\n if len(result) == 1:\n confirmation = Label(win_create_delete_str, text=\"Вы действительно хотите удалить эту строку?\")\n elif len(result) > 1:\n confirmation = Label(win_create_delete_str, text=\"Вы действительно хотите удалить эти строки?\")\n confirmation.place(x=15, y=40)\n for i in range(len(result)):\n output1.insert(END, result[i])\n output1.insert(END, '\\n')\n\n return result", "def returns(self, return_value):\n self._context.set_last_return(self, return_value)\n return self" ]

[ "0.5159244", "0.5159088", "0.51492167", "0.5143759", "0.5083419", "0.502979", "0.5025307", "0.5007266", "0.50014144", "0.49637106", "0.49195036", "0.48437077", "0.481711", "0.4801792", "0.47871172", "0.4770667", "0.47538763", "0.47397462", "0.47369665", "0.46932358", "0.46872762", "0.46819907", "0.467943", "0.46635348", "0.4660666", "0.46424055", "0.46336374", "0.46230698", "0.46187326", "0.46074688" ]

[ "def _onSettings(self, event):\n dialog = sc.SettingsDialog(self)\n if dialog.ShowModal() == wx.ID_OK:\n dialog.saveSettings()\n dialog.Destroy()", "def save(self):\n return self.client._perform_empty(\"PUT\", \"/admin/general-settings\", body = self.settings)", "def save_settings(self):\n logger.info(f'Saving settings: {self.settings_dict}')\n for k, section in self.settings_dict.items():\n for setting_name in section.keys():\n value = self.get_control_value(setting_name)\n if value is not None:\n section[setting_name] = value\n\n write_settings(self.settings_dict)", "def showSettings(self):\n self.c.show()", "def settings_view():\n return template('settings.html')", "def wmSaveSettings(self):\n sModule = uiCommon.getAjaxArg(\"module\")\n sSettings = uiCommon.getAjaxArg(\"settings\")\n\n # sweet, use getattr to actually get the class we want!\n objname = getattr(settings.settings, sModule.lower())\n obj = objname()\n if obj:\n # spin the sValues array and set the appropriate properties.\n # setattr is so awesome\n for pair in sSettings:\n setattr(obj, pair[\"name\"], pair[\"value\"])\n # print \"setting %s to %s\" % (pair[\"name\"], pair[\"value\"])\n # of course all of our settings classes must have a DBSave method\n obj.DBSave()\n catocommon.add_security_log(uiCommon.GetSessionUserID(), catocommon.SecurityLogTypes.Security,\n catocommon.SecurityLogActions.ConfigChange, catocommon.CatoObjectTypes.NA, \"\",\n \"%s settings changed.\" % sModule.capitalize())\n\n return \"{}\"", "def testSaveSettings(self):\n \n self.waitForElement(\"link=Settings\")\n self.selenium.click(\"link=Settings\")\n self.selenium.wait_for_page_to_load(self.WAITTIME)\n self.selenium.click(\"name=zmanage_editProperties:method\")\n self.selenium.wait_for_page_to_load(self.WAITTIME)", "def save(self):\n sublime.save_settings(self.file_name)", "def render_settings_view():\n return render_template('settings_screen.html', realsense_device_status=realsense_enabled, detector_enabled=enabled_detector)", "def save_settings(self):\r\n self.QtSettings.beginGroup(\"MainWindow\")\r\n self.QtSettings.setValue(\"geometry\",self.saveGeometry())\r\n self.QtSettings.setValue(\"state\",self.saveState())\r\n self.QtSettings.endGroup()\r\n \r\n #save element content\r\n self.QtSettings.beginGroup(\"Settings\")\r\n pyguitools.gui_save(self.ui,self.QtSettings)\r\n self.QtSettings.endGroup()", "def show_saved(self):\n self._saved_text.set_text(\"Saved\")", "def saveSettings(self):\n # settings object\n settings = QtCore.QSettings()\n\n # store current working directory\n settings.setValue(\"mainWindow/currentDirectory\", os.getcwd())\n\n # window size\n settings.setValue(\"mainWindow/size\", self.size())", "def save_settings(self):\n settings = {'camera': self.comboCamera.currentIndex(),\n 'rotation': self.comboRotation.currentIndex(),\n 'colors': {\n 'min_hue': self.spinMinHue.value(),\n 'max_hue': self.spinMaxHue.value(),\n 'min_saturation': self.spinMinSaturation.value(),\n 'max_saturation': self.spinMaxSaturation.value(),\n 'min_value': self.spinMinValue.value(),\n 'max_value': self.spinMaxValue.value(),\n }, 'diameter': self.spinDiameter.value(),\n 'lifter': self.lineEditLifter.text(),\n 'save_video': self.checkSaveVideo.isChecked()\n }\n settings_file = open('./resources/settings.json', 'w')\n json.dump(settings, settings_file, indent=4)\n settings_file.close()\n self.statusbar.clearMessage()\n self.statusbar.showMessage('Settings saved.', 5000)", "def saveSettings(self):\n helpers.saveFile(self.dataDir, self.settingsFilename, json.dumps(self.settings))", "def page_settings(state):\n\n st.title(\":wrench: Settings\")\n st.markdown(\"## **Your chosen settings:**\")\n display_state_values(state)\n\n st.write(\"---\")\n st.markdown(\"#### Enter Stock Ticker Symbols:\")\n state.stocks = st.text_input(\n \"Enter Stock Symbols Separated by Commas (EX: AAPL, MSFT):\",\n state.stocks or \"\",\n )\n\n state.stocks = state.stocks\n state.stocks_list = state.stocks.split(\", \")\n\n st.markdown(\"#### Choose dataset size to train models with:\")\n options = [\"5d\", \"1mo\", \"3mo\", \"6mo\", \"1y\", \"5y\", \"10y\", \"max\"]\n\n state.period = st.radio(\n \"Choose amount of historical training data. 1 year is recommended, find more recommendations on homepage.\",\n options,\n options.index(state.radio) if state.radio else 0,\n )\n\n if st.button(\"Run the Tool\", state.run_button):\n state.run_button_checked = True\n st.markdown(\n \"### *PLEASE WAIT! Scraping data, training models, and generating prediction results NOW!*\"\n )\n state.scraped_data = scraper.perform_scraping(state.stocks_list, state.period)\n state.finalized_data = prediction.run_predictor(\n state.scraped_data, state.period\n )\n\n if state.run_button_checked == True:\n st.markdown(\"## *Go to the dashboard to view your newly scraped data data.*\")\n\n if run_location == \"local\":\n st.markdown(\"### Export Options\")\n if st.checkbox(\"Would you like to export results?\", state.export_checkbox):\n state.export_checkbox = True\n st.markdown(\n \"#### Enter New or Existing Export File Name (filename.json):\"\n )\n state.file_name = st.text_input(\n \"Enter the export filename.\", state.input or \"\"\n )\n if state.file_name:\n for data in state.finalized_data:\n json_handler.append_json(\n data[\"prediction_results\"], state.file_name\n )\n st.markdown(\"Your data has been exported!\")\n else:\n st.markdown(\"Enter a file name to export data!\")", "def save(self):\n num_pages = len(self._saved_page_states)\n for state in self._saved_page_states:\n self.__dict__.update(state)\n self.draw_page_number(num_pages)\n self.add_logo()\n if(self._pageNumber != 1):\n self.drawString(5, HEIGHT-70, \"VSS - Security Overview Report\")\n canvas.Canvas.showPage(self)\n canvas.Canvas.save(self)", "def saveInConfigFileDlg( self ):\n pass", "def settings():\n # TODO: How should this be handled? Should a speaker's bio be stored\n # as a snapshot from event to event? It could be stored as part of a\n # talks.models.Presentation.\n from pygotham.forms import ProfileForm\n\n form = ProfileForm(request.form, obj=current_user)\n if form.validate_on_submit():\n form.populate_obj(current_user)\n db.session.commit()\n\n flash('Your profile has been updated.', 'success')\n\n return redirect(url_for('profile.settings'))\n\n return render_template('profile/settings.html', form=form)", "def updateSettingsUI(self):\n\n pass", "def save_changes(self):\n\n velib, autolib, subway = None, None, None\n for key, value in VELIB_SUBSCRIPTIONS.iteritems():\n if self._velib.get() == value:\n velib = key\n break\n for key, value in AUTOLIB_SUBSCRIPTIONS.iteritems():\n if self._autolib.get() == value:\n autolib = key\n break\n for key, value in SUBWAY_SUBSCRIPTIONS.iteritems():\n if self._subway.get() == value:\n subway = key\n break\n preferences = {\n FASTEST: self._fastest.get(),\n SHORTEST: self._shortest.get(),\n CHEAPEST: self._cheapest.get(),\n SIMPLEST: self._simplest.get(),\n WEATHER_IMPACT: self._weather_impact.get(),\n LESS_PAINFUL: self._less_painful.get(),\n LESS_WALKING: self._less_walking.get()\n }\n\n result = self._system.set_profile_settings(velib, autolib, subway, self._driving_licence.get(), preferences)\n if not result[\"success\"]:\n showerror('Erreur système', result[\"error\"])\n return\n\n # Redirection vers la page principale\n from settings import RideSettingsPage\n self.pack_forget()\n RideSettingsPage(self._window, self._system)", "def save_settings(self):\n with open(self.settings_path, \"w\") as f:\n json.dump(self.settings, f, indent=4)", "def save( self ):\n ini = codecs.open(self.filename,\"w\",\"utf-8\",errors=\"replace\",buffering=0)\n for (name,value) in self.conf.items():\n print >>ini, name, \"=\", value\n ini.close()", "def saveSettings():\t\n\tglobal settings\n\tfout = open(config_file,'w')\n\tfout.write(json.dumps(settings, sort_keys=True, indent=4))\n\tfout.close()", "def general_settings(request):\n serversettings = TeamspeakServer.objects.get(id=1)\n saved = False\n if request.method == \"POST\":\n serversettings.host = request.POST['ts3hostname']\n serversettings.voiceport = int(request.POST['Port'])\n serversettings.queryuser = request.POST['QueryLoginUsername']\n if request.POST['QueryLoginPasswort'] != '':\n serversettings.querypass = request.POST['QueryLoginPasswort']\n serversettings.queryport = int(request.POST['QueryPort'])\n serversettings.save()\n saved = True\n\n return TemplateResponse(\n request, 'teamspeak_settings.html',\n {'ts3hostname': serversettings.host,\n 'Port': serversettings.voiceport,\n 'QueryLoginUsername': serversettings.queryuser,\n 'QueryLoginPasswort': serversettings.querypass,\n 'QueryPort': serversettings.queryport,\n 'saved': saved}\n )", "def showSettings():\n cq = dz()\n cq.abag()", "def save(self):\r\n return self.format_inline('SAVE')", "def save(self):\n for name, obj in inspect.getmembers(self.ui):\n if isinstance(obj, QSpinBox):\n name = obj.objectName()\n value = obj.value()\n self.settings.setValue(name, value)\n\n if isinstance(obj, QDoubleSpinBox):\n name = obj.objectName()\n value = obj.value()\n self.settings.setValue(name, value)\n\n if isinstance(obj, QLineEdit):\n name = obj.objectName()\n value = obj.text()\n self.settings.setValue(name, value)\n\n if isinstance(obj, QRadioButton):\n name = obj.objectName()\n value = obj.isChecked()\n self.settings.setValue(name, value)\n\n if isinstance(obj, QComboBox):\n index = obj.currentIndex() # get current index from combobox\n value = obj.itemText(index)\n self.settings.setValue(name, value)", "def save_settings(self, plugin_settings, instance_settings):\n instance_settings.set_value(\"output_directory\", self.output_directory)\n instance_settings.set_value(\"labels\", self.labels)\n if self._sub:\n instance_settings.set_value(\"topic_name\", self._sub.name)", "def saveSettings(self):\n e = constrain.saveSettings(self)\n e.attrib['status'] = ('true' if self.status else 'false')\n return e", "def action_settings(self):\n\n cur_datadir = self.config.starbound_data_dir\n settings = SettingsDialog(self)\n settings.exec()\n new_datadir = self.config.starbound_data_dir\n if new_datadir:\n if cur_datadir != new_datadir:\n self.load_data()\n self.scene.refresh(self.data)\n else:\n self.close_world()\n\n # Make sure our menus are enabled/disabled as appropriate\n self.enforce_menu_state()\n\n # Re-focus the main window\n self.activateWindow()" ]

[ "0.6948361", "0.6705164", "0.6664211", "0.66351837", "0.6594391", "0.6520603", "0.64986426", "0.64945", "0.6485608", "0.64128584", "0.63740045", "0.63704425", "0.63322747", "0.6324476", "0.6320958", "0.63104993", "0.6297963", "0.6241315", "0.6220317", "0.61829704", "0.6119481", "0.6077782", "0.6018466", "0.60177225", "0.5963194", "0.5944273", "0.5922394", "0.59148866", "0.5911474", "0.5899445" ]

[ "def _loss_std_mean(self, iterations):\n\n loss_array = np.array(self._loss_list[-iterations:])\n return loss_array.mean(), loss_array.std()", "def unstandardize(da: xr.DataArray, mean: xr.DataArray, std: xr.DataArray):\n return (std * da) + mean", "def mean_std_calc(dataloader):\n mean = 0\n std = 0\n samples = 0\n for data, _, _ in dataloader:\n batch_samples = data.size(0)\n data = data.view(batch_samples, data.size(1), -1)\n mean += data.mean(2).sum(0)\n std += data.std(2).sum(0)\n samples += batch_samples\n\n return (mean / samples),(std / samples)", "def get_mean_and_std(arr):\r\n return np.round(np.mean(arr), 3), np.round(np.std(arr), 3)", "def standardize(\n da: xr.DataArray,\n mean: Optional[xr.DataArray] = None,\n std: Optional[xr.DataArray] = None,\n dim: str = \"time\",\n) -> Tuple[Union[xr.DataArray, xr.Dataset], xr.DataArray, xr.DataArray]:\n if mean is None:\n mean = da.mean(dim)\n if std is None:\n std = da.std(dim)\n with xr.set_options(keep_attrs=True):\n return (da - mean) / std, mean, std", "def mean_STD(self,counter):\n \n \n pass", "def avg_std_dev(positions):\n # print(\"len pos = \", len(positions))\n # print(positions)\n if sum(positions) == 0:\n the_mean = 0\n standard_dev = 0\n return the_mean, standard_dev \n try:\n the_mean = sum(positions) / float(len(positions))\n standard_dev = numpy.std(positions)\n except ValueError:\n the_mean = 0\n standard_dev = 0\n return the_mean, standard_dev", "def compute_mean_std(x):\n x = np.hstack(x)\n return (np.mean(x).astype(np.float32),\n np.std(x).astype(np.float32))", "def _compute_mean_std(self, sum_, ssum, size):\n assert size > 1, 'BatchNorm computes unbiased standard-deviation, which requires size > 1.'\n mean = sum_ / size\n sumvar = ssum - sum_ * mean\n unbias_var = sumvar / (size - 1)\n bias_var = sumvar / size\n\n self.running_mean = (1 - self.momentum) * self.running_mean + self.momentum * mean.data\n self.running_var = (1 - self.momentum) * self.running_var + self.momentum * unbias_var.data\n\n return mean, bias_var.clamp(self.eps) ** -0.5", "def tolerant_mean(arrs: List[Any]) -> Tuple[Any]:\n lens = [len(i) for i in arrs]\n if len(arrs[0].shape) == 1:\n arr = np.ma.empty((np.max(lens), len(arrs)))\n arr.mask = True\n for idx, l in enumerate(arrs):\n arr[: len(l), idx] = l\n else:\n arr = np.ma.empty((np.max(lens), arrs[0].shape[1], len(arrs)))\n arr.mask = True\n for idx, l in enumerate(arrs):\n arr[: len(l), :, idx] = l\n return arr.mean(axis=-1), arr.std(axis=-1)", "def weightedMean(averages, stddevs):\n\n ndatapoints = averages.shape[0]\n\n # This is if we are doing an array of parameters\n try:\n # There might be some problems with this part of the code\n # Get the number of parameters\n nparams = averages.shape[1]\n # initialise blank arrays\n weighted_means = np.zeros(nparams)\n total_stddevs = np.zeros(nparams)\n # Loop over the parameters\n for i in range(nparams):\n stddevs2 = np.zeros(stddevs[i].shape[1])\n for j in range(len(stddevs[i].T)):\n stddevs2[j] = stddevs[i].T[j].max()\n weighted_mean = np.sum(averages[i]/stddevs2**2, axis = 0)/ np.sum(1./stddevs2**2, axis = 0)\n weighted_means[i] = weighted_mean\n fdis2 = np.sum( ((averages[i] - weighted_mean)**2) / ((stddevs2**2) * (ndatapoints - 1)) , axis =0)\n total_variance = fdis2 * (1 / np.sum(1/(stddevs2**2), axis =0) )\n total_stddevs[i] = np.sqrt(total_variance)\n return weighted_means, total_stddevs\n\n except:\n stddevs2 = np.zeros(len(stddevs.T))\n for j in range(len(stddevs.T)):\n stddevs2[j] = stddevs.T[j].max()\n weighted_mean = np.sum(averages/stddevs2**2, axis = 0)/ np.sum(1./stddevs2**2, axis = 0)\n fdis2 = np.sum( ((averages - weighted_mean)**2) / ((stddevs2**2) * (ndatapoints - 1)) , axis =0)\n total_variance = fdis2 * (1 / np.sum(1/(stddevs2**2), axis =0) )\n total_stddev = np.sqrt(total_variance)\n return weighted_mean, total_stddev", "def mean_stdev_numeric_attribute(nodes: typ.Iterable[vtna.graph.TemporalNode], attribute_name: str) \\\n -> typ.Tuple[float, float]:\n values = [node.get_global_attribute(attribute_name) for node in nodes]\n return float(np.mean(values)), float(np.std(values))", "def standardize(x, mean=None, std=None): \n \n mean = mean if mean is not None else x.mean(axis=0)\n std = std if std is not None else x.std(axis=0) \n \n return (x - mean) / std, mean, std", "def std(X,trimming=0):\n \n if trimming==0:\n s = np.power(np.var(X,axis=0),.5)\n s = np.array(s).reshape(-1)\n else: \n var = sps.trim_mean(np.square(X - sps.trim_mean(X,trimming,0)),\n trimming,0)\n s = np.sqrt(var) \n return s", "def standardize(X):\n X_std = X\n mean = X.mean(axis=0)\n std = X.std(axis=0)\n for col in range(np.shape(X)[1]):\n if std[col]:\n X_std[:, col] = (X_std[:, col] - mean[col]) / std[col]\n # X_std = (X - X.mean(axis=0)) / X.std(axis=0)\n return X_std", "def mov_mean_std(ts, m):\n\n if m <= 1:\n raise ValueError(\"Query length must be longer than one\")\n\n ts = ts.astype(\"float\")\n\n # Add zero to the beginning of the cumsum of ts\n s = np.insert(np.cumsum(ts), 0, 0)\n\n # Add zero to the beginning of the cumsum of ts ** 2\n s_sq = np.insert(np.cumsum(ts ** 2), 0, 0)\n seg_sum = s[m:] - s[:-m]\n seg_sum_sq = s_sq[m:] - s_sq[:-m]\n return seg_sum / m, np.sqrt(seg_sum_sq / m - (seg_sum / m) ** 2)", "def find_mean_std(self, data):\n if self._data_mean is None:\n self._data_mean = np.mean(data)\n if self._data_std is None:\n self._data_std = np.std(data)", "def get_dataset_normalization_mean_std(name):\n if name == 'em-corr-arduino' or name == 'em-cpa-arduino':\n mean = 0.014595353784991782\n std = 0.006548281541447703\n elif name == 'ASCAD':\n mean = -11.587280595238095\n std = 25.75363459386104\n elif name == 'ASCAD_desync50':\n mean = -11.195121833333333\n std = 25.89963055607876\n elif name == 'ASCAD_desync100':\n mean = -11.093145738095238\n std = 26.11483790582092\n else:\n return 0.0, 1.0\n\n return mean, std", "def mean_std(array, errors = None):\n \n array = list(array)\n \n if array == []:\n return np.NaN, np.NaN\n \n if not is_iterable(errors) or len(array) != len(errors):\n return np.mean(array), np.std(array)\n else:\n return np.mean(array), np.mean(errors)", "def wo_mean(arr):\n\n return np.array(arr) - np.mean(arr, axis=0)", "def standardise(tx, mean=None, std=None):\n if((mean is None) and (std is None)):\n mean = np.mean(tx, axis=0)\n std = np.std(tx, axis=0)\n tx = tx - mean\n tx = tx / std\n return tx, mean, std", "def _get_aggregated_mean_std(self, means, stds, n):\n mean = means.view(n, -1).sum(0) / n\n std = (\n stds.view(n, -1).sum(0) / n\n + ((means.view(n, -1) - mean) ** 2).view(n, -1).sum(0) / n\n )\n return mean.detach(), std.detach()", "def meanstd(self):\n\t\tmean = [125.3, 123.0, 113.9] # R,G,B\n\t\tstddev = [63.0, 62.1, 66.7] # R,G,B\n\t\treturn [mean, stddev]", "def calc_mean_stdev(data):\n\n pop_stdev = pstdev(data)\n pop_mean = mean(data)\n\n return pop_mean, pop_stdev", "def deviationAvg(xs):\n\treturn deviation(xs) / sqrt(len(xs))", "def average_std_grid(grid):\n return np.nanmean(grid, axis=0), np.nanstd(grid, axis=0)", "def standardize(x, axis=-1):\n stds_avg = np.std(x, axis=axis, keepdims=True)\n x -= np.mean(x, axis=axis, keepdims=True)\n x /= (stds_avg + 1e-8)\n return x", "def std(values, ave):\n return math.sqrt(float(sum((value-ave)**2 for value in values))/len(values))", "def get_mean_and_std(dataset):\n dataloader = torch.utils.data.DataLoader(\n dataset, batch_size=1, shuffle=True, num_workers=2\n )\n mean = torch.zeros(3)\n std = torch.zeros(3)\n print(\"==> Computing mean and std..\")\n for inputs, targets in dataloader:\n for i in range(3):\n mean[i] += inputs[:, i, :, :].mean()\n std[i] += inputs[:, i, :, :].std()\n mean.div_(len(dataset))\n std.div_(len(dataset))\n return mean, std", "def nanstd(self, axis=0, **kwargs) -> \"Dataset\":\n return self.aggregate(axis=axis, func=np.nanstd, **kwargs)" ]

[ "0.6982349", "0.6848713", "0.68165255", "0.67980915", "0.66196024", "0.66095495", "0.65971655", "0.6595731", "0.6563074", "0.65236825", "0.64669746", "0.644305", "0.64084727", "0.63442326", "0.63397527", "0.63314974", "0.6327874", "0.63175726", "0.63169307", "0.6295772", "0.6279268", "0.6268242", "0.6263149", "0.6252507", "0.6248895", "0.6242027", "0.62386686", "0.6232471", "0.6206268", "0.62031835" ]

[ "def test_update_owner(cards_db):\n i = cards_db.add_card(Card(\"foo\", owner=\"me\"))\n cards_db.update_card(i, Card(owner=\"not me\", state=None))\n\n mod = cards_db.get_card(i)\n assert mod == Card(\"foo\", owner=\"not me\")", "def test_update_both(cards_db):\n i = cards_db.add_card(Card(\"foo\", owner=\"me\"))\n cards_db.update_card(i, Card(summary=\"bar\", owner=\"not me\"))\n\n mod = cards_db.get_card(i)\n assert mod == Card(\"bar\", owner=\"not me\", state=\"todo\")", "def test_laborer_non_existent_card(self):\n d = self.deck\n self.game.pool.set_content([d.atrium0])\n\n mon = Monitor()\n mon.modified(self.game)\n\n a = message.GameAction(message.LABORER, d.dock0)\n with self.assertRaises(GTRError):\n self.game.handle(a)\n\n self.assertFalse(mon.modified(self.game))", "def test_cards_put(self):\n pass", "def test_update_exchange_not_exists(self):\n values = {\"exchange_name\": \"111\", \"api_key\": \"111\", \"secret\": \"111\"}\n ret = self.app.update_exchange(20, values)\n self.assertIn(ret[0], \"error\")", "def test_update_card(self):\n data = {\n 'first_name': 'Ty',\n 'last_name': 'Cobb',\n 'variety': 'green portrait'\n }\n CardFactory()\n self.session.commit()\n resp = self.app.put('cards/1', json=data)\n\n assert resp.status_code == 200\n\n assert data['first_name'] == resp.json['first_name']\n assert data['last_name'] == resp.json['last_name']\n assert data['variety'] == resp.json['variety']", "def test_update_no_customer(self):\n set_up_db()\n with self.assertRaises(ValueError):\n update_customer_credit(2, 5.50)", "def changeCard(self, card):\n if not card in self.influence:\n # todo: create a Coup-specific exception\n raise BaseException(\"%s is not found in player's influence. Something went wrong\" % card)\n \n self.influence.remove(card)\n GameState.AddToDeck(card)\n \n newCard = GameState.DrawCard()\n self.influence.append(newCard)", "def is_valid_retrieval(self, card_index):\n return card_index == 0", "def is_valid_retrieval(self, card_index):\n return card_index == 0", "def test_update_summary(cards_db):\n i = cards_db.add_card(Card(\"foo\", owner=\"me\", state=\"done\"))\n cards_db.update_card(i, Card(summary=\"bar\", state=None))\n\n mod = cards_db.get_card(i)\n assert mod == Card(\"bar\", owner=\"me\", state=\"done\")", "def test_update_nonexist(self):\n promotion = PromotionFactory()\n promotion.id = '1cak41-nonexist'\n try:\n promotion.update()\n except KeyError:\n self.assertRaises(KeyError)", "def remove_card(self, card):\n try:\n \tself.deckcards.remove(card)\n\texcept:\n\t\tif len(self.deckcards)==0:\n\t\t\tprint(\"card cannot be removed, deck is empty\")", "def test_update_community_name_to_an_existing_one_fails(self):\n self.login_as(\"bob\")\n\n bad_payload = self.update_payload.copy()\n bad_payload[\"name\"] = \"group2\"\n\n with self.assertNumQueries(5):\n response = self.client.put(self.url, bad_payload)\n self.assert_validation_failed(response, data={\n \"name\": [\"community with this name already exists.\"]\n })\n self.assertEqual(Community.objects.filter(name=\"group2\").count(), 1)", "def set_card (self, card):\n\t\tif ((card == 1) or (card == 2)):\n\t\t\tself._card = card\n\t\telse:\n\t\t\tsys.stderr.write(\"\\nERROR : %s card number must be 1 or 2 so it can't be %s !\\n\" % (self._target_id, card))\n\t\t\tsys.exit(1)", "def test_privatize_fountain_card(self):\n g = Game()\n g.add_player(uuid4(), 'p0')\n g.add_player(uuid4(), 'p1')\n\n gs = g\n p0, p1 = gs.players\n\n latrine, insula, statue, road = cm.get_cards(['Latrine', 'Insula', 'Statue', 'Road'])\n p0.fountain_card = latrine\n\n gs_private = g.privatized_game_state_copy('p1')\n p0, p1 = gs_private.players\n\n self.assertEqual(p0.fountain_card, Card(-1))", "def test_card_id_present_but_no_signup_yet(self):\n machine_id = helpers.create_coffee_machine(self.app, \\\n \"Senseo Floor 5\", 0.35, \"EUR\" )\n\n card_id = helpers.gen_card_id() \n\n data = { \"card_id\" : card_id, \n \"api_key\" : utils.api_key,\n \"machine_id\" : machine_id }\n\n # make backend aware of card_id\n res = self.app.put(coffeeapp.coffee_count_api_path, data=data)\n assert 200 == res.status_code\n res_json = json.loads(res.data)\n assert res_json.has_key(\"known\")\n assert res_json[\"known\"] == False\n assert res_json.has_key(\"short_pin\")\n assert res_json.has_key(\"url\")\n\n res = self.app.put(coffeeapp.coffee_count_api_path, data=data)\n # now it should respond with the same data\n assert 200 == res.status_code\n res_json = json.loads(res.data)\n assert res_json.has_key(\"known\")\n assert res_json[\"known\"] == False\n assert res_json.has_key(\"short_pin\")\n assert res_json.has_key(\"url\")", "def giveCard(self, card:Card, otherHand):\r\n if card in self.cards:\r\n otherHand.addCard(card)\r\n self.cards.remove(card)\r\n else:\r\n print(\"can't give that card\")", "def test_beneficiaries_update_withoutID_that_will_fail(self):\n print('the test function name: {}'.format(sys._getframe().f_code.co_name))\n try:\n url = reverse('beneficiary:beneficiary-entity-by-id-update')\n response = self.client.get(url, content_type='application/json')\n return self.assertTrue(response.status_code, 200)\n except Exception as e:\n print(\"reason: \", e)", "def test_update_exchange_value_empty(self):\n new_exchange = self.app.add_exchange(\"test\", \"test\", \"test\")\n values = {\"exchange_name\": \"\", \"api_key\": \"111\", \"secret\": \"111\"}\n ret = self.app.update_exchange(new_exchange.id, values)\n self.assertIn(ret[0], \"error\")", "def test_validate_response(db_conn, cards_table):\n\n assert False", "def admin_card_update(card_id):\n mongo_collection = mongo_database[\"questions\"]\n card = mongo_collection.find_one({\"id\": card_id})\n return render_template(\n \"admin_card_update.html\",\n card=card,\n datetime=date_today.strftime(\"%x\"),\n admin_logged=session.get('logged_in'),\n admin_session=session\n )", "def test_create_card_missing_name(self):\n data = {\n 'first_name': 'Ty',\n }\n resp = self.app.post('cards', json=data)\n\n assert resp.status_code == 500", "async def test_update_missing_field(self):\n await self.collection.create({'id': 'foo', 'value': 'bar'})\n with self.assertRaises(InvalidResourceDetails) as cm:\n await self.resource.update('foo', {})\n self.assertEqual(\n 'Error: \"value\": Required', str(cm.exception))", "def insert_exist(self, card):\n if card['card_ordinary'] is not None:\n slug = card['card_ordinary']['slug']\n card['card_type'] = slug\n\n # bug 149\n if slug == 'flyer':\n self.has_flyer = True\n if slug == 'test':\n self.has_test = True\n elif card['card_club'] is not None:\n slug = card['card_club']['slug']\n card['card_type'] = 'club'\n elif card['card_promo'] is not None:\n slug = card['card_promo']['slug']\n card['card_type'] = 'promo'\n else:\n raise\n\n record = []\n\n for name, delegate, title, action, static in MODEL_MAP_RAW:\n value = card.get(name, None)\n record.append(value)\n\n self.storage.append(record)", "def test_account_modification_inexistent(flask_server):\n import requests\n\n data = {\n 'name': 'no',\n 'password': 'nope',\n 'new_name': 'foo2',\n 'new_password': 'bar2',\n 'new_code': '456',\n }\n\n req = requests.post('{}/account/modify'.format(API_URL), data=data)\n assert req.content == b'No such account in database'\n assert req.status_code == 400", "def deck_modify_card(deck_id):\n log_request(request)\n username = request.json['username']\n sId = request.json['session_id']\n sideA = request.json['sideA']\n sideB = request.json['sideB']\n index = request.json['index']\n\n # verify session\n if not user.verify(username, sId):\n logging.debug(\"Invalid username or session_id\")\n return jsonify({'error' : 101})\n \n dId = deck.get_id(deck_id)\n \n # check that the deck exists\n if not deck.exists(dId):\n logging.debug(\"Deck does not exist\")\n return jsonify({'error' : 300})\n\n \n cId = card.get_cId(dId, index)\n ret = card.modify(cId, sideA, sideB)\n \n if ret == 1:\n return jsonify({'error' : 0})\n else:\n logging.error(\"Invalid return code from card.modify {0}\".format(ret))\n print ret\n return jsonify({'error' : 400}) # no idea why this would happen", "def test_upload_rubric(db_conn, cards_table):\n\n card, errors = UploadCard.insert(db_conn, {\n 'unit_id': 'RUF531',\n 'name': 'What is?',\n 'body': 'Testing 1234',\n 'file_extensions': ['jpg'],\n })\n assert len(errors) == 1\n card, errors = card.update(db_conn, {'rubric': None})\n assert len(errors) == 0", "def test_duplicate_cards(hand, card_list):\n with pytest.raises(AssertionError):\n hand.add_cards(card_list)", "def test_api_update_book_with_id_does_not_exist(self):\n\n\t\tlogin_data = self.login_test_user()\n\t\ttoken = login_data['auth_token']\n\n\t\tbook = self.client.put(\n\t\t\tf'{URL_BOOKS}/1',\n\t\t\theaders=dict(Authorization=f'Bearer {token}'),\n\t\t\tcontent_type='application/json',\n\t\t\tdata=json.dumps(\n\t\t\t\tdict(\n\t\t\t\t\ttitle='updated book'\n\t\t\t\t)\n\t\t\t)\n\t\t)\n\n\t\tbook_res = json.loads(book.data.decode())\n\t\tself.assertTrue(book_res['message'] == 'book with id 1 does not exist')\n\t\tself.assertTrue(book_res['status'] == 'error')" ]

[ "0.72570544", "0.6971975", "0.64662427", "0.63850427", "0.6337639", "0.6297447", "0.6253069", "0.6226289", "0.6153988", "0.6153988", "0.613771", "0.6100459", "0.60533106", "0.60427165", "0.60209745", "0.60053265", "0.59934855", "0.5950459", "0.59163815", "0.5905842", "0.5902802", "0.5896635", "0.5887984", "0.58648604", "0.5862114", "0.58480704", "0.5843217", "0.5816478", "0.58057487", "0.58049685" ]

[ "def create_rule(self: object,\n body: dict,\n cs_username: str = None # pylint: disable=W0613 # cs_username is deprecated\n ) -> dict:\n # [POST] https://assets.falcon.crowdstrike.com/support/api/swagger.html#/custom-ioa/create-rule\n return process_service_request(\n calling_object=self,\n endpoints=Endpoints,\n operation_id=\"create_rule\",\n body=body\n )", "def security_group_rule_create(auth=None, **kwargs):\n cloud = get_operator_cloud(auth)\n kwargs = _clean_kwargs(**kwargs)\n return cloud.create_security_group_rule(**kwargs)", "def new_channel(self, *args, **kwargs):\n logger.debug('creating channel -> connection.channel(%r, %r)' % (args, kwargs))\n if self.enabled:\n channel = self.connection.channel(*args, **kwargs)\n self._channels.append(channel)\n return channel\n else:\n return None", "def create_security_group_rule(self, body=None):\r\n return self.post(self.security_group_rules_path, body=body)", "def create_rule(self, cr, uid, kind, filter_id=False, filter_pre_id=False, context=None):\r\n return self.base_action_rule.create(cr,uid,{\r\n 'name': \"Rule 1\",\r\n 'model_id': self.registry('ir.model').search(cr, uid, [('model','=','base.action.rule.lead.test')], context=context)[0],\r\n 'kind': kind,\r\n 'filter_pre_id': filter_pre_id,\r\n 'filter_id': filter_id,\r\n 'act_user_id': self.demo,\r\n }, context=context)", "def channels_create(token, name, is_public):\n auth_u_id = get_id_from_token(token)\n if len(name) > 20:\n raise ValueError(\"\")\n channel_payload = {\n \"name\": name,\n \"all_members\": [auth_u_id],\n \"owners\": [auth_u_id],\n \"is_public\": is_public,\n \"is_standup_active\": False,\n \"time_finish\": None,\n \"standup_queue\": [],\n }\n return channels.add(channel_payload)", "def create_acl_rule(self, context, sgr):\n self.security_group_driver.create_acl_rule(context, sgr)", "def _create_rules(rules, node_rules, node_atrrs):\n for node_attr, node_value in node_atrrs.iteritems():\n if node_attr not in node_rules:\n continue\n for rule in node_rules[node_attr]:\n # if isinstance(rule['from'], REGEX_TYPE) and node_value.startswith('mediumtext'):\n if rule['from'] == node_value:\n rules[node_attr] = rule['to']", "def create_notification_rule(headers, user_id, payload):\n\n # Alter base_url's endpoint\n url = base_url + '/' + user_id + '/notification_rules'\n\n r = requests.post(url, headers=headers, data=json.dumps(payload))\n\n print 'Notification rule response code: ' + str(r.status_code)\n return", "def create_snat_rule(self, **attrs):\n return self._create(_snat.Rule, **attrs)", "async def create_na_channel(self, guild: discord.Guild):\n\n overwrites = {\n guild.default_role: discord.PermissionOverwrite(\n read_messages=False\n ),\n guild.me: discord.PermissionOverwrite(\n read_messages=True,\n send_messages=True,\n add_reactions=True\n )\n }\n\n channel = await guild.create_text_channel(\n \"night-actions\", overwrites=overwrites\n )\n\n await self.config.guild(guild).na_channel_id.set(channel.id)\n\n return channel", "def create_rule(self, id: str, start_port: str, protocol: str = 'tcp', end_port: str = None,\n cidr: str = '0.0.0.0/0',\n direction: str = 'inbound', label: str = None) -> dict:\n payload = {'protocol': protocol, 'start_port': start_port, 'cidr': cidr, 'direction': direction}\n\n if end_port:\n payload['end_port'] = end_port\n\n if label:\n payload['label'] = label\n\n r = requests.post(self.url + '/{}/rules'.format(id), headers=self.headers, params=payload)\n\n return r.json()", "def test_create_rule(self):\n pass", "def add_rule(self, selectors, properties):\n self.cliques.append((selectors, properties))", "async def create_channel(self):\n self._logger.info(\"Deploying chaincode...\")\n network_file_path = os.path.join(os.getcwd(), \"network.json\")\n channel_config_path = os.path.join(self.config_path, \"channel-artifacts\", \"channel.tx\")\n\n self.fabric_client = Client(net_profile=network_file_path)\n\n org1_admin = self.fabric_client.get_user(org_name='org1.example.com', name='Admin')\n\n # Create a New Channel, the response should be true if succeed\n response = await self.fabric_client.channel_create(\n orderer='orderer1.example.com',\n channel_name='mychannel',\n requestor=org1_admin,\n config_tx=channel_config_path\n )\n self._logger.info(\"Result of channel creation: %s\", response)", "def _create_channels(self):\n for name, creator in CommonBase.get_channels(self.__class__):\n for cls, id in creator.pairs:\n # If channel pair was created with MultiChannelCreator\n # add channel interface to collection with passed attribute name\n if isinstance(creator, CommonBase.MultiChannelCreator):\n child = self.add_child(cls, id, collection=name, **creator.kwargs)\n # If channel pair was created with ChannelCreator\n # name channel interface with passed attribute name\n elif isinstance(creator, CommonBase.ChannelCreator):\n child = self.add_child(cls, id, attr_name=name, **creator.kwargs)\n else:\n raise ValueError(\"Invalid class '{creator}' for channel creation.\")\n child._protected = True", "def add_rules(self, rules):\n self.name.append(rules)", "async def handleChannelCreate(self, channel: discord.abc.GuildChannel):\n self.logger.info(\n \"Channel creation has been detected. Name: %s, ID: %s\", channel.name, channel.id\n )\n\n if not isinstance(channel, discord.TextChannel):\n return\n\n if channel.name == AH_CHANNEL:\n self.logger.info(\"%s detected, applying exceptions\", AH_CHANNEL)\n ctx = await self.getContext(channel)\n if not ctx:\n return\n await self.notifyChannel(ctx)\n await self.makeHighlightChanges(ctx, channel)\n await self.makeStarboardChanges(ctx, channel)\n await self.makeWordFilterChanges(ctx, channel)\n async with self.config.guild(channel.guild).get_attr(KEY_CHANNEL_IDS)() as channelIds:\n channelIds[channel.id] = {\"time\": datetime.now().timestamp()}", "async def create_channel(self, name: str) -> Channel:\n async with self.session.post(\n \"https://chat-gateway.veld.dev/api/v1/channels\",\n json={\"name\": name},\n headers={\"Authorization\": f\"Bearer {self.token}\"},\n ) as req:\n if req.status != 200:\n body = await req.text()\n log.debug(f\"HTTP Response code {req.status}, body is {body}\")\n raise HTTPException()\n json = await req.json()\n return Channel.from_dict(json)", "def create(self, subverbify, short_name, description, kind=None,\n created_utc=None):\n try:\n priority = len(list(self._cf.get(subverbify._id36)))\n except tdb_cassandra.NotFoundException:\n priority = 0\n\n if priority >= MAX_RULES_PER_SUBVERBIFY:\n return\n\n blob = self.get_rule_blob(short_name, description, priority,\n kind, created_utc)\n self._set_values(subverbify._id36, blob)", "def create_resolver_rule(CreatorRequestId=None, Name=None, RuleType=None, DomainName=None, TargetIps=None, ResolverEndpointId=None, Tags=None):\n pass", "def channel_create_middleware(\n self,\n payload: GatewayDispatch\n) -> Tuple[str, List[Channel]]:\n return \"on_channel_creation\", [\n Channel.from_dict(construct_client_dict(self, payload.data))\n ]", "async def create(self, name: str, type_: 'channel.ChannelType' = None,\n permission_overwrites: 'typing.List[dt_permissions.Overwrite]' = None,\n *,\n parent: 'channel.Channel' = None,\n bitrate: int = 64, user_limit: int = 0,\n topic: str = None) -> 'channel.Channel':\n if not self._guild.me.guild_permissions.manage_channels:\n raise PermissionsError(\"manage_channels\")\n\n if type_ is None:\n type_ = channel.ChannelType.TEXT\n\n kwargs = {\n \"name\": name,\n \"type\": type_.value,\n \"permission_overwrites\": permission_overwrites,\n }\n if type_ is channel.ChannelType.VOICE:\n kwargs[\"bitrate\"] = bitrate\n kwargs[\"user_limit\"] = user_limit\n\n if parent is not None:\n if parent.type != channel.ChannelType.CATEGORY:\n raise CuriousError(\"Cannot create channel with non-category parent\")\n\n if type_.value == channel.ChannelType.CATEGORY:\n raise CuriousError(\"Cannot create category channel with category\")\n\n kwargs[\"parent_id\"] = parent.id\n\n # create a listener so we wait for the WS before editing\n async def _listener(channel: channel.Channel):\n if channel.name == name and channel.guild == self._guild:\n return True\n\n return False\n\n listener = await curio.spawn(self._guild._bot.wait_for(\"channel_update\", _listener))\n try:\n channel_data = await self._guild._bot.http.create_channel(self._guild.id, **kwargs)\n # if it's a text channel and the topic was provided, automatically add it\n if type is channel.ChannelType.TEXT and topic is not None:\n await self._guild._bot.http.edit_channel(channel_id=channel_data[\"id\"], topic=topic)\n except:\n await listener.cancel()\n raise\n\n # wait on the listener\n await listener.wait()\n # we can safely assume this exists\n return self._channels[int(channel_data.get(\"id\"))]", "def CreateRule(self, request):\n try:\n params = request._serialize()\n headers = request.headers\n body = self.call(\"CreateRule\", params, headers=headers)\n response = json.loads(body)\n model = models.CreateRuleResponse()\n model._deserialize(response[\"Response\"])\n return model\n except Exception as e:\n if isinstance(e, TencentCloudSDKException):\n raise\n else:\n raise TencentCloudSDKException(type(e).__name__, str(e))", "def create_channel(uri, loop=None):\n\n if not loop:\n loop = Mainloop()\n\n connection = create_connection(loop, uri)\n chan = Channel(connection)\n return loop, chan", "def create(\n cls,\n name: str,\n specs: ListLike,\n channels: Channels,\n yes: bool = False,\n strict_channel_priority: bool = True,\n ):\n if not channels:\n raise CondaEnvTrackerChannelError(\"Could not find user channels.\")\n channel_string = channels.create_channel_command(\n strict_channel_priority=strict_channel_priority\n )\n actions = cls()\n if yes:\n prefix_cmd = f\"conda create -y --name {name} \"\n else:\n prefix_cmd = f\"conda create --name {name} \"\n actions.append(prefix_cmd + \" \".join(specs) + \" \" + channel_string)\n return actions", "def __init__(self, rule, tags=None):\n self.tags = tags or set()\n self.a, bcd, self.e = rule.split(\"|\")\n self.b, cd = bcd.split(\">\")\n self.c, self.d = cd.split(\"<\")\n self.theme = self.a\n self.stem = self.a + self.b\n self.suffix = self.d + self.e\n self.distinguisher = self.c + self.e\n self.surface = self.a + self.c + self.e", "def addChannel(self, channel):\n c = SubElement(self.root, 'channel')\n self.setattr(c, 'id', channel['id'])\n\n # Display Name\n for display_name in channel['display-name']:\n dn = SubElement(c, 'display-name')\n self.settext(dn, display_name)\n\n # Icon\n if 'icon' in channel:\n self.seticons(c, channel['icon'])\n\n # URL\n if 'url' in channel:\n for url in channel['url']:\n u = SubElement(c, 'url')\n self.settext(u, url, with_lang=False)", "def create_firewall_rule(self, body=None):\r\n return self.post(self.firewall_rules_path, body=body)", "def cloudflare_waf_firewall_rule_create_command(client: Client, args: Dict[str, Any]) -> CommandResults:\n action = args['action']\n zone_id = args.get('zone_id', client.zone_id)\n filter_id = args.get('filter_id')\n filter_expression = args.get('filter_expression')\n products = argToList(args.get('products'))\n description = args.get('description')\n paused = arg_to_boolean(args.get('paused')) # type: ignore\n priority = arg_to_number(args.get('priority'))\n ref = args.get('ref')\n\n response = client.cloudflare_waf_firewall_rule_create_request(\n action, zone_id,\n description=description, products=products, paused=paused, priority=priority, ref=ref,\n filter_id=filter_id, filter_expression=filter_expression)\n\n output = response['result']\n firewall_rule_output = output[0]\n\n firewall_rule = [{'id': dict_safe_get(firewall_rule_output, ['id']),\n 'action': dict_safe_get(firewall_rule_output, ['action']),\n 'paused': dict_safe_get(firewall_rule_output, ['paused']),\n 'description': dict_safe_get(firewall_rule_output, ['description']),\n 'filter_id': dict_safe_get(firewall_rule_output, ['filter', 'id']),\n 'filter_expression': dict_safe_get(firewall_rule_output, ['filter', 'expression']),\n 'products': dict_safe_get(firewall_rule_output, ['products']),\n 'ref': dict_safe_get(firewall_rule_output, ['ref']),\n 'priority': dict_safe_get(firewall_rule_output, ['priority']),\n 'zone_id': zone_id}]\n\n readable_output = tableToMarkdown(\n name='Firewall rule was successfully created.',\n t=firewall_rule,\n headers=['id', 'action', 'filter_id', 'filter_expression', 'products', 'priority', 'paused', 'description', 'ref'],\n headerTransform=string_to_table_header\n )\n return CommandResults(\n readable_output=readable_output,\n outputs_prefix='CloudflareWAF.FirewallRule',\n outputs_key_field='id',\n outputs=output,\n raw_response=response\n )" ]

[ "0.5678899", "0.5306978", "0.51936877", "0.51825786", "0.5098872", "0.49936134", "0.49537468", "0.49180532", "0.49175808", "0.49095017", "0.48956937", "0.4893867", "0.4890588", "0.48864338", "0.48617128", "0.48356813", "0.48139465", "0.48046735", "0.4803962", "0.47751865", "0.47693992", "0.4766739", "0.47526845", "0.4739935", "0.4727125", "0.4726608", "0.4715499", "0.47114623", "0.4701231", "0.46789205" ]

[ "def loss_plot(train_loss, val_loss, filename):\n\tplt.plot(train_loss)\n\tplt.plot(val_loss)\n\tplt.ylabel('Loss')\n\tplt.xlabel('Epochs')\n\tplt.legend(['Train', 'Val'], loc='upper right')\n\tplt.savefig(filename)\n\tplt.close()", "def plot_loss(stats):\r\n plt.plot(stats['train_loss_ind'], stats['train_loss'], label='Training loss')\r\n plt.plot(stats['val_loss_ind'], stats['val_loss'], label='Validation loss')\r\n plt.legend()\r\n plt.xlabel('Number of iterations')\r\n plt.ylabel('Loss')\r\n plt.show()", "def plot_loss(self):\n plt.plot(self.loss[10:], 'g+', label = \"loss\")\n plt.plot(self.loss[10:], 'r--', label = \"loss (smooth)\")\n plt.title(f\"Graph of loss after {len(self.loss)} steps of Gradient Descent.\")\n plt.xlabel('steps')\n plt.ylabel('loss')\n plt.legend()\n plt.show()", "def plot_loss(x, loss_train, loss_valid, title):\n plt.figure()\n plt.xlabel(\"Epoch\")\n plt.ylabel(\"Loss\")\n plt.title(title)\n plt.plot(x, loss_train, '-b', label='Training')\n plt.plot(x, loss_valid, '-r', linestyle=(0, (1, 2)), label='Validation')\n plt.legend([\"Training\", \"Validation\"], loc=\"upper right\", frameon=False)\n plt.yscale(\"log\")\n # plt.show()\n plt.savefig('{}.png'.format(title))", "def plot_errors(loss_train, loss_val, jet):\n plt.plot(list(range(len(loss_train))), loss_train, 'g', label='Training loss')\n plt.plot(list(range(len(loss_val))), loss_val, 'b', label='Validation loss')\n plt.title('Training and Validation loss for jet: {jet}'.format(jet=jet))\n plt.xlabel('Epochs')\n plt.ylabel('Loss')\n plt.legend()\n plt.show()", "def plot_loss(training_errors, validation_errors):\n plt.xscale('Log')\n plt.xlabel('Epochs')\n plt.ylabel('Mean Actual Error')\n plt.plot(training_errors, label = \"Training Error\", \\\n color = 'blue')\n plt.plot(validation_errors, label = \"Validation Error\", \\\n color = 'red')\n plt.legend()\n # Saves plot automatically, adjust filename as needed.\n plt.savefig('reservoir_05whdens_100h_7spec_test_3.png')\n plt.show()", "def plot_loss(G_losses, D_losses):\n plt.figure(figsize=(10,5))\n plt.title(\"Generator and Discriminator Loss During Training\")\n plt.plot(G_losses,label=\"G\")\n plt.plot(D_losses,label=\"D\")\n plt.xlabel(\"iterations\")\n plt.ylabel(\"Loss\")\n plt.legend()\n plt.show()", "def plot_loss_curve(num_epochs, losses):\n plt.xlabel('Epochs')\n plt.ylabel('Loss') \n plt.title('Loss Curve') \n plt.plot(range(num_epochs), losses)\n plt.show()", "def plot_loss (history):\n \n history_dict = history.history\n loss_values = history_dict['loss']\n val_loss_values = history_dict['val_loss']\n epochs = range(1, len(loss_values) + 1)\n\n plt.plot (epochs, loss_values, 'bo', label='Training loss')\n plt.plot (epochs, val_loss_values, 'b', label=\"validation loss\")\n plt.title('Training and validation loss')\n plt.xlabel('Epochs')\n plt.ylabel('Loss')\n plt.legend()\n plt.show()", "def plot_loss(self):\n train_elbo_range = range(len(self.train_elbo_hist))\n val_elbo_range = range(len(self.val_elbo_hist))\n train_loss_range = range(len(self.train_loss_hist))\n val_loss_range = range(len(self.val_loss_hist))\n\n fig, ax = plt.subplots(2, 2)\n ax[0][0].plot(train_elbo_range, self.train_elbo_hist)\n ax[0][0].title.set_text(\"Train ELBO\")\n ax[0][1].plot(val_elbo_range, self.val_elbo_hist)\n ax[0][1].title.set_text(\"Val ELBO\")\n ax[1][0].plot(train_loss_range, self.train_loss_hist)\n ax[1][0].title.set_text(\"Train MSE\")\n ax[1][1].plot(val_loss_range, self.val_loss_hist)\n ax[1][1].title.set_text(\"Val MSE\")\n plt.tight_layout()\n plt.show()", "def plotLoss():\n # ssr\n ssr = np.log(gradientDescent(X, y)[1])\n # number of iterations \n iterations = np.log(np.arange(1, len(ssr) + 1, 1))\n # plot reduction of ssr\n plt.plot(iterations, ssr)\n # xlabel\n plt.xlabel(\"Iteration\")\n # ylabel\n plt.ylabel(\"SSR\")\n # title\n plt.title(\"Reduction of SSR by number of Iterations\")\n # show plot \n plt.show()", "def plot_loss(history, name):\n\n plt.plot(history.history['loss'])\n plt.plot(history.history['val_loss'])\n plt.title('model loss')\n plt.ylabel('loss')\n plt.xlabel('epoch')\n plt.legend(['train', 'val'], loc='upper left')\n # plt.show()\n plt.savefig(name, format=\"png\")", "def plot_curve(self):\n x1 = np.arange(self.init_epoch, self.params.num_epoch+1, dtype=np.int).tolist()\n x2 = np.linspace(self.init_epoch, self.epoch,\n num=(self.epoch-self.init_epoch)//self.params.val_every+1, dtype=np.int64)\n plt.plot(x1, self.train_loss, label='train_loss')\n plt.plot(x2, self.val_loss, label='val_loss')\n plt.legend(loc='best')\n plt.title('Train/Val loss')\n plt.grid()\n plt.xlabel('Epoch')\n plt.ylabel('Loss')\n plt.show()", "def plot_loss_acc(name,score):\n plt.title(name)\n plt.xlabel('Epoch Number')\n plt.ylabel(name.split(sep=' ')[1])\n plt.plot(score)\n plt.savefig(\"graphs/\"+name+\".png\")", "def plot_cost(c_v, c_t, save_plots_path):\n\n plt.figure()\n plt.plot(c_v, label='Validation loss')\n plt.plot(c_t, label='Training loss')\n plt.legend()\n title = 'Loss per epoch'\n plt.title(title)\n plt.xlabel(\"Epoch\")\n plt.ylabel(\"Loss\")\n plt.savefig(save_plots_path + \"swag_loss_plot.png\")", "def plot_loss(model_fit, save_folder): \n train_loss = model_fit.history['loss']\n val_loss = model_fit.history['val_loss']\n epoch_axis = np.arange(1, len(train_loss) + 1)\n plt.title('Train vs Validation Loss')\n plt.plot(epoch_axis, train_loss, 'b', label='Train Loss')\n plt.plot(epoch_axis, val_loss,'r', label='Val Loss')\n plt.xlim([1, len(train_loss)])\n plt.xticks(np.arange(min(epoch_axis), max(epoch_axis) + 1, round((len(train_loss) / 10) + 0.5)))\n plt.legend(loc='upper right')\n plt.ylabel('Loss')\n plt.xlabel('Epochs')\n plt.savefig(save_folder + '/loss.png')\n plt.show()\n plt.close()", "def plot_loss_vs_epoch(history, var_train, var_val, show=False):\n plt.figure(figsize=(10, 8))\n plt.grid(True)\n plt.plot(history.history['loss']/var_train, marker=\"o\")\n plt.plot(history.history['val_loss']/var_val, marker=\"o\")\n plt.title('Model Loss')\n plt.ylabel('Loss (Normalised to variance of dataset)')\n plt.xlabel('Epoch')\n plt.legend(['Train', 'Validation'])\n # plt.ylim(bottom=0)\n filename = \"img/\"\n filename += datetime.now().strftime(\"%y%m%d_%H%M\")\n filename += \"_model_loss.png\"\n plt.savefig(filename)\n\n if show:\n plt.show()", "def plot_loss_curves(results):\n loss = results[\"train_loss\"]\n test_loss = results[\"test_loss\"]\n\n accuracy = results[\"train_acc\"]\n test_accuracy = results[\"test_acc\"]\n\n epochs = range(len(results[\"train_loss\"]))\n\n plt.figure(figsize=(15, 7))\n\n # Plot loss\n plt.subplot(1, 2, 1)\n plt.plot(epochs, loss, label=\"train_loss\")\n plt.plot(epochs, test_loss, label=\"test_loss\")\n plt.title(\"Loss\")\n plt.xlabel(\"Epochs\")\n plt.legend()\n\n # Plot accuracy\n plt.subplot(1, 2, 2)\n plt.plot(epochs, accuracy, label=\"train_accuracy\")\n plt.plot(epochs, test_accuracy, label=\"test_accuracy\")\n plt.title(\"Accuracy\")\n plt.xlabel(\"Epochs\")\n plt.legend()", "def plotErrors(losses, model_title ='Shallow Network, SGD, Batch Size = 10'):\n fig, axes = plt.subplots()\n\n x = np.arange(len(losses))\n\n axes.plot(x, losses)\n axes.set_ylabel(\"Loss (cross entropy)\")\n axes.set_xlabel(\"Number of iterations\")\n axes.set_title(model_title) \n\n plt.show() \n\n return None", "def plot_loss(path, current_epoch, train_loss, test_loss):\n plotname = os.path.join(path, \"training_loss_curve.png\")\n fig = plt.figure()\n plt.axes().set_facecolor(\"#fbc9bc\")\n plt.plot(\n range(1, current_epoch + 1), train_loss, color=\"#ff6050\", label=\"Training Loss\"\n )\n plt.plot(range(1, current_epoch + 1), test_loss, color=\"#19214e\", label=\"Test Loss\")\n plt.xlabel(\"Epoch Count\")\n plt.ylabel(\"Model Loss\")\n plt.legend()\n fig.savefig(plotname, bbox_inches=\"tight\")\n plt.close()", "def plot_loss(self):\n #x = [k for k in range(self.rep)]\n loss = self.min_list[:,0]//100 #For clarity\n #plt.plot(x,self.min_list[:,0])\n plt.hist(loss,density=True)\n plt.xlabel(self.list_name + '_loss//100')\n plt.ylabel('Frequency')\n #plt.xticks(range(8),[0,250,500,750,1000,1250,1500,1750])\n plt.title('Distribution of '+self.list_name+'_loss ('+str(self.rep)+' iterations)')\n plt.savefig('img/stats/'+self.list_name+'_lossFrequency_'+self.model_name+'.png')\n plt.show()", "def plot_train_val_loss(path_to_file, train_filename, val_filename):\n path = '../'\n labels = ['gen_total_loss', 'gen_loss', 'l1_loss', 'disc_total_loss', 'disc_gen_loss', 'disc_real_loss']\n with open(path_to_file + train_filename + '.csv', newline='') as f:\n reader = csv.reader(f)\n train_data = np.array(list(reader))\n with open(path_to_file + val_filename + '.csv', newline='') as f:\n reader = csv.reader(f)\n val_data = np.array(list(reader))\n\n if train_data.shape == val_data.shape:\n # change label number for the type of loss that should be plotted\n label = 0\n print(train_data.shape, val_data.shape)\n epoch_count = range(1, train_data.shape[0] + 1)\n plt.figure()\n plt.plot(epoch_count, val_data[:len(epoch_count), label].astype('float32'))\n plt.plot(epoch_count, train_data[:len(epoch_count), label].astype('float32'))\n plt.legend(['validation', 'train'])\n plt.xlabel('Epoch')\n plt.ylabel(labels[label])\n plt.show()", "def acc_loss_graph(self):\n acc = self.history['accuracy']\n val_acc = self.history['val_accuracy']\n loss = self.history['loss']\n val_loss = self.history['val_loss']\n plt.figure(figsize=(15, 5))\n plt.subplot(1, 2, 1)\n plt.plot(acc, label='Train')\n plt.plot(val_acc, label='Val')\n plt.legend(loc='lower right')\n plt.ylabel('Accuracy')\n plt.xlabel('Epoch')\n plt.ylim([min(plt.ylim()), 1])\n plt.title('Accuracy')\n\n plt.subplot(1, 2, 2)\n plt.plot(loss, label='Train')\n plt.plot(val_loss, label='Val')\n plt.legend(loc='lower right')\n plt.ylabel('Loss')\n plt.xlabel('Epoch')\n plt.ylim([0, max(plt.ylim())])\n plt.title('Loss')\n plt.show();", "def plot_losses(train, test, mode):\n\tplt.figure()\n\tplt.plot(range(len(train)), train, 'r', label='Training')\n\tplt.plot(range(len(test)), test, 'b', label='Testing')\n\tplt.title('MSE Loss (batch type: ' + mode + ')')\n\tplt.legend()\n\tplt.show()", "def graph_results(loss, acc):\n N = len(loss)\n x = np.linspace(0, N, N)\n plt.subplot(1,2,1)\n plt.plot(x, loss)\n plt.subplot(1,2,2)\n plt.plot(x,acc)\n plt.show()", "def Plot_loss(history_object): \n ### print the keys contained in the history object\n print(history_object.history.keys())\n print(history_object.history['loss'])\n print(history_object.history['val_loss'])\n\n ### plot the training and validation loss for each epoch\n plt.plot(history_object.history['loss'])\n plt.plot(history_object.history['val_loss'])\n plt.title('model mean squared error loss')\n plt.ylabel('mean squared error loss')\n plt.xlabel('epoch')\n plt.legend(['training set', 'validation set'], loc='upper right')\n plt.show()", "def plot_loss(loss_values_dict, save_name):\n fig, ax = plt.subplots(figsize=(10, 10))\n # Add each method to the plot\n for (method_name, loss_val_array) in loss_values_dict.items():\n print(method_name, len(loss_val_array))\n ax.plot(range(len(loss_val_array)), loss_val_array, label=method_name)\n ax.legend(loc='upper right')\n plt.xlabel('iteration')\n plt.ylabel('loss')\n plt.title('Grad Descent in Hyperbolic Space')\n plt.savefig(save_name)", "def plot_loss(model_dir):\n ## extract loss from csv\n file_dir = os.path.join(model_dir, 'losses.csv')\n data = pd.read_csv(file_dir)\n epochs = data['epoch'].ravel()\n loss = data['loss'].ravel()\n\n fig, ax = plt.subplots(1, 1, figsize=(7, 5), sharey=True, sharex=True, dpi=400)\n ax.plot(epochs, loss, #label=r'Loss', \n color='green', linewidth=1.0, alpha=0.8)\n ax.set_ylabel('Loss', fontsize=10)\n ax.set_xlabel('Number of iterations', fontsize=10)\n ax.legend(loc='lower right', prop={\"size\": 15}, ncol=3, framealpha=0.5)\n ax.set_title(\"Loss\")\n ax.spines['top'].set_visible(False)\n ax.spines['right'].set_visible(False)\n plt.tight_layout()\n\n ## create saving directory\n loss_dir = os.path.join(model_dir, 'figures', 'loss')\n os.makedirs(loss_dir, exist_ok=True)\n file_name = os.path.join(loss_dir, 'loss.png')\n plt.savefig(file_name, dpi=400)\n print(\"Plot saved to: {}\".format(file_name))\n file_name = os.path.join(loss_dir, 'loss.pdf')\n plt.savefig(file_name, dpi=400)\n plt.close()\n print(\"Plot saved to: {}\".format(file_name))", "def plot_loss_history(data=None, title=None, name=None, path=None):\n # TODO: add labels to loss history\n plt.figure(random.randint(a=1, b=100))\n plt.title(title)\n plt.plot(data)\n plt.savefig('{}/{}.png'.format(path, name))", "def summarize_diagnostics(self):\n # plot loss\n pyplot.subplot(211)\n pyplot.title('Cross Entropy Loss')\n pyplot.plot(self.history.history['loss'], color='blue', label='train')\n pyplot.plot(self.history.history['val_loss'], color='orange', label='test')\n # plot accuracy\n pyplot.subplot(212)\n pyplot.title('Classification Accuracy')\n pyplot.plot(self.history.history['accuracy'], color='blue', label='train')\n pyplot.plot(self.history.history['val_accuracy'], color='orange', label='test')\n # save plot to file\n pyplot.savefig(f'{self.project_home / \"o\"}/{self.model.name}_plot.png')\n pyplot.close()" ]

[ "0.82998466", "0.82797426", "0.80859876", "0.7981037", "0.7693412", "0.76680315", "0.7617962", "0.7617048", "0.75987184", "0.75846845", "0.7553299", "0.7551096", "0.7526244", "0.74546194", "0.73826283", "0.73073465", "0.72436315", "0.72190005", "0.71932274", "0.71717453", "0.7163786", "0.7153291", "0.7117278", "0.70974237", "0.7093652", "0.7083959", "0.7079474", "0.7070945", "0.69953144", "0.6986692" ]

[ "def plot_tsne_reduction(x_values: np.ndarray, y_values: np.ndarray) -> alt.Chart:\n tsne = manifold.TSNE()\n x_transformed = tsne.fit_transform(x_values)\n\n return plot_dimensionality_reduction(x_transformed, y_values)", "def tsne_plot(features: {}, labels: {}):\n # T-SNE computation\n tsne = TSNE(n_components=2, perplexity=40, n_iter=900, random_state=0)\n tsne_result = tsne.fit_transform(features)\n\n # Color specification\n n_labels = len(np.unique(labels[:,0]))\n label_set = np.unique(labels[:,1])\n palette = np.array(sns.color_palette('hls', n_labels))\n\n # Plot the scatter for each label seperatly\n fig, ax = plt.subplots(figsize=(15,10))\n for i in range(n_labels):\n ax.scatter(tsne_result[labels[:,0].astype(np.int) == i,0], tsne_result[labels[:,0].astype(np.int) == i,1], \\\n linewidth=0, c=np.array([palette[i]]), label=label_set[i])\n ax.axis('tight')\n\n # Shrink current axis by 20%\n box = ax.get_position()\n ax.set_position([box.x0, box.y0, box.width * 0.75, box.height])\n\n # Put a legend to the right of the current axis\n ax.legend(loc='center left', bbox_to_anchor=(1, 0.5), ncol=2, fontsize=12)\n ax.set_title(\"Dimensionality reduction with T-SNE\")\n plt.show()", "def _display_tsne(self):\n self._tsne_window.clear()\n self._tsne_window.plot(self._Y_tsne[:,0], self._Y_tsne[:,1], 'b.')", "def tSNE_plot2(features, labels):\n model = TSNE(n_components=2, random_state=0)\n transformed = model.fit_transform(features)\n\n print(\"Data transformed, now plotting...\")\n\n # Plotting\n x = transformed[:, 0]\n y = transformed[:, 1]\n colors = labels\n\n plt.scatter(x, y, c=colors)\n plt.xlabel(\"t-SNE component 1\")\n plt.ylabel(\"t-SNE component 2\")\n plt.show()", "def plot_visualization(path_results, x_data, y_data, variant_mode, nb_classes, signal_test, args):\n\n\t#path_tsne = path_results + \"/Visualization/train/\" + str(args.step) + \"_2d.csv\"\n\t#data_frame = pd.read_csv(path_tsne)\n\t\n\tpath_maping = path_results + \"/Maping/\" + str(args.subject).split(\".txt\")[0] + \"/\"\n\tfilename = path_maping + \"maping_\" + str(args.step) + \"_\" + str(args.subject).split(\".txt\")[0] + \"_stick\" + str(args.stick) + \".png\"\n\n\tprint(\"path_save maping\", path_maping)\n\n\tif not os.path.exists(path_maping):\n\t\tos.makedirs(path_maping)\n\n\t#print(\"path_tsne\", path_tsne)\n\n\tlabel_maping = np.array([10])\n\n\tx_data = np.concatenate((x_data,signal_test),axis=0)\n\ty_data = np.concatenate((y_data,label_maping),axis=0)\n\n\tprint(\"x_data concatenate\",x_data.shape)\n\tprint(\"y_data concatenate\",y_data.shape)\n\n\tdata_frame = tsne_2d(x_data, y_data)\n\n\t\n\t\n\tgroups = data_frame.groupby('label')\n\n\tcluster_names, cluster_colors = get_target_names_dr(nb_classes, args.mode, args, variant_mode)\n\n\tfig = plt.figure(figsize=(20, 10))\n\tax = fig.add_subplot(111)\n\tax.margins(0.05) # Optional, just adds 5% padding to the autoscaling\n\tfor name, group in groups:\n\t\t\n\t\tif cluster_names[name] == str(args.subject):\n\t\t\tax.scatter(group.x, group.y, marker='D', s=150, edgecolors = 'face',label=cluster_names[name], color=cluster_colors[name])\n\t\telse:\n\t\t\tax.scatter(group.x, group.y, marker='o', label=cluster_names[name], color=cluster_colors[name])\n\n\tax.legend(numpoints=1) #show legend with only 1 point\n\tplt.savefig(filename) #save the plot", "def try4():\n path = '/Users/mayankkejriwal/git-projects/bioExperiments/tsne_python/'\n mnist = path+'mnist2500_X.txt'\n X = numpy.loadtxt(mnist)\n labels = numpy.loadtxt(path+\"mnist2500_labels.txt\")\n Y = tsne.tsne(X, 2, 50, 20.0)\n pylab.scatter(Y[:,0], Y[:,1], 20, labels)\n pylab.show()", "def plot_t_sne(embedding, labels, info, color='black'):\n mpl.rcParams['text.color'] = color\n mpl.rcParams['axes.labelcolor'] = color\n mpl.rcParams['xtick.color'] = color\n mpl.rcParams['ytick.color'] = color\n\n tsne = TSNE(n_components=2).fit_transform(embedding)\n plt.figure(figsize=(20, 12))\n plt.title(\"T-SNE of {} embedding with {} labels\\n\".format(\n info[0], info[1]), fontsize=20)\n plt.xticks(fontsize=12)\n plt.yticks(fontsize=12)\n sns.scatterplot(\n x=tsne[:, 0], y=tsne[:, 1],\n hue=labels,\n palette=sns.color_palette(\"hls\", 2),\n legend=\"full\",\n alpha=0.5\n )\n l = plt.legend(['F', 'M'], fontsize=16)\n for text in l.get_texts():\n text.set_color(\"black\")", "def tsnescatterplot(model, word, list_names):\n arrays = np.empty((0, 50), dtype='f')\n word_labels = [word]\n color_list = ['red']\n\n # adds the vector of the query word\n arrays = np.append(arrays, model.wv.__getitem__([word]), axis=0)\n \n # gets list of most similar words\n close_words = model.wv.most_similar([word])\n \n # adds the vector for each of the closest words to the array\n for wrd_score in close_words:\n wrd_vector = model.wv.__getitem__([wrd_score[0]])\n word_labels.append(wrd_score[0])\n color_list.append('blue')\n arrays = np.append(arrays, wrd_vector, axis=0)\n \n # adds the vector for each of the words from list_names to the array\n for wrd in list_names:\n wrd_vector = model.wv.__getitem__([wrd])\n word_labels.append(wrd)\n color_list.append('green')\n arrays = np.append(arrays, wrd_vector, axis=0)\n \n # Reduces the dimensionality from 800 to 20 dimensions with PCA\n reduc = PCA(n_components=11).fit_transform(arrays)\n \n # Finds t-SNE coordinates for 2 dimensions\n np.set_printoptions(suppress=True)\n \n Y = TSNE(n_components=2, random_state=42, perplexity=10, learning_rate=150).fit_transform(reduc)\n \n # Sets everything up to plot\n df = pd.DataFrame({'x': [x for x in Y[:, 0]],\n 'y': [y for y in Y[:, 1]],\n 'words': word_labels,\n 'color': color_list})\n \n fig, _ = plt.subplots()\n fig.set_size_inches(9, 9)\n \n # Basic plot\n p1 = sns.regplot(data=df,\n x=\"x\",\n y=\"y\",\n fit_reg=False,\n marker=\"o\",\n scatter_kws={'s': 40,\n 'facecolors': df['color']\n }\n )\n \n # Adds annotations one by one with a loop\n for line in range(0, df.shape[0]):\n p1.text(df[\"x\"][line],\n df['y'][line],\n ' ' + df[\"words\"][line].title(),\n horizontalalignment='left',\n verticalalignment='bottom', size='medium',\n color=df['color'][line],\n weight='normal'\n ).set_size(15)\n\n \n plt.xlim(Y[:, 0].min()-50, Y[:, 0].max()+50)\n plt.ylim(Y[:, 1].min()-50, Y[:, 1].max()+50)\n \n plt.title(f't-SNE visualization for {word.title()}')", "def visualize(self):\n\n self.check_model()\n show(prepare(self.model, self.vectorized_data, self.vectorizer, mds='tsne'))", "def plot_tessellation(self):\n\n if (self.ndim != 2):\n print(\"Only able to plot the tessellation in two dimensions.\")\n return\n\n # find bounds:\n xmin = np.nanmin(self.grid[:,0])\n xmax = np.nanmax(self.grid[:,0])\n ymin = np.nanmin(self.grid[:,1])\n ymax = np.nanmax(self.grid[:,1])\n dx = xmax-xmin\n dy = ymax-ymin\n xmin -= dx*0.03\n xmax += dx*0.03\n ymin -= dy*0.05\n ymax += dy*0.05\n\n #plt.semilogy(self.grid[:,0],self.grid[:,1],'o')\n plt.plot(self.grid[:,0],self.grid[:,1],'o')\n plt.triplot(self.grid[:,0],self.grid[:,1],self.tessellation.simplices.copy())\n plt.xlim((xmin,xmax))\n plt.ylim((ymin,ymax))\n plt.xlabel(string_to_latex(self.grid_params[0]))\n plt.ylabel(string_to_latex(self.grid_params[1]))\n plt.savefig(\"tessellation.eps\")", "def tSNE_plot3(features, labels):\n model = TSNE(n_components=3, random_state=0)\n transformed = model.fit_transform(features)\n\n print(\"Data transformed, now plotting...\")\n\n # Plotting\n x = transformed[:, 0]\n y = transformed[:, 1]\n z = transformed[:, 2]\n colors = labels\n\n fig = plt.figure()\n ax = fig.add_subplot(111, projection='3d')\n ax.scatter(x, y, z, s=20, c=colors, depthshade=True)\n plt.show()", "def plot_tsnes():\n # Two environments (for main paper figure. All for final figure)\n ENVS = [\n \"BipedalWalker-v3\",\n #\"LunarLander-v2\",\n #\"Pendulum-v0\"\n \"Acrobot-v1\",\n #\"CartPole-v1\"\n ]\n ALGO_TYPES = [\n \"stablebaselines\",\n \"stablebaselines\",\n \"wann\",\n \"wann\",\n ]\n ALGO_NAMES = [\n \"A2C\",\n \"PPO\",\n \"NEAT\",\n \"CMAES\",\n ]\n ALGO_PRETTY_NAMES = [\n \"A2C\",\n \"PPO\",\n \"NEAT\",\n \"CMA-ES\"\n ]\n\n REWARD_SCALES = {\n \"Pendulum-v0\": [-1600, -200],\n \"Acrobot-v1\": [-500, -100],\n \"LunarLander-v2\": [-230, 200],\n \"BipedalWalker-v3\": [-100, 300],\n \"CartPole-v1\": [0, 500]\n }\n\n figure, axs = pyplot.subplots(\n figsize=[6.4 * 2, 4.8],\n nrows=2,\n ncols=4,\n gridspec_kw={'hspace': 0, 'wspace': 0},\n )\n\n for plot_i in range(2):\n env = ENVS[plot_i]\n reward_scale = REWARD_SCALES[env]\n for algo_i in range(len(ALGO_TYPES)):\n column_idx = (algo_i % 2) + plot_i * 2\n row_idx = 0 if algo_i <= 1 else 1\n ax = axs[row_idx, column_idx]\n algo_type = ALGO_TYPES[algo_i]\n algo_name = ALGO_NAMES[algo_i]\n algo_pretty_name = ALGO_PRETTY_NAMES[algo_i]\n\n experiment_glob = \"experiments/{}_{}_{}_*\".format(algo_type, env, algo_name)\n experiment_paths = glob(experiment_glob)\n tsnes = []\n rewards = []\n for experiment_path in experiment_paths:\n pivector_paths = glob(os.path.join(experiment_path, \"pivectors\", \"*\"))\n population_tsnes = []\n population_rewards = []\n for path in pivector_paths:\n data = np.load(path)\n population_tsnes.append(data[\"tsne\"])\n population_rewards.append(data[\"average_episodic_reward\"])\n data.close()\n tsnes.append(population_tsnes)\n rewards.append(population_rewards)\n tsnes = np.concatenate(tsnes, axis=0)\n rewards = np.concatenate(rewards, axis=0)\n\n # Min-max normalization\n rewards = (rewards - reward_scale[0]) / (reward_scale[1] - reward_scale[0])\n\n scatter = ax.scatter(\n tsnes[:, 0],\n tsnes[:, 1],\n c=rewards,\n cmap=\"plasma\",\n s=1,\n vmin=0,\n vmax=1\n )\n\n ax.text(0.98, 0.98, algo_pretty_name, horizontalalignment=\"right\", verticalalignment=\"top\", transform=ax.transAxes)\n ax.set_xticks([])\n ax.set_yticks([])\n # Hide spines, the outer edges\n ax.spines[\"top\"].set_alpha(0.2)\n ax.spines[\"bottom\"].set_alpha(0.2)\n ax.spines[\"left\"].set_alpha(0.2)\n ax.spines[\"right\"].set_alpha(0.2)\n # Hide edge spines and bolden mid-spines\n if row_idx == 0:\n ax.spines[\"top\"].set_visible(False)\n else:\n ax.spines[\"bottom\"].set_visible(False)\n if column_idx == 0:\n ax.spines[\"left\"].set_visible(False)\n elif column_idx == 1:\n ax.spines[\"right\"].set_alpha(1.0)\n elif column_idx == 2:\n ax.spines[\"left\"].set_alpha(1.0)\n elif column_idx == 3:\n ax.spines[\"right\"].set_visible(False)\n\n # Add titles\n if row_idx == 0 and (column_idx == 0 or column_idx == 2):\n ax.set_title(env.split(\"-\")[0], x=1.0)\n\n cbaxes = figure.add_axes([0.4, 0.94, 0.2, 0.02])\n cbar = figure.colorbar(scatter, orientation=\"horizontal\", cax=cbaxes)\n cbar.set_ticks([0.0, 0.5, 1.0])\n cbar.set_ticklabels([\"Min\", \"Reward\", \"Max\"])\n cbar.ax.xaxis.set_ticks_position('top')\n cbar.ax.xaxis.set_label_position('top')\n cbar.ax.tick_params(labelsize=\"small\", length=0)\n figure.tight_layout()\n figure.savefig(\"figures/tsnes.png\", dpi=200, bbox_inches=\"tight\", pad_inches=0.0)", "def plot_TSNE(fig_name):\n dir = \"log/peps mini\"\n pattern = r'(internal|access|lock)\\\\\\d{1,2}.csv$'\n pattern_valid = r'(3|6|9|12).csv$'\n utils.construct_set(dir, pattern, pattern_valid)\n X, y = utils.load_all()\n utils.plot_TSNE(X, y)\n plt.title(fig_name)\n if not os.path.exists(dir_fig):\n os.makedirs(dir_fig)\n plt.savefig(dir_fig + '/' + fig_name + '.png')", "def plot_run_lenet():\n strNames = ['Dropout','N image', 'Learning rate', 'Regul.']\n df = CNN.get_acc_run_lenet()\n df = df.dropna()\n \n fig = plt.figure(figsize=(16,12))\n for i, name in enumerate(strNames):\n df_sub = df.drop_duplicates([name])\n df_sub = df_sub.sort_values(by=name)\n CNN.subplot_run_lenet(df_sub, name, subplotids=[2,2,i+1])", "def plot_tsne_svc(img_df, labels, labels_dict, title = 'SVC decision regions for TSNE reduced images'):\n\n tsne = TSNE(n_components = 2, method = 'barnes_hut')\n dataTSNE = tsne.fit_transform(img_df)\n\n X_train_TSNE, X_test_TSNE, y_train_tsne, y_test_tsne = train_test_split(dataTSNE,\n labels,\n test_size = 0.3,\n random_state = 123)\n \n svm = SVC(C = 1.0,\n gamma = 'auto',\n kernel = 'rbf')\n \n svm.fit(X_train_TSNE,\n y_train_tsne)\n\n scatter_kwargs = {'s': 120, 'edgecolor': None, 'alpha': 0.7}\n\n fig = plt.figure(figsize = (30, 15))\n \n ax = plot_decision_regions(X_test_TSNE,\n np.array(y_test_tsne),\n clf = svm,\n legend = 0,\n colors = 'red,blue',\n scatter_kwargs = scatter_kwargs)\n \n handles, labels = ax.get_legend_handles_labels()\n ax.set_title(title,\n pad = 20) \n ax.legend(handles,\n [labels_dict[0], labels_dict[1]],\n framealpha=0.3,\n scatterpoints=1,\n fontsize = 'xx-large')\n\n plt.show()", "def generate_tsne(X, y, cols, use_pca=True, n_components=3, **kwargs):\n\n tsne = TSNE(n_components=2, verbose=1, perplexity=40, n_iter=10000, init='random', random_state=42, **kwargs)\n if PCA:\n pca = PCA(n_components, **kwargs)\n pca_result = pca.fit_transform(X)\n tsne_result = tsne.fit_transform(pca_result)\n tsne_df = pd.DataFrame(tsne_result, columns=cols, index=X.index)\n tsne_df['label'] = y\n tsne_plot = ggplot(tsne_df, aes(x='tsne-1', y='tsne-2', color='label') ) + geom_point(size=70,alpha=1) + ggtitle(\"tSNE dimensions colored by class\")\n return tsne_plot\n elif not PCA:\n tsne_results = tsne.fit_transform(X)\n tsne_df = pd.DataFrame(tsne_result, columns=cols, index=X.index)\n tsne_df['label'] = y\n tsne_plot = ggplot(tsne_df, aes(x='tsne-1', y='tsne-2', color='label') ) + geom_point(size=70,alpha=1) + ggtitle(\"tSNE dimensions colored by class\")\n return tsne_plot", "def quick_plot(solution):\n plt.suptitle('GNLSE solution')\n\n plt.subplot(1, 2, 1)\n plot_wavelength_vs_distance(solution)\n\n plt.subplot(1, 2, 2)\n plot_delay_vs_distance(solution)\n\n plt.show()", "def sse_plot(self):\n df_sse = self.df[\"sse\"].sort_values(ascending=False)\n plt.figure(figsize=(self.plot_width, self.plot_height))\n df_sse.plot(\"bar\")\n plt.title(\"SSE por cluster\")\n output_path_sse = os.path.join(self.output_folder, 'sse_plot.png')\n plt.savefig(output_path_sse)", "def plotTsneE_3D(datadf,level,descname,v,path_output,Efilter,own_cmap,clustermethod=\"kmeans\",onlyShow=False,selected=False):\n\n if not selected:\n datadf = datadf[datadf[\"{}Energy\".format(level)]<=Efilter].sort_values(by=\"{}_{}_klabel\".format(level,descname))\n\n klabels = datadf[\"{}_{}_klabel\".format(level,descname)].astype(str)\n fig = px.scatter_3d(data_frame=datadf,\n z=\"{}Energy\".format(level),\n x=\"{}_{}_tsne1\".format(level,descname),\n y=\"{}_{}_tsne2\".format(level,descname),\n color=klabels,\n color_discrete_sequence=own_cmap,\n size=\"GyRadius\",\n opacity=0.9,\n #symbol=\"symbol\", # Use if needed in Jupyter\n hover_name=datadf.index,\n title=\"{}'s' t-SNE + {}Energy\".format(descname,level),\n #range_z=[-36,-20],\n width= 1200,\n height= 900)\n\n\n if onlyShow:\n fig.show()\n elif selected:\n fig.write_html(\"{}/{}_{}_EtSNE_selected.html\".format(path_output,level,descname))\n else:\n fig.write_html(\"{}/{}_{}_EtSNE.html\".format(path_output,level,descname))", "def scree_plot(self, ev):\n plt.scatter(range(1,len(ev)+1), ev)\n plt.plot(range(1,len(ev)+1), ev)\n plt.title(\"Scree Plot\")\n plt.xlabel(\"Factors\")\n plt.ylabel(\"Eigenvalue\")\n plt.grid()\n plt.show()", "def step_plots(X, labs, steps_vec, perplexity = 30, ncols = 3, \\\n verbose = False, cdict = {1: 'red', 2: 'mediumspringgreen', 3: 'royalblue'}):\n \n # Set dimensions of subplots\n nrows = math.ceil(len(steps_vec) / ncols)\n \n # Configure axes\n axes = []\n fig = plt.figure(figsize = (16, 3 * nrows))\n \n # Run t-SNE\n low_d = tsne(X = X, perplexity = perplexity, niter = np.max(steps_vec), verbose = verbose, optim = \"fastest\")\n \n # Iteratively generate plots\n for step in range(len(steps_vec)):\n axes.append(fig.add_subplot(nrows, ncols, step + 1))\n axes[-1].set_title(\"Perplexity = \" + str(perplexity) + \", Step = \" + str(steps_vec[step]))\n plt.scatter(x = low_d[steps_vec[step], :, 0], y = low_d[steps_vec[step], :, 1], \\\n edgecolor = None, alpha = 0.8, c = np.array(list(map(lambda x: cdict[x], labs))))\n axes[-1].set_xticklabels([])\n axes[-1].set_yticklabels([])\n axes[-1].xaxis.set_ticks_position('none')\n axes[-1].yaxis.set_ticks_position('none')", "def plot_failures(features, labels, errors):\n model = TSNE(n_components=2, random_state=0, init=\"pca\", metric=\"correlation\")\n transformed = model.fit_transform(features)\n errors = map(lambda x: 30 if x else 10, errors)\n\n print(\"Data transformed, now plotting...\")\n\n # Plotting\n x = transformed[:, 0]\n y = transformed[:, 1]\n colors = labels\n areas = errors\n\n plt.scatter(x, y, c=colors, s=areas, edgecolors='none')\n plt.xlabel(\"t-SNE component 1\")\n plt.ylabel(\"t-SNE component 2\")\n plt.show()", "def ShowPcaTsne_recal(X, Y, data_encoder, center_distance, class_len , center_mean, doRecal ): \n \n # Define the color list for plot\n color = ['#1F77B4', '#FF7F0E', '#2CA02C', '#D62728', '#9467BD','#8C564B', '#E377C2', '#BCBD22', '#17BECF', '#40004B','#762A83',\\\n '#9970AB', '#C2A5CF', '#E7D4E8', '#F7F7F7','#D9F0D3', '#A6DBA0', '#5AAE61', '#1B7837', '#00441B','#8DD3C7', '#FFFFB3',\\\n '#BEBADA', '#FB8072', '#80B1D3','#FDB462', '#B3DE69', '#FCCDE5', '#D9D9D9', '#BC80BD','#CCEBC5', '#FFED6F']\n color_original = [color[i] for i in Y ]\n \n # Do pca for original data\n pca = PCA(n_components= 2)\n X_pca = X if class_len==2 else pca.fit(X).transform(X) \n X_tsne = X if class_len==2 else TSNE(n_components=2).fit_transform(X)\n \n # Do pca for encoder data if cluster>2\n if data_encoder.shape[1] !=3: # layer code_size >2 (3= 2+1 data+labels) \n data_encoder_pca = data_encoder[:,:-1]\n X_encoder_pca = pca.fit(data_encoder_pca).transform(data_encoder_pca)\n X_encoder_tsne = TSNE(n_components=2).fit_transform(data_encoder_pca)\n Y_encoder_pca = data_encoder[:,-1].astype(int)\n else:\n \n X_encoder_pca = data_encoder[:,:-1]\n X_encoder_tsne = X_encoder_pca \n Y_encoder_pca = data_encoder[:,-1].astype(int)\n Y_encoder_pcac = list(Y_encoder_pca)\n \n color_encoder = [color[i] for i in Y_encoder_pca ]\n plt.figure()\n \n plt.title('Latent Space before rescaling')\n plt.scatter(X_encoder_pca[:, 0], X_encoder_pca[:, 1], c= color_encoder )\n\n plt.show()\n \n # Recalage \n if doRecal : \n X_encoder_pca, Y_encoder_pcac = Recal_minibatch(X_encoder_pca, Y_encoder_pcac, center_mean, data_encoder)\n \n color_encoder = [color[i] for i in Y_encoder_pcac ]\n # Do pca for center_distance\n labels = np.unique(Y)\n center_distance_pca = pca.fit(center_distance).transform(center_distance)\n color_center_distance = [color[i] for i in labels ]\n \n # Plot\n title2 = 'Latent Space rescaled' if class_len==2 else 'NP_Encoder_'+'_PCA'\n plt.figure()\n \n plt.title(title2)\n\n plt.scatter(X_encoder_pca[:, 0], X_encoder_pca[:, 1], c= color_encoder )\n\n plt.show()\n\n return X_encoder_pca , Y_encoder_pca", "def ShowPcaTsne(X, Y, data_encoder, center_distance, class_len, tit, pcafit = None ): \n \n # Define the color list for plot\n color = ['#1F77B4', '#FF7F0E', '#2CA02C', '#D62728', '#9467BD','#8C564B', '#E377C2', '#BCBD22', '#17BECF', '#40004B','#762A83',\\\n '#9970AB', '#C2A5CF', '#E7D4E8', '#F7F7F7','#D9F0D3', '#A6DBA0', '#5AAE61', '#1B7837', '#00441B','#8DD3C7', '#FFFFB3',\\\n '#BEBADA', '#FB8072', '#80B1D3','#FDB462', '#B3DE69', '#FCCDE5', '#D9D9D9', '#BC80BD','#CCEBC5', '#FFED6F']\n\n \n # Do pca for original data\n pca = PCA(n_components= 2)\n pca_centre = PCA(n_components= 2)\n X_pca = X if class_len==2 else pca.fit(X).transform(X) \n X_tsne = X if class_len==2 else TSNE(n_components=2).fit_transform(X)\n \n # Do pca for encoder data if cluster>2\n if data_encoder.shape[1] !=3: # layer code_size >2 (3= 2+1 data+labels) \n data_encoder_pca = data_encoder[:,:-1]\n \n if tit == \"Latent Space Test\" : \n X_encoder_pca = pcafit.transform(data_encoder_pca)\n else : \n X_encoder_pca = pca.fit(data_encoder_pca).transform(data_encoder_pca)\n X_encoder_tsne = TSNE(n_components=2).fit_transform(data_encoder_pca)\n Y_encoder_pca = data_encoder[:,-1].astype(int)\n else:\n X_encoder_pca = data_encoder[:,:-1]\n X_encoder_tsne = X_encoder_pca \n Y_encoder_pca = data_encoder[:,-1].astype(int)\n if tit == \"Latent Space Test\":\n color_encoder = [color[i + class_len] for i in Y_encoder_pca ]\n else :\n color_encoder = [color[i] for i in Y_encoder_pca ]\n \n # Do pca for center_distance\n labels = np.unique(Y)\n center_distance_pca = pca_centre.fit(center_distance).transform(center_distance)\n color_center_distance = [color[i] for i in labels ]\n \n # Plot\n title2 = \"Latent Space\"\n\n \n plt.title(title2)\n if tit == \"Latent Space Test\":\n plt.scatter(X_encoder_pca[:, 0], X_encoder_pca[:, 1], c= color_encoder , marker = 's', s=120)\n else : \n plt.scatter(X_encoder_pca[:, 0], X_encoder_pca[:, 1], c= color_encoder )\n return pca", "def plot_results(model):\n\n # Is is a system of equation\n is_system = max(model.n_input, model.n_output) > 1\n\n # Choose the plotting function depending on the type of training data\n if model.dimension == 1 and not (is_system):\n plot_1d_results(model)\n\n elif model.dimension == 1 and is_system:\n plot_1d_systems(model)\n\n elif model.dimension > 1 and not (is_system):\n plot_2d_results(model)\n\n else:\n # Plot and save slices of the Green's matrix\n for i in range(1, 5):\n plot_2d_systems(model, Green_slice=i)", "def nusselt_distrbution(layers_df, mesh_df, verbose=True, save=False, show=True):\n console.event(\"Constructing Nusselt distribution plot...\", verbose=verbose)\n\n t = time.time()\n font = {'size': 10}\n mpl.rc('font', **font)\n\n\n objects = mesh_df['object'].tolist()\n coordinates_full = mesh_df['coords'].tolist()\n conductivities = mesh_df['conductivity'].tolist()\n dT_dts = mesh_df['dT_dt'].tolist()\n coordinates = []\n nusselt_nos = []\n coordinates_min_z = layers_df['min_z'].tolist()\n nusselt_nos_list = layers_df['nusselt'].tolist()\n for index, coord in enumerate(coordinates_min_z):\n coordinates.append(coord)\n nusselt_nos.append(nusselt_nos_list[index])\n\n fig1 = plt.figure(figsize=(8.0, 5.0)) # depth vs nusselt number, depth vs heat flux\n\n ax1 = fig1.add_subplot(111)\n ax1.plot(coordinates, nusselt_nos, color='b', linewidth=2, linestyle='-')\n ax1.scatter(coordinates, nusselt_nos, color='b')\n ax1.set_xlabel(\"Depth (m)\")\n ax1.set_ylabel(\"Nusselt Number\")\n ax1.tick_params('y', colors='b')\n\n ax2 = ax1.twinx()\n ax2.plot(coordinates_full, dT_dts, color='r', linewidth=1.4, linestyle='--')\n ax2.set_ylabel(\"Heat Flux (degK/s)\")\n ax2.tick_params('y', colors='r')\n\n fig2 = plt.figure(figsize=(8.0, 5.0)) # depth vs nusselt number, depth vs thermal conductivity\n\n ax3 = fig2.add_subplot(111)\n ax3.plot(coordinates, nusselt_nos, color='b', linewidth=2, linestyle='-')\n ax3.scatter(coordinates, nusselt_nos, color='b')\n ax3.set_xlabel(\"Depth (m)\")\n ax3.set_ylabel(\"Nusselt Number\")\n ax3.tick_params('y', colors='b')\n\n ax4 = ax3.twinx()\n ax4.plot(coordinates_full, conductivities, color='m', linewidth=1.4, linestyle='--')\n ax4.set_ylabel(\"Thermal Conductivity\")\n ax4.tick_params('y', colors='m')\n\n object_dict = {}\n for index, object in enumerate(objects):\n if object.lower() != 'boundary':\n if object not in object_dict.keys():\n object_dict.update({object: [coordinates_full[index]]})\n else:\n object_dict[object].append(coordinates_full[index])\n for object in object_dict.keys():\n min_coord = min(object_dict[object])\n max_coord = max(object_dict[object])\n color = np.random.rand(3, )\n ax1.axvspan(xmin=min_coord, xmax=max_coord, color=color, alpha=0.2, label=str(object))\n ax3.axvspan(xmin=min_coord, xmax=max_coord, color=color, alpha=0.2, label=str(object))\n\n ax1.set_title(\"Nusselt No. Distribution Over Depth\")\n ax1.grid()\n ax1.legend(loc='lower left')\n ax3.set_title(\"Nusselt No. Distribution Over Depth\")\n ax3.grid()\n ax3.legend(loc='lower left')\n\n console.event(\"Finished constructing Nusselt distribution plot! (task took {}s)\".format(\n time.time() - t), verbose=verbose)\n\n if show is True:\n plt.show()\n if save is True:\n fig1.tight_layout()\n fig2.tight_layout()\n fig1_name = \"nusselt_distrib_fig1.png\"\n fig2_name = \"nusselt_distrib_fig2.png\"\n if fig1_name in os.listdir(os.getcwd()):\n os.remove(fig1_name)\n if fig2_name in os.listdir(os.getcwd()):\n os.remove(fig2_name)\n fig1.savefig(fig1_name, format='png')\n fig2.savefig(fig2_name, format='png')", "def show_clusters_in_2D_tsne(data: np.ndarray, clusters: np.ndarray, num_clusters: int = 10,\n title: str = \"\", block: bool = True):\n try:\n fig, ax = _show_clusters_in_2D_whatever(data, clusters, TSNE, num_clusters, title, block, verbose=True)\n except:\n raise\n\n return fig, ax", "def plotLoss():\n # ssr\n ssr = np.log(gradientDescent(X, y)[1])\n # number of iterations \n iterations = np.log(np.arange(1, len(ssr) + 1, 1))\n # plot reduction of ssr\n plt.plot(iterations, ssr)\n # xlabel\n plt.xlabel(\"Iteration\")\n # ylabel\n plt.ylabel(\"SSR\")\n # title\n plt.title(\"Reduction of SSR by number of Iterations\")\n # show plot \n plt.show()", "def _display_from_tsne(self, x, y):\n\n # Find the closest 9\n inds = np.argsort(np.sum( (self._Y_tsne-np.array([x, y]))**2, axis=1))\n print(inds[:10])\n\n # Plot the green circles on the tsne plot\n self._display_tsne()\n self._tsne_window.plot(self._Y_tsne[inds[:9],0], self._Y_tsne[inds[:9],1], 'yo')\n\n # Now run through the 9 sub axes and display the image data and cutout location.\n self._sub_window_filenames = []\n for ii, axis in enumerate(self._sub_windows):\n axis.clear()\n\n fits_filename, filename, sliceno, middle = self._process_result_filename_cutout_number[inds[ii]]\n print('display from tsne fits: {} filename: {}'.format(fits_filename, filename))\n\n # So, the filename actually contains the wrong path on it so we\n # need to take it off and use the proper path.\n pf = pickle.load(open(os.path.join(self._cutouts_directory, filename), 'rb'))\n ff = list(glob.iglob('{}/**/{}'.format(self._data_directory, pf['filename'].split('/')[-1])))[0]\n\n print(ff)\n self._display_window(axis, ff)\n self._sub_window_filenames.append(fits_filename)\n\n # Draw the line\n axis.plot([middle[0]-112, middle[0]-112], [middle[1]-112, middle[1]+112], 'y')\n axis.plot([middle[0]+112, middle[0]+112], [middle[1]-112, middle[1]+112], 'y')\n axis.plot([middle[0]-112, middle[0]+112], [middle[1]-112, middle[1]-112], 'y')\n axis.plot([middle[0]-112, middle[0]+112], [middle[1]+112, middle[1]+112], 'y')\n\n plt.figure(1).show()\n plt.figure(1).canvas.draw()", "def plot(self, solution: Matrix) -> None:\n plots.plot_matrices(\"Total Variation Denoising\", self.M, solution)" ]

[ "0.721223", "0.69622654", "0.6888345", "0.6780966", "0.6607102", "0.6492365", "0.64915717", "0.6449874", "0.64182204", "0.6315417", "0.6142444", "0.61178076", "0.6068446", "0.6066621", "0.6031151", "0.60284644", "0.60229105", "0.59930944", "0.5989", "0.5987734", "0.59864", "0.5973591", "0.5930439", "0.5901248", "0.58861744", "0.5865113", "0.5846838", "0.5815932", "0.57913506", "0.57894486" ]

[ "def password_length(self):\n return self.__password_length", "def passWord(pwd):\n pwdLen = len(pwd)\n if pwdLen < 4:\n raise Exception(\"The password is too short.\")\n if pwdLen > 8:\n raise Exception(\"tHE password is too long\")\n else:\n print('the length of the password is correct.')", "def password(self) -> str:", "def __len__(self):\n return self.cli.passwords.len()", "def test01_password_length(self):\n self.set_complexity(length=13, numeric=0, upper=0, lower=0, special=0)\n\n invalid = (\n \"A\",\n \"Tr0ub4dor&3\",\n \"!!!!!!!!!!!!\",\n \"Password\",\n \"Password123!\",\n \"admin\",\n )\n self.assertPasswordsInvalid(invalid)\n\n valid = (\n \"correcthorsebatterystaple\",\n \"abcdefghijklmopqrstuvwxyz\",\n \"12345678901234567890\",\n \"!!!!!!!!!!!!!\" \"Password123!___\",\n )\n self.set_passwords(valid)", "def generate_password(self): \n\n password = []\n length = input(\"Enter Length for Password (At least 8): \")\n\n if length.lower().strip() == \"exit\":\n raise UserExits\n elif length.strip() == \"\":\n raise EmptyField\n elif int(length) < 8:\n raise PasswordNotLongEnough\n else:\n # generating a password\n spinner = Halo(text=colored(\"Generating Password\", \"green\"), spinner=self.dots_, color=\"green\")\n spinner.start()\n for i in range(0, int(length)):\n #choose character from one of the lists randomly\n password.append(random.choice(random.choice([string.ascii_lowercase, string.ascii_uppercase, string.digits, self.specialChar_])))\n\n finalPass = \"\".join(password)\n spinner.stop()\n\n return finalPass", "def main():\n password = input(\"Enter password that contains {} or more characters: \".format(MIN_LENGTH))\n while not is_valid_password(password):\n print(\"Invalid password!\")\n password = input(\"Enter password that contains {} or more characters: \".format(MIN_LENGTH))\n print(\"*\" * len(password))", "def symbol_len(password_length):\r\n while True:\r\n symb_length = input('How much symbols you want in password? At least 1 : ')\r\n try:\r\n symb_length = int(symb_length)\r\n if 1 <= symb_length <= (password_length - 2):\r\n break\r\n else:\r\n print('{} is not in range'.format(symb_length))\r\n except ValueError:\r\n print('{} is not an integer'.format(symb_length))\r\n return symb_length", "def alpha_len(password_length):\r\n while True:\r\n alphabet_length = input('How much alphabets you want in password? At least 1 : ')\r\n try:\r\n alphabet_length = int(alphabet_length)\r\n if 1 <= alphabet_length <= (password_length - 2):\r\n break\r\n else:\r\n print('{} is not in range'.format(alphabet_length))\r\n except ValueError:\r\n print('{} is not an integer'.format(alphabet_length))\r\n return alphabet_length", "def password_min_length(self) -> pulumi.Output[Optional[int]]:\n return pulumi.get(self, \"password_min_length\")", "def number_len(password_length):\r\n while True:\r\n numb_length = input('How much numbers you want in password? At least 1 : ')\r\n try:\r\n numb_length = int(numb_length)\r\n if 1 <= numb_length <= (password_length - 2):\r\n break\r\n else:\r\n print('{} is not in range'.format(numb_length))\r\n except ValueError:\r\n print('{} is not an integer'.format(numb_length))\r\n return numb_length", "def ask_user():\r\n password_lenght = 0\r\n while password_lenght == 0:\r\n try:\r\n password_lenght = int(input(\"How long password you want? Enter the number... \"))\r\n if password_lenght <= 0:\r\n print(\"Try to enter any number greater than 0...\")\r\n continue\r\n return password_lenght\r\n except Exception:\r\n continue", "def genpass(length):\n password = \"\"\n choice = string.ascii_letters + string.digits\n for i in range(length):\n password += random.choice(choice)\n return password", "def test_valid_password(self):\n pass_field = Field(\"\".join(['x' * (int(self.app.config['MAX_PWD_LEN']))]))\n\n valid_password(None, pass_field)", "def check_length(string):\n if 6 < len(string) < 12:\n return True\n\n print(\"Your password is not between 6 and 12 characters\")\n return False", "def password_generator(password_lenght):\r\n password = \"\"\r\n\r\n try:\r\n if password_lenght >=1:\r\n for i in range(password_lenght):\r\n choice = random.choice(symbols)\r\n password += str(choice)\r\n print(f\"Your password is: {password} \\nTnank you!\")\r\n return password\r\n else:\r\n return 0\r\n except Exception:\r\n pass", "def generate_random():\n characters = 'abcdefghijklmnopqrstuvwxz1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ!@$%^&*'\n length=int(input('Enter the length of your password '))\n password_characters=[random.choice(characters) for x in range (length)]\n password= \"\".join(password_characters)\n \n return password", "def check_password_strength():\r\n\r\n password_regex = re.compile(r'''(\r\n (?=.*[A-Z]{2})\r\n (?=.*[a-z]{3})\r\n (?=.*[/!@#$%^&_*+'\\\"-?.:;<>,])\r\n (?=.*[0-9])\r\n .{8,}\r\n )''', re.VERBOSE)\r\n\r\n get_password(password_regex)", "def password_min_length(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"password_min_length\")", "def password_min_length(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"password_min_length\")", "def generate_password(self, length):\n items = [\"a\", \"e\", \"i\", \"o\", \"u\", \"1\", \"2\", \"4\", \"5\", \"7\", \"8\", \"9\"]\n\n new_password = \"\"\n while(len(new_password) < length):\n item = items[randint(0, len(items) - 1)]\n new_password += item\n return new_password", "def password(customer_info, stringLength=5):\n letters = string.ascii_lowercase\n rand_string = ''.join(random.choice(letters) for i in range(stringLength))\n user_password = rand_string + str(customer_info[0][0:2] + customer_info[1][-2:])\n return user_password", "def test_length(self):\n for length in range(2, 30):\n self.assertEqual(len(generate_password(length)), length)", "def get_new_user_pword():\n pword = input(\"Password (3–20 alphanumeric characters): \")\n menu.option_to_exit(pword)\n try:\n if len(pword) < 3 or len(pword) > 20 or not pword.isalnum():\n raise ValueError\n except ValueError:\n print(\"Password must be 3–20 alphanumeric characters.\\n\"\n \"Please try again.\\n\")\n return get_new_user_pword()\n else:\n return pword", "def generate_passwd(length=6):\n ret = ''\n if length < 6 :\n length = 6\n elif length > 10 :\n length = 10\n for x in xrange(length) :\n if x == 3 :\n ret += '-'\n ret += chr(random.randrange(ord('a'),ord('z'),1))\n return ret", "def genAlphaNumPwd(length):\n return genPwd(string.ascii_letters + string.digits, length)", "def generate_password(\n password_length: int = 8,\n has_symbols: bool = False,\n has_uppercase: bool = False\n) -> str:", "def password(length,num=False,strength='weak'):\r\n lower = string.ascii_lowercase\r\n upper = string.ascii_uppercase\r\n letter = lower + upper\r\n dig = string.digits\r\n punct = string.punctuation\r\n pwd = ''\r\n if strength == 'weak':\r\n if num:\r\n length -= 2\r\n for i in range(2):\r\n pwd += random.choice(dig)\r\n for i in range(length):\r\n pwd += random.choice(lower)\r\n\r\n elif strength == 'strong':\r\n if num:\r\n length -=2\r\n for i in range(2):\r\n pwd += random.choice(dig)\r\n for i in range(length):\r\n pwd += random.choice(letter)\r\n elif strength == 'very':\r\n ran = random.randint(2,4)\r\n if num:\r\n length -= ran\r\n for i in range(ran):\r\n pwd += random.choice(dig)\r\n length -= ran\r\n for i in range(ran):\r\n pwd += random.choice(punct)\r\n for i in range(length):\r\n pwd += random.choice(letter)\r\n pwd = list(pwd)\r\n random.shuffle(pwd)\r\n return ''.join(pwd)", "def test_long_password():\n expect_error(register, InputError,\n \"abcdef\", \"a\" * (MIN_PASSWORD - 1), \"a\", \"A\", \"a\")", "def check_len(password_length, alphabet_length, numb_length, symb_length):\r\n return (symb_length + alphabet_length + numb_length) == password_length" ]

[ "0.7629029", "0.7612529", "0.7593266", "0.75244534", "0.738702", "0.7358815", "0.73539585", "0.73169446", "0.71829206", "0.7180958", "0.71143186", "0.71080285", "0.7094232", "0.7092153", "0.708661", "0.7074669", "0.70689845", "0.7059098", "0.7052881", "0.7052881", "0.7003661", "0.7000152", "0.6973706", "0.69556063", "0.69525945", "0.695094", "0.6947782", "0.69210905", "0.68896157", "0.6887745" ]

[ "def len_special(self):\n return sum(self.count(term_chars) * len(term_chars) for term_chars in termcolor.values())", "def part_one():\n return symbol_counts[\"~\"] + symbol_counts[\"|\"]", "def embedcount(line):\r\n\r\n x_temp = line.count(BOX_CHAR['lu'])\r\n return self.defaults.get('size')-(4*x_temp)", "def total_length():\n return", "def __len__(self) -> int:\n return len(self.tape) # TODO: do we count the blank symbols?", "def local_symbols_size(self):\n size = 0\n for s in self.symbols[-1]:\n if self.symbols[-1][s].type == 'procedure': continue\n if self.symbols[-1][s].isparam: continue\n #if self.symbols[-1][s].isparam: continue\n size += self.symbols[-1][s].size\n return size", "def setSymbolSize(x=30):\n dislin.hsymbl(x)", "def num_chars(word):\n return len(word)", "def expected_size(self):\n return self.nsym * self.symbol_len_per_byte", "def width(self) -> int:", "def width(self) -> int:", "def part_two():\n return symbol_counts[\"~\"]", "def countSymbols(epr, symbols):\n freeSymbols = epr.free_symbols\n return len(set(freeSymbols).intersection(symbols))", "def get_number_symbols(self) -> int:\n if self.sons:\n return sum([son.get_number_symbols() for son in self.sons])\n return 1", "def len23(self) -> float:\n ...", "def __stars__(self):\n t_ops = self.__ops__[1::2]\n return t_ops.count('x') + t_ops.count('X')", "def factories(self):\n return self.__as_str.count(\"f\") * 4", "def global_symbols_size(self):\n size = 0\n for s in self.global_symbols:\n if self.global_symbols[s].type == 'procedure': continue\n size += self.global_symbols[s].size\n return size", "def symbol_width(self):\n return self._symbol.get_extents().width", "def get_statistic(source_text):\n symbols = {s: 0 for s in bytes(range(0, 256))}\n for symbol in source_text:\n symbols[symbol] += 1\n return symbols", "def number_of_atoms(formula):\n pass\n # ======== YOUR CODE HERE ========", "def symbols(self):\n pass", "def _alnum_percent(line):\n total = len(line)\n\n test_set = set()\n for letter in string.ascii_letters:\n test_set.add(letter)\n test_set.add(' ')\n\n # Return a failure (no good characters) if there are no characters\n if total < 1:\n return 0\n\n alnum_count = 0\n star_count = 0\n bar_count = 0\n for letter in line:\n # if letter.isalnum():\n if letter in test_set:\n alnum_count += 1\n if letter == '*':\n star_count += 1\n if letter == 'I' or letter == 'i' or letter == 'l' or letter == '|':\n bar_count += 1\n\n # TODO(searow): properly implement this, but sticking this here for now.\n\n if star_count / total > 0.1:\n return 0\n\n if bar_count / total > 0.5:\n return 0\n\n return alnum_count / total", "def size(name):", "def get_char_width(self, char: str) -> float:\n pass", "def __len__(self) -> int:\n return len(self.tab10)", "def characters_left(self):\r\n return self.max_chars - len(self.variable.get())", "def num_of_syllables(self, word):\n\n if word.lower() in self.cmu_dict:\n return len([phoneme for phoneme in self.cmu_dict[word.lower()][0]\n if phoneme[-1].isdigit()])\n # If word is unknown, assume 1 syllable/3 letters (average for English)\n else:\n return len(word)//3", "def number_syllables(self):\n return len(self.array_form)", "def __len__(self) -> int:\n return self.disp_size ** 2" ]

[ "0.6444634", "0.6134199", "0.6113141", "0.60651857", "0.5984401", "0.59586775", "0.59318316", "0.59293085", "0.59119457", "0.584206", "0.584206", "0.58049524", "0.5760604", "0.5757853", "0.57293653", "0.5727135", "0.5700855", "0.5645191", "0.5637213", "0.56198454", "0.56154424", "0.5614134", "0.5607744", "0.560342", "0.5587692", "0.556496", "0.55317295", "0.5505553", "0.55010974", "0.54948" ]

[ "def register_metadata(metadata_file, config):\n metadata_list = []\n import sys\n if metadata_file in sys.argv:\n return config\n try:\n with open(metadata_file, \"r\") as fh:\n reader = csv.DictReader(fh.readlines())\n metadata_list = [row for row in reader]\n run2sample = {row[\"Run\"]:row[\"SampleName\"] for row in metadata_list}\n config_default = {\n 'bio.ngs.settings' : {\n 'sampleinfo' : metadata_file\n },\n 'bio.ngs.tools.sratools': {\n '_datadir': os.path.dirname(metadata_file),\n '_run2sample' : run2sample,\n '_metadata' : metadata_list\n },\n }\n update_config(config_default, config)\n config = config_default\n \n except Exception:\n raise Exception(\"\"\"\n\n no metadata file '{metadata}' found\n\n please initiate analysis by running 'snakemake {metadata}'\n\n \"\"\".format(metadata=metadata_file))\n return config", "def php_ini_scanned_files():\n raise NotImplementedError()", "def main(ini_path, tile_list=None, overwrite_flag=False):\n logging.info('\\nPrepare path/row INI files')\n\n # Open config file\n logging.info(' {0:<18s} {1}'.format(\n 'INI File:', os.path.basename(ini_path)))\n config = ConfigParser.ConfigParser()\n try:\n config.readfp(open(ini_path))\n except IOError:\n logging.error(('\\nERROR: Config file does not exist\\n' +\n ' {0}\\n').format(ini_path))\n sys.exit()\n except ConfigParser.MissingSectionHeaderError:\n logging.error('\\nERROR: Input file is missing a section header\\n' +\n ' Please make sure the following line is at the ' +\n 'beginning of the file\\n[INPUTS]\\n')\n sys.exit()\n except:\n logging.error(('\\nERROR: Unknown error reading input file\\n' +\n ' {0}\\n').format(ini_path))\n sys.exit()\n\n # Get input parameters\n year = config.getint('INPUTS', 'year')\n if tile_list is None:\n tile_list = read_param('tile_list', [], config, 'INPUTS')\n project_ws = config.get('INPUTS', 'project_folder')\n logging.debug(' Year: {}'.format(year))\n logging.debug(' Path/rows: {}'.format(', '.join(tile_list)))\n logging.debug(' Project: {}'.format(project_ws))\n\n ini_file_flag = read_param('ini_file_flag', True, config, 'INPUTS')\n landsat_flag = read_param('landsat_flag', True, config, 'INPUTS')\n ledaps_flag = read_param('ledaps_flag', False, config, 'INPUTS')\n dem_flag = read_param('dem_flag', True, config, 'INPUTS')\n nlcd_flag = read_param('nlcd_flag', True, config, 'INPUTS')\n modis_lc_flag = read_param('modis_lc_flag', False, config, 'INPUTS')\n cdl_flag = read_param('cdl_flag', True, config, 'INPUTS')\n landfire_flag = read_param('landfire_flag', False, config, 'INPUTS')\n field_flag = read_param('field_flag', False, config, 'INPUTS')\n metric_flag = read_param('metric_flag', True, config, 'INPUTS')\n ssebop_flag = read_param('ssebop_flag', False, config, 'INPUTS')\n monte_carlo_flag = read_param('monte_carlo_flag', False, config, 'INPUTS')\n interp_rasters_flag = read_param(\n 'interpolate_rasters_flag', False, config, 'INPUTS')\n interp_tables_flag = read_param(\n 'interpolate_tables_flag', False, config, 'INPUTS')\n\n metric_hourly_weather = read_param(\n 'metric_hourly_weather', 'NLDAS', config, 'INPUTS')\n\n project_ws = config.get('INPUTS', 'project_folder')\n footprint_path = config.get('INPUTS', 'footprint_path')\n skip_list_path = read_param('skip_list_path', '', config, 'INPUTS')\n\n # tile_gcs_buffer = read_param('tile_buffer', 0.1, config)\n\n # Template input files for scripts\n if metric_flag:\n metric_ini = config.get('INPUTS', 'metric_ini')\n pixel_rating_ini = config.get('INPUTS', 'pixel_rating_ini')\n if ssebop_flag:\n ssebop_ini = config.get('INPUTS', 'ssebop_ini')\n if monte_carlo_flag:\n monte_carlo_ini = config.get('INPUTS', 'monte_carlo_ini')\n\n if interp_rasters_flag or interp_tables_flag:\n interpolate_folder = read_param('interpolate_folder', 'ET', config)\n interpolate_ini = config.get('INPUTS', 'interpolate_ini')\n if interp_rasters_flag:\n study_area_path = config.get('INPUTS', 'study_area_path')\n study_area_mask_flag = read_param('study_area_mask_flag', True, config)\n study_area_snap = read_param('study_area_snap', (0, 0), config)\n study_area_cellsize = read_param('study_area_cellsize', 30, config)\n study_area_buffer = read_param('study_area_buffer', 0, config)\n study_area_proj = read_param('study_area_proj', '', config)\n if interp_tables_flag:\n zones_path = config.get('INPUTS', 'zones_path')\n zones_name_field = read_param('zones_name_field', 'FID', config)\n # zones_buffer = read_param('zones_buffer', 0, config)\n zones_snap = read_param('zones_snap', (0, 0), config)\n zones_cellsize = read_param('zones_cellsize', 30, config)\n # zones_proj = read_param('zones_proj', '', config)\n zones_mask = read_param('zones_mask', None, config)\n zones_buffer = None\n zones_proj = None\n\n # Input/output folder and file paths\n if landsat_flag:\n landsat_input_ws = config.get('INPUTS', 'landsat_input_folder')\n else:\n landsat_input_ws = None\n if ledaps_flag:\n ledaps_input_ws = config.get('INPUTS', 'ledaps_input_folder')\n else:\n ledaps_input_ws = None\n\n if dem_flag:\n dem_input_ws = config.get('INPUTS', 'dem_input_folder')\n dem_tile_fmt = config.get('INPUTS', 'dem_tile_fmt')\n dem_output_ws = config.get('INPUTS', 'dem_output_folder')\n dem_output_name = read_param(\n 'dem_output_name', 'dem.img', config)\n # dem_output_name = config.get('INPUTS', 'dem_output_name')\n else:\n dem_input_ws, dem_tile_fmt = None, None\n dem_output_ws, dem_output_name = None, None\n\n if nlcd_flag:\n nlcd_input_path = config.get('INPUTS', 'nlcd_input_path')\n nlcd_output_ws = config.get('INPUTS', 'nlcd_output_folder')\n nlcd_output_fmt = read_param(\n 'nlcd_output_fmt', 'nlcd_{0:04d}.img', config)\n else:\n nlcd_input_path, nlcd_output_ws, nlcd_output_fmt = None, None, None\n\n if modis_lc_flag:\n modis_lc_input_path = config.get('INPUTS', 'modis_lc_input_folder')\n modis_lc_output_ws = config.get('INPUTS', 'modis_lc_output_folder')\n modis_lc_output_name = read_param(\n 'modis_lc_output_name', 'modis_lc.img', config)\n else:\n modis_lc_input_path = None\n modis_lc_output_ws, modis_lc_output_name = None, None\n\n if cdl_flag:\n cdl_input_path = config.get('INPUTS', 'cdl_input_path')\n cdl_ag_list = config.get('INPUTS', 'cdl_ag_list')\n cdl_ag_list = list(parse_int_set(cdl_ag_list))\n # default_cdl_ag_list = range(1,62) + range(66,78) + range(204,255)\n # cdl_ag_list = read_param(\n # 'cdl_ag_list', default_cdl_ag_list, config)\n # cdl_ag_list = map(int, cdl_ag_list)\n # cdl_non_ag_list = read_param(\n # 'cdl_non_ag_list', [], config)\n cdl_output_ws = config.get('INPUTS', 'cdl_output_folder')\n cdl_output_fmt = read_param(\n 'cdl_output_fmt', 'cdl_{0:04d}.img', config)\n cdl_ag_output_fmt = read_param(\n 'cdl_ag_output_fmt', 'cdl_ag_{0:04d}.img', config)\n else:\n cdl_input_path, cdl_ag_list = None, None\n cdl_output_ws, cdl_output_fmt, cdl_ag_output_fmt = None, None, None\n\n if landfire_flag:\n landfire_input_path = config.get('INPUTS', 'landfire_input_path')\n landfire_ag_list = config.get('INPUTS', 'landfire_ag_list')\n landfire_ag_list = list(parse_int_set(landfire_ag_list))\n # default_landfire_ag_list = range(3960,4000)\n # landfire_ag_list = read_param(\n # 'landfire_ag_list', default_landfire_ag_list, config)\n # landfire_ag_list = map(int, landfire_ag_list)\n landfire_output_ws = config.get('INPUTS', 'landfire_output_folder')\n landfire_output_fmt = read_param(\n 'landfire_output_fmt', 'landfire_{0:04d}.img', config)\n landfire_ag_output_fmt = read_param(\n 'landfire_ag_output_fmt', 'landfire_ag_{0:04d}.img', config)\n else:\n landfire_input_path, landfire_ag_list = None, None\n landfire_output_ws = None\n landfire_output_fmt, landfire_ag_output_fmt = None, None\n\n if field_flag:\n field_input_path = config.get('INPUTS', 'field_input_path')\n field_output_ws = config.get('INPUTS', 'field_output_folder')\n field_output_fmt = read_param(\n 'field_output_fmt', 'fields_{0:04d}.img', config)\n else:\n field_input_path = None\n field_output_ws, field_output_fmt = None, None\n\n if monte_carlo_flag:\n etrf_training_path = config.get('INPUTS', 'etrf_training_path')\n # mc_iter_list = config.get('INPUTS', 'mc_iter_list')\n # mc_iter_list = list(parse_int_set(mc_iter_list))\n if monte_carlo_flag or interp_rasters_flag or interp_tables_flag:\n etrf_input_ws = read_param('etrf_input_folder', None, config)\n # if etrf_input_ws is None:\n # etrf_input_ws = os.path.join(project_ws, year)\n etr_input_ws = config.get('INPUTS', 'etr_input_folder')\n ppt_input_ws = config.get('INPUTS', 'ppt_input_folder')\n etr_input_re = config.get('INPUTS', 'etr_input_re')\n ppt_input_re = config.get('INPUTS', 'ppt_input_re')\n if monte_carlo_flag or interp_rasters_flag or interp_tables_flag:\n awc_input_path = config.get('INPUTS', 'awc_input_path')\n spinup_days = read_param('swb_spinup_days', 30, config, 'INPUTS')\n min_spinup_days = read_param(\n 'swb_min_spinup_days', 5, config, 'INPUTS')\n\n # Weather data parameters\n if metric_flag:\n metric_hourly_weather_list = ['NLDAS', 'REFET']\n metric_hourly_weather = config.get(\n 'INPUTS', 'metric_hourly_weather').upper()\n if metric_hourly_weather not in metric_hourly_weather_list:\n logging.error(\n ('\\nERROR: The METRIC hourly weather type {0} is invalid.' +\n '\\nERROR: Set metric_hourly_weather to {1}').format(\n metric_hourly_weather,\n ','.join(metric_hourly_weather_list)))\n sys.exit()\n elif metric_hourly_weather == 'REFET':\n refet_params_path = os.path.normpath(\n config.get('INPUTS', 'refet_params_path'))\n elif metric_hourly_weather == 'NLDAS':\n # metric_hourly_re = config.get('INPUTS', 'metric_hourly_re')\n # metric_daily_re = config.get('INPUTS', 'metric_daily_re')\n metric_ea_input_ws = config.get('INPUTS', 'metric_ea_input_folder')\n metric_wind_input_ws = config.get(\n 'INPUTS', 'metric_wind_input_folder')\n metric_etr_input_ws = config.get(\n 'INPUTS', 'metric_etr_input_folder')\n try:\n calc_metric_tair_flag = config.getboolean(\n 'INPUTS', 'calc_metric_tair_flag')\n metric_tair_input_ws = config.get(\n 'INPUTS', 'metric_tair_input_folder')\n except:\n calc_metric_tair_flag = False\n metric_tair_input_ws = ''\n if ssebop_flag:\n # ssebop_daily_re = config.get('INPUTS', 'ssebop_daily_re')\n ssebop_ea_input_ws = config.get('INPUTS', 'ssebop_ea_input_folder')\n ssebop_tmin_input_ws = config.get('INPUTS', 'ssebop_tmin_input_folder')\n ssebop_tmax_input_ws = config.get('INPUTS', 'ssebop_tmax_input_folder')\n ssebop_etr_input_ws = config.get('INPUTS', 'ssebop_etr_input_folder')\n # ssebop_wind_input_ws = config.get('INPUTS', 'ssebop_wind_input_folder')\n\n # Check inputs folders/paths\n logging.info('\\nChecking input folders/files')\n file_check(footprint_path)\n if landsat_flag:\n folder_check(landsat_input_ws)\n if ledaps_flag:\n folder_check(ledaps_input_ws)\n if dem_flag:\n folder_check(dem_input_ws)\n if nlcd_flag:\n file_check(nlcd_input_path)\n if cdl_flag:\n file_check(cdl_input_path)\n if landfire_flag:\n # Landfire will likely be an ESRI grid (set as a folder)\n if not (os.path.isdir(landfire_input_path) or\n os.path.isfile(landfire_input_path)):\n logging.error(' {0} does not exist.'.format(\n landfire_input_path))\n sys.exit()\n if field_flag:\n file_check(field_input_path)\n if metric_flag:\n file_check(metric_ini)\n file_check(pixel_rating_ini)\n if ssebop_flag:\n file_check(ssebop_ini)\n if interp_rasters_flag or interp_tables_flag or monte_carlo_flag:\n if etrf_input_ws is not None:\n folder_check(etrf_input_ws)\n folder_check(etr_input_ws)\n folder_check(ppt_input_ws)\n file_check(awc_input_path)\n if monte_carlo_flag:\n file_check(monte_carlo_ini)\n file_check(etrf_training_path)\n if metric_flag:\n if metric_hourly_weather == 'REFET':\n file_check(refet_params_path)\n elif metric_hourly_weather == 'NLDAS':\n folder_check(metric_ea_input_ws)\n folder_check(metric_wind_input_ws)\n folder_check(metric_etr_input_ws)\n if calc_metric_tair_flag:\n folder_check(metric_tair_input_ws)\n if ssebop_flag:\n folder_check(ssebop_ea_input_ws)\n folder_check(ssebop_tmin_input_ws)\n folder_check(ssebop_tmax_input_ws)\n folder_check(ssebop_etr_input_ws)\n # folder_check(ssebop_wind_input_ws)\n if skip_list_path:\n file_check(skip_list_path)\n\n # Build output folders\n if not os.path.isdir(project_ws):\n os.makedirs(project_ws)\n\n # For now assume path/row are two digit numbers\n tile_fmt = 'p{0:02d}r{1:02d}'\n\n # Set snap environment parameters\n snap_cs = 30\n snap_xmin, snap_ymin = (15, 15)\n env = gdc.env\n env.cellsize = snap_cs\n env.snap_xmin, env.snap_ymin = snap_xmin, snap_ymin\n\n\n # Use WGSS84 (EPSG 4326) for GCS spatial reference\n # Could also use NAD83 (EPSG 4269)\n # gcs_epsg = 4326\n # gcs_osr = epsg_osr(4326)\n # gcs_proj = osr_proj(gcs_osr)\n\n # Landsat Footprints (WRS2 Descending Polygons)\n logging.debug('\\nFootprint (WRS2 descending should be GCS84):')\n tile_gcs_osr = gdc.feature_path_osr(footprint_path)\n logging.debug(' OSR: {0}'.format(tile_gcs_osr))\n\n # Doublecheck that WRS2 descending shapefile is GCS84\n # if tile_gcs_osr != epsg_osr(4326):\n # logging.error(' WRS2 is not GCS84')\n # sys.exit()\n\n # Get geometry for each path/row\n tile_gcs_wkt_dict = path_row_wkt_func(\n footprint_path, path_field='PATH', row_field='ROW')\n # Get UTM zone for each path/row\n tile_utm_zone_dict = path_row_utm_zone_func(\n footprint_path, zone_field='UTM_ZONE',\n path_field='PATH', row_field='ROW')\n\n # Check that each path/row extent and UTM zone exist\n logging.info('\\nChecking path/row list against footprint shapefile')\n for tile_name in sorted(tile_list):\n if tile_name not in tile_gcs_wkt_dict.keys():\n logging.error(\n ' {0} feature not in footprint shapefile'.format(tile_name))\n continue\n elif tile_name not in tile_utm_zone_dict.keys():\n logging.error(\n ' {0} UTM zone not in footprint shapefile'.format(tile_name))\n continue\n elif tile_utm_zone_dict[tile_name] == 0:\n logging.error((\n ' UTM zone is not set for {0} in ' +\n 'footprint shapefile').format(tile_name))\n continue\n\n # Read RefET parameters\n if metric_hourly_weather == 'REFET':\n refet_ws = os.path.dirname(refet_params_path)\n with open(refet_params_path, 'r') as input_f:\n lines = input_f.readlines()\n lines = [line.strip() for line in lines]\n lines = [line.split(',') for line in lines if line]\n columns = lines.pop(0)\n refet_params_dict = defaultdict(dict)\n for line in lines:\n tile_name = tile_fmt.format(\n int(line[columns.index('PATH')]),\n int(line[columns.index('ROW')]))\n yr_tile_name = '{0}_{1}'.format(\n line[columns.index('YEAR')], tile_name)\n for i, column in enumerate(columns):\n if column not in ['YEAR', 'PATH', 'ROW']:\n refet_params_dict[yr_tile_name][column.lower()] = line[i]\n\n # Process input files for each year and path/row\n logging.info('\\nBuilding path/row specific input files')\n for tile_name in tile_list:\n tile_output_ws = os.path.join(project_ws, str(year), tile_name)\n logging.info('{0} {1}'.format(year, tile_name))\n yr_tile_name = '{0}_{1}'.format(year, tile_name)\n if not os.path.isdir(tile_output_ws):\n os.makedirs(tile_output_ws)\n\n # File paths\n if metric_flag:\n tile_metric_ini = os.path.join(\n tile_output_ws, os.path.basename(metric_ini).replace(\n '.ini', '_{0}_{1}.ini'.format(year, tile_name)))\n tile_pixel_rating_ini = os.path.join(\n tile_output_ws, os.path.basename(pixel_rating_ini).replace(\n '.ini', '_{0}_{1}.ini'.format(year, tile_name)))\n if overwrite_flag and os.path.isfile(tile_metric_ini):\n os.remove(tile_metric_ini)\n if overwrite_flag and os.path.isfile(tile_pixel_rating_ini):\n os.remove(tile_pixel_rating_ini)\n if ssebop_flag:\n tile_ssebop_ini = os.path.join(\n tile_output_ws, os.path.basename(ssebop_ini).replace(\n '.ini', '_{0}_{1}.ini'.format(year, tile_name)))\n if overwrite_flag and os.path.isfile(tile_ssebop_ini):\n os.remove(tile_ssebop_ini)\n\n # Monte Carlo is independent of tile and year, but process\n # with METRIC input file\n if monte_carlo_flag:\n tile_monte_carlo_ini = os.path.join(\n tile_output_ws, os.path.basename(monte_carlo_ini).replace(\n '.ini', '_{0}_{1}.ini'.format(year, tile_name)))\n if overwrite_flag and os.path.isfile(tile_monte_carlo_ini):\n os.remove(tile_monte_carlo_ini)\n\n if dem_flag:\n dem_output_path = os.path.join(\n dem_output_ws, tile_name, dem_output_name)\n if nlcd_flag:\n nlcd_output_path = os.path.join(\n nlcd_output_ws, tile_name, nlcd_output_fmt.format(year))\n if modis_lc_flag:\n modis_lc_output_path = os.path.join(\n modis_lc_output_ws, tile_name,\n '{1}_{0}{2}'.format(year, *os.path.splitext(modis_lc_output_name)))\n if cdl_flag:\n cdl_ag_output_path = os.path.join(\n cdl_output_ws, tile_name, cdl_ag_output_fmt.format(year))\n print (cdl_ag_output_path)\n\n if cdl_flag:\n cdl_output_path = os.path.join(\n cdl_output_ws, tile_name, cdl_output_fmt.format(year))\n print (cdl_output_path)\n\n if landfire_flag:\n landfire_ag_output_path = os.path.join(\n landfire_output_ws, tile_name, landfire_output_fmt.format(year))\n if field_flag:\n field_output_path = os.path.join(\n field_output_ws, tile_name, field_output_fmt.format(year))\n\n # Check that the path/row was in the RefET parameters file\n if (metric_flag and\n metric_hourly_weather == 'REFET' and\n yr_tile_name not in refet_params_dict.keys()):\n logging.error(\n (' The year {0} & path/row {1} is not in the ' +\n 'RefET parameters csv, skipping').format(year, tile_name))\n continue\n\n if metric_flag and not os.path.isfile(tile_metric_ini):\n # DEADBEEF - This approach removes all formatting and comments\n config = ConfigParser.RawConfigParser()\n config.read(metric_ini)\n # shutil.copy(metric_ini, tile_metric_ini)\n # config.read(tile_metric_ini)\n\n if metric_hourly_weather == 'REFET':\n # Add RefET options\n config.set('INPUTS', 'weather_data_source', 'REFET')\n config.set(\n 'INPUTS', 'refet_file',\n os.path.join(\n refet_ws, os.path.normpath(\n refet_params_dict[yr_tile_name]['refet_file'])))\n config.set(\n 'INPUTS', 'gmt_offset',\n refet_params_dict[yr_tile_name]['gmt_offset'])\n config.set(\n 'INPUTS', 'datum',\n refet_params_dict[yr_tile_name]['datum'])\n elif metric_hourly_weather == 'NLDAS':\n # Add NLDAS options\n config.set('INPUTS', 'weather_data_source', 'NLDAS')\n # Remove RefET options\n try:\n config.remove_option('INPUTS', 'refet_file')\n except:\n pass\n try:\n config.remove_option('INPUTS', 'gmt_offset')\n except:\n pass\n #try: config.remove_option('INPUTS', 'datum')\n #except: pass\n\n if dem_flag:\n config.set('INPUTS', 'dem_raster', dem_output_path)\n else:\n try:\n config.remove_option('INPUTS', 'dem_raster')\n except:\n pass\n # config.set('INPUTS', 'dem_raster', 'None')\n\n if nlcd_flag:\n config.set('INPUTS', 'landuse_raster', nlcd_output_path)\n else:\n try:\n config.remove_option('INPUTS', 'landuse_raster')\n except:\n pass\n # config.set('INPUTS', 'landuse_raster', 'None')\n\n if modis_lc_flag:\n config.set('INPUTS', 'landuse_raster', modis_lc_output_path)\n else:\n try:\n config.remote_option('INPUTS', 'landuse_raster')\n except:\n pass\n\n logging.debug(' {}'.format(tile_metric_ini))\n with open(tile_metric_ini, 'wb') as config_f:\n config.write(config_f)\n\n if metric_flag and not os.path.isfile(tile_pixel_rating_ini):\n config = ConfigParser.RawConfigParser()\n config.read(pixel_rating_ini)\n if nlcd_flag:\n config.set('INPUTS', 'landuse_raster', nlcd_output_path)\n elif modis_lc_flag:\n config.set('INPUTS', 'landuse_raster', modis_lc_output_path)\n else:\n try:\n config.remove_option('INPUTS', 'landuse_raster')\n except:\n pass\n # config.set('INPUTS', 'landuse_raster', 'None')\n if cdl_flag:\n config.set('INPUTS', 'apply_cdl_ag_mask', True)\n config.set('INPUTS', 'cdl_ag_raster', cdl_ag_output_path)\n else:\n config.set('INPUTS', 'apply_cdl_ag_mask', False)\n try:\n config.remove_option('INPUTS', 'cdl_ag_raster')\n except:\n pass\n\n if cdl_flag:\n config.set('INPUTS', 'apply_cdl_ag_mask', True)\n config.set('INPUTS', 'cdl_raster', cdl_output_path)\n else:\n config.set('INPUTS', 'apply_cdl_ag_mask', False)\n try:\n config.remove_option('INPUTS', 'cdl_raster')\n except:\n pass\n\n if field_flag:\n config.set('INPUTS', 'apply_field_mask', True)\n config.set('INPUTS', 'fields_raster', field_output_path)\n else:\n config.set('INPUTS', 'apply_field_mask', False)\n try:\n config.remove_option('INPUTS', 'fields_raster')\n except:\n pass\n # config.set('INPUTS', 'fields_raster', 'None')\n # if landfire_flag:\n # config.set('INPUTS', 'apply_landfire_ag_mask', True)\n # config.set('INPUTS', 'landfire_ag_raster', cdl_ag_output_path)\n # else:\n # config.set('INPUTS', 'apply_landfire_ag_mask', False)\n # try: config.remove_option('INPUTS', 'landfire_ag_raster')\n # except: pass\n # # config.set('INPUTS', 'landfire_ag_raster', 'None')\n\n logging.debug(' {}'.format(tile_pixel_rating_ini))\n with open(tile_pixel_rating_ini, 'wb') as config_f:\n config.write(config_f)\n\n if monte_carlo_flag and not os.path.isfile(tile_monte_carlo_ini):\n config = ConfigParser.RawConfigParser()\n config.read(monte_carlo_ini)\n config.set('INPUTS', 'etrf_training_path', etrf_training_path)\n config.set('INPUTS', 'etr_ws', etr_input_ws)\n config.set('INPUTS', 'ppt_ws', ppt_input_ws)\n config.set('INPUTS', 'etr_re', etr_input_re)\n config.set('INPUTS', 'ppt_re', ppt_input_re)\n config.set('INPUTS', 'awc_path', awc_input_path)\n config.set('INPUTS', 'swb_spinup_days', spinup_days)\n config.set('INPUTS', 'swb_min_spinup_days', min_spinup_days)\n\n logging.debug(' {}'.format(tile_monte_carlo_ini))\n with open(tile_monte_carlo_ini, 'wb') as config_f:\n config.write(config_f)\n\n if ssebop_flag and not os.path.isfile(tile_ssebop_ini):\n # DEADBEEF - This approach removes all formatting and comments\n config = ConfigParser.RawConfigParser()\n config.read(ssebop_ini)\n # shutil.copy(metric_ini, tile_ssebop_ini)\n # config.read(tile_ssebop_ini)\n\n # Add GRIDMET options\n # config.set('INPUTS', 'daily_re', ssebop_daily_re)\n # config.set('INPUTS', 'ea_folder', ssebop_ea_output_path)\n # config.set('INPUTS', 'tmin_folder', ssebop_tmin_output_path)\n # config.set('INPUTS', 'tmax_folder', ssebop_tmax_output_path)\n # config.set('INPUTS', 'wind_folder', ssebop_wind_output_path)\n # config.set('INPUTS', 'etr_folder', ssebop_etr_output_path)\n\n if dem_flag:\n config.set('INPUTS', 'dem_raster', dem_output_path)\n else:\n try:\n config.remove_option('INPUTS', 'dem_raster')\n except:\n pass\n # config.set('INPUTS', 'dem_raster', 'None')\n\n logging.debug(' {}'.format(tile_ssebop_ini))\n with open(tile_ssebop_ini, 'wb') as config_f:\n config.write(config_f)\n\n # Cleanup\n del tile_output_ws, yr_tile_name\n\n # Interpolator input file\n if interp_rasters_flag or interp_tables_flag:\n logging.info('\\nBuilding interpolator input files')\n year_interpolator_name = os.path.basename(interpolate_ini).replace(\n '.ini', '_{0}_{1}.ini'.format(year, interpolate_folder.lower()))\n year_interpolator_ini = os.path.join(\n project_ws, str(year), year_interpolator_name)\n if overwrite_flag and os.path.isfile(year_interpolator_ini):\n os.remove(year_interpolator_ini)\n if not os.path.isfile(year_interpolator_ini):\n # First copy the template config file to the year folder\n shutil.copy(interpolate_ini, year_interpolator_ini)\n\n # Open the existing config file and update the values\n # DEADBEEF - This approach removes all formatting and comments\n config = ConfigParser.RawConfigParser()\n config.read(year_interpolator_ini)\n config.set('INPUTS', 'folder_name', interpolate_folder)\n config.set('INPUTS', 'tile_list', ', '.join(tile_list))\n if interp_rasters_flag:\n config.set('INPUTS', 'study_area_path', study_area_path)\n config.set('INPUTS', 'study_area_mask_flag', study_area_mask_flag)\n config.set('INPUTS', 'study_area_snap', ', '.join(map(str, study_area_snap)))\n config.set('INPUTS', 'study_area_cellsize', study_area_cellsize)\n config.set('INPUTS', 'study_area_buffer', study_area_buffer)\n if study_area_proj:\n config.set('INPUTS', 'study_area_proj', study_area_proj)\n else:\n try:\n config.remove_option('INPUTS', 'study_area_proj', study_area_proj)\n except:\n pass\n if interp_tables_flag:\n config.set('INPUTS', 'zones_path', zones_path)\n config.set('INPUTS', 'zones_snap', ', '.join(map(str, zones_snap)))\n config.set('INPUTS', 'zones_cellsize', zones_cellsize)\n config.set('INPUTS', 'zones_name_field', zones_name_field)\n # zones_buffer is not currently implemented\n if zones_buffer:\n config.set('INPUTS', 'zones_buffer', zones_buffer)\n else:\n try:\n config.remove_option('INPUTS', 'zones_buffer', zones_buffer)\n except:\n pass\n # zones proj., cellsize, and snap are not needed or\n # read in if zones_mask is set\n # zones_proj is not currently implemented\n if zones_mask:\n config.set('INPUTS', 'zones_mask', zones_mask)\n try:\n config.remove_option('INPUTS', 'zones_proj')\n except:\n pass\n try:\n config.remove_option('INPUTS', 'zones_cellsize')\n except:\n pass\n try:\n config.remove_option('INPUTS', 'zones_snap')\n except:\n pass\n # elif zones_proj:\n # config.set('INPUTS', 'zones_proj', zones_proj)\n # try:\n # config.remove_option('INPUTS', 'zones_mask')\n # except:\n # pass\n else:\n try:\n config.remove_option('INPUTS', 'zones_proj')\n except:\n pass\n try:\n config.remove_option('INPUTS', 'zones_mask')\n except:\n pass\n config.set('INPUTS', 'year', year)\n config.set('INPUTS', 'footprint_path', footprint_path)\n if etrf_input_ws is not None:\n config.set('INPUTS', 'etrf_input_folder', etrf_input_ws)\n config.set('INPUTS', 'etr_input_folder', etr_input_ws)\n config.set('INPUTS', 'etr_input_re', etr_input_re)\n config.set('INPUTS', 'ppt_input_folder', ppt_input_ws)\n config.set('INPUTS', 'ppt_input_re', ppt_input_re)\n # DEADBEEF - add check for SWB flag\n config.set('INPUTS', 'awc_input_path', awc_input_path)\n config.set('INPUTS', 'swb_spinup_days', spinup_days)\n config.set('INPUTS', 'swb_min_spinup_days', min_spinup_days)\n\n logging.debug(' {}'.format(year_interpolator_ini))\n with open(year_interpolator_ini, 'wb') as config_f:\n config.write(config_f)", "def read_ini_file (path):\n # TODO write a code to read data from ini-file to dictionary\n\n\n pass", "def __init__(self, ini_file):\n self.config = configparser.ConfigParser()\n self.config.read(ini_file)", "def __init__(self, __file):\n\n\t\tself.fileName = __file\n\t\tif (os.path.isfile(self.fileName)):\n\t\t\t# config.ini found, load it\n\t\t\tself.config.read(self.fileName)\n\t\t\tself.default = False\n\t\telse:\n\t\t\t# config.ini not found, generate a default one\n\t\t\tself.generateDefaultConfig()\n\t\t\tself.default = True", "def configure_parser_scan(subparsers):\n help_msg = \"Scan input regions to detect motif occurrences.\"\n desc_msg = help_msg + dedent(\"\"\"\n \n This main command invokes to scan the sequences of user specified input \n genomic regions and detect the occurrences for a set of known motifs. \n After scanning the input regions, an optional motif enrichment analysis \n is performed to check whether these motifs are over/under-represented \n compared to control regions (can be random generated or user specified).\n \"\"\")\n\n epilog_msg = dedent(\"\"\"\n Examples:\n ---------\n 1) Scan input regions for a set of known motifs under 'hg19' genome:\n\n motifscan scan -i regions.bed -m <motif_set> -g hg19 -o <path>\n \n 2) Test motif enrichment compared to user-specified control regions:\n\n motifscan scan -i regions.bed -c control.bed -m <motif_set> -g hg19 -o <path>\n \n 3) Only scan input regions located at promoters:\n\n motifscan scan -i regions.bed -m <motif_set> -g hg19 --loc promoter -o <path>\n \n 4) Scan whole input regions rather than fixed-size windows:\n\n motifscan scan -i regions.bed -m <motif_set> -g hg19 -w 0 -o <path>\n\n 5) Report the positions and distributions of detected motif sites:\n\n motifscan scan -i regions.bed -m <motif_set> -g hg19 --site --plot -o <path>\n\n \"\"\")\n\n parser = subparsers.add_parser(\n \"scan\", description=desc_msg, help=help_msg, epilog=epilog_msg,\n formatter_class=argparse.RawDescriptionHelpFormatter)\n parser_input = parser.add_argument_group(\"Input Options\")\n parser_input.add_argument(\n \"-i\", metavar=\"FILE\", dest=\"input_file\", required=True,\n help=\"Input genomic regions (peaks) to be scanned.\")\n parser_input.add_argument(\n \"-f\", dest=\"input_format\", choices=REGION_FORMATS, default=\"bed\",\n help=\"Format of the input file. Default: bed\")\n parser_input.add_argument(\n \"-m\", \"--motif\", metavar=\"NAME\", dest=\"motif\", required=True,\n help=\"Motif set name to scan for.\")\n parser_input.add_argument(\n \"-g\", \"--genome\", metavar=\"GENOME\", dest=\"genome\", required=True,\n help=\"Genome assembly name.\")\n\n parser_advance = parser.add_argument_group(\"Scanning Options\")\n parser_advance.add_argument(\n \"-p\", dest=\"p_value\", default=\"1e-4\",\n choices=[\"1e-2\", \"1e-3\", \"1e-4\", \"1e-5\", \"1e-6\"],\n help=\"P value cutoff for motif scores. Default: 1e-4\")\n parser_advance.add_argument(\n \"--loc\", dest=\"location\", choices=[\"promoter\", \"distal\"], default=None,\n help=\"If specified, only scan promoter or distal regions.\")\n parser_advance.add_argument(\n \"--upstream\", metavar=\"DISTANCE\", dest=\"upstream\",\n type=_pos_int, default=4000,\n help=\"TSS upstream distance for promoters. Default: 4000\")\n parser_advance.add_argument(\n \"--downstream\", metavar=\"DISTANCE\", dest=\"downstream\",\n type=_pos_int, default=2000,\n help=\"TSS downstream distance for promoters. Default: 2000\")\n parser_advance.add_argument(\n \"-w\", \"--window-size\", metavar=\"LENGTH\", dest=\"window_size\",\n type=_non_negative_int, default=1000,\n help=\"Window size for scanning. In most cases, motifs occur closely \"\n \"around the centers or summits of genomic peaks. Scanning a \"\n \"fixed-size window is often sufficient to detect motif sites and \"\n \"unbiased for the enrichment analysis. If set to 0, the whole \"\n \"input regions are included for scanning. Default: 1000\")\n parser_advance.add_argument(\n \"--strand\", dest=\"strand\", choices=['both', '+', '-'], default=\"both\",\n help=\"Enable strand-specific scanning, defaults to scan both strands.\")\n\n parser_enrich = parser.add_argument_group(\"Enrichment Analysis Options\")\n parser_enrich.add_argument(\n \"--no-enrich\", dest=\"no_enrich\", action=\"store_true\", default=False,\n help=\"Disable the enrichment analysis.\")\n parser_enrich.add_argument(\n \"--n-random\", metavar=\"N\", dest=\"n_random\",\n type=_non_negative_int, default=5,\n help=\"Generate N random control regions for each input region. \"\n \"Default: 5\")\n parser_enrich.add_argument(\n \"--seed\", metavar=\"SEED\", dest=\"seed\", type=int, default=None,\n help=\"Random seed used to generate control regions.\")\n parser_enrich.add_argument(\n \"-c\", metavar=\"FILE\", dest=\"control_file\",\n help=\"Use custom control regions for the enrichment analysis.\")\n parser_enrich.add_argument(\n \"--cf\", dest=\"control_format\", choices=REGION_FORMATS, default=\"bed\",\n help=\"Format of the control file. Default: bed\")\n\n parser_threads = parser.add_argument_group(\"Threads Options\")\n parser_threads.add_argument(\n \"-t\", \"--threads\", metavar=\"N\", dest=\"n_threads\", type=int, default=1,\n help=\"Number of processes used to run in parallel.\")\n\n parser_output = parser.add_argument_group(\"Output Options\")\n parser_output.add_argument(\n \"-o\", \"--output-dir\", metavar=\"DIR\", dest=\"output_dir\", required=True,\n help=\"Directory to write output files.\")\n parser_output.add_argument(\n \"--site\", dest=\"report_site\", action=\"store_true\", default=False,\n help=\"If set, report the position for each detected motif site.\")\n parser_output.add_argument(\n \"--plot\", dest=\"plot_dist\", action=\"store_true\", default=False,\n help=\"If set, plot the distributions of detected motif sites.\")\n\n parser = _add_verbose_argument(parser)\n parser.set_defaults(func=scan.run)", "def test_invocations_ini():\n invocations = labeled.contents(label=\"invocations\")\n tox = Path(\"tox.ini\").read_text(encoding=\"utf-8\")\n gendir = \".gendir-ini\"\n assert gendir in invocations\n assert f\"output_directory = {gendir}\" in tox", "def processIniFile_(self, opts):\n\n # Extract cfg-file name from the cmd-line options.\n \n for opt in opts.keys():\n if ( opt == '-cfg' ):\n if self.flag_continue:\n raise SkimException('-continue and -cfg cannot coexist.')\n if opts[opt] : self.cfg_fname = opts[opt]\n else : usage()\n pass\n\n elif ( opt == '-name' ):\n self.name = opts[opt]\n pass\n\n pass\n\n # Set default cfg-fname\n \n if self.cfg_fname == None:\n if self.flag_continue:\n self.cfg_fname = common.work_space.cfgFileName()\n else:\n self.cfg_fname = common.prog_name+'.cfg'\n pass\n pass\n\n # Load cfg-file\n \n if string.lower(self.cfg_fname) != 'none':\n if os.path.exists(self.cfg_fname):\n self.cfg_params = loadConfig(self.cfg_fname)\n self.cfg_params['user'] = os.environ['USER']\n pass\n else:\n msg = 'cfg-file '+self.cfg_fname+' not found.'\n raise SkimException(msg)\n pass\n pass\n\n return", "def populate(infile):\n main(infile)", "def get_config_params():\n configParser = configparser.ConfigParser()\n configParser.read(os.path.splitext(sys.argv[0])[0]+'.ini')\n return configParser", "def ConfigureScan(self, argin):\n # PROTECTED REGION ID(CbfSubarray.ConfigureScan) ENABLED START #\n # \"\"\"\n\n command = self.get_command_object(\"ConfigureScan\")\n (return_code, message) = command(argin)\n return [[return_code], [message]]", "def scan(ctx, infile):\n # ensure that ctx.obj exists and is a dict (in case `cli()` is called\n # by means other than the `if` block below)\n ctx.ensure_object(dict)\n ctx.obj['log'] = cdslog\n with open(infile, 'r') as fj:\n args = json.load(fj)\n ctx.obj['dsargs'] = define_args(args['index'], args['tstep'])\n api_request(ctx, args, scan=True)", "def configure_parser_main():\n description = dedent(\"\"\"\n MotifScan: A motif discovery tool to detect the occurrences of known motifs\n \n Given a set of input genomic regions, MotifScan scans the sequences to \n detect the occurrences of known motifs. It can also perform an enrichment \n analysis to check whether these motifs are over/under-represented compared \n to the control regions.\n \n !!! NOTE !!!\n MotifScan requires basic data files including genome sequences and motif \n PFMs (Position Frequency Matrices) to detect the binding sites of motifs. \n Before scanning, users should install genome assemblies and motif sets from\n a remote database or with local prepared files via `motifscan genome` and \n `motifscan motif` subcommands.\n \n Citation:\n Sun, H., Wang, J., Gong, Z. et al. Quantitative integration of epigenomic \n variation and transcription factor binding using MAmotif toolkit identifies\n an important role of IRF2 as transcription activator at gene promoters. \n Cell Discov 4, 38 (2018). https://doi.org/10.1038/s41421-018-0045-y\n \"\"\")\n\n epilog_msg = dedent(\"\"\"\n Please run `motifscan COMMAND -h` to see the subcommand options.\n \n See also: \n Documentation: https://motifscan.readthedocs.io\n Source code: https://github.com/shao-lab/MotifScan\n Bug reports: https://github.com/shao-lab/MotifScan/issues\n \"\"\")\n\n parser = argparse.ArgumentParser(\n description=description, epilog=epilog_msg,\n formatter_class=argparse.RawDescriptionHelpFormatter)\n parser.add_argument(\"-v\", \"--version\", action=\"version\",\n version=f\"MotifScan {__version__}\")\n\n subparsers = parser.add_subparsers(title=\"MotifScan Subcommands\",\n metavar=\"command\", dest=\"cmd\")\n configure_parser_config(subparsers)\n configure_parser_genome(subparsers)\n configure_parser_motif(subparsers)\n configure_parser_scan(subparsers)\n return parser", "def __init__(self, ini_file):\n self.config = configparser.ConfigParser()\n self.config.read(ini_file)\n #print(self.config)", "def comando_config(self):\r\n if args.tag:\r\n cfile = args.file\r\n\t if args.opcao == 'daruma' and not cfile:\r\n cfile = '/usr/local/lib/daruma.ini'\r\n\t if args.value:\r\n dictags = self.set_param_section_config_ini(cfile, args.loja, args.tag, args.value)\r\n return dictags\r\n # modificar\r\n\t else:\r\n dictag = self.get_param_section_config_ini(cfile, args.loja, args.tag)\r\n return dictag #retorna dicicionario\r", "def load_bookie_ini(ini_file):\r\n ini = ConfigParser()\r\n ini_path = path.join(path.dirname(path.dirname(__file__)), ini_file)\r\n ini.readfp(open(ini_path))\r\n here = path.abspath(path.join(path.dirname(__file__), '../'))\r\n ini.set('app:bookie', 'here', here)\r\n initialize_sql(dict(ini.items(\"app:bookie\")))\r\n return ini", "def load_ini_file(ini_file_path):\n config = configparser.ConfigParser()\n config.read(ini_file_path)\n cfg = {}\n\n # Load hyperparameters\n cfg[\"hyperparameters\"] = {}\n cfg[\"hyperparameters\"][\"gpu_id\"] = config.getint(\"hyperparameters\", \"gpu_id\")\n cfg[\"hyperparameters\"][\"seed\"] = config.getint(\"hyperparameters\", \"seed\")\n cfg[\"hyperparameters\"][\"optimizer\"] = config.get(\"hyperparameters\", \"optimizer\")\n cfg[\"hyperparameters\"][\"lr\"] = config.getfloat(\"hyperparameters\", \"lr\")\n cfg[\"hyperparameters\"][\"momentum\"] = config.getfloat(\"hyperparameters\", \"momentum\")\n cfg[\"hyperparameters\"][\"clip\"] = config.getfloat(\"hyperparameters\", \"clip\")\n cfg[\"hyperparameters\"][\"dropout\"] = config.getfloat(\"hyperparameters\", \"dropout\")\n cfg[\"hyperparameters\"][\"batch_size\"] = config.getint(\"hyperparameters\", \"batch_size\")\n cfg[\"hyperparameters\"][\"embedding_dim\"] = config.getint(\"hyperparameters\", \"embedding_dim\")\n cfg[\"hyperparameters\"][\"commun_embed_size\"] = config.getint(\"hyperparameters\", \"commun_embed_size\")\n cfg[\"hyperparameters\"][\"num_epochs\"] = config.getint(\"hyperparameters\", \"num_epochs\")\n cfg[\"hyperparameters\"][\"use_one_hot\"] = config.getboolean(\"hyperparameters\", \"use_one_hot\")\n cfg[\"hyperparameters\"][\"max_input_length\"] = config.getint(\"hyperparameters\", \"max_input_length\")\n cfg[\"hyperparameters\"][\"max_num_answers\"] = config.getint(\"hyperparameters\", \"max_num_answers\")\n cfg[\"hyperparameters\"][\"use_dnc_c\"] = config.getboolean(\"hyperparameters\", \"use_dnc_c\") \n cfg[\"hyperparameters\"][\"use_dnc_q\"] = config.getboolean(\"hyperparameters\", \"use_dnc_q\")\n cfg[\"hyperparameters\"][\"share_memory\"] = config.getboolean(\"hyperparameters\", \"share_memory\")\n cfg[\"hyperparameters\"][\"weight_decay\"] = config.getfloat(\"hyperparameters\", \"weight_decay\")\n cfg[\"hyperparameters\"][\"use_clip_grad\"] = config.getboolean(\"hyperparameters\", \"use_clip_grad\")\n cfg[\"hyperparameters\"][\"clip_value\"] = config.getfloat(\"hyperparameters\", \"clip_value\")\n cfg[\"hyperparameters\"][\"lr_reduce_after\"] = config.getint(\"hyperparameters\", \"lr_reduce_after\")\n cfg[\"hyperparameters\"][\"lr_decay_rate\"] = config.getfloat(\"hyperparameters\", \"lr_decay_rate\")\n cfg[\"hyperparameters\"][\"grad_flow_interval\"] = config.getfloat(\"hyperparameters\", \"grad_flow_interval\")\n cfg[\"hyperparameters\"][\"add_noise\"] = config.getboolean(\"hyperparameters\", \"add_noise\")\n cfg[\"hyperparameters\"][\"finetune\"] = config.getboolean(\"hyperparameters\", \"finetune\")\n cfg[\"hyperparameters\"][\"fc_flag\"] = config.getboolean(\"hyperparameters\", \"fc_flag\")\n\n # Load lstm parameters\n cfg[\"lstm\"] = {}\n cfg[\"lstm\"][\"hidden_dim\"] = config.getint(\"lstm\", \"hidden_dim\")\n cfg[\"lstm\"][\"num_layers\"] = config.getint(\"lstm\", \"num_layers\")\n cfg[\"lstm\"][\"dropout\"] = config.getfloat(\"lstm\", \"dropout\")\n\n # Load dnc_q parameters\n cfg[\"dnc_q\"] = {}\n cfg[\"dnc_q\"][\"input_size\"] = config.getint(\"dnc_q\", \"input_size\")\n cfg[\"dnc_q\"][\"output_size\"] = config.getint(\"dnc_q\", \"output_size\")\n cfg[\"dnc_q\"][\"rnn_type\"] = config.get(\"dnc_q\", \"rnn_type\")\n cfg[\"dnc_q\"][\"hidden_dim\"] = config.getint(\"dnc_q\", \"hidden_dim\")\n cfg[\"dnc_q\"][\"memory_type\"] = config.get(\"dnc_q\", \"memory_type\")\n cfg[\"dnc_q\"][\"num_layers\"] = config.getint(\"dnc_q\", \"num_layers\")\n cfg[\"dnc_q\"][\"num_layers_hidden\"] = config.getint(\"dnc_q\", \"num_layers_hidden\")\n cfg[\"dnc_q\"][\"n\"] = config.getint(\"dnc_q\", \"n\")\n cfg[\"dnc_q\"][\"w\"] = config.getint(\"dnc_q\", \"w\")\n cfg[\"dnc_q\"][\"r\"] = config.getint(\"dnc_q\", \"r\")\n cfg[\"dnc_q\"][\"s_r\"] = config.getint(\"dnc_q\", \"t_r\")\n cfg[\"dnc_q\"][\"t_r\"] = config.getint(\"dnc_q\", \"s_r\")\n cfg[\"dnc_q\"][\"pass_through_mem\"] = config.getboolean(\"dnc_q\", \"pass_through_mem\")\n cfg[\"dnc_q\"][\"reset_experience\"] = config.getboolean(\"dnc_q\", \"reset_experience\")\n cfg[\"dnc_q\"][\"debug\"] = config.getboolean(\"dnc_q\", \"debug\")\n cfg[\"dnc_q\"][\"lr\"] = config.getfloat(\"dnc_q\", \"lr\")\n cfg[\"dnc_q\"][\"dropout\"] = config.getfloat(\"dnc_q\", \"dropout\")\n\n # Load dnc_c parameters\n cfg[\"dnc_c\"] = {}\n cfg[\"dnc_c\"][\"output_size\"] = config.getint(\"dnc_c\", \"output_size\")\n cfg[\"dnc_c\"][\"rnn_type\"] = config.get(\"dnc_c\", \"rnn_type\")\n cfg[\"dnc_c\"][\"hidden_dim\"] = config.getint(\"dnc_c\", \"hidden_dim\")\n cfg[\"dnc_c\"][\"memory_type\"] = config.get(\"dnc_c\", \"memory_type\")\n cfg[\"dnc_c\"][\"num_layers\"] = config.getint(\"dnc_c\", \"num_layers\")\n cfg[\"dnc_c\"][\"num_layers_hidden\"] = config.getint(\"dnc_c\", \"num_layers_hidden\")\n cfg[\"dnc_c\"][\"n\"] = config.getint(\"dnc_c\", \"n\")\n cfg[\"dnc_c\"][\"w\"] = config.getint(\"dnc_c\", \"w\")\n cfg[\"dnc_c\"][\"r\"] = config.getint(\"dnc_c\", \"r\")\n cfg[\"dnc_c\"][\"s_r\"] = config.getint(\"dnc_c\", \"t_r\")\n cfg[\"dnc_c\"][\"t_r\"] = config.getint(\"dnc_c\", \"s_r\")\n cfg[\"dnc_c\"][\"pass_through_mem\"] = config.getboolean(\"dnc_c\", \"pass_through_mem\")\n cfg[\"dnc_c\"][\"reset_experience\"] = config.getboolean(\"dnc_c\", \"reset_experience\")\n cfg[\"dnc_c\"][\"debug\"] = config.getboolean(\"dnc_c\", \"debug\")\n cfg[\"dnc_c\"][\"lr\"] = config.getfloat(\"dnc_c\", \"lr\")\n cfg[\"dnc_c\"][\"dropout\"] = config.getfloat(\"dnc_c\", \"dropout\")\n cfg[\"dnc_c\"][\"type\"] = config.get(\"dnc_c\", \"type\")\n cfg[\"dnc_c\"][\"nonlinearity\"] = config.get(\"dnc_c\", \"nonlinearity\")\n cfg[\"dnc_c\"][\"concat_out_rv\"] = config.getboolean(\"dnc_c\", \"concat_out_rv\")\n cfg[\"dnc_c\"][\"bidirectional\"] = config.getboolean(\"dnc_c\", \"bidirectional\")\n\n # Load logging paths\n cfg[\"logging\"] = {}\n cfg[\"logging\"][\"tensorboard_dir\"] = config.get(\"logging\", \"tensorboard_dir\")\n cfg[\"logging\"][\"checkpoints_dir\"] = config.get(\"logging\", \"checkpoints_dir\")\n cfg[\"logging\"][\"results_dir\"] = config.get(\"logging\", \"results_dir\")\n cfg[\"logging\"][\"grad_flow_dir\"] = config.get(\"logging\", \"grad_flow_dir\")\n\n # Load paths\n cfg[\"paths\"] = {}\n cfg[\"paths\"][\"input\"] = config.get(\"paths\", \"input\")\n cfg[\"paths\"][\"json_q_path_tr\"] = config.get(\"paths\", \"json_q_path_tr\")\n cfg[\"paths\"][\"json_q_path_val\"] = config.get(\"paths\", \"json_q_path_val\")\n cfg[\"paths\"][\"json_a_path_tr\"] = config.get(\"paths\", \"json_a_path_tr\")\n cfg[\"paths\"][\"json_a_path_val\"] = config.get(\"paths\", \"json_a_path_val\")\n cfg[\"paths\"][\"json_q_path_test\"] = config.get(\"paths\", \"json_q_path_test\")\n cfg[\"paths\"][\"dnc_q\"] = config.get(\"paths\", \"dnc_q\")\n cfg[\"paths\"][\"dnc_c\"] = config.get(\"paths\", \"dnc_c\")\n return cfg", "def read_ini(ini_file): \n project = ''\n bd_analysis_time = bd_interval_time = '' \n bd_ripper_analysis_time = bd_ripper_interval_time = '' \n dvd_analysis_time = dvd_interval_time = '' \n file_analysis_time = file_interval_time = '' \n bd_path = dvd_path = file_path = ''\n bd_path_mac = dvd_path_mac = file_path_mac = ''\n params_dict = {}\n \n if os.path.exists(ini_file): \n try:\n config = ConfigParser.ConfigParser()\n config.readfp(open(ini_file))\n except Exception, e:\n initlog('failed to read ini file; %s' % str(e)) \n else: \n try:\n project = (config.get('Project', 'project')) \n bd_analysis_time = int(config.get('BD/3Dcopy','analysis time')) \n bd_interval_time = int(config.get('BD/3Dcopy','interval time')) \n bd_ripper_analysis_time = int(config.get('BD/3Dcopy','ripper analysis time')) \n bd_ripper_interval_time = int(config.get('BD/3Dcopy','ripper interval time')) \t\t\t\t\n dvd_analysis_time = int(config.get('DVD/DVDcopy','analysis time')) \n dvd_interval_time = int(config.get('DVD/DVDcopy','interval time'))\n file_analysis_time = int(config.get('FILE','analysis time')) \n file_interval_time = int(config.get('FILE','interval time'))\n bd_path = config.get('BD/3Dcopy','bd_path')\n dvd_path = config.get('DVD/DVDcopy', 'dvd_path')\n file_path = config.get('FILE','file_path')\n bd_path_mac = config.get('BD/3Dcopy','bd_path_mac')\n dvd_path_mac = config.get('DVD/DVDcopy', 'dvd_path_mac')\n file_path_mac = config.get('FILE','file_path_mac')\n except Exception, e:\n initlog('read ini file error; %s' % str(e))\n else:\n initlog('dvdfab_auto_tool.ini file does not exist')\n params_dict[\"project\"] = project\n params_dict[\"bd_analysis_time\"] = bd_analysis_time\n params_dict[\"bd_interval_time\"] = bd_interval_time\n params_dict[\"bd_ripper_analysis_time\"] = bd_ripper_analysis_time\n params_dict[\"bd_ripper_interval_time\"] = bd_ripper_interval_time\n params_dict[\"dvd_analysis_time\"] = dvd_analysis_time\n params_dict[\"dvd_interval_time\"] = dvd_interval_time\n params_dict[\"file_analysis_time\"] = file_analysis_time\n params_dict[\"file_interval_time\"] = file_interval_time\n params_dict[\"bd_path\"] = bd_path\n params_dict[\"dvd_path\"] = dvd_path\n params_dict[\"file_path\"] = file_path\n params_dict[\"bd_path_mac\"] = bd_path_mac\n params_dict[\"dvd_path_mac\"] = dvd_path_mac\n params_dict[\"file_path_mac\"] = file_path_mac\n return params_dict\n return project, bd_analysis_time, bd_interval_time, bd_ripper_analysis_time, bd_ripper_interval_time, dvd_analysis_time, dvd_interval_time, file_analysis_time, file_interval_time, bd_path, dvd_path, file_path,bd_path_mac,dvd_path_mac,file_path_mac", "def read_setup(inifile):\n # inifile = os.path.join(spathy_path, inifile)\n print(inifile)\n cfg = configparser.ConfigParser()\n cfg.read(inifile)\n\n pp = {}\n for s in cfg.sections():\n section = s.encode('ascii', 'ignore')\n pp[section] = {}\n for k, v in cfg.items(section):\n key = k.encode('ascii', 'ignore')\n val = v.encode('ascii', 'ignore')\n if section == 'General': # 'general' section\n pp[section][key] = val\n else:\n pp[section][key] = float(val)\n pp['General']['dt'] = float(pp['General']['dt'])\n\n pgen = pp['General']\n pcpy = pp['CanopyGrid']\n pbu = pp['BucketGrid']\n ptop = pp['Topmodel']\n\n return pgen, pcpy, pbu, ptop", "def define_user_config(self) -> None:\n self.add_standard_metadata('infiles')\n\n self.add_custom_metadata(name='key_cols',\n short_name='k',\n required=True,\n default=[],\n nargs='*',\n type=list)\n self.add_custom_metadata(name='compare_cols',\n short_name='c',\n default=[],\n nargs='*',\n type=list)\n self.add_custom_metadata(name='ignore_cols',\n default=[],\n nargs='*',\n type=list)\n self.add_custom_metadata(name='col_names',\n default=[],\n nargs='*',\n type=list)\n self.add_custom_metadata(name='variables',\n default=[],\n nargs='*',\n type=list)\n self.add_custom_metadata(name='already_sorted',\n action='store_const',\n const=True,\n default=False,\n type=bool)\n self.add_custom_metadata(name='already_uniq',\n action='store_const',\n const=True,\n default=False,\n type=bool)\n self.add_custom_metadata(name='temp_dir',\n default=None,\n type=str)\n self.add_custom_metadata(name='out_dir',\n default=None,\n type=str)\n self.add_custom_metadata(name='assignments',\n default=[],\n type=list)\n\n self.add_standard_metadata('verbosity')\n self.add_all_config_configs()\n self.add_all_csv_configs()\n self.add_all_help_configs()", "def parse_inifile(self):\n parsed_info = {\n \"identity_type\": None,\n \"username\": None,\n \"api_key\": None,\n \"region\": None,\n }\n res = self.configparse.read(self.inifile)\n for field in parsed_info.keys():\n try:\n parsed_info[field] = self.configparse[\"rackspace_cloud\"][field]\n except KeyError:\n parsed_info[field] = None\n pass\n return LoginInfo(\n identity_type=parsed_info[\"identity_type\"],\n username=parsed_info[\"username\"],\n api_key=parsed_info[\"api_key\"],\n region=parsed_info[\"region\"],\n )", "def __init__(self, file):\n\n self.read(file)\n\n for key in [\"sqlite3dir\", \"htmldir\"]:\n print(key)\n if not hasattr(self, \"_{:s}\".format(key)):\n raise ValueError(\"misspecification in config file for \\\"{:s}\\\"\".format(key) + \\\n \" in [observations] section\")", "def ini(filename, **defaults):\n filename = sh.path(filename)\n defaults.update(home=sh.path('~'))\n return ConfigObject(filename=filename, defaults=defaults)", "def load_from_file(self, path):\n schema = self.schema\n \n # Set up the default values.\n if schema is not None:\n for sect, sect_obj in schema.items():\n for opt, val in sect_obj.items():\n # This call is to convert the value to\n # the type specified. We do this to\n # prevent the programmer from specifying\n # inconsistent type with the value in the \n # schema.\n self.set(*_convert(schema, sect, opt, val[1]))\n\n # Parse the INI file.\n parser = RawConfigParser()\n parser.read(path)\n \n sections = parser.sections()\n for section in sections:\n \n # If application has supplied a schema,\n # and it does not has such a section, we skip\n # it. No error raised.\n if schema is not None and \\\n not schema.has_key(section):\n continue\n\n options = parser.options(section)\n \n for option in options:\n \n # If application has supplied a schema,\n # we know the section is valid since it pass the\n # previus test, but if the option is not included\n # in the section, we skip it. No error raised.\n if schema is not None and \\\n (option not in schema[section]):\n continue \n \n # If there is a schema, then we convert the \n # option to its type stated in the schema,\n # otherwise we just leave it as string.\n if schema is not None:\n self.set(*_convert(schema, section, option,\n parser.get(section, option)))\n else:\n self.set(section, option,\n parser.get(section, option))", "def configure_args(self):\n super(InstaApriori, self).configure_args()\n self.add_passthru_arg('-iteration', type=int, help=\"The current iteration. Not used as a command line argument\")\n self.add_passthru_arg('--k', type=int, default=3, help=\"Specify the maximum size of itemsets to find\")\n self.add_passthru_arg('--s', type=float, help=\"Specify the minimum support threshold\")\n self.add_passthru_arg('--c', type=float, default=0, help=\"Specify the minimum confidence threshold\")\n self.add_file_arg('--f', default='frequent.txt',\n help=\"Specify the name of the file used to store frequent itemsets\")", "def parse_ini_file_into_dict(filename):\n output = {}\n\n INIfile = SafeConfigParser()\n result = INIfile.read(filename) # returns an empty list if file error\n if result == []:\n raise IOError\n\n #iterate through INI file and build dictionary\n for section_name in INIfile.sections():\n section_dict = {}\n for option_name in INIfile.options(section_name):\n option_value = INIfile.get(section_name, option_name)\n section_dict[option_name] = option_value\n output[section_name] = section_dict\n\n return output", "def loadIni(self):\n reLoadFiles = re.compile(r'^\\[Game Files\\](.*)')\n reLoadFile = re.compile(r'GameFile[0-9]+=(.*)$')\n #--Read file\n self.mtime = getmtime(self.path)\n self.size = os.path.getsize(self.path)\n ins = file(self.path,'rt')\n #--Pre-Load Lines\n del self.preLoadLines[:]\n del self.postLoadLines[:]\n while True:\n line = ins.readline()\n if not line: \n ins.close()\n raise Tes3Error('Morrowind.ini', _('Morrowind.ini: [GameFiles] section not found.'))\n maLoadFiles = reLoadFiles.match(line)\n if maLoadFiles: break\n self.preLoadLines.append(line)\n #--Load Files \n self.loadFilesComment = maLoadFiles.group(1)\n del self.loadFiles[:]\n del self.loadFilesBad[:]\n while True:\n line = ins.readline()\n maLoadFile = reLoadFile.match(line)\n if not maLoadFile: \n if line: self.postLoadLines.append(line)\n break\n loadFile = unicode(maLoadFile.group(1), 'latin-1')\n loadPath = os.path.join(self.dir,'Data Files',loadFile)\n loadExt = os.path.splitext(loadPath)[-1].lower()\n if len(self.loadFiles) == 255:\n self.loadFilesExtra.append(loadFile)\n elif os.path.exists(loadPath) and re.match('^\\.es[pm]$',loadExt):\n self.loadFiles.append(loadFile)\n else:\n self.loadFilesBad.append(loadFile)\n #--Post-Load Lines\n while True:\n line = ins.readline()\n if not line: break\n self.postLoadLines.append(line)\n #--Done\n ins.close()", "def configure_app(self, app, parser):\n parser.add_argument(\n 'infile',\n nargs=argparse.OPTIONAL,\n default='-',\n help='JSON-encoded glucose data'\n )", "def __init__(self, file):\n self.file = file\n self.config = self.__analyze_config()" ]

[ "0.62581795", "0.6172191", "0.5904631", "0.5810348", "0.5731689", "0.5710172", "0.5697868", "0.5671793", "0.5557136", "0.55527836", "0.5547069", "0.5531849", "0.5523526", "0.5495392", "0.54795927", "0.5473922", "0.5470717", "0.54607505", "0.54423887", "0.54402304", "0.543897", "0.54364556", "0.54342407", "0.5433634", "0.5424777", "0.53733706", "0.53527766", "0.53518075", "0.53029215", "0.52961695" ]

[ "def check_errors(self) -> None:", "def has_errors(self) -> bool:", "def check_set_errors(self):\n raise NotImplementedError(\"Implement it in a subclass.\")", "def test_raises(self):\n no_replicates = 25\n try:\n replicate(experiment3, no_replicates)\n except RuntimeError as err:\n self.assertEqual(err, FAKE_ERROR)\n else:\n assert False", "def test_error_if_negative_more_than_population(self):\n model = PoincareModel(self.data, negative=5)\n with self.assertRaises(ValueError):\n model.train(epochs=1)", "def check_errors(self):\n raise NotImplementedError(\"Implement it in a subclass.\")", "def hasErrors(self):\n return False", "def test_exception(\n self,\n ):\n with pytest.raises(ValueError, match=\"cannot be larger than number of subsystems\"):\n symplectic.reduced_state(np.array([0, 0]), np.identity(2), [6, 4])", "def test_seed_initial_population():\n # Test if a initial population can be read in from CSV\n i_population = owp.seed_initial_population('initial_populations.csv')\n # Test if a new population can be generated with i_population as the base\n pop_size = 30\n population = sga.generate_population(pop_size, i_population)\n assert type(i_population) is list\n assert len(population) == pop_size", "def check_get_errors(self):\n raise NotImplementedError(\"Implement it in a subclass.\")", "def test_create_population():\n pop = Population()\n assert len(pop.population) == POPULATION_SIZE\n assert isinstance(pop.population[0], Individual)", "def test_value_error(self):\n self._error_test(ValueError)", "def test_errors(self):\n self.assertRaises(TypeError, columnize, 5, 'reject input - not array')\n return", "def test_setup_errors(self):\n with self.assertRaises(ValueError):\n _ = RandomForest(n_estimators=0, max_depth=1, criterion='entropy')\n\n with self.assertRaises(ValueError):\n _ = RandomForest(n_estimators=1, max_depth=0, criterion='entropy')\n\n with self.assertRaises(ValueError):\n _ = RandomForest(n_estimators=1, max_depth=1, criterion='test')", "def test_mothur_error_2(self):\n\n m = Mothur(**self.init_vars)\n self.set_current_dirs(m)\n with self.assertRaises(RuntimeError):\n m.summary.seqs()\n\n return", "def test_no_errors(self):\n raised = False\n try:\n _ = RandomForest(n_estimators=1, max_depth=1, criterion=\"entropy\")\n except Exception as error:\n print(error)\n raised = True\n self.assertFalse(raised)", "def test_case_01(self):\n if True:\n self.fail()", "def test_init_errors(self):\n t = self.Test({})\n self.assertEqual(t.errors, {})", "def test_get_error_data_table_when_no_errors(self):\n field_setup = None\n error_names = ['non-field_name', 'not_a_field']\n prepared_info = self.setup_error_data(field_setup, error_names, True)\n for row in prepared_info:\n self.assertEqual(row['expected'], row['actual'])", "def __check(self):\n if self.probid is None:\n raise ProblemConfigError('problem %s has no probid' % self.problem_name)\n if self.color is None:\n raise ProblemConfigError('problem %s has no color' % self.problem_name)\n if self.samples is None:\n raise ProblemConfigError('problem %s has no sample' % self.problem_name)", "def test_get_error_data_when_no_errors(self):\n field_setup = None\n error_names = ['non-field_name', 'not_a_field']\n prepared_info = self.setup_error_data(field_setup, error_names)\n for row in prepared_info:\n self.assertEqual(row['expected'], row['actual'])", "def error(self):\n pass", "def testRaisesErrorValueMismatch(self):\n c = Simulation(logging_level=logging.CRITICAL)\n c.set_simulation_parameters(\n seed=4,\n task=32,\n output_directory=\"output\",\n min_speciation_rate=0.5,\n sigma=2,\n tau=2,\n deme=1,\n sample_size=0.1,\n max_time=10,\n dispersal_relative_cost=1,\n min_num_species=1,\n )\n c.set_map_files(\n sample_file=\"sample/SA_samplemaskINT.tif\",\n fine_file=\"sample/SA_sample_coarse_zeros.tif\",\n dispersal_map=\"sample/dispersal_fine_cumulative.tif\",\n )\n with self.assertRaises(RuntimeError):\n c.run()", "def test_required(self):\n \n from pystarlab.starlab import Makeplummer\n self.assertRaises(ValueError, Makeplummer)\n self.assertRaises(ValueError, Makeplummer, n=500)\n \n # this will fail if it raises any exceptions\n plummer_nonfailing = Makeplummer(n=500, s=12345)", "def error(self):\n ...", "def test_empty(self):\n self.assertRaisesInternalError(())", "def has_errors_fatal(self) -> bool:", "def experiment3():\n raise FAKE_ERROR", "def test_checks_population_size(self):\n with pm.Model() as model:\n n = pm.Normal(\"n\", mu=0, sigma=1)\n for stepper in TestPopulationSamplers.steppers:\n step = stepper()\n with pytest.raises(ValueError, match=\"requires at least 3 chains\"):\n pm.sample(draws=10, tune=10, chains=1, cores=1, step=step)\n # don't parallelize to make test faster\n pm.sample(\n draws=10,\n tune=10,\n chains=4,\n cores=1,\n step=step,\n compute_convergence_checks=False,\n )", "def test_invalid_input_data(self):\n self.data.diffusion_data = self.data.diffusion_data[0]\n self.assertRaises(ValueError, module_05.run_module,\n self.data)" ]

[ "0.6724634", "0.6614121", "0.6571839", "0.6506624", "0.6498713", "0.6492715", "0.6352794", "0.6229535", "0.6203304", "0.6190145", "0.61648875", "0.6164363", "0.6125414", "0.6124468", "0.6115176", "0.60903215", "0.6060993", "0.6059786", "0.60476184", "0.6033371", "0.6023753", "0.60230595", "0.60119355", "0.59939945", "0.5975166", "0.59582126", "0.5919021", "0.59169436", "0.58970964", "0.5894911" ]

[ "def test_households_in_admin_unit(self):", "def test_createHousehold_single(self):\n h = self.z.createHousehold(\"testHousehold\")\n self.assertTrue(self.z.getHousehold(\"testHousehold\") is not None, \"No household came back from the database.\")\n self.assertTrue(self.z.getHousehold(\"testHousehold\") is h, \"Household comparison failed.\")", "def test_getHousehold_multiple(self):\n h1 = self.z.createHousehold(\"h1\")\n h2 = self.z.createHousehold(\"h2\")\n h3 = self.z.createHousehold(\"h3\")\n\n self.assertTrue(h1 is not h2)\n self.assertTrue(h2 is not h3)\n\n # Theoretically, the below can be replaced with \"is h1\" based on transitive property above, but\n # I want to be explicit.\n self.assertTrue(self.z.getHousehold('h1') is not h2)\n self.assertTrue(self.z.getHousehold('h1') is not h3)\n\n self.assertTrue(self.z.getHousehold('h1') is h1)\n self.assertTrue(self.z.getHousehold('h2') is h2)\n self.assertTrue(self.z.getHousehold('h3') is h3)\n\n self.assertTrue(self.z.getHousehold('bogus') is None)", "def test_createHousehold_multiple(self):\n house1 = self.z.createHousehold('42')\n house2 = self.z.createHousehold('41')\n self.assertTrue(house1 is not None, \"Household returned from createHousehold was None.\")\n self.assertTrue(house2 is not None, \"Household returned from createHousehold was None.\")\n self.assertTrue(house1 is self.z.getHousehold('42'))\n self.assertTrue(house2 is self.z.getHousehold('41'))", "def test_get_household_successful(self):\n res = self.client.get(HOUSEHOLD_URL)\n\n self.assertEqual(res.status_code, status.HTTP_200_OK)\n self.assertEqual(self.user.household.id, res.data[0]['id'])", "def test_full_house_properties(self):\n self.assertEqual(self.hand.flushInd, 0)\n self.assertEqual(self.hand.straightInd, 0)\n self.assertEqual(self.hand.straightHead, 0)\n self.assertEqual(self.hand.postHandType, 4)\n self.assertEqual(self.hand.postHandValue, 171)", "def test_household_get(self):\n url = '/household/'+ self.test_id + '/'\n response = self.tester.get(url,\n content_type='application/json')\n self.assertEqual(response.status_code, 200)", "def test_it_exists():\n dan = Hobbit(\"Dan\")\n assert type(dan) == Hobbit\n assert dan.name == \"Dan\"\n assert dan.disposition == \"adventurous\"\n assert dan.age == 0", "def test_create_household_not_successful(self):\n payload = {\n 'name': 'Test Household 1'\n }\n res = self.client.post(HOUSEHOLD_URL, payload)\n\n self.assertEqual(res.status_code, status.HTTP_401_UNAUTHORIZED)", "def test_check_full_house_false(self):\n not_full_house_fixtures = [[1, 1, 1, 1, 2],\n [2, 1, 1, 1, 1],\n [1, 1, 2, 2, 3],\n [1, 2, 3, 4, 5],\n ]\n\n for fixture in not_full_house_fixtures:\n score = self.roll.check_full_house(fixture)\n\n self.assertNotEqual(score, 25)\n self.assertEqual(score, 0)\n self.assertEqual(len(fixture), 5)", "def test_getHousehold_invalidId(self):\n self.assertTrue(self.z.getHousehold(None) is None, \"An invalid value passed to getHousehold returns None.\")\n self.assertTrue(self.z.getHousehold('') is None, \"An invalid value passed to getHousehold returns None.\")\n self.assertTrue(self.z.getHousehold('invalid') is None, \"An invalid value passed to getHousehold returns None.\")", "def has_fullhouse(self):\n if self.has_pair() & self.has_three_of_a_kind():\n self.rank_per_hand['5'] = \"full house\"\n return True\n return False", "def test_hand_is_full_house(hand, card_list, expected):\n hand.add_cards(card_list)\n assert hand.is_full_house() == expected", "def test_check_full_house_true(self):\n full_house_fixtures = [[1, 1, 2, 2, 2],\n [1, 2, 2, 2, 1],\n [1, 2, 1, 2, 2],\n [1, 2, 2, 1, 2],\n [2, 1, 2, 2, 1],\n [2, 2, 1, 2, 1],\n [2, 2, 2, 1, 1],\n ]\n\n for fixture in full_house_fixtures:\n score = self.roll.check_full_house(fixture)\n\n self.assertEqual(score, 25)\n self.assertEqual(len(fixture), 5)", "def test_areas_locked_ok(self):", "def test_can_have_a_ring():\n ben = Hobbit(\"Ben\")\n danielle = Hobbit(\"Danielle\")\n stacy = Hobbit(\"Stacy\")\n assert ben.has_ring() is False\n assert stacy.has_ring() is False\n assert danielle.has_ring() is True", "def test_should_implement(self):\n pass", "def test_is_occupied(self):\n self.assertFalse(self.test_square.is_occupied())\n\n self.test_square.piece = Piece(ChessColor.BLACK)\n self.assertTrue(self.test_square.is_occupied())", "def test_createHousehold_duplicateHousehold(self):\n self.z.createHousehold('dupe')\n self.z.createHousehold('not a dupe')\n\n with self.assertRaises(zdb.DuplicateRecordException):\n self.z.createHousehold('dupe')", "def test_create_new_household(self):\n user = get_user_model().objects.create_user(\n email='[email protected]',\n password='TestPass1',\n name='Test User 1',\n )\n self.client.force_authenticate(user)\n payload = {\n 'name': 'Test Household 1'\n }\n res = self.client.post(HOUSEHOLD_URL, payload)\n\n self.assertEqual(res.status_code, status.HTTP_201_CREATED)", "def create_all_households(rel_poi_df, subsectie=None):\n # Identify households that are in areas for centralized rest collection\n polygon_list = load_geodata_containers(subsectie=subsectie)\n all_households = rel_poi_df[rel_poi_df['type'] != 'afval_cluster']\n all_households = all_households[['s1_afv_nodes', 'cluster_x', 'cluster_y']]\n all_households['uses_container'] = all_households\\\n .apply(lambda row: address_in_service_area(row['cluster_x'],\n row['cluster_y'],\n polygon_list=polygon_list),\n axis=1)\n\n # Identify households that are in areas where cardboard is collected\n wijken = gpd.read_file('../data/brtk2010_ind2005_region.shp')\n polygons_list = list(wijken.iloc[[49, 185, 307, 311, 328]]['geometry'])\n all_households['collect_cardboard'] = all_households.\\\n apply(lambda row: address_in_service_area(row['cluster_x'],\n row['cluster_y'],\n polygon_list=polygons_list),\n axis=1)\n\n # Identify households that are in Landelijk Noord to exclude\n polygons_list = list(wijken[wijken['BC'] == '73']['geometry'])\n all_households['in_landelijk_noord'] = all_households.\\\n apply(lambda row: address_in_service_area(row['cluster_x'],\n row['cluster_y'],\n polygon_list=polygons_list),\n axis=1)\n\n # Exclude all households in stadsdeel centrum because of inconsistent data\n polygons_list = list(wijken[wijken['SD09'] == 'A']['geometry'])\n all_households['in_centrum'] = all_households.\\\n apply(lambda row: address_in_service_area(row['cluster_x'],\n row['cluster_y'],\n polygon_list=polygons_list),\n axis=1)\n\n # Identify all households that are in specified area\n neighborhood_list = load_shapefile_neighborhood(area=subsectie)\n all_households['in_neigborhood'] = all_households\\\n .apply(lambda row:\n address_in_service_area(row['cluster_x'], row['cluster_y'],\n polygon_list=neighborhood_list),\n axis=1)\n\n return all_households", "def test_post_opening_balance_journals(self):\n pass", "def is_onhold(self) -> bool:", "def add_own_house(self, house): # Filling a list of houses are owned by Person\n self.own_home.append(house)", "def test_balance_tracking(self):\n # TODO\n pass", "def test_01_BuildObjects(self):\n # print(PrettyFormatAny.form(self.m_pyhouse_obj, 'A1-01-A - Main', 190))\n # print(PrettyFormatAny.form(self.m_pyhouse_obj.House, 'A1-02-B - House', 190))\n # print(PrettyFormatAny.form(self.m_pyhouse_obj.House.Location, 'A1-01-C - Location', 190))\n self.assertIsInstance(self.m_pyhouse_obj, PyHouseInformation)\n self.assertIsInstance(self.m_pyhouse_obj.House, HouseInformation)\n self.assertIsInstance(self.m_pyhouse_obj.House.Location, LocationInformationPrivate)", "def test_calculates_risk_points_with_mortgaged_house(self):\n\n self.user[\"houses\"].insert(0, {\n \"id\": 123,\n \"ownership_status\": \"mortgaged\"\n })\n\n self.risk_profile[\"home\"].insert(0, {\n \"id\": 123,\n \"is_eligible\": True,\n \"risk_points\": 1\n })\n\n self.calculates_risk_points_by_houses.execute(self.user, self.risk_profile)\n\n for house in self.risk_profile[\"home\"]:\n if house[\"id\"] == 123:\n self.assertEquals(house[\"risk_points\"], 2)\n else: \n self.assertEquals(house[\"risk_points\"], 1)\n \n self.assertEquals(self.risk_profile[\"disability\"][\"risk_points\"], 2)", "def test_get_household_not_successful(self):\n res = self.client.get(HOUSEHOLD_URL)\n\n self.assertEqual(res.status_code, status.HTTP_401_UNAUTHORIZED)", "def test_address__HomePageAddress__1():\n zope.interface.verify.verifyObject(IHomePageAddress, HomePageAddress())", "def test_create_population():\n pop = Population()\n assert len(pop.population) == POPULATION_SIZE\n assert isinstance(pop.population[0], Individual)" ]

[ "0.6838143", "0.6817663", "0.6814737", "0.655817", "0.6156855", "0.6130907", "0.5943895", "0.5855799", "0.5852164", "0.5847315", "0.5841273", "0.5840119", "0.5839334", "0.5837827", "0.5781486", "0.5735657", "0.5691197", "0.5643968", "0.5629447", "0.5597476", "0.5569006", "0.55431104", "0.5535452", "0.55203515", "0.5515921", "0.54963726", "0.54474956", "0.54451185", "0.5440615", "0.5433354" ]

[ "def test_models_meetings_name_prefix(self):\n room = MeetingFactory(id=\"f629e68e-e256-44fe-8ba6-a7e0849de00b\")\n self.assertEqual(room.jitsi_name, \"123f629e68ee25644fe8ba6a7e0849de00b\")", "def format_jira(jid: str) -> str:\n jid = jid.lower().strip()\n jid = jid.split('_')[0]\n j = \"\".join(jid.split('-'))\n return j", "def name_from_iid(self, iid):\n retVal = iid.replace(\"_IID\", \"\")\n retVal = retVal.replace(\"_\", \" \")\n return retVal", "def jid_jname(jnid):\n jails = jails_list()\n try:\n int(jnid) == True\n testid = 0\n except ValueError:\n testid = 1\n\n if testid == 0:\n if jnid in jails[2]:\n j = jails[2].index(jnid)\n jnid = jails[1][j]\n else:\n print \" Jail with ID '%s' not found!\" % (jnid)\n return False\n\n return jnid", "def _get_job_id(self) -> str:\n return self.split_name[2][3:]", "def get_meeting_room_name(self, obj):\n return obj.meeting_room.name", "def _parse_title(self, meeting_title):\n if \"Committee\" not in meeting_title and \"Special\" not in meeting_title:\n return \"Board of Directors\"\n if \"Meeting\" in meeting_title and \"Special\" not in meeting_title:\n meeting_title = meeting_title.replace(\"Meeting\", \"\").strip()\n return meeting_title", "def name_id(self, fn:str='Jane',ln:str='Dear',sec:int=5):\n code = '[0-9]{4:%s}'% int(sec)\n return f\"{fn[0].capitalize()}{ln[0].capitalize()}{StringGenerator(str(code)).render(unique=True)}\"", "async def nameid(self, fn:str='Jane',ln:str='Dear',sec:int=5):\n code = '[0-9]{4:%s}'% int(sec)\n return f\"{fn[0].capitalize()}{ln[0].capitalize()}{StringGenerator(str(code)).render(unique=True)}\"", "def inlet_name(inlet) -> str:\n name = '_'.join(inlet.info().name().split())\n return name.replace('-', '_')", "def autoname(self):\n self.name = datetime.datetime.strftime(datetime.datetime.now(), \"%y%m%d %H%M%S\") + \"_\" + self.participant_role", "def get_job_title(self, job_name):\n return ''", "async def short_nameid(self, fn:str='Jane',ln:str='Dear',sec:int=2):\n code = '[0-9]{2:%s}'% int(sec)\n return f\"{fn[0].capitalize()}{ln[0].capitalize()}{StringGenerator(str(code)).render(unique=True)}\"", "def get_job_name(self) -> Text:\n return self._job_name", "def full_name(self):\n return \"%s.%s\" % (self._dj._wid, self._job)", "def short_name_id(self, fn:str='Jane',ln:str='Dear',sec:int=2):\n code = '[0-9]{2:%s}'% int(sec)\n return f\"{fn[0].capitalize()}{ln[0].capitalize()}{StringGenerator(str(code)).render(unique=True)}\"", "def get_name() -> str:", "def job_name(self) -> str:\n return pulumi.get(self, \"job_name\")", "def get_name(self):\n\n return \"Sawyer McLane\"", "def getJudgeName(self):\n judgeNotesLogger.info(\"getJudgeName: Retrieving Judge Name from Notes File '%s'\", self.notesFile)\n try:\n judgeParse = re.search(\"^(.*)_Notes\", self.notesFile)\n if judgeParse is not None:\n self.judgeName = str(judgeParse.group(1))\n judgeNotesLogger.debug(\"getJudgeName: Judge is '%s'\", self.judgeName)\n else:\n judgeNotesLogger.warning(\"getJudgeName: Judge Notes File is not in correct format\")\n except:\n judgeNotesLogger.warning(\"getJudgeName: {0}: {1}\".format(sys.exc_info()[0].__name__,\n str(sys.exc_info()[1])))", "def _username_from_name(self, name):\r\n return name.replace(' ', '_')", "def get_notification_name(self):\n return f\"{self.first_name[0].lower()}.{self.last_name.lower()}\"", "def get_name():", "def job_name(parameter):\n return (\n \"job_encut_\"\n + str(parameter[0]).replace(\".\", \"_\")\n + \"_kpoints_\"\n + str(parameter[1][0])\n + \"_\"\n + str(parameter[1][1])\n + \"_\"\n + str(parameter[1][2])\n )", "def getShortname(input_id):\n \n name = formatDesignation(input_id)\n \n return name[0:6] + name[10:15]", "def satname(rocketsatname):\n \n # split the rocket and satellite name at the bullet\n names = rocketsatname.split('•')\n \n # remove spaces around satellite name\n namefull = names[1].strip()\n \n # return the satellite's name\n return namefull", "def _entity_skill_id(skill_id):\n skill_id = skill_id[:-1]\n skill_id = skill_id.replace('.', '_')\n skill_id = skill_id.replace('-', '_')\n return skill_id", "def default_name(self):\n name = f\"Player {self.UID.split('-')[0]}\"\n return name", "def format_name(self):\n\t\tself.full_name = self.first + \" \" + self.last", "def get_name() -> str:\n pass" ]

[ "0.6866796", "0.6679597", "0.62532425", "0.61189544", "0.60640043", "0.5963949", "0.58309263", "0.5824851", "0.58022356", "0.5795273", "0.5780392", "0.5699202", "0.56982464", "0.5674717", "0.56611484", "0.56552875", "0.5650024", "0.5633229", "0.55841947", "0.55732095", "0.55619967", "0.55358964", "0.5522179", "0.5473832", "0.54346824", "0.54180676", "0.53987426", "0.5397351", "0.53969884", "0.5377791" ]

[ "def freqnorm(freq):\n t = 0.0\n for i in freq:\n t += freq[i]\n for i in freq:\n freq[i] /= t\n return freq", "def _normalize_counts(counts, val=1):\n n = sum(counts.values())\n frequencies = {}\n for r in list(counts.keys()):\n frequencies[r] = val * float(counts[r]) / float(n)\n return frequencies", "def normalize(self, reverse=False):\n if self.powerspectrum==None:\n self.average_ps()\n for sub in range(self.Nsubs):\n if not(reverse):\n self.powerspectra[sub]=self.powerspectra[sub]/self.powerspectrum\n self.normalized=True\n else:\n self.powerspectra[sub]=self.powerspectra[sub]*self.powerspectrum\n self.normalized=False", "def normalize(w):\n s = sum(w)\n for i in range(len(w)):\n w[i] /= s\n return w", "def normalize(counts):\n numvals = sum(counts.itervalues())\n if numvals <= 0:\n return counts\n res = dict()\n for (k,cnt) in counts.iteritems():\n res[k] = float(cnt)/float(numvals)\n return res", "def Normalise(SNR,sig1,freq_bin,delta_t,PSD):\n Normalise_Factor = InnerProduct(sig1,sig1,freq_bin,delta_t,PSD)\n return (SNR / np.sqrt(Normalise_Factor)) * sig1", "def normalize(counts):\n counts_sum0 = np.sum(counts, axis=0, keepdims=True)\n counts_sum1 = np.sum(counts, axis=1, keepdims=True)\n counts_sum = np.sum(counts)\n\n # Get residuals\n theta = 100\n mu = counts_sum1 @ counts_sum0 / counts_sum\n z = (counts - mu) / np.sqrt(mu + mu ** 2 / theta)\n\n # Clip to sqrt(n)\n n = counts.shape[0]\n z[z > np.sqrt(n)] = np.sqrt(n)\n z[z < -np.sqrt(n)] = -np.sqrt(n)\n\n return z", "def get_freqs(self):\r\n return self.df_fix(self.freqs.copy(), 'freqs')", "def _normalize(self, inp):\n \n return inp/inp.sum()", "def normalize(self):\n for key in self.corpus.keys():\n sum_count = 0\n words = []\n counts = []\n for k, v in self.corpus[key].items():\n sum_count += v\n words.append(k)\n counts.append(v)\n prob = [float(count)/sum_count for count in counts]\n\n self.corpus[key] = [words, prob]", "def freqs(self, xs):\n return [self.freq(x) for x in xs]", "def analyze2(ys, freqs, ts):", "def normalize_and_clip(meas):\n frequency_weights = np.zeros(len(meas))\n\n for i in range(len(meas)):\n if(meas[i] > NORMALIZE_SENS[i]):\n meas[i] = NORMALIZE_SENS[i]\n frequency_weights[i] = meas[i] / NORMALIZE_SENS[i]\n\n return frequency_weights", "def normalize(self):\n norm_val = self.sum2/self.sum1\n self.sum1=0\n\n for sentence in self.data_set:\n sentence.weight *= norm_val\n self.sum1 += sentence.weight", "def _uniform_freqs(Nd, xp=np):\n if xp.isscalar(Nd):\n Nd = (Nd,)\n ndim = len(Nd)\n fs = [2 * np.pi * xp.arange(Nd[d]) / Nd[d] for d in range(ndim)]\n fs = xp.meshgrid(*fs, indexing=\"ij\")\n fs = [f.reshape((-1, 1), order=\"F\") for f in fs]\n return xp.hstack(fs)", "def __normalize_after_fft(arr):\n\n n1, n2 = arr.shape[0], arr.shape[1]\n for i in range(n1):\n for j in range(n2):\n arr[i, j] *= n1 * n2\n\n return arr", "def normalize(self):\n total = self.total()\n for x in self.d:\n self.d[x] /= total\n return total", "def normalise(self):\n s = self._sum()\n if s != 0:\n for element, value in self.focals.items():\n self.focals[element] /= s", "def normalise(self):\n total = 0\n for feat_set in self.values():\n for value in feat_set.values():\n total += value\n norm = 1/total\n for feat_set in self.values():\n for feat in feat_set:\n feat_set[feat] *= norm\n return self", "def normalize(arr):\n\n total = sum(arr)\n\n return list(map(lambda x: x / total, arr))", "def normalize(self, factor):", "def get_comparative_word_freq(freqs):\n\n total_freq = sum(freqs.values())\n comp_freqs = {}\n\n for k, v in freqs.items():\n try:\n freq = v / total_freq\n except ZeroDivisionError:\n freq = 0\n comp_freqs[k] = freq\n\n return comp_freqs", "def centre_freqs(self, low_freq=DEFAULT_LOW_FREQ, high_freq=DEFAULT_HIGH_FREQ, num=DEFAULT_FILTER_NUM):\n\t\treturn self.erb_point(low_freq, high_freq, (np.arange(1.0, num+1.0)/num)[::-1])", "def update_frequencies():\n pass", "def setfreqs(self, freqs):\n self.fm_freq, self.hfm_freq, self.sv_freq = freqs[0], freqs[1], freqs[2]", "def normalization(distribution):\r\n total_sum = 0\r\n for number in distribution.values():\r\n total_sum += number\r\n \r\n for bin in distribution.keys():\r\n distribution[bin] = float(distribution[bin]) / total_sum\r\n\r\n return distribution", "def normalize(sequence):\n return [_norm(s) for s in sequence]", "def normalize(self):\n total = float(sum(self.values()))\n for key in self:\n self[key] /= total", "def relative_freqs(allcounts):\n #print(allcounts.head())\n lengths = np.sum(allcounts, axis=\"index\")\n #print(lengths)\n relfreqs = allcounts.div(lengths, axis=\"columns\").mul(100)\n #print(relfreqs.head())\n save_dataframe(relfreqs, \"1-relfreqs.csv\")\n return relfreqs", "def normalize(self):\n total = float(sum(self.values()))\n for key in self:\n self[key] /= total" ]

[ "0.7933617", "0.66565824", "0.65418106", "0.6425697", "0.6359233", "0.633326", "0.6305108", "0.6268649", "0.6249235", "0.6235215", "0.62128705", "0.6194164", "0.6144104", "0.61389965", "0.6133477", "0.6125413", "0.61036325", "0.60963297", "0.6072995", "0.6057717", "0.60538304", "0.5998401", "0.5995912", "0.5995666", "0.5975435", "0.597234", "0.59445024", "0.5897651", "0.58945286", "0.5860187" ]

[ "def get_article_indices(self, article_id):\n start, end, _ = self.article_features[article_id]\n return list(range(start, end + 1))", "def top_sentences(query, sentences, idf, n):\n ll=[]\n for s in sentences:\n st=sentences[s]\n st=[word.lower() for word in st]\n found_word=0\n total_idf=0\n\n for word in query:\n if word in st:\n total_idf+=idf[word]\n found_word+=1 \n ll.append((total_idf,found_word/len(st),s))\n ll.sort(reverse=True)\n #print(ll)\n ans=[]\n for i in range(n):\n ans.append(ll[i][2])\n #print(\"answer is : \",*ans)\n return ans", "def articles_id_headwords (_id):\n\n offset = int (arg ('offset', '0', re_integer_arg))\n limit = clip (arg ('limit', str (MAX_RESULTS), re_integer_arg), 1, MAX_RESULTS)\n\n with current_app.config.dba.engine.begin () as conn:\n res = execute (conn, r\"\"\"\n SELECT id, webkeyword, no\n FROM keyword\n WHERE no = :id\n ORDER BY sortkeyword\n LIMIT :limit\n OFFSET :offset\n \"\"\", { 'id' : _id, 'offset' : offset, 'limit' : limit })\n\n return make_headwords_response (res, limit)", "def get_relevant_articles_tf_idf(self, title, k):\n\n\n inner_product=0\n distances=list()\n for article in self.tf_idf:\n if not article==title:\n angle=self.angle_finder(self.tf_idf[title], self.tf_idf[article])\n distances.append((article, math.acos(angle)))\n distances=sorted(distances, key=lambda tup: tup[1])\n print (distances[:k])\n return distances[:k]", "def text_rank(sentence_vector_list, number_topics, sentences):\n\n nx_graph = nx.from_numpy_array(cosine_similarity(sentence_vector_list, sentence_vector_list))\n scores = nx.pagerank(nx_graph)\n\n summary = sorted(((scores[i], i, s) for i, s in enumerate(sentences)), reverse=True)[0:number_topics]\n\n return list(s for score, i, s in summary)", "def most_similar(self, article: str, topn: int = 5):\n return [article[0] for article in self._model.similar_by_word(article, topn)]", "def topArticles():\n c = db.cursor()\n c.execute(\"select titles.title, tophits.hits\\\n from tophits, titles\\\n where tophits.path = titles.slug\\\n order by hits desc limit 3;\")\n results = c.fetchall()\n c.close()\n return results", "def idx_sentence(sentence, word2id_dict):\r\n x = []\r\n words = sentence.split()\r\n for word in words:\r\n x.append(word2id_dict[word]) # 假设word就在word2idx_dict中.\r\n return x", "def get_closest_sentence(self, query_emb_init, paper_id, text, topk=10):\n csv_filepath = os.path.join(\"selected\", paper_id + '.csv')\n df_article = pd.read_csv(csv_filepath, index_col=0)\n \n normalize = lambda x: x/np.linalg.norm(x, axis = 1, keepdims = True)\n query_emb = normalize(query_emb_init)\n val_norm = normalize(df_article.values)\n score_arr = safe_sparse_dot(val_norm, query_emb.T)\n\n # sort in decreasing order\n similar_paragr = sorted(zip(range(len(score_arr)), score_arr), \n key = lambda x: x[1], reverse=True)[:min(topk, len(score_arr))] \n\n # obtain the text of this closest paragraphs\n field_text = text.split(\"\\n\")\n similar_paragr = [(field_text[idx], score) for (idx, score) in similar_paragr]\n\n return similar_paragr", "def article2ids(article_words, vocab):\n\tids = []\n\toovs = []\n\tunk_id = vocab.word2id(UNKNOWN_TOKEN)\n\tfor w in article_words:\n\t\ti = vocab.word2id(w)\n\t\tif i == unk_id: # If w is OOV\n\t\t\tif w not in oovs: # Add to list of OOVs\n\t\t\t\toovs.append(w)\n\t\t\toov_num = oovs.index(w) # This is 0 for the first article OOV, 1 for the second article OOV...\n\t\t\tids.append(vocab.size() + oov_num) # This is e.g. 50000 for the first article OOV, 50001 for the second...\n\t\telse:\n\t\t\tids.append(i)\n\treturn ids, oovs", "def predict(self, text, top_num=5):\n text = Suggest_Util.clean_data(text)\n encoded = Suggest_Util.text_to_id(text, self.word_to_id)\n encoded_padded = tf.keras.preprocessing.sequence.pad_sequences([encoded], maxlen=self.input_length, padding='pre')\n\n prediction = self.model.predict(encoded_padded)\n prediction = tf.squeeze(prediction, 0)\n predict_words = np.argsort(prediction[self.input_length-1, :])[::-1][:top_num]\n \n return [self.id_to_word[str(word)] for word in predict_words]", "def keywords(articles, top_n=25):\n\n # compute term idfs\n token_docs = [lemma_tokenize(clean(a.text)) for a in articles]\n local_term_idf = IDF(token_docs)\n\n token_docs, phrases = extract_phrases(token_docs, [a.text for a in articles], global_term_idf)\n\n titles = [a.title for a in articles]\n title_tokens = [lemma_tokenize(clean(t)) for t in titles]\n term_counts = defaultdict(int)\n for doc in token_docs:\n for t in set(doc):\n if t:\n term_counts[t] += 1\n\n title_terms = set()\n for title_tks in title_tokens:\n title_terms = title_terms | set(title_tks)\n for ph in phrases:\n if any(ph in title.lower() for title in titles):\n title_terms.add(ph)\n\n # Score terms\n term_scores = []\n for t, count in term_counts.items():\n # Ignore numbers, they are very specific to a particular event and\n # introduce noise\n try:\n float(t)\n continue\n except ValueError:\n # TODO This is a troublesome token, not sure why it's not filtered out by\n # IDF. needs more investigation\n if t == 'n\\'t':\n continue\n score = count * (global_term_idf[t] - local_term_idf[t])\n if t in title_terms:\n score *= 1.5\n term_scores.append((t, score))\n\n return sorted(term_scores, key=lambda t: t[1], reverse=True)[:top_n]", "def get_article_keyword_idx(article,\n keywords,\n preprocess_type=PreprocessWordType.LEMMATIZE):\n matches = set()\n for idx, word in enumerate(article.words):\n preprocessed_word = query_utils.preprocess_word(word, preprocess_type)\n if preprocessed_word in keywords:\n match = (preprocessed_word, idx)\n matches.add(match)\n return sorted(list(matches))", "def local_h( author, data ) :\n papers = papers_and_cites( author, data )\n papers.sort( lambda a,b : cmp(int(b[1]), int(a[1])) )\n i = 0\n while i < (len(papers)-1) and i < int(papers[i][1] ) :\n i = i + 1\n\n return (i+1, int(papers[i][1]) )", "def getRanking(videoId):\n\n if videoId in moviesRanked:\n print moviesRanked.index('videoId') + 1\n else:\n print 'Movie not found'", "def tldr_matrix(article, lang):\r\n article = re.sub(r\"[^\\w\\s\\.]\", \" \", article).lower()\r\n sentences = sent_tokenize(article, language=lang)\r\n stemmed_sentences = [sentence_stem(sentence, lang) for sentence in sentences]\r\n\r\n bagofwords_matrix = CountVectorizer().fit_transform(stemmed_sentences)\r\n # normalize with TF-IDF\r\n bagofwords_matrix = TfidfTransformer().fit_transform(bagofwords_matrix)\r\n\r\n # mirror the matrix onto itself to get the similarity edges between sentences\r\n similarity_matrix = bagofwords_matrix * bagofwords_matrix.T\r\n similarity_graph = nx.from_scipy_sparse_matrix(similarity_matrix)\r\n\r\n scores = nx.nx.pagerank_scipy(similarity_graph)\r\n scored_sentences = [(i, s, scores[i]) for i, s in enumerate(sentences)]\r\n\r\n return sorted(scored_sentences, key=lambda x: x[2])", "def top_sentences(query, sentences, idfs, n):\n tf_idfs = []\n for sentence, words in sentences.items():\n tf_idf = 0\n\n for word in query:\n if word not in idfs:\n continue\n idf = idfs[word]\n tf = (1 if word in words else 0)\n tf_idf += idf * tf\n t = (sentence, tf_idf)\n tf_idfs.append(t)\n\n sorted_list = sorted(tf_idfs, key=sorter)\n sorted_list.reverse()\n file_list = [item[0] for item in sorted_list]\n\n return file_list[:n]", "def _determine_index(self, id):\n\n return bisect.bisect_left(self._max_node_ids, id)", "def get_idx_from_sent(sent, word_idx_map, k=300):\n x = []\n words = list(jieba.cut(sent, cut_all=False)) \n\n \n for word in words:\n \n if word in word_idx_map:\n x.append(word_idx_map[word])\n return x", "def rank(self, urlids, wordids):\r\n\t\tself.score()\r\n\t\treturn sorted(self.scores.items(), key=lambda v:v[1], reverse=self.rev)", "def _candidate_ranking(self, big_final_dict):\n self.logger.info(\"Disambiguated Entity Link\")\n big_list = []\n\n for dict in big_final_dict:\n for dict_value in dict.values():\n temp = []\n for i in dict_value:\n x = (i.split(\"http://dbpedia.org/resource/\"))\n y = list(filter(None, x))\n yy = (y[0].split('_'))\n strg = ''\n for x in yy:\n strg = strg + x + ' '\n strg = strg[:-1]\n temp.append(strg)\n big_list.append(temp)\n\n big_arr2 = []\n for small_list in big_list:\n arr2 = []\n for i in small_list:\n arr2.append(re.sub(r'[^\\w\\s]', '', (i)))\n\n big_arr2.append(arr2)\n\n input_text_cleaned = re.sub(r'[^\\w\\s]', '', self.text)\n arr1 = input_text_cleaned.split() # remove stop words\n arr1 = [w for w in arr1 if w.lower() not in self.english_stopwords]\n\n self.ranked_entities = []\n for arr2 in big_arr2:\n a = numpy.zeros(shape=(len(arr2), len(arr1)))\n for i in range(len(arr1)):\n for j in range(len(arr2)):\n if arr1[i] in arr2[j]:\n a[j][i] = 1\n else:\n a[j][i] = 0\n\n rows = len(a)\n cols = len(a[0])\n highest = []\n\n for x in range(0, rows):\n rowtotal = 0\n for y in range(0, cols):\n rowtotal = rowtotal + int(a[x][y])\n highest.append(rowtotal)\n\n highest_value = highest.index(max(highest))\n ranked_entity = arr2[highest_value]\n self.logger.info(\n 'Ambiguous word:' + ranked_entity + ' ' + 'Disambiguation link' + ' ' + 'https://en.wikipedia.org/wiki/' + (\n ranked_entity).replace(' ', '_'))\n self.ranked_entities.append(\n [ranked_entity, 'https://en.wikipedia.org/wiki/' + (ranked_entity).replace(' ', '_')])\n return self.ranked_entities", "def __getHints(self, p):\n st = bisect.bisect_left(self.index, (p[:self.ln], -1)) # binary search\n en = bisect.bisect_right(self.index, (p[:self.ln], sys.maxsize)) # binary search\n hits = self.index[st:en] # this range of elements corresponds to the hits\n return [h[1] for h in hits] # return just the offsets", "def top_sentences(query, sentences, idfs, n):\n rank = []\n\n for sentence in sentences:\n sentence_values = [sentence, 0, 0]\n\n for word in query:\n if word in sentences[sentence]:\n # Compute matching word measure. Sum of IDF values.\n sentence_values[1] += idfs[word]\n # Compute query term density. Proportion of words in a sentence that are in the query.\n sentence_values[2] += sentences[sentence].count(\n word) / len(sentences[sentence])\n\n rank.append(sentence_values)\n\n rank = sorted(rank, key=lambda x: (x[1], x[2]), reverse=True)[:n]\n \n return [sentence for sentence, mwm, qtd in rank]", "def pars2idx(pars, vocabulary, verbose = True):\n pars_idx = []\n npars = len(pars)\n\n for i in range(npars):\n p_idx = []\n \n for w in pars[i].split():\n w_idx = vocabulary.index(str(w))\n if type(w_idx) == int:\n p_idx.append(w_idx)\n \n if verbose:\n sys.stdout.write(\"Converting paragraph %d of %d \\r\" %(i, npars))\n sys.stdout.flush() \n \n pars_idx.append(p_idx)\n\n return pars_idx", "def get_order_from_tree(ids, tree_text):\r\n tree = parse_newick(tree_text, PhyloNode)\r\n ordered_ids = []\r\n for tip in tree.iterTips():\r\n if tip.Name in ids:\r\n ordered_ids.append(tip.Name)\r\n return names_to_indices(ids, ordered_ids)", "def top_sentences(query, sentences, idfs, n):\n\n # claculate idfs of each sentence\n sent_score = dict()\n for sentence in sentences:\n sent_score[sentence] = 0\n for query_word in query:\n if query_word in sentences[sentence]:\n sent_score[sentence] += idfs[query_word]\n\n # create sorted list of sentences\n sorted_sentences = sorted(sent_score, key= lambda item: sent_score[item], reverse= True)\n\n # re-order sentences with the same rank of idfs according to query term density\n loop_sentences = sorted_sentences.copy()\n for sentence1 in loop_sentences:\n for sentence2 in loop_sentences:\n if sentence1 != sentence2:\n if sent_score[sentence1] == sent_score[sentence2]:\n qtd1 = query_term_density(sentence1, query, sentences)\n qtd2 = query_term_density(sentence2, query, sentences)\n index1 = sorted_sentences.index(sentence1)\n index2 = sorted_sentences.index(sentence2)\n if qtd1 > qtd2:\n if index1 > index2:\n sorted_sentences[index2], sorted_sentences[index1] = sorted_sentences[index1], sorted_sentences[index2]\n elif qtd1 < qtd2:\n if index1 < index2:\n sorted_sentences[index2], sorted_sentences[index1] = sorted_sentences[index1], sorted_sentences[index2]\n\n # get list contains top n sentences\n top_sentences = []\n for index in range(n):\n top_sentences.append(sorted_sentences[index]) \n\n return top_sentences", "def __ranking_function(self, doc, query_tokens):", "def articles ():\n\n offset = int (arg ('offset', '0', re_integer_arg))\n limit = clip (arg ('limit', str (MAX_RESULTS), re_integer_arg), 1, MAX_RESULTS)\n\n with current_app.config.dba.engine.begin () as conn:\n res = execute (conn, r\"\"\"\n SELECT no\n FROM article\n ORDER BY no\n LIMIT :limit\n OFFSET :offset\n \"\"\", { 'offset' : offset, 'limit' : limit })\n\n return make_articles_response (res, limit)", "def top_indices(preds, num):\n sort_preds = np.sort(preds, 1)\n sort_preds = np.flip(sort_preds)\n sort_index = np.argsort(preds, 1)\n sort_index = np.flip(sort_index)\n\n print(f\"Top {num} results:\")\n for i in range(num):\n print(sort_index[0][i], sort_preds[0][i])\n\n return 0", "def build_inverted_index(msgs):\n # YOUR CODE HERE\n inverted_idx = dict()\n\n temp = dict()\n\n # msgs here is the item dict \n for item in msgs:\n temp[item['id']] = item\n\n for i in range(1,9046):\n if i in temp:\n item = temp[i]\n toks = tokenize(item['name']) + tokenize(item['better'])\n counts = Counter(toks)\n for word, value in counts.items():\n if word in inverted_idx.keys():\n inverted_idx[word].append((item['id'],value))\n else:\n inverted_idx[word] = [(item['id'], value)]\n\n return inverted_idx" ]

[ "0.64989346", "0.5971395", "0.57531977", "0.5531953", "0.544047", "0.53984046", "0.53607553", "0.53604835", "0.5280121", "0.52442205", "0.51826274", "0.51738113", "0.51463974", "0.5126516", "0.5115128", "0.5109", "0.51089376", "0.51077867", "0.5099182", "0.5094853", "0.508908", "0.5085396", "0.50766325", "0.5074809", "0.5072901", "0.50704664", "0.5065066", "0.5033931", "0.50326455", "0.500613" ]

[ "def brief(self):\n result = \"({0.mode}) {0.name}\".format(self)\n if self.content_hash_before is None:\n result += \" (new)\"\n return result", "def help(cls):\n return textwrap.dedent(cls.__doc__).strip()", "def _create_readme(self, name, summary, description):\n return \"\"\"\n %(header_bar)s\n %(header)s\n %(header_bar)s\n\n %(content)s\n \"\"\" % {\n 'header': name,\n 'header_bar': '=' * len(name),\n 'content': '\\n\\n'.join(\n content\n for content in (summary, description)\n if content\n ) or 'Describe your extension.',\n }", "def print_hint(self):\n print(self.__doc__)", "def insert_methods_markers(soup):\r\n # look for all memitem divs\r\n divs = soup.find_all(\"div\", \"memitem\")\r\n for div in divs:\r\n\r\n # look for method name and signature \r\n memdoc = div.find(\"div\", \"memdoc\")\r\n memname_td = div.find(\"td\",\"memname\")\r\n memname_table = div.find(\"table\", \"memname\")\r\n if not memdoc or not memname_td or not memname_table:\r\n continue\r\n\r\n # extract method name\r\n fullmethodname = memname_td.get_text().strip()\r\n methodname = fullmethodname.split(\"::\")[-1]\r\n\r\n # extract method signature\r\n signature = memname_table.get_text().replace(\"\\n\", \"\")\r\n compactsignature = signature.replace(\" \",\"\")\r\n \r\n # insert Qt Creator markers around the memdoc div\r\n memdoc.insert_before(method_start(methodname, compactsignature))\r\n memdoc.insert_after(method_end(methodname))\r\n\r\n # create a hidden div and insert method signature\r\n hiddendiv = soup.new_tag(\"div\", style=\"display: none\")\r\n hiddendiv.string = signature\r\n memdoc.insert(0, hiddendiv)", "def prefix(self):\n if len(self.desc) > 0:\n return self.desc + \" \"\n\n return \"\"", "def main_docstring():", "def describe(self):\r\n print( self.name + \" is here!\" )\r\n print( self.description )", "def drawDescription(self):\n print(\"\\nPress the following keys to run the features of the GoPiGo3.\")\n print(\"To move the motors, make sure you have a fresh set of batteries powering the GoPiGo3.\\n\")", "def helptext(self):\n return \"\"\"\n <b>A</b> to start the aperture or set the value<br/>\n <b>S</b> to select an existing aperture<br/>\n <b>C</b> to clear the selection<br/>\n <b>F</b> to find a peak close to the cursor<br/>\n <b>[</b> to edit the left edge of selected or closest<br/>\n <b>]</b> to edit the right edge of selected or closest<br/>\n <b>L</b> to edit the location of selected or closest<br/>\n <b>D</b> to delete the selected or closest aperture\n \"\"\"", "def description():", "def __str__(self):\n return self.__class__.__name__ + '\\n' + self.__class__.__doc__", "def help_insert(self):\n print(INSERT)", "def help(self):\n self._log.info('### Help for the class %s ###',\n self.__class__)\n self._log.info(self.__doc__)\n self._log.info('### End of the help for the class %s ###',\n self.__class__)", "def banner():\n print \"\"\" \n _____ __ \n |_ _|_ _ ___ / _| __ _ \n | |/ _` / __| |_ / _` |\n | | (_| \\__ \\ _| (_| |\n |_|\\__,_|___/_| \\__,_|\n \n \"\"\"\n print \"Welcome to use am-auto-start!\"\n print \"For more infomation --> www.tasfa.cn!!\"\n print \"<--------------------------------------------------->\"", "def get_description(self):\n return re.sub('\\n\\W+',' ', self.__doc__)", "def help_description():\n pass", "def get_class_description(lines: List[str], start_index: int) -> str:\n\n began_desc = False\n class_desc = \"\"\n for i in range(start_index, len(lines)):\n if '\"\"\"' in lines[i]:\n # Found the terminating triple quote.\n if began_desc:\n break\n # Found the beginning triple quote.\n else:\n began_desc = True\n continue\n elif began_desc:\n if \"```\" in lines[i]:\n lines[i] = lines[i].strip()\n else:\n lines[i] = lines[i][4:]\n class_desc += lines[i] + \"\\n\"\n # Remove trailing new lines.\n while class_desc[-1] == \"\\n\":\n class_desc = class_desc[:-1]\n return class_desc", "def get_main_help(self):\r\n return __doc__.strip()", "def show_man_page(self):\n print(Gstr_synopsis)", "def description(self):", "def _show(self, indent = 0):\n print(\" \"*indent, \"Name:\", self.name)\n print(\" \"*indent, \"Description:\", self.description)", "def brief(self):\n return self.name", "def insert_tables_docstring(cur, conn):", "def show_help(self):\n\n message = QMessageBox()\n message.setWindowTitle(\"Help\")\n message.setMinimumHeight(1000)\n message.setMinimumWidth(1000)\n\n message.setText(\"1) How to annotate?\\n\"\n \"Move the mouse up and down inside the doted rectangle.\\n\\n\\n\"\n\n \"2) Why is 'wide mode' inactivated?\\n\"\n \"Wide mode and record mode are not allowed to work together.\\n\"\n \"Make sure to exit record mode to access wide mode. \\n\\n\\n\"\n\n \"3) Mouse shortcuts (outside the diagram widget):\\n\\n\"\n \"\\t Right click\\tPlay/pause\\n\"\n \"\\t Scroll\\t\\tFast forward/ backward\\n\"\n \"\\t Dubble click\\tSave\\n\"\n \"\\t Wheel click\\tToggle record mode\\n\\n\\n\"\n\n \"4) Keyboard shortcuts:\\n\\n\"\n \"\\t CTRL+S\\t\\tSave\\n\"\n \"\\t CTRL+O\\t\\tOpen video\\n\"\n \"\\t CTRL+I\\t\\tOpen annotation\\n\"\n \"\\t CTRL+N\\t\\tNew file\\n\"\n \"\\t CTRL+C\\t\\tClear annotation\\n\"\n \"\\t CTRL+Q\\t\\tQuit\\n\"\n \"\\t CTRL+H\\t\\tHelp\\n\\n\"\n \"\\t S\\t\\tPlay/ stop\\n\"\n \"\\t Z\\t\\tFast bakward 50 ms\\n\"\n \"\\t C\\t\\tFast forward 50 ms\\n\"\n \"\\t A\\t\\tFast bakward 200 ms\\n\"\n \"\\t D\\t\\tFast forward 200 ms\\n\"\n \"\\t Q\\t\\tFast bakward 5 s\\n\"\n \"\\t E\\t\\tFast forward 5 s\\n\"\n \"\\t R\\t\\tToggle record mode\\n\\n\"\n \"\\t 1\\t\\tPlayback rate: 0.5\\n\"\n \"\\t 2\\t\\tPlayback rate: 0.75\\n\"\n \"\\t 3\\t\\tPlayback rate: 1\\n\"\n \"\\t 4\\t\\tPlayback rate: 1.25\\n\"\n \"\\t 5\\t\\tPlayback rate: 1.5\\n\"\n \"\\t 6\\t\\tPlayback rate: 1.75\\n\")\n\n x = message.exec_() # this will show our messagebox", "def standard(self) -> global___Snippet.Standard:", "def show_man_page(self):\n \n print(Gstr_synopsis)", "def descr_prototype(self, buf):\n state = \"define\" if self.blocks else \"declare\"\n ret = self.return_value\n args = \", \".join(str(a) for a in self.args)\n name = self.get_reference()\n attrs = ' ' + ' '.join(self.attributes._to_list(\n self.ftype.return_type)) if self.attributes else ''\n if any(self.args):\n vararg = ', ...' if self.ftype.var_arg else ''\n else:\n vararg = '...' if self.ftype.var_arg else ''\n linkage = self.linkage\n cconv = self.calling_convention\n prefix = \" \".join(str(x) for x in [state, linkage, cconv, ret] if x)\n metadata = self._stringify_metadata()\n metadata = ' {}'.format(metadata) if metadata else ''\n section = ' section \"{}\"'.format(self.section) if self.section else ''\n pt_str = \"{prefix} {name}({args}{vararg}){attrs}{section}{metadata}\\n\"\n prototype = pt_str.format(prefix=prefix, name=name, args=args,\n vararg=vararg, attrs=attrs, section=section,\n metadata=metadata)\n buf.append(prototype)", "def help(self, dummy):\r\n help = self.doc + \"\\n\"\r\n if help.find(\"%s\") > 0:\r\n help = help.replace(\"%s\", self.progname)\r\n print_function(help, end='', file=self.stdout)\r\n self.exit(0)", "def test(self):\n self.note(\"Test Note\", \"\"\" This is a note.\nsecond line\"\"\", \"date\")" ]

[ "0.62908995", "0.58696854", "0.5801665", "0.577401", "0.5764486", "0.57053465", "0.57039404", "0.56879723", "0.5668434", "0.5647913", "0.56420195", "0.5619122", "0.5604377", "0.55983883", "0.55982256", "0.5554882", "0.5552204", "0.55472237", "0.55414754", "0.55331683", "0.550288", "0.54875576", "0.5443099", "0.54282534", "0.54212826", "0.5417178", "0.54152524", "0.5414517", "0.53965265", "0.5391131" ]