Datasets:

---

gangiswag

/

python_ablation

like 0

[ "def height(self):\n return self.i_node.distance(self.n_node)", "def _height1(self): #works but n^2 time\n return max(self.depth(p) for p in self.positions() if self.is_leaf(p))", "def height(self):\n return self.upper_right.y - self.lower_left.y", "def _height1(self): # works, but O(n^2) worst-case time\n return max(self.depth(p) for p in self.positions() if self.is_leaf(p))", "def height(self):\n return self.y.max() - self.y.min()", "def _height(self, node):\n if node.value is not None and not node.nodes:\n return node.height\n elif node.value is not None and node.nodes:\n return max(flatten([node.height, ] +\n map(self._height, node.nodes.values())))\n elif node.value is None and node.nodes:\n return max(flatten(map(self._height, node.nodes.values())))\n else:\n raise Exception('should never have gotten here')", "def get_height(self):\n def _get_height(node, height=None):\n if not height:\n height = self._get_level(node) + 1\n if node.left:\n height = _get_height(node.left, height+1)\n if node.right:\n height = max(height, _get_height(node.right, height+1))\n if not node.left and not node.right:\n height = self._get_level(node)\n return height\n return _get_height(self.root)", "def _height1(self): # works, but O(n^2) worst-case time\n return max(self.depth(p) for p in self.positions() if self.is_leaf(p))", "def height(self, p=None):\n if p is None:\n p = self.root()\n return self._height2(p) # start _height2 recursion", "def height(self):\n yy = self.yy\n return max(yy) - min(yy)", "def height(self, p=None):\n\n if p is None:\n p = self.root()\n return self._height2(p) # start height2 recursion", "def height(self, p=None):\n if p is None:\n p = self.root()\n return self._height2(p) # start _height2 recursion", "def height(self, p = None):\n if p is None:\n p = self.root()\n return self._height2(p) # start _height2 recursion", "def height(node):\n\n if node is None:\n return 0\n\n left_height = height(node.left)\n right_height = height(node.right)\n\n return max(left_height, right_height) + 1", "def height(t):\n if t.is_empty:\n return 0\n else:\n left = height(t.left)\n right = height(t.right)\n \n return 1 + max([left, right])", "def height(self):\n return abs(self.end[1] - self.start[1])", "def height(self):\n return self.maxy - self.miny", "def height(node): \n if node is None:\n return -1\n \n # select the top two heights:\n max_height_1, max_height_2 = -1, -1\n for child in node.children:\n h = height(child) + 1\n if h > max_height_1:\n max_height_1, max_height_2 = h, max_height_1\n elif h > max_height_2:\n max_height_2 = h\n \n self.diameter = max(self.diameter, max_height_1 + max_height_2 + 2)\n \n return max_height_1", "def node_y_dimensionality(self) -> int:\n return int(self.graph_tuple_stats.node_y_dimensionality or 0)", "def _height1(self, p):\n return max(self.depth(p) for p in self.positions() if self.is_leaf(p))", "def get_height_tree(self):\n layers = self.breadth_first_traversal()\n \n if all(node is None for node in layers[-1]):\n del layers[-1]\n \n height = len(layers) - 1\n return height", "def height(self):\n if self.is_empty():\n return 0\n elif self.is_leaf():\n return 0\n else:\n if self.has_left():\n if self.has_right():\n return 1+max(self.get_left().height(), self.get_right().height())\n else:\n return 1+self.get_left().height()\n else:\n return 1+self.get_right().height()", "def get_height_iterative(self):\n max_so_far = 0\n nodes_queue = deque()\n nodes_queue.append((self.root, 0))\n while nodes_queue:\n node, depth = nodes_queue.popleft()\n max_so_far = max(max_so_far, depth)\n if node.left:\n nodes_queue.append((node.left, depth + 1))\n if node.right:\n nodes_queue.append((node.right, depth + 1))\n return max_so_far", "def height(self, p=None):\n if p is None:\n p = self.root()\n return self._height2(p)", "def height(self, p=None):\n if p is None:\n p = self.root()\n return self._height2(p)", "def height(poly):\n num = len(poly) - 1\n if abs(poly[num][2] - poly[0][2]) > abs(poly[1][2] - poly[0][2]):\n return dist(poly[num], poly[0])\n elif abs(poly[num][2] - poly[0][2]) < abs(poly[1][2] - poly[0][2]):\n return dist(poly[1], poly[0])\n else:\n return min(dist(poly[num], poly[0]), dist(poly[1], poly[0]))", "def _height(node):\n\n if not node:\n return 0\n\n return 1 + max(_height(node.left), _height(node.right))", "def get_height(self, treenode=self):\n\t\treturn self.__get_height(treenode)", "def _height2(self, p):\n if self.is_leaf(p):\n return 0\n else:\n return 1 + max(self._height2(c) for c in self.children(p))", "def _height2(self, p):\n if self.is_leaf(p):\n return 0\n else:\n return 1 + max(self._height2(c) for c in self.children(p))" ]

[ "0.6800607", "0.65334195", "0.65241534", "0.6479777", "0.6462834", "0.63903254", "0.6358888", "0.6354578", "0.6334228", "0.63333184", "0.62644345", "0.6259376", "0.62438977", "0.62394667", "0.6223324", "0.6222117", "0.62176883", "0.6216847", "0.62075406", "0.6189507", "0.61804366", "0.61419976", "0.6124716", "0.61037725", "0.61037725", "0.6092213", "0.60656893", "0.6052646", "0.60373825", "0.60373825" ]

[ "def get_water_level(self):\n return self.water_level", "def get_current_water_level(self):\n \n url = f'http://waterservices.usgs.gov/nwis/iv/?format=json&sites={self.site_number}&parameterCd=00060,00065&siteStatus=all'\n\n response = requests.request(\"GET\", url)\n data = json.loads(response.text)\n \n #parses json response to get only value of current water level for given river\n current_water_level = data['value']['timeSeries'][0]['values'][0]['value'][0]['value']\n \n return current_water_level", "def get_water_level(df):\n\n water,lat = [],[]\n #gets just ocean photons\n df = df.loc[df.Conf_ocean == 4]\n if len(df) == 0:\n return None\n #getting photons +- 2 of the median height of photons\n df = df.loc[(df.Height > df.Height.median() - 2) & (df.Height < df.Height.median() + 2)]\n\n #creating a df with just the latitude and height\n sea_level = pd.DataFrame([df.Height,df.Latitude]).T.dropna()\n sea_level.columns = ['water','latitude']\n\n #getting photons +- 1.25 of the median height of photons\n sea_level = sea_level.loc[(sea_level.water > sea_level.water.median() -1.25) & (sea_level.water < sea_level.water.median() +1.25)]\n\n #fitting linear line to remaining points\n z = np.polyfit(sea_level.latitude, sea_level.water,1)\n f = np.poly1d(z)\n\n #getting points with <2m abs error\n sea_level['abs_diff'] = np.abs(sea_level.water - f(sea_level.latitude))\n sea_level = sea_level.loc[sea_level.abs_diff < 2]\n #fitting a parabolic function to the remaining points\n z2 = np.polyfit(sea_level.latitude, sea_level.water,2)\n f2 = np.poly1d(z2)\n\n return f2", "def get_geologic_level(self, point: Point) -> int:\n if point == self.target:\n return 0\n if point.y == 0:\n return point.x * 16807\n if point.x == 0:\n return point.y * 48271\n return self.get_erosion_level(to_above(point)) * self.get_erosion_level(to_left(point))", "def elevation(x, y):\n file = os.path.abspath(\"..\") + \"\\Shape\\Shape.vrt\"\n layer = gdal.Open(file)\n gt = layer.GetGeoTransform()\n rasterx = int((x - gt[0]) / gt[1])\n rastery = int((y - gt[3]) / gt[5])\n print('elevation =', layer.GetRasterBand(1).ReadAsArray(rasterx, rastery, 1, 1)[0][0], 'm above sea level')", "def power_level(x, y, serial):\n rack_id = x + 10\n return (rack_id * y + serial) * rack_id // 100 % 10 - 5", "def supply_region(self, x, y):\n if x>350 and x<450 and y>0 and y<100:\n return 1\n elif x>350 and x<450 and y>400 and y<500:\n return 2\n return 0", "def elevation(self):\n return self.altitude - self.heightAboveGround", "def elevation(source):\n srcAzEl = subarrayControl.s.azel(source, 0.0);\n return srcAzEl[1];", "def test_welch(x, y, level):\n return test_t(x, y, level, equal_var=False)", "def get_ly(self):\r\n return self.dy * self.ny - self.oy", "def first_level_functionality(file, y=0, x=0, z=0):\n\n fileobj = open(file,'r')\n\n count_above_seaLevel = 0\n count_total = 0\n\n for row in fileobj:\n # Split the argument into words using str.split()\n altitude = float(row.split()[2])\n\n if altitude > 0:\n count_total += 1\n\n if altitude > z:\n #explain double for loop here\n count_above_seaLevel += 1\n\n area_above_seaLevel = int(x * y * count_above_seaLevel)\n\n #comment explain this\n percentage_landArea_above_seaLevel = \\\n 100 * round(count_above_seaLevel/count_total,4)\n\n fileobj.close()\n\n print(\n \"The land area above water in this area at +\",\n z,\n \"meters will be\",\n area_above_seaLevel,\n \"square kilometers, which is\",\n percentage_landArea_above_seaLevel,\n \"% of the current land area above water.\")", "def set_level(self, x, level):\n return x * 10 ** ((level - self.ref_level) / 20)", "def retrieve_pixel_value(lon, lat, data_source):\n dataset = gdal.Open(data_source)\n\n gt = dataset.GetGeoTransform()\n the_band = dataset.GetRasterBand(1)\n px = int((lon - gt[0]) / gt[1]) # x pixel\n py = int((lat - gt[3]) / gt[5]) # y pixel\n\n buf = the_band.ReadRaster(px, py, 1, 1, buf_type=gdal.GDT_Int16)\n elev = struct.unpack(\"h\", buf)\n\n return elev[0]", "def get_temperature(elevation, sea_level):\n if elevation <= sea_level:\n return 0.8\n else:\n return (-1.0 / (1.0 - sea_level)) * (elevation - sea_level) + 1.0", "def buff_region(self, x, y):\n if x>120 and x<220 and y>275 and y<375:\n return 1\n elif x>580 and x<680 and y>125 and y<225:\n return 2\n return 0", "def get(self, x: int, y: int, /) -> int:", "def calculate_dew_point(temp, hum):\n return temp - (100 - hum) / 5", "def get_level(rol):\n\treturn rol.level", "def elevation(self, rover):\n\t\tcurrent_tile = rover.planet.tiles[rover.y][rover.x]\n\t\t#current_tile is slope\n\t\tif current_tile.is_slope():\n\t\t\t#self is slope current_tile is slope\n\t\t\tif self.is_slope():\n\t\t\t\tif current_tile.high_elevation == self.low_elevation:\n\t\t\t\t\treturn \"/\"\n\t\t\t\tif current_tile.low_elevation == self.high_elevation:\n\t\t\t\t\treturn \"\\\\\"\n\t\t\t\tif self.high_elevation < current_tile.low_elevation:\n\t\t\t\t\treturn \"-\"\n\t\t\t\tif self.low_elevation > current_tile.high_elevation:\n\t\t\t\t\treturn \"+\"\n\t\t\t\tif self.low_elevation == current_tile.low_elevation\\\n\t\t\t\t\tand self.high_elevation == current_tile.high_elevation:\n\t\t\t\t\treturn \" \"\n\t\t\t#self is flat current_tile is slope\n\t\t\telse:\n\t\t\t\tif self.low_elevation > current_tile.high_elevation:\n\t\t\t\t\treturn \"+\"\n\t\t\t\tif self.low_elevation < current_tile.low_elevation:\n\t\t\t\t\treturn \"-\"\n\t\t\t\treturn \" \"\n\n\n\t\telse: #current_tile is flat\n\t\t\t#self is slope current_tile is flat\n\t\t\tif self.is_slope():\n\t\t\t\tif self.low_elevation == current_tile.low_elevation:\n\t\t\t\t\treturn \"/\"\n\t\t\t\tif self.high_elevation == current_tile.low_elevation:\n\t\t\t\t\treturn \"\\\\\"\n\t\t\t\tif self.low_elevation > current_tile.low_elevation:\n\t\t\t\t\treturn \"+\"\n\t\t\t\tif self.high_elevation < current_tile.low_elevation:\n\t\t\t\t\treturn \"-\"\n\t\t\t#self is flat current_tile is flat\n\t\t\telse:\n\t\t\t\tif self.low_elevation > current_tile.low_elevation:\n\t\t\t\t\treturn \"+\"\n\t\t\t\tif self.high_elevation < current_tile.low_elevation:\n\t\t\t\t\treturn \"-\"\n\t\t\treturn \" \"", "def getLevel(self):\n return self.level", "def calculateLighting(x,y,z, xnormal, ynormal, znormal):\n dummy = 0\n clr = dislin.getlit(x,y,z,xn,yn,zn,dummy)", "def get_level(self, channel=None):\n return int(self.getSensorData(\"FILLING_LEVEL\", channel))", "def getLightSensor() -> int:\n pass", "def get_pixel(self, x, y):\n if x < 0 or x > 7 or y < 0 or y > 15:\n # Ignore out of bounds pixels.\n return\n if y < 8:\n return self.get_led( y * 16 + x)\n else:\n return self.get_led((y-8) * 16 + (x+8))", "def get_velocity_sink(strength, xs, ys, X, Y):\r\n u = strength / (2 * math.pi) * (X - xs) / ((X - xs)**2 + (Y - ys)**2)\r\n v = strength / (2 * math.pi) * (Y - ys) / ((X - xs)**2 + (Y - ys)**2)\r\n \r\n return u, v", "def walled_in(x: int, y: int) -> bool:\r\n threshold = 2\r\n level = 0\r\n if wall_check(x, y, True):\r\n threshold = 1\r\n if not wall_check(x-1, y+1, False):\r\n if example[x-1, y+1] == 0:\r\n if mark_traveller(x-1, y+1, \"SW\"):\r\n level += 1\r\n if level >= threshold:\r\n return True\r\n if not wall_check(x - 1, y - 1, False):\r\n if example[x - 1, y - 1] == 0:\r\n if mark_traveller(x - 1, y - 1, \"SE\"):\r\n level += 1\r\n if level >= threshold:\r\n return True\r\n if not wall_check(x + 1, y - 1, False):\r\n if example[x + 1, y - 1] == 0:\r\n if mark_traveller(x + 1, y - 1, \"NE\"):\r\n level += 1\r\n if level >= threshold:\r\n return True\r\n if not wall_check(x + 1, y + 1, False):\r\n if example[x + 1, y + 1] == 0:\r\n if mark_traveller(x + 1, y + 1, \"NW\"):\r\n level += 1\r\n if level >= threshold:\r\n return True\r\n return False", "def level(self):\n return self.init_v[2]", "def get_level(cls, curve_value):\n return curve_value & (2 ** cls.level_bits - 1)", "def elevation(self):\n return self.container['elevation']" ]

[ "0.7158327", "0.67313606", "0.661933", "0.65803623", "0.65341234", "0.63737684", "0.59729874", "0.5847632", "0.58334917", "0.5827491", "0.58220893", "0.58033043", "0.57986677", "0.5751506", "0.56921387", "0.56882936", "0.5679975", "0.5662248", "0.56592685", "0.56507444", "0.56410825", "0.56353784", "0.56149995", "0.56101435", "0.56098944", "0.5595319", "0.55663246", "0.5505086", "0.54982936", "0.5497777" ]

[ "def is_small(a:int, b:int) -> bool:\n return a <= b", "def dangerouslySmall(c, e):\n return e < -limit and e < (-integerLog10(abs(c))) - 1", "def is_large(a:int, b:int) -> bool:\n return a>=b", "def has_small_digits(n,maxdigit):\n digits = [int(num) for num in str(n)]\n return all([num <= maxdigit for num in digits])", "def verySmall(a, delta=1e-30):\n # used when we really want the values to be 0, but this\n # can't be guaranteed due to floating errors.\n return np.average(a*a) <= delta", "def exceeds_min(value, min_):\n\n if isinstance(value, (float, int)):\n val_ = value\n else:\n try:\n val_ = int(value)\n except:\n val_ = value\n if isinstance(min_, (float, int)):\n return (val_ < min_)\n else:\n if min_.isalnum():\n try:\n imin = int(min_)\n return (val_ < imin)\n except:\n pass\n \n return False", "def smallest_factor(number):\n for i in xrange(2, int(sqrt(number)+1)):\n if number % i == 0:\n return i\n return False", "def largest_scaled_float_not_above(val, scale):\n assert val >= 0\n assert scale >= 0\n float_val = float(val) / 10**scale\n if float_val * 10**scale > val:\n # Take the float just below... it *should* satisfy\n float_val = np.nextafter(float_val, 0.0)\n if float_val * 10**scale > val:\n float_val = np.nextafter(float_val, 0.0)\n assert float_val * 10**scale <= val\n return float_val", "def isSmallInt(op):\n return op == opcode.OP_0 or (op >= opcode.OP_1 and op <= opcode.OP_16)", "def validate_low_integer(number):\n if number < 2:\n raise MaxLimitTooLowError()", "def is_scientific(number):\n if convert_to_scientific_notation(float(number)) == number:\n return True\n return False", "def test_large_values(self):\n eq_(0, smart_int('1' * 1000))", "def lessThan(self, t):\n if t is None:\n return False\n if isinstance(t, (float, int)):\n return self._micros < long(t * 1000000)\n else:\n return self._micros < t._micros", "def is_deficient_number(x):\n return sum(proper_divisors(x)) < x", "def ensure_size(value):\n return int(round(value * 1.0 / base)) * base", "def test_constructed_is_small(self):\n self.assertTrue(all(elt<10 for elt in goodwinsheaf.checkradii()))#check all entries have small radii", "def min_size(v=(0, 0)):\n return _check_two_scalars('min_size', v)", "def check_is_less_than(number1, number2):\n if number1<number2:\n return True\n else:\n return False\n pass", "def is_valid_significant_digits(\n value: Decimal,\n max_significant_digits: int\n) -> bool:\n return round(value, max_significant_digits) == value", "def is_simple_number(x: int):\n divisor = 2\n while divisor < x:\n if x % divisor == 0:\n return False\n divisor += 1\n return True", "def _is_pos_int(number: int) -> bool:\n return type(number) == int and number >= 0", "def test_size_too_small(self):\n min_size = min(settings.MISAGO_AVATARS_SIZES)\n too_small = min_size / 2\n\n self.assertEqual(clean_size(too_small), min_size)", "def arecloseenough(x1, x2):\n\n if abs(x1 - x2) <= VERYSMALL:\n return True\n \n return False", "def n_sanity_check(number):\n #number = min(99,number)\n #number = max(1,number)\n #return number\n if number > 99: # This is alot clearer no?\n return 99\n elif number < 1:\n return 1\n else:\n return number", "def find_bigger_sqrt_number(num):\n\n tmpPos = num\n while np.sqrt(tmpPos) % 1 != 0:\n tmpPos += 1\n return int(np.sqrt(tmpPos))", "def is_acceptable_multiplier(m):\n return 1 < m < (2 ** 61 - 1)", "def is_integer(number: float):\n\tif number.is_integer():\n\t\treturn int(number)\n\treturn number", "def big_or_small(n):\n\n if n > 100:\n print('This is a big number ({0})'.format(n))\n else:\n print('This is a small number ({0})'.format(n))", "def _is_safe_size(n):\n n = int(n)\n\n if n == 0:\n return True\n\n # Divide by 3 until you can't, then by 5 until you can't\n for c in (3, 5):\n while n % c == 0:\n n //= c\n\n # Return True if the remainder is a power of 2\n return not n & (n-1)", "def floor_with_tolerance(num):\n if isclose(num, ceil(num)):\n return ceil(num)\n return floor(num)" ]

[ "0.71358377", "0.70233357", "0.6894309", "0.64070696", "0.6313465", "0.623198", "0.62296844", "0.6060151", "0.605466", "0.6032642", "0.5905205", "0.58516663", "0.58045554", "0.571476", "0.5698064", "0.56735736", "0.5664453", "0.5655646", "0.5649527", "0.5642045", "0.5599978", "0.5578391", "0.5576619", "0.5572189", "0.55665046", "0.5549886", "0.5548237", "0.5534949", "0.55279547", "0.55171806" ]

[ "def cross_product(p0,p1,p2):\n\treturn (((p1[0]-p0[0])*(p2[1]-p0[1]))-((p2[0]-p0[0])*(p1[1]-p0[1])))", "def cross_product(v1, v2):\n return cg3d_vector.CG3dVector(\n v1[1] * v2[2] - v2[1] * v1[2],\n v1[2] * v2[0] - v2[2] * v1[0],\n v1[0] * v2[1] - v2[0] * v1[1]\n )", "def crossProduct(self, p1, p2):\n return (p1.x * p2.y - p1.y * p2.x)", "def cross_pts_triangle(p1, p2, p3):\n return (p1[:, 0] - p3[0]) * (p2[1] - p3[1]) - (p2[0] - p3[0]) * (p1[:, 1] - p3[1])", "def cross3(self, left, right):\n return np.array([left[1] * right[2] - left[2] * right[1],\n left[2] * right[0] - left[0] * right[2],\n left[0] * right[1] - left[1] * right[0]])", "def cross(p, q):\n xyz = np.zeros(3)\n xyz[0] = p[1] * q[2] - p[2] * q[1]\n xyz[1] = p[2] * q[0] - p[0] * q[2]\n xyz[2] = p[0] * q[1] - p[1] * q[0]\n return xyz", "def cross_product(a, b):\n a1, a2, a3 = a\n b1, b2, b3 = b\n return (a2 * b3 - a3 * b2, a3 * b1 - a1 * b3, a1 * b2 - a2 * b1)", "def cross(v1, v2):\n return np.cross(v1, v2)", "def cross(vec1, vec2):\n result = np.zeros(3)\n return cross_(vec1, vec2, result)", "def crossProduct( set1, set2):\n set1 = asarray( set1, _aformat(set1))\n set1 = reshape( set1, (-1, 3))\n set2 = asarray( set2, _aformat(set2))\n set2 = reshape( set2, (-1, 3))\n return cross( set1, set2 )", "def cross(self, v):\n if (len(self.mV) != 3) or (len(v) != 3):\n raise IndexError('Cross product is only for 2 3-vectors.')\n\n (x1, y1, z1) = (self.mV[0], self.mV[1], self.mV[2])\n (x2, y2, z2) = (v[0], v[1], v[2])\n x = y1 * z2 - y2 * z1\n y = z1 * x2 - z2 * x1\n z = x1 * y2 - x2 * y1\n return Vector(x, y, z)", "def cross(v1: Vector, v2: Vector) -> Vector: # Function is fucked TODO\n if len(v1.coords) != 3 or len(v2.coords) != 3:\n raise ValueError(\"Vectors have to be 3 fucking D, nøøb\")\n x = v1.y * v2.z - v1.z * v2.y\n y = v1.z * v2.x - v1.x * v2.z\n z = v1.x * v2.y - v1.y * v2.x\n return Vector(x, y, z)", "def cross_(vec1, vec2, result):\n a1, a2, a3 = double(vec1[0]), double(vec1[1]), double(vec1[2])\n b1, b2, b3 = double(vec2[0]), double(vec2[1]), double(vec2[2])\n result[0] = a2 * b3 - a3 * b2\n result[1] = a3 * b1 - a1 * b3\n result[2] = a1 * b2 - a2 * b1\n return result", "def cross(a, b):\n c1 = a[1]*b[2] - a[2]*b[1]\n c2 = a[2]*b[0] - a[0]*b[2]\n c3 = a[0]*b[1] - a[1]*b[0]\n return sp.array([c1,c2,c3])", "def cross(a, b):\n #return np.cross(a,b)\n\n return vector(a[1] * b[2] - a[2] * b[1],\n a[2] * b[0] - a[0] * b[2],\n a[0] * b[1] - a[1] * b[0])", "def cross( self, vector3 ):\n product = cross( self.array, vector3.array )\n self._coords[:3] = matrix( product ).transpose()\n return self", "def cross_product(a, b):\n return (a[1]*b[2] - a[2]*b[0],\n a[2]*b[0] - a[0]*b[2],\n a[0]*b[1] - a[1]*b[0])", "def cross_multiply(x):\n return (x[0][0] * x[1][1]) - (x[0][1] * x[1][0])", "def cross(u,v):\n u1, u2, u3 = u\n v1, v2, v3 = v\n return np.array([u2*v3 - u3*v2,\n u3*v1 - u1*v3,\n u1*v2 - u2*v1], dtype=u.dtype)", "def cross_product(a,b):\n return [a[1]*b[2]-a[2]*b[1], a[2]*b[0]-a[0]*b[2], a[0]*b[1]-a[1]*b[0]]", "def crossProduct4( set1, set2 ):\n set1 = asarray( set1, _aformat(set1))\n set1 = reshape( set1, (-1, 4))\n set2 = asarray( set2, _aformat(set1))\n set2 = reshape( set2, (-1, 4))\n result = zeros( (len(set1),4), _aformat(set1))\n result[:,:3] = cross( set1[:,:3],set2[:,:3])\n result[:,3] = 1.0\n return result", "def xCrossProd(self, other):\n return other.y * self.z - other.z * self.y", "def test_cross_v3(self):\n\n vec1 = Vec3(1, 0, 0)\n vec2 = Vec3(0, 1, 0)\n cross = vec1.cross(vec2)\n\n expected = Vec3(0, 0, 1)\n\n self.assertEqual(cross, expected)", "def vec_cross(a,b):\r\n return [a[1] * b[2] - a[2] * b[1],\r\n a[2] * b[0] - a[0] * b[2],\r\n a[0] * b[1] - a[1] * b[0]]", "def cross(a,b):\n \n return [ a[1]*b[2] - a[2]*b[1],\n a[2]*b[0] - a[0]*b[2],\n a[0]*b[1] - a[1]*b[0],\n 1.0 ]", "def cross(a, b):\n return np.array([a[1]*b[2] - a[2]*b[1],\n a[2]*b[0] - a[0]*b[2],\n a[0]*b[1] - a[1]*b[0]])", "def cross(v1: Vec2, v2: Vec2) -> float:\n return v1.x * v2.x + v1.y * v2.y", "def cross(x, y):\n x = x.reshape(3)\n y = y.reshape(3)\n z = np.cross(x, y)\n z = z.reshape((3, 1))\n return z", "def d_cross(a, b):\n d_cross = np.zeros((3, 3), dtype=float)\n for i in range(3):\n ei = np.zeros(3, dtype=float)\n ei[i] = 1.0\n d_cross[i] = np.cross(ei, b)\n return d_cross", "def uVectNorm(x1,y1,z1, # P\n x2,y2,z2, # Q\n x3,y3,z3): # R\n p1 = np.array([x1,y1,z1])\n p2 = np.array([x2,y2,z2])\n p3 = np.array([x3,y3,z3])\n\n v1 = p3-p1\n v2 = p2-p1\n\n cp = np.cross(v1,v2)\n a,b,c = cp\n\n d = np.dot(cp, p3)\n\n print(a,b,c)" ]

[ "0.7840646", "0.7627517", "0.7564835", "0.75022256", "0.7371499", "0.716658", "0.7165488", "0.71437544", "0.7071827", "0.69996214", "0.6967165", "0.69446385", "0.6910858", "0.6805146", "0.67996776", "0.67702717", "0.67530876", "0.6737045", "0.6727149", "0.6688273", "0.66100967", "0.65714574", "0.6571141", "0.655815", "0.6545461", "0.65289557", "0.6527682", "0.6517802", "0.64971024", "0.6418191" ]

[ "def update_profits(self, next_profit):\n self.profit = next_profit\n self.profit_history.append(next_profit)", "def update_profile(profile_id):\n \n profile = mongo.db.profiles\n profile.find_one_and_update({'_id': ObjectId(profile_id)},\n {'$set': {'date': datetime.utcnow(),\n 'headline': request.form.get('headline'),\n 'bio': request.form.get('bio'),\n 'xp': request.form.get('xp'),\n 'interests': request.form.get('interests'),\n 'stack': request.form.get('stack'),\n 'languages': request.form.get('languages'),\n 'frameworks': request.form.get('frameworks'),\n 'github': request.form.get('github'),\n 'linkedin': request.form.get('linkedin')\n }\n }\n )\n return redirect(url_for('dashboard'))", "def update(self, profile: Dict[datetime.time, float]) -> None:\n\n if self._profile is None:\n self._profile = profile\n else:\n self._profile.update(profile)", "def update(table, id_):\n\n # 4\n for index in range(len(table)):\n if table[index][0] == id_:\n addnew = ui.get_inputs(\n ['name: ', 'birth_year: '],\n 'Updating list of hr')\n addnew.insert(0, id_)\n table[index] = addnew\n data_manager.write_table_to_file('hr/persons.csv', table)\n return table", "def update_profile(orcid_id, data=None):\n \n u = db.session.query(User).filter_by(orcid_id=orcid_id).first()\n if u:\n u.updated = datetime.utcnow()\n if data:\n u.profile = data\n # save the user\n db.session.begin_nested()\n try:\n db.session.add(u)\n db.session.commit()\n except exc.IntegrityError as e:\n db.session.rollback()\n # per PEP-0249 a transaction is always in progress \n db.session.commit()", "def update_experience(uid, rid, increment):\n errmsg = []\n\n experience = Experience.query.filter(Experience.uid == uid).filter(Experience.rid == rid).first()\n if not experience:\n errmsg.append(\"Experience entry does not exist for the given user ID and restaurant ID.\")\n elif increment < 0:\n errmsg.append(\"Experience cannot be incremented by a negative number.\")\n\n if not errmsg:\n old_level = convert_experience_to_level(experience.experience)\n milestone = get_milestone(uid, rid)\n Experience.query.filter(Experience.uid == uid).filter(Experience.rid == rid).update(dict(experience=experience.experience + increment))\n db.session.commit()\n if milestone:\n new_level = convert_experience_to_level(experience.experience)\n if old_level < new_level and new_level == int(milestone[\"level\"]):\n update_points(uid, rid, milestone[\"reward\"])\n return None\n\n return errmsg", "def update_profile(id):\n tags = request.form.get('tags')\n user = User.query.get(id)\n speaker = Speaker.query.filter_by(id_assigned_user=user.id).first()\n\n speaker.tags = tags\n try:\n db.session.commit()\n except:\n abort(500)\n\n return redirect(url_for('get_profile', id=user.id))", "def update_followers(request, profile_id):\n user = request.user\n profile = User.objects.get(id=profile_id)\n\n if profile in user.following.all():\n user.following.remove(profile.id)\n user.save()\n else:\n user.following.add(profile.id)\n user.save()\n\n return HttpResponseRedirect(reverse(\"profile\", kwargs={\n \"username\": profile.username\n }))", "def profile_page(cls, employee_id, logger=None):\n if logger is None:\n logger = cls._logger\n\n database_connection = DatabaseConnection(f\"employees.csv\")\n table = database_connection.table\n employee = Employee(employee_id)\n\n view = table[(table['employee_id']==employee.get_employee_id())]\n logger.log(view)\n\n while True:\n\n choice = input(\n \"Please choose: \"\n \"(1) check data, \"\n \"(2) update first name, \"\n \"(3) update last name, \"\n \"(4) save changes, \"\n \"(5) exit without saving \"\n )\n if choice not in ('1', '2', '3', '4', '5'):\n logger.log(\"Please pick a valid choice\")\n elif choice=='1':\n view = table[(table['employee_id']==employee.get_employee_id())]\n logger.log(view)\n elif choice=='2':\n first_name = input(\"Enter your first name: \")\n employee.set_first_name(first_name)\n elif choice=='3':\n last_name = input(\"Enter your last name: \")\n employee.set_last_name(last_name)\n elif choice=='4':\n table[\n (table['employee_id']==employee.get_employee_id())\n ] = pd.Series(\n {'employee_id': employee.get_employee_id(),\n 'first_name': employee.get_first_name(),\n 'last_name': employee.get_last_name(),\n }\n )\n database_connection.overwrite()\n logger.log(\"Information saved!\")\n else:\n break", "def update_employee(self, obj):\n cursor = self.dbconnect.get_cursor()\n try:\n cursor.execute('UPDATE employee '\n 'SET name = %s, email = %s, office = %s, extra_info = %s, picture_location = %s, '\n 'research_group = %s, title = %s, is_external = %s, is_admin = %s, is_active = %s '\n 'WHERE id = %s;',\n (obj.name, obj.email, obj.office, obj.extra_info, obj.picture_location, obj.research_group,\n obj.title, obj.is_external, obj.is_admin, obj.is_active, obj.e_id))\n self.dbconnect.commit()\n except:\n self.dbconnect.rollback()\n raise", "def update(self,\n ipfix_l2_profile_id,\n i_pfix_l2_profile,\n ):\n return self._invoke('update',\n {\n 'ipfix_l2_profile_id': ipfix_l2_profile_id,\n 'i_pfix_l2_profile': i_pfix_l2_profile,\n })", "def update(\n self,\n email,\n company_name,\n location,\n job_profile,\n salary,\n username,\n password,\n security_question,\n security_answer,\n notes,\n date_applied,\n status,\n):", "def _update_state(self, job_id):\n self.logger.info(\"updating 'timestamp' in profile state\")\n # get current state ...\n with open(self.state_file, \"r\") as json_current:\n state = json.load(json_current)\n json_current.close()\n # ... and write new timestamp\n with open(self.state_file, \"w\") as json_new:\n state[\"timestamp\"] = job_id\n json.dump(state, json_new, indent=4)\n json_new.close()", "def do_user_baseline_update():\n targetUsers = User.query.filter_by(id=request.form['id']).all()\n if not any(targetUsers):\n return user_list(\"Unknown user.\")\n\n targetUser = targetUsers[0]\n\n targetUser.baseline = request.form['baseline']\n\n db.session.commit()\n return Response(render_template('employee/user/list.html',\n users=targetUsers,\n message=f\"Updated baseline for {targetUser.name}\"),\n mimetype='text/html')", "def put(self, id ):\n adm = Administration()\n print(api.payload)\n p = Profile.from_dict(api.payload)\n if p is not None:\n p.set_id(id)\n adm.save_profile(p)\n return p, 200\n else:\n return '', 500", "def update_policy_profile(self, profile, body=None):\r\n return self.put(self.policy_profile_path % (profile), body=body)", "def update_education(education_list, profile_id):\n saved_education_ids = set()\n for education in education_list:\n education_id = education.get(\"id\")\n if education_id is not None:\n try:\n education_instance = Education.objects.get(profile_id=profile_id, id=education_id)\n except Education.DoesNotExist:\n raise ValidationError(\"Education {} does not exist\".format(education_id))\n else:\n education_instance = None\n education_serializer = EducationSerializer(instance=education_instance, data=education)\n education_serializer.is_valid(raise_exception=True)\n education_serializer.save(profile_id=profile_id)\n saved_education_ids.add(education_serializer.instance.id)\n\n Education.objects.filter(profile_id=profile_id).exclude(id__in=saved_education_ids).delete()", "def update_user_profile_info(user_id, user_fname, user_lname, email):\n \n user=User.query.filter(User.user_id == user_id).first()\n\n if email != None:\n user.update_email(email)\n if user_fname != None:\n user.update_first_name(user_fname)\n if user_lname != None:\n user.update_last_name\n \n db.session.commit()", "def update(table, id_):\n\n # your code\n key = common.check_for_key(id_,table)\n if key == None:\n ui.print_error_message('Key does not exist')\n else:\n return_inputs = ui.get_inputs(['Name', 'Age'], 'Enter New Values')\n modif_index = key\n\n table[modif_index][NAME] = return_inputs[FIRST_PROP]\n table[modif_index][AGE] = return_inputs[SECOND_PROP]\n data_manager.write_table_to_file('hr/persons.csv', table) \n\n return table", "def update(self, id):\n loan = self._model.query.get(id)\n loan.original_due_date = loan.due_date\n loan.due_date = loan.due_date + 1 * TimeUnits.MONTH_IN_SEC\n\n db.session.add(loan)\n\n try:\n db.session.commit()\n except Exception as exc:\n print(f'Something went wrong: {exc}')\n db.session.rollback()", "def update(self,\n ike_profile_id,\n ip_sec_vpn_ike_profile,\n ):\n return self._invoke('update',\n {\n 'ike_profile_id': ike_profile_id,\n 'ip_sec_vpn_ike_profile': ip_sec_vpn_ike_profile,\n })", "async def updateAudit(self, auditid, name, description, status, type, data, userid) -> UpdateAuditResponse:\n return await self.stub.UpdateAudit(\n UpdateAuditRequest(_id=auditid, name=name,\n description=description, status=status, type=type, created_by=userid\n ))", "def update_users(self):\n conn = sqlite3.connect(self.__DB)\n cursor = conn.cursor()\n\n users_data = []\n unsaved_histories_data = []\n for key, user in self.__users.items(): # here, key it's actually users id\n users_data.append((user.get_balance(), key))\n for register in user.get_history():\n register_str, is_saved = register\n if not is_saved:\n unsaved_histories_data.append((register_str, key))\n\n cursor.executemany('''\n UPDATE users\n SET balance=?\n WHERE id=?;\n ''', users_data)\n\n cursor.executemany('''\n INSERT INTO history (register, owner)\n VALUES (?, ?);\n ''', unsaved_histories_data)\n\n conn.commit()\n conn.close()\n\n self.load_users() # RELOADING!!! Pew, pew, pew, pew, pew...", "def commit_checkpoint(self, checkpoint_id):\n changes_to_merge = self.pop_checkpoint(checkpoint_id)\n if self.checkpoints:\n # we only have to merge the changes into the latest checkpoint if\n # there is one.\n self.latest = merge(\n changes_to_merge,\n self.latest,\n )", "def put(self, employee_id):\n\n employee = EmployeeModel.find_by_id(employee_id)\n if employee is None:\n return {'message': \"There is no employee with this ID, or your access_token is invalid.\"}, 404\n else:\n \"\"\" check if employee entered the building today\"\"\"\n if WorkdayModel.find_latest_workday(employee.id):\n \"\"\"checking if employee already entered building today\"\"\"\n last_workday = WorkdayModel.find_latest_workday(employee.id)\n\n if last_workday.time_in.day == datetime.today().day:\n last_workday.time_out = datetime.today()\n # calculate hours_worked| .time converts to H:M\n duration = last_workday.time_out - last_workday.time_in\n # duration is a datetime.timedelta\n duration = (datetime.min + duration).time()\n last_workday.hours_worked = duration\n try:\n last_workday.save_to_db()\n except:\n return {'message': 'An error occurred updating worked hours'}, 500\n\n return last_workday.json()\n\n return {'message': 'First use of card, or employee did not start work today'}, 200", "def employment(self, instance):\r\n return instance.user.profile.employment", "def update_account_with(self, id_, **kwargs):\n self.update_user_with(id_, **kwargs)\n self.update_profile_with(id_, **kwargs)\n # TODO:\n # self.update_prefecture_with(id_, kwargs)", "def put(self, id):\n adm = Administration()\n print(api.payload)\n lp = LearnProfile.from_dict(api.payload)\n if lp is not None:\n lp.set_id(id)\n adm.save_learnprofile(lp)\n return lp, 200\n\n else:\n return '', 500", "def refresh_history(self):\n\n self.old_jobs = self.secretary_bot.history_bullshit_filter(self.old_jobs)\n self.jobs_save(self.old_jobs, 'overwrite')", "def record_update_for_user(record_id, values):\n session = get_session()\n with session.begin():\n record_ref = get_user_record(record_id, session=session)\n record_ref.update(values)\n record_ref.save(session=session)" ]

[ "0.5801277", "0.57033116", "0.55727786", "0.5357609", "0.5347083", "0.52954924", "0.529461", "0.5294242", "0.52700007", "0.5151352", "0.5092951", "0.5087638", "0.5076853", "0.5068695", "0.5017037", "0.50102806", "0.50093156", "0.5007281", "0.50012374", "0.5000325", "0.49863422", "0.49825117", "0.4979344", "0.49755374", "0.49453056", "0.49182734", "0.49078512", "0.49030033", "0.48741964", "0.48657006" ]

[ "def get_required_fields(self) -> Iterable[fields.Field]:\n for model_field in self.get_fields():\n if model_field.required:\n yield model_field", "def clean_fields(self, instance, exclude=None):\n errors = {}\n exclude = exclude or []\n for name, f in self.properties.items():\n raw_value = getattr(instance, name, None)\n is_blank = not bool(raw_value)\n is_nullable = f.null\n is_defaulted = f.column.default or f.column.server_default\n is_required = f.required\n\n is_skippable = is_blank and (is_nullable or is_defaulted or not is_required)\n\n if name in exclude or is_skippable:\n continue\n try:\n setattr(instance, name, f.clean(raw_value, instance))\n except ValidationError as e:\n errors[name] = e.error_list\n if errors:\n raise NestedValidationError(errors)", "def enforce_required_fields(self, attrs):\n if self.instance is not None:\n return\n # missing_items = {\n # field_name: self.missing_message\n # for field_name in self.fields\n # if field_name not in attrs\n # }\n # if missing_items:\n # raise ValidationError(missing_items, code='required')", "def forbid_properties(schema: Dict[str, Any], forbidden: List[str]) -> None:\n not_schema = schema.setdefault(\"not\", {})\n already_forbidden = not_schema.setdefault(\"required\", [])\n already_forbidden.extend(forbidden)\n not_schema[\"required\"] = list(set(chain(already_forbidden, forbidden)))", "def setRequiredValues(self, instance):\n for key in instance.__slots__:\n if key in instance.requiredFields:\n value = self.getTypicalValue(type(instance), key)\n setattr(instance, key, value)", "def required_dict_validator(self, dict_fields, model_name, erp_required=[]):\n required_fields = self.env['settings.field'].sudo().search([('model_id.model', '=', model_name)])\n\n if required_fields:\n erp_required.extend(required_fields.required_field_ids.filtered(lambda x: x.id not in [er.id for er in erp_required]))\n\n for field in erp_required:\n if field.name in dict_fields and 'required' not in dict_fields[field.name]:\n dict_fields[field.name]['required'] = True\n dict_fields[field.name]['empty'] = False\n\n return dict_fields", "def required_fields(model, values):\n if values:\n for k in list(values):\n if k not in model.__table__.columns.keys():\n values.pop(k)\n return values", "def clean_fields(self, exclude=None):\n obj = self._obj\n if obj is None:\n return None\n\n self.event = self.clean_event(self.event)\n self.resource_name = self.clean_resource_name(obj.__class__.__name__)\n self.resource_id = obj.id\n self.site = self.clean_site(obj)\n\n serializer_class = self.get_serializer_for_resource(self.resource_name)\n serializer = serializer_class(obj)\n self._resource = serializer.data", "def get_empty_required_fields(self):\n empty_fields = self.get_empty_fields()\n return [f for f in empty_fields if f in self.REQUIRED_FIELDS]", "def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n ignore_fields = (\n 'about_me',\n 'romanized_first_name',\n 'romanized_last_name',\n 'postal_code',\n )\n set_fields_to_required(self, ignore_fields=ignore_fields)", "def _filtered_attributes(\n self, required_attributes: Union[Iterable, Literal[\"__all__\"]], dontformat=False\n ) -> Tuple[Dict, Dict]:\n if required_attributes == \"__all__\":\n required_attributes = self.__atomic_fields_set__ | {\"meta\"}\n required_attributes = set(required_attributes)\n errors = []\n attrs = {name: getattr(self, name, None) for name in required_attributes-{\"meta\"}}\n for name in required_attributes - {\"meta\"}:\n if name not in self.__atomic_fields_set__:\n errors.append(f\" Unexpected required attribute: '{name}'.\")\n continue\n if attrs.get(name) is None:\n if not utils.is_an_optional_type_hint(self.__fields_types__[name]):\n errors.append(f\" Missing required attribute: '{name}'.\")\n if errors:\n raise ValueError(\"\\n\" + \"\\n\".join(errors))\n attrs = {\n utils.snake_to_camel_case(k, dontformat): v\n for (k, v) in attrs.items()\n if k in set(required_attributes) - self._identifier_fields\n }\n meta_attrs = {\n utils.snake_to_camel_case(name, dontformat): getattr(self, name)\n for name in self.__meta_attributes__\n if getattr(self, name) is not None\n } if \"meta\" in required_attributes else None\n return attrs, meta_attrs", "def remove_null_fields(self):\n with open(self.schema_path, 'r') as file_obj:\n schema_data = yaml.safe_load(file_obj)\n schema_fields = schema_data.get('mapping').keys()\n for field in schema_fields:\n # We want to keep 'false' and 0 values, and avoid removing fields that are required in the schema.\n if field in self.data and self.data[field] in (None, '', [], {}) and \\\n not schema_data.get('mapping', {}).get(field, {}).get('required'):\n self.data.pop(field)", "def only(self, *fields):\n for field in fields:\n self._only_fields.add(field)\n\n return self", "def _populate_always_present_fields(self, field):\n defaults = [\n (\"label\", \"\"),\n (\"instructions\", \"\"),\n (\"placeholder\", \"\"),\n (\"defaultValue\", \"\"),\n (\"restrictions\", {}),\n (\"errorMessages\", {}),\n ]\n field.update({\n key: value\n for key, value in defaults if key not in field\n })", "def check_for_required_fields(cls, fields=[], dataDict={}):\n\n validateRequired = Validate.required(fields=fields, dataDict=dataDict)\n if validateRequired['status'] == False:\n res = jsonify(\n {'status': 400, 'error': validateRequired['message'], 'data': []})\n return abort(make_response(res, 400))\n return True", "def set_additional_fields(cls, model, data):\n for k, v in data.items():\n if not hasattr(model, k):\n setattr(model, k, v)", "def depopulate(self, is_update):\n fields = {}\n schema = self.schema\n for k, field in schema.fields.items():\n is_modified = k in self.modified_fields\n orig_v = getattr(self, k)\n v = field.iset(\n self,\n orig_v,\n is_update=is_update,\n is_modified=is_modified\n )\n\n if is_modified or v is not None:\n if is_update and field.is_pk() and v == orig_v:\n continue\n\n else:\n fields[k] = v\n\n if not is_update:\n for field_name in schema.required_fields.keys():\n if field_name not in fields:\n raise KeyError(\"Missing required field {}\".format(field_name))\n\n return fields", "def validate_fields_for_magento(self,data):\n for field in data:\n if data[field] == None :\n del data[field]\n if data[field] == True:\n data[field] = 1\n if data[field] == False :\n data[field] = 0", "def test_object_is_not_created_without_required_fields(self):\n data1 = self.data.copy()\n del data1[\"title\"]\n\n serializer = ProductSerializer(data=data1)\n\n self.assertFalse(serializer.is_valid())\n self.assertEqual(serializer.errors.get(\"title\")[0], self.error_message)\n\n data2 = self.data.copy()\n del data2[\"description\"]\n\n serializer = ProductSerializer(data=data2)\n self.assertFalse(serializer.is_valid())\n self.assertEqual(serializer.errors.get(\"description\")[0], self.error_message)\n\n data3 = self.data.copy()\n del data3[\"price\"]\n\n serializer = ProductSerializer(data=data3)\n self.assertFalse(serializer.is_valid())\n self.assertEqual(serializer.errors.get(\"price\")[0], self.error_message)", "def required_fields(required_fields=[]):\n def decorator(func):\n \"\"\" The decorator applied to the obj_create method\"\"\"\n def wrapper(resource, bundle=None, **kwargs):\n \"\"\" wraps the decorated method and verifies a list of required\n fields when a new object is being created.\n\n \"\"\"\n if not isinstance(bundle, Bundle):\n request = bundle\n data = resource.deserialize(\n request, request.body,\n format=request.META.get('CONTENT_TYPE', 'application/json')\n )\n bundle = resource.build_bundle(request=request, data=data)\n else:\n request = None\n\n for required_field in required_fields:\n if required_field not in bundle.data:\n response = HttpBadRequest(\n json.dumps(\"missing %s field\" % required_field),\n content_type=bundle.request.META['CONTENT_TYPE'])\n raise ImmediateHttpResponse(response=response)\n return func(resource, bundle=bundle, **kwargs)\n return wrapper\n return decorator", "def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n self.fields['first_name'].required = False\n self.fields['last_name'].required = False\n self.fields['institution'].required = False\n self.fields['institution_logo'].required = False\n self.fields['allow_notifications'].required = False", "def test_create_enforces_required_fields(self):\n serializer = ServiceSerializer(data = {}, context = dict(project = self.project))\n self.assertFalse(serializer.is_valid())\n required_fields = {'name', 'category'}\n self.assertCountEqual(serializer.errors.keys(), required_fields)\n for name in required_fields:\n self.assertEqual(serializer.errors[name][0].code, 'required')", "def test_defining_only_or_defer_on_nonexistant_fields_fails(self):", "def data_only(self, fields):\n only = {}\n data = json.loads(self.data())\n for field, value in data.items():\n if field in fields:\n only[field] = value\n return json.dumps(only)", "def writeRequiredFields(self, outputFile):\n fields = []\n for field in self.getFields():\n if not field.has_default:\n fields.append(field)\n if len(fields) < 1:\n self._writeWithIndent('requiredFields = set([])', outputFile)\n else:\n self._writeWithIndent('requiredFields = set([', outputFile)\n for field in fields:\n string_ = '\"{0}\",'.format(field.name)\n self._writeWithIndent(string_, outputFile, 2)\n self._writeWithIndent('])', outputFile)", "def get_fields(self, exclude=('id',)):\n fields = {}\n for field in self._meta.fields:\n if not field.name in exclude and getattr(self, field.name):\n fields[field.name] = getattr(self, field.name)\n return fields", "def _validate_fields(fields):\n for field in fields:\n if field not in request.form:\n raise FieldNotFoundError(field)", "def subfields_all(verifield, required):\n for req_key, req_val in required.items():\n if getitem(verifield, req_key, '') != req_val:\n return False\n return True", "def check_for_empties():\n if hasattr(self.instance, 'fields_required_for_publish'):\n errors_for_empties = {\n field_name: try_adding_error_to_field(\n field_name, field_value)\n for (field_name, field_value) in self.data.items()\n if (len(field_value) == 0 or field_value == 'null') and field_name in self.instance.fields_required_for_publish\n }", "def missing_required_fields(proposal):\n data = flatten(proposal.data[0])\n sections = search_multiple_keys(proposal.schema, primary_search='isRequired', search_list=['label', 'name'])\n\n missing_fields = []\n for flat_key in data.items():\n for item in sections:\n if flat_key[0].endswith(item['name']):\n if not flat_key[1].strip():\n missing_fields.append( dict(name=flat_key[0], label=item['label']) )\n return missing_fields" ]

[ "0.64765036", "0.6341806", "0.63284636", "0.6283481", "0.62026083", "0.6162853", "0.6133982", "0.6094568", "0.5909462", "0.5858007", "0.58525836", "0.58163685", "0.5798981", "0.5755898", "0.5753509", "0.5744149", "0.57343006", "0.5726579", "0.57135725", "0.57066965", "0.5697895", "0.5679485", "0.56732327", "0.5667943", "0.5658092", "0.56472766", "0.5645767", "0.5642113", "0.5634381", "0.5613377" ]

[ "def __init__(self, baseurl, nodename, jenkins_obj):\n self.name = nodename\n self.jenkins = jenkins_obj\n JenkinsBase.__init__(self, baseurl)", "def fromurl(cls, url: str):\n return cls.parse_obj(requests.get(url).json())", "async def from_url(cls) -> \"AocPrivateLeaderboard\":\n api_json = await cls.json_from_url()\n return cls.from_json(api_json)", "def __init__(self, jenkinsurl=None, dburl=None):\n self.logger = get_named_logger('Djinn')\n self.dj = DJenkins(url=jenkinsurl, logger=self.logger)\n self.dburl = dburl\n self.db = PipelineResults(connection_url=dburl, echo=False)", "def get_jenkins_with_http_info(self, **kwargs):\n\n all_params = []\n all_params.append('async')\n all_params.append('_return_http_data_only')\n all_params.append('_preload_content')\n all_params.append('_request_timeout')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method get_jenkins\" % key\n )\n params[key] = val\n del params['kwargs']\n\n collection_formats = {}\n\n path_params = {}\n\n query_params = []\n\n header_params = {}\n\n form_params = []\n local_var_files = {}\n\n body_params = None\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n\n # Authentication setting\n auth_settings = ['jenkins_auth']\n\n return self.api_client.call_api('/api/json', 'GET',\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=local_var_files,\n response_type='Hudson',\n auth_settings=auth_settings,\n async=params.get('async'),\n _return_http_data_only=params.get('_return_http_data_only'),\n _preload_content=params.get('_preload_content', True),\n _request_timeout=params.get('_request_timeout'),\n collection_formats=collection_formats)", "def _get_instance(cls, configuration, auth_type):\n if configuration in cls._INSTANCES:\n return cls._INSTANCES[configuration]\n return cls._create_instance(configuration, auth_type)", "def get_builder_instance(self):\n if self.framework == 'standalone':\n builder_instance = BuildStandaloneExecutionScenario(\n scenario=self.scenario,\n testcase_list=self.testcase_list,\n splunk_metadata=self.splunk_metadata\n )\n else:\n builder_instance = BuildOneMapExecutionScenario(\n scenario=self.scenario,\n testcase_list=self.testcase_list,\n splunk_metadata=self.splunk_metadata\n )\n return builder_instance", "def get_instance(driver_info: DriverInfo) -> webdriver:\n if driver_info.get_driver_type() == \"chrome\":\n options = webdriver.ChromeOptions()\n options.add_argument(\"--start-maximized\")\n return webdriver.Chrome(\n executable_path=os.path.join(\n driver_info.get_driver_path(),\n \"chromedriver\"\n ),\n chrome_options=options\n )", "def getinstance() :\n\t\treturn Jikji.instance", "def get_object(self) -> Job:\n project = ProjectPermissionsMixin.get_object(self)\n return project.jobs.get(id=self.kwargs[\"job\"])", "def get_instance(self, name):\n klass = self.get_class(name)\n return klass()", "def getResource(self, url):\n\n res = self.getRequest(url)\n return self._instantiateResource(res)", "def get_browser(self, name, job):\n browser = None\n if 'type' in job and job['type'] == 'traceroute':\n from .traceroute import Traceroute\n browser = Traceroute(self.options, job)\n elif name in self.browsers and 'exe' in self.browsers[name]:\n from .chrome_desktop import ChromeDesktop\n browser = ChromeDesktop(self.browsers[name]['exe'], self.options, job)\n return browser", "def getInstance(config):\n return Plugin(config)", "def getInstance(config):\n return Plugin(config)", "def get_plugin(version):\n build_version = get_build_version(current_app, version)\n if build_version:\n pid = request.args.get('id')\n return _get_plugin(current_app, build_version, pid)\n else:\n return invalid_api_version(404)", "def __new__(cls, *_args, **_kwargs):\n if cls._instance is None:\n cls._instance = super(TestJob, cls).__new__(cls)\n return cls._instance", "def get_instance(self, instance):\n return self._get(_instance.Instance, instance)", "def get_instance(instance: Optional[str] = None,\n project: Optional[str] = None,\n opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetInstanceResult:\n __args__ = dict()\n __args__['instance'] = instance\n __args__['project'] = project\n opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)\n __ret__ = pulumi.runtime.invoke('google-native:sqladmin/v1:getInstance', __args__, opts=opts, typ=GetInstanceResult).value\n\n return AwaitableGetInstanceResult(\n available_maintenance_versions=pulumi.get(__ret__, 'available_maintenance_versions'),\n backend_type=pulumi.get(__ret__, 'backend_type'),\n connection_name=pulumi.get(__ret__, 'connection_name'),\n create_time=pulumi.get(__ret__, 'create_time'),\n current_disk_size=pulumi.get(__ret__, 'current_disk_size'),\n database_installed_version=pulumi.get(__ret__, 'database_installed_version'),\n database_version=pulumi.get(__ret__, 'database_version'),\n disk_encryption_configuration=pulumi.get(__ret__, 'disk_encryption_configuration'),\n disk_encryption_status=pulumi.get(__ret__, 'disk_encryption_status'),\n etag=pulumi.get(__ret__, 'etag'),\n failover_replica=pulumi.get(__ret__, 'failover_replica'),\n gce_zone=pulumi.get(__ret__, 'gce_zone'),\n instance_type=pulumi.get(__ret__, 'instance_type'),\n ip_addresses=pulumi.get(__ret__, 'ip_addresses'),\n ipv6_address=pulumi.get(__ret__, 'ipv6_address'),\n kind=pulumi.get(__ret__, 'kind'),\n maintenance_version=pulumi.get(__ret__, 'maintenance_version'),\n master_instance_name=pulumi.get(__ret__, 'master_instance_name'),\n max_disk_size=pulumi.get(__ret__, 'max_disk_size'),\n name=pulumi.get(__ret__, 'name'),\n on_premises_configuration=pulumi.get(__ret__, 'on_premises_configuration'),\n out_of_disk_report=pulumi.get(__ret__, 'out_of_disk_report'),\n project=pulumi.get(__ret__, 'project'),\n region=pulumi.get(__ret__, 'region'),\n replica_configuration=pulumi.get(__ret__, 'replica_configuration'),\n replica_names=pulumi.get(__ret__, 'replica_names'),\n root_password=pulumi.get(__ret__, 'root_password'),\n satisfies_pzs=pulumi.get(__ret__, 'satisfies_pzs'),\n scheduled_maintenance=pulumi.get(__ret__, 'scheduled_maintenance'),\n secondary_gce_zone=pulumi.get(__ret__, 'secondary_gce_zone'),\n self_link=pulumi.get(__ret__, 'self_link'),\n server_ca_cert=pulumi.get(__ret__, 'server_ca_cert'),\n service_account_email_address=pulumi.get(__ret__, 'service_account_email_address'),\n settings=pulumi.get(__ret__, 'settings'),\n state=pulumi.get(__ret__, 'state'),\n suspension_reason=pulumi.get(__ret__, 'suspension_reason'))", "def get_jira_instance(use_test_server):\n username = get_username()\n password = get_password()\n\n credentials=(username, password)\n\n if use_test_server:\n cfg.server = cfg.TEST_SERVER\n\n try:\n j = JIRA(cfg.server, basic_auth=credentials), username\n except JIRAError, e:\n if e.text.find('CAPTCHA_CHALLENGE') != -1:\n eprint('Captcha verification has been triggered by '\\\n 'JIRA - please go to JIRA using your web '\\\n 'browser, log out of JIRA, log back in '\\\n 'entering the captcha; after that is done, '\\\n 'please re-run the script')\n sys.exit(os.EX_NOPERM)\n else:\n raise\n return j", "def get_instance(cls):\n return cls.__new__(cls)", "def get_instance(cls):\n return cls.__new__(cls)", "def get_instance(cls):\n return cls.__new__(cls)", "def _create_instance(cls, configuration, auth_type):\n auth = ClientAuthFactory.get(\n username=configuration.username,\n password=configuration.password,\n auth_type=auth_type\n )\n instance = HttpClient(configuration.url, auth)\n cls._INSTANCES[configuration] = instance\n return instance", "def from_url(cls, url):\n query_params = _get_query_params_from_url(url)\n\n if _get_param(query_params, \"SERVICE\") == \"WMS\":\n layer = _get_param(query_params, \"LAYERS\")\n elif _get_param(query_params, \"SERVICE\") == \"WCS\":\n layer = _get_param(query_params, \"COVERAGE\")\n\n d = None\n if layer.startswith(\"https://\"):\n d = _get_from_url(layer).json()\n elif layer.startswith(\"s3://\"):\n parts = layer.split(\"/\")\n bucket = parts[2]\n key = \"/\".join(parts[3:])\n s3 = S3CacheStore(s3_bucket=bucket)\n s = s3._load(key)\n elif layer == \"%PARAMS%\":\n s = _get_param(query_params, \"PARAMS\")\n else:\n p = _get_param(query_params, \"PARAMS\")\n if p is None:\n p = \"{}\"\n if not isinstance(p, dict):\n p = json.loads(p)\n return cls.from_name_params(layer, p)\n\n if d is None:\n d = json.loads(s, object_pairs_hook=OrderedDict)\n\n return cls.from_definition(d)", "def from_url(cls, url):\n query_params = _get_query_params_from_url(url)\n\n if _get_param(query_params, \"SERVICE\") == \"WMS\":\n layer = _get_param(query_params, \"LAYERS\")\n elif _get_param(query_params, \"SERVICE\") == \"WCS\":\n layer = _get_param(query_params, \"COVERAGE\")\n\n d = None\n if layer.startswith(\"https://\"):\n d = _get_from_url(layer).json()\n elif layer.startswith(\"s3://\"):\n parts = layer.split(\"/\")\n bucket = parts[2]\n key = \"/\".join(parts[3:])\n s3 = S3CacheStore(s3_bucket=bucket)\n s = s3._load(key)\n elif layer == \"%PARAMS%\":\n s = _get_param(query_params, \"PARAMS\")\n else:\n p = _get_param(query_params, \"PARAMS\")\n if p is None:\n p = \"{}\"\n if not isinstance(p, dict):\n p = json.loads(p)\n return cls.from_name_params(layer, p)\n\n if d is None:\n d = json.loads(s, object_pairs_hook=OrderedDict)\n\n return cls.from_definition(d)", "def get_instance(self, name):\n return self.website.instance.id", "def get_instance(cls, galaxy_instance=None):\n if not WorkflowLoader._instance:\n cls._logger.debug(\"Creating a new WorflowLoader instance...\")\n WorkflowLoader._instance = WorkflowLoader(galaxy_instance)\n elif galaxy_instance:\n cls._logger.debug(\"Initializing the existing WorkflowLoader instance...\")\n WorkflowLoader._instance._initialize(galaxy_instance)\n return WorkflowLoader._instance", "def loadComponentFromURL( cUrl, tProperties=() ):\n StarDesktop = getDesktop()\n oDocument = StarDesktop.loadComponentFromURL( cUrl, \"_blank\", 0, tProperties )\n return oDocument", "def loadComponentFromURL( cUrl, tProperties=() ):\n StarDesktop = getDesktop()\n oDocument = StarDesktop.loadComponentFromURL( cUrl, \"_blank\", 0, tProperties )\n return oDocument" ]

[ "0.5845707", "0.55609673", "0.52667314", "0.51818883", "0.5164338", "0.5137516", "0.5066826", "0.5053414", "0.5036196", "0.49901026", "0.49768355", "0.49687746", "0.4964062", "0.49446085", "0.49446085", "0.48970905", "0.48545104", "0.48198324", "0.48110753", "0.48049742", "0.47993132", "0.47993132", "0.47993132", "0.47983548", "0.47976637", "0.47976637", "0.47592542", "0.47507975", "0.4747257", "0.4747257" ]

[ "def exists_for_view(self, view_id):\n raise NotImplementedError(\"calling abstract method\")", "def has_debug_view(name=None):\r\n for view in sublime.active_window().views():\r\n if is_debug_view(view):\r\n if name is not None:\r\n if view.name() == name:\r\n return True\r\n else:\r\n return True\r\n return False", "def has_view_permission(self, request, obj=None):\n return True\n opts = self.opts\n codename = get_permission_codename('view', opts)\n return any([\n request.user.has_perm(\"%s.%s\" % (opts.app_label, codename)),\n request.user.has_perm(\"%s.%s\" % (opts.app_label, codename), obj)])", "def is_view(self):\n return self._base is not None", "def is_db_view(db_table):\n if db_table in postgresql_views:\n return True\n return False", "def exists(self):\n try:\n select_template(self.get_paths())\n return True\n except TemplateDoesNotExist:\n return False", "def exists(self):\n return True", "def exists(self):\n return True", "def test_vote_exists(self):\n name_exists = 'vote' in self.views_module_listing\n is_callable = callable(self.views_module.vote)\n \n self.assertTrue(name_exists, f\"{FAILURE_HEADER}vote() view does not exist{FAILURE_FOOTER}\")\n self.assertTrue(is_callable, f\"{FAILURE_HEADER}vote() function does not exist or will not execute{FAILURE_FOOTER}\")", "def has_permission(self, request, view):\n return True", "def has_permission(self, request, view):\n return False", "def is_viewed(self):\n return self.has_label(VIEWED_LABEL)", "def test_VIEW_pass(self):\n for V in self.mod.views.itervalues():\n self.assertTrue(V.isset)", "def exists(path):\n return get_instance(path).exists(path)", "def exists(self):\r\n return os.path.exists(self.full_path)", "def exists(self):\n return self.path.exists()", "def exists(self, url):\n return (self.base_path / url).exists()", "def test_detail_exists(self):\n name_exists = 'detail' in self.views_module_listing\n is_callable = callable(self.views_module.detail)\n \n self.assertTrue(name_exists, f\"{FAILURE_HEADER}detail() view does not exist{FAILURE_FOOTER}\")\n self.assertTrue(is_callable, f\"{FAILURE_HEADER}detail() function does not exist or will not execute{FAILURE_FOOTER}\")", "def exists(self):\n return self.obj is not None", "def exists(self):\n return _os.path.exists(self.__str__())", "def is_element_in_view(self, element: Element) -> bool:\n return self.find_element_view(element=element) is not None", "def exists_task(self, task):\n assert task, \"Must input a valid task name.\"\n return any(self.get_by_task(task))", "def test_index_exists(self):\n name_exists = 'index' in self.views_module_listing\n is_callable = callable(self.views_module.index)\n \n self.assertTrue(name_exists, f\"{FAILURE_HEADER}index() view does not exist{FAILURE_FOOTER}\")\n self.assertTrue(is_callable, f\"{FAILURE_HEADER}index() function does not exist or will not execute{FAILURE_FOOTER}\")", "def exists(self) -> bool:\n p = pathlib.Path(self.summary_path)\n return p.exists()", "def exists(self, path: str) -> bool:\n pass", "def _is_drf_view(pattern):\n return hasattr(pattern.callback, 'cls') and issubclass(pattern.callback.cls,\n APIView)", "def exists(self) -> bool:\n doc_ref = self.doc_ref\n if isinstance(doc_ref, DocumentReference):\n return doc_ref.get().exists\n return False", "def exists(self):\n return self.islink() or exists(self._path)", "def Exists(self, path: str) -> bool:\n ...", "def exists(self) -> bool:\n try:\n result = self.get()\n except KeyError:\n return False\n return True" ]

[ "0.8074527", "0.70116293", "0.68193936", "0.66889185", "0.660105", "0.6589236", "0.6287463", "0.6287463", "0.6283923", "0.6276442", "0.62659264", "0.6244167", "0.623865", "0.6238351", "0.6232471", "0.6214478", "0.61842877", "0.6141818", "0.61366314", "0.6128516", "0.612039", "0.6117486", "0.6086874", "0.6066519", "0.6056968", "0.6037086", "0.60223305", "0.59939903", "0.59724456", "0.5956503" ]

[ "def create_view(name, fields=''):\n if '/' in name:\n blueprint_name, model_name = name.split('/')\n output_file = 'blueprints/%s/views.py' % blueprint_name\n else:\n model_name = name\n output_file = 'views.py'\n file_exists = os.path.exists(output_file)\n form_data = []\n for f in fields.split():\n form_data.append('form.%s.data' % f.split(':')[0])\n views = create_view.views_scaffold % dict(name=model_name.lower(),\n model_name=model_name.capitalize(),\n form_data=', '.join(form_data))\n with open(output_file, 'a') as out_file:\n if not file_exists:\n views = '''%(imports)s\\n%(rest)s''' % dict(imports=create_view.imports,\n rest=views)\n out_file.write(views)\n create_templates(name, fields)", "def create_view(self, view_name='', description='', fields=None, order=None, filters=''):\n res, _ = self.clients.resource_registry.find_resources(name=view_name, id_only=True)\n if len(res) > 0:\n raise BadRequest('The view resource with name: %s, already exists.' % view_name)\n\n #======================\n # Arg Validations\n #======================\n validate_is_instance(fields,list, 'Specified fields must be a list.')\n validate_true(len(fields)>0, 'Specfied fields must be a list.')\n if order is not None:\n validate_is_instance(order,list, 'Specified order must be a list of fields')\n for field in order:\n if not field in fields:\n raise BadRequest('The specified ordering field was not part of the search fields.')\n\n fields = set(fields) # Convert fields to a set for aggregation across the catalogs\n #======================================================================================================\n # Priorty Queue Index Matching\n #======================================================================================================\n\n pq = [] # Priority queue for matching\n catalog_id = None\n catalogs, _ = self.clients.resource_registry.find_resources(restype=RT.Catalog, id_only=False)\n for catalog in catalogs:\n if set(catalog.catalog_fields).issubset(fields):\n index_num = len(self.clients.catalog_management.list_indexes(catalog._id))\n heapq.heappush(pq, (index_num,catalog))\n if pq:\n weight, catalog = heapq.heappop(pq)\n if weight < self.heuristic_cutoff:\n catalog_id = catalog._id\n\n \n if catalog_id is None:\n catalog_id = self.clients.catalog_management.create_catalog('%s_catalog'% view_name, keywords=list(fields))\n\n view_res = View(name=view_name, description=description)\n view_res.order = order\n view_res.filters = filters\n view_id, _ = self.clients.resource_registry.create(view_res)\n self.clients.resource_registry.create_association(subject=view_id, predicate=PRED.hasCatalog,object=catalog_id)\n return view_id", "def createViews(views):\n ...", "def newEditorView(self, fn, caller, filetype=\"\", indexes=None):\n editor, assembly = self.cloneEditor(caller, filetype, fn)\n \n self._addView(assembly, fn, caller.getNoName(), indexes=indexes)\n self._modificationStatusChanged(editor.isModified(), editor)\n self._checkActions(editor)\n \n return editor", "def create_view(self, repo, view, sql):\n return self.user_con.create_view(\n repo=repo, view=view, sql=sql)", "def __newDocumentView(self):\n aw = self.activeWindow()\n if aw:\n self.newEditorView(aw.getFileName(), aw, aw.getFileType())", "def view(view_name, db=None, empty_ok=True, **kwargs):\n db_name = DEFAULT_DATABASE if db is None else db\n db = dbs[db_name]\n name = '%s%s/%s' % (db_name, DESIGN_DOC_SUFFIX, view_name)\n if empty_ok:\n return _view_empty_ok(db, name, kwargs)\n return db.view(name, **kwargs)", "def view(self, view_id):\r\n return resources.View(self, view_id)", "def _trait_view ( cls, name, view_element, default_name, view_elements,\n editable_traits ):\n # If a view element was passed instead of a name or None, return it:\n if isinstance( name, ViewElement ):\n return name\n\n # Get the ViewElements object associated with the class:\n view_elements = view_elements()\n\n # The following test should only succeed for objects created before\n # traits has been fully initialized (such as the default Handler):\n if view_elements is None:\n return None\n\n if name:\n if view_element is None:\n # If only a name was specified, return the ViewElement it\n # matches, if any:\n return view_elements.find( name )\n\n # Otherwise, save the specified ViewElement under the name\n # specified:\n view_elements.content[ name ] = view_element\n return\n\n # Get the default view/view name:\n name = default_name()\n\n # If the default is a View, return it:\n if isinstance( name, ViewElement ):\n return name\n\n # Otherwise, get all View objects associated with the object's class:\n names = view_elements.filter_by()\n\n # If the specified default name is in the list, return its View:\n if name in names:\n return view_elements.find( name )\n\n # If there is only one View, return it:\n if len( names ) == 1:\n return view_elements.find( names[0] )\n\n # Otherwise, create and return a View based on the set of editable\n # traits defined for the object:\n from enthought.traits.ui.api import View\n return View( editable_traits() )", "def creates_view(self):\n return self.statements[0].creates_view()", "def add_view(self, schema, create=True):\n if not constants.NAME_RX.match(schema[\"name\"]):\n raise ValueError(\"invalid view name\")\n if utils.name_in_nocase(schema[\"name\"], self.db[\"tables\"]):\n raise ValueError(\"name is already in use for a table\")\n if utils.name_in_nocase(schema[\"name\"], self.db[\"views\"]):\n raise ValueError(\"name is already in use for a view\")\n if create:\n sql = 'CREATE VIEW \"%s\" AS %s' % (\n schema[\"name\"],\n dbshare.query.get_sql_statement(schema[\"query\"]),\n )\n self.dbcnx.execute(sql)\n cursor = self.dbcnx.cursor()\n try:\n sql = 'PRAGMA table_info(\"%s\")' % schema[\"name\"]\n cursor.execute(sql)\n except sqlite3.Error: # Invalid view\n sql = 'DROP VIEW \"%s\"' % schema[\"name\"]\n cursor.execute(sql)\n raise ValueError(\"invalid view; maybe non-existent column?\")\n # Source names considering quotes and disregarding AS part, if any.\n schema[\"sources\"] = dbshare.query.get_from_sources(schema[\"query\"][\"from\"])\n schema[\"columns\"] = [{\"name\": row[1], \"type\": row[2]} for row in cursor]\n sql = \"INSERT INTO %s (name, schema) VALUES (?,?)\" % constants.VIEWS\n with self.dbcnx:\n self.dbcnx.execute(sql, (schema[\"name\"], json.dumps(schema)))\n self.db[\"views\"][schema[\"name\"]] = schema", "def register_view(self, viewfunc, url_rule=None) :\n\n\t\tviewid = View.parse_id(viewfunc, self.settings.VIEW_ROOT)\n\t\t\n\t\tif viewid not in self.views :\n\t\t\t# Add view if not exists\n\t\t\tv = View(\n\t\t\t\tid = viewid,\n\t\t\t\tviewfunc = viewfunc,\n\t\t\t\turl_rule = url_rule,\n\t\t\t)\n\t\t\tself.views[viewid] = v\n\n\t\telse :\n\t\t\t# Update view if exists\n\t\t\tv = self.views[viewid]\n\t\t\tv.viewfunc = viewfunc\n\n\t\t\tif url_rule is not None :\n\t\t\t\tv.url_rule = url_rule\n\n\t\treturn v", "def _create_or_alter_view(self, survey_data):\n self.log.info(\"Creating or altering view vw_AllSurveyData \")\n edit_view = self._get_query('edit_view') + \"( \" + survey_data + \" )\"\n self.db.execute_query(edit_view)\n self.log.info(\"View was edited successfully\")", "def addViewToDb(self,name):\n\t\tsql = \"INSERT INTO hudson_views(viewname) VALUES (%s)\"\n\t\tcsr = self.db.cursor()\n\t\tcsr.execute(sql,[name])", "def make_view(app, view_class=View, view_name='View', **kwargs):\n kwargs.update({'__app__': app})\n return type(view_name, (view_class, ), kwargs)", "def test_migrate_view_fields(self):\n self.test_view = RecordView.create(\n self.testcoll, test_view_id, test_view_create_values\n )\n migrate_coll_data(self.testcoll)\n # Read field definition and check for inline field list\n view_data = self.check_entity_values(\n \"_view\", test_view_id, check_values=test_view_migrated_values\n )\n return", "def _create_from_template(self):\n template_file = self._helper._get_template_file_path()\n self._engine.open_file_by_path(template_file)\n self._save_current_as_new()", "def saveViews(lib, filename='views', path=os.path.expanduser('~')):\n ext = '.camera'\n os.chdir(path)\n f = open(filename + ext, 'wb')\n pickle.dump(lib, f, pickle.HIGHEST_PROTOCOL)\n f.close()", "def create_or_replace_view(self, relation) -> None:\n database = self.quoted(self._correct_case(relation.database))\n schema = self.quoted(self._correct_case(relation.schema))\n ddl_statement = f\"\"\"CREATE OR REPLACE VIEW\n{self.quoted_dot_notation(relation)}\nAS\n{relation.view_ddl}\n\"\"\"\n engine = self.get_connection(database_override=database,\n schema_override=schema)\n try:\n engine.execute(ddl_statement)\n except Exception as exc:\n logger.info(\"Failed to create %s %s:%s\", relation.materialization.name,\n self.quoted_dot_notation(relation),\n exc)\n raise exc\n logger.info('Created relation %s', self.quoted_dot_notation(relation))", "def render(self, filename: str, view: bool = False) -> None:\n self._dot.render(filename, view=view)", "def validate_view_naming(view_file):\n parsed = sqlparse.parse(view_file.read_text())[0]\n tokens = [\n t\n for t in parsed.tokens\n if not (t.is_whitespace or isinstance(t, sqlparse.sql.Comment))\n ]\n is_view_statement = (\n \" \".join(tokens[0].normalized.split()) == \"CREATE OR REPLACE\"\n and tokens[1].normalized == \"VIEW\"\n )\n if is_view_statement:\n target_view = str(tokens[2]).strip().split()[0]\n try:\n [project_id, dataset_id, view_id] = target_view.replace(\"`\", \"\").split(\".\")\n if not (\n view_file.parent.name == view_id\n and view_file.parent.parent.name == dataset_id\n and view_file.parent.parent.parent.name == project_id\n ):\n print(\n f\"{view_file} ERROR\\n\"\n f\"View name {target_view} not matching directory structure.\"\n )\n return False\n except Exception:\n print(f\"{view_file} ERROR\\n{target_view} missing project ID qualifier.\")\n return False\n else:\n print(\n f\"ERROR: {view_file} does not appear to be \"\n \"a CREATE OR REPLACE VIEW statement! Quitting...\"\n )\n return False\n return True", "def mkview(self,\n context=[],\n viewobj=None):\n if viewobj == None:\n raise ValueError, \"mkview: viewobj is None\"\n return jsoncall.do_call(\"mkview\", {'modelname':self.modelname,\\\n 'user':self.user,\\\n 'password':self.password,\\\n 'context':context,\\\n 'viewobj':viewobj.__dict__},\n self.connection)", "def _create_view(self, view, schema=None, config=None):\n viewname, vschema = view[\"__tablename__\"].split(' ')[0], view[\"__schema__\"].split(' ')[0]\n try:\n dve = SQL('NULL from {}.{}').format(Identifier(vschema),\n Identifier(viewname))\n veq = self.__session.query(self._sql_to_string(dve)).limit(1)\n self.__session.execute(veq)\n self._commit()\n except ProgrammingError:\n self._rollback()\n like = text(\"information_schema.routines.routine_name like 'crosstab%'\")\n count = self.__session.query('* FROM information_schema.routines')\n count = count.filter(like).count()\n if int(count) == 0:\n self._create_extension(config)\n self.exschema = 'public'\n else:\n like = text(\"information_schema.routines.routine_name like 'crosstab%'\")\n count = self.__session.query('routine_schema FROM'\n ' information_schema.routines')\n count = count.filter(like).limit(1)\n count = self.__session.execute(count).fetchone()[0]\n self._commit()\n self.exschema = count\n like = text(\"SELECT has_schema_privilege(:exschema, 'USAGE')\")\n like = self.__session.execute(like,\n {\"exschema\": self.exschema}).fetchone()[0]\n self._commit()\n if not like:\n self._grant_access(config)\n viewst, raw = self._sql_to_string(view[\"__statement__\"]), '{}.crosstab'\n defsch = self._sql_to_string(SQL(raw).format(Identifier(schema)))\n exsch = SQL(raw).format(Identifier(self.exschema))\n self.__session.execute(viewst.replace(defsch, self._sql_to_string(exsch)))\n self._commit()\n except Exception:\n self._rollback()\n self._reset_session()\n raise", "def view(name, selectable, *, clear: bool = False):\n log.debug('view(%r, clear=%r)', name, clear)\n\n if clear:\n DDL[name] = None, None\n return None\n\n DDL[name] = (CreateView(name, selectable),\n DropView(name))\n\n return make_table(selectable, name=name)", "def DEADcreate_v_fix_view():\n sql_view = \"\"\"create or replace view v_fix as\n SELECT \n fix.fix_ident, \n fix.fix_center,\n ST_Y(ST_Transform(fix.fix_center, 4326)) as fix_lat84,\n ST_X(ST_Transform(fix.fix_center, 4326)) as fix_lon84\n \n FROM \n fix\"\"\"\n conf.Cur.execute(sql_view)\n conf.Con.commit()", "def view(self, viewname, **data):\n view = self.mylookup.get_template(viewname + '.mako').render(**data)\n \n self.res.status = 202\n self.res.content_type = 'text/html'\n self.res.content_length = len(view)\n \n self.start_response(self.res.status, self.res.headerlist)\n return view", "def create_revision(self, model_definition_uid):\n WMLResource._chk_and_block_create_update_for_python36(self)\n\n if self._client.ICP_30 is None and not self._client.CLOUD_PLATFORM_SPACES and not self._client.ICP_PLATFORM_SPACES:\n raise WMLClientError(\n u'Revisions APIs are not supported in this release.')\n\n self._client._check_if_either_is_set()\n\n model_defn_id = str_type_conv(model_definition_uid)\n ModelDefinition._validate_type(model_defn_id, u'model_defn_id', STR_TYPE, True)\n\n print(\"Creating model_definition revision...\")\n\n # return self._get_required_element_from_response(\n # self._create_revision_artifact_for_assets(model_defn_id, 'Model definition'))\n\n response = self._get_required_element_from_response(\n self._create_revision_artifact_for_assets(model_defn_id, 'Model definition'))\n\n if not self._client.CLOUD_PLATFORM_SPACES and not self._client.ICP_PLATFORM_SPACES:\n return response\n else:\n entity = response[u'entity']\n\n try:\n del entity[u'wml_model_definition'][u'ml_version']\n except KeyError:\n pass\n\n final_response = {\n \"metadata\": response[u'metadata'],\n \"entity\": entity\n }\n\n return final_response", "def create_view(self):\n title_label = Label(self, text='Upload, Preview, Describe and Visualize',\n fg='blue', font=('Arial', 16))\n title_label.pack(fill=BOTH, expand=True)\n select_file_button = Button(self, background='White', text='Select Data File [.csv, .xlsx, .xls, .json, .txt]',\n command=self.start_upload)\n select_file_button.pack(padx=5, pady=10)", "def loadViews(filename='views.camera', path=os.path.expanduser('~')):\n os.chdir(path)\n with open(filename, 'rb') as f:\n return pickle.load(f)", "def create(cls, xml):\n raise Exception('Not Implemented Yet')" ]

[ "0.59218645", "0.5722048", "0.5537454", "0.5507403", "0.54620814", "0.54460394", "0.5323818", "0.53216887", "0.5261694", "0.52564645", "0.5204779", "0.5170237", "0.5099098", "0.5052455", "0.50478405", "0.50409013", "0.50351095", "0.50225526", "0.50119054", "0.49706888", "0.49474493", "0.49418244", "0.49392807", "0.49227813", "0.49002323", "0.48775333", "0.48600185", "0.484708", "0.48421258", "0.48366874" ]

[ "def job_exists(self, job_id):\n\n return True if self.get_status(job_id) else False", "def exists(cls, job_id: str, connection: Optional['Redis'] = None) -> bool:\n if not connection:\n connection = resolve_connection()\n job_key = cls.key_for(job_id)\n job_exists = connection.exists(job_key)\n return bool(job_exists)", "def isJobRunning ( self ):\n #cmd = \"qstat \" + str(self.jobid)\n \n #magicString='Unknown Job Id' ### magicString _might_ need to be changed if Torque version changes\n #(output, error) = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()\n\n if self.ofile_exists(): #output.find(magicString) >=0 or redhawkStatsRe.search(output):\n self.status = \"finished\"\n return False\n \n\n return True", "def test_job_exists():\n with tempfile.TemporaryDirectory() as STATUS_DIR:\n Status.add_job(STATUS_DIR, 'generation', 'test1',\n job_attrs={'job_status': 'submitted'})\n exists = Status.job_exists(STATUS_DIR, 'test1')\n assert exists", "def exists(self):\r\n return bool(self.bucket.lookup(self.name))", "def check_job_exists( job_list, analysis_group_id, reprocess_config_id):\n for job in job_list:\n struct = JSONMessage.unserialize(job.input_message)\n\n if( int( struct.analysis_group_id ) == int( analysis_group_id ) and \\\n int( struct.reprocess_config_id ) == int( reprocess_config_id ) ):\n return 1\n return 0", "def exists(self, prefix, args=()):\n file_path = self.path(prefix, args)\n return os.path.isfile(file_path)", "def in_queue(self):\n if self.get_db('jobid') is None:\n log.debug('jobid not found for calculation.')\n return False\n else:\n # get the jobid\n jobid = self.get_db('jobid')\n # see if jobid is in queue\n _, jobids_in_queue, _ = getstatusoutput('qselect',\n stdout=subprocess.PIPE,\n stderr=subprocess.PIPE)\n\n if str(jobid) in jobids_in_queue.split('\\n'):\n # get details on specific jobid in case it is complete\n status, output, err = getstatusoutput(['qstat', jobid],\n stdout=subprocess.PIPE,\n stderr=subprocess.PIPE)\n if status == 0:\n lines = output.split('\\n')\n fields = lines[2].split()\n job_status = fields[4]\n if job_status == 'C':\n return False\n else:\n return True\n else:\n return False", "def exists(self):\n return self.path.exists()", "def _check_queryinfo_existence(self, hostname: str, job: str) -> bool:\n with self.lock:\n hosts = self.host_query_info.all()\n for host in hosts:\n if host['hostname'] == hostname and host['job'] == job:\n return True\n return False", "def exists(self):\n return _os.path.exists(self.__str__())", "def batch_job_running(self, name):\n if name not in self.batch_jobs:\n raise ValueError(\"job {} doesn't exists\".format(name))\n return name in self.jobs", "def pid_exists(self, job_id):\n ## class QueuePage()\n pid = mysql.job_get_pid(job_id)\n if pid == None:\n ## job PID somehow did not get stored in the database, so return\n ## False => state='syserror'; job may still be running!\n return False\n else:\n pid = int(pid)\n try:\n #os.kill(pid, 0) ## This does not work, 2009-05-27\n ## NOTE: Three possible results:\n ## (1): os.kill(pid, 0) -> None: process exists, and you are process\n ## owner or root\n ## (2): os.kill(pid, 0) -> OSError, Operation not permitted:\n ## process exists, you are not owner or root\n ## (3): os.kill(pid, 0) -> OSError, No such process:\n ## process does not exist\n if os.path.exists(\"/proc/%s\" % pid):\n return True ## process is still running\n return False\n except:\n return False", "def isThisJobFinished(self, identifier):\n identifier = identifier.strip()\n with self.__queueLock:\n # Look through the finished jobs and attempt to find a matching\n # identifier. If the job exists here, it is finished\n for run in self.__finished:\n if run.identifier == identifier:\n return True\n\n # Look through the pending jobs and attempt to find a matching identifier\n # If the job exists here, it is not finished\n for queue in [self.__queue, self.__clientQueue]:\n for run in queue:\n if run.identifier == identifier:\n return False\n\n # Look through the running jobs and attempt to find a matching identifier\n # If the job exists here, it is not finished\n for run in self.__running+self.__clientRunning:\n if run is not None and run.identifier == identifier:\n return False\n\n # If you made it here and we still have not found anything, we have got\n # problems.\n self.raiseAnError(RuntimeError,\"Job \"+identifier+\" is unknown!\")", "def checkjob(sid, jid):\n with slycat.web.server.remote.get_session(sid) as session:\n return session.checkjob(jid)", "def exists(self) -> bool:\n try:\n result = self.get()\n except KeyError:\n return False\n return True", "def exists(self):\r\n return os.path.exists(self.full_path)", "def remove_job_if_exists(name: str, context: ContextTypes.DEFAULT_TYPE) -> bool:\n current_jobs = context.job_queue.get_jobs_by_name(name)\n if not current_jobs:\n return False\n for job in current_jobs:\n job.schedule_removal()\n return True", "def is_job_running(self, condor_id):\n\n classads = self.get_classads(\"OSGRSVUniqueName==\\\"%s\\\"\" % condor_id)\n\n if classads is None:\n self.rsv.log(\"ERROR\", \"Could not determine if job is running\")\n return False\n\n for classad in classads:\n # We put the attribute into the classad in quotes, so search for it accordingly\n if classad[\"OSGRSVUniqueName\"] == '\"' + condor_id + '\"':\n return True\n\n return False", "def exists(self):\n\n return os.path.exists(self.path)", "def exists(self):\n return True", "def exists(self):\n return True", "def verify_job(cls, auth_key, job_id):\n key = ObjectId(job_id)\n user_id = ObjectId(auth_key)\n db = cls.mongo_cli.get_database(collection=Job.collection_name)\n if db.count({\"_id\": key, \"user_id\": user_id}) > 0:\n return True\n return False", "def remove_job_if_exists(self, name: str, context: CallbackContext) -> bool:\n current_jobs = context.job_queue.get_jobs_by_name(name)\n if not current_jobs:\n return False\n for job in current_jobs:\n job.schedule_removal()\n return True", "def remove_job_if_exists(self, name: str, context: CallbackContext) -> bool:\n current_jobs = context.job_queue.get_jobs_by_name(name)\n if not current_jobs:\n return False\n for job in current_jobs:\n job.schedule_removal()\n return True", "def exists(self):\n return bool(self.get())", "def remove_job_if_exists(name, context):\n current_jobs = context.job_queue.get_jobs_by_name(name)\n if not current_jobs:\n return False\n for job in current_jobs:\n job.schedule_removal()\n return True", "def queue_exists(name: str) -> bool:\n try:\n batch = aws.client_with_default_region(\"batch\")\n\n return bool(\n batch.describe_job_queues(jobQueues = [name]) \\\n .get(\"jobQueues\"))\n except:\n return False", "def exists(self) -> bool:\n return self._file_exists()", "def exists(self):\n return os.path.isfile(self.location)" ]

[ "0.8646111", "0.80569893", "0.69944775", "0.6987492", "0.6604774", "0.654603", "0.6538874", "0.65194386", "0.6514213", "0.6511255", "0.64722615", "0.64207816", "0.6419019", "0.6390656", "0.63874865", "0.63817424", "0.6360946", "0.63050056", "0.63043344", "0.62540364", "0.6230864", "0.6230864", "0.6206416", "0.6196641", "0.6196641", "0.6193515", "0.61923015", "0.6178714", "0.61785465", "0.6163299" ]

[ "def delete_job(self, job, context=None):\n return self._client.call_method(\n 'UserAndJobState.delete_job',\n [job], self._service_ver, context)", "def delete(job_id):\n job = JobModel.get_one_job(job_id)\n if not job:\n return custom_response({'Error':'Job Not Found'}, 404)\n\n JobModel.query.filter(JobModel.job_id == job_id).delete()\n\n return custom_response({'Message': 'Deleted'}, 204)", "def delete(\n address: Optional[str],\n job_id: str,\n headers: Optional[str],\n verify: Union[bool, str],\n):\n client = _get_sdk_client(address, headers=headers, verify=verify)\n client.delete_job(job_id)\n cli_logger.print(f\"Job '{job_id}' deleted successfully\")", "def DeleteJob(self, job_urn, token=None):\n aff4.FACTORY.Delete(job_urn, token=token)", "def delete_job(self, jobid=None, squash=None):\n\n self.check_all_jobs()\n\n if jobid is None:\n if hasattr(self, 'current_job'):\n jobid = self.current_job\n\n if jobid:\n if hasattr(self, 'current_job'):\n if jobid == self.current_job:\n del self.current_job\n\n if self.job_dict[jobid] in ['COMPLETED', 'ERROR',\n 'ABORTED', 'PENDING']:\n result = self.session.delete(\n CosmoSim.QUERY_URL + \"/{}\".format(jobid),\n auth=(self.username, self.password), data={'follow': ''})\n\n else:\n warnings.warn(\"Can only delete a job with phase: \"\n \"'COMPLETED', 'ERROR', 'ABORTED', or 'PENDING'.\")\n return\n\n if not result.ok:\n result.raise_for_status()\n if squash is None:\n warnings.warn('Deleted job: {}'.format(jobid))\n\n return result", "def _delete_job(self, job):", "def deleteJob(self, jobId):\n params = {'id': jobId}\n try:\n return self.gc.delete(JobUtils.JOB_ID_PATH, parameters=params)\n except HttpError as e:\n if e.status == 400:\n print('Error. invalid job id:', jobId)\n return {}\n raise", "def _delete_job(self, job):\n with self.db_lock:\n return self.rcon.zrem(job)", "def job_delete(job):\n\n if os.path.exists(job.output_abspath):\n os.remove(job.output_abspath)\n db.session.delete(job)\n db.session.commit()", "def delete(self, job_id):\n # Only admin can delete any job\n if not current_user.is_admin():\n return get_message_json('删除任务需要管理员权限'), HTTPStatus.FORBIDDEN\n\n try:\n result = jobs.delete_job_by_id(job_id)\n if result == 1:\n return get_message_json('已删除该任务'), HTTPStatus.OK\n else:\n if jobs.find_job_by_id(job_id) is None:\n return get_message_json('任务不存在'), HTTPStatus.NOT_FOUND\n return get_message_json('未知的任务删除失败'), HTTPStatus.BAD_REQUEST\n except Exception as err:\n return handle_internal_error(str(err))", "def delete_job(self, filename):\n job = Jobs.get(Jobs.filename == filename)\n job.delete_instance()", "def delete_job(api_instance, job_name):\n api_response = api_instance.delete_namespaced_job(\n name=job_name,\n namespace=\"default\",\n body=client.V1DeleteOptions(\n propagation_policy=\"Foreground\", grace_period_seconds=5\n ),\n )\n logger.info(\"Job deleted with status='%s'\" % str(api_response.status))", "def delete_job(request, job_id):\n job = get_object_or_404(Jobs, pk=job_id)\n\n if request.user.id != job.author.id:\n messages.error(request, 'You can only delete your own job profiles')\n return redirect(reverse('view_home'))\n\n job.delete()\n messages.success(request, 'You have successfully deleted the job profile!')\n return redirect(reverse('all_jobs'))", "def cmd_delete_job():\r\n id = request.form.get('id', \"\")\r\n confirm = request.form.get(\"confirm\", \"\")\r\n if confirm != \"DELETE\":\r\n flash(f\"Contact '{id}' NOT deleted. Please enter DELETE in the confirm field.\")\r\n return redirect(url_for('main.jobs'))\r\n \r\n index = get_job_by_id(id)\r\n Job.query.filter(Job.id == id).delete()\r\n db.session.commit()\r\n\r\n\r\n if index != None:\r\n flash(f\"Job '{id}' was succesfully deleted!\")\r\n return redirect(url_for('main.jobs'))\r\n else:\r\n flash(f\"Job '{id}' was not found\")\r\n return redirect(url_for('main.jobs'))", "def delete_dlp_job(project, job_name):\n\n # Import the client library.\n import google.cloud.dlp\n\n # Instantiate a client.\n dlp = google.cloud.dlp.DlpServiceClient()\n\n # Convert the project id and job name into a full resource id.\n name = dlp.dlp_job_path(project, job_name)\n\n # Call the API to delete job.\n dlp.delete_dlp_job(name)\n\n print('Successfully deleted %s' % job_name)", "def delete_job():\r\n id = request.args.get('id', \"\")\r\n return render_template(\"delete_job.html\", id=id)", "def delete(self):\n parser = reqparse.RequestParser()\n parser.add_argument(\"job_id\", type=str, location=\"form\")\n args = parser.parse_args()\n job_id = args[\"job_id\"]\n if job_id is None or job_id == \"\":\n return errors.all_errors(\n \"CLIENT_MISSING_PARAMETER\", \"job_id (str) parameter is required\"\n )\n\n get_job_info = get(\n config.Config.FLASK_ENDPOINT + \"/api/scheduler/job\",\n headers={\"X-SOCA-TOKEN\": config.Config.API_ROOT_KEY},\n params={\"job_id\": job_id},\n verify=False,\n ) # nosec\n\n if get_job_info.status_code != 200:\n return {\n \"success\": False,\n \"message\": \"Unable to retrieve this job. Job may have terminated\",\n }, 500\n else:\n job_info = get_job_info.json()[\"message\"]\n job_owner = job_info[\"Job_Owner\"].split(\"@\")[0]\n request_user = request.headers.get(\"X-SOCA-USER\")\n if request_user is None:\n return errors.all_errors(\"X-SOCA-USER_MISSING\")\n if request_user != job_owner:\n return errors.all_errors(\"CLIENT_NOT_OWNER\")\n try:\n qdel_command = config.Config.PBS_QDEL + \" \" + job_id\n try:\n delete_job = subprocess.check_output(shlex.split(qdel_command))\n return {\"success\": True, \"message\": \"Job deleted\"}\n except Exception as err:\n return {\n \"success\": False,\n \"message\": \"Unable to execute qdel command: \" + str(err),\n }, 500\n\n except Exception as err:\n return {\"success\": False, \"message\": \"Unknown error: \" + str(err)}, 500", "def removeJob(self):\n job, name = self.getJob() \n answer = tkMessageBox.askyesno(\"Warning\",'Remove this job?')\n if answer == False:\n return \n try: \n self.jobManager.deleteJob(job)\n except:\n print 'job not in database, removing from peat'\n del self.DB.meta.peatsa_jobs[name]\n self.DB.meta.__p__changed = 1\n self.updateJobs()\n return", "def remove_job(job_id):\n subprocess.check_call(['atrm', str(job_id)])\n return job_id", "def delete_job(self, id, jobstore=None):\n\n self._scheduler.remove_job(id, jobstore)", "def delete_job_by_id(self, job_id):\n try:\n self._session.query(JobEntity).\\\n filter(JobEntity.id == job_id).\\\n delete(synchronize_session=False)\n except SQLAlchemyError as err:\n Log.an().error('sql exception [%s]', str(err))\n return False\n\n return True", "def remove(self, job_or_id):\n if isinstance(job_or_id, Job):\n job = job_or_id\n else:\n job = Job(connection=self.connection, id=job_or_id)\n\n try:\n job.refresh()\n job._delete()\n except NoSuchJobError:\n pass\n\n self._remove(job.id)", "def cancel_job(self, job):\n try:\n self.jobs.remove(job)\n except ValueError:\n pass", "def delete(job, cmt=None, config_file=config_file):\n # Calling config file\n cf = config.ReadFile(config_file)\n user = cf[\"authentication\"][\"user\"]\n\n cron = CronTab(user=user)\n cron.remove_all(job)\n cron.remove_all(comment=cmt)", "def delete(self, jobs):\n assert isinstance(jobs, list), 'Jobs must be a list'\n assert len(jobs) > 0, 'One or more jobs required'\n\n req = list()\n if len(jobs) > 1:\n for r in self._batch_request(jobs):\n req.append(\n ''.join([self._scheduler_endpoint, '?', '&'.join(r)]))\n else:\n req = \"{}?job={}\".format(\n self._scheduler_endpoint, jobs[0])\n\n try:\n self._api_delete(req)\n except HTTPError as e:\n raise JobClientError(e.message)", "def delete_vmware_protection_job(job_name, delete_snapshots=True):\n try:\n cohesity_client = _get_client()\n jobs = cohesity_client.protection_jobs.get_protection_jobs(\n is_deleted=False, names=job_name)\n if not jobs:\n return \"Job with name {} not available.\".format(job_name)\n for job in jobs:\n if job.name == job_name:\n job_id = job.id\n break\n if not job_id:\n return \"Job with name {} not available.\".format(job_name)\n # Get recent job run id and status.\n body = DeleteProtectionJobParam()\n body.delete_snapshots = delete_snapshots\n cohesity_client.protection_jobs.delete_protection_job(job_id, body)\n return \"Successfully deleted job {}\".format(job_name)\n except APIException as err:\n return \"Error while attempting to delete the job {}, error : {}\".format(\n job_name, err)", "def delete_jobs(self, job_ids=['JID_CLEARALL']):\n return self._job_mgmt.delete_jobs(job_ids)", "def _remove(self, job_id):\n self.connection._lrem(self.key, 1, job_id)", "def delete_job_step_by_job_id(self, job_id):\n try:\n self._session.query(JobStepEntity).\\\n filter(JobStepEntity.job_id == job_id).\\\n delete(synchronize_session=False)\n except SQLAlchemyError as err:\n Log.an().error('sql exception [%s]', str(err))\n return False\n\n return True", "def kill_job(self, job):\n\n if job.status == Job.STATUS_QUEUED:\n # case 1: job is in QUEUED state\n # remove it from the queue and mark as killed\n\n job_queue = job_queue_name(job.model)\n logger.info(\n \"killing job {} by removing from queue {}\".\n format(job.uuid, job_queue))\n\n command_dict = {'command': 'PROCESS_JOB', 'job_uuid': job.uuid}\n remove_command(redis_connection(), job_queue, command_dict)\n job.status = Job.STATUS_KILLED\n # save it\n Job[job.uuid] = job\n elif job.status == Job.STATUS_RUNNING:\n # case 2: job is in RUNNING state\n # send message to worker to kill the job\n worker = worker_name(job.worker_url, job.model)\n worker_channel = node_channel_name(worker)\n logger.info(\"sending command to kill job on channel {}\".\n format(worker_channel))\n command_dict = {'command': \"KILL_JOB\", 'job_uuid': job.uuid}\n publish_command(redis_connection(), worker_channel, command_dict)\n else:\n logger.info(\"kill called on job {} in incompatible state {}\".\n format(job.uuid, job.status))" ]

[ "0.7612383", "0.75631183", "0.75325656", "0.7520281", "0.74776965", "0.7339835", "0.73373073", "0.73164237", "0.7306595", "0.71888834", "0.70548284", "0.6966155", "0.69645363", "0.69290483", "0.6865273", "0.6846396", "0.682398", "0.6734061", "0.6658749", "0.6615366", "0.65832365", "0.65469056", "0.654216", "0.6523422", "0.64868456", "0.64190954", "0.6418003", "0.64175516", "0.6415986", "0.64063144" ]

[ "def trigger(builder, revision, files=[], dry_run=False, extra_properties=None):\n repo_name = query_repo_name_from_buildername(builder)\n return buildapi.trigger_arbitrary_job(repo_name, builder, revision, files, dry_run,\n extra_properties)", "def trigger_labeling_job(input_batch_id, batch_id, job_params):\n\n job_input = input_config_to_job_input(\n input_batch_id, job_params[\"jobName\"], job_params[\"jobLevel\"], job_params[\"inputConfig\"]\n )\n\n if job_params[\"jobType\"] == SmgtJobType.BATCH:\n trigger_batch_job(batch_id, job_input, job_params)", "def trigger_job(self, job_id, auth_token=RUNDECK_AUTH_TOKEN, argString=None):\n self.headers['X-Rundeck-Auth-Token'] = auth_token\n if argString:\n payload = {\"argString\": argString}\n self.job_response = requests.post(json=payload,\n url= \"{}/job/{}/run\".format(self.api,job_id),\n headers = self.headers)\n\n else:\n self.job_response = requests.post(url=\"{}/job/{}/run\".format(self.api, job_id),\n headers=self.headers)", "def do_job(self, job_id, job_param):\n raise NotImplementedError(\"should be implemented in inherited class\")", "def executor(self, job):\n job.connect(self)\n job.trigger(wait=True, **job.trigger_args) # Wait until job is ready\n job.start() # Notify star of job\n # Run specific action for this job\n job.action(**job.action_args)", "def execute(self, job):\n raise NotImplementedError", "def trigger(hass, event, value1=None, value2=None, value3=None):\n data = {\n ATTR_EVENT: event,\n ATTR_VALUE1: value1,\n ATTR_VALUE2: value2,\n ATTR_VALUE3: value3,\n }\n hass.services.call(DOMAIN, SERVICE_TRIGGER, data)", "def trigger(self, journey_id, step_id, data):\n self.journey_id = journey_id\n self.step_id = step_id\n if 'email_address' not in data:\n raise KeyError('The automation email queue must have an email_address')\n\n check_email(data['email_address'])\n response = self._mc_client._post(\n url=self._build_path(\"journeys\", journey_id, 'steps', step_id, 'actions', \"trigger\"),\n data=data\n )\n\n return response", "def Trigger(self):\n\t\tpayload = { \"Arg1\": self.href }\n\t\treturn self._execute('trigger', payload=payload, response_object=None)", "def send(self, trigger, **kwargs):\n temp_data = {}\n for key, value in kwargs.iteritems():\n temp_data[key] = value\n self.evt.sendMessage(trigger, data=temp_data)", "def modify_job(self, job, parameter):\n job.set_encut(parameter[0])\n job.set_kpoints(parameter[1])\n return job", "def __trigger(self, toBeExecuted, args = []):\n\n self.__connect()\n [ f(args) for f in toBeExecuted ]\n self.__disconnect()", "def modify_job(self, id, jobstore=None, **changes):\n\n fix_job_def(changes)\n\n if 'trigger' in changes:\n trigger, trigger_args = pop_trigger(changes)\n self._scheduler.reschedule_job(id, jobstore, trigger, **trigger_args)\n\n return self._scheduler.modify_job(id, jobstore, **changes)", "def build_trigger(ctx, build_type_id, branch, comment, parameter, agent_id,\n open_build_log, wait_for_run):\n parameters = dict([p.split('=', 1) for p in parameter])\n data = ctx.obj.trigger_build(\n build_type_id=build_type_id,\n branch=branch,\n comment=comment,\n parameters=parameters,\n agent_id=agent_id)\n build_id = data['id']\n ctx.invoke(build_queue_show, args=[build_id])\n if open_build_log:\n url = data['webUrl'] + '&tab=buildLog'\n webbrowser.open(url)\n if not wait_for_run:\n return\n while data['state'] == 'queued':\n data = ctx.obj.get_queued_build_by_build_id(build_id)\n click.echo('state: %s' % data['state'])\n time.sleep(1)\n ctx.invoke(build_queue_show, args=[build_id])", "def _run_a_job(self,\n job: 'JobAdapter',\n label: str,\n rerun: bool = False,\n ):\n self.run_job(job_type=job.job_type,\n conformer=job.conformer,\n cpu_cores=job.cpu_cores,\n dihedrals=job.dihedrals,\n directed_scan_type=job.directed_scan_type,\n ess_trsh_methods=job.ess_trsh_methods,\n fine=job.fine,\n irc_direction=job.irc_direction,\n job_adapter=job.job_adapter,\n label=label,\n level_of_theory=job.level,\n memory=job.job_memory_gb,\n max_job_time=job.max_job_time,\n rotor_index=job.rotor_index,\n reactions=job.reactions,\n trsh=list(job.args['trsh'].values()) if 'trsh' in job.args else '',\n torsions=job.torsions,\n times_rerun=job.times_rerun + int(rerun),\n tsg=job.tsg,\n xyz=job.xyz,\n )", "def fix_trigger(self, kwargs):\n trigger_kwargs = self.get_trigger_kwargs(**kwargs)\n if kwargs[\"trigger\"] == \"interval\":\n kwargs[\"trigger\"] = apscheduler.triggers.interval.IntervalTrigger(**trigger_kwargs)\n elif kwargs[\"trigger\"] == \"date\":\n kwargs[\"trigger\"] = apscheduler.triggers.date.DateTrigger(**trigger_kwargs)\n elif kwargs[\"trigger\"] == \"cron\":\n kwargs[\"trigger\"] = apscheduler.triggers.cron.CronTrigger(**trigger_kwargs)\n return kwargs", "def task_trigger(self, args):\n h, tmp = tempfile.mkstemp(\n dir=self._tmpdir, prefix='trigger_raw', suffix='.json')\n os.close(h)\n cmd = [\n '-user',\n 'joe@localhost',\n '-d',\n 'pool=default',\n '-dump-json',\n tmp,\n ]\n cmd.extend(args)\n assert not self._run_swarming('trigger',\n cmd), 'Failed to trigger a task. cmd=%s' % cmd\n with open(tmp, 'rb') as f:\n data = json.load(f)\n task_id = data['tasks'][0]['task_id']\n logging.debug('task_id = %s', task_id)\n return task_id", "def fire_trigger(self, trigger):\n if not self.exists():\n return\n if trigger in self.events:\n for action in self.events[trigger]:\n action(requestor=self)", "def run(\n self,\n cause: str = None,\n account_id: int = None,\n job_id: int = None,\n token: str = None,\n additional_args: dict = None,\n account_id_env_var_name: str = \"ACCOUNT_ID\",\n job_id_env_var_name: str = \"JOB_ID\",\n token_env_var_name: str = \"DBT_CLOUD_TOKEN\",\n wait_for_job_run_completion: bool = False,\n max_wait_time: int = None,\n domain: str = None,\n ) -> dict:\n if cause is None:\n raise ValueError(\n \"\"\"\n Cause cannot be None.\n Please provide a cause to trigger the dbt Cloud job.\n \"\"\"\n )\n\n if account_id is None and account_id_env_var_name in os.environ:\n account_id = int(os.environ[account_id_env_var_name])\n\n if account_id is None:\n raise ValueError(\n \"\"\"\n dbt Cloud Account ID cannot be None.\n Please provide an Account ID or the name of the env var that contains it.\n \"\"\"\n )\n\n if job_id is None and job_id_env_var_name in os.environ:\n job_id = int(os.environ[job_id_env_var_name])\n\n if job_id is None:\n raise ValueError(\n \"\"\"\n dbt Cloud Job ID cannot be None.\n Please provide a Job ID or the name of the env var that contains it.\n \"\"\"\n )\n\n if domain is None:\n domain = \"cloud.getdbt.com\"\n\n if token is None and token_env_var_name in os.environ:\n token = os.environ.get(token_env_var_name)\n\n if token is None:\n raise ValueError(\n \"\"\"\n dbt Cloud token cannot be None.\n Please provide a token or the name of the env var that contains it.\n \"\"\"\n )\n\n run = trigger_job_run(\n account_id=account_id,\n job_id=job_id,\n cause=cause,\n additional_args=additional_args,\n token=token,\n domain=domain,\n )\n if wait_for_job_run_completion:\n job_run_result = wait_for_job_run(\n account_id=account_id,\n run_id=run[\"id\"],\n token=token,\n max_wait_time=max_wait_time,\n domain=domain,\n )\n\n artifact_links = []\n try:\n artifact_links = list_run_artifact_links(\n account_id=account_id, run_id=run[\"id\"], token=token, domain=domain\n )\n\n markdown = f\"Artifacts for dbt Cloud run {run['id']} of job {job_id}\\n\"\n for link, name in artifact_links:\n markdown += f\"- [{name}]({link})\\n\"\n create_markdown_artifact(markdown)\n\n except DbtCloudListArtifactsFailed as err:\n self.logger.warn(\n f\"Unable to retrieve artifacts generated by dbt Cloud job run: {err}\"\n )\n\n job_run_result[\"artifact_urls\"] = [link for link, _ in artifact_links]\n\n return job_run_result\n\n else:\n return run", "def handler(event: Dict[str, Any], context: Any) -> None:\n client = boto3.client(\"batch\")\n\n job_a = client.submit_job(\n jobName=\"submit_job_a\",\n jobQueue=os.getenv(\"BATCH_JOB_QUEUE\"),\n jobDefinition=os.getenv(\"BATCH_JOB_A_DEFINITION\"))\n print(\"JobA Submitted: \", job_a)\n\n job_b = client.submit_job(\n jobName=\"submit_job_b\",\n jobQueue=os.getenv(\"BATCH_JOB_QUEUE\"),\n jobDefinition=os.getenv(\"BATCH_JOB_B_DEFINITION\"),\n dependsOn=[{\n \"jobId\": job_a[\"jobId\"]\n }])\n print(\"JobB Sumitted: \", job_b)", "def update(self, job_name, param_name, value, description=None):\n if job_name in self._jobs:\n getattr(self._jobs[job_name], param_name).update(value, description)\n else:\n self.log.error(\"Invalid job name: %s\", job_name)", "def trigger_batch_job(parent_batch_id, job_input, job_params):\n job_name = job_params[\"jobName\"]\n job_modality = job_params[\"jobModality\"]\n\n batch_id = f\"{parent_batch_id}-{job_name}\"\n\n output_path = (\n f\"s3://{batch_processing_bucket_name}/batch_manifests/{job_modality}/{batch_id}/output\"\n )\n\n # If a label category file wasn't provided as API input, use the previous\n # job's label category file.\n label_category_config_uri = job_input.label_category_s3_uri\n if \"labelCategoryConfigS3Uri\" in job_params:\n label_category_config_uri = job_params[\"labelCategoryConfigS3Uri\"]\n\n # batch_job_input_data = event[\"batch_job_input\"]\n labeling_job_request = construct_labeling_job_input(\n parent_batch_id=parent_batch_id,\n input_manifest_url=job_input.input_manifest_s3_uri,\n audit_label_attribute_name=job_input.label_attribute_name,\n label_category_config_uri=label_category_config_uri,\n job_params=job_params,\n output_path=output_path,\n )\n\n sagemaker.create_labeling_job(**labeling_job_request)\n s3_output_path = f\"{output_path}/{job_name}/manifests/output/output.manifest\"\n\n db.insert_job_level_metadata(\n parent_batch_id=parent_batch_id,\n batch_id=batch_id,\n batch_status=BatchStatus.WAIT_FOR_SMGT_RESPONSE,\n labeling_job_name=job_name,\n label_attribute_name=labeling_job_request[\"LabelAttributeName\"],\n label_category_s3_uri=labeling_job_request[\"LabelCategoryConfigS3Uri\"],\n job_input_s3_uri=labeling_job_request[\"InputConfig\"][\"DataSource\"][\"S3DataSource\"][\n \"ManifestS3Uri\"\n ],\n job_output_s3_uri=s3_output_path,\n )", "def trigger_job(revision, buildername, times=1, files=None, dry_run=False,\n extra_properties=None):\n repo_name = query_repo_name_from_buildername(buildername)\n builder_to_trigger = None\n list_of_requests = []\n LOG.info(\"We want to trigger '%s' on revision '%s' a total of %d time(s).\" %\n (buildername, revision, times))\n\n if not buildapi.valid_revision(repo_name, revision):\n return list_of_requests\n\n if not valid_builder(buildername):\n LOG.error(\"The builder %s requested is invalid\" % buildername)\n # XXX How should we exit cleanly?\n exit(-1)\n\n if files:\n builder_to_trigger = buildername\n _all_urls_reachable(files)\n else:\n builder_to_trigger, files = _determine_trigger_objective(\n revision,\n buildername,\n )\n\n if builder_to_trigger != buildername and times != 1:\n # The user wants to trigger a downstream job,\n # however, we need a build job instead.\n # We should trigger the downstream job multiple times, however,\n # we only trigger the upstream jobs once.\n LOG.debug(\"Since we need to trigger a build job we don't need to \"\n \"trigger it %s times but only once.\" % times)\n LOG.info(\"In order to trigger %s %i times, please run the script again after %s ends.\"\n % (buildername, times, builder_to_trigger))\n times = 1\n\n if builder_to_trigger:\n if dry_run:\n LOG.info(\"Dry-run: We were going to request '%s' %s times.\" %\n (builder_to_trigger, times))\n # Running with dry_run being True will only output information\n trigger(builder_to_trigger, revision, files, dry_run, extra_properties)\n else:\n for _ in range(times):\n req = trigger(builder_to_trigger, revision, files, dry_run, extra_properties)\n if req is not None:\n list_of_requests.append(req)\n else:\n LOG.debug(\"Nothing needs to be triggered\")\n\n return list_of_requests", "def job(self, job: str):\n\n self._job = job", "def job(self, job: str):\n\n self._job = job", "def setTrigger(self, *args):\n return _libsbml.Event_setTrigger(self, *args)", "def job_as_parameter(f):\n f.job_as_parameter = True\n return f", "def submit(cls, background_job):\n background_job.save()\n request_es_backup.schedule(args=(background_job.id,), delay=10)", "def submit(self, job_parameters):\n # FIX: Don't pass through the real job name. Bilby outputs the job files by whatever this parameter is, that\n # means that names containing special characters will break. Uniqueness is guaranteed by the folder structure\n job_parameters = json.loads(job_parameters)\n job_parameters['name'] = 'bilby'\n\n # Write the job parameters to a file\n json.dump(job_parameters, open(self.job_parameter_file, 'w'))\n\n # Run the job\n return super().submit(job_parameters)", "async def trigger(self, variables):\n variables[\"samples\"] = self._center.samples\n _LOGGER.debug(\"Triggered automation %s\", self.name)\n try:\n cond = self._cond_func(variables)\n except TemplateError as exc:\n _LOGGER.error(\"Failed to render condition for %s: %s\", self.name, exc)\n return\n if cond:\n _LOGGER.debug(\"Condition passed for %s\", self.name)\n await self._action_sequence(variables)" ]

[ "0.6365271", "0.6245668", "0.62099326", "0.61203486", "0.588978", "0.5762087", "0.5737363", "0.56618714", "0.5655177", "0.55685776", "0.5567557", "0.55617213", "0.5506177", "0.5457874", "0.5420332", "0.5409931", "0.53858936", "0.5350611", "0.53456885", "0.5329666", "0.5314936", "0.5295545", "0.5263992", "0.5262621", "0.5262621", "0.52589387", "0.524901", "0.52480626", "0.52473295", "0.5242411" ]

[ "def EnableJob(self, job_urn, token=None):\n cron_job = aff4.FACTORY.Open(job_urn, mode=\"rw\", aff4_type=\"CronJob\",\n token=token)\n cron_job.Set(cron_job.Schema.DISABLED(0))\n cron_job.Close()", "def disable_job(self, job):\n if subprocess.call(self.cli + [PlatformJenkinsJavaCLI.DISABLE_JOB, job.name]) != 0:\n raise PlatformJenkinsException(\"Disabling job failed: \" + job.name)", "def post_job_enable_with_http_info(self, name, **kwargs):\n\n all_params = ['name', 'jenkins_crumb']\n all_params.append('async')\n all_params.append('_return_http_data_only')\n all_params.append('_preload_content')\n all_params.append('_request_timeout')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method post_job_enable\" % key\n )\n params[key] = val\n del params['kwargs']\n # verify the required parameter 'name' is set\n if ('name' not in params) or (params['name'] is None):\n raise ValueError(\"Missing the required parameter `name` when calling `post_job_enable`\")\n\n\n collection_formats = {}\n\n path_params = {}\n if 'name' in params:\n path_params['name'] = params['name']\n\n query_params = []\n\n header_params = {}\n if 'jenkins_crumb' in params:\n header_params['Jenkins-Crumb'] = params['jenkins_crumb']\n\n form_params = []\n local_var_files = {}\n\n body_params = None\n # Authentication setting\n auth_settings = ['jenkins_auth']\n\n return self.api_client.call_api('/job/{name}/enable', 'POST',\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=local_var_files,\n response_type=None,\n auth_settings=auth_settings,\n async=params.get('async'),\n _return_http_data_only=params.get('_return_http_data_only'),\n _preload_content=params.get('_preload_content', True),\n _request_timeout=params.get('_request_timeout'),\n collection_formats=collection_formats)", "def enable(self, subsystem=False):\n self.__dict__[\"enabled\"] = True\n\n if subsystem:\n self.subsystem.enable()", "def cli_enable_plugin(self, args) -> str:\n plugin_name = args.plugin_name\n if plugin_name not in self.name_to_plugin_class:\n return error(\"Plugin {} DNE\".format(plugin_name))\n\n self.name_to_enabled[plugin_name] = True\n return ok(\"Plugin {} enabled\".format(plugin_name))", "def register_job(self, job):\n self.job = job", "def post_job_enable(self, name, **kwargs):\n kwargs['_return_http_data_only'] = True\n if kwargs.get('async'):\n return self.post_job_enable_with_http_info(name, **kwargs)\n else:\n (data) = self.post_job_enable_with_http_info(name, **kwargs)\n return data", "def enable(self, *args, **kwargs):\n pass", "def __set_job_status(self, job: Job):\n\n self.redis_client.set(f'jobstatus:{job.id}:{str(job.status)}', f'job:{job.id}')", "async def enable(self, ctx):\n self.bot.db.execute(\"UPDATE starboards SET enabled = 1 WHERE channel_id = ?\", (ctx.channel.id,))\n await ctx.say(\"star.enabled\")", "async def enable(self, **kwargs) -> None: # pylint: disable=unused-argument\r\n await self.set_ena(True)", "def mark(self, job, status='succeeded'):\n pass", "async def enable(self, ctx, *, channel: discord.Channel=None):\n\n server = ctx.message.server\n\n temp = self.bot.dota_ticker_settings.get(server.id)\n\n if temp is not None and temp['enabled']:\n await self.bot.say('The match ticker has already been enabled on this server.')\n return\n\n if channel is None:\n channel = server.default_channel\n\n settings = {'enabled': True, 'channel_id': channel.id}\n\n await self.bot.dota_ticker_settings.put(server.id, settings)\n await self.bot.say('The match ticker has been enabled on {0.mention}.'.format(channel))", "def enable(self):\n\t\tresponse = self.client.post(self._endpoint + \"/enable\")\n\t\treturn bool(response.json[\"success\"])", "def enable(self):\n if not self.labExperiment:\n super().enable()\n else:\n self.connection.command('open_dm', self.DMserial)\n status = self.connection.query('get_status')\n assert status == 0, 'Error connecting to DM. Error: ' + str(status)\n numActProfile = self.connection.query('num_actuators')\n assert numActProfile == self.numActProfile, 'Wrong number of profile actuators entered'\n print(\"'BM1k' is now enabled\")", "def enable(self, enable):\n\n self._enable = enable", "def enable(self, name, channel):\n if channel not in self.disabled_extensions:\n self.disabled_extensions[channel] = set()\n\n if name not in self.extension_names:\n return False\n\n logger.info('Enabling %s on %s' % (name, channel))\n self.disabled_extensions[channel].discard(name)\n\n return True", "def enable(service_name: str, print_action: bool = True):\n \n if print_action:\n print_log_status(3, f\"Enabling `{service_name}`\")\n \n run_command(f\"sudo systemctl enable {service_name}\")", "def set_saucelabs_job_status(jobid, passed=True):\r\n config = get_saucelabs_username_and_key()\r\n url = 'http://saucelabs.com/rest/v1/{}/jobs/{}'.format(config['username'], world.jobid)\r\n body_content = dumps({\"passed\": passed})\r\n base64string = encodestring('{}:{}'.format(config['username'], config['access-key']))[:-1]\r\n headers = {\"Authorization\": \"Basic {}\".format(base64string)}\r\n result = requests.put(url, data=body_content, headers=headers)\r\n return result.status_code == 200", "def modify_job(self, job, parameter):\n job.set_encut(parameter[0])\n job.set_kpoints(parameter[1])\n return job", "def _enable(self):\n sub = multiprocessing.Process(target=subproc)\n sub.start()", "def enable(self):\n self.switch.enable()\n self._enabled = True", "def enable():\n request = dict(id='gbn')\n _gbn_enable(request)", "def activate_job(job_name):\n job = Job.from_name(job_name)\n job.set_active(True)\n return redirect(url_for('all_jobs_for_client', ClientID=job.ClientID))", "def start(self, job: PandaJob) -> None:\n raise NotImplementedError(\"Base method not implemented\")", "def enable_plugin(self, plugin: str):\r\n with PluginStore.mutex:\r\n self._disabled.remove(plugin)", "def job(self, job: str):\n\n self._job = job", "def job(self, job: str):\n\n self._job = job", "def set_skill_enablement_v1(self, skill_id, stage, **kwargs):\n # type: (str, str, **Any) -> Union[ApiResponse, object, StandardizedError_f5106a89, BadRequestError_f854b05]\n operation_name = \"set_skill_enablement_v1\"\n params = locals()\n for key, val in six.iteritems(params['kwargs']):\n params[key] = val\n del params['kwargs']\n # verify the required parameter 'skill_id' is set\n if ('skill_id' not in params) or (params['skill_id'] is None):\n raise ValueError(\n \"Missing the required parameter `skill_id` when calling `\" + operation_name + \"`\")\n # verify the required parameter 'stage' is set\n if ('stage' not in params) or (params['stage'] is None):\n raise ValueError(\n \"Missing the required parameter `stage` when calling `\" + operation_name + \"`\")\n\n resource_path = '/v1/skills/{skillId}/stages/{stage}/enablement'\n resource_path = resource_path.replace('{format}', 'json')\n\n path_params = {} # type: Dict\n if 'skill_id' in params:\n path_params['skillId'] = params['skill_id']\n if 'stage' in params:\n path_params['stage'] = params['stage']\n\n query_params = [] # type: List\n\n header_params = [] # type: List\n\n body_params = None\n header_params.append(('Content-type', 'application/json'))\n header_params.append(('User-Agent', self.user_agent))\n\n # Response Type\n full_response = False\n if 'full_response' in params:\n full_response = params['full_response']\n\n # Authentication setting\n access_token = self._lwa_service_client.get_access_token_from_refresh_token()\n authorization_value = \"Bearer \" + access_token\n header_params.append(('Authorization', authorization_value))\n\n error_definitions = [] # type: List\n error_definitions.append(ServiceClientResponse(response_type=None, status_code=204, message=\"No Content; Confirms that enablement is successfully created/updated.\"))\n error_definitions.append(ServiceClientResponse(response_type=\"ask_smapi_model.v1.bad_request_error.BadRequestError\", status_code=400, message=\"Server cannot process the request due to a client error.\"))\n error_definitions.append(ServiceClientResponse(response_type=\"ask_smapi_model.v1.skill.standardized_error.StandardizedError\", status_code=401, message=\"The auth token is invalid/expired or doesn&#39;t have access to the resource.\"))\n error_definitions.append(ServiceClientResponse(response_type=\"ask_smapi_model.v1.bad_request_error.BadRequestError\", status_code=403, message=\"The operation being requested is not allowed.\"))\n error_definitions.append(ServiceClientResponse(response_type=\"ask_smapi_model.v1.skill.standardized_error.StandardizedError\", status_code=404, message=\"The resource being requested is not found.\"))\n error_definitions.append(ServiceClientResponse(response_type=\"ask_smapi_model.v1.skill.standardized_error.StandardizedError\", status_code=409, message=\"The request could not be completed due to a conflict with the current state of the target resource.\"))\n error_definitions.append(ServiceClientResponse(response_type=\"ask_smapi_model.v1.skill.standardized_error.StandardizedError\", status_code=429, message=\"Exceed the permitted request limit. Throttling criteria includes total requests, per API, ClientId, and CustomerId.\"))\n error_definitions.append(ServiceClientResponse(response_type=\"ask_smapi_model.v1.skill.standardized_error.StandardizedError\", status_code=500, message=\"Internal Server Error.\"))\n error_definitions.append(ServiceClientResponse(response_type=\"ask_smapi_model.v1.skill.standardized_error.StandardizedError\", status_code=503, message=\"Service Unavailable.\"))\n\n api_response = self.invoke(\n method=\"PUT\",\n endpoint=self._api_endpoint,\n path=resource_path,\n path_params=path_params,\n query_params=query_params,\n header_params=header_params,\n body=body_params,\n response_definitions=error_definitions,\n response_type=None)\n\n if full_response:\n return api_response\n \n return None", "def __set_job(self, job: Job):\n\n serialized_job = self._serialize_entry(job)\n self.__delete_job_status(job)\n self.redis_client.set(f'job:{job.id}', serialized_job)\n self.__set_job_status(job)" ]

[ "0.6508622", "0.640465", "0.6054045", "0.589058", "0.5827825", "0.55788094", "0.5573359", "0.5561993", "0.5552079", "0.5471112", "0.54423046", "0.5440283", "0.543312", "0.5425502", "0.5387053", "0.53846234", "0.5364459", "0.5362083", "0.5344735", "0.53233784", "0.52979136", "0.5291625", "0.527096", "0.5260427", "0.52597964", "0.5251214", "0.5205945", "0.5205945", "0.5201516", "0.5185637" ]

[ "def DisableJob(self, job_urn, token=None):\n cron_job = aff4.FACTORY.Open(job_urn, mode=\"rw\", aff4_type=\"CronJob\",\n token=token)\n cron_job.Set(cron_job.Schema.DISABLED(1))\n cron_job.Close()", "def deactivate_job(job_name):\n job = Job.from_name(job_name)\n job.set_active(False)\n return redirect(url_for('active_jobs_for_client', ClientID=job.ClientID))", "def cancel_job(self, job):\n try:\n self.jobs.remove(job)\n except ValueError:\n pass", "def cli(ctx, job_id):\n return ctx.gi.jobs.cancel_job(job_id)", "def kill_job(self , index):\n job = self.jobs.__getitem__( index )\n if job:\n job.kill()", "def cancel_job(self, job_number):\n raise NotImplementedError", "def disable(self):\n if not self.labExperiment:\n super().disable()\n else:\n self.zero()\n self.connection.query('close_dm')\n print(\"'BM1k' is now disbaled\")", "def kill_job(self, job):\n\n if job.status == Job.STATUS_QUEUED:\n # case 1: job is in QUEUED state\n # remove it from the queue and mark as killed\n\n job_queue = job_queue_name(job.model)\n logger.info(\n \"killing job {} by removing from queue {}\".\n format(job.uuid, job_queue))\n\n command_dict = {'command': 'PROCESS_JOB', 'job_uuid': job.uuid}\n remove_command(redis_connection(), job_queue, command_dict)\n job.status = Job.STATUS_KILLED\n # save it\n Job[job.uuid] = job\n elif job.status == Job.STATUS_RUNNING:\n # case 2: job is in RUNNING state\n # send message to worker to kill the job\n worker = worker_name(job.worker_url, job.model)\n worker_channel = node_channel_name(worker)\n logger.info(\"sending command to kill job on channel {}\".\n format(worker_channel))\n command_dict = {'command': \"KILL_JOB\", 'job_uuid': job.uuid}\n publish_command(redis_connection(), worker_channel, command_dict)\n else:\n logger.info(\"kill called on job {} in incompatible state {}\".\n format(job.uuid, job.status))", "def jobFail(job):\n\tif 'a' in job.proc.config._notify.when['pipeline']:\n\t\tlogger.debug('Notifying job fails')\n\t\tEMAIL.send('job', job, 'abort')", "def stop_labeling_job(LabelingJobName=None):\n pass", "def on_disable(self) -> None:\n self._cancel_automation()", "def kill(self):\n return self._raw_execute(\"cancel\", {\"job_id\": self.job_id})", "def cancel_job(job_id: str, connection: Optional['Redis'] = None, serializer=None, enqueue_dependents: bool = False):\n Job.fetch(job_id, connection=connection, serializer=serializer).cancel(enqueue_dependents=enqueue_dependents)", "def unset_wrapper(bot, update, args, job_queue, chat_data):\n if len(args) == 0:\n update.message.reply_text('No parameter provided')\n return\n\n job_name = args[0]\n if len(args) == 0 or job_name not in settings.JOBS:\n update.message.reply_text(\n 'Sorry {0} is not a valid job'.format(job_name))\n return\n\n job = find_job(job_name, job_queue)\n\n if not job:\n update.message.reply_text('You have no active job')\n return\n\n job.schedule_removal()\n\n update.message.reply_text('{0} job successfully unset!'.format(job_name))", "def stop_compilation_job(CompilationJobName=None):\n pass", "def on_kill(self):\n if self.job_id:\n self.log.info(\"on_kill: cancel the airbyte Job %s\", self.job_id)\n self.hook.cancel_job(self.job_id)", "def delete_job(self, job):\n subprocess.call(self.cli + [PlatformJenkinsJavaCLI.DELETE_JOB, job.name])", "def stop_job(self):\n # DELETE /jobs/{job_id}/results\n pass", "async def cmd_galdisable(self, ctx):\n # ===== SET LOCAL COG VARIABLE\n self.cogset['enable']= False\n\n # ===== SAVE SETTINGS \n await cogset.SAVE(self.cogset, cogname=self.qualified_name)\n\n # ===== DELETE THE JOB IF IT EXISTS\n for job in self.jobstore.get_all_jobs():\n if [\"_delete_gallery_messages\"] == job.id.split(\" \"):\n self.scheduler.remove_job(job.id)\n\n await ctx.channel.send(content=\"Galleries are disabled.\")\n\n return", "def Disable(self):\n handler = self.get_command_object(\"Disable\")\n handler()", "def _delete_job(self, job):", "def unclaim(self, job, owner):\n raise NotImplementedError()", "async def stop(self):\n self._job.cancel()\n await super().stop()", "def deactivate_port(self, job_req):\n # STEP-0 Extract parameters from job_req\n #job_params\n #job_params[0]: Bot Command\n #job_params[1]: Switch IP Address\n #job_params[2]: Port Number\n devicon = chr(0x2757) + chr(0xFE0F)\n check_icon = chr(0x2705)\n job_params = job_req.split()\n if len(job_params) < 3:\n #Not Enough info provided\n message = f\" Job Request is incomplete, please provide Switch IP, Switch-Port, Vlan-ID ie _change-port-vlan 1.1.1.1 10 101 \\n\"\n else:\n ## STEP 0-1: Assign all the parameters to job variables\n ip_addr = \"\".join(re.findall(r'\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}', job_params[1])) #Well Formed IP Address\n port_id = \"\".join(re.findall(r'^\\d{1,2}$',job_params[2])) #Accepting up to numbers\n # STEP 1: Validations\n ## STEP 1-1: GET Switch Serial Number\n serial_id, switch_name = get_switch_serial(ip_addr, self.meraki_net)\n if serial_id in [\"\"]:\n message = f\"{devicon} **There is not switch with that IP**\"\n logger.error(\"VALIDATION failed Switch serial not Found %s\", ip_addr)\n return message\n else:\n logger.info(\"VALIDATION Succeeded Switch serial Found %s\", serial_id)\n\n ## STEP 1-2: Validate Port ID\n if validate_port(port_id, serial_id):\n logger.info(\"VALIDATION Succeeded Port ID Valid %s\", port_id)\n else:\n logger.error(\"VALIDATION failed Port ID not Found %s\", port_id)\n message = f\"{devicon} **Invalid Port ID**\"\n return message\n\n # STEP 2: Prepare the Payload\n port_payload = {}\n port_payload[\"name\"] = f\"Port disabled by {self.job_owner} via Teams\"\n port_payload[\"enabled\"] = False\n logger.info(\"JSON Data to Port Update %s \", json.dumps(port_payload))\n\n # STEP 3: Send The Change to API\n api_uri = f\"/v1/devices/{serial_id}/switch/ports/{int(port_id)}\"\n data = update_via_meraki_api(api_uri, port_payload)\n if data:\n logger.info(\"Port updated successfully job_owner %s : \", self.job_owner)\n message = f\" {check_icon} **Port Update has been applied Sucesfully** \\n\"\n message += F\"* Job Owner: **{self.job_owner}** \\n\"\n message += F\"* Switch Name: **{switch_name}** \\n\"\n message += f\"* PortID **{data['portId']}** \\n\"\n message += f\"* Port Name **{data['name']}** \\n\"\n message += f\"* Port Type **{data['enabled']}** \\n\"\n else: \n logger.error(\"Port update failed : \") \n message = f\"{devicon} Port Update incomplete\"\n return message", "async def request_job_stop(self, job_id: str, *args, **kwargs) -> bool:\n # TODO: implement\n raise NotImplementedError('{} function \"request_job_stop\" not implemented yet'.format(self.__class__.__name__))", "def run_job(job, interrupt_if_necessary):", "def set_Off(self):\n if not(self._locked):\n self.__dict__['statusOn']=False\n self._undo_action()\n else:\n self._log.info('The JobProperty %s is blocked', self.__name__)", "def cancel_vmware_protection_job(job_name):\n try:\n cohesity_client = _get_client()\n jobs = cohesity_client.protection_jobs.get_protection_jobs(\n is_deleted=False, names=job_name)\n if not jobs:\n return \"Job with name {} not available.\".format(job_name)\n for job in jobs:\n if job.name == job_name:\n job_id = job.id\n break\n if not job_id:\n return \"Job with name {} not available.\".format(job_name)\n\n # Get recent job run id and status.\n runs = cohesity_client.protection_runs.get_protection_runs(\n job_id=job_id)\n if not runs:\n return \"Job run details not available for job {}\".format(job_name)\n latest_run = runs[0]\n if latest_run.backup_run.status not in [\"kRunning\", \"kAccepted\"]:\n return \"No active job run available for job {}\".format(job_name)\n run_id = latest_run.backup_run.job_run_id\n body = CancelProtectionJobRunParam()\n body.job_run_id = run_id\n cohesity_client.protection_runs.create_cancel_protection_job_run(\n job_id, body)\n return \"Successfully cancelled the run for job {}\".format(job_name)\n except APIException as err:\n return \"Error while attempting to cancel the job {}, error : {}\".format(\n job_name, err)", "def cli_disable_plugin(self, args) -> str:\n plugin_name = args.plugin_name\n if plugin_name not in self.name_to_plugin_class:\n return error(\"Plugin {} DNE\".format(plugin_name))\n\n self.name_to_enabled[plugin_name] = False\n return ok(\"Plugin {} disabled\".format(plugin_name))", "def cancel_search(job):\n job.cancel()" ]

[ "0.7047712", "0.66080946", "0.6542796", "0.61389357", "0.61290914", "0.6022472", "0.6003207", "0.596457", "0.59564406", "0.5941506", "0.59358865", "0.59051114", "0.58281994", "0.58168745", "0.5810319", "0.5772574", "0.57711303", "0.57645935", "0.57537967", "0.5739578", "0.5725265", "0.57167447", "0.568465", "0.56842715", "0.5678199", "0.5670605", "0.56671345", "0.56503046", "0.5645008", "0.56448716" ]

[ "def create(cfg, jobs):\n server = jenkins_utils.server_factory(cfg)\n libjobs.createJobs(server, jobs)", "def create_job(api_instance, job):\n api_response = api_instance.create_namespaced_job(\n body=job, namespace=\"default\", pretty=True\n )\n logger.info(\"Job created with status='%s'\" % str(api_response.status))\n return api_response", "def create_job(jobtype, server):\n name = generate_job_name(jobtype)\n job = Job.objects.create(jobtype=jobtype, server=server, name=name)\n return job", "def create_job(self, name: str) -> Slurm:\n LOG.info(\"Create a slurm job with name %s\", name)\n job = Slurm(\n name,\n {\"account\": self.account, \"time\": self.time,},\n scripts_dir=str(self.scripts_dir),\n log_dir=str(self.log_dir),\n )\n return job", "def _create_job(self,\n name,\n environment_string,\n description='',\n platform='LINUX'):\n job = data_types.Job()\n job.name = name\n if environment_string.strip():\n job.environment_string = environment_string\n job.platform = platform\n job.descripton = description\n job.put()\n\n return job", "def createJob(self, joboptions, previousId=None):\n root = self.manifest.getRootResource()\n assert self.manifest.tosca\n job = Job(self, root, joboptions, previousId)\n\n if (\n self.manifest.localEnv\n and not joboptions.parentJob\n and not joboptions.startTime\n ):\n logPath = self.manifest.getJobLogPath(job.getStartTime(), \".log\")\n if not os.path.isdir(os.path.dirname(logPath)):\n os.makedirs(os.path.dirname(logPath))\n initLogging(logfile=logPath)\n path = self.manifest.path\n if joboptions.planOnly:\n logger.info(\"creating %s plan for %s\", joboptions.workflow, path)\n else:\n logger.info(\"starting %s job for %s\", joboptions.workflow, path)\n\n WorkflowPlan = Plan.getPlanClassForWorkflow(joboptions.workflow)\n if not WorkflowPlan:\n raise UnfurlError(\"unknown workflow: %s\" % joboptions.workflow)\n job.plan = WorkflowPlan(root, self.manifest.tosca, joboptions)\n return job", "def create_job(self, context=None):\n return self._client.call_method(\n 'UserAndJobState.create_job',\n [], self._service_ver, context)", "def create(self, resource, **data):\n body = ''\n if resource == 'robot/job':\n body = data['body']\n else:\n body = urllib.urlencode(data)\n\n return self.request('/' + resource, 'POST', body=body)", "def job_create(self, sender, name=None):\n self._require_running()\n name = name or self.DEFAULT_JOB_NAME\n job_id = uuid.uuid4().hex\n assert job_id not in self._jobs\n assert sender is not None\n assert sender.connection\n job = Job(\n job_id,\n name,\n self._session_root.joinpath(job_id),\n sender,\n self._loop\n )\n self._jobs[job_id] = job\n self._jobs_by_connection[sender.connection][job_id] = job\n self._log.debug('Created job %s', job)\n return job_id", "def create_job(script, args, inputs, outputs, tools):\n job = Job(script)\n for arg in args:\n job.addArguments(arg)\n\n # all jobs will have access to python scripts\n for tool in tools:\n job.uses(tools[tool], link=Link.INPUT)\n\n for input in inputs:\n job.uses(input, link=Link.INPUT)\n\n for output in outputs:\n job.uses(output, link=Link.OUTPUT, transfer=True)\n\n #job.addProfile(Profile(Namespace.PEGASUS, 'clusters.size', '20'))\n return job", "def create_job(project, description):\n randomnames = open(os.path.join(\"Anemone\", \"templates\", \"namegen.html\")).readlines()\n jobname = (\"Quick.\" +\n random.choice(randomnames)[:-1] + # for some reason choice gives extra space\n random.choice(randomnames)[:-1]) # for some reason choice gives extra space\n\n newjob = Job.create(project=project, name=jobname, description=description)\n newjob.name = newjob.name + \".{0:0=3d}\".format(newjob.id)\n newjob.save()\n return newjob", "def send_job(self):\n graph = self.processgraphEdit.toPlainText()\n # info(self.iface, graph)\n response = self.connection.job_create(json.loads(graph))\n if response.status_code == 201:\n info(self.iface, \"Successfully created new job, Response: {}\".format(response.status_code))\n else:\n warning(self.iface, \"Not able to created new job, Response: {}\".format(str(response.json())))", "def create(self, validated_data):\n return Job.objects.create(**validated_data)", "def create_jobs(release, project_yaml):\n logger = logging.getLogger(__file__)\n\n # We assume here project keep their subrepo jobs under the part\n # project name. Otherwise we'll have to look for jjb/<repo> for each\n # branch listed.\n project, _ = next(iter(project_yaml['branches'][0]['location'].items()))\n\n yaml_parser = YAML()\n yaml_parser.preserve_quotes = True\n yaml_parser.explicit_start = True\n # yaml_parser.indent(mapping=4, sequence=0, offset=0)\n # These are some esoteric values that produce indentation matching our jjb\n # configs\n # yaml_parser.indent(mapping=3, sequence=3, offset=2)\n # yaml_parser.indent(sequence=4, offset=2)\n yaml_parser.indent(mapping=2, sequence=4, offset=2)\n\n (job_files, skipped_files) = jjb_files(project, release)\n\n if skipped_files:\n logger.info(\"Jobs already exists for %s in files: %s\",\n project, ', '.join(skipped_files))\n # Exit if there are not jobs to create\n if not job_files:\n return\n logger.info(\"Creating Jenkins Jobs for %s in files: %s\",\n project, ', '.join(job_files))\n\n stable_branch_stream = \"\"\"\\\n %s:\n branch: 'stable/{stream}'\n gs-pathname: '/{stream}'\n disabled: false\n \"\"\" % release\n\n stable_branch_yaml = yaml_parser.load(stable_branch_stream)\n stable_branch_yaml[release].yaml_set_anchor(release, always_dump=True)\n\n for job_file in job_files:\n yaml_jjb = yaml_parser.load(open(job_file))\n if 'stream' not in yaml_jjb[0]['project']:\n continue\n\n # TODO: Some JJB files don't have 'stream'\n project_config = yaml_jjb[0]['project']['stream']\n # There is an odd issue where just appending adds a newline before the\n # branch config, so we append (presumably after master) instead.\n project_config.insert(1, stable_branch_yaml)\n\n # NOTE: In the future, we may need to override one or multiple of the\n # following ruamal Emitter methods:\n # * ruamel.yaml.emitter.Emitter.expect_block_sequence_item\n # * ruamel.yaml.emitter.Emitter.write_indent\n # To hopefully replace the need to shell out to sed...\n yaml_parser.dump(yaml_jjb, open(job_file, 'w'))\n args = ['sed', '-i', 's/^ //', job_file]\n subprocess.Popen(args, stdout=subprocess.PIPE, shell=False)", "def create_custom_job(\n type,\n project,\n location,\n payload,\n gcp_resources,\n):\n remote_runner = job_remote_runner.JobRemoteRunner(\n type, project, location, gcp_resources\n )\n\n try:\n # Create custom job if it does not exist\n job_name = remote_runner.check_if_job_exists()\n if job_name is None:\n job_name = remote_runner.create_job(\n create_custom_job_with_client,\n insert_system_labels_into_payload(payload),\n )\n\n # Poll custom job status until \"JobState.JOB_STATE_SUCCEEDED\"\n remote_runner.poll_job(get_custom_job_with_client, job_name)\n except (ConnectionError, RuntimeError) as err:\n error_util.exit_with_internal_error(err.args[0])", "def create_job_object(message, environment_image):\n\n PYTHONUNBUFFERED_ENV = client.V1EnvVar(name=\"PYTHONUNBUFFERED\", value=\"1\")\n AUTH_TOKEN_ENV = client.V1EnvVar(name=\"AUTH_TOKEN\", value=AUTH_TOKEN)\n EVALAI_API_SERVER_ENV = client.V1EnvVar(\n name=\"EVALAI_API_SERVER\", value=EVALAI_API_SERVER\n )\n MESSAGE_BODY_ENV = client.V1EnvVar(name=\"BODY\", value=json.dumps(message))\n submission_pk = message[\"submission_pk\"]\n image = message[\"submitted_image_uri\"]\n # Configureate Pod agent container\n agent_container = client.V1Container(\n name=\"agent\", image=image, env=[PYTHONUNBUFFERED_ENV]\n )\n # Configureate Pod environment container\n environment_container = client.V1Container(\n name=\"environment\",\n image=environment_image,\n env=[\n PYTHONUNBUFFERED_ENV,\n AUTH_TOKEN_ENV,\n EVALAI_API_SERVER_ENV,\n MESSAGE_BODY_ENV,\n ],\n resources=client.V1ResourceRequirements(\n limits={\"nvidia.com/gpu\": \"1\"}\n ),\n )\n # Create and configurate a spec section\n template = client.V1PodTemplateSpec(\n metadata=client.V1ObjectMeta(labels={\"app\": \"evaluation\"}),\n spec=client.V1PodSpec(\n containers=[environment_container, agent_container],\n restart_policy=\"Never\",\n ),\n )\n # Create the specification of deployment\n spec = client.V1JobSpec(backoff_limit=1, template=template)\n # Instantiate the job object\n job = client.V1Job(\n api_version=\"batch/v1\",\n kind=\"Job\",\n metadata=client.V1ObjectMeta(\n name=\"submission-{0}\".format(submission_pk)\n ),\n spec=spec,\n )\n return job", "def created_job(new_job, bulk_request):\n bulk_request.return_value = '''<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n <jobInfo xmlns=\"http://www.force.com/2009/06/asyncapi/dataload\">\n <id>THEJOBID</id>\n <operation>update</operation>\n <object>Lead</object>\n </jobInfo>\n '''\n new_job.create()\n return new_job", "def test_post_job(self):\n body = UnitTesterJobCreateReq()\n response = self.client.open(\n '/v1/job',\n method='POST',\n data=json.dumps(body),\n content_type='application/json')\n self.assert200(response,\n 'Response body is : ' + response.data.decode('utf-8'))", "def trigger_job(self, job, parameters=None):\n parameters = parameters or {}\n parameter_list = []\n for key in parameters:\n parameter_list.append(\"-p\")\n parameter_list.append(\"%s=%s\" % (key, parameters[key]))\n if subprocess.call(self.cli + [PlatformJenkinsJavaCLI.BUILD_JOB, job.name] + parameter_list) != 0:\n raise PlatformJenkinsException(\"Triggering job failed: \" + job.name)", "def _create_jenkins_build(self, step):\n # we also have to inject the correct build_type here in order\n # to generate the correct params and to generate the correct\n # commands later on\n builder = self.get_builder(build_type=self.shard_build_type)\n\n builder.create_jenkins_build(step, job_name=step.data['job_name'],\n script=step.data['cmd'].format(\n test_names=' '.join(step.data['tests']),\n ),\n setup_script=self.shard_setup_script,\n teardown_script=self.shard_teardown_script,\n path=step.data['path'],\n )", "def build_job(job_url, pr_number, run_full, has_params):\n log.debug(\n \"job_url: %s pr_num: %s run_full: %s has_params: %s\",\n job_url,\n pr_number,\n run_full,\n has_params,\n )\n if has_params:\n pr_url = \"{}/job/PR-{}/buildWithParameters?runFull={}\".format(\n job_url.rstrip(\"/\"), pr_number, \"true\" if run_full else \"false\"\n )\n else:\n pr_url = \"{}/job/PR-{}/build\".format(\n job_url.rstrip(\"/\"),\n pr_number,\n )\n res = requests.get(\n uri + \"/crumbIssuer/api/json\",\n auth=requests.auth.HTTPBasicAuth(user, password),\n verify=verify,\n )\n if res.status_code != 200:\n raise Exception(\"Jenkins returned non 200 response\")\n data = res.json()\n res = requests.post(\n pr_url,\n headers={\n \"Content-Type\": \"application/x-www-form-urlencoded\",\n data[\"crumbRequestField\"]: data[\"crumb\"],\n },\n auth=requests.auth.HTTPBasicAuth(user, password),\n verify=verify,\n )\n if res.status_code == 201:\n log.info(\"Build started: %s\", pr_url)\n else:\n log.info(\"Build request received non 201 status: %s\", res.status_code)", "def _create_job(self, tjc, machine, build_url, project, revision, build_type, build_abi,\n build_platform, build_sdk, builder_type, t):\n logger = utils.getLogger()\n logger.debug('AutophoneTreeherder.create_job: %s', t)\n assert self.url and revision, 'AutophoneTreeherder.create_job: no url/revision'\n\n if len(revision) != 40:\n logger.warning('AutophoneTreeherder using revision with length %d: %s',\n len(revision), revision)\n\n logger.info('creating Treeherder job %s for %s %s, revision: %s',\n t.job_guid, t.name, project, revision)\n if not t.job_guid:\n logger.error(\n '_create_job: invalid job_guid %s for test %s, '\n 'machine: %s, build_url: %s, project: %s, revision: %s, '\n 'build_type: %s, build_abi: %s, build_platform: %s, '\n 'build_sdk: %s, builder_type: %s',\n t.name, t.job_guid, machine, build_url, project,\n revision, build_type, build_abi, build_platform,\n build_sdk, builder_type)\n raise Exception('Can not create Treeherder Job with invalid test job_guid')\n\n logger.debug('AutophoneTreeherder.create_job: test config_file=%s, config sections=%s',\n t.config_file, t.cfg.sections())\n\n tj = tjc.get_job()\n tj.add_tier(self.options.treeherder_tier)\n tj.add_revision(revision)\n tj.add_project(project)\n tj.add_job_guid(t.job_guid)\n tj.add_job_name(t.job_name)\n tj.add_job_symbol(t.job_symbol)\n tj.add_group_name(t.group_name)\n tj.add_group_symbol(t.group_symbol)\n tj.add_product_name('fennec')\n\n tj.add_machine(machine)\n build_platform = platform(architecture(build_abi),\n build_platform,\n build_sdk)\n build_architecture = architecture(build_abi)\n machine_platform = platform(architecture(t.phone.abi),\n t.phone.os,\n build_sdk)\n machine_architecture = architecture(t.phone.abi)\n tj.add_build_info('android', build_platform, build_architecture)\n tj.add_machine_info('android', machine_platform, machine_architecture)\n tj.add_option_collection({build_type: True})\n\n # Add job details for storing information regarding the build (so we can\n # retrigger them)\n job_details = [\n {'title': title, 'value': str(value)} for (title, value) in [\n ('config_file', t.config_file),\n ('chunk', t.chunk),\n ('builder_type', builder_type)\n ]\n ]\n job_details.append({'title': 'build_url',\n 'value': 'build_url',\n 'url': build_url})\n tj.add_artifact('Job Info', 'json', {\n 'job_details': job_details\n })\n\n return tj", "async def create_job(response: Response,\n request: Request,\n job: Job = Body(\n ...,\n example={\n \"id_video\": \"bbb_0.mp4\",\n \"bitrate\": 7000,\n \"speed\": \"ultrafast\",\n },\n )\n ): \n \n\n # get an ID and return to client\n id_job = mngr.getID()\n logger.debug(\"got id_job %s\" %id_job)\n resp = [\"http:/\"]\n resp.append(request.headers['host'])\n resp.append(id_job)\n response.headers[\"Location\"] = \"/\".join(resp)\n\n # create the task\n mngr.newJob(id_job, \n job.id_video, \n job.bitrate, \n job.speed)\n\n return id_job", "def create(cls, job_id: str) -> \"JobManifest\":\n now = datetime.datetime.now(datetime.timezone.utc)\n return JobManifest(creation_time=now, job_id=job_id, orbit_ids=[], task_ids=[])", "def create_job(self, employer_id, compensation, location, description, category_id, group_id):\n\n job = Job(employer_id=employer_id, group_id=group_id, compensation=compensation, location=location, category_id=category_id, description=description) \n db.session.add(job)\n db.session.commit()", "def jobserver_job():\n return _MakeJob()", "def add_new_job():\n ClientID = request.form['ClientID']\n job_name = request.form['job_name']\n rate = int(float(request.form['rate']) * 100)\n\n job = Job(Name=job_name, ClientID=ClientID, DefaultRate=rate, Active=True)\n\n get_module_logger().info(\"Created job %s\", job)\n\n job.insert()\n\n return redirect(url_for('all_jobs_for_client', ClientID=ClientID))", "def post(self):\n data, errors = JobSchema().loads(request.data)\n\n if errors:\n return Response().send(\n data=None, status=400, code=\"bad_request\", message=errors\n )\n return self.job.create(request.json)", "def test_create_job(self):\n engine = Engine(self.config_file, self.api_token)\n\n engine.create_job()\n\n assert engine.ingest_job_id == 23", "def create_job_object(job_type: int = 0,\n team_id: int = 0,\n destination_name: str = None,\n destination_lat: float = 0,\n destination_lng: float = 0,\n destination_text: str = None,\n destination_url: str = None,\n text_dispatcher: str = None,\n text_receiver: str = None,\n contact_name: str = None,\n contact_phone: str = None,\n contact_email: str = None,\n day: int = None,\n priority: int = None,\n number: int = None,\n on_site_seconds: int = None,\n window_start: int = None,\n window_end: int = None,\n order_id: int = None,\n dispatcher_uid: str = None,\n place_uid: str = None,\n worker: str = None,\n items_to_dropoff: int = None,\n items_to_pickup: int = None,\n custom_attributes: dict = None) -> dict:\n\n job = {\n \"type\": job_type,\n \"teamId\": team_id,\n \"destinationName\": destination_name,\n \"destinationLat\": destination_lat,\n \"destinationLng\": destination_lng,\n \"destinationText\": destination_text,\n \"destinationUrl\": destination_url,\n \"textDispatcher\": text_dispatcher,\n \"textReceiver\": text_receiver,\n \"contactName\": contact_name,\n \"contactPhone\": contact_phone,\n \"contactEmail\": contact_email,\n \"day\": day,\n \"priority\": priority,\n \"number\": number,\n \"onSiteSeconds\": on_site_seconds,\n \"windowStart\": window_start,\n \"windowEnd\": window_end,\n \"orderId\": order_id,\n \"dispatcherUid\": dispatcher_uid,\n \"placeUid\": place_uid,\n \"worker\": worker,\n \"itemsToDropoff\": items_to_dropoff,\n \"itemsToPickup\": items_to_pickup\n }\n job_without_none = {k: v for k, v in job.items() if v is not None}\n job.clear()\n job.update(job_without_none)\n\n if custom_attributes:\n job.update({f\"custom_{k}\": v for k, v in custom_attributes.items() if k})\n\n return job" ]

[ "0.7520048", "0.7107826", "0.7052509", "0.70495903", "0.7000261", "0.6887487", "0.68790656", "0.6827953", "0.6707598", "0.66782993", "0.6650939", "0.6482045", "0.6402906", "0.63344806", "0.6322465", "0.62909174", "0.6267784", "0.62481385", "0.6242675", "0.6240722", "0.62374854", "0.62191284", "0.6191502", "0.6134481", "0.61327434", "0.608689", "0.6004062", "0.592998", "0.5928104", "0.5915662" ]

[ "def update(cfg, jobs):\n server = jenkins_utils.server_factory(cfg)\n libjobs.updateJobs(server, jobs)", "def update(self, job_name, param_name, value, description=None):\n if job_name in self._jobs:\n getattr(self._jobs[job_name], param_name).update(value, description)\n else:\n self.log.error(\"Invalid job name: %s\", job_name)", "def update(self):\n self._log.debug(\"About to update job {0}\".format(self.id))\n resp = self._api.get_job(self.id)\n\n if resp.success:\n self.submission = self._format_submission(resp.result)\n return True\n\n else:\n raise resp.result", "def on_job_update(_job):\n nonlocal job\n job = _job", "def on_job_update(_job):\n nonlocal job\n job = _job", "def on_job_update(_job):\n nonlocal job\n job = _job", "def on_job_update(_job):\n nonlocal job\n job = _job", "def update_job(self, job, token, status, est_complete, context=None):\n return self._client.call_method(\n 'UserAndJobState.update_job',\n [job, token, status, est_complete], self._service_ver, context)", "def on_job_update(_job):\n nonlocal job, job_update_counter\n\n # Cancel the job when it updates in the `WORKING` state for the\n # second time. We do it just to be sure it is somewhere in the\n # middle of executions.\n if (job is not None and\n _job.state == job.state == 'WORKING'):\n my_job_gen.job_manager_class.cancel(job.id)\n\n job = _job\n job_update_counter += 1", "def put(self, job_id):\n form = request.get_json()\n try:\n the_job = jobs.find_job_by_id(job_id)\n if the_job is None:\n return get_message_json('任务不存在'), HTTPStatus.NOT_FOUND\n\n if the_job.account_id != current_user.account_id:\n return get_message_json('用户无法修改他人任务'), HTTPStatus.FORBIDDEN\n\n # The job state must be valid and can not go back\n form_job_state = form.get('job_state')\n if not(validate_job_state_code(form_job_state) and form_job_state >= the_job.job_state):\n return get_message_json('任务状态不合法'), HTTPStatus.BAD_REQUEST\n\n # Client can edit label id if and only if the job is 'unlabeled'\n form_label_id = form.get('label_id')\n if the_job.job_state == ConstantCodes.Unlabeled:\n if not form_label_id:\n return get_message_json('必须为该任务提供对应的标注'), HTTPStatus.BAD_REQUEST\n elif the_job.job_state == ConstantCodes.Labeling:\n # Can NOT change the label id\n if form_label_id is not None and form_label_id != the_job.label_id:\n return get_message_json('用户无法替换任务的标注'), HTTPStatus.FORBIDDEN\n elif the_job.job_state == ConstantCodes.Finished:\n return get_message_json('用户无法修改已完成的任务'), HTTPStatus.FORBIDDEN\n\n # Update finished date automatically when the job is updated to be finished\n finished_date = None\n if form_job_state == ConstantCodes.Finished:\n finished_date = datetime.date.today()\n\n if not form_label_id:\n form_label_id = the_job.label_id\n\n result = jobs.update_job_by_id(\n job_id,\n form_label_id,\n finished_date,\n form_job_state,\n the_job.image_id,\n the_job.account_id\n )\n if result == 1:\n json_res = form.copy()\n json_res['message'] = '成功编辑任务'\n\n return json_res, HTTPStatus.OK\n else:\n return get_message_json('未知的任务更新失败'), HTTPStatus.BAD_REQUEST\n\n except IntegrityError as err:\n if err.orig.args[0] == DBErrorCodes.FOREIGN_KEY_FAILURE:\n return get_message_json('指定的用户或标注不存在'), HTTPStatus.BAD_REQUEST\n else:\n return handle_internal_error(err.orig.args[1])\n except Exception as err:\n return handle_internal_error(str(err))", "def on_job_update(_job):\n nonlocal job, job_update_counter\n\n # Cancel the job when it updates in the `WORKING` state for the\n # second time. We do it just to be sure it is somewhere in the\n # middle of execution.\n if (job is not None and\n _job.state == job.state == 'WORKING'):\n my_job_async_gen.job_manager_class.cancel(job.id)\n\n job = _job\n job_update_counter += 1", "def update(self) -> None:\n self.previous_status = self.status\n\n jobs = self._client.describe_jobs(jobs = [ self.id ])[\"jobs\"]\n\n try:\n self.state = jobs[0]\n except IndexError:\n raise ValueError(\"Invalid or unknown job id %s\" % self.id) from None", "def on_job_update(_job):\n nonlocal job\n job = _job\n # Asserts that job is either pending or canceled.\n assert job.state in ['PENDING', 'CANCELED'], (\n 'job that canceled immediately after submission has wrong '\n 'state `%s`' % job.state\n )", "def on_job_update(_job):\n nonlocal job\n job = _job\n # Asserts that job is either pending or canceled.\n assert job.state in ['PENDING', 'CANCELED'], (\n 'Job that canceled immediately after submission has wrong '\n 'state `{job.state}`!'\n )", "def on_job_update(_job):\n nonlocal job\n job = _job\n # Asserts that job is either pending or canceled.\n assert job.state in ['PENDING', 'CANCELED'], (\n 'Job that canceled immediately after submission has wrong '\n f'state `{job.state}`!')", "def on_job_update(_job):\n nonlocal job\n job = _job\n # Asserts that job is either pending or canceled.\n assert job.state in ['PENDING', 'CANCELED'], (\n 'Job that canceled immediately after submission has wrong '\n f'state `{job.state}`!')", "def on_job_update(_job):\n nonlocal job\n job = _job\n # Asserts that job is either pending or canceled.\n assert job.state in ['PENDING', 'CANCELED'], (\n 'Job that canceled immediately after submission has wrong '\n f'state `{job.state}`!')", "def update_job_state(self, job):", "def update(self, request, pk=None):\n\n job = Job.objects.get(pk=pk)\n job.title = request.data[\"title\"]\n job.description = request.data[\"description\"]\n job.city = request.data[\"city\"]\n job.state = request.data[\"state\"]\n job.application = request.data[\"application\"]\n user = request.auth.user\n job.user = user\n job.save()\n\n return Response({}, status=status.HTTP_204_NO_CONTENT)", "def run_job(playerID, rF2root, job, config):\n _j = Job(job, config)\n # read the file to be edited\n try:\n _j.read_json_file_to_be_edited()\n # do the edits\n try:\n _edit_count = _j.run_edits()\n if _edit_count:\n # if successful:\n # backup 'filepath'\n # save new contents to 'filepath\n _report = _j.backup_file()\n _j.write()\n else:\n _report = ''\n return _report\n except (KeyError, ValueError, EmptyJsonError) as e:\n raise JobFailedError\n except JsonContentError:\n raise FileNotFoundError", "def on_job_update(_job):\n nonlocal job\n job = _job\n\n if job.state in ['WORKING', 'DONE', 'ERROR']:\n canceled = my_job.job_manager_class.cancel(job.id)\n assert not canceled, (\n f'Uncancelable job is canceled in the `{job.state}` state!')", "def update_job_metrics(self, job_id:int)->None:\n with connection.cursor() as cursor:\n cursor.execute(f\"SELECT update_job_metrics({job_id})\")\n ##TODO: this should return something ", "def update_job_status(self, job_id, status):\n\n if not (job_id and status):\n raise ValueError(\"Please provide both job_id and status\")\n\n job = self.get_mongo_util().get_job(job_id=job_id)\n self._test_job_permissions(job, job_id, JobPermissions.WRITE)\n\n job.status = status\n with self.get_mongo_util().mongo_engine_connection():\n job.save()\n\n return str(job.id)", "def on_job_update(_job):\n nonlocal job\n job = _job\n\n if job.state in ['DONE', 'ERROR', 'WORKING']:\n canceled = my_job_async.job_manager_class.cancel(job.id)\n assert not canceled, (\n f'Uncancelable job is canceled in the `{job.state}` state!')", "def job_status(bot, update, args, job_queue, chat_data):\n if len(args) == 0:\n update.message.reply_text('No parameter provided')\n return\n\n job_name = args[0]\n if job_name not in settings.JOBS:\n update.message.reply_text(\n 'Sorry {0} is not a valid job'.format(job_name))\n return\n\n job = find_job(job_name, job_queue)\n\n if not job:\n update.message.reply_text('{0} job is not running'.format(job_name))\n return\n\n update.message.reply_text('{0} job is running'.format(job_name))", "def job(self, job: str):\n\n self._job = job", "def job(self, job: str):\n\n self._job = job", "def _update(self):\n _logme.log('Updating job.', 'debug')\n self._updating = True\n if self.done or not self.submitted:\n self._updating = False\n return\n self.queue.update()\n if self.id:\n queue_info = self.queue[self.id]\n if queue_info:\n assert self.id == queue_info.id\n self.queue_info = queue_info\n self.state = self.queue_info.state\n if self.state == 'completed':\n if not self._got_exitcode:\n self.get_exitcode()\n if not self._got_times:\n self.get_times()\n self._updating = False", "def update_job_status(jid, new_status):\n jrd.hset(_generate_job_key(jid), 'status', new_status)", "def save_job(self, job):\n data = {\n 'class': 'Job',\n 'id': job.id,\n 'attrs': {\n 'type': job.type,\n 'task': job.task,\n 'command': job.command,\n 'status': job.status.value,\n 'runner': job.runner_id,\n },\n }\n self.db_client.send_request('update', json.dumps(data))" ]

[ "0.7519566", "0.7305608", "0.72748035", "0.67824453", "0.67824453", "0.67824453", "0.67824453", "0.65911585", "0.6502356", "0.64618725", "0.6382063", "0.6357814", "0.6337168", "0.6310358", "0.63080525", "0.63080525", "0.63080525", "0.62912005", "0.6251998", "0.61053956", "0.60982627", "0.6090971", "0.60133094", "0.59893095", "0.5970912", "0.59670943", "0.59670943", "0.5961652", "0.5913073", "0.58726716" ]

[ "def set_current_build_description(self, description):\n job_name = os.environ.get(\"JOB_NAME\", None)\n build_id = os.environ.get(\"BUILD_NUMBER\", None)\n if job_name is not None and build_id is not None:\n self.set_build_description(job_name, build_id, description)", "def update_experiment_description(self, experiment_id, description):\n return self.dbclient.update_by_id(Tables.EXPERIMENTS, experiment_id, {\n ExperimentAttr.DESC: description\n })", "def update(self, job_name, param_name, value, description=None):\n if job_name in self._jobs:\n getattr(self._jobs[job_name], param_name).update(value, description)\n else:\n self.log.error(\"Invalid job name: %s\", job_name)", "def update_info(self, *args, **kwargs):\n # Create the layout with the information\n self.info_widgets_list = [\n urwid.Text('ID: {}'.format(self.job.id)),\n urwid.Divider('='),\n urwid.Text('Command: {}'.format(self.job.command)),\n urwid.Text('Status: {}'.format(self.job.status))\n ]\n\n if self.job.status == JobStatus.FAILED: # If job has failed add error reason (if available)\n if 'Error reason' in self.job.metadata:\n self.info_widgets_list.append(urwid.Text('Possible error reason: {}'.format(self.job.metadata['Error reason'])))\n\n # Add button with the option available depending on the job status\n if self.job.status in [JobStatus.DONE, JobStatus.FAILED]:\n self.info_widgets_list.append(urwid.Padding(JobResubmitWidget(self.job, callback=self.resubmit), align='center', left=4, right=2))\n self.info_widgets_list.append(urwid.Divider('-'))\n elif self.job.status != JobStatus.UNSUBMITTED:\n self.info_widgets_list.append(create_button('Kill', self.terminate))\n self.info_widgets_list.append(urwid.Divider('-'))\n\n self.metadata_widgets_list = []\n self.metadata_widgets_list.append(urwid.Text('Retries: {}'.format(self.job.retries)))\n self.metadata_widgets_list.append(urwid.Divider())\n # Add resources requested by the job\n requested_resources = 'Specific requested resources:\\n'\n requested_resources += ' '+str(self.job.params).replace('\\n', '\\n ')\n self.metadata_widgets_list.append(urwid.Text(requested_resources))\n\n # If usage information is available, display it\n if 'usage' in self.job.metadata:\n self.metadata_widgets_list.append(urwid.Divider())\n used_resources = 'Used resources:\\n'\n used_resources += \"\\n\".join([\" {} = {}\".format(k, v) for k, v in self.job.metadata['usage'].items()])\n self.metadata_widgets_list.append(urwid.Text(used_resources))\n\n self.file_widgets_list = [] # Reset files widget\n # Create widget with the files if the job has failed\n if self.job.status == JobStatus.FAILED:\n # Generate wigets with stdout and stderr if available. Done here because Failed state is \"absolute\"=\n stdout_widget = self._load_file_as_widget(self.job.f_stdout, 'stdout')\n if stdout_widget is not None:\n self.file_widgets_list.append(stdout_widget)\n self.file_widgets_list.append(urwid.Divider('*'))\n stderr_widget = self._load_file_as_widget(self.job.f_stderr, 'stderr')\n if stderr_widget is not None:\n self.file_widgets_list.append(stderr_widget)\n self.file_widgets_list.append(urwid.Divider('*'))", "def edit_description(self, task, new_description):\n raise ValueError(\"cannot edit description in 'In Progress' status\")", "def request_description_update():\n global should_update_description\n should_update_description = True", "def update_job(self, job):\n call = subprocess.Popen(self.cli + [PlatformJenkinsJavaCLI.UPDATE_JOB, job.name], stdin=subprocess.PIPE)\n call.communicate(input=platform_ci.jjb.get_job_as_xml(job, self.template_dir))\n call.wait()\n if call.returncode != 0:\n raise PlatformJenkinsException(\"Updating job failed: \" + job.name)", "async def slashtag_edit_description(\n self, ctx: commands.Context, tag: GuildTagConverter, *, description: str\n ):\n await ctx.send(await tag.edit_description(description))", "def description(self, new_description):\r\n self.set({\"description\": new_description})", "def setDescription(self, description):\n url = G.api + self.testId + '/snapshots/' + self.hash\n self.info = requests.put(url, auth=(G.username, G.authkey), data={'description':description})", "def updateJobData(self, jobName):\n self.jobRow.setText(jobName)\n self.updateSelectedLayer()", "def submission_update_description(request, submission_pk):\n try:\n submission = models.CompetitionSubmission.objects.get(pk=submission_pk)\n if submission.participant.user != request.user:\n raise Http404()\n submission.description = request.POST.get('updated_description')\n submission.save()\n return HttpResponse()\n except models.CompetitionSubmission.DoesNotExist:\n raise Http404()", "def update(self):\n self._log.debug(\"About to update job {0}\".format(self.id))\n resp = self._api.get_job(self.id)\n\n if resp.success:\n self.submission = self._format_submission(resp.result)\n return True\n\n else:\n raise resp.result", "def describe_text_translation_job(JobId=None):\n pass", "def set_longdescription(self, longdesc):\n self.longdescription(longdesc)", "def update_description_debounced(self, value):\n self.update_description(value)", "def update(cfg, jobs):\n server = jenkins_utils.server_factory(cfg)\n libjobs.updateJobs(server, jobs)", "def EventContentMissionExcelAddDescription(builder, Description):\n return AddDescription(builder, Description)", "def update_description(self, option, desc):\n _, command = self.__options[option]\n self.__options[option] = (desc, command)", "def long_description(self, long_description):\n self._long_description = long_description", "def get_job_description(self, job, context=None):\n return self._client.call_method(\n 'UserAndJobState.get_job_description',\n [job], self._service_ver, context)", "def update_description(self, host, baseUrl, description):\n self._host = host\n self._urlBase = baseUrl\n self._description = description\n return", "def update_model_description(\n self, content: Dict[str, Any], model_name: str, is_already_documented: bool = False\n ) -> Dict[str, Any]:\n message = f\"Do you want to write a description for {model_name}\"\n if is_already_documented:\n message = f\"Do you want to change the model description of {model_name}\"\n model_doc_payload: List[Mapping[str, Any]] = [\n {\n \"type\": \"confirm\",\n \"name\": \"wants_to_document_model\",\n \"message\": message,\n \"default\": True,\n },\n {\n \"type\": \"text\",\n \"name\": \"model_description\",\n \"message\": \"Please write down your description:\",\n },\n ]\n user_input = UserInputCollector(\"model\", model_doc_payload).collect()\n if user_input.get(\"model_description\", None):\n for model in content.get(\"models\", []):\n if model[\"name\"] == model_name:\n model[\"description\"] = user_input[\"model_description\"]\n return content", "def put(self, job_id):\n form = request.get_json()\n try:\n the_job = jobs.find_job_by_id(job_id)\n if the_job is None:\n return get_message_json('任务不存在'), HTTPStatus.NOT_FOUND\n\n if the_job.account_id != current_user.account_id:\n return get_message_json('用户无法修改他人任务'), HTTPStatus.FORBIDDEN\n\n # The job state must be valid and can not go back\n form_job_state = form.get('job_state')\n if not(validate_job_state_code(form_job_state) and form_job_state >= the_job.job_state):\n return get_message_json('任务状态不合法'), HTTPStatus.BAD_REQUEST\n\n # Client can edit label id if and only if the job is 'unlabeled'\n form_label_id = form.get('label_id')\n if the_job.job_state == ConstantCodes.Unlabeled:\n if not form_label_id:\n return get_message_json('必须为该任务提供对应的标注'), HTTPStatus.BAD_REQUEST\n elif the_job.job_state == ConstantCodes.Labeling:\n # Can NOT change the label id\n if form_label_id is not None and form_label_id != the_job.label_id:\n return get_message_json('用户无法替换任务的标注'), HTTPStatus.FORBIDDEN\n elif the_job.job_state == ConstantCodes.Finished:\n return get_message_json('用户无法修改已完成的任务'), HTTPStatus.FORBIDDEN\n\n # Update finished date automatically when the job is updated to be finished\n finished_date = None\n if form_job_state == ConstantCodes.Finished:\n finished_date = datetime.date.today()\n\n if not form_label_id:\n form_label_id = the_job.label_id\n\n result = jobs.update_job_by_id(\n job_id,\n form_label_id,\n finished_date,\n form_job_state,\n the_job.image_id,\n the_job.account_id\n )\n if result == 1:\n json_res = form.copy()\n json_res['message'] = '成功编辑任务'\n\n return json_res, HTTPStatus.OK\n else:\n return get_message_json('未知的任务更新失败'), HTTPStatus.BAD_REQUEST\n\n except IntegrityError as err:\n if err.orig.args[0] == DBErrorCodes.FOREIGN_KEY_FAILURE:\n return get_message_json('指定的用户或标注不存在'), HTTPStatus.BAD_REQUEST\n else:\n return handle_internal_error(err.orig.args[1])\n except Exception as err:\n return handle_internal_error(str(err))", "def update(repository, args, **_):\n _log(repository, 'INFO', \"Going to build commit %s\" % args[2][:7])", "def _append_descriptions(self, issue, dep_name, dep_latest_version):\n logging.info(\"Updating JIRA issue {0} to track {1} upgrade process\".format(\n issue.key,\n dep_name))\n description = issue.fields.description + \"\"\"\\n\\n{0}\\n\n Please review and upgrade the {1} to the latest version {2} \\n \n cc: \"\"\".format(\n datetime.today(),\n dep_name,\n dep_latest_version\n )\n _, owners = self._find_owners(dep_name)\n for owner in owners:\n description += \"[~{0}], \".format(owner)\n try:\n self.jira.update_issue(issue, description=description)\n except Exception as e:\n traceback.print_exc()\n logging.error(\"Failed updating issue: \"+ str(e))", "def update_job_state(self, job):", "def build_description(self):\n return self._build_description", "def description(self, newDescription=None):\n pass", "def update(self) -> None:\n self.previous_status = self.status\n\n jobs = self._client.describe_jobs(jobs = [ self.id ])[\"jobs\"]\n\n try:\n self.state = jobs[0]\n except IndexError:\n raise ValueError(\"Invalid or unknown job id %s\" % self.id) from None" ]

[ "0.72318727", "0.60756296", "0.60743475", "0.6020576", "0.5999859", "0.59925103", "0.59728664", "0.5708703", "0.5699203", "0.56206816", "0.55843204", "0.55488455", "0.55029446", "0.548009", "0.5469594", "0.5459312", "0.54585123", "0.5456848", "0.5452424", "0.54208547", "0.5387264", "0.53862894", "0.5376971", "0.5344236", "0.5311184", "0.53074163", "0.5272898", "0.5266738", "0.5258574", "0.52426124" ]

[ "def set_build_description(self, job_name, build, description):\n try:\n subprocess.check_call(self.cli + [PlatformJenkinsJavaCLI.SET_DESCRIPTION, job_name, build, description])\n except subprocess.CalledProcessError:\n message = \"Setting build description failed (job={0}, build={1}, description='{2}')\".format(job_name,\n build,\n description)\n raise PlatformJenkinsException(message)", "def update_experiment_description(self, experiment_id, description):\n return self.dbclient.update_by_id(Tables.EXPERIMENTS, experiment_id, {\n ExperimentAttr.DESC: description\n })", "def request_description_update():\n global should_update_description\n should_update_description = True", "def update_description(self, host, baseUrl, description):\n self._host = host\n self._urlBase = baseUrl\n self._description = description\n return", "def description(request):\n if request.method != 'POST':\n description = request.issue.description or \"\"\n return HttpTextResponse(description)\n if not request.issue.edit_allowed:\n if not IS_DEV:\n return HttpTextResponse('Login required', status=401)\n issue = request.issue\n issue.description = request.POST.get('description')\n issue.put()\n return HttpTextResponse('')", "def edit_description(self, task, new_description):\n raise ValueError(\"cannot edit description in 'In Progress' status\")", "def set_variable_value():\n\n mp_rp_conf_file = 'entitlement-tests/CCI/ReportPortal/mp_rp_conf.json'\n \n # 1. Set project name which is just the test product name with upper case letter\n cmd = \"sed -i -e 's/PROJECT_NAME/{0}/g' {1}\".format(test_product.upper(), mp_rp_conf_file)\n (ret, output) = commands.getstatusoutput(cmd)\n \n # 2. Set launch name\n # Launch name examples - Errata-49798_RHEL7_Server_x86_64_Full_ProdCDN; Errata-53717_RHEL8_x86_64_Full_ProdCDN\n cmd = \"sed -i -e 's/LAUNCH_NAME/{0}/g' {1}\".format(get_launch_name(), mp_rp_conf_file)\n (ret, output) = commands.getstatusoutput(cmd)\n \n # 3. Set variables value in description of launch\n # a) Set Errata url in description of launch\n errata_url = \"[{0}](https:\\/\\/errata.devel.redhat.com\\/advisory\\/{1})\".format(errata_id, errata_id)\n cmd = \"sed -i -e 's/ERRATA_URL/{0}/g' {1}\".format(errata_url, mp_rp_conf_file)\n (ret, output) = commands.getstatusoutput(cmd)\n \n # b) Set jenkins job url in description of launch\n build_id = build_url.strip('/').split('/')[-1]\n build_url_str = \"[{0}]({1})\".format(build_id, build_url.replace(\"/\",\"\\/\"))\n \n cmd = \"sed -i -e 's/BUILD_URL/{0}/g' {1}\".format(build_url_str, mp_rp_conf_file)\n (ret, output) = commands.getstatusoutput(cmd)\n \n # 4. Set launch tag\n # Tag examples - OpenStack16; Ceph3; CNV2\n cmd = \"cat product_version.txt\"\n (ret, output) = commands.getstatusoutput(cmd)\n \n cmd = \"sed -i -e 's/LAUNCH_TAG/{0}{1}/g' {2}\".format(test_product, output, mp_rp_conf_file)\n (ret, output) = commands.getstatusoutput(cmd)", "def format_description(self, project_name, description):\n description = description if description else ''\n return \"%s %s\" % (project_name, '- ' + description)", "def set_description(desc):\n global last_description\n last_description = desc", "def update(self, job_name, param_name, value, description=None):\n if job_name in self._jobs:\n getattr(self._jobs[job_name], param_name).update(value, description)\n else:\n self.log.error(\"Invalid job name: %s\", job_name)", "def set_description(self, room_description):\n self.description = room_description", "def set_description(self, description):\n self.description = description\n if not self.record:\n return\n self.mdb.results.update({'_id':self.result_id}, \n {'$set':{'test_case':description}})", "def get_job_description(self, job, context=None):\n return self._client.call_method(\n 'UserAndJobState.get_job_description',\n [job], self._service_ver, context)", "def set_description(self, desc: str) -> None:\n self.metadata.data[\"description\"] = desc", "def EventContentMissionExcelAddDescription(builder, Description):\n return AddDescription(builder, Description)", "def update_model_description(\n self, content: Dict[str, Any], model_name: str, is_already_documented: bool = False\n ) -> Dict[str, Any]:\n message = f\"Do you want to write a description for {model_name}\"\n if is_already_documented:\n message = f\"Do you want to change the model description of {model_name}\"\n model_doc_payload: List[Mapping[str, Any]] = [\n {\n \"type\": \"confirm\",\n \"name\": \"wants_to_document_model\",\n \"message\": message,\n \"default\": True,\n },\n {\n \"type\": \"text\",\n \"name\": \"model_description\",\n \"message\": \"Please write down your description:\",\n },\n ]\n user_input = UserInputCollector(\"model\", model_doc_payload).collect()\n if user_input.get(\"model_description\", None):\n for model in content.get(\"models\", []):\n if model[\"name\"] == model_name:\n model[\"description\"] = user_input[\"model_description\"]\n return content", "def buildname(self, env_prop=None):\n if self._buildname is not None:\n return self._buildname\n try:\n platform, build = env_prop['chipName'], env_prop['switchppVersion']\n except (KeyError, TypeError):\n message = 'Cannot determine build name'\n self.class_logger.warning(message)\n self._buildname = self.UNDEFINED_BUILD\n else:\n self.platform = platform\n self.build = build\n name_iter = (MODULES[_var].ReportingServerConfig._get_build_name(self._opts) for _var in # pylint: disable=protected-access\n MODULES if 'reports_conf.' in _var)\n with suppress(StopIteration): # retain build name from env_prop\n build = next(name for name in name_iter if name is not None)\n self._buildname = '{0}-{1}'.format(build, platform)\n\n # WORKAROUND to add 'sanity' suffix to buildname\n if 'sanity' in self._opts.markexpr and self._buildname is not None:\n self._buildname += \"-sanity\"\n # WORKAROUND END\n return self._buildname", "def set_description(urn: str, description: str, md_file: Path) -> None:\n\n if not urn.startswith(\"urn:li:dataProduct:\"):\n urn = f\"urn:li:dataProduct:{urn}\"\n\n if description is None and not md_file:\n click.secho(\n \"Need one of --description or --md-file provided to populate description field\",\n fg=\"red\",\n )\n raise click.Abort()\n\n if description and md_file:\n click.secho(\n \"Need only one of --description or --md-file provided to populate description field. You provided both.\",\n fg=\"red\",\n )\n raise click.Abort()\n\n if md_file:\n logger.info(f\"Opening file {md_file} for populating description\")\n with open(md_file) as fp:\n description = fp.read()\n\n dataproduct_patcher: DataProductPatchBuilder = DataProduct.get_patch_builder(urn)\n dataproduct_patcher.set_description(description)\n with get_default_graph() as graph:\n _abort_if_non_existent_urn(graph, urn, \"set description\")\n for mcp in dataproduct_patcher.build():\n graph.emit(mcp)", "def set_longdescription(self, longdesc):\n self.longdescription(longdesc)", "def long_description(self, long_description):\n self._long_description = long_description", "def SetDescription(self, description):\n self.description = str(description)", "def description(self, description) :\n\t\ttry :\n\t\t\tself._description = description\n\t\texcept Exception as e:\n\t\t\traise e", "def generate_description(jira_key: str, comment: str) -> str:\n if jira_key in comment:\n return comment\n else:\n return '{}: {}'.format(jira_key, comment)", "def _append_descriptions(self, issue, dep_name, dep_latest_version):\n logging.info(\"Updating JIRA issue {0} to track {1} upgrade process\".format(\n issue.key,\n dep_name))\n description = issue.fields.description + \"\"\"\\n\\n{0}\\n\n Please review and upgrade the {1} to the latest version {2} \\n \n cc: \"\"\".format(\n datetime.today(),\n dep_name,\n dep_latest_version\n )\n _, owners = self._find_owners(dep_name)\n for owner in owners:\n description += \"[~{0}], \".format(owner)\n try:\n self.jira.update_issue(issue, description=description)\n except Exception as e:\n traceback.print_exc()\n logging.error(\"Failed updating issue: \"+ str(e))", "def set_description(self, description):\r\n self.__description = description", "def set_description(self, description):\n self.description = description", "def set_desc(self, item_desc):\r\n self.description = item_desc", "def setDescription(self, description):\n url = G.api + self.testId + '/snapshots/' + self.hash\n self.info = requests.put(url, auth=(G.username, G.authkey), data={'description':description})", "async def slashtag_edit_description(\n self, ctx: commands.Context, tag: GuildTagConverter, *, description: str\n ):\n await ctx.send(await tag.edit_description(description))", "def description(self, new_description):\r\n self.set({\"description\": new_description})" ]

[ "0.77581465", "0.58388937", "0.55399406", "0.5432845", "0.5427102", "0.5406418", "0.5297104", "0.524192", "0.5240581", "0.5238138", "0.519109", "0.51833254", "0.5152861", "0.5104744", "0.5102506", "0.50946575", "0.50842863", "0.50842136", "0.5079061", "0.50598854", "0.5059168", "0.50519663", "0.5014469", "0.50041556", "0.49860138", "0.4979509", "0.49547186", "0.49539742", "0.49522904", "0.49368942" ]

[ "def buildExposureTable(exposures, fields, instruments):\n name = []\n ra = []\n dec= []\n field= []\n inst = []\n airmass = []\n mjd = []\n exptime = []\n epoch = []\n apcorr = []\n index = 0\n for k,e in exposures.items():\n name.append(e.name)\n ra.append(getDegree(e.coords.ra))\n dec.append(getDegree(e.coords.dec))\n field.append(fields[e.field].index)\n if e.instrument in specialInstruments:\n inst.append(specialInstruments[e.instrument])\n else:\n inst.append(instruments[e.instrument].index)\n e.index = index\n index += 1\n\n airmass.append(e.airmass)\n mjd.append(e.mjd)\n exptime.append(e.exptime)\n epoch.append(e.epoch)\n apcorr.append(e.apcorr)\n hdu = pf.BinTableHDU.from_columns(\\\n pf.ColDefs( [pf.Column(name='NAME',format=py_to_fits(name),array=name),\n pf.Column(name='RA',format=py_to_fits(ra),array=ra),\n pf.Column(name='DEC',format=py_to_fits(dec),array=dec),\n pf.Column(name='FIELDNUMBER',format=py_to_fits(field),array=field),\n pf.Column(name='INSTRUMENTNUMBER',format=py_to_fits(inst),\\\n array=inst),\n pf.Column(name=\"MJD\",format=py_to_fits(mjd),array=mjd),\n pf.Column(name=\"AIRMASS\",format=py_to_fits(airmass),array=airmass),\n pf.Column(name=\"EXPTIME\",format=py_to_fits(exptime),array=exptime),\n pf.Column(name=\"EPOCH\",format=py_to_fits(epoch),array=epoch),\n pf.Column(name=\"APCORR\",format=py_to_fits(apcorr),array=apcorr)] ),\n name = 'Exposures')\n # hdu.header['EXTNAME'] = 'Exposures'\n return hdu", "def make_test_observation_table(observatory_name='HESS', n_obs=10,\n az_range=Angle([0, 360], 'deg'),\n alt_range=Angle([45, 90], 'deg'),\n date_range=(Time('2010-01-01'),\n Time('2015-01-01')),\n use_abs_time=False,\n n_tels_range=(3, 4),\n random_state='random-seed'):\n from ..data import ObservationTable, observatory_locations\n random_state = get_random_state(random_state)\n\n n_obs_start = 1\n\n obs_table = ObservationTable()\n\n # build a time reference as the start of 2010\n dateref = Time('2010-01-01T00:00:00')\n dateref_mjd_fra, dateref_mjd_int = np.modf(dateref.mjd)\n\n # define table header\n obs_table.meta['OBSERVATORY_NAME'] = observatory_name\n obs_table.meta['MJDREFI'] = dateref_mjd_int\n obs_table.meta['MJDREFF'] = dateref_mjd_fra\n if use_abs_time:\n # show the observation times in UTC\n obs_table.meta['TIME_FORMAT'] = 'absolute'\n else:\n # show the observation times in seconds after the reference\n obs_table.meta['TIME_FORMAT'] = 'relative'\n header = obs_table.meta\n\n # obs id\n obs_id = np.arange(n_obs_start, n_obs_start + n_obs)\n obs_table['OBS_ID'] = obs_id\n\n # obs time: 30 min\n ontime = Quantity(30. * np.ones_like(obs_id), 'minute').to('second')\n obs_table['ONTIME'] = ontime\n\n # livetime: 25 min\n time_live = Quantity(25. * np.ones_like(obs_id), 'minute').to('second')\n obs_table['LIVETIME'] = time_live\n\n # start time\n # - random points between the start of 2010 and the end of 2014 (unless\n # otherwise specified)\n # - using the start of 2010 as a reference time for the header of the table\n # - observations restrict to night time (only if specified time interval is\n # more than 1 day)\n # - considering start of astronomical day at midday: implicit in setting\n # the start of the night, when generating random night hours\n datestart = date_range[0]\n dateend = date_range[1]\n time_start = random_state.uniform(datestart.mjd, dateend.mjd, len(obs_id))\n time_start = Time(time_start, format='mjd', scale='utc')\n\n # check if time interval selected is more than 1 day\n if (dateend - datestart).jd > 1.:\n # keep only the integer part (i.e. the day, not the fraction of the day)\n time_start_f, time_start_i = np.modf(time_start.mjd)\n time_start = Time(time_start_i, format='mjd', scale='utc')\n\n # random generation of night hours: 6 h (from 22 h to 4 h), leaving 1/2 h\n # time for the last run to finish\n night_start = Quantity(22., 'hour')\n night_duration = Quantity(5.5, 'hour')\n hour_start = random_state.uniform(night_start.value,\n night_start.value + night_duration.value,\n len(obs_id))\n hour_start = Quantity(hour_start, 'hour')\n\n # add night hour to integer part of MJD\n time_start += hour_start\n\n if use_abs_time:\n # show the observation times in UTC\n time_start = Time(time_start.isot)\n else:\n # show the observation times in seconds after the reference\n time_start = time_relative_to_ref(time_start, header)\n # converting to quantity (better treatment of units)\n time_start = Quantity(time_start.sec, 'second')\n\n obs_table['TSTART'] = time_start\n\n # stop time\n # calculated as TSTART + ONTIME\n if use_abs_time:\n time_stop = Time(obs_table['TSTART'])\n time_stop += TimeDelta(obs_table['ONTIME'])\n else:\n time_stop = TimeDelta(obs_table['TSTART'])\n time_stop += TimeDelta(obs_table['ONTIME'])\n # converting to quantity (better treatment of units)\n time_stop = Quantity(time_stop.sec, 'second')\n\n obs_table['TSTOP'] = time_stop\n\n # az, alt\n # random points in a portion of sphere; default: above 45 deg altitude\n az, alt = sample_sphere(size=len(obs_id),\n lon_range=az_range,\n lat_range=alt_range,\n random_state=random_state)\n az = Angle(az, 'deg')\n alt = Angle(alt, 'deg')\n obs_table['AZ'] = az\n obs_table['ALT'] = alt\n\n # RA, dec\n # derive from az, alt taking into account that alt, az represent the values\n # at the middle of the observation, i.e. at time_ref + (TIME_START + TIME_STOP)/2\n # (or better: time_ref + TIME_START + (TIME_OBSERVATION/2))\n # in use_abs_time mode, the time_ref should not be added, since it's already included\n # in TIME_START and TIME_STOP\n az = Angle(obs_table['AZ'])\n alt = Angle(obs_table['ALT'])\n if use_abs_time:\n obstime = Time(obs_table['TSTART'])\n obstime += TimeDelta(obs_table['ONTIME']) / 2.\n else:\n obstime = time_ref_from_dict(obs_table.meta)\n obstime += TimeDelta(obs_table['TSTART'])\n obstime += TimeDelta(obs_table['ONTIME']) / 2.\n location = observatory_locations[observatory_name]\n altaz_frame = AltAz(obstime=obstime, location=location)\n alt_az_coord = SkyCoord(az, alt, frame=altaz_frame)\n sky_coord = alt_az_coord.transform_to('icrs')\n obs_table['RA'] = sky_coord.ra\n obs_table['DEC'] = sky_coord.dec\n\n # positions\n\n # number of telescopes\n # random integers in a specified range; default: between 3 and 4\n n_tels = random_state.randint(n_tels_range[0], n_tels_range[1] + 1, len(obs_id))\n obs_table['N_TELS'] = n_tels\n\n # muon efficiency\n # random between 0.6 and 1.0\n muoneff = random_state.uniform(low=0.6, high=1.0, size=len(obs_id))\n obs_table['MUONEFF'] = muoneff\n\n return obs_table", "def add_observations(instrument_id, obstable):\n\n if Session.registry.has():\n session = Session()\n else:\n session = Session(bind=DBSession.session_factory.kw[\"bind\"])\n\n # if the fields do not yet exist, we need to add them\n if ('RA' in obstable) and ('Dec' in obstable) and not ('field_id' in obstable):\n instrument = session.query(Instrument).get(instrument_id)\n regions = Regions.parse(instrument.region, format='ds9')\n field_data = obstable[['RA', 'Dec']]\n field_ids = add_tiles(\n instrument.id, instrument.name, regions, field_data, session=session\n )\n obstable['field_id'] = field_ids\n\n try:\n observations = []\n for index, row in obstable.iterrows():\n field_id = int(row[\"field_id\"])\n field = (\n session.query(InstrumentField)\n .filter(\n InstrumentField.instrument_id == instrument_id,\n InstrumentField.field_id == field_id,\n )\n .first()\n )\n if field is None:\n return log(\n f\"Unable to add observations for instrument {instrument_id}: Missing field {field_id}\"\n )\n\n observation = (\n session.query(ExecutedObservation)\n .filter_by(\n instrument_id=instrument_id, observation_id=row[\"observation_id\"]\n )\n .first()\n )\n if observation is not None:\n log(\n f\"Observation {row['observation_id']} for instrument {instrument_id} already exists... continuing.\"\n )\n continue\n\n # enable multiple obstime formats\n try:\n # can catch iso and isot this way\n obstime = Time(row[\"obstime\"])\n except ValueError:\n # otherwise catch jd as the numerical example\n obstime = Time(row[\"obstime\"], format='jd')\n\n observations.append(\n ExecutedObservation(\n instrument_id=instrument_id,\n observation_id=row[\"observation_id\"],\n instrument_field_id=field.id,\n obstime=obstime.datetime,\n seeing=row.get(\"seeing\", None),\n limmag=row[\"limmag\"],\n exposure_time=row[\"exposure_time\"],\n filt=row[\"filter\"],\n processed_fraction=row[\"processed_fraction\"],\n target_name=row[\"target_name\"],\n )\n )\n session.add_all(observations)\n session.commit()\n\n flow = Flow()\n flow.push('*', \"skyportal/REFRESH_OBSERVATIONS\")\n\n return log(f\"Successfully added observations for instrument {instrument_id}\")\n except Exception as e:\n return log(f\"Unable to add observations for instrument {instrument_id}: {e}\")\n finally:\n session.close()\n Session.remove()", "def movie_tbl(band,tranges,verbose=0,framesz=0,retries=20):\n\tif verbose:\n\t\tprint_inline('Populating exposure time table.')\n\ttstarts,tstops,exptimes=[],[],[]\n\tfor trange in tranges:\n\t\tstepsz = framesz if framesz else trange[1]-trange[0]\n\t\tsteps = np.ceil((trange[1]-trange[0])/stepsz)\n\t\tfor i,t0 in enumerate(np.arange(trange[0],trange[1],stepsz)):\n\t\t\tt1 = trange[1] if i==steps else t0+stepsz\n\t\t\ttstarts.append(t0)\n\t\t\ttstops.append(t1)\n\t\t\texptimes.append(dbt.compute_exptime(band,[t0,t1],\n\t\t\t\t\t\t\tverbose=verbose,retries=retries))\n\tcol1 = pyfits.Column(name='tstart',format='E',array=np.array(tstarts))\n\tcol2 = pyfits.Column(name='tstop',format='E',array=np.array(tstops))\n\tcol3 = pyfits.Column(name='exptime',format='E',array=np.array(exptimes))\n\tcols = pyfits.ColDefs([col1,col2,col3])\n\ttbl = pyfits.new_table(cols)\n\n\treturn tbl", "def info_for_all_observations(self):\n # Get all combinations of instrument, detector, filter, exp_type,\n all_combinations = []\n for i in range(len(self.info['Instrument'])):\n # Get instrument information for the exposure\n instrument = self.info['Instrument'][i]\n detector = self.info['detector'][i]\n if instrument == 'NIRCAM':\n detector = 'NRC{}'.format(detector)\n if '5' in detector:\n filtername = self.info['LongFilter'][i]\n pupilname = self.info['LongPupil'][i]\n detector = detector.replace('5', 'LONG')\n else:\n filtername = self.info['ShortFilter'][i]\n pupilname = self.info['ShortPupil'][i]\n elif instrument == 'NIRISS':\n filtername = self.info['ShortFilter'][i]\n pupilname = self.info['ShortPupil'][i]\n elif instrument == 'FGS':\n filtername = 'N/A'\n pupilname = 'N/A'\n readpattern = self.info['ReadoutPattern'][i]\n\n if instrument == 'NIRCAM':\n exptype = 'NRC_IMAGE'\n elif instrument == 'NIRISS':\n exptype = 'NIS_IMAGE'\n elif instrument == 'FGS':\n exptype = 'FGS_IMAGE'\n\n entry = (instrument, detector, filtername, pupilname, readpattern, exptype)\n all_combinations.append(entry)\n unique_combinations = list(set(all_combinations))\n return all_combinations, unique_combinations", "def file_table(list_observations, indir, informat, outfile):\n print('Creating file summary table ...')\n\n # We gather all infos in a list of dicts and write this\n # as a FITS table at the end.\n # for documentation see http://gamma-astro-data-formats.readthedocs.org/en/latest/data_storage/hdu_index/index.html\n\n HDU_CLASS_TAGS = dict(\n events='events',\n aeff='aeff_2d',\n edisp='edisp_2d',\n psf_3gauss='psf_3gauss',\n psf_king='psf_king',\n psf_table='psf_table',\n gti='gti'\n )\n\n rows = []\n for obs in list_observations.observations:\n testfile=obs.out_filename(\"events\", format=informat, dir=indir)\n try:\n table = Table.read(str(testfile), hdu='EVENTS')\n except Exception:\n print \"fits corrupted for file \"+str(filename)\n continue\n #for filetype in ['events', 'aeff', 'edisp', 'psf_3gauss']:\n #for filetype in ['events']:\n for filetype in ['events', 'aeff', 'edisp', 'psf_3gauss']:\n filename = obs.out_filename(filetype, format=informat, dir=indir)\n\n if filename.is_file():\n print('Processing {}'.format(filename))\n\n data = dict()\n\n # OBS_ID\n data['OBS_ID'] = obs.obs_id\n\n # HDU_TYPE\n if filetype in ('psf_3gauss'):\n data['HDU_TYPE'] = 'psf'\n else:\n data['HDU_TYPE'] = str(filetype)\n\n # HDU_CLASS\n data['HDU_CLASS'] = HDU_CLASS_TAGS[filetype]\n\n # FILE_DIR (relative path)\n data['FILE_DIR'] = str(os.path.relpath(str(obs.out_filename(filetype).parent), str(Path(outfile).parent)))\n\n # FILE_NAME\n data['FILE_NAME'] = str(obs.filename(filetype, format=informat).parts[-1])\n\n # HDU-INFOS\n hdu_list = fits.open(str(filename))\n hdu = hdu_list[1]\n header = hdu.header\n data['HDU_NAME'] = hdu.name\n\n # FILE-INFOS\n stat = filename.stat()\n data['SIZE'] = stat.st_size\n data['MTIME'] = stat.st_mtime\n data['MD5'] = hashlib.md5(filename.open('rb').read()).hexdigest()\n\n # if 'HDUCLAS2' in header:\n # data['HDUCLASS'] = header['HDUCLAS2']\n # else:\n # data['HDUCLASS'] = 'EVENTS'\n\n # if its the events-file, use a second dict for the gti-hdu\n if filetype == 'events':\n data_gti = dict()\n data_gti['OBS_ID'] = obs.obs_id\n data_gti['HDU_TYPE'] = 'gti'\n data_gti['HDU_CLASS'] = 'gti'\n data_gti['FILE_DIR'] = data['FILE_DIR']\n data_gti['FILE_NAME'] = data['FILE_NAME']\n data_gti['HDU_NAME'] = hdu_list[2].name\n data_gti['SIZE'] = data['SIZE']\n data_gti['MTIME'] = data['MTIME']\n data_gti['MD5'] = data['MD5']\n\n rows.append(data_gti)\n\n rows.append(data)\n hdu_list.close()\n\n else:\n print('File not found: {}'.format(filename))\n\n names = [\n 'OBS_ID', 'HDU_TYPE', 'HDU_CLASS',\n 'FILE_DIR', 'FILE_NAME', 'HDU_NAME',\n 'SIZE', 'MTIME', 'MD5'\n ]\n table = Table(rows=rows, names=names)\n\n print('Writing {}'.format(outfile))\n table.write(str(outfile), overwrite=True)\n # add hdu name\n hdulist = fits.open(str(outfile), mode='update')\n hdulist[1].name = 'HDU_INDEX'\n hdulist.close()", "def fill_obs(self, observation_table, data_store):\n for obs in observation_table:\n events = data_store.obs(obs_id=obs['OBS_ID']).events\n\n # TODO: filter out (mask) possible sources in the data\n # for now, the observation table should not contain any\n # run at or near an existing source\n\n self.counts_cube.fill_events([events])\n self.livetime_cube.data += events.observation_live_time_duration", "def file_table(list_observations, indir, informat, outfile):\n print('Creating file summary table ...')\n\n # We gather all infos in a list of dicts and write this\n # as a FITS table at the end.\n # for documentation see http://gamma-astro-data-formats.readthedocs.org/en/latest/data_storage/hdu_index/index.html\n\n HDU_CLASS_TAGS = dict(\n events='events',\n aeff='aeff_2d',\n edisp='edisp_2d',\n psf_3gauss='psf_3gauss',\n psf_king='psf_king',\n psf_table='psf_table',\n gti='gti'\n )\n\n rows = []\n for obs in list_observations.observations:\n events_filename = Path(indir) / obs.filename('events', format=informat)\n try:\n table = Table.read(str(events_filename), hdu='EVENTS')\n except Exception:\n print \"fits corrupted for file \" + str(events_filename)\n continue\n if table.meta[\"OBS_ID\"]!=obs.obs_id:\n continue\n # for filetype in ['events', 'aeff', 'edisp', 'psf_3gauss']:\n # for filetype in ['events']:\n #for filetype in ['events', 'aeff', 'edisp', 'psf_3gauss']:\n for filetype in ['events', 'aeff', 'edisp', 'psf_table']:\n filename = Path(indir) / obs.filename(filetype, format=informat)\n\n if filename.is_file():\n print('Processing {}'.format(filename))\n\n data = dict()\n\n # OBS_ID\n data['OBS_ID'] = obs.obs_id\n\n # HDU_TYPE\n if filetype in ('psf_3gauss'):\n data['HDU_TYPE'] = 'psf'\n elif filetype in ('psf_table'):\n data['HDU_TYPE'] = 'psf'\n else:\n data['HDU_TYPE'] = str(filetype)\n\n # HDU_CLASS\n data['HDU_CLASS'] = HDU_CLASS_TAGS[filetype]\n\n # FILE_DIR (relative path)\n data['FILE_DIR'] = str(\n os.path.relpath(str(obs.out_filename(filetype).parent), str(Path(outfile).parent)))\n\n # FILE_NAME\n data['FILE_NAME'] = str(obs.filename(filetype, format=informat).parts[-1])\n\n # HDU-INFOS\n hdu_list = fits.open(str(filename))\n hdu = hdu_list[1]\n header = hdu.header\n data['HDU_NAME'] = hdu.name\n\n # FILE-INFOS\n stat = filename.stat()\n data['SIZE'] = stat.st_size\n data['MTIME'] = stat.st_mtime\n data['MD5'] = hashlib.md5(filename.open('rb').read()).hexdigest()\n\n # if 'HDUCLAS2' in header:\n # data['HDUCLASS'] = header['HDUCLAS2']\n # else:\n # data['HDUCLASS'] = 'EVENTS'\n\n # if its the events-file, use a second dict for the gti-hdu\n if filetype == 'events':\n data_gti = dict()\n data_gti['OBS_ID'] = obs.obs_id\n data_gti['HDU_TYPE'] = 'gti'\n data_gti['HDU_CLASS'] = 'gti'\n data_gti['FILE_DIR'] = data['FILE_DIR']\n data_gti['FILE_NAME'] = data['FILE_NAME']\n data_gti['HDU_NAME'] = hdu_list[2].name\n data_gti['SIZE'] = data['SIZE']\n data_gti['MTIME'] = data['MTIME']\n data_gti['MD5'] = data['MD5']\n\n rows.append(data_gti)\n\n rows.append(data)\n hdu_list.close()\n\n else:\n print('File not found: {}'.format(filename))\n\n names = [\n 'OBS_ID', 'HDU_TYPE', 'HDU_CLASS',\n 'FILE_DIR', 'FILE_NAME', 'HDU_NAME',\n 'SIZE', 'MTIME', 'MD5'\n ]\n\n table = Table(rows=rows, names=names)\n\n print('Writing {}'.format(indir + \"/\" + str(outfile)))\n table.write(indir + \"/\" + str(outfile), overwrite=True)\n # add hdu name\n hdulist = fits.open(indir + \"/\" + str(outfile), mode='update')\n hdulist[1].name = 'HDU_INDEX'\n hdulist.close()", "def _generate_exposure(self, expstart, number):\n\n index_number = number - 1 # for zero indexing\n\n filename = '{:04d}_raw.fits'.format(number)\n\n exp_gen = ExposureGenerator(self.detector, self.grism, self.NSAMP,\n self.SAMPSEQ, self.SUBARRAY,\n self.planet, filename, expstart)\n\n if not self.spatial_scan:\n self.sample_rate = 1 * u.year # high number reverts to read times\n\n _, sample_mid_points, sample_durations, read_index = \\\n exp_gen._gen_scanning_sample_times(self.sample_rate)\n\n time_array = (sample_mid_points + expstart).to(u.day)\n\n if self.transmission_spectroscopy:\n star_norm_flux = self.generate_lightcurves(time_array)\n planet_depths = 1 - star_norm_flux\n else:\n planet_depths = None\n\n # x shifts - linear shift with exposure, second exposure shifted by\n # x_shifts, direct image and first exp will match.\n x_ref = self._try_index(self.x_ref, index_number)\n y_ref = self._try_index(self.y_ref, index_number)\n sky_background = self._try_index(self.sky_background, index_number)\n\n # X and Y Shifts\n x_ref += self.x_shifts * index_number\n y_ref += self.y_shifts * index_number\n x_jitter = self.x_jitter\n y_jitter = self.y_jitter\n\n if self._visit_trend:\n scale_factor = self._visit_trend.get_scale_factor(index_number)\n else:\n scale_factor = None\n\n if self.spatial_scan:\n exp_frame = exp_gen.scanning_frame(\n x_ref, y_ref, x_jitter, y_jitter,\n self.wl, self.stellar_flux, planet_depths,\n self.scan_speed, self.sample_rate, sample_mid_points,\n sample_durations, read_index, ssv_generator=self.ssv_gen,\n noise_mean=self.noise_mean, noise_std=self.noise_std,\n add_flat=self.add_flat, add_dark=self.add_dark,\n scale_factor=scale_factor, sky_background=sky_background,\n cosmic_rate=self.cosmic_rate,\n add_gain_variations=self.add_gain_variations,\n add_non_linear=self.add_non_linear,\n clip_values_det_limits=self.clip_values_det_limits,\n add_read_noise=self.add_read_noise,\n add_stellar_noise=self.add_stellar_noise,\n add_initial_bias=self.add_initial_bias,\n progress_bar=self.progess,\n threads=self.threads\n )\n else:\n exp_frame = exp_gen.staring_frame(\n x_ref, y_ref, x_jitter, y_jitter,\n self.wl, self.stellar_flux, planet_depths,\n sample_mid_points, sample_durations, read_index,\n noise_mean=self.noise_mean, noise_std=self.noise_std,\n add_flat=self.add_flat, add_dark=self.add_dark,\n scale_factor=scale_factor, sky_background=sky_background,\n cosmic_rate=self.cosmic_rate,\n add_gain_variations=self.add_gain_variations,\n add_non_linear=self.add_non_linear,\n clip_values_det_limits=self.clip_values_det_limits,\n add_read_noise=self.add_read_noise,\n add_stellar_noise=self.add_stellar_noise,\n add_initial_bias=self.add_initial_bias,\n progress_bar=self.progess,\n threads=self.threads\n )\n\n exp_frame.generate_fits(self.outdir, filename, ldcoeffs=self.ldcoeffs)\n\n return exp_frame", "def generate_exptime_table(self, ):\n\n # Perform calculation for all stars in biased sample\n Ndraw = self.NBIAS\n\n np.random.seed(seed=None)\n\n # Allocate memory for exposure times\n t_tots = np.zeros(Ndraw)\n tpbpcs = []\n pct_obs_iwas = []\n lammax_obs_iwas = []\n specs = []\n\n \"\"\"\n Calculate the exposure times and spectra in each bandpass for each\n star in biased sample\n \"\"\"\n\n # Loop over stars in this sample\n for i in range(Ndraw):\n #print(\"HIP %i, %.2f pc, %s \" %(hip[i], dist[i], stype[i]))\n\n # Set system parameters for this star\n self.prep_ith_star(i)\n\n # Calculate the time to observe the complete spectrum\n t_tots[i], tpbpc, spectrum, iwa = self.complete_spectrum_time()\n\n tpbpcs.append(tpbpc)\n pct_obs_iwas.append(iwa[0])\n specs.append(spectrum)\n\n # Calculate channel widths\n deltas = []\n for channel in CHANNELS:\n l = default_luvoir(channel=channel)\n deltas.append(l.lammax - l.lammin)\n self.deltas = np.array(deltas)\n\n # Calculate channel fractional completeness\n self.channel_weights = (self.deltas / np.sum(self.deltas))\n\n # Calculate completeness for each star in sample\n self.completeness = np.sum(np.array(pct_obs_iwas) * self.channel_weights, axis = 1)\n\n \"\"\"\n Make a Lookup Table of Exposure times for each star in sample\n \"\"\"\n\n tpbpcs_rect = [] # Time per bandpass\n tpcs_rect = [] # Time per channel\n\n # Loop over all the stars in sample\n for idrew in range(self.NBIAS):\n\n tpbpcs_rect.append([])\n tpcs_rect.append([])\n bp_names = []\n bp_chan = []\n\n # Loop over all the LUVOIR channels\n for ichan in range(len(CHANNELS)):\n\n tpcs_rect[idrew].append(0.0)\n\n # Loop over all the bands in this channel\n for iband in range(len(tpbpcs[0][ichan])):\n\n bp_names.append(\"%s %i\" %(CHANNELS[ichan], iband+1))\n bp_chan.append(ichan)\n tpbpcs_rect[idrew].append(tpbpcs[idrew][ichan][iband])\n tpcs_rect[idrew][ichan] += tpbpcs[idrew][ichan][iband]\n\n # Make np arrays\n tpbpcs_rect = np.array(tpbpcs_rect)\n tpcs_rect = np.array(tpcs_rect)\n bp_names = np.array(bp_names)\n bp_chan = np.array(bp_chan)\n\n # Make infs --> nans\n infmask = ~np.isfinite(tpbpcs_rect)\n tpbpcs_rect[infmask] = np.nan\n infmask = ~np.isfinite(tpcs_rect)\n tpcs_rect[infmask] = np.nan\n\n # Set attributes\n self.tpbpcs_rect = tpbpcs_rect\n self.tpcs_rect = tpcs_rect\n self.bp_names = bp_names\n self.bp_chan = bp_chan\n\n \"\"\"\n New completeness calculations\n \"\"\"\n\n bandpasses = []\n\n # Loop over telescope channels\n for j, channel in enumerate(CHANNELS):\n\n # Channel dependent bandwidth?\n if type(self.bandwidth) is float:\n bandwidth = self.bandwidth\n else:\n assert len(self.bandwidth) == len(CHANNELS)\n bandwidth = self.bandwidth[j]\n\n # Get the channel specific telescope parameters\n luvoir = default_luvoir(channel=channel)\n self.cn.telescope = luvoir\n\n # Calculate the bandpass edges\n edges = calculate_bandpass_edges(luvoir.lammin, luvoir.lammax, bandwidth = bandwidth)\n\n # Calculate the number of bandpasses\n Nbands = len(edges) - 1\n\n # Loop over bandpasses\n for i in range(Nbands):\n\n # Get the max, min, and middle wavelenths for this bandpass\n lammin = edges[i]\n lammax = edges[i+1]\n\n bandpasses.append([lammin, lammax])\n\n bandpasses = np.array(bandpasses)\n lmin, lmax = np.min(np.hstack(bandpasses)), np.max(np.hstack(bandpasses))\n\n # Fractional completeness of each bandpass\n bp_frac = ((bandpasses[:,1] - bandpasses[:,0]) / (lmax - lmin)) / np.sum((bandpasses[:,1] - bandpasses[:,0]) / (lmax - lmin))\n\n # Completeness by target\n tot_completeness = np.sum(np.isfinite(self.tpbpcs_rect) * bp_frac, axis=1)\n\n # Fraction of stars in biased sample that can completely observe each bandpass\n frac_bias_bp = np.sum(np.isfinite(tpbpcs_rect)*1.0, axis=0) / self.NBIAS\n\n # Set attributes\n self.bandpasses = bandpasses\n self.bp_frac = bp_frac\n self.tot_completeness = tot_completeness\n self.frac_bias_bp = frac_bias_bp\n\n self._make_pandas_table()\n\n return", "def attribute_irrigation():\n fc = ee.FeatureCollection(IRRIGATION_TABLE)\n for state in TARGET_STATES:\n for yr in range(2011, 2021):\n images = os.path.join(ASSET_ROOT, '{}_{}'.format(state, yr))\n coll = ee.Image(images)\n tot = coll.select('classification').remap([0, 1, 2, 3], [1, 0, 0, 0])\n means = tot.reduceRegions(collection=fc,\n reducer=ee.Reducer.mean(),\n scale=30)\n\n task = ee.batch.Export.table.toCloudStorage(\n means,\n description='{}_{}'.format(state, yr),\n bucket='wudr',\n fileNamePrefix='attr_{}_{}'.format(state, yr),\n fileFormat='CSV')\n\n print(state, yr)\n task.start()", "def Table(self: Any, accessories: List[Dict[str, Any]]) -> List[Dict[str, Any]]:\n\n table: List[Dict[str, Any]] = Utility.ReadCSV(\n self, f\"{self.iXAssets}/mp/accessorytable.csv\", AccessoryTable\n )\n\n if table is None:\n return accessories\n\n for accessory in accessories:\n for entry in table:\n if accessory.get(\"altId\") != entry.get(\"ref\"):\n continue\n\n accessory[\"name\"] = self.localize.get(entry.get(\"name\"))\n accessory[\"description\"] = self.localize.get(entry.get(\"description\"))\n accessory[\"image\"] = entry.get(\"lootImage\")\n accessory[\"hidden\"] = bool(entry.get(\"hideInUI\"))\n\n return accessories", "def update_hdrtab(image, level, total_obj_list, input_exposures):\n # Convert input_exposure filenames into HAP product filenames\n name_col = []\n orig_tab = image['hdrtab'].data\n\n for row in orig_tab:\n rootname = str(row['rootname'])\n\n # The rootname is ipppssoot, but the expname is only contains ipppssoo,\n # so remove the last character for the comparisons\n rootname = rootname[0:-1]\n\n for expname in input_exposures:\n if rootname in expname:\n if level == 1:\n # Intrepret inputs as exposures (FLT/FLC) filename not HAP names\n name_col.append(expname)\n else:\n # Convert input exposure names into HAP names\n foundit = False\n for tot_obj in total_obj_list:\n for exposure in tot_obj.edp_list:\n if rootname in exposure.full_filename:\n name_col.append(exposure.drizzle_filename)\n foundit = True\n break\n\n # define new column with HAP expname\n max_len = min(max([len(name) for name in name_col]), 51)\n hapcol = Column(array=np.array(name_col, dtype=np.str), name=HAPCOLNAME, format='{}A'.format(max_len + 4))\n newcol = fits.ColDefs([hapcol])\n\n # define new extension\n haphdu = fits.BinTableHDU.from_columns(orig_tab.columns + newcol)\n haphdu.header['extname'] = 'HDRTAB'\n haphdu.header['extver'] = 1\n # remove old extension\n del image['hdrtab']\n # replace with new extension\n image.append(haphdu)", "def build_data(self):\n from desiutil.io import combine_dicts\n # Loop on exposures\n odict = {}\n for qanight in self.qa_nights:\n for qaexp in qanight.qa_exps:\n # Get the exposure dict\n idict = write_qa_exposure('foo', qaexp, ret_dict=True)\n odict = combine_dicts(odict, idict)\n # Finish\n self.data = odict", "def exp_scan(self, exposure_time_list):\n self.generic_scan(self.exp, exposure_time_list)", "def factor_exposure(self):\n exp_hs_all = pd.DataFrame([])\n exp_zz_all = pd.DataFrame([])\n for i in range(len(self.weekly_date)):\n date = self.weekly_date.iloc[i,0]\n factor = get_barra_factor_from_sql(date)\n factor['secID'] = factor.index.tolist()\n stocklist = factor.index.tolist()\n \n hs300 = get_index_composition(date,'000300.SH')\n zz500 = get_index_composition(date,'000905.SH')\n hs300['secID'] = hs300.index.tolist()\n zz500['secID'] = zz500.index.tolist()\n \n stocklist_hs300 = list(set(hs300.index.tolist()).intersection(set(stocklist)))\n stocklist_zz500 = list(set(zz500.index.tolist()).intersection(set(stocklist)))\n stocklist_hs300.sort()\n stocklist_zz500.sort()\n \n factor_hs = extract_part_from_all(stocklist_hs300,factor,'secID')\n factor_zz = extract_part_from_all(stocklist_zz500,factor,'secID')\n hs_weight = extract_part_from_all(stocklist_hs300,hs300,'secID')\n zz_weight = extract_part_from_all(stocklist_zz500,zz500,'secID')\n del factor_hs['secID'],factor_zz['secID'],hs_weight['secID'],zz_weight['secID']\n \n \n exp_hs = pd.DataFrame(np.dot(hs_weight.T,factor_hs))\n exp_zz = pd.DataFrame(np.dot(zz_weight.T,factor_zz))\n \n \n exp_hs_all = pd.concat([exp_hs_all,exp_hs], axis = 0)\n exp_zz_all = pd.concat([exp_zz_all,exp_zz], axis = 0) \n print(i)\n exp_hs_all.columns = ['Beta','Momentum','Size','EY','RV','Growth',\\\n 'BP','Leverage','Liquidity']\n exp_zz_all.columns = ['Beta','Momentum','Size','EY','RV','Growth',\\\n 'BP','Leverage','Liquidity']\n exp_hs_all.index = self.weekly_date.iloc[:,0]\n exp_zz_all.index = self.weekly_date.iloc[:,0]\n return exp_hs_all,exp_zz_all", "def run_observation(self):\n\n self._generate_direct_image() # to calibrate x_ref and y_ref\n\n num_frames = len(self.exp_start_times)\n progress = Progress(num_frames)\n self.progess = progress\n\n progress_line = 'Generating frames 0/{} done'.format(num_frames)\n progress.print_status_line(progress_line)\n progress.progress_line = progress_line\n\n for i, start_time in enumerate(self.exp_start_times):\n filenum = i + 1\n self._generate_exposure(start_time, filenum)\n\n progress.increment()\n progress_line = 'Generating frames {}/{} done'.format(filenum,\n num_frames)\n progress.print_status_line(progress_line)\n\n # so it can be retreived by exposure_generator\n progress.progress_line = progress_line", "def parse_ipac_table(table_file):\n file_lines = table_file.readlines()\n if len(file_lines) < 5:\n raise ValueError(\"No images found!\")\n \n columns = file_lines[0].replace(\"|\",\" \").split()\n \n # Each row in the table starting at index 4 is metadata for a new image / observation\n metadatas = []\n for image_data in file_lines[4:]:\n line = image_data.replace(\"|\",\" \").split()\n obsdate_idx = columns.index(\"obsdate\")\n tmp = line[obsdate_idx] + \" \" + line[obsdate_idx+1]\n del line[obsdate_idx+1]\n line[obsdate_idx] = tmp\n metadatas.append(dict(zip(columns, line)))\n \n return metadatas", "def create_observation(obs):\n\n obs = {\n \"resourceType\": \"Bundle\",\n \"entry\": [\n {\n \"resource\": {\n \"resourceType\": \"Observation\",\n \"text\": \"Respiratory Rate\",\n \"effectiveDateTime\": obs.datetime,\n \"subject\": {\n \"reference\": obs.pat_no\n },\n \"valueQuantity\": {\n \"value\": obs.resp_rate,\n }\n }\n },\n {\n \"resource\": {\n \"resourceType\": \"Observation\",\n \"text\": \"Body Temperature\",\n \"effectiveDateTime\": obs.datetime,\n \"subject\": {\n \"reference\": obs.pat_no\n },\n \"valueQuantity\": {\n \"value\": obs.temp,\n }\n }\n },\n {\n \"resource\": {\n \"resourceType\": \"Observation\",\n \"text\": \"BP Systolic\",\n \"effectiveDateTime\": obs.datetime,\n \"subject\": {\n \"reference\": obs.pat_no\n },\n \"valueQuantity\": {\n \"value\": obs.bp_sys,\n }\n }\n },\n {\n \"resource\": {\n \"resourceType\": \"Observation\",\n \"text\": \"Heart Rate\",\n \"effectiveDateTime\": obs.datetime,\n \"subject\": {\n \"reference\": obs.pat_no\n },\n \"valueQuantity\": {\n \"value\": obs.pulse,\n }\n }\n }\n ]\n }\n\n return obs", "def make_sourceframe_with_observations(\n n_observations: int,\n exposure_id: str = \"exposure\",\n obscode: str = \"obs\",\n exposure_mjd_start: float = 50000.0,\n exposure_mjd_mid: float = 50000.0,\n healpixel: int = 1,\n) -> SourceFrame:\n observations = [\n make_sourceobs(\n exposure_id=exposure_id,\n obscode=obscode,\n healpixel=healpixel,\n mjd=exposure_mjd_mid,\n exposure_mjd_start=exposure_mjd_start,\n exposure_mjd_mid=exposure_mjd_mid,\n )\n for _ in range(n_observations)\n ]\n\n return SourceFrame(\n exposure_id=exposure_id,\n obscode=obscode,\n filter=\"filter\",\n exposure_mjd_start=exposure_mjd_start,\n exposure_mjd_mid=exposure_mjd_mid,\n exposure_duration=30.0,\n healpixel=1,\n observations=observations,\n )", "def summarize_observing_conditions(fitsFiles):\n count = len(fitsFiles)\n\n # Here is the data we are going to collect from the fits headers\n year = np.zeros(count, dtype=int)\n month = np.zeros(count, dtype=int)\n day = np.zeros(count, dtype=int)\n hour = np.zeros(count, dtype=int)\n minute = np.zeros(count, dtype=int)\n airmass = np.zeros(count, dtype=float)\n water_column = np.zeros(count, dtype=float)\n \n for ii in range(len(fitsFiles)):\n # Get header info\n hdr = pyfits.getheader(fitsFiles[ii])\n\n airmass[ii] = float(hdr['AIRMASS'])\n\n date = hdr['DATE-OBS'].split('-')\n _year = int(date[0])\n _month = int(date[1])\n _day = int(date[2])\n\n utc = hdr['UTC'].split(':')\n _hour = int(utc[0])\n _minute = int(utc[1])\n _second = int(math.floor(float(utc[2])))\n\n utc = datetime.datetime(_year, _month, _day, _hour, _minute, _second)\n utc2hst = datetime.timedelta(hours=-10)\n hst = utc + utc2hst\n\n year[ii] = hst.year\n month[ii] = hst.month\n day[ii] = hst.day\n hour[ii] = hst.hour\n minute[ii] = hst.minute\n\n # Get the water column in mm of H2O\n water_column[ii] = weather.cso_water_column(_year, _month, _day, \n _hour, _minute)\n\n # Now lets fetch the CFHT weather data\n (temperature, pressure, humidity, wind_speed, wind_dir) = \\\n weather.cfht_weather_data(year, month, day, hour, minute)\n\n # Print out a nicely formatted table\n print('%-20s %4s %2s %2s %2s %2s %4s %4s %5s %5s %4s %4s %4s' % \\\n ('Filename', 'Year', 'M', 'D', 'h', 'm', 'AirM', 'H2O', 'Temp', \n 'Press', 'Humi', 'Wind', 'Dir'))\n print('%-20s %4s %2s %2s %2s %2s %4s %4s %5s %5s %4s %4s %4s' % \\\n ('HST', '', '', '', '', '', '', 'mm', 'C', 'mbar', '%', 'km/h', 'deg'))\n print('%-20s %4s %2s %2s %2s %2s %4s %4s %5s %5s %4s %4s %4s' % \\\n ('--------', '----', '--', '--', '--', '--', '----', '----', '-----', \n '-----', '----', '----', '----'))\n\n for ii in range(len(fitsFiles)):\n print('%-20s %4d %2d %2d %2d %2d ' % \\\n (fitsFiles[ii], year[ii], month[ii], day[ii], hour[ii], minute[ii]),)\n print('%4.2f %4.2f %5.1f %5.1f %4.1f %4.1f %4d' % \\\n (airmass[ii], water_column[ii], temperature[ii], pressure[ii],\n humidity[ii], wind_speed[ii], wind_dir[ii]))\n\n # Print out the average values\n print('%-20s %4s %2s %2s %2s %2s %4s %4s %5s %5s %4s %4s %4s' % \\\n ('--------', '----', '--', '--', '--', '--', '----', '----', '-----', \n '-----', '----', '----', '----'))\n print('%-20s %4d %2d %2d %2d %2d ' % \\\n ('Average', year.mean(), month.mean(), day.mean(), hour.mean(), \n minute.mean()),)\n print('%4.2f %4.2f %5.1f %5.1f %4.1f %4.1f %4d' % \\\n (airmass.mean(), water_column.mean(), temperature.mean(), \n pressure.mean(), humidity.mean(), wind_speed.mean(), wind_dir.mean()))\n print('%-20s %4d %2d %2d %2d %2d ' % \\\n ('Std. Dev.', year.std(), month.std(), day.std(), hour.std(), \n minute.std()),)\n print('%4.2f %4.2f %5.1f %5.1f %4.1f %4.1f %4d' % \\\n (airmass.std(), water_column.std(), temperature.std(), \n pressure.std(), humidity.std(), wind_speed.std(), wind_dir.std()))", "def create_exposure(event_class,event_type,egy,cth):\n\n if isinstance(event_type,int):\n event_type = evtype_string[event_type]\n \n irf_factory=pyIrfLoader.IrfsFactory.instance()\n irf = irf_factory.create('%s::%s'%(event_class,event_type))\n\n irf.aeff().setPhiDependence(False)\n \n theta = np.degrees(np.arccos(cth))\n \n # Exposure Matrix\n # Dimensions are Etrue and incidence angle\n m = np.zeros((len(egy),len(cth)))\n\n for i, x in enumerate(egy):\n for j, y in enumerate(theta): \n m[i,j] = irf.aeff().value(10**x,y,0.0)\n\n return m", "def tabulate(store: ObservationStore) -> \\\n Generator[LabelledObservation, None, None]:\n for k in store:\n for ob in store[k]:\n yield when(ob), measured(ob), k", "def observeField(target, exposure):\n\n status = 2\n real_exposure = exposure + np.random.normal(0.0, 20.0)\n realSN2 = target['DESsn2'] + np.random.uniform(0.0, 1.0)\n\n return status, real_exposure, realSN2", "def make_test_eventlist(observation_table,\n obs_id,\n sigma=Angle(5., 'deg'),\n spectral_index=2.7,\n random_state='random-seed'):\n from ..data import EventList\n random_state = get_random_state(random_state)\n\n # find obs row in obs table\n obs_ids = observation_table['OBS_ID'].data\n obs_index = np.where(obs_ids == obs_id)\n row = obs_index[0][0]\n\n # get observation information\n alt = Angle(observation_table['ALT'])[row]\n livetime = Quantity(observation_table['LIVETIME'])[row]\n\n # number of events to simulate\n # it is linearly dependent on the livetime, taking as reference\n # a trigger rate of 300 Hz\n # it is linearly dependent on the zenith angle (90 deg - altitude)\n # it is n_events_max at alt = 90 deg and n_events_max/2 at alt = 0 deg\n n_events_max = Quantity(300., 'Hz') * livetime\n alt_min = Angle(0., 'deg')\n alt_max = Angle(90., 'deg')\n slope = (n_events_max - n_events_max / 2) / (alt_max - alt_min)\n free_term = n_events_max / 2 - slope * alt_min\n n_events = alt * slope + free_term\n\n # simulate energy\n # the index of `~numpy.random.RandomState.power` has to be\n # positive defined, so it is necessary to translate the (0, 1)\n # interval of the random variable to (emax, e_min) in order to\n # have a decreasing power-law\n e_min = Quantity(0.1, 'TeV')\n e_max = Quantity(100., 'TeV')\n energy = sample_powerlaw(e_min.value, e_max.value, spectral_index,\n size=n_events, random_state=random_state)\n energy = Quantity(energy, 'TeV')\n\n E_0 = Quantity(1., 'TeV') # reference energy for the model\n\n # define E dependent sigma\n # it is defined via a PL, in order to be log-linear\n # it is equal to the parameter sigma at E max\n # and sigma/2. at E min\n sigma_min = sigma / 2. # at E min\n sigma_max = sigma # at E max\n s_index = np.log(sigma_max / sigma_min)\n s_index /= np.log(e_max / e_min)\n s_norm = sigma_min * ((e_min / E_0) ** -s_index)\n sigma = s_norm * ((energy / E_0) ** s_index)\n\n # simulate detx, dety\n detx = Angle(random_state.normal(loc=0, scale=sigma.deg, size=n_events), 'deg')\n dety = Angle(random_state.normal(loc=0, scale=sigma.deg, size=n_events), 'deg')\n\n # fill events in an event list\n event_list = EventList()\n event_list['DETX'] = detx\n event_list['DETY'] = dety\n event_list['ENERGY'] = energy\n\n # store important info in header\n event_list.meta['LIVETIME'] = livetime.to('second').value\n event_list.meta['EUNIT'] = str(energy.unit)\n\n # effective area table\n aeff_table = Table()\n\n # fill threshold, for now, a default 100 GeV will be set\n # independently of observation parameters\n energy_threshold = Quantity(0.1, 'TeV')\n aeff_table.meta['LO_THRES'] = energy_threshold.value\n aeff_table.meta['name'] = 'EFFECTIVE AREA'\n\n # convert to BinTableHDU and add necessary comment for the units\n aeff_hdu = table_to_fits_table(aeff_table)\n aeff_hdu.header.comments['LO_THRES'] = '[' + str(energy_threshold.unit) + ']'\n\n return event_list, aeff_hdu", "def obs_assimilation_statistics(prior, obs): #post, obs):\n # Make sure these states are the right kind of object\n assert isinstance(prior, EnsembleState)\n #assert isinstance(post, EnsembleState)\n\n # Build a list of dictionaries\n oblist = []\n for ob in obs:\n obd = {}\n obd['validtime'] = ob.time\n obd['flead'] = (ob.time - pd.to_datetime(prior['validtime'].values[0])).total_seconds()/3600\n obd['lat'] = ob.lat\n obd['lon'] = ob.lon\n obd['obtype'] = ob.obtype\n obd['description'] = ob.description\n obd['ob error'] = ob.error\n obd['value'] = ob.value\n obd['assimilated'] = ob.assimilated\n prior_ye = ob.estimate(prior)\n #post_ye = ob.estimate(post)\n obd['prior mean'] = prior_ye.mean()\n #obd['post mean'] = post_ye.mean()\n obd['prior variance'] = prior_ye.var()\n #obd['post variance'] = post_ye.var()\n oblist.append(obd)\n print(len(oblist))\n # Build a dataframe from this list of objects\n df = pd.DataFrame(oblist)\n return df", "def make_data_table(self, events):\n data_table = []\n for event in events:\n table_row = {}\n for key, val in PROOFPOINT_TRAP_EVENTS_MAP.items():\n if key in event.keys():\n table_row[val] = {\"value\" : event[key]}\n data_table.append({\"cells\" : table_row})\n LOG.debug(\"Table Row created with values: %s\", table_row)\n LOG.info(\"Data Table Assembled with %d rows\", len(data_table))\n\n # TODO: POST Data Table to Resilient Incident\n LOG.debug(pprint.pformat(data_table, indent=4))\n return {'proofpoint_trap_events' : data_table}", "def create_observation(self):", "def create_observation(self):", "def _get_dataset_table(self):\n\n model_dataset = self.get_model_dataset()\n index_as_str = np.expand_dims(model_dataset.index.astype(str), 1)\n observation_data = np.column_stack((index_as_str, model_dataset.as_matrix()))\n observation_data_headers = ['DateTime']\n observation_data_headers.extend(model_dataset.keys())\n observation_table = SimpleTable(data=observation_data,\n headers=observation_data_headers)\n\n return observation_table" ]

[ "0.70176095", "0.6014823", "0.5961176", "0.5897251", "0.5735278", "0.57064164", "0.5697232", "0.5609351", "0.5595745", "0.5515109", "0.5511498", "0.5509595", "0.5412777", "0.5358326", "0.52642626", "0.5259989", "0.52551216", "0.5245346", "0.5239172", "0.52262944", "0.52035564", "0.52017057", "0.519556", "0.517978", "0.5164753", "0.5161697", "0.5160446", "0.5156876", "0.5156876", "0.5142819" ]

[ "def to_string(self):\n return self.sequence", "def __str__(self):\n string = 'input dim: {} \\noutput dim: {} \\n'.format(\n self.dim_inputs, self.dim_outputs\n )\n string += 'sequence length: {} \\n'.format(\n self.tensors[0].shape[1]\n )\n key = 'train' if self.train else 'test'\n string += '{}_samples: {} \\n{}_sequences: {} \\n'.format(\n key, self.experiment_length, key, self.tensors[0].shape[0]\n )\n return string", "def __str__(self):\n ret_val = 'Trace sequence number within line: %i\\n' % \\\n self.header.trace_sequence_number_within_line\n ret_val += '%i samples, dtype=%s, %.2f Hz' % (\n len(self.data),\n self.data.dtype, 1.0 /\n (self.header.sample_interval_in_ms_for_this_trace /\n float(1E6)))\n return ret_val", "def __str__(self):\n return self._seq", "def dump(self):\n outputs = [\"Sequence : %s\" % self.name]\n if self.curr_value:\n outputs.append(\" start : %d\" % self.curr_value)\n outputs.append(\" minimum : %d\" % self.min_value)\n outputs.append(\" maximum : %d\" % self.max_value)\n if self.increment_by > 1:\n outputs.append(\" increment : %d\" % self.increment_by)\n return \"\\n\".join(outputs)", "def __str__(self):\n\n nframes = len(self.frames)\n if nframes == 0:\n return \"\"\n elif nframes == 1:\n frame, = self.frames\n return str(frame)\n else:\n frames = sorted(self.frames)\n start = prev = frames[0] # First frame.\n step = None\n subranges = []\n for end in frames[1:]: # Frame starting from the second in the list.\n\n if step is None: # Step is still none.\n step = end - prev # Find and set step.\n\n if prev + step != end: # If the sequence is broken.\n subranges.append((start, prev, step)) # Create a subrange.\n step = None # Reset step.\n start = end # Re-start start.\n prev = end # The next previous.\n\n else:\n subranges.append((start, end, step))\n\n return \", \".join(format_subrange(start, end, step) for (start, end, step) in subranges)", "def excitation_seq(self) -> str:\n return self.frame_selector.excitation_seq", "def __str__(self):\n return \"{}\\n{}\\n{}\\n{}\".format(self.header,self.sequence,self.line3,self.quality)", "def __str__(self):\n return self.sequence", "def __str__(self):\r\n\r\n data = [self.seq_f,\r\n self.seq_r,\r\n self.tf,\r\n self.df,\r\n len(self.taxons),\r\n len(self.families),\r\n ]\r\n\r\n return \"%s\\n\" % \"\\t\".join([str(x) for x in data])", "def __repr__(self):\n return '%s([%s])' % (self.__class__.__name__, ', '.join(\n ['(%r, %r)' % (key, self[key]) for key in self._sequence]))", "def __repr__(self):\n msg = str(self.__class__.__name__)\n msg += \" (\\n\\tpath={}\\n\\tobs_keys={}\\n\\tseq_length={}\\n\\tfilter_key={}\\n\\tframe_stack={}\\n\"\n msg += \"\\tpad_seq_length={}\\n\\tpad_frame_stack={}\\n\\tgoal_mode={}\\n\"\n msg += \"\\tcache_mode={}\\n\"\n msg += \"\\tnum_demos={}\\n\\tnum_sequences={}\\n)\"\n filter_key_str = self.filter_by_attribute if self.filter_by_attribute is not None else \"none\"\n goal_mode_str = self.goal_mode if self.goal_mode is not None else \"none\"\n cache_mode_str = self.hdf5_cache_mode if self.hdf5_cache_mode is not None else \"none\"\n msg = msg.format(self.hdf5_path, self.obs_keys, self.seq_length, filter_key_str, self.n_frame_stack,\n self.pad_seq_length, self.pad_frame_stack, goal_mode_str, cache_mode_str,\n self.n_demos, self.total_num_sequences)\n return msg", "def snapshot(self):\n text = \"\"\n text += \"{}:\\n{}\\n\".format('chi', np.array2string(self.chi))\n return text", "def __str__(self):\n s = 'Gene: ' + self._dna[:6] + '...' + self._dna[-6:] + \\\n ', length=%d' % len(self._dna)\n if self._exons is not None:\n s += ', %d exon regions' % len(self._exons)\n return s", "def __str__(self):\n return str(self._num_rotations)", "def __str__(self):\n #Get an ordered list of the elements strings so it outputs always the same\n #string given a mass function.\n elements = []\n for element in self.focals:\n elements.append((element, str(element)))\n sortedList = sorted(elements, key=lambda x:x[1])\n \n result = \"\"\n first = True\n for t in sortedList:\n if first:\n result += t[1] + \":\" + \"{:.4f}\".format(self.focals[t[0]])\n first = False\n else:\n result += \", \" + t[1] + \":\" + \"{:.4f}\".format(self.focals[t[0]])\n return \"{\" + result + \"}\"", "def __str__(self):\n # TODO also show relative abundance\n s = \"{} ion species\\n\".format(len(self.ions))\n for ion in self.ions:\n s += \" {:2s} (Z = {:3d}) {:.3e} particles\\n\".format(ion.getName(), ion.getCharge(), ion.getParticleNumber())\n \n return s", "def __str__(self):\n s = \"\"\n for v in self.vectors:\n s += str(v) + \"\\n\"\n return s", "def __str__(self):\n out_str = \"\\n\".join(`\"%.5f, %.5f, %.1f, %s, %s\" % (point[0], point[1], point[2], point[3], point[4])` for point in self.__traectory_list)\n return \"\\'x, y, altitude, capture time, capture date'\\n\"+out_str", "def to_string(self):\n string = (\n f\"r{self.num_repeat}_k{self.kernel_size}_s{self.stride}{self.stride}\"\n f\"_e{self.expand_ratio}_i{self.input_filters}_o{self.output_filters}\"\n f\"_se{self.se_ratio}\"\n )\n\n if not self.id_skip:\n string += \"_noskip\"\n return string", "def as_str(self) -> str:\n return dumps(self.as_dict(), cls=NumpyEncoder)", "def __str__(self):\n if len(self.label) > 0:\n descr = [\"'%s', target='%s' [%s]\" % (self.label, self.target.name, self.target.body_type)]\n else:\n descr = [\"target='%s' [%s]\" % (self.target.name, self.target.body_type)]\n if self.baseline:\n descr[0] += ', initial baseline offset=%f' % (self.baseline.poly[-1],)\n if self.beam:\n descr[0] += ', beam height=%f' % (self.beam.height,)\n for scan_ind, scan in enumerate(self.scans):\n descr.append('%4d: %s' % (scan_ind, str(scan)))\n return '\\n'.join(descr)", "def to_str(self):\n return u\"Superellipse[{:.4g},{:.4g}]\".format(self.alpha0.l, self.alpha0.r)", "def sequence(self):\n\n\t\tseq = \"\"\n\t\tfor chain in self.chain:\n\t\t\tfor res in chain.residue:\n\t\t\t\tseq += res.aa1()\n\n\t\treturn seq", "def __str__(self):\n # newline-delimited values of all the attributes\n return \">%s\\n%s\" % (self.Label, self.Sequence)", "def __str__(self):\n st=\"\"\n for g in self:\n st+=g.fasta()\n st+=\"\\n\"\n return st", "def __str__(self):\n output = \"\"\n for i in self.values:\n st = []\n output += \"[\"\n for j in i:\n st.append(str(j))\n output += \",\".join(st)+\"]\"\n return str(self.m)+\"x\"+str(self.n)+\" [\" + output + \"]\"", "def __str__(self):\n string = ''\n for degree, coef in enumerate(self.coefs, 1):\n degree = degree - 1\n string += str(coef)+'x^' + str(degree) + ' + '\n string = string[0:-3] # remove the last ' + '\n return string", "def __str__( self ) :\n\n return( ' '.join( [ \"%g\" % c_l for c_l in self.coefficients ] ) )", "def __str__(self):\n return str((self.code, self.fitness,))" ]

[ "0.72283626", "0.7040741", "0.67555356", "0.6664315", "0.6626783", "0.6547962", "0.65409464", "0.65346056", "0.6483022", "0.64496106", "0.6439818", "0.633267", "0.6277435", "0.62634873", "0.62428826", "0.6218749", "0.620363", "0.61781204", "0.6177901", "0.61686456", "0.615419", "0.61360776", "0.6126522", "0.6114013", "0.6102579", "0.60984993", "0.60914254", "0.60867995", "0.6084197", "0.6062007" ]

[ "def find_source(self, name):\n t = filter( lambda x: x.name==name, self.point_sources+self.extended_sources)\n return t[0] if len(t)==1 else None", "def get_source(source_name):\n if source_name == \"SCHOLAR_CENSUS\":\n from mec_data.source.scholar import ScholarSource\n\n return ScholarSource()\n elif source_name == \"UNIVERSITY_CENSUS\":\n from mec_data.source.university import UniversitySource\n\n return UniversitySource()", "def getSourceForId(context, identifier):\n nearest = getattr(context, identifier, None)\n if IExternalSource.providedBy(nearest):\n return nearest\n return None", "def get_source_name(self, source_id: str) -> str:\n if not self._source_list_map:\n return \"\"\n if source_id.upper() == DIGITAL_TV.upper():\n source_id = \"dtv\"\n for map_value in self._source_list_map:\n map_id = map_value.get(\"id\")\n if map_id and map_id == source_id:\n return map_value.get(\"name\", \"\")\n return \"\"", "def source(self):\n for source in self.coordinator.data.sources:\n if source.SourceID == self.zone.SourceID:\n return source.Name\n return None", "def by_source(self, source):\n return self.filter(source_object=source)", "def source_id(self) -> Optional[str]:\n return pulumi.get(self, \"source_id\")", "def get_source(self, name):\n return self._sources[name]", "def get_source(self) -> Optional[SourceIdentifierParameter]:\n return self.get_param_by_type(SourceIdentifierParameter)", "def get_source(self, source_name: str) -> Optional[Tag]:\n # sanitize the name, this will also add index if there isn't one\n source_name, *_ = Tags._sanitize_tag(source_name, 0, 0)\n return next(self.tags.filter(name=source_name, valid=None), None)", "def _get_source(self, uri: str) -> Optional[_Source]:\n\n for source in self._sources:\n if uri == source.uri:\n return source\n\n return None", "def source(self) -> Optional[str]:\n return pulumi.get(self, \"source\")", "def source():\n\n source = models.Source(name=u\"Joe's Funerals.com\", url=u\"http://www.joesfunerals.com\")\n return source", "def get_source(self) -> Optional[str]:\n return self._source", "def find_data_source_url(a_name, url_prefs):\n for row in url_prefs:\n if row[0] == a_name:\n return row[1]\n return None", "def get_media_source_id(self, source_name):\n\t\tvalidation.required(source_name, 'source_name')\n\n\t\treturn self.media_sources.get(source_name, 1)", "def _get_source(self, source_id):\n logging.debug(\"Getting entity for source_id %s\", source_id)\n if self.trace.has_item(source_id):\n return self.trace.get_item(source_id)\n\n source_components = source_id.split('/')\n if len(source_components) not in [2, 4]:\n logging.error(\n \"Expecting source with either 2 or 4 components, got %s\",\n source_id)\n return None\n\n if not re.match(\"[0-9]+\", source_components[0]):\n logging.error(\n \"Expecting source beginning with item ID, got %s\",\n source_components[0])\n return None\n\n if len(source_components) == 2:\n source_item_id = source_components[0]\n well = source_components[1]\n\n pattern = r\"\\[\\[([0-9]+),[ \\t]*([0-9]+)\\]\\]\"\n match = re.match(pattern, source_components[1])\n if match:\n well = well_coordinates(int(match[1]), int(match[2]))\n\n elif len(source_components) == 4:\n source_item_id = source_components[1]\n well = source_components[3]\n\n source_item_entity = self.factory.get_item(item_id=source_item_id)\n\n if not source_item_entity.is_collection():\n msg = \"Ignoring source part %s from non-collection %s\"\n logging.info(msg, well, source_item_id)\n return source_item_entity\n\n source_part_entity = self.factory.get_part(\n collection=source_item_entity,\n well=well\n )\n\n return source_part_entity", "def getSourceName(self, instance):\n mapping = IAnnotations(instance).setdefault(\n 'collective.table',\n PersistentMapping()\n )\n return mapping.get('source_name', self.defaultSourceName)", "def data_source_display_name(self, data_source_display_name):\n\n self._data_source_display_name = data_source_display_name", "def get_source(self, source, driver_name=None):\n if not driver_name:\n driver_name = self.driver_name\n driver = ogr.GetDriverByName(driver_name)\n return driver.Open(source, 0)", "def get_source(self) -> CopyPasteSource:\n mode = self.new_or_existing.currentIndex()\n\n if mode == 0:\n name = self.name_widget.name.text()\n\n description = self.name_widget.description.text()\n if not description:\n description = None\n\n return self.source.create_source(self.context, name, description)\n\n sources = self.table.get_selected_sources()\n\n return sources[0]", "async def async_select_source(self, source):\n source = next((g[\"id\"] for g in self._galleries if g[\"name\"] == source), None)\n if source is None:\n _LOGGER.warning(\"Source %s not found\", source)\n await self.local_meural.send_change_gallery(source)", "def show_source_page(sourceid=None):\n uuid = request.args.get(\"uuid\", sourceid)\n if not uuid:\n return redirect(url_for(\"virhesivu\", code=1, text=\"Missing Source key\"))\n u_context = UserContext(user_session, current_user, request)\n try:\n with SourceReader(\"read\", u_context) as service:\n # reader = SourceReader(readservice, u_context)\n res = service.get_source_with_references(uuid, u_context)\n\n if res[\"status\"] == Status.NOT_FOUND:\n msg = res.get(\"statustext\", _(\"No objects found\"))\n flash(msg, \"error\")\n if res[\"status\"] != Status.OK:\n flash(f'{res.get(\"statustext\", _(\"error\"))}', \"error\")\n\n stk_logger(\n u_context, f\"-> bp.scene.routes.show_source_page n={len(res['citations'])}\"\n )\n\n except KeyError as e:\n msg = f\"bp.scene.routes.show_source_page: {e.__class__.__name__} {e}\"\n flash(f'{ _(\"Program error\")}', \"error\")\n logger.error(msg)\n\n # for c in res.citations:\n # for i in c.citators:\n # if i.id[0] == \"F\": print(f'{c} – family {i} {i.clearname}')\n # else: print(f'{c} – person {i} {i.sortname}')\n return render_template(\n \"/scene/source_events.html\",\n source=res[\"item\"],\n citations=res[\"citations\"],\n user_context=u_context,\n )", "def get_source(self):\n return self.source", "def source(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"source\")", "def source_id(self) -> str:\n return self._source_id", "def source_id(self) -> str:\n return self._source_id", "def grab_external_id(stix_object, source_name):\n for external_reference in stix_object.get(\"external_references\", []):\n if external_reference.get(\"source_name\") == source_name:\n return external_reference[\"external_id\"]", "def _fetch_source_objects(source_objects, source_type, name=None):\n try:\n nodes = source_objects[0].nodes\n for node in nodes:\n if node.get(\"nodes\", []):\n nodes.extend(node[\"nodes\"])\n else:\n if node[\"protectionSource\"][\"vmWareProtectionSource\"][\n \"type\"] == source_type:\n obj_name = node[\"protectionSource\"][\"name\"]\n if not name:\n return node[\"protectionSource\"][\"id\"]\n elif name and name == obj_name:\n return node[\"protectionSource\"][\"id\"]\n except APIException as err:\n return str(err)", "def source_identifier(self) -> str:\n return pulumi.get(self, \"source_identifier\")" ]

[ "0.6412398", "0.6283802", "0.62611306", "0.6204275", "0.6198703", "0.6188179", "0.608557", "0.5972765", "0.5959811", "0.59588695", "0.594499", "0.58315796", "0.5799471", "0.57752895", "0.57598245", "0.57466704", "0.5684819", "0.5638011", "0.561176", "0.5592158", "0.55663866", "0.5533117", "0.5516964", "0.5510883", "0.5498491", "0.54852426", "0.54852426", "0.54776955", "0.547437", "0.5467378" ]

[ "def ensure_visible(self):\n self.set_visible(True)", "def test_visibility(self):\r\n self.assertFalse(self.net.environment\\\r\n .are_visible(self.net.pos[self.node1],\r\n self.net.pos[self.node2]))\r\n self.assertTrue(self.net.environment\\\r\n .are_visible(self.net.pos[self.node2],\r\n self.net.pos[self.node3]))", "def setVisible( self, state ):\n self._visible = state\n \n super(XNode, self).setVisible(self.isVisible())\n \n self.dispatch.visibilityChanged.emit(state)\n self.setDirty()", "def inspectedNodeIsVisible(self):\n return self._inspected_node_is_visible", "def isVisible(self):\n\t\treturn True", "def invisible_visit(self, node: Node) -> None:\n pass", "def is_visible(self):", "def isVisible(self, p_int): # real signature unknown; restored from __doc__\n return False", "def isVisible(self, p_int): # real signature unknown; restored from __doc__\n return False", "def wait_for_visible(self, timeout=None):\n wait_until(lambda: self.is_displayed(),\n \"Element '%s' not visible after <TIMEOUT>.\" % self._locator,\n timeout)", "def visible(self, show):", "def is_visible(self, path):\n return True", "def is_visible(self, timeout=None):\n try:\n self.visibility_of_element_located(timeout)\n except TimeoutException:\n return False\n return True", "def assert_visible(self, locator, msg=None):\r\n e = driver.find_elements_by_locator(locator)\r\n if len(e) == 0:\r\n raise AssertionError(\"Element at %s was not found\" % locator)\r\n assert e.is_displayed()", "def wait_for_invisible(self, timeout=None):\n wait_until(lambda: not self.is_displayed(),\n \"Element '%s' still visible after <TIMEOUT>.\" % self._locator,\n timeout)", "def EnsureVisible(self, item):\r\n\r\n # first expand all parent branches\r\n parent = item.GetParent()\r\n\r\n if self.HasAGWFlag(TR_HIDE_ROOT):\r\n while parent and parent != self._anchor:\r\n self.Expand(parent)\r\n parent = parent.GetParent()\r\n else:\r\n while parent:\r\n self.Expand(parent)\r\n parent = parent.GetParent()\r\n \r\n self.ScrollTo(item)", "def test_visibility(self, data, visible):\n layer = Points(data)\n assert layer.visible is True\n\n layer = Points(data, visible=visible)\n assert layer.visible is visible\n\n layer.visible = not visible\n assert layer.visible is not visible", "def verify_visible(self, locator, msg=None):\r\n try:\r\n self.assert_visible(locator, msg)\r\n except AssertionError, e:\r\n if msg:\r\n m = \"%s:\\n%s\" % (msg, str(e))\r\n else:\r\n m = str(e)\r\n self.verification_erorrs.append(m)", "def is_element_visible(self):\n if self.web_element.is_displayed():\n return True\n else:\n return False", "def is_visible(self):\n return self.real > 0", "def test_visible_whitelisted(self):\n\n self.feature_test.set_percentage(0)\n self.feature_test.add_to_whitelist(3)\n self.assertTrue(self.feature_test.is_visible(3))", "def visible(self, visible):\n\n self._visible = visible", "def visible(self) -> bool:\n try:\n return bool(self.driver.wait_until_all_visible(*self.ROOT_LOCATOR))\n except WebDriverException:\n return False", "def _is_visible(self, point):\n return point[0] > 0 and point[0] < 1 and point[1] > 0 and point[1] < 1", "def isVisible( self ):\n layer = self.layer()\n if ( layer and not layer.isVisible() ):\n return False\n# \n# if ( self.isIsolateHidden() ):\n# return False\n# \n return self._visible", "def setVisible(*args):", "def setVisible(*args):", "def setVisible(*args):", "def setVisible(*args):", "def setVisible(*args):" ]

[ "0.6804122", "0.6494671", "0.6356905", "0.6340063", "0.63099027", "0.6276163", "0.62759423", "0.61556643", "0.61556643", "0.61108905", "0.6087162", "0.6059026", "0.6036995", "0.6013018", "0.5971871", "0.59257257", "0.58930624", "0.58760315", "0.58694416", "0.58317655", "0.5784247", "0.5783572", "0.57727337", "0.57556677", "0.573891", "0.571824", "0.571824", "0.571824", "0.571824", "0.571824" ]

[ "def test_get_bucketlist_items(self):\n resp = self.client.post('/bucketlists',\n data=json.dumps(self.bucketlist),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n\n resp_item = self.client.post('/bucketlistitems/1/items',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n\n self.assertEqual(resp_item.status_code, 200)\n resp_item = self.client.get('/bucketlistitems/1/items', headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp_item.status_code, 200)", "def test_user_can_get_list_of_buckets(self):\n with self.client:\n response = self.client.get(\n '/bucketlists/',\n headers=dict(Authorization='Bearer ' + self.get_user_token())\n )\n data = json.loads(response.data.decode())\n self.assertEqual(response.status_code, 200)\n self.assertTrue(data['status'] == 'success')\n self.assertIsInstance(data['buckets'], list)\n self.assertEqual(len(data['buckets']), 0)\n self.assertEqual(data['count'], 0)\n self.assertIsInstance(data['count'], int)\n self.assertEqual(data['previous'], None)\n self.assertEqual(data['next'], None)", "def test_api_get_all_bucketlists(self):\n res = self.client().post('/bucketlist', data=self.bucketlist)\n self.assertEqual(res.status_code, 201)\n res = self.client().get('/bucketlist')\n self.assertEqual(res.status_code, 200)\n self.assertIn('Go to vacation', str(res.data))", "def test_get_request_on_bucketlist_resource(self):\n\n response = self.client.get(\"/bucketlists/\")\n self.assertEqual(response.status_code, 401)", "def test_read_bucket(self):\n post_data = self.post_a_bucket()\n self.assertEqual(post_data.status_code, 201)\n result_of_get_method = self.client().get('/bucketlists/',\n headers=dict(Authorization='Bearer '\n + self.token())\n )\n self.assertEqual(result_of_get_method.status_code, 200)\n self.assertIn('Climb the Himalayas', str(result_of_get_method.data))", "def test_list(self):\n responses.add(\n responses.Response(\n method='GET',\n url='https://connection.keboola.com/v2/storage/buckets',\n json=list_response\n )\n )\n buckets_list = self.buckets.list()\n assert isinstance(buckets_list, list)", "def test_creating_and_getting_a_bucketlist_for_authenticated_user(self):\n\n # test all bucketlists\n response = self.client.post(\n \"/bucketlists/\",\n data=dict(name='test_bucketlist'),\n headers={'Authorization': self.user_token}\n )\n bucketlist = json.loads(response.data)\n\n self.assertEqual(response.status_code, 200)\n self.assertEqual(bucketlist[\"name\"], 'test_bucketlist')\n\n # test single bucketlist\n self.bucketlist_id = bucketlist[\"bucketlist_id\"]\n single_bucketlist = self.client.get(\n \"/bucketlists/\" + str(self.bucketlist_id) + \"\",\n headers={'Authorization': self.user_token}\n )\n\n one_bucketlist = json.loads(single_bucketlist.data)\n\n self.assertEqual(single_bucketlist.status_code, 200)\n self.assertEqual(one_bucketlist[\"name\"], 'test_bucketlist')\n\n # test all items in bucketlist\n item = self.client.post(\n \"/bucketlists/\" + str(self.bucketlist_id) + \"/items/\",\n data=dict(name=\"test_item\"),\n headers={'Authorization': self.user_token}\n )\n\n one_item = json.loads(item.data)\n\n self.assertEqual(item.status_code, 200)\n self.assertEqual(one_item[\"name\"], 'test_item')\n\n # test single item in bucketlist\n self.item_id = one_item[\"item_id\"]\n single_item = self.client.get(\n \"/bucketlists/\" + str(self.bucketlist_id) + \"/items/\" + str(self.item_id) + \"\",\n headers={'Authorization': self.user_token}\n )\n\n created_item = json.loads(single_item.data)\n\n self.assertEqual(single_item.status_code, 200)\n self.assertEqual(created_item[\"name\"], 'test_item')\n\n # test for deletion of bucketlist\n second_bucketlist = self.client.post(\n \"/bucketlists/\",\n data=dict(name='second_bucketlist'),\n headers={'Authorization': self.user_token}\n )\n\n bucketlist_two = json.loads(second_bucketlist.data)\n\n self.assertEqual(second_bucketlist.status_code, 200)\n self.assertEqual(bucketlist_two[\"name\"], 'second_bucketlist')\n\n delete_response = self.client.delete(\n \"/bucketlists/\" + str(bucketlist_two[\"bucketlist_id\"]) + \"\",\n headers={'Authorization': self.user_token}\n )\n\n deletion = json.loads(delete_response.data)\n\n self.assertEqual(delete_response.status_code, 200)\n self.assertEqual(deletion[\"message\"], \"Deleted\")\n\n # test for deletion of an item in bucketlist\n delete_item = self.client.delete(\n \"/bucketlists/\" + str(bucketlist[\"bucketlist_id\"]) + \"/items/\" + str(one_item[\"item_id\"]) + \"\",\n headers={'Authorization': self.user_token}\n )\n\n item_deletion = json.loads(delete_item.data)\n\n self.assertEqual(delete_item.status_code, 200)\n self.assertEqual(item_deletion[\"message\"], \"Deleted\")\n\n # test for updating of bucketlist\n self.bucketlist_id = bucketlist[\"bucketlist_id\"]\n bucketlist_update = self.client.put(\n \"/bucketlists/\" + str(self.bucketlist_id) + \"\",\n data=dict(name='bucketlist_test'),\n headers={'Authorization': self.user_token}\n )\n\n updated_bucketlist = json.loads(bucketlist_update.data)\n\n self.assertEqual(bucketlist_update.status_code, 200)\n self.assertEqual(updated_bucketlist[\"name\"], 'bucketlist_test')\n\n # test update of item in bucketlist\n item = self.client.post(\n \"/bucketlists/\" + str(self.bucketlist_id) + \"/items/\",\n data=dict(name=\"test_item\"),\n headers={'Authorization': self.user_token}\n )\n\n one_item = json.loads(item.data)\n\n item_update = self.client.put(\n \"/bucketlists/\" + str(self.bucketlist_id) + \"/items/\"+ str(one_item[\"item_id\"]) + \"\",\n data=dict(name=\"item_test\"),\n headers={'Authorization': self.user_token}\n )\n\n updated_item = json.loads(item_update.data)\n\n self.assertEqual(item_update.status_code, 200)\n self.assertEqual(updated_item[\"name\"], 'item_test')", "def test_bucket_by_id_is_returned_on_get_request(self):\n with self.client:\n token = self.get_user_token()\n # Create a Bucket\n response = self.client.post(\n '/bucketlists',\n data=json.dumps(dict(name='Travel')),\n headers=dict(Authorization='Bearer ' + token),\n content_type='application/json'\n )\n # Test Bucket creation\n data = json.loads(response.data.decode())\n self.assertEqual(response.status_code, 201)\n self.assertTrue(data['status'], 'success')\n self.assertTrue(data['name'], 'Travel')\n response = self.client.get(\n '/bucketlists/1',\n headers=dict(Authorization='Bearer ' + token)\n )\n data = json.loads(response.data.decode())\n self.assertEqual(response.status_code, 200)\n self.assertTrue(data['status'] == 'success')\n self.assertTrue(data['bucket']['name'] == 'travel')\n self.assertIsInstance(data['bucket'], dict)\n self.assertTrue(response.content_type == 'application/json')", "def test_get_bucketlist_item_id(self):\n resp = self.client.post('/bucketlists',\n data=json.dumps(self.bucketlist),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n resp_item = self.client.post('/bucketlistitems/1/items',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n get_item = self.client.get('/bucketlistitems/1/items/1', headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)", "def test_buckets_returned_when_searched(self):\n with self.client:\n token = self.get_user_token()\n self.create_buckets(token)\n response = self.client.get(\n '/bucketlists/?q=T',\n headers=dict(Authorization='Bearer ' + token)\n )\n data = json.loads(response.data.decode())\n self.assertTrue(data['status'] == 'success')\n self.assertIsInstance(data['buckets'], list, 'Items must be a list')\n self.assertEqual(len(data['buckets']), 3)\n self.assertEqual(data['buckets'][0]['id'], 1)\n self.assertEqual(data['count'], 6)\n self.assertEqual(data['next'], 'http://localhost/bucketlists/?page=2')\n self.assertEqual(data['previous'], None)\n self.assertEqual(response.status_code, 200)", "def test_buckets_returned_when_searched_2(self):\n with self.client:\n token = self.get_user_token()\n self.create_buckets(token)\n response = self.client.get(\n '/bucketlists/?q=T&page=2',\n headers=dict(Authorization='Bearer ' + token)\n )\n data = json.loads(response.data.decode())\n self.assertTrue(data['status'] == 'success')\n self.assertIsInstance(data['buckets'], list, 'Items must be a list')\n self.assertEqual(len(data['buckets']), 3)\n self.assertEqual(data['buckets'][0]['id'], 4)\n self.assertEqual(data['count'], 6)\n self.assertEqual(data['next'], None)\n self.assertEqual(data['previous'], 'http://localhost/bucketlists/?page=1')\n self.assertEqual(response.status_code, 200)", "def test_api_get_bucketlist_by_id(self):\n res_post = self.client().post('/bucketlist', data=self.bucketlist)\n self.assertEqual(res_post.status_code, 201)\n res_in_json = json.loads(res_post.data.decode('UTF-8').replace(\"'\", \"\\\"\"))\n res = self.client().get(f\"/bucketlist/{res_in_json['id']}\")\n self.assertEqual(res.status_code, 200)\n self.assertIn('Go to vacation', str(res.data))", "def test_create_bucket_list_return(self):\n bucket = BucketList(\"\", \"\")\n bucket = bucket.create_bucket_list(\"Name\", \"Completed\")\n self.assertIsInstance(bucket, BucketList)", "def test_no_bucket_returned_by_given_id(self):\n with self.client:\n token = self.get_user_token()\n\n response = self.client.get(\n '/bucketlists/1',\n headers=dict(Authorization='Bearer ' + token)\n )\n data = json.loads(response.data.decode())\n self.assertEqual(response.status_code, 200)\n self.assertTrue(data['status'] == 'success')\n self.assertIsInstance(data['bucket'], list)\n self.assertTrue(response.content_type == 'application/json')", "def test_create_bucketlist_item(self):\n resp = self.client.post('/bucketlists',\n data=json.dumps(self.bucketlist),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n response = self.client.get(\n \"/bucketlists/1\", headers={\n \"Authorization\": self.token})\n self.assertEqual(response.status_code, 200)\n resp_item = self.client.post('/bucketlistitems/1/items',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n result = json.loads(resp_item.data)\n self.assertEqual(result[\"message\"],\n \"Bucket list item added successfully.\")\n self.assertEqual(resp.status_code, 201)", "def test_get_bucket(self):\n pass", "def get_bucketlist():\n pass", "def test_get_buckets(self):\n pass", "def test_add_bucketlist_items(self):\r\n email = \"[email protected]\"\r\n _pword = \"test\"\r\n user = User.query.filter_by(email=email).first()\r\n bucketlist = BucketList.query.filter_by(user_id=user.id, name=\"test bucketlist\").first()\r\n item_no = BucketListItem.query.filter_by(bucketlist_id=bucketlist.id).count()\r\n response = self.add_bucketlist_item(email, _pword, bucketlist.id, \"bucketlist item name\")\r\n result = json.loads(response.data.decode('utf-8'))\r\n self.assertEqual(response.status, '201 CREATED')\r\n self.assertEqual(result['message'], 'Bucket list item added')\r\n new_item_no = BucketListItem.query.filter_by(bucketlist_id=bucketlist.id).count()\r\n self.assertLess(item_no, new_item_no)", "def test_list_bucket(self):\n\n if self.bos.does_bucket_exist(\"aaaaaaxzr1\"):\n self.bos.delete_bucket(\"aaaaaaxzr1\")\n if self.bos.does_bucket_exist(\"aaaaaaxzr2\"):\n self.bos.delete_bucket(\"aaaaaaxzr2\")\n\n time1 = utils.get_canonical_time()\n self.bos.create_bucket(\"aaaaaaxzr1\")\n\n time2 = utils.get_canonical_time()\n self.bos.create_bucket(\"aaaaaaxzr2\")\n\n response = self.bos.list_buckets()\n self.check_headers(response)\n\n self.assertEqual(response.owner.id, bos_test_config.OWNER_ID)\n self.assertEqual(response.owner.display_name, bos_test_config.DISPLAY_NAME)\n for bucket in response.buckets:\n if bucket.name == \"aaaaaaxzr1\":\n self.assertEqual(\n compat.convert_to_bytes(bucket.creation_date)[0:19], \n compat.convert_to_bytes(time1)[0:19])\n elif bucket.name == \"aaaaaaxzr2\":\n self.assertEqual(\n compat.convert_to_bytes(bucket.creation_date)[0:19], \n compat.convert_to_bytes(time2)[0:19])\n self.bos.delete_bucket(\"aaaaaaxzr1\")\n self.bos.delete_bucket(\"aaaaaaxzr2\")", "def test_bucketlist_create(self):\n res = self.client().post('/bucketlist', data=self.bucketlist)\n self.assertEqual(res.status_code, 201)\n self.assertIn('Go to vacation', str(res.data))", "def test_list_all_bucektlists_for_authenticated_user(self):\n\n response = self.client.get(\n \"/bucketlists/\",\n headers={'Authorization': self.user_token}\n )\n\n self.assertEqual(response.status_code, 200)\n self.assertEqual(response.data, '[]\\n')", "def test_put_bucketlist_item(self):\r\n data = {\"name\": \"bucketlist item name\", \"completed\": \"true\"}\r\n email = \"[email protected]\"\r\n _pword = \"test\"\r\n user = User.query.filter_by(email=email).first()\r\n bucketlist = BucketList.query.filter_by(user_id=user.id, name=\"test bucketlist\").first()\r\n item = BucketListItem.query.filter_by(bucketlist_id=bucketlist.id, id=1).first()\r\n self.assertNotEqual(item.name, \"bucketlist item name\")\r\n self.assertFalse(item.completed)\r\n\r\n response = self.put_bucketlist_item(email, _pword, bucketlist.id, 1, data)\r\n result = json.loads(response.data.decode('utf-8'))\r\n item2 = BucketListItem.query.filter_by(bucketlist_id=bucketlist.id, id=1).first()\r\n self.assertEqual(response.status, '201 CREATED')\r\n self.assertEqual(item2.name, \"bucketlist item name\")\r\n self.assertTrue(item2.completed)", "def test_delete_bucketlist_item(self):\n self.register_user()\n result = self.login_user()\n access_token = json.loads(result.data.decode())['access_token']\n\n # create a bucketlist by making a POST request\n res = self.client().post(\n '/api/v1/bucketlists/',\n headers=dict(Authorization=\"Bearer \" + access_token),\n data=self.bucketlist)\n self.assertEqual(res.status_code, 201)\n # get the json with the bucketlist\n results = json.loads(res.data.decode())\n\n # create a bucketlist item by making a POST request and add it to the created bucketlist\n res = self.client().post(\n '/api/v1/bucketlists/{}/items/'.format(results['id']),\n headers=dict(Authorization=\"Bearer \" + access_token),\n data={\n \"name\": \"Eat fried crabs\"\n })\n self.assertEqual(res.status_code, 201)\n # get the json containing the created bucketlist item\n res_item = json.loads(res.data.decode())\n\n # delete the bucketlist item we just created\n res = self.client().delete(\n '/api/v1/bucketlists/{}/items/{}'.format(results['id'], res_item['id']),\n headers=dict(Authorization=\"Bearer \" + access_token), )\n self.assertEqual(res.status_code, 200)\n\n # Test to see if it exists, should return a 404\n result = self.client().get(\n '/api/v1/bucketlists/{}/items/1'.format(results['id']),\n headers=dict(Authorization=\"Bearer \" + access_token))\n self.assertEqual(result.status_code, 404)", "def test_edit_bucketlist(self):\n post_data = self.post_a_bucket()\n self.assertEqual(post_data.status_code, 201)\n result_of_put_method = self.client().put(\n '/bucketlists/1',\n headers=dict(Authorization='Bearer '\n + self.token()\n ),\n data={\n \"name\": \"The seasons will be, summer winter and autumn\"\n })\n self.assertEqual(result_of_put_method.status_code, 201)\n result_of_get_method = self.client().get('/bucketlists/1',\n headers=dict(Authorization='Bearer '\n + self.token())\n )\n self.assertIn('The seasons will b', str(result_of_get_method.data))", "def test_api_delete_bucketlist(self):\n\n res_post = self.client().post('/bucketlist', data={'name': \"Don't forget to exercise\"})\n self.assertEqual(res_post.status_code, 201)\n res_post_in_json = json.loads(res_post.data.decode('UTF-8'))\n id = res_post_in_json['id']\n res_delete = self.client().delete(f\"/bucketlist/{id}\")\n self.assertEqual(res_delete.status_code, 200)\n\n # should return 404 after delete the data\n res = self.client().get(f'/bucketlist/{id}')\n self.assertEqual(res.status_code, 404)", "def test_create_bucketlist_view_returns_200_status_code(self):\n response = self.app.get('/create-bucketlist')\n self.assertEqual(response.status_code, 200, \n \"should return a status code of 200\")", "def test_get_item_list(self):\n resp = self.app.get('/items')\n self.assertEqual(resp.status_code, status.HTTP_200_OK)\n data = json.loads(resp.data)\n self.assertEqual(len(data), 3)", "def test_bucketlist_creation(self):\n post_data = self.post_a_bucket()\n self.assertEqual(post_data.status_code, 201)\n self.assertIn('Climb the Himalayas', str(post_data.data))", "def manipulate_bucketlist():\n pass" ]

[ "0.8520477", "0.8132996", "0.7968485", "0.79678524", "0.7939482", "0.791598", "0.76777196", "0.76503426", "0.760791", "0.75708175", "0.7465317", "0.7436615", "0.7426375", "0.74000996", "0.7353851", "0.73192596", "0.73068476", "0.725187", "0.72268575", "0.7211199", "0.71193653", "0.7109211", "0.7098046", "0.707913", "0.70477027", "0.7005692", "0.7002244", "0.6994109", "0.69594705", "0.6937721" ]

[ "def test_create_bucketlist_item(self):\n resp = self.client.post('/bucketlists',\n data=json.dumps(self.bucketlist),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n response = self.client.get(\n \"/bucketlists/1\", headers={\n \"Authorization\": self.token})\n self.assertEqual(response.status_code, 200)\n resp_item = self.client.post('/bucketlistitems/1/items',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n result = json.loads(resp_item.data)\n self.assertEqual(result[\"message\"],\n \"Bucket list item added successfully.\")\n self.assertEqual(resp.status_code, 201)", "def test_put_bucketlist_item(self):\r\n data = {\"name\": \"bucketlist item name\", \"completed\": \"true\"}\r\n email = \"[email protected]\"\r\n _pword = \"test\"\r\n user = User.query.filter_by(email=email).first()\r\n bucketlist = BucketList.query.filter_by(user_id=user.id, name=\"test bucketlist\").first()\r\n item = BucketListItem.query.filter_by(bucketlist_id=bucketlist.id, id=1).first()\r\n self.assertNotEqual(item.name, \"bucketlist item name\")\r\n self.assertFalse(item.completed)\r\n\r\n response = self.put_bucketlist_item(email, _pword, bucketlist.id, 1, data)\r\n result = json.loads(response.data.decode('utf-8'))\r\n item2 = BucketListItem.query.filter_by(bucketlist_id=bucketlist.id, id=1).first()\r\n self.assertEqual(response.status, '201 CREATED')\r\n self.assertEqual(item2.name, \"bucketlist item name\")\r\n self.assertTrue(item2.completed)", "def test_bucketlist_create(self):\n res = self.client().post('/bucketlist', data=self.bucketlist)\n self.assertEqual(res.status_code, 201)\n self.assertIn('Go to vacation', str(res.data))", "def test_bucketlist_creation(self):\n post_data = self.post_a_bucket()\n self.assertEqual(post_data.status_code, 201)\n self.assertIn('Climb the Himalayas', str(post_data.data))", "def test_get_bucketlist_items(self):\n resp = self.client.post('/bucketlists',\n data=json.dumps(self.bucketlist),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n\n resp_item = self.client.post('/bucketlistitems/1/items',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n\n self.assertEqual(resp_item.status_code, 200)\n resp_item = self.client.get('/bucketlistitems/1/items', headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp_item.status_code, 200)", "def add_bucketlist_item(self, email, password, buckelist_id, item_name):\r\n test_date = str(date(2020, 9, 22))\r\n headers = self.authentication_headers(email=email, password=password)\r\n return self.client.post(\r\n '/api/v1/bucketlist/{}/items/'.format(buckelist_id),\r\n data=json.dumps({\"name\": item_name, \"finished_by\": test_date}),\r\n content_type=\"application/json\",\r\n headers=headers,\r\n follow_redirects=True\r\n )", "def test_add_item_at_using_put(self):\n pass", "def test_creating_and_getting_a_bucketlist_for_authenticated_user(self):\n\n # test all bucketlists\n response = self.client.post(\n \"/bucketlists/\",\n data=dict(name='test_bucketlist'),\n headers={'Authorization': self.user_token}\n )\n bucketlist = json.loads(response.data)\n\n self.assertEqual(response.status_code, 200)\n self.assertEqual(bucketlist[\"name\"], 'test_bucketlist')\n\n # test single bucketlist\n self.bucketlist_id = bucketlist[\"bucketlist_id\"]\n single_bucketlist = self.client.get(\n \"/bucketlists/\" + str(self.bucketlist_id) + \"\",\n headers={'Authorization': self.user_token}\n )\n\n one_bucketlist = json.loads(single_bucketlist.data)\n\n self.assertEqual(single_bucketlist.status_code, 200)\n self.assertEqual(one_bucketlist[\"name\"], 'test_bucketlist')\n\n # test all items in bucketlist\n item = self.client.post(\n \"/bucketlists/\" + str(self.bucketlist_id) + \"/items/\",\n data=dict(name=\"test_item\"),\n headers={'Authorization': self.user_token}\n )\n\n one_item = json.loads(item.data)\n\n self.assertEqual(item.status_code, 200)\n self.assertEqual(one_item[\"name\"], 'test_item')\n\n # test single item in bucketlist\n self.item_id = one_item[\"item_id\"]\n single_item = self.client.get(\n \"/bucketlists/\" + str(self.bucketlist_id) + \"/items/\" + str(self.item_id) + \"\",\n headers={'Authorization': self.user_token}\n )\n\n created_item = json.loads(single_item.data)\n\n self.assertEqual(single_item.status_code, 200)\n self.assertEqual(created_item[\"name\"], 'test_item')\n\n # test for deletion of bucketlist\n second_bucketlist = self.client.post(\n \"/bucketlists/\",\n data=dict(name='second_bucketlist'),\n headers={'Authorization': self.user_token}\n )\n\n bucketlist_two = json.loads(second_bucketlist.data)\n\n self.assertEqual(second_bucketlist.status_code, 200)\n self.assertEqual(bucketlist_two[\"name\"], 'second_bucketlist')\n\n delete_response = self.client.delete(\n \"/bucketlists/\" + str(bucketlist_two[\"bucketlist_id\"]) + \"\",\n headers={'Authorization': self.user_token}\n )\n\n deletion = json.loads(delete_response.data)\n\n self.assertEqual(delete_response.status_code, 200)\n self.assertEqual(deletion[\"message\"], \"Deleted\")\n\n # test for deletion of an item in bucketlist\n delete_item = self.client.delete(\n \"/bucketlists/\" + str(bucketlist[\"bucketlist_id\"]) + \"/items/\" + str(one_item[\"item_id\"]) + \"\",\n headers={'Authorization': self.user_token}\n )\n\n item_deletion = json.loads(delete_item.data)\n\n self.assertEqual(delete_item.status_code, 200)\n self.assertEqual(item_deletion[\"message\"], \"Deleted\")\n\n # test for updating of bucketlist\n self.bucketlist_id = bucketlist[\"bucketlist_id\"]\n bucketlist_update = self.client.put(\n \"/bucketlists/\" + str(self.bucketlist_id) + \"\",\n data=dict(name='bucketlist_test'),\n headers={'Authorization': self.user_token}\n )\n\n updated_bucketlist = json.loads(bucketlist_update.data)\n\n self.assertEqual(bucketlist_update.status_code, 200)\n self.assertEqual(updated_bucketlist[\"name\"], 'bucketlist_test')\n\n # test update of item in bucketlist\n item = self.client.post(\n \"/bucketlists/\" + str(self.bucketlist_id) + \"/items/\",\n data=dict(name=\"test_item\"),\n headers={'Authorization': self.user_token}\n )\n\n one_item = json.loads(item.data)\n\n item_update = self.client.put(\n \"/bucketlists/\" + str(self.bucketlist_id) + \"/items/\"+ str(one_item[\"item_id\"]) + \"\",\n data=dict(name=\"item_test\"),\n headers={'Authorization': self.user_token}\n )\n\n updated_item = json.loads(item_update.data)\n\n self.assertEqual(item_update.status_code, 200)\n self.assertEqual(updated_item[\"name\"], 'item_test')", "def post_bucketlist():\n pass", "def test_edit_bucketlist(self):\n post_data = self.post_a_bucket()\n self.assertEqual(post_data.status_code, 201)\n result_of_put_method = self.client().put(\n '/bucketlists/1',\n headers=dict(Authorization='Bearer '\n + self.token()\n ),\n data={\n \"name\": \"The seasons will be, summer winter and autumn\"\n })\n self.assertEqual(result_of_put_method.status_code, 201)\n result_of_get_method = self.client().get('/bucketlists/1',\n headers=dict(Authorization='Bearer '\n + self.token())\n )\n self.assertIn('The seasons will b', str(result_of_get_method.data))", "def test_api_edit_bucketlist(self):\n res_post = self.client().post('/bucketlist', data={'name': 'Wake up, Eat, Code, Sleep & Repeat'})\n self.assertEqual(res_post.status_code, 201)\n res_post_in_json = json.loads(res_post.data.decode('UTF-8').replace(\"'\", \"\\\"\"))\n id = res_post_in_json['id']\n res_put = self.client().put(\n f'bucketlist/{id}',\n data={\n 'name': \"Don't forget to exercise\"\n }\n )\n self.assertEqual(res_put.status_code, 200)\n res = self.client().get(f'/bucketlist/{id}')\n self.assertIn(\"exercise\", str(res.data))", "def test_duplicate_bucketlist_item(self):\n resp = self.client.post('/bucketlists',\n data=json.dumps(self.bucketlist),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n resp_item = self.client.post('/bucketlistitems/1/items',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n resp_item2 = self.client.post('/bucketlistitems/1/items',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n result = json.loads(resp_item2.data)\n self.assertEqual(result[\"message\"], \"Item with the given name exists.\")\n self.assertEqual(resp_item2.status_code, 409)", "def test_create_bucket_list_return(self):\n bucket = BucketList(\"\", \"\")\n bucket = bucket.create_bucket_list(\"Name\", \"Completed\")\n self.assertIsInstance(bucket, BucketList)", "def test_create_bucket_list_name(self):\n bucket = BucketList(\"\", \"\")\n bucket = bucket.create_bucket_list(\"\")\n self.assertEqual(bucket, \"Please provide a name for your bucket list\", )", "def test_delete_bucketlist_item(self):\n self.register_user()\n result = self.login_user()\n access_token = json.loads(result.data.decode())['access_token']\n\n # create a bucketlist by making a POST request\n res = self.client().post(\n '/api/v1/bucketlists/',\n headers=dict(Authorization=\"Bearer \" + access_token),\n data=self.bucketlist)\n self.assertEqual(res.status_code, 201)\n # get the json with the bucketlist\n results = json.loads(res.data.decode())\n\n # create a bucketlist item by making a POST request and add it to the created bucketlist\n res = self.client().post(\n '/api/v1/bucketlists/{}/items/'.format(results['id']),\n headers=dict(Authorization=\"Bearer \" + access_token),\n data={\n \"name\": \"Eat fried crabs\"\n })\n self.assertEqual(res.status_code, 201)\n # get the json containing the created bucketlist item\n res_item = json.loads(res.data.decode())\n\n # delete the bucketlist item we just created\n res = self.client().delete(\n '/api/v1/bucketlists/{}/items/{}'.format(results['id'], res_item['id']),\n headers=dict(Authorization=\"Bearer \" + access_token), )\n self.assertEqual(res.status_code, 200)\n\n # Test to see if it exists, should return a 404\n result = self.client().get(\n '/api/v1/bucketlists/{}/items/1'.format(results['id']),\n headers=dict(Authorization=\"Bearer \" + access_token))\n self.assertEqual(result.status_code, 404)", "def test_fail_repeated_buckelist_item(self):\r\n user = User.query.filter_by(email=\"[email protected]\").first()\r\n bucketlist = BucketList.query.filter_by(user_id=user.id, name=\"test bucketlist\").first()\r\n item_no = BucketListItem.query.filter_by(bucketlist_id=bucketlist.id).count()\r\n response = self.add_bucketlist_item(\"[email protected]\", \"test\", bucketlist.id, \"test item\")\r\n result = json.loads(response.data.decode('utf-8'))\r\n self.assertEqual(response.status, '409 CONFLICT')\r\n self.assertEqual(result['message'], 'Bucketlist Item Exists')\r\n new_item_no = BucketListItem.query.filter_by(bucketlist_id=bucketlist.id).count()\r\n self.assertEqual(item_no, new_item_no)", "def test_get_bucketlist_item_id(self):\n resp = self.client.post('/bucketlists',\n data=json.dumps(self.bucketlist),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n resp_item = self.client.post('/bucketlistitems/1/items',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n get_item = self.client.get('/bucketlistitems/1/items/1', headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)", "def test_update_busketlistitem_by_id(self):\n resp = self.client.post('/bucketlists',\n data=json.dumps(self.bucketlist),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n resp_item = self.client.post('/bucketlistitems/1/items',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n update_item = self.client.put('/bucketlistitems/1/items/1',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs and museums too.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(update_item.status_code, 201)", "def test_bucket_is_updated(self):\n with self.client:\n # Get an auth token\n token = self.get_user_token()\n # Create a Bucket\n response = self.client.post(\n '/bucketlists',\n data=json.dumps(dict(name='Travel')),\n headers=dict(Authorization='Bearer ' + token),\n content_type='application/json'\n )\n # Test Bucket creation\n data = json.loads(response.data.decode())\n self.assertEqual(response.status_code, 201)\n self.assertTrue(data['status'], 'success')\n self.assertTrue(data['name'], 'Travel')\n # Update the bucket name\n res = self.client.put(\n '/bucketlists/1',\n headers=dict(Authorization='Bearer ' + token),\n data=json.dumps(dict(name='Adventure')),\n content_type='application/json'\n )\n data = json.loads(res.data.decode())\n self.assertEqual(res.status_code, 201)\n self.assertTrue(res.content_type == 'application/json')\n self.assertTrue(data['status'] == 'success')\n self.assertTrue(data['name'] == 'Adventure')\n self.assertEqual(data['id'], 1)", "def test_put_item_wrong_id(self):\r\n data = {\"name\": \"bucketlist item name\", \"completed\": \"true\"}\r\n email = \"[email protected]\"\r\n _pword = \"test\"\r\n user = User.query.filter_by(email=email).first()\r\n bucketlist = BucketList.query.filter_by(user_id=user.id, name=\"test bucketlist\").first()\r\n item = BucketListItem.query.filter_by(bucketlist_id=bucketlist.id, id=0).first()\r\n self.assertFalse(item)\r\n\r\n response = self.put_bucketlist_item(email, _pword, bucketlist.id, 0, data)\r\n result = json.loads(response.data.decode('utf-8'))\r\n self.assertEqual(response.status, '404 NOT FOUND')\r\n self.assertEqual(\r\n result['message'],\r\n 'Bucketlist Item with ID {} not found in the database. You have requested this URI '\\\r\n '[/api/v1/bucketlist/1/items/0] but did you mean /api/v1/bucketlist/<int:bucketlist_id>/items/'\\\r\n ' or /api/v1/bucketlist/<int:bucketlist_id> or /api/v1/bucketlist ?'.format(0)\r\n )", "def test_create(self):\n responses.add(\n responses.Response(\n method='POST',\n url='https://connection.keboola.com/v2/storage/buckets',\n json=create_response\n )\n )\n name = 'my-new-bucket'\n description = 'Some Description'\n backend = 'snowflake'\n created_detail = self.buckets.create(name=name,\n description=description,\n backend=backend)\n assert created_detail['id'] == 'in.c-{}'.format(name)", "def post(self, user):\n # parse request data\n bucketlist_name = self.request.form['name']\n\n # validate bucketlist\n if not bucketlist_name:\n return \"Name cannot be empty\", 401\n\n # create bucketlist and save bucketlist\n bucketlist = Bucketlist(name=bucketlist_name, date_created=datetime.utcnow(\n ), created_by=user.username, author=user)\n bucketlist.save()\n\n return \"Successfully created bucketlist\", 201", "def test_delete_bucketlistitem_by_id(self):\n resp = self.client.post('/bucketlists',\n data=json.dumps(self.bucketlist),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n resp_item = self.client.post('/bucketlistitems/1/items',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n delete_item = self.client.delete('/bucketlistitems/1/items/1',\n headers={\n \"Authorization\": self.token\n })\n self.assertEqual(delete_item.status_code, 204)", "def test_add_item_using_post(self):\n pass", "def test_bucket_by_id_is_returned_on_get_request(self):\n with self.client:\n token = self.get_user_token()\n # Create a Bucket\n response = self.client.post(\n '/bucketlists',\n data=json.dumps(dict(name='Travel')),\n headers=dict(Authorization='Bearer ' + token),\n content_type='application/json'\n )\n # Test Bucket creation\n data = json.loads(response.data.decode())\n self.assertEqual(response.status_code, 201)\n self.assertTrue(data['status'], 'success')\n self.assertTrue(data['name'], 'Travel')\n response = self.client.get(\n '/bucketlists/1',\n headers=dict(Authorization='Bearer ' + token)\n )\n data = json.loads(response.data.decode())\n self.assertEqual(response.status_code, 200)\n self.assertTrue(data['status'] == 'success')\n self.assertTrue(data['bucket']['name'] == 'travel')\n self.assertIsInstance(data['bucket'], dict)\n self.assertTrue(response.content_type == 'application/json')", "def test_create_bucket(self):\n pass", "def put_bucketlist_item(self, email, password, bucketlist_id, item_id, data):\r\n headers = self.authentication_headers(email=email, password=password)\r\n return self.client.put(\r\n '/api/v1/bucketlist/{}/items/{}'.format(bucketlist_id, item_id),\r\n content_type=\"application/json\",\r\n data=json.dumps(data),\r\n headers=headers,\r\n follow_redirects=True\r\n )", "def test_create_bucketlist_view_returns_200_status_code(self):\n response = self.app.get('/create-bucketlist')\n self.assertEqual(response.status_code, 200, \n \"should return a status code of 200\")", "def test_single_bucketlist_item_delete_with_empty_token(self):\n self.register_user()\n result = self.login_user()\n access_token = json.loads(result.data.decode())['access_token']\n\n res = self.client().post(\n '/api/v1/bucketlists/',\n headers=dict(Authorization=\"Bearer \" + access_token),\n data=self.bucketlist)\n\n # assert that the bucketlist is created\n self.assertEqual(res.status_code, 201)\n # get the response data in json format\n results = json.loads(res.data.decode())\n\n # create a bucketlist item by making a POST request and add it to the created bucketlist\n res = self.client().post(\n '/api/v1/bucketlists/{}/items/'.format(results['id']),\n headers=dict(Authorization=\"Bearer \" + access_token),\n data={\n \"name\": \"Eat fried crabs\"\n })\n self.assertEqual(res.status_code, 201)\n # get the json containing the created bucketlist item\n res_item = json.loads(res.data.decode())\n\n # delete the bucketlist item we just created\n res = self.client().delete(\n '/api/v1/bucketlists/{}/items/{}'.format(results['id'], res_item['id']),\n headers=dict(Authorization=\"\"), )\n self.assertEqual(res.status_code, 401)\n self.assertIn('Token not provided in the header with key Authorization.', str(res.data))", "def test_get_bucketlist_items(self):\r\n email = \"[email protected]\"\r\n _pword = \"test\"\r\n user = User.query.filter_by(email=email).first()\r\n bucketlist = BucketList.query.filter_by(user_id=user.id, id=1).first()\r\n items_no = len(bucketlist.bucketlist_items)\r\n headers = self.authentication_headers(email=email, password=_pword)\r\n response = self.client.get(\r\n '/api/v1/bucketlist/1/items/',\r\n content_type=\"application/json\",\r\n headers=headers,\r\n follow_redirects=True\r\n )\r\n result = json.loads(response.data.decode('utf-8'))\r\n self.assertEqual(len(result), items_no)" ]

[ "0.8470567", "0.8040441", "0.76671934", "0.7665731", "0.75571686", "0.7541412", "0.73769414", "0.7354037", "0.735012", "0.73247266", "0.73235244", "0.7313603", "0.7295238", "0.71595377", "0.7149308", "0.7145139", "0.71401936", "0.71109724", "0.7093405", "0.70680696", "0.6946335", "0.68785876", "0.687531", "0.6841962", "0.68415093", "0.6760094", "0.66894764", "0.66697323", "0.6665334", "0.6653366" ]

[ "def test_duplicate_bucketlist_item(self):\n resp = self.client.post('/bucketlists',\n data=json.dumps(self.bucketlist),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n resp_item = self.client.post('/bucketlistitems/1/items',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n resp_item2 = self.client.post('/bucketlistitems/1/items',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n result = json.loads(resp_item2.data)\n self.assertEqual(result[\"message\"], \"Item with the given name exists.\")\n self.assertEqual(resp_item2.status_code, 409)", "def test_add_bucketlist_items(self):\r\n email = \"[email protected]\"\r\n _pword = \"test\"\r\n user = User.query.filter_by(email=email).first()\r\n bucketlist = BucketList.query.filter_by(user_id=user.id, name=\"test bucketlist\").first()\r\n item_no = BucketListItem.query.filter_by(bucketlist_id=bucketlist.id).count()\r\n response = self.add_bucketlist_item(email, _pword, bucketlist.id, \"bucketlist item name\")\r\n result = json.loads(response.data.decode('utf-8'))\r\n self.assertEqual(response.status, '201 CREATED')\r\n self.assertEqual(result['message'], 'Bucket list item added')\r\n new_item_no = BucketListItem.query.filter_by(bucketlist_id=bucketlist.id).count()\r\n self.assertLess(item_no, new_item_no)", "def test_create_bucketlist_item(self):\n resp = self.client.post('/bucketlists',\n data=json.dumps(self.bucketlist),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n response = self.client.get(\n \"/bucketlists/1\", headers={\n \"Authorization\": self.token})\n self.assertEqual(response.status_code, 200)\n resp_item = self.client.post('/bucketlistitems/1/items',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n result = json.loads(resp_item.data)\n self.assertEqual(result[\"message\"],\n \"Bucket list item added successfully.\")\n self.assertEqual(resp.status_code, 201)", "def test_put_bucketlist_item(self):\r\n data = {\"name\": \"bucketlist item name\", \"completed\": \"true\"}\r\n email = \"[email protected]\"\r\n _pword = \"test\"\r\n user = User.query.filter_by(email=email).first()\r\n bucketlist = BucketList.query.filter_by(user_id=user.id, name=\"test bucketlist\").first()\r\n item = BucketListItem.query.filter_by(bucketlist_id=bucketlist.id, id=1).first()\r\n self.assertNotEqual(item.name, \"bucketlist item name\")\r\n self.assertFalse(item.completed)\r\n\r\n response = self.put_bucketlist_item(email, _pword, bucketlist.id, 1, data)\r\n result = json.loads(response.data.decode('utf-8'))\r\n item2 = BucketListItem.query.filter_by(bucketlist_id=bucketlist.id, id=1).first()\r\n self.assertEqual(response.status, '201 CREATED')\r\n self.assertEqual(item2.name, \"bucketlist item name\")\r\n self.assertTrue(item2.completed)", "def test_get_bucketlist_items(self):\n resp = self.client.post('/bucketlists',\n data=json.dumps(self.bucketlist),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n\n resp_item = self.client.post('/bucketlistitems/1/items',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n\n self.assertEqual(resp_item.status_code, 200)\n resp_item = self.client.get('/bucketlistitems/1/items', headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp_item.status_code, 200)", "def test_get_bucketlist_item_id(self):\n resp = self.client.post('/bucketlists',\n data=json.dumps(self.bucketlist),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n resp_item = self.client.post('/bucketlistitems/1/items',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n get_item = self.client.get('/bucketlistitems/1/items/1', headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)", "def test_put_item_wrong_id(self):\r\n data = {\"name\": \"bucketlist item name\", \"completed\": \"true\"}\r\n email = \"[email protected]\"\r\n _pword = \"test\"\r\n user = User.query.filter_by(email=email).first()\r\n bucketlist = BucketList.query.filter_by(user_id=user.id, name=\"test bucketlist\").first()\r\n item = BucketListItem.query.filter_by(bucketlist_id=bucketlist.id, id=0).first()\r\n self.assertFalse(item)\r\n\r\n response = self.put_bucketlist_item(email, _pword, bucketlist.id, 0, data)\r\n result = json.loads(response.data.decode('utf-8'))\r\n self.assertEqual(response.status, '404 NOT FOUND')\r\n self.assertEqual(\r\n result['message'],\r\n 'Bucketlist Item with ID {} not found in the database. You have requested this URI '\\\r\n '[/api/v1/bucketlist/1/items/0] but did you mean /api/v1/bucketlist/<int:bucketlist_id>/items/'\\\r\n ' or /api/v1/bucketlist/<int:bucketlist_id> or /api/v1/bucketlist ?'.format(0)\r\n )", "def test_create_bucket_list_name(self):\n bucket = BucketList(\"\", \"\")\n bucket = bucket.create_bucket_list(\"\")\n self.assertEqual(bucket, \"Please provide a name for your bucket list\", )", "def test_creating_and_getting_a_bucketlist_for_authenticated_user(self):\n\n # test all bucketlists\n response = self.client.post(\n \"/bucketlists/\",\n data=dict(name='test_bucketlist'),\n headers={'Authorization': self.user_token}\n )\n bucketlist = json.loads(response.data)\n\n self.assertEqual(response.status_code, 200)\n self.assertEqual(bucketlist[\"name\"], 'test_bucketlist')\n\n # test single bucketlist\n self.bucketlist_id = bucketlist[\"bucketlist_id\"]\n single_bucketlist = self.client.get(\n \"/bucketlists/\" + str(self.bucketlist_id) + \"\",\n headers={'Authorization': self.user_token}\n )\n\n one_bucketlist = json.loads(single_bucketlist.data)\n\n self.assertEqual(single_bucketlist.status_code, 200)\n self.assertEqual(one_bucketlist[\"name\"], 'test_bucketlist')\n\n # test all items in bucketlist\n item = self.client.post(\n \"/bucketlists/\" + str(self.bucketlist_id) + \"/items/\",\n data=dict(name=\"test_item\"),\n headers={'Authorization': self.user_token}\n )\n\n one_item = json.loads(item.data)\n\n self.assertEqual(item.status_code, 200)\n self.assertEqual(one_item[\"name\"], 'test_item')\n\n # test single item in bucketlist\n self.item_id = one_item[\"item_id\"]\n single_item = self.client.get(\n \"/bucketlists/\" + str(self.bucketlist_id) + \"/items/\" + str(self.item_id) + \"\",\n headers={'Authorization': self.user_token}\n )\n\n created_item = json.loads(single_item.data)\n\n self.assertEqual(single_item.status_code, 200)\n self.assertEqual(created_item[\"name\"], 'test_item')\n\n # test for deletion of bucketlist\n second_bucketlist = self.client.post(\n \"/bucketlists/\",\n data=dict(name='second_bucketlist'),\n headers={'Authorization': self.user_token}\n )\n\n bucketlist_two = json.loads(second_bucketlist.data)\n\n self.assertEqual(second_bucketlist.status_code, 200)\n self.assertEqual(bucketlist_two[\"name\"], 'second_bucketlist')\n\n delete_response = self.client.delete(\n \"/bucketlists/\" + str(bucketlist_two[\"bucketlist_id\"]) + \"\",\n headers={'Authorization': self.user_token}\n )\n\n deletion = json.loads(delete_response.data)\n\n self.assertEqual(delete_response.status_code, 200)\n self.assertEqual(deletion[\"message\"], \"Deleted\")\n\n # test for deletion of an item in bucketlist\n delete_item = self.client.delete(\n \"/bucketlists/\" + str(bucketlist[\"bucketlist_id\"]) + \"/items/\" + str(one_item[\"item_id\"]) + \"\",\n headers={'Authorization': self.user_token}\n )\n\n item_deletion = json.loads(delete_item.data)\n\n self.assertEqual(delete_item.status_code, 200)\n self.assertEqual(item_deletion[\"message\"], \"Deleted\")\n\n # test for updating of bucketlist\n self.bucketlist_id = bucketlist[\"bucketlist_id\"]\n bucketlist_update = self.client.put(\n \"/bucketlists/\" + str(self.bucketlist_id) + \"\",\n data=dict(name='bucketlist_test'),\n headers={'Authorization': self.user_token}\n )\n\n updated_bucketlist = json.loads(bucketlist_update.data)\n\n self.assertEqual(bucketlist_update.status_code, 200)\n self.assertEqual(updated_bucketlist[\"name\"], 'bucketlist_test')\n\n # test update of item in bucketlist\n item = self.client.post(\n \"/bucketlists/\" + str(self.bucketlist_id) + \"/items/\",\n data=dict(name=\"test_item\"),\n headers={'Authorization': self.user_token}\n )\n\n one_item = json.loads(item.data)\n\n item_update = self.client.put(\n \"/bucketlists/\" + str(self.bucketlist_id) + \"/items/\"+ str(one_item[\"item_id\"]) + \"\",\n data=dict(name=\"item_test\"),\n headers={'Authorization': self.user_token}\n )\n\n updated_item = json.loads(item_update.data)\n\n self.assertEqual(item_update.status_code, 200)\n self.assertEqual(updated_item[\"name\"], 'item_test')", "def test_update_busketlistitem_by_id(self):\n resp = self.client.post('/bucketlists',\n data=json.dumps(self.bucketlist),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n resp_item = self.client.post('/bucketlistitems/1/items',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n update_item = self.client.put('/bucketlistitems/1/items/1',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs and museums too.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(update_item.status_code, 201)", "def add_bucketlist_item(self, email, password, buckelist_id, item_name):\r\n test_date = str(date(2020, 9, 22))\r\n headers = self.authentication_headers(email=email, password=password)\r\n return self.client.post(\r\n '/api/v1/bucketlist/{}/items/'.format(buckelist_id),\r\n data=json.dumps({\"name\": item_name, \"finished_by\": test_date}),\r\n content_type=\"application/json\",\r\n headers=headers,\r\n follow_redirects=True\r\n )", "def test_delete_bucketlist_item(self):\n self.register_user()\n result = self.login_user()\n access_token = json.loads(result.data.decode())['access_token']\n\n # create a bucketlist by making a POST request\n res = self.client().post(\n '/api/v1/bucketlists/',\n headers=dict(Authorization=\"Bearer \" + access_token),\n data=self.bucketlist)\n self.assertEqual(res.status_code, 201)\n # get the json with the bucketlist\n results = json.loads(res.data.decode())\n\n # create a bucketlist item by making a POST request and add it to the created bucketlist\n res = self.client().post(\n '/api/v1/bucketlists/{}/items/'.format(results['id']),\n headers=dict(Authorization=\"Bearer \" + access_token),\n data={\n \"name\": \"Eat fried crabs\"\n })\n self.assertEqual(res.status_code, 201)\n # get the json containing the created bucketlist item\n res_item = json.loads(res.data.decode())\n\n # delete the bucketlist item we just created\n res = self.client().delete(\n '/api/v1/bucketlists/{}/items/{}'.format(results['id'], res_item['id']),\n headers=dict(Authorization=\"Bearer \" + access_token), )\n self.assertEqual(res.status_code, 200)\n\n # Test to see if it exists, should return a 404\n result = self.client().get(\n '/api/v1/bucketlists/{}/items/1'.format(results['id']),\n headers=dict(Authorization=\"Bearer \" + access_token))\n self.assertEqual(result.status_code, 404)", "def test_delete_bucketlistitem_by_id(self):\n resp = self.client.post('/bucketlists',\n data=json.dumps(self.bucketlist),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n resp_item = self.client.post('/bucketlistitems/1/items',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n delete_item = self.client.delete('/bucketlistitems/1/items/1',\n headers={\n \"Authorization\": self.token\n })\n self.assertEqual(delete_item.status_code, 204)", "def test_bucket_is_updated(self):\n with self.client:\n # Get an auth token\n token = self.get_user_token()\n # Create a Bucket\n response = self.client.post(\n '/bucketlists',\n data=json.dumps(dict(name='Travel')),\n headers=dict(Authorization='Bearer ' + token),\n content_type='application/json'\n )\n # Test Bucket creation\n data = json.loads(response.data.decode())\n self.assertEqual(response.status_code, 201)\n self.assertTrue(data['status'], 'success')\n self.assertTrue(data['name'], 'Travel')\n # Update the bucket name\n res = self.client.put(\n '/bucketlists/1',\n headers=dict(Authorization='Bearer ' + token),\n data=json.dumps(dict(name='Adventure')),\n content_type='application/json'\n )\n data = json.loads(res.data.decode())\n self.assertEqual(res.status_code, 201)\n self.assertTrue(res.content_type == 'application/json')\n self.assertTrue(data['status'] == 'success')\n self.assertTrue(data['name'] == 'Adventure')\n self.assertEqual(data['id'], 1)", "def test_id_of_bucket_to_be_edited_does_not_exist(self):\n with self.client:\n # Get an auth token\n token = self.get_user_token()\n # Update the bucket name\n res = self.client.put(\n '/bucketlists/1',\n headers=dict(Authorization='Bearer ' + token),\n data=json.dumps(dict(name='Adventure')),\n content_type='application/json'\n )\n data = json.loads(res.data.decode())\n self.assertEqual(res.status_code, 404)\n self.assertTrue(res.content_type == 'application/json')\n self.assertTrue(data['status'] == 'failed')\n self.assertTrue(data['message'] == 'The Bucket with Id 1 does not exist')", "def test_bucketlist_creation(self):\n post_data = self.post_a_bucket()\n self.assertEqual(post_data.status_code, 201)\n self.assertIn('Climb the Himalayas', str(post_data.data))", "def test_single_bucketlist_item_delete_with_empty_token(self):\n self.register_user()\n result = self.login_user()\n access_token = json.loads(result.data.decode())['access_token']\n\n res = self.client().post(\n '/api/v1/bucketlists/',\n headers=dict(Authorization=\"Bearer \" + access_token),\n data=self.bucketlist)\n\n # assert that the bucketlist is created\n self.assertEqual(res.status_code, 201)\n # get the response data in json format\n results = json.loads(res.data.decode())\n\n # create a bucketlist item by making a POST request and add it to the created bucketlist\n res = self.client().post(\n '/api/v1/bucketlists/{}/items/'.format(results['id']),\n headers=dict(Authorization=\"Bearer \" + access_token),\n data={\n \"name\": \"Eat fried crabs\"\n })\n self.assertEqual(res.status_code, 201)\n # get the json containing the created bucketlist item\n res_item = json.loads(res.data.decode())\n\n # delete the bucketlist item we just created\n res = self.client().delete(\n '/api/v1/bucketlists/{}/items/{}'.format(results['id'], res_item['id']),\n headers=dict(Authorization=\"\"), )\n self.assertEqual(res.status_code, 401)\n self.assertIn('Token not provided in the header with key Authorization.', str(res.data))", "def test_delete_item_with_non_existing_bucket(self):\n self.client.post('/buckets',\n content_type='application/json',\n data=self.bucket, headers=self.header)\n self.client.post('/buckets/1/items',\n content_type='application/json',\n data=self.item, headers=self.header)\n response = self.client.delete('/buckets/2/items/1'\n , headers=self.header)\n self.assertEquals(response.status_code, 400)\n self.assertIn('Attempting to delete item on non existing bucket',\n response.data.decode())", "def test_edit_bucketlist(self):\n post_data = self.post_a_bucket()\n self.assertEqual(post_data.status_code, 201)\n result_of_put_method = self.client().put(\n '/bucketlists/1',\n headers=dict(Authorization='Bearer '\n + self.token()\n ),\n data={\n \"name\": \"The seasons will be, summer winter and autumn\"\n })\n self.assertEqual(result_of_put_method.status_code, 201)\n result_of_get_method = self.client().get('/bucketlists/1',\n headers=dict(Authorization='Bearer '\n + self.token())\n )\n self.assertIn('The seasons will b', str(result_of_get_method.data))", "def test_name_attribute_is_set_in_bucket_creation_request(self):\n with self.client:\n response = self.client.post(\n '/bucketlists',\n headers=dict(Authorization='Bearer ' + self.get_user_token()),\n data=json.dumps({}),\n content_type='application/json'\n )\n data = json.loads(response.data.decode())\n self.assertEqual(response.status_code, 400)\n self.assertTrue(data['status'], 'failed')\n self.assertTrue(data['message'], 'Missing name attribute')", "def manipulate_bucketlist():\n pass", "def test_single_bucketlist_item_delete_with_invalid_token(self):\n self.register_user()\n result = self.login_user()\n access_token = json.loads(result.data.decode())['access_token']\n\n res = self.client().post(\n '/api/v1/bucketlists/',\n headers=dict(Authorization=\"Bearer \" + access_token),\n data=self.bucketlist)\n\n # assert that the bucketlist is created\n self.assertEqual(res.status_code, 201)\n # get the response data in json format\n results = json.loads(res.data.decode())\n\n # create a bucketlist item by making a POST request and add it to the created bucketlist\n res = self.client().post(\n '/api/v1/bucketlists/{}/items/'.format(results['id']),\n headers=dict(Authorization=\"Bearer \" + access_token),\n data={\n \"name\": \"Eat fried crabs\"\n })\n self.assertEqual(res.status_code, 201)\n # get the json containing the created bucketlist item\n res_item = json.loads(res.data.decode())\n\n # delete the bucketlist item we just created\n res = self.client().delete(\n '/api/v1/bucketlists/{}/items/{}'.format(results['id'], res_item['id']),\n headers=dict(Authorization=access_token), )\n self.assertEqual(res.status_code, 401)\n self.assertIn('Invalid token format.', str(res.data))", "def test_api_edit_bucketlist(self):\n res_post = self.client().post('/bucketlist', data={'name': 'Wake up, Eat, Code, Sleep & Repeat'})\n self.assertEqual(res_post.status_code, 201)\n res_post_in_json = json.loads(res_post.data.decode('UTF-8').replace(\"'\", \"\\\"\"))\n id = res_post_in_json['id']\n res_put = self.client().put(\n f'bucketlist/{id}',\n data={\n 'name': \"Don't forget to exercise\"\n }\n )\n self.assertEqual(res_put.status_code, 200)\n res = self.client().get(f'/bucketlist/{id}')\n self.assertIn(\"exercise\", str(res.data))", "def test_single_bucketlist_item_delete_with_no_auth_header(self):\n self.register_user()\n result = self.login_user()\n access_token = json.loads(result.data.decode())['access_token']\n\n res = self.client().post(\n '/api/v1/bucketlists/',\n headers=dict(Authorization=\"Bearer \" + access_token),\n data={'name': 'Visit the Grand Canyon!'})\n self.assertEqual(res.status_code, 201)\n # get the bucketlist in json\n results = json.loads(res.data.decode())\n\n # create a bucketlist item by making a POST request and add it to the created bucketlist\n res = self.client().post(\n '/api/v1/bucketlists/{}/items/'.format(results['id']),\n headers=dict(Authorization=\"Bearer \" + access_token),\n data={\n \"name\": \"Eat fried crabs\"\n })\n self.assertEqual(res.status_code, 201)\n # get the json containing the created bucketlist item\n res_item = json.loads(res.data.decode())\n\n # delete the bucketlist item we just created\n res = self.client().delete(\n '/api/v1/bucketlists/{}/items/{}'.format(results['id'], res_item['id']),\n headers=dict(), )\n self.assertEqual(res.status_code, 401)\n self.assertIn('Header with key Authorization missing.', str(res.data))", "def test_bucketlist_create(self):\n res = self.client().post('/bucketlist', data=self.bucketlist)\n self.assertEqual(res.status_code, 201)\n self.assertIn('Go to vacation', str(res.data))", "def test_delete_bucketlist_item(self):\r\n email = \"[email protected]\"\r\n _pword = \"test\"\r\n user = User.query.filter_by(email=email).first()\r\n bucketlist = BucketList.query.filter_by(user_id=user.id, name=\"test bucketlist\").first()\r\n item = BucketListItem.query.filter_by(bucketlist_id=bucketlist.id, id=1).first()\r\n self.assertTrue(item)\r\n\r\n response = self.delete_bucketlist_item(email, _pword, bucketlist.id, item.id)\r\n result = json.loads(response.data.decode('utf-8'))\r\n self.assertEqual(response.status, '200 OK')\r\n self.assertEqual(\r\n result['message'],\r\n 'Bucketlist Item with ID {} deleted'.format(item.id)\r\n )\r\n item = BucketListItem.query.filter_by(bucketlist_id=bucketlist.id, id=1).first()\r\n self.assertFalse(item)", "def test_list_bucket(self):\n\n if self.bos.does_bucket_exist(\"aaaaaaxzr1\"):\n self.bos.delete_bucket(\"aaaaaaxzr1\")\n if self.bos.does_bucket_exist(\"aaaaaaxzr2\"):\n self.bos.delete_bucket(\"aaaaaaxzr2\")\n\n time1 = utils.get_canonical_time()\n self.bos.create_bucket(\"aaaaaaxzr1\")\n\n time2 = utils.get_canonical_time()\n self.bos.create_bucket(\"aaaaaaxzr2\")\n\n response = self.bos.list_buckets()\n self.check_headers(response)\n\n self.assertEqual(response.owner.id, bos_test_config.OWNER_ID)\n self.assertEqual(response.owner.display_name, bos_test_config.DISPLAY_NAME)\n for bucket in response.buckets:\n if bucket.name == \"aaaaaaxzr1\":\n self.assertEqual(\n compat.convert_to_bytes(bucket.creation_date)[0:19], \n compat.convert_to_bytes(time1)[0:19])\n elif bucket.name == \"aaaaaaxzr2\":\n self.assertEqual(\n compat.convert_to_bytes(bucket.creation_date)[0:19], \n compat.convert_to_bytes(time2)[0:19])\n self.bos.delete_bucket(\"aaaaaaxzr1\")\n self.bos.delete_bucket(\"aaaaaaxzr2\")", "def test_id_of_bucket_to_be_edited_is_invalid(self):\n with self.client:\n # Get an auth token\n token = self.get_user_token()\n # Update the bucket name\n res = self.client.put(\n '/bucketlists/bucketid',\n headers=dict(Authorization='Bearer ' + token),\n data=json.dumps(dict(name='Adventure')),\n content_type='application/json'\n )\n data = json.loads(res.data.decode())\n self.assertEqual(res.status_code, 400)\n self.assertTrue(res.content_type == 'application/json')\n self.assertTrue(data['status'] == 'failed')\n self.assertTrue(data['message'] == 'Please provide a valid Bucket Id')", "def test_adding_item_to_list(create_shopping_item, create_shopping_list):\n shopping_list = create_shopping_list\n items_before = shopping_list.items.values_list().count()\n new_item = create_shopping_item\n shopping_list.items.add(new_item)\n items_after = shopping_list.items.values_list().count()\n assert items_after > items_before\n assert items_before == 0\n assert items_after == 1", "def test_add_item_at_using_put(self):\n pass" ]

[ "0.8174513", "0.74510795", "0.74059886", "0.7099884", "0.7079807", "0.6917014", "0.68960243", "0.68957806", "0.6796505", "0.67483217", "0.6740296", "0.66837454", "0.66416943", "0.66326", "0.6624022", "0.65148836", "0.65080565", "0.64689416", "0.64585537", "0.6440524", "0.64242446", "0.6410709", "0.63807267", "0.6350579", "0.6320388", "0.6309799", "0.6294033", "0.62715477", "0.6227774", "0.62054074" ]

[ "def test_edit_bucketlist(self):\n post_data = self.post_a_bucket()\n self.assertEqual(post_data.status_code, 201)\n result_of_put_method = self.client().put(\n '/bucketlists/1',\n headers=dict(Authorization='Bearer '\n + self.token()\n ),\n data={\n \"name\": \"The seasons will be, summer winter and autumn\"\n })\n self.assertEqual(result_of_put_method.status_code, 201)\n result_of_get_method = self.client().get('/bucketlists/1',\n headers=dict(Authorization='Bearer '\n + self.token())\n )\n self.assertIn('The seasons will b', str(result_of_get_method.data))", "def test_bucket_is_updated(self):\n with self.client:\n # Get an auth token\n token = self.get_user_token()\n # Create a Bucket\n response = self.client.post(\n '/bucketlists',\n data=json.dumps(dict(name='Travel')),\n headers=dict(Authorization='Bearer ' + token),\n content_type='application/json'\n )\n # Test Bucket creation\n data = json.loads(response.data.decode())\n self.assertEqual(response.status_code, 201)\n self.assertTrue(data['status'], 'success')\n self.assertTrue(data['name'], 'Travel')\n # Update the bucket name\n res = self.client.put(\n '/bucketlists/1',\n headers=dict(Authorization='Bearer ' + token),\n data=json.dumps(dict(name='Adventure')),\n content_type='application/json'\n )\n data = json.loads(res.data.decode())\n self.assertEqual(res.status_code, 201)\n self.assertTrue(res.content_type == 'application/json')\n self.assertTrue(data['status'] == 'success')\n self.assertTrue(data['name'] == 'Adventure')\n self.assertEqual(data['id'], 1)", "def test_api_edit_bucketlist(self):\n res_post = self.client().post('/bucketlist', data={'name': 'Wake up, Eat, Code, Sleep & Repeat'})\n self.assertEqual(res_post.status_code, 201)\n res_post_in_json = json.loads(res_post.data.decode('UTF-8').replace(\"'\", \"\\\"\"))\n id = res_post_in_json['id']\n res_put = self.client().put(\n f'bucketlist/{id}',\n data={\n 'name': \"Don't forget to exercise\"\n }\n )\n self.assertEqual(res_put.status_code, 200)\n res = self.client().get(f'/bucketlist/{id}')\n self.assertIn(\"exercise\", str(res.data))", "def test_modify_item_successfully(self):\n self.client.post('/buckets',\n content_type='application/json',\n data=self.bucket, headers=self.header)\n self.client.post('/buckets/1/items',\n content_type='application/json',\n data=self.item,\n headers=self.header)\n response = self.client.put('/buckets/1/items/1',\n content_type='application/json',\n data=self.item_edit,\n headers=self.header)\n self.assertEquals(response.status_code, 200)\n self.assertIn('Item successfully updated',\n response.data.decode())", "def test_update_busketlistitem_by_id(self):\n resp = self.client.post('/bucketlists',\n data=json.dumps(self.bucketlist),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n resp_item = self.client.post('/bucketlistitems/1/items',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n update_item = self.client.put('/bucketlistitems/1/items/1',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs and museums too.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(update_item.status_code, 201)", "def test_update_bucket(self):\n pass", "def test_put_item_wrong_id(self):\r\n data = {\"name\": \"bucketlist item name\", \"completed\": \"true\"}\r\n email = \"[email protected]\"\r\n _pword = \"test\"\r\n user = User.query.filter_by(email=email).first()\r\n bucketlist = BucketList.query.filter_by(user_id=user.id, name=\"test bucketlist\").first()\r\n item = BucketListItem.query.filter_by(bucketlist_id=bucketlist.id, id=0).first()\r\n self.assertFalse(item)\r\n\r\n response = self.put_bucketlist_item(email, _pword, bucketlist.id, 0, data)\r\n result = json.loads(response.data.decode('utf-8'))\r\n self.assertEqual(response.status, '404 NOT FOUND')\r\n self.assertEqual(\r\n result['message'],\r\n 'Bucketlist Item with ID {} not found in the database. You have requested this URI '\\\r\n '[/api/v1/bucketlist/1/items/0] but did you mean /api/v1/bucketlist/<int:bucketlist_id>/items/'\\\r\n ' or /api/v1/bucketlist/<int:bucketlist_id> or /api/v1/bucketlist ?'.format(0)\r\n )", "def test_add_item_at_using_put(self):\n pass", "def taco_test_put_update(self):\n body = '{ \"id\": 400, \"name\": \"item4\", \"content\": \"after test update\" }'\n env = self.get_env('PUT', '/item/4', body=body)\n webapi_start(env, lambda status, response_headers: self.assertEqual(status, '204'))", "def test_add_bucketlist_items(self):\r\n email = \"[email protected]\"\r\n _pword = \"test\"\r\n user = User.query.filter_by(email=email).first()\r\n bucketlist = BucketList.query.filter_by(user_id=user.id, name=\"test bucketlist\").first()\r\n item_no = BucketListItem.query.filter_by(bucketlist_id=bucketlist.id).count()\r\n response = self.add_bucketlist_item(email, _pword, bucketlist.id, \"bucketlist item name\")\r\n result = json.loads(response.data.decode('utf-8'))\r\n self.assertEqual(response.status, '201 CREATED')\r\n self.assertEqual(result['message'], 'Bucket list item added')\r\n new_item_no = BucketListItem.query.filter_by(bucketlist_id=bucketlist.id).count()\r\n self.assertLess(item_no, new_item_no)", "def test_update_item_good(test_client, item):\n\n response = test_client.put(GOOD_ITEM_URL,\n data=json.dumps(item),\n content_type='application/json')\n\n data = json.loads(response.get_data())\n\n assert response.status_code == 200\n assert data['item']['name'] == item['name']\n assert data['item']['value'] == item['value']", "def put_bucketlist_item(self, email, password, bucketlist_id, item_id, data):\r\n headers = self.authentication_headers(email=email, password=password)\r\n return self.client.put(\r\n '/api/v1/bucketlist/{}/items/{}'.format(bucketlist_id, item_id),\r\n content_type=\"application/json\",\r\n data=json.dumps(data),\r\n headers=headers,\r\n follow_redirects=True\r\n )", "def test_update_item_using_post(self):\n pass", "def test_app_can_update_a_list(self):\n self.ne=json.dumps({\"newName\":\"pants\"})\n list_update=self.client.put('/shoppinglists/trou',\n data=self.ne,\n headers={\n 'Content-Type':'application/json',\n 'x-access-token':self.tok})\n self.assertIn(\"list doesnt exist\",str(list_update.data)) \n self.assertEqual(list_update.status_code,200)", "def test_id_of_bucket_to_be_edited_is_invalid(self):\n with self.client:\n # Get an auth token\n token = self.get_user_token()\n # Update the bucket name\n res = self.client.put(\n '/bucketlists/bucketid',\n headers=dict(Authorization='Bearer ' + token),\n data=json.dumps(dict(name='Adventure')),\n content_type='application/json'\n )\n data = json.loads(res.data.decode())\n self.assertEqual(res.status_code, 400)\n self.assertTrue(res.content_type == 'application/json')\n self.assertTrue(data['status'] == 'failed')\n self.assertTrue(data['message'] == 'Please provide a valid Bucket Id')", "def test_create_bucketlist_item(self):\n resp = self.client.post('/bucketlists',\n data=json.dumps(self.bucketlist),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n response = self.client.get(\n \"/bucketlists/1\", headers={\n \"Authorization\": self.token})\n self.assertEqual(response.status_code, 200)\n resp_item = self.client.post('/bucketlistitems/1/items',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n result = json.loads(resp_item.data)\n self.assertEqual(result[\"message\"],\n \"Bucket list item added successfully.\")\n self.assertEqual(resp.status_code, 201)", "def taco_test_put_new(self):\n body = '{ \"id\": 400, \"name\": \"item_new\", \"content\": \"after test update\" }'\n env = self.get_env('PUT', '/item/4', body=body)\n webapi_start(env, lambda status, response_headers: self.assertEqual(status, '204'))", "def test_id_of_bucket_to_be_edited_does_not_exist(self):\n with self.client:\n # Get an auth token\n token = self.get_user_token()\n # Update the bucket name\n res = self.client.put(\n '/bucketlists/1',\n headers=dict(Authorization='Bearer ' + token),\n data=json.dumps(dict(name='Adventure')),\n content_type='application/json'\n )\n data = json.loads(res.data.decode())\n self.assertEqual(res.status_code, 404)\n self.assertTrue(res.content_type == 'application/json')\n self.assertTrue(data['status'] == 'failed')\n self.assertTrue(data['message'] == 'The Bucket with Id 1 does not exist')", "def test_patch_bucket(self):\n pass", "def put(self, user, id):\n # parse request data\n if 'name' not in self.request.form:\n return \"Bucketlist not Update\", 202\n\n bucketlist_name = self.request.form['name']\n\n # validate bucketlist\n if not bucketlist_name:\n return \"Name cannot be empty\", 401\n\n # search for the bucketlist_id\n bucketlist = Bucketlist.query.filter_by(\n id=id, created_by=user.email).first()\n\n # return 400 if bucketlist non exixtant or not belongs to this user\n if bucketlist is None:\n return 'Bucketlist not found', 202\n\n # Update bucketlist and save changes\n bucketlist.name = bucketlist_name\n bucketlist.save()\n\n return \"Successfully updated bucketlist\", 201", "def test_shelflistitem_putpatch_requires_auth(api_settings,\n assemble_custom_shelflist,\n get_shelflist_urls, api_client):\n test_lcode, test_id = '1test', 99999999\n _, _, trecs = assemble_custom_shelflist(test_lcode, [(test_id, {})])\n url = '{}{}'.format(get_shelflist_urls(trecs)[test_lcode], test_id)\n before = api_client.get(url)\n put_resp = api_client.put(url, {})\n patch_resp = api_client.patch(url, {})\n after = api_client.get(url) \n assert put_resp.status_code == 403\n assert patch_resp.status_code == 403\n assert before.data == after.data", "def test_put(self):\n url, port = self.server.address\n\n #couple of basic POSTs\n r = self.client.get(\"http://{0}:{1}/\".format(url, port))\n self.assertEqual(200, r.status_code)\n r = self.client.get(\"http://{0}:{1}\".format(url, port))\n self.assertEqual(200, r.status_code)\n r = self.client.get(\"http://{0}:{1}/200\".format(url, port))\n self.assertEqual(200, r.status_code)\n r = self.client.get(\"http://{0}:{1}/400\".format(url, port))\n self.assertEqual(400, r.status_code)\n\n r = self.client.put(\"http://{0}:{1}/400?foo=bar\".format(url, port))\n self.assertEqual(400, r.status_code)", "def _put(self, *args, **kwargs):\n return self._request('put', *args, **kwargs)", "def test_putorganizations_item(self):\n pass", "def test_delete_bucketlist_item(self):\n self.register_user()\n result = self.login_user()\n access_token = json.loads(result.data.decode())['access_token']\n\n # create a bucketlist by making a POST request\n res = self.client().post(\n '/api/v1/bucketlists/',\n headers=dict(Authorization=\"Bearer \" + access_token),\n data=self.bucketlist)\n self.assertEqual(res.status_code, 201)\n # get the json with the bucketlist\n results = json.loads(res.data.decode())\n\n # create a bucketlist item by making a POST request and add it to the created bucketlist\n res = self.client().post(\n '/api/v1/bucketlists/{}/items/'.format(results['id']),\n headers=dict(Authorization=\"Bearer \" + access_token),\n data={\n \"name\": \"Eat fried crabs\"\n })\n self.assertEqual(res.status_code, 201)\n # get the json containing the created bucketlist item\n res_item = json.loads(res.data.decode())\n\n # delete the bucketlist item we just created\n res = self.client().delete(\n '/api/v1/bucketlists/{}/items/{}'.format(results['id'], res_item['id']),\n headers=dict(Authorization=\"Bearer \" + access_token), )\n self.assertEqual(res.status_code, 200)\n\n # Test to see if it exists, should return a 404\n result = self.client().get(\n '/api/v1/bucketlists/{}/items/1'.format(results['id']),\n headers=dict(Authorization=\"Bearer \" + access_token))\n self.assertEqual(result.status_code, 404)", "def update_bucketlist():\n pass", "def test_security_on_put(self):\n # test the update url\n product = Product.objects.all()[0]\n url = '/product/xml/%s/' % product.item_number\n response = self.client.put(url,{'description':'my new description'})\n self.failUnlessEqual(response.status_code, 401)", "def test_vault_update_vault_item(self):\n pass", "def put(handler, *args, **kwargs):\n bucket_id = args[0]\n user_id = args[1]\n content = tornado.escape.json_decode(handler.request.body)\n BucketClasss = type(\"Bucket_%s\" % (bucket_id), (Bucket,), {})\n bucket = yield BucketClasss.get(user_id)\n if not bucket:\n bucket = BucketClasss()\n bucket.pkey = user_id \n if bucket_id == \"userData\":\n save_ver = int(content.get(\"data\", {}).get(\"saveVer\",0))\n current_ver = int(bucket.data.get(\"data\", {}).get(\"saveVer\",0))\n if save_ver < current_ver:\n raise Return((405, None))\n bucket.data = content \n yield bucket.put()\n raise Return((204, None))", "def test_put_method(self):\n self.getPage('/blah', method='PUT')\n self.assertStatus('200 OK')\n self.assertHeader('Content-Type', 'application/json')\n self.assertBody('{\"mystring\": \"blah\"}')" ]

[ "0.8058875", "0.80090237", "0.7962996", "0.7944334", "0.7826577", "0.7747739", "0.7705827", "0.74234086", "0.7353868", "0.72529393", "0.7214844", "0.72071826", "0.7201491", "0.7160625", "0.71453685", "0.7111688", "0.71060103", "0.70663935", "0.69522905", "0.69248813", "0.6919276", "0.69109577", "0.69079494", "0.6896508", "0.68850464", "0.68756735", "0.6859558", "0.6834577", "0.68279994", "0.6807831" ]

[ "def test_id_of_bucket_to_be_edited_is_invalid(self):\n with self.client:\n # Get an auth token\n token = self.get_user_token()\n # Update the bucket name\n res = self.client.put(\n '/bucketlists/bucketid',\n headers=dict(Authorization='Bearer ' + token),\n data=json.dumps(dict(name='Adventure')),\n content_type='application/json'\n )\n data = json.loads(res.data.decode())\n self.assertEqual(res.status_code, 400)\n self.assertTrue(res.content_type == 'application/json')\n self.assertTrue(data['status'] == 'failed')\n self.assertTrue(data['message'] == 'Please provide a valid Bucket Id')", "def test_update_item_incorrect_id(test_client, item):\n\n response = test_client.put(BAD_ITEM_URL,\n data=json.dumps(item),\n content_type='application/json')\n\n data = json.loads(response.get_data())\n\n assert response.status_code == 404\n assert data['error'] == app.NOT_FOUND", "def test_id_of_bucket_to_be_edited_does_not_exist(self):\n with self.client:\n # Get an auth token\n token = self.get_user_token()\n # Update the bucket name\n res = self.client.put(\n '/bucketlists/1',\n headers=dict(Authorization='Bearer ' + token),\n data=json.dumps(dict(name='Adventure')),\n content_type='application/json'\n )\n data = json.loads(res.data.decode())\n self.assertEqual(res.status_code, 404)\n self.assertTrue(res.content_type == 'application/json')\n self.assertTrue(data['status'] == 'failed')\n self.assertTrue(data['message'] == 'The Bucket with Id 1 does not exist')", "def taco_test_put_error_requires_id(self):\n body = '{ \"id\": 400, \"name\": \"item_new\", \"content\": \"after test update\" }'\n env = self.get_env('PUT', '/item', body=body)\n webapi_start(env, lambda status, response_headers: self.assertEqual(status, '501'))", "def test_update_busketlistitem_by_id(self):\n resp = self.client.post('/bucketlists',\n data=json.dumps(self.bucketlist),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n resp_item = self.client.post('/bucketlistitems/1/items',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n update_item = self.client.put('/bucketlistitems/1/items/1',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs and museums too.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(update_item.status_code, 201)", "def test_api_edit_bucketlist(self):\n res_post = self.client().post('/bucketlist', data={'name': 'Wake up, Eat, Code, Sleep & Repeat'})\n self.assertEqual(res_post.status_code, 201)\n res_post_in_json = json.loads(res_post.data.decode('UTF-8').replace(\"'\", \"\\\"\"))\n id = res_post_in_json['id']\n res_put = self.client().put(\n f'bucketlist/{id}',\n data={\n 'name': \"Don't forget to exercise\"\n }\n )\n self.assertEqual(res_put.status_code, 200)\n res = self.client().get(f'/bucketlist/{id}')\n self.assertIn(\"exercise\", str(res.data))", "def test_delete_item_wrong_id(self):\r\n email = \"[email protected]\"\r\n _pword = \"test\"\r\n user = User.query.filter_by(email=email).first()\r\n bucketlist = BucketList.query.filter_by(user_id=user.id, name=\"test bucketlist\").first()\r\n item = BucketListItem.query.filter_by(bucketlist_id=bucketlist.id, id=0).first()\r\n self.assertFalse(item)\r\n\r\n response = self.delete_bucketlist_item(email, _pword, bucketlist.id, 0)\r\n result = json.loads(response.data.decode('utf-8'))\r\n self.assertEqual(response.status, '404 NOT FOUND')\r\n self.assertEqual(\r\n result['message'],\r\n 'Bucketlist Item with ID {} not found in the database. You have requested this URI '\\\r\n '[/api/v1/bucketlist/1/items/0] but did you mean /api/v1/bucketlist/<int:bucketlist_id>/items/'\\\r\n ' or /api/v1/bucketlist/<int:bucketlist_id> or /api/v1/bucketlist ?'.format(0)\r\n )", "def test_put_bucketlist_item(self):\r\n data = {\"name\": \"bucketlist item name\", \"completed\": \"true\"}\r\n email = \"[email protected]\"\r\n _pword = \"test\"\r\n user = User.query.filter_by(email=email).first()\r\n bucketlist = BucketList.query.filter_by(user_id=user.id, name=\"test bucketlist\").first()\r\n item = BucketListItem.query.filter_by(bucketlist_id=bucketlist.id, id=1).first()\r\n self.assertNotEqual(item.name, \"bucketlist item name\")\r\n self.assertFalse(item.completed)\r\n\r\n response = self.put_bucketlist_item(email, _pword, bucketlist.id, 1, data)\r\n result = json.loads(response.data.decode('utf-8'))\r\n item2 = BucketListItem.query.filter_by(bucketlist_id=bucketlist.id, id=1).first()\r\n self.assertEqual(response.status, '201 CREATED')\r\n self.assertEqual(item2.name, \"bucketlist item name\")\r\n self.assertTrue(item2.completed)", "def test_modify_item_successfully(self):\n self.client.post('/buckets',\n content_type='application/json',\n data=self.bucket, headers=self.header)\n self.client.post('/buckets/1/items',\n content_type='application/json',\n data=self.item,\n headers=self.header)\n response = self.client.put('/buckets/1/items/1',\n content_type='application/json',\n data=self.item_edit,\n headers=self.header)\n self.assertEquals(response.status_code, 200)\n self.assertIn('Item successfully updated',\n response.data.decode())", "def taco_test_put_update(self):\n body = '{ \"id\": 400, \"name\": \"item4\", \"content\": \"after test update\" }'\n env = self.get_env('PUT', '/item/4', body=body)\n webapi_start(env, lambda status, response_headers: self.assertEqual(status, '204'))", "def test_update_bucket(self):\n pass", "def test_bucket_is_updated(self):\n with self.client:\n # Get an auth token\n token = self.get_user_token()\n # Create a Bucket\n response = self.client.post(\n '/bucketlists',\n data=json.dumps(dict(name='Travel')),\n headers=dict(Authorization='Bearer ' + token),\n content_type='application/json'\n )\n # Test Bucket creation\n data = json.loads(response.data.decode())\n self.assertEqual(response.status_code, 201)\n self.assertTrue(data['status'], 'success')\n self.assertTrue(data['name'], 'Travel')\n # Update the bucket name\n res = self.client.put(\n '/bucketlists/1',\n headers=dict(Authorization='Bearer ' + token),\n data=json.dumps(dict(name='Adventure')),\n content_type='application/json'\n )\n data = json.loads(res.data.decode())\n self.assertEqual(res.status_code, 201)\n self.assertTrue(res.content_type == 'application/json')\n self.assertTrue(data['status'] == 'success')\n self.assertTrue(data['name'] == 'Adventure')\n self.assertEqual(data['id'], 1)", "def test_fail_repeated_buckelist_item(self):\r\n user = User.query.filter_by(email=\"[email protected]\").first()\r\n bucketlist = BucketList.query.filter_by(user_id=user.id, name=\"test bucketlist\").first()\r\n item_no = BucketListItem.query.filter_by(bucketlist_id=bucketlist.id).count()\r\n response = self.add_bucketlist_item(\"[email protected]\", \"test\", bucketlist.id, \"test item\")\r\n result = json.loads(response.data.decode('utf-8'))\r\n self.assertEqual(response.status, '409 CONFLICT')\r\n self.assertEqual(result['message'], 'Bucketlist Item Exists')\r\n new_item_no = BucketListItem.query.filter_by(bucketlist_id=bucketlist.id).count()\r\n self.assertEqual(item_no, new_item_no)", "def test_edit_bucketlist(self):\n post_data = self.post_a_bucket()\n self.assertEqual(post_data.status_code, 201)\n result_of_put_method = self.client().put(\n '/bucketlists/1',\n headers=dict(Authorization='Bearer '\n + self.token()\n ),\n data={\n \"name\": \"The seasons will be, summer winter and autumn\"\n })\n self.assertEqual(result_of_put_method.status_code, 201)\n result_of_get_method = self.client().get('/bucketlists/1',\n headers=dict(Authorization='Bearer '\n + self.token())\n )\n self.assertIn('The seasons will b', str(result_of_get_method.data))", "def test_update_telegram_id_fail(self):\n url = reverse('telegram_id')\n response = self.second_client.put(url, {}, content_type='application/json')\n self.assertEqual(400, response.status_code)", "def test_app_can_update_a_list(self):\n self.ne=json.dumps({\"newName\":\"pants\"})\n list_update=self.client.put('/shoppinglists/trou',\n data=self.ne,\n headers={\n 'Content-Type':'application/json',\n 'x-access-token':self.tok})\n self.assertIn(\"list doesnt exist\",str(list_update.data)) \n self.assertEqual(list_update.status_code,200)", "def test_update_item_incorrect_value_type(test_client, item_with_bad_value):\n\n response = test_client.put(GOOD_ITEM_URL,\n data=json.dumps(item_with_bad_value),\n content_type='application/json')\n\n data = json.loads(response.get_data())\n\n assert response.status_code == 400\n assert data['error'] == app.BAD_REQUEST", "def test_wrong_admin_put(self):\n\n with self.client:\n token = self.get_token()\n id = 4\n response = self.client.put('api/v1/meals/{}'.format(id),\n data=json.dumps(dict(\n meal_name=\"chips\",\n price=15000\n )),\n content_type='application/json',\n headers=({\"token\": token}))\n data = json.loads(response.data.decode())\n self.assertEqual(data.get('message'), \"Meal not found\")\n self.assertEqual(response.status_code, 400)", "def test_update_car_invalid_id():\n car_data = {\n \"id\": 1,\n \"make\": \"BMW\",\n \"model\": \"3 Series\",\n \"year\": 1998,\n \"vin\": \"JH4CU2F60AC794232\",\n }\n response = client.put(\"/11111\", data=car_data)\n assert response.status_code == STATUS_NOT_FOUND", "def taco_test_put_new(self):\n body = '{ \"id\": 400, \"name\": \"item_new\", \"content\": \"after test update\" }'\n env = self.get_env('PUT', '/item/4', body=body)\n webapi_start(env, lambda status, response_headers: self.assertEqual(status, '204'))", "def test_update_item_good(test_client, item):\n\n response = test_client.put(GOOD_ITEM_URL,\n data=json.dumps(item),\n content_type='application/json')\n\n data = json.loads(response.get_data())\n\n assert response.status_code == 200\n assert data['item']['name'] == item['name']\n assert data['item']['value'] == item['value']", "def test_security_on_put(self):\n # test the update url\n product = Product.objects.all()[0]\n url = '/product/xml/%s/' % product.item_number\n response = self.client.put(url,{'description':'my new description'})\n self.failUnlessEqual(response.status_code, 401)", "def test_add_item_at_using_put(self):\n pass", "def test_update_item_using_post(self):\n pass", "def test_update_item_incorrect_content_type(test_client, item):\n\n response = test_client.put(GOOD_ITEM_URL,\n data=json.dumps(item))\n\n data = json.loads(response.get_data())\n\n assert response.status_code == 400\n assert data['error'] == app.BAD_REQUEST", "def test_shelflistitem_putpatch_requires_auth(api_settings,\n assemble_custom_shelflist,\n get_shelflist_urls, api_client):\n test_lcode, test_id = '1test', 99999999\n _, _, trecs = assemble_custom_shelflist(test_lcode, [(test_id, {})])\n url = '{}{}'.format(get_shelflist_urls(trecs)[test_lcode], test_id)\n before = api_client.get(url)\n put_resp = api_client.put(url, {})\n patch_resp = api_client.patch(url, {})\n after = api_client.get(url) \n assert put_resp.status_code == 403\n assert patch_resp.status_code == 403\n assert before.data == after.data", "def test_vault_update_vault_item(self):\n pass", "def test_edit_non_existing_item(self):\n response = self.client.put('/api/v1/category/200',\n data=json.dumps(category[3]),\n content_type='application/json',\n headers=self.admin_headers)\n self.assertEqual(response.status_code, 404)\n self.assertIn('category with id 200 does not exist',\n str(response.data))", "def test_put_wrong_data(self):\n new_data = {\"fromMonth\": \"another\"}\n response = self.client.put(self.url + str(self.current_data[-1]['id']) + '/', data=json.dumps(new_data),\n content_type='application/json')\n self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST, msg=response.content.decode())", "def test_put_db_fail(self):\n test_data = {\n 'first_name': 'new_first_name',\n 'last_name': 'new_last_name'\n }\n with mock.patch('user_profile.models.UserProfile.update') as update:\n update.return_value = False\n response = self.client.put(self.url, json.dumps(test_data), content_type='application/json')\n self.assertEquals(response.status_code, 400)" ]

[ "0.8020481", "0.7893578", "0.78514856", "0.7821233", "0.769216", "0.74274623", "0.74184465", "0.74172276", "0.7320262", "0.7253771", "0.7236808", "0.7163079", "0.7149734", "0.7134282", "0.7058692", "0.701769", "0.69915277", "0.6915926", "0.691373", "0.6895343", "0.68850976", "0.6878846", "0.6847633", "0.68400025", "0.679686", "0.6796606", "0.6767939", "0.6750086", "0.67410725", "0.6735798" ]

[ "def test_delete_bucketlist_item(self):\n self.register_user()\n result = self.login_user()\n access_token = json.loads(result.data.decode())['access_token']\n\n # create a bucketlist by making a POST request\n res = self.client().post(\n '/api/v1/bucketlists/',\n headers=dict(Authorization=\"Bearer \" + access_token),\n data=self.bucketlist)\n self.assertEqual(res.status_code, 201)\n # get the json with the bucketlist\n results = json.loads(res.data.decode())\n\n # create a bucketlist item by making a POST request and add it to the created bucketlist\n res = self.client().post(\n '/api/v1/bucketlists/{}/items/'.format(results['id']),\n headers=dict(Authorization=\"Bearer \" + access_token),\n data={\n \"name\": \"Eat fried crabs\"\n })\n self.assertEqual(res.status_code, 201)\n # get the json containing the created bucketlist item\n res_item = json.loads(res.data.decode())\n\n # delete the bucketlist item we just created\n res = self.client().delete(\n '/api/v1/bucketlists/{}/items/{}'.format(results['id'], res_item['id']),\n headers=dict(Authorization=\"Bearer \" + access_token), )\n self.assertEqual(res.status_code, 200)\n\n # Test to see if it exists, should return a 404\n result = self.client().get(\n '/api/v1/bucketlists/{}/items/1'.format(results['id']),\n headers=dict(Authorization=\"Bearer \" + access_token))\n self.assertEqual(result.status_code, 404)", "def test_delete_bucketlistitem_by_id(self):\n resp = self.client.post('/bucketlists',\n data=json.dumps(self.bucketlist),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n resp_item = self.client.post('/bucketlistitems/1/items',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n delete_item = self.client.delete('/bucketlistitems/1/items/1',\n headers={\n \"Authorization\": self.token\n })\n self.assertEqual(delete_item.status_code, 204)", "def test_delete_bucketlist(self):\n post_data = self.post_a_bucket()\n self.assertEqual(post_data.status_code, 201)\n result_of_delete_method = self.client().delete('/bucketlists/1',\n headers=dict(Authorization='Bearer '\n + self.token())\n )\n self.assertEqual(result_of_delete_method.status_code, 200)\n response_after_removal = self.client().get('/bucketlists/1',\n headers=dict(Authorization='Bearer '\n + self.token())\n )\n self.assertEqual(response_after_removal.status_code, 400)", "def test_api_delete_bucketlist(self):\n\n res_post = self.client().post('/bucketlist', data={'name': \"Don't forget to exercise\"})\n self.assertEqual(res_post.status_code, 201)\n res_post_in_json = json.loads(res_post.data.decode('UTF-8'))\n id = res_post_in_json['id']\n res_delete = self.client().delete(f\"/bucketlist/{id}\")\n self.assertEqual(res_delete.status_code, 200)\n\n # should return 404 after delete the data\n res = self.client().get(f'/bucketlist/{id}')\n self.assertEqual(res.status_code, 404)", "def test_single_bucketlist_item_delete_with_no_auth_header(self):\n self.register_user()\n result = self.login_user()\n access_token = json.loads(result.data.decode())['access_token']\n\n res = self.client().post(\n '/api/v1/bucketlists/',\n headers=dict(Authorization=\"Bearer \" + access_token),\n data={'name': 'Visit the Grand Canyon!'})\n self.assertEqual(res.status_code, 201)\n # get the bucketlist in json\n results = json.loads(res.data.decode())\n\n # create a bucketlist item by making a POST request and add it to the created bucketlist\n res = self.client().post(\n '/api/v1/bucketlists/{}/items/'.format(results['id']),\n headers=dict(Authorization=\"Bearer \" + access_token),\n data={\n \"name\": \"Eat fried crabs\"\n })\n self.assertEqual(res.status_code, 201)\n # get the json containing the created bucketlist item\n res_item = json.loads(res.data.decode())\n\n # delete the bucketlist item we just created\n res = self.client().delete(\n '/api/v1/bucketlists/{}/items/{}'.format(results['id'], res_item['id']),\n headers=dict(), )\n self.assertEqual(res.status_code, 401)\n self.assertIn('Header with key Authorization missing.', str(res.data))", "def test_single_bucketlist_item_delete_with_empty_token(self):\n self.register_user()\n result = self.login_user()\n access_token = json.loads(result.data.decode())['access_token']\n\n res = self.client().post(\n '/api/v1/bucketlists/',\n headers=dict(Authorization=\"Bearer \" + access_token),\n data=self.bucketlist)\n\n # assert that the bucketlist is created\n self.assertEqual(res.status_code, 201)\n # get the response data in json format\n results = json.loads(res.data.decode())\n\n # create a bucketlist item by making a POST request and add it to the created bucketlist\n res = self.client().post(\n '/api/v1/bucketlists/{}/items/'.format(results['id']),\n headers=dict(Authorization=\"Bearer \" + access_token),\n data={\n \"name\": \"Eat fried crabs\"\n })\n self.assertEqual(res.status_code, 201)\n # get the json containing the created bucketlist item\n res_item = json.loads(res.data.decode())\n\n # delete the bucketlist item we just created\n res = self.client().delete(\n '/api/v1/bucketlists/{}/items/{}'.format(results['id'], res_item['id']),\n headers=dict(Authorization=\"\"), )\n self.assertEqual(res.status_code, 401)\n self.assertIn('Token not provided in the header with key Authorization.', str(res.data))", "def test_single_bucketlist_item_delete_with_invalid_token(self):\n self.register_user()\n result = self.login_user()\n access_token = json.loads(result.data.decode())['access_token']\n\n res = self.client().post(\n '/api/v1/bucketlists/',\n headers=dict(Authorization=\"Bearer \" + access_token),\n data=self.bucketlist)\n\n # assert that the bucketlist is created\n self.assertEqual(res.status_code, 201)\n # get the response data in json format\n results = json.loads(res.data.decode())\n\n # create a bucketlist item by making a POST request and add it to the created bucketlist\n res = self.client().post(\n '/api/v1/bucketlists/{}/items/'.format(results['id']),\n headers=dict(Authorization=\"Bearer \" + access_token),\n data={\n \"name\": \"Eat fried crabs\"\n })\n self.assertEqual(res.status_code, 201)\n # get the json containing the created bucketlist item\n res_item = json.loads(res.data.decode())\n\n # delete the bucketlist item we just created\n res = self.client().delete(\n '/api/v1/bucketlists/{}/items/{}'.format(results['id'], res_item['id']),\n headers=dict(Authorization=access_token), )\n self.assertEqual(res.status_code, 401)\n self.assertIn('Invalid token format.', str(res.data))", "def test_bucket_is_deleted(self):\n with self.client:\n # Get an auth token\n token = self.get_user_token()\n response = self.client.post(\n '/bucketlists',\n data=json.dumps(dict(name='Travel')),\n headers=dict(Authorization='Bearer ' + token),\n content_type='application/json'\n )\n # Test Bucket creation\n data = json.loads(response.data.decode())\n self.assertEqual(response.status_code, 201)\n self.assertTrue(data['status'], 'success')\n self.assertTrue(data['name'], 'Travel')\n # Delete the created Bucket\n res = self.client.delete(\n '/bucketlists/1',\n headers=dict(Authorization='Bearer ' + token)\n )\n data = json.loads(res.data.decode())\n self.assertEqual(res.status_code, 200)\n self.assertTrue(data['status'] == 'success')\n self.assertTrue(data['message'] == 'Bucket Deleted successfully')\n self.assertTrue(res.content_type == 'application/json')", "def test_delete_item_wrong_id(self):\r\n email = \"[email protected]\"\r\n _pword = \"test\"\r\n user = User.query.filter_by(email=email).first()\r\n bucketlist = BucketList.query.filter_by(user_id=user.id, name=\"test bucketlist\").first()\r\n item = BucketListItem.query.filter_by(bucketlist_id=bucketlist.id, id=0).first()\r\n self.assertFalse(item)\r\n\r\n response = self.delete_bucketlist_item(email, _pword, bucketlist.id, 0)\r\n result = json.loads(response.data.decode('utf-8'))\r\n self.assertEqual(response.status, '404 NOT FOUND')\r\n self.assertEqual(\r\n result['message'],\r\n 'Bucketlist Item with ID {} not found in the database. You have requested this URI '\\\r\n '[/api/v1/bucketlist/1/items/0] but did you mean /api/v1/bucketlist/<int:bucketlist_id>/items/'\\\r\n ' or /api/v1/bucketlist/<int:bucketlist_id> or /api/v1/bucketlist ?'.format(0)\r\n )", "def test_delete_item_successfully(self):\n self.client.post('/buckets',\n content_type='application/json',\n data=self.bucket, headers=self.header)\n self.client.post('/buckets/1/items',\n content_type='application/json',\n data=self.item, headers=self.header)\n response = self.client.delete('/buckets/1/items/1',\n headers=self.header)\n self.assertEquals(response.status_code, 200)\n self.assertIn('Item successfully deleted', response.data.decode())", "def test_delete_item(test_client):\n\n response = test_client.delete(GOOD_ITEM_URL)\n\n assert response.status_code == 204\n assert response.get_data() == b''", "def test_deletion_handles_no_bucket_found_by_id(self):\n with self.client:\n response = self.client.delete(\n '/bucketlists/1',\n headers=dict(Authorization='Bearer ' + self.get_user_token())\n )\n data = json.loads(response.data.decode())\n self.assertEqual(response.status_code, 404)\n self.assertTrue(data['status'] == 'failed')\n self.assertTrue(data['message'] == 'Bucket resource cannot be found')\n self.assertTrue(response.content_type == 'application/json')", "def test_request_for_deleting_bucket_has_integer_id(self):\n with self.client:\n response = self.client.delete(\n '/bucketlists/dsfgsdsg',\n headers=dict(Authorization='Bearer ' + self.get_user_token())\n )\n data = json.loads(response.data.decode())\n self.assertEqual(response.status_code, 400)\n self.assertTrue(data['status'] == 'failed')\n self.assertTrue(data['message'] == 'Please provide a valid Bucket Id')", "def test_delete(self):\n responses.add(\n responses.Response(\n method='DELETE',\n url='https://connection.keboola.com/v2/storage/buckets/1?force=False&async=False',\n json={}\n )\n )\n bucket_id = '1'\n deleted_detail = self.buckets.delete(bucket_id, asynchronous=False)\n assert deleted_detail is None", "def delete_bucketlist():\n pass", "def test_delete_item_using_delete(self):\n pass", "def test_delete_bucket(self):\n pass", "def test_delete_item_with_non_existing_bucket(self):\n self.client.post('/buckets',\n content_type='application/json',\n data=self.bucket, headers=self.header)\n self.client.post('/buckets/1/items',\n content_type='application/json',\n data=self.item, headers=self.header)\n response = self.client.delete('/buckets/2/items/1'\n , headers=self.header)\n self.assertEquals(response.status_code, 400)\n self.assertIn('Attempting to delete item on non existing bucket',\n response.data.decode())", "def delete_bucketlist_item(self, email, password, bucketlist_id, item_id):\r\n headers = self.authentication_headers(email=email, password=password)\r\n return self.client.delete(\r\n '/api/v1/bucketlist/{}/items/{}'.format(bucketlist_id, item_id),\r\n content_type=\"application/json\",\r\n headers=headers,\r\n follow_redirects=True\r\n )", "def delete(self, user, id):\n # Search for bucketlist\n print (id)\n bucketlist = Bucketlist.query.filter_by(\n id=id, created_by=user.email).first()\n\n # return 400 if bucketlist non exixtant or not belongs to this user\n if bucketlist is None:\n return 'Bucketlist not found', 202\n\n bucketlist.delete()\n\n return \"Successfully deleted bucketlist\", 200", "def test_vault_delete_vault_item(self):\n pass", "def test_delete_buckets(self):\n pass", "def __delitem__(self, key):\r\n self.client.delete(id=key, ignore=[404], **self.kwargs)", "def test_app_can_delete_list(self):\n delete_list=self.client.delete('/shoppinglists/nikes',\n headers={\n 'Content-Type':'application/json',\n 'x-access-token':self.tok})\n self.assertEqual(delete_list.status_code,200)", "def test_delitem(self):\n with self.assertRaises(QiitaDBNotImplementedError):\n del self.tester['1.SKM7.640188']", "def test_shoppingitem_deletion(self):\n # register and login a user\n self.app.post('/register', data=self.user_reg_details)\n self.app.post('/login', data=self.user_login_details)\n # create a shopping list\n self.shopping_class_obj.create_list(\n 'Christmass', '[email protected]')\n # create an item\n self.item_class_obj.add_item(\n 'Christmass', 'Bread', '[email protected]')\n # make a post request with the delete name\n res = self.app.post(\n '/delete-item', data={'list_name': 'Christmass', 'item_name': 'Bread'})\n self.assertEqual(res.status_code, 200)\n self.item_class_obj.delete_item(\n 'Bread', '[email protected]', 'Christmass')\n # check if delete was successful\n self.assertIn(\"Successfuly deleted item \", str(res.data))", "def test_shoppinglist_deletion(self):\n # register and login a user\n self.app.post('/register', data=self.user_reg_details)\n self.app.post('/login', data=self.user_login_details)\n # create a shopping list\n self.shopping_class_obj.create_list(\n 'Christmass', '[email protected]')\n # make a post request with the delete name\n res = self.app.post(\n '/delete-list', data={'list_name': 'Christmass'})\n self.assertEqual(res.status_code, 200)\n self.shopping_class_obj.delete_list(\n 'Christmass', '[email protected]')\n # check if delete was successful by looking for the deleted name\n self.assertIn(\"Christmass\", str(res.data))", "def test_delete(client):\n rv = delete(client, 'Michael')\n assert json.loads(rv.data.decode())['code'] == 0\n assert json.loads(rv.data.decode())['owner'] == 'Michael'", "def test_DELETE3(self):\n r = requests.delete(self.address + \"/cars/42\")\n self.assertEqual(r.status_code, 400)", "def test_delete_single(single_bucket): # pylint: disable=redefined-outer-name\n single_bucket.delete(\"key 1\")\n\n assert single_bucket.is_empty() is True" ]

[ "0.8505305", "0.83253217", "0.82858104", "0.8246607", "0.82087", "0.81654054", "0.8043401", "0.78209937", "0.77620775", "0.76105493", "0.7587545", "0.75202996", "0.7477461", "0.7458294", "0.73910975", "0.7342991", "0.73347974", "0.7244719", "0.7221748", "0.7206562", "0.7108436", "0.6908336", "0.68953", "0.6842576", "0.68179005", "0.67890906", "0.6782164", "0.6727874", "0.67037225", "0.6703348" ]

[ "def test_deletion_handles_no_bucket_found_by_id(self):\n with self.client:\n response = self.client.delete(\n '/bucketlists/1',\n headers=dict(Authorization='Bearer ' + self.get_user_token())\n )\n data = json.loads(response.data.decode())\n self.assertEqual(response.status_code, 404)\n self.assertTrue(data['status'] == 'failed')\n self.assertTrue(data['message'] == 'Bucket resource cannot be found')\n self.assertTrue(response.content_type == 'application/json')", "def test_request_for_deleting_bucket_has_integer_id(self):\n with self.client:\n response = self.client.delete(\n '/bucketlists/dsfgsdsg',\n headers=dict(Authorization='Bearer ' + self.get_user_token())\n )\n data = json.loads(response.data.decode())\n self.assertEqual(response.status_code, 400)\n self.assertTrue(data['status'] == 'failed')\n self.assertTrue(data['message'] == 'Please provide a valid Bucket Id')", "def test_delete_item_incorrect_id(test_client):\n\n response = test_client.delete(GOOD_ITEM_URL)\n\n data = json.loads(response.get_data())\n\n assert response.status_code == 404\n assert data['error'] == app.NOT_FOUND", "def test_api_delete_bucketlist(self):\n\n res_post = self.client().post('/bucketlist', data={'name': \"Don't forget to exercise\"})\n self.assertEqual(res_post.status_code, 201)\n res_post_in_json = json.loads(res_post.data.decode('UTF-8'))\n id = res_post_in_json['id']\n res_delete = self.client().delete(f\"/bucketlist/{id}\")\n self.assertEqual(res_delete.status_code, 200)\n\n # should return 404 after delete the data\n res = self.client().get(f'/bucketlist/{id}')\n self.assertEqual(res.status_code, 404)", "def test_delete_bucketlistitem_by_id(self):\n resp = self.client.post('/bucketlists',\n data=json.dumps(self.bucketlist),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n resp_item = self.client.post('/bucketlistitems/1/items',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n delete_item = self.client.delete('/bucketlistitems/1/items/1',\n headers={\n \"Authorization\": self.token\n })\n self.assertEqual(delete_item.status_code, 204)", "def test_delete_bucketlist_item(self):\r\n email = \"[email protected]\"\r\n _pword = \"test\"\r\n user = User.query.filter_by(email=email).first()\r\n bucketlist = BucketList.query.filter_by(user_id=user.id, name=\"test bucketlist\").first()\r\n item = BucketListItem.query.filter_by(bucketlist_id=bucketlist.id, id=1).first()\r\n self.assertTrue(item)\r\n\r\n response = self.delete_bucketlist_item(email, _pword, bucketlist.id, item.id)\r\n result = json.loads(response.data.decode('utf-8'))\r\n self.assertEqual(response.status, '200 OK')\r\n self.assertEqual(\r\n result['message'],\r\n 'Bucketlist Item with ID {} deleted'.format(item.id)\r\n )\r\n item = BucketListItem.query.filter_by(bucketlist_id=bucketlist.id, id=1).first()\r\n self.assertFalse(item)", "def test_single_bucketlist_item_delete_with_invalid_token(self):\n self.register_user()\n result = self.login_user()\n access_token = json.loads(result.data.decode())['access_token']\n\n res = self.client().post(\n '/api/v1/bucketlists/',\n headers=dict(Authorization=\"Bearer \" + access_token),\n data=self.bucketlist)\n\n # assert that the bucketlist is created\n self.assertEqual(res.status_code, 201)\n # get the response data in json format\n results = json.loads(res.data.decode())\n\n # create a bucketlist item by making a POST request and add it to the created bucketlist\n res = self.client().post(\n '/api/v1/bucketlists/{}/items/'.format(results['id']),\n headers=dict(Authorization=\"Bearer \" + access_token),\n data={\n \"name\": \"Eat fried crabs\"\n })\n self.assertEqual(res.status_code, 201)\n # get the json containing the created bucketlist item\n res_item = json.loads(res.data.decode())\n\n # delete the bucketlist item we just created\n res = self.client().delete(\n '/api/v1/bucketlists/{}/items/{}'.format(results['id'], res_item['id']),\n headers=dict(Authorization=access_token), )\n self.assertEqual(res.status_code, 401)\n self.assertIn('Invalid token format.', str(res.data))", "def test_delete_bucketlist_item(self):\n self.register_user()\n result = self.login_user()\n access_token = json.loads(result.data.decode())['access_token']\n\n # create a bucketlist by making a POST request\n res = self.client().post(\n '/api/v1/bucketlists/',\n headers=dict(Authorization=\"Bearer \" + access_token),\n data=self.bucketlist)\n self.assertEqual(res.status_code, 201)\n # get the json with the bucketlist\n results = json.loads(res.data.decode())\n\n # create a bucketlist item by making a POST request and add it to the created bucketlist\n res = self.client().post(\n '/api/v1/bucketlists/{}/items/'.format(results['id']),\n headers=dict(Authorization=\"Bearer \" + access_token),\n data={\n \"name\": \"Eat fried crabs\"\n })\n self.assertEqual(res.status_code, 201)\n # get the json containing the created bucketlist item\n res_item = json.loads(res.data.decode())\n\n # delete the bucketlist item we just created\n res = self.client().delete(\n '/api/v1/bucketlists/{}/items/{}'.format(results['id'], res_item['id']),\n headers=dict(Authorization=\"Bearer \" + access_token), )\n self.assertEqual(res.status_code, 200)\n\n # Test to see if it exists, should return a 404\n result = self.client().get(\n '/api/v1/bucketlists/{}/items/1'.format(results['id']),\n headers=dict(Authorization=\"Bearer \" + access_token))\n self.assertEqual(result.status_code, 404)", "def test_delete_item_with_non_existing_bucket(self):\n self.client.post('/buckets',\n content_type='application/json',\n data=self.bucket, headers=self.header)\n self.client.post('/buckets/1/items',\n content_type='application/json',\n data=self.item, headers=self.header)\n response = self.client.delete('/buckets/2/items/1'\n , headers=self.header)\n self.assertEquals(response.status_code, 400)\n self.assertIn('Attempting to delete item on non existing bucket',\n response.data.decode())", "def test_delete_data_wrong_id(self):\n # get current ids\n list_current = [item['id'] for item in self.current_data]\n self.assertNotIn(10, list_current)\n\n response = self.client.delete(self.url + '10/')\n self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST, msg=response.content.decode())", "def test_delete_car_invalid_id():\n response = client.delete(\"/11111\")\n assert response.status_code == STATUS_NOT_FOUND", "def test_put_item_wrong_id(self):\r\n data = {\"name\": \"bucketlist item name\", \"completed\": \"true\"}\r\n email = \"[email protected]\"\r\n _pword = \"test\"\r\n user = User.query.filter_by(email=email).first()\r\n bucketlist = BucketList.query.filter_by(user_id=user.id, name=\"test bucketlist\").first()\r\n item = BucketListItem.query.filter_by(bucketlist_id=bucketlist.id, id=0).first()\r\n self.assertFalse(item)\r\n\r\n response = self.put_bucketlist_item(email, _pword, bucketlist.id, 0, data)\r\n result = json.loads(response.data.decode('utf-8'))\r\n self.assertEqual(response.status, '404 NOT FOUND')\r\n self.assertEqual(\r\n result['message'],\r\n 'Bucketlist Item with ID {} not found in the database. You have requested this URI '\\\r\n '[/api/v1/bucketlist/1/items/0] but did you mean /api/v1/bucketlist/<int:bucketlist_id>/items/'\\\r\n ' or /api/v1/bucketlist/<int:bucketlist_id> or /api/v1/bucketlist ?'.format(0)\r\n )", "def test_AlgorithmsIdHandler_DELETE_MalformedRequest(self):\n searchedId='xyz' + ' ' + '1'\n response = self.testapp.delete('/algorithms/' + searchedId, expect_errors=True)\n self.assertEqual(400, response.status_int, msg='Wrong answer code')\n self.assertEqual('application/json', response.content_type)\n self.assertIn('Malformed Data', response.normal_body.decode(encoding='UTF-8'))", "def test_delete(self):\n responses.add(\n responses.Response(\n method='DELETE',\n url='https://connection.keboola.com/v2/storage/buckets/1?force=False&async=False',\n json={}\n )\n )\n bucket_id = '1'\n deleted_detail = self.buckets.delete(bucket_id, asynchronous=False)\n assert deleted_detail is None", "def test_delete_bucketlist(self):\n post_data = self.post_a_bucket()\n self.assertEqual(post_data.status_code, 201)\n result_of_delete_method = self.client().delete('/bucketlists/1',\n headers=dict(Authorization='Bearer '\n + self.token())\n )\n self.assertEqual(result_of_delete_method.status_code, 200)\n response_after_removal = self.client().get('/bucketlists/1',\n headers=dict(Authorization='Bearer '\n + self.token())\n )\n self.assertEqual(response_after_removal.status_code, 400)", "def test_single_bucketlist_item_delete_with_no_auth_header(self):\n self.register_user()\n result = self.login_user()\n access_token = json.loads(result.data.decode())['access_token']\n\n res = self.client().post(\n '/api/v1/bucketlists/',\n headers=dict(Authorization=\"Bearer \" + access_token),\n data={'name': 'Visit the Grand Canyon!'})\n self.assertEqual(res.status_code, 201)\n # get the bucketlist in json\n results = json.loads(res.data.decode())\n\n # create a bucketlist item by making a POST request and add it to the created bucketlist\n res = self.client().post(\n '/api/v1/bucketlists/{}/items/'.format(results['id']),\n headers=dict(Authorization=\"Bearer \" + access_token),\n data={\n \"name\": \"Eat fried crabs\"\n })\n self.assertEqual(res.status_code, 201)\n # get the json containing the created bucketlist item\n res_item = json.loads(res.data.decode())\n\n # delete the bucketlist item we just created\n res = self.client().delete(\n '/api/v1/bucketlists/{}/items/{}'.format(results['id'], res_item['id']),\n headers=dict(), )\n self.assertEqual(res.status_code, 401)\n self.assertIn('Header with key Authorization missing.', str(res.data))", "def test_delete_item_using_delete(self):\n pass", "def test_single_bucketlist_item_delete_with_empty_token(self):\n self.register_user()\n result = self.login_user()\n access_token = json.loads(result.data.decode())['access_token']\n\n res = self.client().post(\n '/api/v1/bucketlists/',\n headers=dict(Authorization=\"Bearer \" + access_token),\n data=self.bucketlist)\n\n # assert that the bucketlist is created\n self.assertEqual(res.status_code, 201)\n # get the response data in json format\n results = json.loads(res.data.decode())\n\n # create a bucketlist item by making a POST request and add it to the created bucketlist\n res = self.client().post(\n '/api/v1/bucketlists/{}/items/'.format(results['id']),\n headers=dict(Authorization=\"Bearer \" + access_token),\n data={\n \"name\": \"Eat fried crabs\"\n })\n self.assertEqual(res.status_code, 201)\n # get the json containing the created bucketlist item\n res_item = json.loads(res.data.decode())\n\n # delete the bucketlist item we just created\n res = self.client().delete(\n '/api/v1/bucketlists/{}/items/{}'.format(results['id'], res_item['id']),\n headers=dict(Authorization=\"\"), )\n self.assertEqual(res.status_code, 401)\n self.assertIn('Token not provided in the header with key Authorization.', str(res.data))", "def test_delete_reusableitem_api_fails(self):\n self.client.force_authenticate(user=self.user_1)\n\n response = self.client.delete(get_reusable_item_1_url(self))\n\n self.assertEqual(response.status_code, status.HTTP_500_INTERNAL_SERVER_ERROR)", "def test_delete_item_successfully(self):\n self.client.post('/buckets',\n content_type='application/json',\n data=self.bucket, headers=self.header)\n self.client.post('/buckets/1/items',\n content_type='application/json',\n data=self.item, headers=self.header)\n response = self.client.delete('/buckets/1/items/1',\n headers=self.header)\n self.assertEquals(response.status_code, 200)\n self.assertIn('Item successfully deleted', response.data.decode())", "def test_delete_unkonwn_id_error(self):\n with self.assertRaises(QiitaDBUnknownIDError):\n SampleTemplate.delete(5)", "def test_bucket_is_deleted(self):\n with self.client:\n # Get an auth token\n token = self.get_user_token()\n response = self.client.post(\n '/bucketlists',\n data=json.dumps(dict(name='Travel')),\n headers=dict(Authorization='Bearer ' + token),\n content_type='application/json'\n )\n # Test Bucket creation\n data = json.loads(response.data.decode())\n self.assertEqual(response.status_code, 201)\n self.assertTrue(data['status'], 'success')\n self.assertTrue(data['name'], 'Travel')\n # Delete the created Bucket\n res = self.client.delete(\n '/bucketlists/1',\n headers=dict(Authorization='Bearer ' + token)\n )\n data = json.loads(res.data.decode())\n self.assertEqual(res.status_code, 200)\n self.assertTrue(data['status'] == 'success')\n self.assertTrue(data['message'] == 'Bucket Deleted successfully')\n self.assertTrue(res.content_type == 'application/json')", "def test_delitem(self):\n with self.assertRaises(QiitaDBNotImplementedError):\n del self.tester['1.SKM7.640188']", "def test_delete_bucket(self):\n pass", "def test_delete_with_bad_id(self):\n resp = self.api_client.delete('/api/metadata/tracks/100000/')\n data = json.loads(resp.content)\n\n # Ensure the request filed with a 404, and an error message is returned\n self.assertEqual(resp.status_code, 404)\n self.assertEqual(data['detail'], u'The record could not be found.')", "def test_delete_item(test_client):\n\n response = test_client.delete(GOOD_ITEM_URL)\n\n assert response.status_code == 204\n assert response.get_data() == b''", "def test_DELETE3(self):\n r = requests.delete(self.address + \"/cars/42\")\n self.assertEqual(r.status_code, 400)", "def test_delete_car_valid_id():\n initial_number_of_cars = len(client.get(\"/\").json())\n\n response = client.delete(\"/1\")\n assert response.status_code == STATUS_NO_CONTENT\n\n assert len(client.get(\"/\").json()) == initial_number_of_cars - 1", "def test_vault_delete_vault_item(self):\n pass", "def test_id_of_bucket_to_be_edited_does_not_exist(self):\n with self.client:\n # Get an auth token\n token = self.get_user_token()\n # Update the bucket name\n res = self.client.put(\n '/bucketlists/1',\n headers=dict(Authorization='Bearer ' + token),\n data=json.dumps(dict(name='Adventure')),\n content_type='application/json'\n )\n data = json.loads(res.data.decode())\n self.assertEqual(res.status_code, 404)\n self.assertTrue(res.content_type == 'application/json')\n self.assertTrue(data['status'] == 'failed')\n self.assertTrue(data['message'] == 'The Bucket with Id 1 does not exist')" ]

[ "0.8280715", "0.81965166", "0.8153652", "0.80517626", "0.7886369", "0.7813242", "0.7694013", "0.76679814", "0.76200867", "0.74761516", "0.7440213", "0.74288243", "0.74263364", "0.7391026", "0.73868865", "0.7326834", "0.7310586", "0.72898954", "0.72570956", "0.7218091", "0.7213452", "0.71546626", "0.71132094", "0.71117187", "0.70680153", "0.70378864", "0.7037814", "0.7031019", "0.7004663", "0.69480836" ]

[ "def test_put_bucketlist_item(self):\r\n data = {\"name\": \"bucketlist item name\", \"completed\": \"true\"}\r\n email = \"[email protected]\"\r\n _pword = \"test\"\r\n user = User.query.filter_by(email=email).first()\r\n bucketlist = BucketList.query.filter_by(user_id=user.id, name=\"test bucketlist\").first()\r\n item = BucketListItem.query.filter_by(bucketlist_id=bucketlist.id, id=1).first()\r\n self.assertNotEqual(item.name, \"bucketlist item name\")\r\n self.assertFalse(item.completed)\r\n\r\n response = self.put_bucketlist_item(email, _pword, bucketlist.id, 1, data)\r\n result = json.loads(response.data.decode('utf-8'))\r\n item2 = BucketListItem.query.filter_by(bucketlist_id=bucketlist.id, id=1).first()\r\n self.assertEqual(response.status, '201 CREATED')\r\n self.assertEqual(item2.name, \"bucketlist item name\")\r\n self.assertTrue(item2.completed)", "def put(self, user, id):\n # parse request data\n if 'name' not in self.request.form:\n return \"Bucketlist not Update\", 202\n\n bucketlist_name = self.request.form['name']\n\n # validate bucketlist\n if not bucketlist_name:\n return \"Name cannot be empty\", 401\n\n # search for the bucketlist_id\n bucketlist = Bucketlist.query.filter_by(\n id=id, created_by=user.email).first()\n\n # return 400 if bucketlist non exixtant or not belongs to this user\n if bucketlist is None:\n return 'Bucketlist not found', 202\n\n # Update bucketlist and save changes\n bucketlist.name = bucketlist_name\n bucketlist.save()\n\n return \"Successfully updated bucketlist\", 201", "def test_edit_bucketlist(self):\n post_data = self.post_a_bucket()\n self.assertEqual(post_data.status_code, 201)\n result_of_put_method = self.client().put(\n '/bucketlists/1',\n headers=dict(Authorization='Bearer '\n + self.token()\n ),\n data={\n \"name\": \"The seasons will be, summer winter and autumn\"\n })\n self.assertEqual(result_of_put_method.status_code, 201)\n result_of_get_method = self.client().get('/bucketlists/1',\n headers=dict(Authorization='Bearer '\n + self.token())\n )\n self.assertIn('The seasons will b', str(result_of_get_method.data))", "def test_update_busketlistitem_by_id(self):\n resp = self.client.post('/bucketlists',\n data=json.dumps(self.bucketlist),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n resp_item = self.client.post('/bucketlistitems/1/items',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n update_item = self.client.put('/bucketlistitems/1/items/1',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs and museums too.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(update_item.status_code, 201)", "def update_bucketlist():\n pass", "def test_api_edit_bucketlist(self):\n res_post = self.client().post('/bucketlist', data={'name': 'Wake up, Eat, Code, Sleep & Repeat'})\n self.assertEqual(res_post.status_code, 201)\n res_post_in_json = json.loads(res_post.data.decode('UTF-8').replace(\"'\", \"\\\"\"))\n id = res_post_in_json['id']\n res_put = self.client().put(\n f'bucketlist/{id}',\n data={\n 'name': \"Don't forget to exercise\"\n }\n )\n self.assertEqual(res_put.status_code, 200)\n res = self.client().get(f'/bucketlist/{id}')\n self.assertIn(\"exercise\", str(res.data))", "def test_bucket_is_updated(self):\n with self.client:\n # Get an auth token\n token = self.get_user_token()\n # Create a Bucket\n response = self.client.post(\n '/bucketlists',\n data=json.dumps(dict(name='Travel')),\n headers=dict(Authorization='Bearer ' + token),\n content_type='application/json'\n )\n # Test Bucket creation\n data = json.loads(response.data.decode())\n self.assertEqual(response.status_code, 201)\n self.assertTrue(data['status'], 'success')\n self.assertTrue(data['name'], 'Travel')\n # Update the bucket name\n res = self.client.put(\n '/bucketlists/1',\n headers=dict(Authorization='Bearer ' + token),\n data=json.dumps(dict(name='Adventure')),\n content_type='application/json'\n )\n data = json.loads(res.data.decode())\n self.assertEqual(res.status_code, 201)\n self.assertTrue(res.content_type == 'application/json')\n self.assertTrue(data['status'] == 'success')\n self.assertTrue(data['name'] == 'Adventure')\n self.assertEqual(data['id'], 1)", "def test_create_bucketlist_item(self):\n resp = self.client.post('/bucketlists',\n data=json.dumps(self.bucketlist),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n response = self.client.get(\n \"/bucketlists/1\", headers={\n \"Authorization\": self.token})\n self.assertEqual(response.status_code, 200)\n resp_item = self.client.post('/bucketlistitems/1/items',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n result = json.loads(resp_item.data)\n self.assertEqual(result[\"message\"],\n \"Bucket list item added successfully.\")\n self.assertEqual(resp.status_code, 201)", "def post_bucketlist():\n pass", "def test_put_item_wrong_id(self):\r\n data = {\"name\": \"bucketlist item name\", \"completed\": \"true\"}\r\n email = \"[email protected]\"\r\n _pword = \"test\"\r\n user = User.query.filter_by(email=email).first()\r\n bucketlist = BucketList.query.filter_by(user_id=user.id, name=\"test bucketlist\").first()\r\n item = BucketListItem.query.filter_by(bucketlist_id=bucketlist.id, id=0).first()\r\n self.assertFalse(item)\r\n\r\n response = self.put_bucketlist_item(email, _pword, bucketlist.id, 0, data)\r\n result = json.loads(response.data.decode('utf-8'))\r\n self.assertEqual(response.status, '404 NOT FOUND')\r\n self.assertEqual(\r\n result['message'],\r\n 'Bucketlist Item with ID {} not found in the database. You have requested this URI '\\\r\n '[/api/v1/bucketlist/1/items/0] but did you mean /api/v1/bucketlist/<int:bucketlist_id>/items/'\\\r\n ' or /api/v1/bucketlist/<int:bucketlist_id> or /api/v1/bucketlist ?'.format(0)\r\n )", "def _put(self, *args, **kwargs):\n return self._request('put', *args, **kwargs)", "def test_add_bucketlist_items(self):\r\n email = \"[email protected]\"\r\n _pword = \"test\"\r\n user = User.query.filter_by(email=email).first()\r\n bucketlist = BucketList.query.filter_by(user_id=user.id, name=\"test bucketlist\").first()\r\n item_no = BucketListItem.query.filter_by(bucketlist_id=bucketlist.id).count()\r\n response = self.add_bucketlist_item(email, _pword, bucketlist.id, \"bucketlist item name\")\r\n result = json.loads(response.data.decode('utf-8'))\r\n self.assertEqual(response.status, '201 CREATED')\r\n self.assertEqual(result['message'], 'Bucket list item added')\r\n new_item_no = BucketListItem.query.filter_by(bucketlist_id=bucketlist.id).count()\r\n self.assertLess(item_no, new_item_no)", "def manipulate_bucketlist():\n pass", "def test_get_bucketlist_items(self):\n resp = self.client.post('/bucketlists',\n data=json.dumps(self.bucketlist),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n\n resp_item = self.client.post('/bucketlistitems/1/items',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n\n self.assertEqual(resp_item.status_code, 200)\n resp_item = self.client.get('/bucketlistitems/1/items', headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp_item.status_code, 200)", "def put(handler, *args, **kwargs):\n bucket_id = args[0]\n user_id = args[1]\n content = tornado.escape.json_decode(handler.request.body)\n BucketClasss = type(\"Bucket_%s\" % (bucket_id), (Bucket,), {})\n bucket = yield BucketClasss.get(user_id)\n if not bucket:\n bucket = BucketClasss()\n bucket.pkey = user_id \n if bucket_id == \"userData\":\n save_ver = int(content.get(\"data\", {}).get(\"saveVer\",0))\n current_ver = int(bucket.data.get(\"data\", {}).get(\"saveVer\",0))\n if save_ver < current_ver:\n raise Return((405, None))\n bucket.data = content \n yield bucket.put()\n raise Return((204, None))", "def put_req(self, item):\n self.export.put_req(item)", "def put_req(self, item):\n self.req_q.put(item)", "def put(self, *args, **kwargs):\n self.request(\"put\", *args, **kwargs)", "def http_put(self, **kwargs):\n return self.rabjcallable.put(**kwargs)", "def add_bucketlist_item(self, email, password, buckelist_id, item_name):\r\n test_date = str(date(2020, 9, 22))\r\n headers = self.authentication_headers(email=email, password=password)\r\n return self.client.post(\r\n '/api/v1/bucketlist/{}/items/'.format(buckelist_id),\r\n data=json.dumps({\"name\": item_name, \"finished_by\": test_date}),\r\n content_type=\"application/json\",\r\n headers=headers,\r\n follow_redirects=True\r\n )", "def test_get_bucketlist_item_id(self):\n resp = self.client.post('/bucketlists',\n data=json.dumps(self.bucketlist),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n resp_item = self.client.post('/bucketlistitems/1/items',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n get_item = self.client.get('/bucketlistitems/1/items/1', headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)", "def put(self, *args, **kwargs):\n return self.handle_put_request()", "def test_delete_bucketlistitem_by_id(self):\n resp = self.client.post('/bucketlists',\n data=json.dumps(self.bucketlist),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n resp_item = self.client.post('/bucketlistitems/1/items',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n delete_item = self.client.delete('/bucketlistitems/1/items/1',\n headers={\n \"Authorization\": self.token\n })\n self.assertEqual(delete_item.status_code, 204)", "def put_list(self, request, **kwargs):\r\n response = super(BaseCorsResource, self).put_list(request, **kwargs)\r\n return self.add_cors_headers(response, True)", "def test_modify_item_successfully(self):\n self.client.post('/buckets',\n content_type='application/json',\n data=self.bucket, headers=self.header)\n self.client.post('/buckets/1/items',\n content_type='application/json',\n data=self.item,\n headers=self.header)\n response = self.client.put('/buckets/1/items/1',\n content_type='application/json',\n data=self.item_edit,\n headers=self.header)\n self.assertEquals(response.status_code, 200)\n self.assertIn('Item successfully updated',\n response.data.decode())", "def put_object(self, bucket_name, key, data):\n url = self.__key_url(bucket_name, key)\n resp = self.infinispan_client.put(url, data=data,\n auth=self.basicAuth,\n headers=self.headers)\n logger.debug(resp)", "def test_add_item_at_using_put(self):\n pass", "def test_id_of_bucket_to_be_edited_is_invalid(self):\n with self.client:\n # Get an auth token\n token = self.get_user_token()\n # Update the bucket name\n res = self.client.put(\n '/bucketlists/bucketid',\n headers=dict(Authorization='Bearer ' + token),\n data=json.dumps(dict(name='Adventure')),\n content_type='application/json'\n )\n data = json.loads(res.data.decode())\n self.assertEqual(res.status_code, 400)\n self.assertTrue(res.content_type == 'application/json')\n self.assertTrue(data['status'] == 'failed')\n self.assertTrue(data['message'] == 'Please provide a valid Bucket Id')", "def add_bucket_list_item(self, id, collection, item):\n if type(id) is not ObjectId:\n id = ObjectId(id)\n obj = getattr(self.db, collection)\n result = obj.update(\n {'_id': id},\n {'$addToSet': {'bucket_list': item}}\n )\n return result", "def test_app_can_update_a_list(self):\n self.ne=json.dumps({\"newName\":\"pants\"})\n list_update=self.client.put('/shoppinglists/trou',\n data=self.ne,\n headers={\n 'Content-Type':'application/json',\n 'x-access-token':self.tok})\n self.assertIn(\"list doesnt exist\",str(list_update.data)) \n self.assertEqual(list_update.status_code,200)" ]

[ "0.77104014", "0.75837624", "0.73698086", "0.7226279", "0.7216704", "0.71507794", "0.702163", "0.68962586", "0.6804519", "0.67802167", "0.6777862", "0.66020447", "0.6598506", "0.65621024", "0.64808017", "0.64796245", "0.64737403", "0.64593357", "0.6454596", "0.645011", "0.640735", "0.6369721", "0.6360353", "0.633439", "0.631797", "0.63168114", "0.6312306", "0.6288249", "0.62331", "0.62205523" ]

[ "def test_submodule(submodule):\n is_correct_subclass = issubclass(submodule, AnalysisModule)\n # Ensure submodule is defined within the package we are inspecting (and not 'base')\n is_correct_module = package.__name__ in submodule.__module__\n return is_correct_subclass and is_correct_module", "def is_root_mod(self):\n return all([not b.parents for b in self.input_bindings.bindings.values()])", "def check_submodules():\n if not os.path.exists('.git'):\n return\n with open('.gitmodules') as f:\n for l in f:\n if 'path' in l:\n p = l.split('=')[-1].strip()\n if not os.path.exists(p):\n raise ValueError('Submodule %s missing' % p)\n\n\n proc = subprocess.Popen(['git', 'submodule', 'status'],\n stdout=subprocess.PIPE)\n status, _ = proc.communicate()\n status = status.decode(\"ascii\", \"replace\")\n for line in status.splitlines():\n if line.startswith('-') or line.startswith('+'):\n raise ValueError('Submodule not clean: %s' % line)", "def is_model(self):\n return self.model_name() is not None", "def __contains__(self, name):\n return name in self._modules", "def is_submodule(self, submodule_basename):\n\n return submodule_basename in self._submodule_basename_to_node", "def use_ppmodel(self):\n return hasattr(self, \"ppmodel\")", "def test_model_can_import():\n assert hasattr(model, \"SEIR_model_publish_w_risk\")\n assert hasattr(model, \"compute_R0\")", "def hasModel(self, model):\n if model in self.models:\n return S_OK()\n else:\n return S_ERROR(\"Model %s is not defined, use any of %s\" % (model, self.models.keys()))", "def isModellingFramework(*args):\n return _libsbml.SBO_isModellingFramework(*args)", "def requires_model_loading(self):\n return self.requires_loaded_models", "def models_compatible(model_a: ModuleModel, model_b: ModuleModel) -> bool:\n if model_a == model_b:\n return True\n return model_b.value in _load_v2_module_def(model_a)['compatibleWith']", "def __contains__(self, name):\n return (self.model_dir / (str(name) + '.pkl')).exists()", "def is_module(obj):\n return type(obj) is types.ModuleType", "def SBO_isModellingFramework(*args):\n return _libsbml.SBO_isModellingFramework(*args)", "def source_repo_is_related():\n return True", "def test_get_leaf_modules(request):\n filename = request.module.__file__\n qalgebra_dir = os.path.join(\n os.path.split(filename)[0], '..', 'src', 'qalgebra'\n )\n modules = get_leaf_modules(qalgebra_dir)\n assert \"qalgebra.core.abstract_algebra\" in modules", "def isModule(self, name):\n return os.path.isfile(self.modulePath(name))", "def supports_ordinary_make_module_imports(self):\n return True", "def is_surjective(self):\n # Testing equality of free modules over PIDs is unreliable\n # see Trac #11579 for explanation and status\n # We test if image equals codomain with two inclusions\n # reverse inclusion of below is trivially true\n return self.codomain().is_submodule(self.image())", "def has_module(self, name: str) -> bool:\n return name in self.modules", "def check_model_exists(class_name):\n if path.exists(settings.get('FALAFEL_DIR') + settings.get('MODELS_DIR') + '/' + class_name + '.py'):\n return True\n else:\n return False", "def __is_model_permission(self, name: str) -> bool:\n permission_name, model_name = name.split('_')\n\n return permission_name in PERMISSIONS_PREFIXES and model_name in self.models_names", "def hasMetaModel(self, metaModel):\r\n if self.getClass() == metaModel: return 1\t\t\t\t# if the meta model is the actual class\r\n for mmodels in self.mergedASG:\t\t\t\t\t# else check the merged meta-models\r\n if mmodels.getClass() == metaModel: return 1\r\n return 0", "def _validate_mod(self, mod: Modifier):\r\n return not mod.name in self.mods", "def is_distributed_model(model):\n try:\n get_tenant_field(model)\n return True\n except ValueError:\n return False", "def is_model(model: Model) -> bool:\n for key in model:\n if not is_variable(key):\n return False\n return True", "def has_module_perms(self, app_label):\n\t\treturn True", "def is_module_object(self, obj):\n if not isinstance(obj, BaseException):\n try:\n c = obj.__class__\n source_file = inspect.getsourcefile(c)\n except (TypeError, AttributeError):\n pass\n else:\n if source_file and source_file.startswith(self.path):\n return True\n\n return False", "def _sufficient_deps(cls, deps):\n if cls.MODEL_PACKAGE is None:\n return True\n else:\n for d in deps.conda:\n if cls.MODEL_PACKAGE in d:\n return True\n for d in deps.pip:\n if cls.MODEL_PACKAGE in d:\n return True\n return False" ]

[ "0.66678244", "0.6193898", "0.6127741", "0.6090915", "0.60585386", "0.5981495", "0.5975656", "0.59688056", "0.58849907", "0.5884931", "0.5833496", "0.5831226", "0.58079565", "0.5742593", "0.5681119", "0.5659924", "0.56587225", "0.56485283", "0.56155103", "0.5606545", "0.5603672", "0.5603305", "0.559993", "0.5596409", "0.5594016", "0.5591113", "0.5575471", "0.5573548", "0.5569031", "0.5562536" ]

[ "def populate_buffer(self, num_transitions):\n while len(self.replay_buffer) < self.buffer_sample_size:\n self.play(num_transitions)", "def collect_samples(self):\n self.replay_buffer = self.collect_initial_batch(\n self.replay_buffer, self.acm_pre_train_samples\n )", "def prepare_data(self, train_data, **kwargs):\n data_len = len(train_data[\"done\"])\n for index in range(data_len):\n if self.multi_step == 1:\n self.buff.add(train_data[\"cur_state\"][index],\n train_data[\"action\"][index],\n train_data[\"reward\"][index],\n train_data[\"next_state\"][index],\n float(train_data[\"done\"][index])) # Add replay buffer", "def _preallocate_samples(self):\n self.prealloc_samples_ = []\n for _ in range(self.num_prealloc_samples_):\n self.prealloc_samples_.append(self.sample())", "def __init__(self,buffer_size,state_dim,action_dim,random_seed=123):\n print(\"Creating Replay Buffer object\")\n self.buffer_size=buffer_size\n self.state_dim=state_dim\n self.action_dim=action_dim\n self.pointer=0\n self.states=np.zeros(shape=[buffer_size,state_dim])\n self.actions=np.zeros(shape=[buffer_size,action_dim])\n self.rewards=np.zeros(shape=[buffer_size,1])\n self.dones=np.zeros(shape=[buffer_size,1])\n self.next_states=np.zeros(shape=[buffer_size,state_dim])\n self.filled=False\n \n random.seed(random_seed)", "def __init__(self, buffer_size):\n self.num_experiences = 0\n self.buffer = deque(maxlen=buffer_size)", "def setup_training(self):\n print('setup training called')\n self.steps_done = 0\n self.current_episode_num = 1\n self.total_reward = 0\n\n # self.optimizer = optim.RMSprop(policy_net.parameters())\n self.memory = ReplayMemory(300000)\n self.total_reward_history = []\n # self.loss_history = []\n self.positions = []\n self.n_destroyed_crates = 0\n self.is_in_bomb_range = False", "def initBuffer(self, env):\n cnt = 0\n while len(self.memory) < self.memory.capacity:\n cnt += 1\n print(\"\\rWarmup Buffer [{:d}]\".format(cnt), end=\"\")\n s = env.reset()\n actionIdx, actionIdxTuple = self.select_action(s, explore=True)\n s_, r, done, info = env.step(actionIdxTuple)\n self.store_transition(s, actionIdx, r, s_, info)\n print(\"\\n => Warmup Buffer Ends\")", "def train_experience_replay(self, epochs, batch_size, iterations_per_epoch, capacity, n_obs, **kwargs):\n\n # Initialize losses dictionary and memory replay buffer\n losses = dict()\n mem = MemoryReplayBuffer(capacity)\n\n for ep in range(1, epochs+1):\n losses[ep] = []\n with tqdm(total=iterations_per_epoch, desc='Training epoch {}'.format(ep)) as p_bar:\n\n for it in range(1, iterations_per_epoch+1):\n \n # Determine n_obs and generate data on-the-fly\n if type(n_obs) is int:\n n_obs_it = n_obs\n else:\n n_obs_it = n_obs()\n # Simulate and add to buffer\n params, sim_data = self._forward_inference(batch_size, n_obs_it, **kwargs)\n mem.store(params, sim_data)\n\n # Sample from buffer\n params, sim_data = mem.sample()\n\n # One step backprop\n loss = self._train_step(params, sim_data)\n \n # Store loss into dictionary\n losses[ep].append(loss)\n\n # Update progress bar\n p_bar.set_postfix_str(\"Epoch {0},Iteration {1},Loss: {2:.3f},Running Loss: {3:.3f}\"\n .format(ep, it, loss, np.mean(losses[ep])))\n p_bar.update(1)\n\n # Store after each epoch, if specified\n if self.manager is not None:\n self.manager.save()\n return losses", "def collect_initial_batch(\n self, buffer: ReplayBufferAcM, samples_no: int\n ) -> ReplayBufferAcM:\n collected = 0\n while collected < samples_no:\n obs = self.env.reset()\n end = False\n obs = torch.tensor(obs, dtype=torch.float32, device=self.device)\n obs = obs.unsqueeze(0)\n\n prev_idx = buffer.add_obs(obs)\n ep_len = 0\n\n while not end:\n action = AcMTrainer.initial_act(self, obs)\n action_tensor = torch.tensor(action).unsqueeze(0)\n obs, rew, end, _ = self.env.step(action)\n ep_len += 1\n\n obs = torch.tensor(obs, dtype=torch.float32, device=self.device)\n obs = obs.unsqueeze(0)\n\n next_idx = buffer.add_obs(obs)\n buffer.add_timestep(prev_idx, next_idx, action_tensor)\n prev_idx = next_idx\n collected += 1\n return buffer", "def _build_replay_buffer(self):\n return prioritized_replay_buffer.OutOfGraphPrioritizedReplayBuffer(\n observation_shape=self.observation_shape,\n stack_size=self.stack_size,\n update_horizon=self.update_horizon,\n gamma=self.gamma,\n observation_dtype=self.observation_dtype)", "def replay(self):\n # Start only have enough memories\n if len(self.memory) < self.train_start:\n return\n\n batch_size = min(self.batch_size, len(self.memory))\n\n # Use mini_batch, sampling form the memory\n mini_batch = random.sample(self.memory, batch_size)\n\n # Since we are suing batch, we need to collect input and target\n input_update = np.zeros((batch_size, self.input_shape[0]))\n target_update = np.zeros((batch_size, self.output_num))\n\n for i in range(batch_size):\n state, action, reward, next_state, done = mini_batch[i]\n target = self.model.predict(state)[0]\n\n # Add future discounted reward\n if not done:\n # Use target_model here, because we want to keep the weights\n # not changing in one complete game\n target[action] = (1 - ALPHA) * reward + ALPHA * \\\n (self.gamma * np.amax(self.target_model.\n predict(next_state)[0]))\n else:\n target[action] = reward\n\n # Record the info into batch collection\n input_update[i] = state\n target_update[i] = target\n\n # Update model (also use a batch)\n self.model.fit(input_update, target_update, batch_size=batch_size,\n epochs=1, verbose=0)", "def initialize_replay_memory(n_steps: int, env: gym.Env, replay_memory: ReplayMemory) -> None:\n obs = env.reset()\n for _ in range(n_steps):\n a = env.action_space.sample()\n obs2, r, d, _ = env.step(a)\n\n replay_memory.store(obs, a, r, obs2, d)\n\n # For next iteration\n obs = env.reset() if d else obs2", "def _train_step(self):\n if self._replay.add_count > self.min_replay_history:\n if self.training_steps % self.update_period == 0:\n self._sample_from_replay_buffer()\n\n if self._replay_scheme == 'prioritized':\n # The original prioritized experience replay uses a linear exponent\n # schedule 0.4 -> 1.0. Comparing the schedule to a fixed exponent of\n # 0.5 on 5 games (Asterix, Pong, Q*Bert, Seaquest, Space Invaders)\n # suggested a fixed exponent actually performs better, except on Pong.\n probs = self.replay_elements['sampling_probabilities']\n loss_weights = 1.0 / jnp.sqrt(probs + 1e-10)\n loss_weights /= jnp.max(loss_weights)\n else:\n loss_weights = jnp.ones(self.replay_elements['state'].shape[0])\n\n self._rng, self.optimizer, loss, mean_loss= train(\n self.network_def,\n self.target_network_params,\n self.optimizer,\n self.replay_elements['state'],\n self.replay_elements['action'],\n self.replay_elements['next_state'],\n self.replay_elements['reward'],\n self.replay_elements['terminal'],\n loss_weights,\n self._target_opt,\n self.num_tau_samples,\n self.num_tau_prime_samples,\n self.num_quantile_samples,\n self.cumulative_gamma,\n self.double_dqn,\n self.kappa,\n self._tau,\n self._alpha,\n self._clip_value_min,\n self._num_actions,\n self._rng)\n\n if self._replay_scheme == 'prioritized':\n # Rainbow and prioritized replay are parametrized by an exponent\n # alpha, but in both cases it is set to 0.5 - for simplicity's sake we\n # leave it as is here, using the more direct sqrt(). Taking the square\n # root \"makes sense\", as we are dealing with a squared loss. Add a\n # small nonzero value to the loss to avoid 0 priority items. While\n # technically this may be okay, setting all items to 0 priority will\n # cause troubles, and also result in 1.0 / 0.0 = NaN correction terms.\n self._replay.set_priority(self.replay_elements['indices'],\n jnp.sqrt(loss + 1e-10))\n\n\n if (self.summary_writer is not None and\n self.training_steps > 0 and\n self.training_steps % self.summary_writing_frequency == 0):\n summary = tf.compat.v1.Summary(value=[\n tf.compat.v1.Summary.Value(tag='ImplicitLoss',\n simple_value=mean_loss)])\n self.summary_writer.add_summary(summary, self.training_steps)\n if self.training_steps % self.target_update_period == 0:\n self._sync_weights()\n\n self.training_steps += 1", "def _build_replay_buffer(self):\n if self._replay_scheme not in ['uniform', 'prioritized']:\n raise ValueError('Invalid replay scheme: {}'.format(self._replay_scheme))\n # Both replay schemes use the same data structure, but the 'uniform' scheme\n # sets all priorities to the same value (which yields uniform sampling).\n return prioritized_replay_buffer.OutOfGraphPrioritizedReplayBuffer(\n observation_shape=self.observation_shape,\n stack_size=self.stack_size,\n update_horizon=self.update_horizon,\n gamma=self.gamma,\n observation_dtype=self.observation_dtype)", "def initialize_replay_memory(self, size):\n if self.replay_memory:\n self.train_logger.info('INFO: Replay memory already initialized')\n return\n\n assert size >= self.batch_size, \"Initialize with size >= batch size\"\n\n old_state = self.env.reset()\n for i in range(size):\n action = random.choice(self.valid_actions)\n new_state, reward, done, _ = self.env.step(action)\n reward = np.clip(self.scale * reward, -self.clip, self.clip)\n self.replay_memory.append(transition(old_state, action,\n reward, new_state, done))\n\n if done:\n old_state = self.env.reset()\n else:\n old_state = new_state\n\n self.train_logger.info(f'INFO: Replay memory initialized with {size} experiences')", "def experience_replay(self):\n s,a,r,sp,done = self.memory.sample(self.batch_size)\n # TODO: 5 lines missing.\n raise NotImplementedError(\"\")\n self.Q.fit(s, target=target)", "def learn(self):\n\n if (len(self._replay_buffer) < self._batch_size or\n len(self._replay_buffer) < self._min_buffer_size_to_learn):\n return None\n # print(len(self._replay_buffer), self._min_buffer_size_to_learn)\n\n cum_v_loss = 0.\n cum_q_loss = 0.\n\n # ---------------- compute all targets (not necessary)---------------#\n # vectorize may have problem.\n self._replay_buffer.vectorize(frame_buffer=0, n_step_size=N_STEP_SIZE, gamma=GAMMA)\n # print(self._replay_buffer.idcs, self._replay_buffer.n_step)\n # change to getting all target values first\n all_tar_v, all_tar_q, q_plus = self.__compute_targets(self._sampled_indices)\n # if self._replay_buffer.n_step.shape == (0,):\n # return\n all_v_mb, all_q_mb = self._session.run([all_tar_v, all_tar_q],\n feed_dict={self._info_state_ph: self._replay_buffer.obs,\n self._n_step_ph: self._replay_buffer.n_step[self._replay_buffer.idcs],\n self._action_ph: self._replay_buffer.actions})\n\n # ----------------every iteration, sample and compute loss-------------#\n for i_iter in range(self.iteration):\n # Sample (get states & ...)\n mb_idcs = np.random.choice(len(self._replay_buffer), self._batch_size)\n mb_info_state, _, mb_actions, *_ = self._replay_buffer[mb_idcs] # problem\n\n mb_est_rew_w = self._replay_buffer.est_rew_weights[self._replay_buffer.idcs[mb_idcs]] # problem\n mb_est_non_zero = np.nonzero(mb_est_rew_w)\n n_step = self._replay_buffer.n_step[mb_idcs]\n\n if len(mb_est_non_zero[0]): # the array is not empty\n mb_est_non_zero = np.squeeze(mb_est_non_zero)\n mb_est_rew_idcs = (self._replay_buffer.idcs[mb_idcs][mb_est_non_zero] +\n self._replay_buffer.n_step_size).reshape(-1)\n\n # mb_v_prime_obs = next_info_state_ph\n mb_v_prime_obs, _, _, *_ = self._replay_buffer[mb_est_rew_idcs]\n else:\n mb_v_prime_obs = np.zeros((32, mb_info_state[0].size))\n\n # if self.player_id == 0:\n # print(\"In Learn Test Start: {}#################\".format(i_iter))\n # print(self.player_id)\n # print(mb_info_state.shape)\n # print(mb_actions.shape)\n # print(mb_v_prime_obs.shape)\n # print(n_step.shape)\n # print(mb_est_rew_w)\n # print(mb_est_non_zero)\n # print(\"In\n # Test End: {}###################\".format(i_iter))\n tar_v_mb = all_v_mb[mb_idcs]\n tar_q_mb = all_q_mb[mb_idcs]\n # print(\"In iteration: {}\".format(i_iter))\n # print(tar_v_mb.shape, tar_q_mb.shape)\n\n loss, _, v_loss, q_loss = self._session.run(\n [self._loss, self._learn_step, self.v_loss, self.q_loss],\n feed_dict={\n self._info_state_ph: mb_info_state,\n self._action_ph: mb_actions,\n self._next_info_state_ph: mb_v_prime_obs,\n self._mb_est_rew_ph: mb_est_rew_w,\n self._tar_q_ph: tar_q_mb,\n self._tar_v_ph: tar_v_mb\n })\n\n self._session.run(self._update_target_network)\n\n cum_q_loss += q_loss\n cum_v_loss += v_loss\n\n if (i_iter + 1) % (self.iteration / 10) == 0.:\n # print loss\n mean_v_loss = (cum_v_loss / int(self.iteration / 10))\n mean_q_loss = (cum_q_loss / int(self.iteration / 10))\n print(\"interation: {}, v_loss: {:.6f}, q_loss: {:.6f}\".format(\n i_iter + 1, mean_v_loss, mean_q_loss), end='\\r')\n if (i_iter + 1) == self.iteration:\n cum_v_loss = mean_v_loss\n cum_q_loss = mean_q_loss\n else:\n cum_v_loss = 0.0\n cum_q_loss = 0.0\n\n # transitions = self._replay_buffer.sample(self._batch_size)\n # info_states = [t.info_state for t in transitions]\n # actions = [t.action for t in transitions]\n # rewards = [t.reward for t in transitions]\n # next_info_states = [t.next_info_state for t in transitions]\n # are_final_steps = [t.is_final_step for t in transitions]\n # legal_actions_mask = [t.legal_actions_mask for t in transitions]\n # loss, _ = self._session.run(\n # [self._loss, self._learn_step],\n # feed_dict={\n # self._info_state_ph: info_states,\n # self._action_ph: actions,\n # self._reward_ph: rewards,\n # self._is_final_step_ph: are_final_steps,\n # self._next_info_state_ph: next_info_states,\n # self._legal_actions_mask_ph: legal_actions_mask,\n # })\n self._last_loss_value = [cum_v_loss, cum_q_loss]\n self.replay_buffer.clear()\n return [cum_v_loss, cum_q_loss]", "def __init__(self, size, train_frequency, avoid_episode_crossing=False,\n **kwargs):\n super().__init__(**kwargs)\n self.avoid_episode_crossing = avoid_episode_crossing\n self.size = size\n # A 'linear' history of all samples, in the order they were added.\n # Note these are just references to the same sample in the main\n # 'buffer' in the parent class, there is no RAM duplication here.\n # This defines the order samples are removed from the replay buffer\n self.linear_history = deque()\n self.train_frequency = train_frequency\n # This signifies how much train quota we have, for each sample\n # received this increases by 'train_frequency' and decreases on every\n # sample trained\n self.train_quota = 0", "def _build_replay_buffer(self, use_staging):\n return circular_replay_buffer.WrappedReplayBuffer(\n observation_shape=self.observation_shape,\n stack_size=self.stack_size,\n use_staging=use_staging,\n update_horizon=self.update_horizon,\n observation_dtype=self.observation_dtype.as_numpy_dtype)", "def __init__(self, num_prealloc_samples=0):\n self.num_prealloc_samples_ = num_prealloc_samples\n if self.num_prealloc_samples_ > 0:\n self._preallocate_samples()", "def __init__(self):\n self.replay_buffer = deque()", "def __init__(\n self, brain, reward_buff_cap, trainer_parameters, training, load, seed, run_id\n ):\n super().__init__(brain, trainer_parameters, training, run_id, reward_buff_cap)\n self.param_keys = [\n \"batch_size\",\n \"beta\",\n \"buffer_size\",\n \"epsilon\",\n \"hidden_units\",\n \"lambd\",\n \"learning_rate\",\n \"max_steps\",\n \"normalize\",\n \"num_epoch\",\n \"num_layers\",\n \"time_horizon\",\n \"sequence_length\",\n \"summary_freq\",\n \"use_recurrent\",\n \"summary_path\",\n \"memory_size\",\n \"model_path\",\n \"reward_signals\",\n ]\n self.check_param_keys()\n\n # Make sure we have at least one reward_signal\n if not self.trainer_parameters[\"reward_signals\"]:\n raise UnityTrainerException(\n \"No reward signals were defined. At least one must be used with {}.\".format(\n self.__class__.__name__\n )\n )\n\n self.step = 0\n self.policy = PPOPolicy(seed, brain, trainer_parameters, self.is_training, load)\n\n stats = defaultdict(list)\n # collected_rewards is a dictionary from name of reward signal to a dictionary of agent_id to cumulative reward\n # used for reporting only. We always want to report the environment reward to Tensorboard, regardless\n # of what reward signals are actually present.\n self.collected_rewards = {\"environment\": {}}\n for _reward_signal in self.policy.reward_signals.keys():\n self.collected_rewards[_reward_signal] = {}\n\n self.stats = stats\n\n self.training_buffer = Buffer()\n self.episode_steps = {}", "def _initialize_buffers(self) -> None:", "def setup_training(self):\n self.transitions = deque(maxlen=TRANSITION_HISTORY_SIZE)\n self.total_rewards = []\n self.rewards = []\n self.steps = []\n self.average_rewards = []\n self.average_steps = []\n self.model = initialize_model()\n self.invalid_actions = 0\n self.average_invalid_actions = []\n self.total_invalid_actions = []", "def build_replay_buffer(agent, batch_size, steps_per_loop):\n buf = tf_uniform_replay_buffer.TFUniformReplayBuffer(\n data_spec=agent.policy.trajectory_spec,\n batch_size=batch_size,\n max_length=steps_per_loop)\n return buf", "def training_start(self, dataloader):\n self.datasize = len(dataloader)", "def fillBuffer():\n buff[bufferCounter].next = dataIn", "def fit(self, env, num_iterations, max_episode_length=None):\n print ('initializing replay memory...')\n sys.stdout.flush()\n self.mode = 'init'\n self.memory.clear()\n self.preprocessor.reset()\n self.num_steps = 0\n num_updates = 0\n num_episodes = 0\n while num_updates < num_iterations:\n state = env.reset()\n self.preprocessor.reset()\n num_episodes += 1\n t = 0\n total_reward = 0\n while True:\n self.num_steps +=1\n t += 1\n action, _ = self.select_action(state)\n next_state, reward, is_terminal, debug_info = env.step(action)\n\n reward = self.preprocessor.process_reward(reward)\n total_reward += reward\n\n preprocessed_state = self.preprocessor.process_state_for_memory(state)\n\n self.memory.append(preprocessed_state, action, reward, is_terminal)\n\n if self.num_steps > self.num_burn_in:\n if self.mode != 'train':\n print('Finish Burn-in, Start Training!')\n\n self.mode = 'train'\n if self.num_steps % self.train_freq == 0:\n self.update_predict_network()\n num_updates += 1\n if num_updates % 10000 == 0:\n self.q_network.save_weights('%s/model_weights_%d.h5' % (self.save_path, num_updates // 10000))\n \n if is_terminal or (max_episode_length is not None and t > max_episode_length):\n break\n \n state = next_state\n #print ('episode %d ends, lasts for %d steps (total steps:%d), gets $d reward. (%d/%d updates.)' % (num_episodes, t, self.))", "def main():\n timer_total_start = time.time()\n rospy.init_node(\"ReplayBufferFiller\")\n rospy.loginfo(\"----- Replay Buffer Filler -----\")\n\n ground_list = [\"water1\",\n \"water2\",\n \"water3\",\n \"water4\",\n \"water5\",\n \"water6\",\n \"water7\",\n \"water8\",\n \"water9\",\n \"water10\"]\n\n replay_memory_size = 400000\n replay_buffer_path = \"./replay_buffer.pickle\"\n # replay_buffer_path_positive = \"./replay_buffer_positive.pickle\"\n # replay_buffer_path_negative = \"./replay_buffer_negative.pickle\"\n replay_buffer = ExperienceReplayBuffer(capacity=replay_memory_size)\n # replay_buffer_positive = ExperienceReplayBuffer(capacity=replay_memory_size)\n # replay_buffer_negative = ExperienceReplayBuffer(capacity=replay_memory_size)\n # Load the Replay buffer from file or accumulate experiences\n if(os.path.isfile(replay_buffer_path) == True): \n print(\"Replay buffer loading from file: \" +\n str(replay_buffer_path))\n replay_buffer.load(replay_buffer_path)\n else:\n\t print('No buffer_1 found')\n\n # if(os.path.isfile(replay_buffer_path_positive) == True): \n # print(\"Replay buffer loading from file: \" +\n # str(replay_buffer_path_positive))\n # replay_buffer_positive.load(replay_buffer_path_positive)\n # else:\n\t# print('No buffer_2 found') \n\n # if(os.path.isfile(replay_buffer_path_negative) == True): \n # print(\"Replay buffer loading from file: \" +\n # str(replay_buffer_path_negative))\n # replay_buffer_negative.load(replay_buffer_path_negative)\n # else:\n\t# print('No buffer_2 found') \n \n \n # Create a subscriber fot the greyscale image\n rospy.Subscriber(\"/quadrotor/ardrone/bottom/ardrone/bottom/image_raw\", ROSImage, image_callback)\n\n images_stack_size = 4\n tot_steps = 3000000 # finite-horizont simulation\n frame_preliminary = 0\n\n saving_every_tot_experiences = 2500\n is_buffer_saved = True\n\n noop_time = 2.0 # pause in seconds between actions\n steps_per_episodes = 30\n #saving_every_tot_experiences = 450 #TODO SET TO 250 JUST FOR TEST\n #r = rospy.Rate(10) # 10hz\n num_ground_plane = 15\n frame_per_ground_plane = int(replay_memory_size / num_ground_plane)\n frame_per_ground_plane = 3125 #!M positive / 4 classes / 10 grounds / 8 transformations\n actual_ground_index = 0\n episode_per_ground = 50\n #ground_counter = replay_buffer_positive.return_size() / frame_per_ground_plane\n ground_counter = 1\n positive_experience_counter = 0\n positive_experience_print_episode = 50\n old_positive_experience_counter = 0\n total_experience_counter = 0.0\n old_total_experience_counter = 0.0001\n episode = 1\n wrong_altitude = False\n quadrotor_pose = ModelState()\n quadrotor_pose.model_name = \"quadrotor\"\n quadrotor_pose.reference_frame = \"world\"\n while True:\n # if replay_buffer_positive.return_size() >= replay_memory_size:\n # break\n\n # if replay_buffer_positive.return_size() <= ground_counter * frame_per_ground_plane and episode != 1:\n # pass\n # else:\n # print ground_counter\n # generate_new_world(ground_list, ground_counter)\n # ground_counter = ground_counter + 1\n if(ground_counter < episode_per_ground) and episode != 1:\n ground_counter = ground_counter + 1\n else:\n ground = choose_random_ground(ground_list)\n generate_new_world(ground, ground_list)\n ground_counter = 1\n\n cumulated_reward = 0\n print \"\"\n print \"Preliminary Episode: \" + str(episode)\n print \"Ground counter value: \" + str(ground_counter)\n # Reset UAV at random pose\n reset_pose()\n send_action('stop')\n rospy.sleep(3.0)\n #get_image()\n image_t = _last_image\n # When the replay buffer is empty, fill it with the same picture 4\n # times\n image_t = np.stack([image_t] * images_stack_size, axis=2) # create a stack of X images\n timer_start = time.time()\n actual_time = rospy.get_rostime()\n \trospy_start_time = actual_time.secs + actual_time.nsecs / 1000000000.0\n frame_episode = 0\n \n done_reward = get_done_reward()\n update_quadrotor_pose(quadrotor_pose, done_reward)\n \n for step in range(tot_steps):\n # Execute a random action in the world and observe the reward and\n # state_t1.\n action = get_random_action()\n send_action(action)\n if action == \"descend\":\n # setpoint = round( quadrotor_pose.pose.position.z ) - 0.8\n # while True:\n # done_reward = get_done_reward()\n # update_quadrotor_pose(quadrotor_pose, done_reward)\n # if quadrotor_pose.pose.position.z < setpoint + 0.05 and quadrotor_pose.pose.position.z > setpoint - 0.05:\n # print \"Setpoint: \" + str(setpoint)\n # send_action(\"stop\")\n # rospy.sleep(2.0)\n # break\n rospy.sleep(5.0)\n send_action(\"stop\")\n rospy.sleep(1.0)\n #quadrotor_pose.pose.position.z = adjust_altitude(quadrotor_pose.pose.position.z)\n #set_pose(quadrotor_pose)\n else:\n #print \"Action taken: \" + action\n #send_action(action)\n rospy.sleep(noop_time)\n # Acquire a new frame and convert it in a numpy array\n image_t1 = _last_image\n done_reward = get_done_reward()\n send_action(\"stop\") #NOTE: moved here to fix problem with baricenter (partially reduced)\n\n # Get the reward and done status\n\n reward = done_reward.reward\n done = done_reward.done\n print \"Step(\" + str(step) + \"), Action: \" + action + \", Altitude: \" + str(done_reward.z) + \", Reward: \" + str(reward)\n wrong_altitude = done_reward.wrong_altitude\n if wrong_altitude == True:\n rospy.logerr(\"[ERROR] Wrong altitude!\")\n # Calculate the new cumulated_reward\n cumulated_reward += reward\n # state_t1, reward, done, info = env.step(action)\n image_t1 = np.expand_dims(image_t1, 2)\n # stack the images\n image_t1 = np.append(image_t[:, :, 1:], image_t1, axis=2)\n # Store the experience in the replay buffer\n if reward > 0:\n if action == \"descend\":\n # replay_buffer_positive.add_experience(image_t, action, reward, image_t1, done)\n # is_buffer_saved = False\n pass\n else:\n rospy.logerr(\"[POSITIVE]Wrong action for positive reward: %s\", action)\n elif reward == -1.0:\n if action == \"descend\":\n # replay_buffer_negative.add_experience(image_t, action, reward, image_t1, done)\n pass\n else:\n rospy.logerr(\"[NEGATIVE]Wrong action for negative reward: %s\", action)\n else:\n # pass\n replay_buffer.add_experience(image_t, action, reward, image_t1, done)\n frame_preliminary += 1 # To call every time a frame is obtained\n total_experience_counter += 1\n image_t = image_t1\n timer_episode_stop = time.time()\n frame_episode +=1\n update_quadrotor_pose(quadrotor_pose, done_reward)\n \n #rospy.sleep(2.0) #NOTE: fix the descend bug affecting the altitude\n if frame_episode >= steps_per_episodes:\n\t done = True\n # Save the buffer every 25000 experiences\n # if replay_buffer_positive.return_size() % saving_every_tot_experiences == 0 and is_buffer_saved == False:\n if replay_buffer.return_size() % saving_every_tot_experiences == 0 :\n timer_start = time.time()\n print(\"\")\n print(\"Saving the replay buffer in: \" + replay_buffer_path)\n print(\"Sit back and relax, it may take a while...\")\n replay_buffer.save(replay_buffer_path)\n timer_stop = time.time()\n print \"Time episode: \" + str(timer_stop - timer_start) + \" seconds\"\n print \"Time episode: \" + str((timer_stop - timer_start) / 60) + \" minutes\"\n print(\"Done!\")\n # timer_start = time.time()\n # print(\"\")\n # print(\"Saving the replay buffer in: \" + replay_buffer_path_positive)\n # print(\"Sit back and relax, it may take a while...\")\n # replay_buffer_positive.save(replay_buffer_path_positive)\n # timer_stop = time.time()\n # print \"Time episode: \" + str(timer_stop - timer_start) + \" seconds\"\n # print \"Time episode: \" + str((timer_stop - timer_start) / 60) + \" minutes\"\n # print(\"Done!\")\n # print(\"\")\n # print(\"Saving the replay buffer in: \" + replay_buffer_path_negative)\n # print(\"Sit back and relax, it may take a while...\")\n # replay_buffer_negative.save(replay_buffer_path_negative)\n # timer_stop = time.time()\n # print \"Time episode: \" + str(timer_stop - timer_start) + \" seconds\"\n # print \"Time episode: \" + str((timer_stop - timer_start) / 60) + \" minutes\"\n # print(\"Done!\")\n # print(\"\")\n # is_buffer_saved = True\n if done:\n episode += 1\n timer_stop = time.time()\n actual_time = rospy.get_rostime()\n rospy_stop_time = actual_time.secs + actual_time.nsecs / 1000000000.0\n rospy_time_elapsed = rospy_stop_time - rospy_start_time\n print \"Replay Buffer Size: \" + str(replay_buffer.return_size()) + \" out of \" + str(replay_memory_size)\n # print \"Replay Buffer Positive Size: \" + str(replay_buffer_positive.return_size()) + \" out of \" + str(replay_memory_size)\n # print \"Replay Buffer Negative Size: \" + str(replay_buffer_negative.return_size()) + \" out of \" + str(replay_memory_size)\n print \"Frame counter: \" + str(frame_preliminary)\n print \"Time episode: \" + str(timer_stop - timer_start) + \" seconds\"\n print( \"Ros time episode: \" + str(rospy_time_elapsed) + \" seconds\")\n if cumulated_reward >= 0:\n rospy.logwarn(\"Positive reward obtained!\")\n print \"Cumulated reward: \" + str(cumulated_reward)\n print \"Episode finished after {} timesteps\".format(step + 1)\n break\n\n # timer_total_stop = time.time()\n # print \"Total time simulation: \" + str((timer_total_stop - timer_total_start) / 60.0) + \" minutes\"\n # print \"Total time simulation: \" + str((timer_total_stop - timer_total_start) / 3600.0) + \" hours\"\n # # Once the buffer is filled, save it to disk\n # timer_saving_start = time.time()\n # print \"Saving the replay buffer in: \" + replay_buffer_positive_path\n # print \"Sit back and relax, it may take a while...\"\n # replay_buffer_positive.save(replay_buffer_positive_path)\n # print \"Done!\"\n # timer_saving_stop = time.time()\n # print \"Time to save the buffer: \" + str(timer_saving_stop - timer_saving_start) + \" seconds\"\n # print \"Time to save the buffer: \" + str((timer_saving_stop - timer_saving_start) / 60) + \" minutes\"\n # timer_saving_start = time.time()\n # print \"Saving the replay buffer in: \" + replay_buffer_negative_path\n # print \"Sit back and relax, it may take a while...\"\n # replay_buffer_negative.save(replay_buffer_negative_path)\n # print \"Done!\"\n # timer_saving_stop = time.time()\n # print \"Time to save the buffer: \" + str(timer_saving_stop - timer_saving_start) + \" seconds\"\n # print \"Time to save the buffer: \" + str((timer_saving_stop - timer_saving_start) / 60) + \" minutes\"\n # Shutdown the node\n rospy.signal_shutdown(\"Rospy Shutdown!\")" ]

[ "0.7086755", "0.634814", "0.62348205", "0.61094946", "0.6062285", "0.601058", "0.59450614", "0.59385663", "0.59318626", "0.5931236", "0.5920841", "0.591392", "0.59087026", "0.5903313", "0.58007306", "0.57563967", "0.5704546", "0.56222826", "0.5611808", "0.56116015", "0.55923367", "0.5574717", "0.5571157", "0.5569781", "0.5561985", "0.55542725", "0.5531555", "0.55267376", "0.5523613", "0.5490623" ]

[ "def two_qubit_rotation(self, bits, symbols):\n circuit = cirq.Circuit()\n circuit += cirq.Circuit(self.one_qubit_rotation(bits[0], symbols[0:3]))\n circuit += cirq.Circuit(self.one_qubit_rotation(bits[1], symbols[3:6]))\n circuit += [cirq.ZZ(*bits)**symbols[6]]\n circuit += [cirq.YY(*bits)**symbols[7]]\n circuit += [cirq.XX(*bits)**symbols[8]]\n circuit += cirq.Circuit(self.one_qubit_rotation(bits[0], symbols[9:12]))\n circuit += cirq.Circuit(self.one_qubit_rotation(bits[1], symbols[12:]))\n return circuit", "def _tk1_to_rotations(a: float, b: float, c: float) -> Circuit:\n circ = Circuit(1)\n circ.Rz(c, 0).Rx(b, 0).Rz(a, 0)\n return circ", "def one_qubit_rotation(self, qubit, symbols):\n # print(symbols, \"hi\")\n return [cirq.rx(symbols[0])(qubit),\n cirq.ry(symbols[1])(qubit),\n cirq.rz(symbols[2])(qubit)]", "def test_serialize_circuit_rotations(self):\n dev = QeQiskitDevice(wires=1, shots=1000, backend=\"qasm_simulator\", analytic=False)\n\n def circuit():\n qml.Hadamard(wires=[0])\n return qml.expval(qml.Hadamard(0))\n\n qnode = qml.QNode(circuit, dev)\n qnode._construct([], {})\n\n qasm = dev.serialize_circuit(qnode.circuit)\n expected = 'OPENQASM 2.0;\\ninclude \"qelib1.inc\";\\nqreg q[1];\\ncreg c[1];\\nh q[0];\\nry(-0.7853981633974483) q[0];\\n'\n assert qasm == expected", "def test_rot_decomposition(self, diff_method):\r\n dev = qml.device(\"default.qubit\", wires=1)\r\n\r\n def circuit(weights):\r\n qml.Rot(weights[0], weights[1], weights[2], wires=0)\r\n return qml.expval(qml.PauliX(0))\r\n\r\n circuit = qml.QNode(circuit, dev, diff_method=diff_method)\r\n params = np.array([1.0, 2.0, 3.0])\r\n tapes = qml.metric_tensor(circuit, only_construct=True)(params)\r\n assert len(tapes) == 3\r\n\r\n # first parameter subcircuit\r\n assert len(tapes[0].operations) == 0\r\n\r\n # Second parameter subcircuit\r\n assert len(tapes[1].operations) == 4\r\n assert isinstance(tapes[1].operations[0], qml.RZ)\r\n assert tapes[1].operations[0].data == [1]\r\n # PauliY decomp\r\n assert isinstance(tapes[1].operations[1], qml.PauliZ)\r\n assert isinstance(tapes[1].operations[2], qml.S)\r\n assert isinstance(tapes[1].operations[3], qml.Hadamard)\r\n\r\n # Third parameter subcircuit\r\n assert len(tapes[2].operations) == 2\r\n assert isinstance(tapes[2].operations[0], qml.RZ)\r\n assert isinstance(tapes[2].operations[1], qml.RY)\r\n assert tapes[2].operations[0].data == [1]\r\n assert tapes[2].operations[1].data == [2]\r\n\r\n result = qml.metric_tensor(circuit)(params)\r\n assert result.shape == (3, 3)", "def Rot_layer(self, w):\n for idx, element in enumerate(w):\n qml.Rot(element[0], element[1], element[2], wires=idx)", "def toRot(q):\n R = SX.zeros(3, 3)\n qi = q[0]; qj = q[1]; qk = q[2]; qr = q[3]\n R[0, 0] = 1. - 2. * (qj * qj + qk * qk);\n R[0, 1] = 2. * (qi * qj - qk * qr);\n R[0, 2] = 2. * (qi * qk + qj * qr)\n R[1, 0] = 2. * (qi * qj + qk * qr);\n R[1, 1] = 1. - 2. * (qi * qi + qk * qk);\n R[1, 2] = 2. * (qj * qk - qi * qr)\n R[2, 0] = 2. * (qi * qk - qj * qr);\n R[2, 1] = 2. * (qj * qk + qi * qr);\n R[2, 2] = 1. - 2. * (qi * qi + qj * qj)\n\n return R", "def qwc_rotation(pauli_operators):\n paulis_with_identity = (qml.Identity, qml.PauliX, qml.PauliY, qml.PauliZ)\n if not all(isinstance(element, paulis_with_identity) for element in pauli_operators):\n raise TypeError(\n \"All values of input pauli_operators must be either Identity, PauliX, PauliY, or PauliZ instances,\"\n \" instead got pauli_operators = {}.\".format(pauli_operators)\n )\n\n for pauli in pauli_operators:\n if isinstance(pauli, qml.PauliX):\n qml.RY(-np.pi / 2, wires=pauli.wires)\n\n elif isinstance(pauli, qml.PauliY):\n qml.RX(np.pi / 2, wires=pauli.wires)", "def add_rotation_layer(self, rotation_blocks:Optional[Union[str, cirq.Gate, Callable,\n List[str],List[cirq.Gate],List[Callable],\n List['TemplateCircuitBlock']]] =None):\n rotation_blocks = self._parse_rotation_blocks(rotation_blocks)\n for i, block in enumerate(rotation_blocks):\n if self._reuse_param_per_layer:\n self.reset_index()\n if isinstance(block, TemplateCircuitBlock):\n interaction_graphs = self.get_interaction_graphs(i, block.num_block_qubits)\n for qubits in interaction_graphs:\n if self._reuse_param_per_template:\n self.reset_index()\n block.build(self, qubits)\n else:\n for qubit in range(self.n_qubit):\n gate = self.parameterise_gate(block)\n self.apply_gate_operation(gate, qubit)", "def getRotationTrajectory(self) -> SO3Trajectory:\n return SO3Trajectory(self.times,[m[:9] for m in self.milestones])", "def rotationData(self):\n return [self.detections.rotationTimeTags, self.detections.rotations], self.b1, self.b2", "def intermediateJacPol2Rot(self,x):\n allS = np.sin(x[0,:])\n allC = np.cos(x[0,:])\n allR = x[1,:]\n \n Jac = Idn(x.shape[1],self._dim)\n Jac[:,0,0] = -allS*allR\n Jac[:,0,1] = allC\n Jac[:,1,0] = allC*allR\n Jac[:,1,1] = allS\n return Jac", "def __init__(self, n_qubit:int, copies:int=1,\n rotation_blocks:Optional[Union[str, cirq.Gate, Callable, 'TemplateCircuitBlock',\n List[str],List[cirq.Gate],List[Callable],\n List['TemplateCircuitBlock']]] =None,\n entanglement_blocks:Optional[Union[str, cirq.Gate, Callable, 'TemplateCircuitBlock',\n List[str],List[cirq.Gate],List[Callable],\n List['TemplateCircuitBlock']]] =None,\n entangle_strategy:Optional[Union[str,List[str], Callable[[int,int],List[Tuple[int]]],\n List[Callable[[int,int],List[Tuple[int]]]]]]=None,\n parameter_symbol:str='θ',\n final_rotation_layer:bool=False,\n flatten_circuit:bool=False,\n reuse_param_per_depth:bool=False,\n reuse_param_per_layer:bool=False,\n reuse_param_per_template:bool=False,\n parameter_index:Optional[int]=None,\n parameter_scale=1,\n name:str='ParameterisedCircuit',\n *args, **kwargs):\n super().__init__(n_qubit, name=name, *args, **kwargs)\n self._parameter_symbol = parameter_symbol\n self._parameters = np.array([], dtype=object)\n self._readout_qubit = None\n self._flatten_circuit = flatten_circuit\n self._entangle_strategy = entangle_strategy if entangle_strategy else 'full'\n self._parameter_index = parameter_index\n self._reuse_param_per_depth = reuse_param_per_depth\n self._reuse_param_per_layer = reuse_param_per_layer\n self._reuse_param_per_template = reuse_param_per_template\n self._parameter_scale = parameter_scale \n self.build(rotation_blocks, entanglement_blocks, entangle_strategy, copies,\n final_rotation_layer)", "def representation_2_txyz(self: Q, representation: str = \"\") -> List:\n\n symbolic = False\n\n if (\n hasattr(self.t, \"free_symbols\")\n or hasattr(self.x, \"free_symbols\")\n or hasattr(self.y, \"free_symbols\")\n or hasattr(self.z, \"free_symbols\")\n ):\n symbolic = True\n\n if representation == \"\":\n box_t, box_x, box_y, box_z = self.t, self.x, self.y, self.z\n\n elif representation == \"polar\":\n amplitude, theta_x, theta_y, theta_z = self.t, self.x, self.y, self.z\n\n theta = (theta_x ** 2 + theta_y ** 2 + theta_z ** 2) ** (1 / 2)\n\n if theta == 0:\n box_t = self.t\n box_x, box_y, box_z = 0, 0, 0\n\n else:\n if symbolic:\n box_t = amplitude * sp.cos(theta)\n box_x = self.x / theta * amplitude * sp.sin(theta)\n box_y = self.y / theta * amplitude * sp.sin(theta)\n box_z = self.z / theta * amplitude * sp.sin(theta)\n else:\n box_t = amplitude * math.cos(theta)\n box_x = self.x / theta * amplitude * math.sin(theta)\n box_y = self.y / theta * amplitude * math.sin(theta)\n box_z = self.z / theta * amplitude * math.sin(theta)\n\n elif representation == \"spherical\":\n box_t, R, theta, phi = self.t, self.x, self.y, self.z\n\n if symbolic:\n box_x = R * sp.sin(theta) * sp.cos(phi)\n box_y = R * sp.sin(theta) * sp.sin(phi)\n box_z = R * sp.cos(theta)\n else:\n box_x = R * math.sin(theta) * math.cos(phi)\n box_y = R * math.sin(theta) * math.sin(phi)\n box_z = R * math.cos(theta)\n\n elif representation == \"hyperbolic\":\n u, v, theta, phi = self.t, self.x, self.y, self.z\n\n if symbolic:\n box_t = v * sp.exp(u)\n box_x = v * sp.exp(-u)\n box_y = v * sp.sin(theta) * sp.sin(phi)\n box_z = v * sp.cos(theta)\n\n else:\n box_t = v * math.exp(u)\n box_x = v * math.exp(-u)\n box_y = v * math.sin(theta) * sp.sin(phi)\n box_z = v * math.cos(theta)\n\n else:\n raise ValueError(f\"Oops, don't know representation: representation\")\n\n return [box_t, box_x, box_y, box_z]", "def rotation(self):\n\t\treturn self.piv.a.rotate.v", "def to_revolute_chain(self):\n T_zero = {\"p0\": SE3.identity()}\n ang_lims_map = {}\n old_to_new_names = {\n \"p0\": \"p0\"\n } # Returned for user of the method (to map old joint names to new ones)\n ub, lb = spherical_angle_bounds_to_revolute(self.ub, self.lb)\n count = 1\n joint_prev = \"p0\"\n for (\n joint\n ) in self.d: # Assumes the dictionary is in chain order (perhaps enforce?)\n new_node1 = \"p\" + str(count)\n count += 1\n # ub[new_node1] = self.ub[joint]\n # lb[new_node1] = self.lb[joint]\n ang_lims_map[joint] = new_node1\n\n new_node2 = \"p\" + str(count)\n count += 1\n old_to_new_names[joint] = new_node2\n\n Ry = SE3(SO3(roty(np.pi / 2)), np.zeros(3))\n T_zero[new_node1] = T_zero[joint_prev].dot(Ry)\n d = self.d[joint]\n Ry_back = SE3(SO3(roty(-np.pi / 2)), np.zeros(3))\n T_zero[new_node2] = T_zero[new_node1].dot(Ry_back).dot(trans_axis(d, \"z\"))\n\n joint_prev = new_node2\n\n # for key in T_zero:\n # if key not in ub.keys() and key is not 'p0':\n # ub[key] = np.pi\n # lb[key] = -np.pi\n\n params = {\"T_zero\": T_zero, \"ub\": ub, \"lb\": lb}\n return RobotRevolute(params), old_to_new_names, ang_lims_map", "def rotorconversion(x):\n return cf.MultiVector(layout, val_rotorconversion(x))", "def rotate(self, theta, legs):\n U, onew = rotationTensor(theta, self.symmetries, legs)\n B = U @ self\n new = list(onew)\n old = list(legs)\n if B.internallegs != self.internallegs:\n old.append(self.internallegs[0])\n new.append(B.internallegs[0])\n B.swaplegs({n: o for o, n in zip(old, new)})\n return B.couplingAddapt(self.coupling)", "def __repr__(self):\n # first check for identity quaternion to avoid nans\n if self.real != 1:\n theta = numpy.arccos(self.real)\n angle = 360 * theta / numpy.pi\n xyz = self.pure / numpy.sin(theta)\n else:\n angle = 0.\n xyz = self.pure\n result = \"Transformation: tx ty tz rx ry rz angle\\n %g %g %g %g %g %g %g\" \\\n % (self.trans[0], self.trans[1], self.trans[2],\n xyz[0], xyz[1], xyz[2], angle)\n return result", "def get_Grotations(self, x):\n xsh = x.get_shape().as_list()\n angles = [0.,np.pi/2.,np.pi,3.*np.pi/2.]\n rx = []\n for i in range(4):\n # Z4 rotations about the z axis\n perm = [1,0,2,3]\n y = tf.transpose(x, perm=perm)\n y = tf.contrib.image.rotate(y, angles[i])\n y = tf.transpose(y, perm=perm)\n # Rotations in the quotient space (sphere S^2)\n # i) Z4 rotations about y axis\n for j in range(4):\n perm = [2,1,0,3]\n z = tf.transpose(y, perm=perm)\n z = tf.contrib.image.rotate(z, angles[-j])\n z = tf.transpose(z, perm=perm)\n \n rx.append(z)\n # ii) 2 rotations to the poles about the x axis\n perm = [0,2,1,3]\n z = tf.transpose(y, perm=perm)\n z = tf.contrib.image.rotate(z, angles[3])\n z = tf.transpose(z, perm=perm)\n rx.append(z)\n\n z = tf.transpose(y, perm=perm)\n z = tf.contrib.image.rotate(z, angles[1])\n z = tf.transpose(z, perm=perm)\n rx.append(z)\n\n return rx", "def test_to_rotation(self):\r\n q = np.array([-1, 1, 3, 2])\r\n q = q / np.linalg.norm(q)\r\n R_gt = np.array([\r\n [-1/3., -14/15., -2/15.],\r\n [2/3., -1/3., 2/3.],\r\n [-2/3., 2/15., 11/15.]]).T\r\n R = to_rotation(q)\r\n\r\n zero_matrix = R - R_gt\r\n self.assertAlmostEqual(np.linalg.norm(zero_matrix), 0.0)\r\n\r\n for _ in range(20):\r\n q = np.random.randn(4)\r\n q /= np.linalg.norm(q)\r\n q_inv = quaternion_conjugate(q)\r\n\r\n R = to_rotation(q)\r\n R_inv = to_rotation(q_inv)\r\n\r\n zero_matrix = R @ R_inv - np.identity(3)\r\n self.assertAlmostEqual(np.linalg.norm(zero_matrix), 0.0)\r\n\r\n # orthogonal matrix\r\n zero_matrix = R @ R.T - np.identity(3)\r\n self.assertAlmostEqual(np.linalg.norm(zero_matrix), 0.0)", "def get_rotation(self) -> np.array:\n axis = self.get_arms()[1]\n force = [self.d_x, self.d_y] # \"Force applied on the arm\"\n o_m = [self.target.x_obj - axis.x_obj, self.target.y_obj - axis.y_obj]\n torque = o_m[0]*force[1] - o_m[1] * force[0] # OM vectorial F\n if torque == 1: # Anti clockwise rotation\n rotation = np.array([[0, -1], [1, 0]])\n if torque == -1: # Clockwise rotation\n rotation = np.array([[0, 1], [-1, 0]])\n if torque == 0: # No rotation\n rotation = np.array([[0, 0], [0, 0]])\n return rotation", "def getEllipsYZRotMatrix(a1, a2):\n adir = a2 - a1\n amid = a1 + 0.5 * adir\n kath = np.sqrt((adir[0] * adir[0] + adir[1] * adir[1]) / 4.0)\n octantA2 = octant(a2)\n theta = np.arctan( abs( (adir[2]/2) / kath) )\n #[1, 4, 6, 7 ] => left rotation\n #[2, 3, 5, 8 ] => right rotation\n if octantA2 in [2, 3, 5, 8]: \n theta = -theta \n print \"theta =\" , np.rad2deg(theta)\n RotY = np.matrix( [ [ np.cos(theta), 0.0, np.sin(theta) ],\n [ 0.0 , 1.0, 0.0 ],\n [ -np.sin(theta), 0.0, np.cos(theta) ]\n ]) \n \n psi = np.arctan( abs( adir[1] / adir[0] ) )\n #[2, 4, 6, 8 ] => left rotation\n #[1, 3, 5, 7 ] => right rotation\n if octantA2 in [1, 3, 5, 7]:\n psi = -psi\n print \"psi =\" , np.rad2deg(psi)\n RotZ = np.matrix( [ [ np.cos(psi), -np.sin(psi), 0.0 ],\n [ np.sin(psi), np.cos(psi), 0.0 ],\n [ 0.0 , 0.0 , 1.0 ]\n ])\n return np.asarray( RotY * RotZ )", "def txyz_2_representation(self: Q, representation: str = \"\") -> List:\n\n symbolic = self.is_symbolic()\n\n if representation == \"\":\n rep = [self.t, self.x, self.y, self.z]\n\n elif representation == \"polar\":\n amplitude = (self.t ** 2 + self.x ** 2 + self.y ** 2 + self.z ** 2) ** (\n 1 / 2\n )\n\n abs_v = abs_of_vector(self).t\n\n if symbolic:\n theta = sp.atan2(abs_v, self.t)\n else:\n theta = math.atan2(abs_v, self.t)\n\n if abs_v == 0:\n theta_x, theta_y, theta_z = 0, 0, 0\n\n else:\n theta_x = theta * self.x / abs_v\n theta_y = theta * self.y / abs_v\n theta_z = theta * self.z / abs_v\n\n rep = [amplitude, theta_x, theta_y, theta_z]\n\n elif representation == \"spherical\":\n\n spherical_t = self.t\n\n spherical_r = (self.x ** 2 + self.y ** 2 + self.z ** 2) ** (1 / 2)\n\n if spherical_r == 0:\n theta = 0\n else:\n if symbolic:\n theta = sp.acos(self.z / spherical_r)\n\n else:\n theta = math.acos(self.z / spherical_r)\n\n if symbolic:\n phi = sp.atan2(self.y, self.x)\n else:\n phi = math.atan2(self.y, self.x)\n\n rep = [spherical_t, spherical_r, theta, phi]\n\n else:\n raise ValueError(f\"Oops, don't know representation: representation\")\n\n return rep", "def intermediateJacRot2Polar(self,x):\n r = cNorm(x[:2,:],kd=False)\n x0overr = x[0,:]/r\n x1overr = x[1,:]/r\n\n Jac = Idn(x.shape[1],x.shape[0])\n Jac[:,0,0] = -x1overr\n Jac[:,0,1] = x0overr\n Jac[:,1,0] = x0overr\n Jac[:,1,1] = x1overr\n \n return Jac", "def __init__(self, XY_rotations, lines_2Q, n_qubits):\n self.XY_rotations = XY_rotations\n self.lines_2Q = lines_2Q\n self.n_qubits = n_qubits\n dim_depth, dim_qubits, dim_XY = self.XY_rotations.shape\n self.depth = 1+2*len(lines_2Q)\n # XY rotations vector does not match the depth\n if not((2*dim_depth-1) == self.depth):\n raise ValueError('XY rotations vector does not match the depth')\n # XY rotations vector does not match the qubit number\n if not(dim_qubits == n_qubits):\n raise ValueError(\n 'XY rotations vector does not match the qubit number')\n # XY rotations vector does not match the parameter number\n if not(dim_XY == 2):\n raise ValueError(\n 'XY rotations vector does not match the parameter number')", "def _make_circuit_instructions(n_qubits, depth, type_circuit):\n\n if type_circuit in [0, 1, 2]:\n\n # if type_circuit == 1:\n # if depth > 8:\n # raise ValueError(\n # \"For type-1 circuits, only at most depth=8 allowed!\"\n # )\n\n # define rotations for circuit in each layer, 0: identity, 1:X, 2:Y 3:Z\n ini_pauli = np.zeros([depth, n_qubits], dtype=int)\n\n # set first and second layer, rest comes later\n ini_pauli[0, :] = 2 # y rotation\n if depth > 1:\n ini_pauli[1, :] = 3 # z rotation\n\n # construct natural parameterized circuit\n # gives which type of entangling gates at each layer -- first entry is\n # first qubit index, second is second qubit index, third entry is type\n # of entangling gate\n entangling_gate_index_list = [[] for i in range(depth)]\n orderList = []\n for i in range(n_qubits//2):\n if i % 2 == 0:\n orderList.append(i//2)\n else:\n orderList.append((n_qubits-i)//2)\n\n if n_qubits > 1:\n shiftList = [orderList[0]]\n else:\n shiftList = []\n for i in range(1, n_qubits//2):\n shiftList.append(orderList[i])\n shiftList += shiftList[:-1]\n\n # this list gives which entangling gates are applied in which layer\n if type_circuit == 0:\n # deep natural PQC, includes non-nearest neighbor gates\n for j in range(min(len(shiftList), int(np.ceil(depth/2))-1)):\n entangling_gate_index_list[1+2*j] = [\n [2*i, (2*i+1+2*shiftList[j]) % n_qubits, 0]\n for i in range(n_qubits//2)\n ]\n elif type_circuit == 1:\n # only do 2 entangling layers at max, and only do gates with\n # nearest neighbor and no ring\n for j in range(min(len(shiftList), 3)):\n if j == 0:\n entangling_gate_index_list[1+2*j] = [\n [2*i, (2*i+1+2*shiftList[j]) % n_qubits, 0]\n for i in range(n_qubits//2)\n ]\n elif (j == 1 or j == 2):\n # exclude ring gate and gate 0,1 on third entangling layer\n entangling_gate_index_list[1+2*j] = [\n [2*i, (2*i+1+2*shiftList[j]) % n_qubits, 0]\n for i in range(1, n_qubits//2)\n ]\n\n elif type_circuit == 2:\n # only do 3 regular entangling layers in a ring topology, then two\n # more phase gates with next-nearst neighbor, which requires one\n # swap. This adds 4 more parameters\n for j in range(min(len(shiftList), 3)):\n entangling_gate_index_list[1+2*j] = [\n [2*i, (2*i+1+2*shiftList[j]) % n_qubits, 0]\n for i in range(n_qubits//2)\n ]\n # entangling_gate_index_list[1+2*3]=[[0,n_qubits-1,1],[0,1,0],[n_qubits-1,n_qubits-2,0]]\n # entangling_gate_index_list[1+2*3]=[[0,n_qubits-1,1],[0,1,0],[n_qubits-1,n_qubits-2,0]]\n entangling_gate_index_list[1+2*3] = [\n [n_qubits-1, 1, 0],\n [0, n_qubits-2, 0]\n ]\n\n for i in range(len(entangling_gate_index_list)-1):\n if len(entangling_gate_index_list[i]) > 0:\n for j in range(len(entangling_gate_index_list[i])):\n qubit_index = entangling_gate_index_list[i][j][0]\n ini_pauli[i+1, qubit_index] = 2\n if i+2 < depth:\n ini_pauli[i+2, qubit_index] = 3\n\n elif type_circuit == 3:\n\n ini_pauli = np.ones([depth, n_qubits], dtype=int)*2\n\n for i in range(1, depth, 2):\n ini_pauli[i, :] = 3\n\n if n_qubits % 2 == 0:\n # even qubits ALT circuit needs to get rid of boundary rotations at\n # even entangling layers\n for i in range(4, depth, 4):\n ini_pauli[i, 0] = 0\n ini_pauli[i, -1] = 0\n if i+1 < depth:\n ini_pauli[i+1, 0] = 0\n ini_pauli[i+1, -1] = 0\n else:\n # for odd qubits, get rid of boundary either on top or bottom qubit\n for i in range(2, depth, 4):\n ini_pauli[i, -1] = 0\n if i+1 < depth:\n ini_pauli[i+1, -1] = 0\n for i in range(4, depth, 4):\n ini_pauli[i, 0] = 0\n if i+1 < depth:\n ini_pauli[i+1, 0] = 0\n\n # CNOT entangling gates\n entangling_gate_index_list = [[] for i in range(depth)]\n counter = 0\n # third index indicates type of entangling gate\n for k in range(1, depth-1, 2):\n\n # place entangler every second layer, do not place any at last\n if counter % 2 == 0:\n # even layer\n entangling_gate_index_list[k] = [\n [2*j, 2*j+1, 1] for j in range(n_qubits//2)\n ]\n else:\n # odd layer\n entangling_gate_index_list[k] = [\n [2*j+1, 2*j+2, 1] for j in range((n_qubits-1)//2)\n ]\n counter += 1\n\n else:\n raise ValueError('type_circuit='+f'{type_circuit}'+' not recognised.')\n\n return ini_pauli, entangling_gate_index_list", "def rotation(self):\n return self.transform.getRotation() + [0]", "def _rotate_quaternion(self, q):\n self._normalise()\n return self * q * self.conjugate", "def __repr__(self):\n return \"Quaternion({}, {}, {}, {})\".format(repr(self.q[0]), repr(self.q[1]), repr(self.q[2]), repr(self.q[3]))" ]

[ "0.63733256", "0.6243695", "0.61284345", "0.59969985", "0.59389025", "0.5919403", "0.5793986", "0.5788567", "0.57774144", "0.5774565", "0.57473123", "0.57306886", "0.5724324", "0.57041705", "0.5641081", "0.56394804", "0.5630439", "0.5608946", "0.5591003", "0.55356807", "0.5504258", "0.5492301", "0.5478781", "0.5455895", "0.54513836", "0.543862", "0.5429372", "0.5428642", "0.53663313", "0.536328" ]

[ "def getEllipsYZRotMatrix(a1, a2):\n adir = a2 - a1\n amid = a1 + 0.5 * adir\n kath = np.sqrt((adir[0] * adir[0] + adir[1] * adir[1]) / 4.0)\n octantA2 = octant(a2)\n theta = np.arctan( abs( (adir[2]/2) / kath) )\n #[1, 4, 6, 7 ] => left rotation\n #[2, 3, 5, 8 ] => right rotation\n if octantA2 in [2, 3, 5, 8]: \n theta = -theta \n print \"theta =\" , np.rad2deg(theta)\n RotY = np.matrix( [ [ np.cos(theta), 0.0, np.sin(theta) ],\n [ 0.0 , 1.0, 0.0 ],\n [ -np.sin(theta), 0.0, np.cos(theta) ]\n ]) \n \n psi = np.arctan( abs( adir[1] / adir[0] ) )\n #[2, 4, 6, 8 ] => left rotation\n #[1, 3, 5, 7 ] => right rotation\n if octantA2 in [1, 3, 5, 7]:\n psi = -psi\n print \"psi =\" , np.rad2deg(psi)\n RotZ = np.matrix( [ [ np.cos(psi), -np.sin(psi), 0.0 ],\n [ np.sin(psi), np.cos(psi), 0.0 ],\n [ 0.0 , 0.0 , 1.0 ]\n ])\n return np.asarray( RotY * RotZ )", "def txyz_2_representation(self: Q, representation: str = \"\") -> List:\n\n symbolic = self.is_symbolic()\n\n if representation == \"\":\n rep = [self.t, self.x, self.y, self.z]\n\n elif representation == \"polar\":\n amplitude = (self.t ** 2 + self.x ** 2 + self.y ** 2 + self.z ** 2) ** (\n 1 / 2\n )\n\n abs_v = abs_of_vector(self).t\n\n if symbolic:\n theta = sp.atan2(abs_v, self.t)\n else:\n theta = math.atan2(abs_v, self.t)\n\n if abs_v == 0:\n theta_x, theta_y, theta_z = 0, 0, 0\n\n else:\n theta_x = theta * self.x / abs_v\n theta_y = theta * self.y / abs_v\n theta_z = theta * self.z / abs_v\n\n rep = [amplitude, theta_x, theta_y, theta_z]\n\n elif representation == \"spherical\":\n\n spherical_t = self.t\n\n spherical_r = (self.x ** 2 + self.y ** 2 + self.z ** 2) ** (1 / 2)\n\n if spherical_r == 0:\n theta = 0\n else:\n if symbolic:\n theta = sp.acos(self.z / spherical_r)\n\n else:\n theta = math.acos(self.z / spherical_r)\n\n if symbolic:\n phi = sp.atan2(self.y, self.x)\n else:\n phi = math.atan2(self.y, self.x)\n\n rep = [spherical_t, spherical_r, theta, phi]\n\n else:\n raise ValueError(f\"Oops, don't know representation: representation\")\n\n return rep", "def one_qubit_rotation(self, qubit, symbols):\n # print(symbols, \"hi\")\n return [cirq.rx(symbols[0])(qubit),\n cirq.ry(symbols[1])(qubit),\n cirq.rz(symbols[2])(qubit)]", "def two_qubit_rotation(self, bits, symbols):\n circuit = cirq.Circuit()\n circuit += cirq.Circuit(self.one_qubit_rotation(bits[0], symbols[0:3]))\n circuit += cirq.Circuit(self.one_qubit_rotation(bits[1], symbols[3:6]))\n circuit += [cirq.ZZ(*bits)**symbols[6]]\n circuit += [cirq.YY(*bits)**symbols[7]]\n circuit += [cirq.XX(*bits)**symbols[8]]\n circuit += cirq.Circuit(self.one_qubit_rotation(bits[0], symbols[9:12]))\n circuit += cirq.Circuit(self.one_qubit_rotation(bits[1], symbols[12:]))\n return circuit", "def qwc_rotation(pauli_operators):\n paulis_with_identity = (qml.Identity, qml.PauliX, qml.PauliY, qml.PauliZ)\n if not all(isinstance(element, paulis_with_identity) for element in pauli_operators):\n raise TypeError(\n \"All values of input pauli_operators must be either Identity, PauliX, PauliY, or PauliZ instances,\"\n \" instead got pauli_operators = {}.\".format(pauli_operators)\n )\n\n for pauli in pauli_operators:\n if isinstance(pauli, qml.PauliX):\n qml.RY(-np.pi / 2, wires=pauli.wires)\n\n elif isinstance(pauli, qml.PauliY):\n qml.RX(np.pi / 2, wires=pauli.wires)", "def representation_2_txyz(self: Q, representation: str = \"\") -> List:\n\n symbolic = False\n\n if (\n hasattr(self.t, \"free_symbols\")\n or hasattr(self.x, \"free_symbols\")\n or hasattr(self.y, \"free_symbols\")\n or hasattr(self.z, \"free_symbols\")\n ):\n symbolic = True\n\n if representation == \"\":\n box_t, box_x, box_y, box_z = self.t, self.x, self.y, self.z\n\n elif representation == \"polar\":\n amplitude, theta_x, theta_y, theta_z = self.t, self.x, self.y, self.z\n\n theta = (theta_x ** 2 + theta_y ** 2 + theta_z ** 2) ** (1 / 2)\n\n if theta == 0:\n box_t = self.t\n box_x, box_y, box_z = 0, 0, 0\n\n else:\n if symbolic:\n box_t = amplitude * sp.cos(theta)\n box_x = self.x / theta * amplitude * sp.sin(theta)\n box_y = self.y / theta * amplitude * sp.sin(theta)\n box_z = self.z / theta * amplitude * sp.sin(theta)\n else:\n box_t = amplitude * math.cos(theta)\n box_x = self.x / theta * amplitude * math.sin(theta)\n box_y = self.y / theta * amplitude * math.sin(theta)\n box_z = self.z / theta * amplitude * math.sin(theta)\n\n elif representation == \"spherical\":\n box_t, R, theta, phi = self.t, self.x, self.y, self.z\n\n if symbolic:\n box_x = R * sp.sin(theta) * sp.cos(phi)\n box_y = R * sp.sin(theta) * sp.sin(phi)\n box_z = R * sp.cos(theta)\n else:\n box_x = R * math.sin(theta) * math.cos(phi)\n box_y = R * math.sin(theta) * math.sin(phi)\n box_z = R * math.cos(theta)\n\n elif representation == \"hyperbolic\":\n u, v, theta, phi = self.t, self.x, self.y, self.z\n\n if symbolic:\n box_t = v * sp.exp(u)\n box_x = v * sp.exp(-u)\n box_y = v * sp.sin(theta) * sp.sin(phi)\n box_z = v * sp.cos(theta)\n\n else:\n box_t = v * math.exp(u)\n box_x = v * math.exp(-u)\n box_y = v * math.sin(theta) * sp.sin(phi)\n box_z = v * math.cos(theta)\n\n else:\n raise ValueError(f\"Oops, don't know representation: representation\")\n\n return [box_t, box_x, box_y, box_z]", "def __init__(self, rotations_1Q, lines_2Q, n_qubits):\n self.rotations_1Q = rotations_1Q\n self.lines_2Q = lines_2Q\n self.n_qubits = n_qubits\n dim_depth, dim_qubits, dim_rot = self.rotations_1Q.shape\n self.depth = 1+2*len(lines_2Q)\n # 1Q rotations vector does not match the depth\n if not((2*dim_depth-1) == self.depth):\n raise ValueError('1Q rotations vector does not match the depth')\n # 1Q rotations vector does not match the qubit number\n if not(dim_qubits == n_qubits):\n raise ValueError(\n '1Q rotations vector does not match the qubit number')\n # 1Q rotations vector does not match the parameter number\n if not(dim_rot == 4):\n raise ValueError(\n '1Q rotations vector does not match the parameter number')", "def vector_arrows(Out, x, y, z, plot_layer):\n\n x = sort_dim(x)\n y = sort_dim(y)\n z = sort_dim(z)\n\n # length of array in each dimension\n Ny = len(y)-1\n Nx = len(x)-1\n Nz = len(z)-1\n\n # coordinates of cell centres\n # (halfway between L and R edges)\n xm = 0.5 * (x[:-1] + x[1:])\n ym = 0.5 * (y[:-1] + y[1:])\n zm = 0.5 * (z[:-1] + z[1:])\n\n # create empty arrays for output\n U = np.zeros((len(Out.Qx[:,0,0,0]),len(Out.Qx[0,:,0,0]),len(Out.Qx[0,0,:,0]),len(Out.Qx[0,0,0,:])+1)) \n V = np.zeros((len(Out.Qy[:,0,0,0]),len(Out.Qy[0,:,0,0]),len(Out.Qy[0,0,:,0])+1,len(Out.Qy[0,0,0,:])))\n W = np.zeros((len(Out.Qz[:,0,0,0]),len(Out.Qz[0,:,0,0])+1,len(Out.Qz[0,0,:,0]),len(Out.Qz[0,0,0,:])))\n\n # create mesh\n X, Y, = np.meshgrid(xm, ym) # coordinates of cell centers\n Z = np.meshgrid(zm)\n\n # iterate through timesteps\n for t in range(len(Out.Qy[:,0,0,0])): # number of timesteps\n\n #grab relevant timestep from Out array\n Qx = Out.Qx[t,:,:,:]\n Qy = Out.Qy[t,:,:,:]\n Qz = Out.Qz[t,:,:,:]\n\n # Calculate flows at cell centers by interpolating between L and R faces\n Ut = np.concatenate((Qx[plot_layer, :, 0].reshape((1, Ny, 1)), \\\n 0.5 * (Qx[plot_layer, :, :-1].reshape((1, Ny, Nx-2)) +\\\n Qx[plot_layer, :, 1: ].reshape((1, Ny, Nx-2))), \\\n Qx[plot_layer, :, -1].reshape((1, Ny, 1))), axis=2).reshape((Ny,Nx))\n\n Vt = np.concatenate((Qy[plot_layer, 0, :].reshape((1, 1, Nx)), \\\n 0.5 * (Qy[plot_layer, :-1, :].reshape((1, Ny-2, Nx)) +\\\n Qy[plot_layer, 1:, :].reshape((1, Ny-2, Nx))), \\\n Qy[plot_layer, -1, :].reshape((1, 1, Nx))), axis=1).reshape((Ny,Nx))\n\n # average flow across vertical cell to get z flow at cell centre\n QzTop = Qz[0:-1,:,:]\n QzBot = Qz[1:,:,:]\n Wt = (QzTop+QzBot)/2\n \n # add results to output arrays\n U[t,:,:,:] = Ut\n V[t,:,:,:] = Vt\n W[t,1:-1,:,:] = Wt\n\n return X,Y,Z,U,V,W", "def intermediateJacPol2Rot(self,x):\n allS = np.sin(x[0,:])\n allC = np.cos(x[0,:])\n allR = x[1,:]\n \n Jac = Idn(x.shape[1],self._dim)\n Jac[:,0,0] = -allS*allR\n Jac[:,0,1] = allC\n Jac[:,1,0] = allC*allR\n Jac[:,1,1] = allS\n return Jac", "def test_rot_decomposition(self, diff_method):\r\n dev = qml.device(\"default.qubit\", wires=1)\r\n\r\n def circuit(weights):\r\n qml.Rot(weights[0], weights[1], weights[2], wires=0)\r\n return qml.expval(qml.PauliX(0))\r\n\r\n circuit = qml.QNode(circuit, dev, diff_method=diff_method)\r\n params = np.array([1.0, 2.0, 3.0])\r\n tapes = qml.metric_tensor(circuit, only_construct=True)(params)\r\n assert len(tapes) == 3\r\n\r\n # first parameter subcircuit\r\n assert len(tapes[0].operations) == 0\r\n\r\n # Second parameter subcircuit\r\n assert len(tapes[1].operations) == 4\r\n assert isinstance(tapes[1].operations[0], qml.RZ)\r\n assert tapes[1].operations[0].data == [1]\r\n # PauliY decomp\r\n assert isinstance(tapes[1].operations[1], qml.PauliZ)\r\n assert isinstance(tapes[1].operations[2], qml.S)\r\n assert isinstance(tapes[1].operations[3], qml.Hadamard)\r\n\r\n # Third parameter subcircuit\r\n assert len(tapes[2].operations) == 2\r\n assert isinstance(tapes[2].operations[0], qml.RZ)\r\n assert isinstance(tapes[2].operations[1], qml.RY)\r\n assert tapes[2].operations[0].data == [1]\r\n assert tapes[2].operations[1].data == [2]\r\n\r\n result = qml.metric_tensor(circuit)(params)\r\n assert result.shape == (3, 3)", "def intermediateJacRot2Polar(self,x):\n r = cNorm(x[:2,:],kd=False)\n x0overr = x[0,:]/r\n x1overr = x[1,:]/r\n\n Jac = Idn(x.shape[1],x.shape[0])\n Jac[:,0,0] = -x1overr\n Jac[:,0,1] = x0overr\n Jac[:,1,0] = x0overr\n Jac[:,1,1] = x1overr\n \n return Jac", "def Rotation_EQJ_ECL():\n # ob = mean obliquity of the J2000 ecliptic = 0.40909260059599012 radians.\n c = 0.9174821430670688 # cos(ob)\n s = 0.3977769691083922 # sin(ob)\n return RotationMatrix([\n [ 1, 0, 0],\n [ 0, +c, -s],\n [ 0, +s, +c]\n ])", "def get_Grotations(self, x):\n xsh = x.get_shape().as_list()\n angles = [0.,np.pi/2.,np.pi,3.*np.pi/2.]\n rx = []\n for i in range(4):\n # Z4 rotations about the z axis\n perm = [1,0,2,3]\n y = tf.transpose(x, perm=perm)\n y = tf.contrib.image.rotate(y, angles[i])\n y = tf.transpose(y, perm=perm)\n # Rotations in the quotient space (sphere S^2)\n # i) Z4 rotations about y axis\n for j in range(4):\n perm = [2,1,0,3]\n z = tf.transpose(y, perm=perm)\n z = tf.contrib.image.rotate(z, angles[-j])\n z = tf.transpose(z, perm=perm)\n \n rx.append(z)\n # ii) 2 rotations to the poles about the x axis\n perm = [0,2,1,3]\n z = tf.transpose(y, perm=perm)\n z = tf.contrib.image.rotate(z, angles[3])\n z = tf.transpose(z, perm=perm)\n rx.append(z)\n\n z = tf.transpose(y, perm=perm)\n z = tf.contrib.image.rotate(z, angles[1])\n z = tf.transpose(z, perm=perm)\n rx.append(z)\n\n return rx", "def z_rotation(self):\n before = ('R', 'r', 'U', 'u', 'L', 'l', 'D', 'd', 'M', 'E', 'x', 'y')\n after = ('U', 'u', 'L', 'l', 'D', 'd', 'R', 'r', 'E', 'M\\'', \"y\", \"x'\")\n solve = self.solve_helper.maketrans(dict(zip(before, after)))\n solve_trans = self.solve_helper.translate(solve)\n solve_trans = solve_trans.replace(\"\\'\\'\", \"\")\n self.solve_helper = solve_trans", "def T(self):\n\n # Calculate the direction cosines for the local x-axis\n # The local x-axis will run from the i-node to the j-node\n xi = self.i_node.X\n xj = self.j_node.X\n yi = self.i_node.Y\n yj = self.j_node.Y\n zi = self.i_node.Z\n zj = self.j_node.Z\n x = [(xj - xi), (yj - yi), (zj - zi)]\n x = x/norm(x)\n \n # The local y-axis will be in the plane of the plate\n # Find a vector in the plate's local xy plane\n xn = self.n_node.X\n yn = self.n_node.Y\n zn = self.n_node.Z\n xy = [xn - xi, yn - yi, zn - zi]\n\n # Find a vector perpendicular to the plate surface to get the orientation of the local z-axis\n z = cross(x, xy)\n \n # Divide the vector by its magnitude to produce a unit z-vector of direction cosines\n z = z/norm(z)\n\n # Calculate the local y-axis as a vector perpendicular to the local z and x-axes\n y = cross(z, x)\n \n # Divide the z-vector by its magnitude to produce a unit vector of direction cosines\n y = y/norm(y)\n\n # Create the direction cosines matrix\n dirCos = array([x, y, z])\n \n # Build the transformation matrix\n transMatrix = zeros((24, 24))\n transMatrix[0:3, 0:3] = dirCos\n transMatrix[3:6, 3:6] = dirCos\n transMatrix[6:9, 6:9] = dirCos\n transMatrix[9:12, 9:12] = dirCos\n transMatrix[12:15, 12:15] = dirCos\n transMatrix[15:18, 15:18] = dirCos\n transMatrix[18:21, 18:21] = dirCos\n transMatrix[21:24, 21:24] = dirCos\n \n return transMatrix", "def rotorconversion(x):\n return cf.MultiVector(layout, val_rotorconversion(x))", "def Rot_layer(self, w):\n for idx, element in enumerate(w):\n qml.Rot(element[0], element[1], element[2], wires=idx)", "def _tk1_to_rotations(a: float, b: float, c: float) -> Circuit:\n circ = Circuit(1)\n circ.Rz(c, 0).Rx(b, 0).Rz(a, 0)\n return circ", "def _cubelet_rotation_matrix(self, cubelet_meta_info, qpos_array):\n euler_angles = qpos_array[cubelet_meta_info[\"euler_qpos\"]]\n return rotation.euler2mat(euler_angles)", "def Rotation_ECL_EQJ():\n # ob = mean obliquity of the J2000 ecliptic = 0.40909260059599012 radians.\n c = 0.9174821430670688 # cos(ob)\n s = 0.3977769691083922 # sin(ob)\n return RotationMatrix([\n [ 1, 0, 0],\n [ 0, +c, +s],\n [ 0, -s, +c]\n ])", "def rotations4(polycube, axis):\r\n for i in range(4):\r\n yield rot90(polycube, i, axis)", "def input_system():\n vx = a.odometry_data[:, 2:3] # linear velocity_y [m/s]\n vy = a.odometry_data[:, 1:2] # linear velocity_x [m/s]\n v = np.add(vx, vy)\n v = np.true_divide(v, 2) # combined velocity [m/s]\n yawrate = np.reshape(a.odometry_data[:, 3], (-1, 1)) # angular_z [rad/s]\n u = np.reshape([v, yawrate], (-1, 2))\n return u", "def __init__(self, name, times, x, y, z):\n x = numpy.array(x)\n y = numpy.array(y)\n z = numpy.array(z)\n assert len(x.shape) == 1\n assert len(y.shape) == 1\n assert len(z.shape) == 1\n roll, pitch, yaw = z, y, x # first (resp. last) coordinate in EulerAnglesZyx is yaw (resp. roll)\n cr, cp, cy = numpy.cos(roll / 2.), numpy.cos(pitch / 2.), numpy.cos(yaw / 2.)\n sr, sp, sy = numpy.sin(roll / 2.), numpy.sin(pitch / 2.), numpy.sin(yaw / 2.)\n q_w = cr * cp * cy + sr * sp * sy\n q_x = sr * cp * cy - cr * sp * sy\n q_y = cr * sp * cy + sr * cp * sy\n q_z = cr * cp * sy - sr * sp * cy\n self.roll = roll\n self.pitch = pitch\n self.yaw = yaw\n super(EulerAnglesZyxSignal, self).__init__(name, times, q_w, q_x, q_y, q_z)", "def rotate(self, theta, legs):\n U, onew = rotationTensor(theta, self.symmetries, legs)\n B = U @ self\n new = list(onew)\n old = list(legs)\n if B.internallegs != self.internallegs:\n old.append(self.internallegs[0])\n new.append(B.internallegs[0])\n B.swaplegs({n: o for o, n in zip(old, new)})\n return B.couplingAddapt(self.coupling)", "def make_oneq_cliffords():\n ixyz_list = [g().to_matrix() for g in (IGate, XGate, YGate, ZGate)]\n ih_list = [g().to_matrix() for g in (IGate, HGate)]\n irs_list = [\n IGate().to_matrix(),\n SdgGate().to_matrix() @ HGate().to_matrix(),\n HGate().to_matrix() @ SGate().to_matrix(),\n ]\n oneq_cliffords = [\n Operator(ixyz @ ih @ irs) for ixyz in ixyz_list for ih in ih_list for irs in irs_list\n ]\n return oneq_cliffords", "def circuit():\n np.random.seed(1967)\n for gates in gates_per_layers:\n for gate in gates:\n qml.apply(gate)\n return qml.expval(qml.PauliZ(0))", "def generate(self):\n inside = self.crystal.is_inside(self.x,self.y,self.z)\n X = np.vstack((self.x[inside],self.y[inside],self.z[inside]))\n return self.rot.rotate(X)", "def get_rotation(self) -> np.array:\n axis = self.get_arms()[1]\n force = [self.d_x, self.d_y] # \"Force applied on the arm\"\n o_m = [self.target.x_obj - axis.x_obj, self.target.y_obj - axis.y_obj]\n torque = o_m[0]*force[1] - o_m[1] * force[0] # OM vectorial F\n if torque == 1: # Anti clockwise rotation\n rotation = np.array([[0, -1], [1, 0]])\n if torque == -1: # Clockwise rotation\n rotation = np.array([[0, 1], [-1, 0]])\n if torque == 0: # No rotation\n rotation = np.array([[0, 0], [0, 0]])\n return rotation", "def __init__(self, euler_1Q, lines_2Q, n_qubits):\n self.euler_1Q = euler_1Q\n self.lines_2Q = lines_2Q\n self.n_qubits = n_qubits\n dim_depth, dim_qubits, dim_euler = self.euler_1Q.shape\n self.depth = 1+2*len(lines_2Q)\n # euler angles vector does not match the depth\n if not((2*dim_depth-1) == self.depth):\n raise ValueError('euler angles vector does not match the depth')\n # euler angles vector does not match the qubit number\n if not(dim_qubits == n_qubits):\n raise ValueError(\n 'euler angles vector does not match the qubit number')\n # euler angles vector does not match the parameter number\n if not(dim_euler == 3):\n raise ValueError(\n 'euler angles vector does not match the parameter number')", "def ik3(xyz_array):\n # Eqn 1\n theta_1 = np.arctan2(xyz_array[1], xyz_array[0])\n # Eqn 2\n r1 = np.hypot(xyz_array[0], xyz_array[1])\n # Eqn 3\n r2 = xyz_array[2] - link_lengths[0]\n # Eqn 4\n phi2 = np.arctan2(r2, r1)\n # Eqn 5\n r3 = np.hypot(r1, r2)\n # Eqn 6\n num6 = np.power(link_lengths[2], 2) - \\\n np.power(link_lengths[1], 2) - np.power(r3, 2)\n den6 = -2 * link_lengths[1] * r3\n phi1 = np.arccos(num6 / den6)\n # Eqn 7\n # theta_2 = phi2 - phi1 # elbow down\n theta_2 = phi2 + phi1\n # Eqn 8\n num8 = np.power(r3, 2) - \\\n np.power(link_lengths[1], 2) - np.power(link_lengths[2], 2)\n den8 = -2 * link_lengths[1] * link_lengths[2]\n phi3 = np.arccos(num8 / den8)\n # Eqn 9\n # theta_3 = pi - phi3 # elbow down\n theta_3 = -(np.pi - phi3)\n # Output Joint Angles\n theta_1 = np.rad2deg(theta_1)\n theta_2 = np.rad2deg(theta_2)\n theta_3 = np.rad2deg(theta_3)\n joint_rotations = np.array([theta_1, theta_2, theta_3])\n return joint_rotations" ]

[ "0.5938358", "0.5937187", "0.59367967", "0.5919371", "0.57940376", "0.56724787", "0.5659674", "0.5651457", "0.5649507", "0.55863035", "0.55385494", "0.5521582", "0.5468761", "0.5432579", "0.5426138", "0.5414661", "0.5390122", "0.5376509", "0.5373534", "0.5363947", "0.53566766", "0.5331303", "0.5328344", "0.53211504", "0.52783394", "0.5239268", "0.5230893", "0.52231055", "0.5220119", "0.521671" ]

[ "def test_input_transposed_vector(multiple_linear_regression_data):\n X, y = multiple_linear_regression_data\n x = X.copy().T\n y = pd.DataFrame(y)\n\n # There is a difference with a transposed array\n with pytest.raises(\n AssertionError, match=r\"N >= K: You need at least as many rows .*\"\n ):\n _ = multiple_linear_regression(x, y)", "def check_all(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim):\n\tcheck_dimensions(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim)\n\tcheck_coords(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim)\n\tcheck_consistent(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim)\n\tcheck_type(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim)\n\t#check_transposed(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim)", "def check_type(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim):\n\tassert type(X) == xr.DataArray, 'XCast requires a dataset to be of type \"Xarray.DataArray\"'", "def __check_2d_and_reshape(X):\n if len(X.shape) == 1:\n X = np.reshape(X, (-1, X.shape[0]))\n return X", "def _validate_X(X):\n return X if not isinstance(X, pd.DataFrame) else X.as_matrix()", "def test_feature_format(X):\r\n print(\"test_feature_format()...\", end = \"\")\r\n for row in range(len(X)):\r\n for col in range(len(X[0])):\r\n assert (isinstance(X[row][col], float) == True)\r\n print(\"Passed!\")", "def _validate_X_predict(self, X):\n # X = check_array(X, ensure_2d=False)\n X = np.atleast_2d(X)\n n_features = X.shape[1]\n if self.n_features_in_ != n_features:\n raise ValueError(\n f\"Number of features of the model must match the input. Model n_features_in_ is {self.n_features_in_} and input n_features is {n_features}. Reshape your data.\"\n )", "def check_coords(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim):\n\tassert x_lat_dim in X.coords.keys(), 'XCast requires a dataset_lat_dim to be a coordinate on X'\n\tassert x_lon_dim in X.coords.keys(), 'XCast requires a dataset_lon_dim to be a coordinate on X'\n\tassert x_sample_dim in X.coords.keys(), 'XCast requires a dataset_sample_dim to be a coordinate on X'\n\tassert x_feature_dim in X.coords.keys(), 'XCast requires a dataset_feature_dim to be a coordinate on X'", "def check_conv_transpose(extract):\n call = extract\n if isinstance(call, tvm.relay.expr.TupleGetItem):\n call = call.tuple_value\n elif call.op.name == \"nn.relu\":\n call = call.args[0]\n if isinstance(call, tvm.relay.expr.TupleGetItem):\n call = call.tuple_value\n elif call.op.name == \"clip\":\n if call.attrs[\"a_min\"] != 0.0 or call.attrs[\"a_max\"] != 6.0:\n return False\n call = call.args[0]\n if isinstance(call, tvm.relay.expr.TupleGetItem):\n call = call.tuple_value\n\n while call.op.name != \"nn.conv2d_transpose\":\n call = call.args[0]\n\n attrs = call.attrs\n if attrs.data_layout != \"NCHW\":\n return False\n\n return True", "def transpose(X):\n if len(X.shape) == 1:\n return X\n else:\n Xt = zeros((X.shape[1], X.shape[0]))\n for i in range(X.shape[0]):\n for j in range(X.shape[1]):\n Xt[j][i] = X[i][j]\n\n\n return Xt", "def transform(self, X):\n X = np.asarray(X)\n if X.shape[1:] != self.features_shape_:\n raise ValueError(\"Shape of X used in fit and transform must be \" \"same\")\n return X.reshape(len(X), -1)", "def _need_transpose(expr_matrix, adj_matrix):\n return expr_matrix.shape[1] != adj_matrix.shape[0]", "def _check_input(self, X):\n symbols = np.concatenate(X)\n if len(symbols) == 1: # not enough data\n raise ValueError(\"expected at least 1 observation \"\n \"but none found.\")\n elif (symbols < 0).any(): # contains negative integers\n raise ValueError(\"expected non-negative features \"\n \"for each observation.\")\n elif X.shape[1] > 1: # contains to many features\n raise ValueError(\"expected only 1 feature but got {0} \"\n \"for each observation.\".format(X.shape[1]))\n else:\n return True", "def _validate_X_predict(self, X, check_input=True):\n if check_input:\n X = check_array(X, dtype=DTYPE, accept_sparse=\"csr\")\n if issparse(X) and (X.indices.dtype != np.intc or\n X.indptr.dtype != np.intc):\n raise ValueError(\"No support for np.int64 index based \"\n \"sparse matrices\")\n\n n_features = X.shape[1]\n # if self.n_features_ != n_features:\n # raise ValueError(\"Number of features of the model must \"\n # \"match the input. Model n_features is %s and \"\n # \"input n_features is %s \"\n # % (self.n_features_, n_features))\n\n return X", "def check_consistent_X(self, X):\n # X must be ndarray-type\n if not isinstance(X, np.ndarray):\n X = np.array(X)\n\n return X", "def _validate_XY(X, Y):\n try:\n for inp in [X, Y]:\n assert isinstance(inp, torch.Tensor)\n assert inp.dtype is torch.float or inp.dtype is torch.double\n assert len(inp.shape) == 2\n assert X.dtype is Y.dtype\n assert X.shape[0] == Y.shape[0]\n except AssertionError:\n raise AttributeError(\n \"invalid inputs: X and Y should be float/double tensors of shape \"\n \"(n, d) and (n, m) respectively, where n is the number of samples, \"\n \"d is the number of features, and m is the number of outputs\"\n )", "def _validate_input(self, x, y):\n\n x, y = check_X_y(x, y, accept_sparse=[\"csr\", \"csc\", \"coo\"],\n multi_output=True, y_numeric=True)\n return x, y.ravel()", "def test_xy(self):\n x = np.array([[1,3], [2,8], [1,3]])\n y = np.array([1,1,-1])\n lro = LogisticRegressionOptimiser(x,y)\n expected = np.array([[1,3], [2,8], [-1,-3]])\n for i in 0,1,2:\n for j in 0,1:\n self.assertEqual(lro.xy[i][j], expected[i][j])", "def check_transformations(*args):\n assert args[0].shape == (21,21)\n assert args[0].dtype == np.float64\n if len(args) == 2:\n assert args[1].shape == (2,2)\n assert args[1].dtype == np.float64", "def check_consistent(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim):\n\tassert X.shape[list(X.dims).index(x_lat_dim)] == len(X.coords[x_lat_dim].values), \"XCast requires a dataset's x_lat_dim coordinate to be the same length as its x_lat_dim dimension\"\n\tassert X.shape[list(X.dims).index(x_lon_dim)] == len(X.coords[x_lon_dim].values), \"XCast requires a dataset's x_lon_dim coordinate to be the same length as its x_lon_dim dimension\"\n\tassert X.shape[list(X.dims).index(x_sample_dim)] == len(X.coords[x_sample_dim].values), \"XCast requires a dataset's x_sample_dim coordinate to be the same length as its x_sample_dim dimension\"\n\tassert X.shape[list(X.dims).index(x_feature_dim)] == len(X.coords[x_feature_dim].values), \"XCast requires a dataset's x_feature_dim coordinate to be the same length as its x_feature_dim dimension\"", "def test_roundtrip_from_transpose1(self):\n transposed_array = np.array([[0, 1, 2], [2, 1, 0]]).T\n assert_array_equal(transposed_array, carray(transposed_array, dtype=None))", "def transform(\n self,\n X: FEATURES | None = None,\n y: TARGET | None = None,\n ) -> PANDAS | tuple[DATAFRAME, PANDAS]:\n check_is_fitted(self)\n X, y = self._prepare_input(X, y, columns=getattr(self, \"feature_names_in_\", None))\n\n self.log(\"Cleaning the data...\", 1)\n\n if X is not None:\n # Replace all missing values with NaN\n X = X.replace(self.missing + [np.inf, -np.inf], np.NaN)\n\n for name, column in X.items():\n # Drop features with invalid data type\n if column.dtype.name in lst(self.drop_types):\n self.log(\n f\" --> Dropping feature {name} for having a \"\n f\"prohibited type: {column.dtype.name}.\", 2\n )\n X = X.drop(name, axis=1)\n continue\n\n elif column.dtype.name in (\"object\", \"category\"):\n if self.strip_categorical:\n # Strip strings from blank spaces\n X[name] = column.apply(\n lambda val: val.strip() if isinstance(val, str) else val\n )\n\n # Drop prohibited chars from column names\n if self.drop_chars:\n X = X.rename(columns=lambda x: re.sub(self.drop_chars, \"\", str(x)))\n\n # Drop duplicate samples\n if self.drop_duplicates:\n X = X.drop_duplicates(ignore_index=True)\n\n if y is not None:\n if self.drop_chars:\n if isinstance(y, SERIES_TYPES):\n y.name = re.sub(self.drop_chars, \"\", y.name)\n else:\n y = y.rename(columns=lambda x: re.sub(self.drop_chars, \"\", str(x)))\n\n # Delete samples with NaN in target\n if self.drop_missing_target:\n length = len(y) # Save original length to count deleted rows later\n y = y.replace(self.missing + [np.inf, -np.inf], np.NaN).dropna()\n\n if X is not None:\n X = X[X.index.isin(y.index)] # Select only indices that remain\n\n if (d := length - len(y)) > 0:\n self.log(f\" --> Dropping {d} rows with missing values in target.\", 2)\n\n if self.encode_target:\n y_transformed = y.__class__(dtype=\"object\")\n for col, est in self._estimators.items():\n if est:\n if n_cols(out := est.transform(bk.DataFrame(y)[col])) == 1:\n self.log(f\" --> Label-encoding column {col}.\", 2)\n out = to_series(out, y.index, col)\n\n else:\n self.log(f\" --> Label-binarizing column {col}.\", 2)\n out = to_df(\n data=out,\n index=y.index,\n columns=[f\"{col}_{c}\" for c in est.classes_],\n )\n\n # Replace target with encoded column(s)\n if isinstance(y, SERIES_TYPES):\n y_transformed = out\n else:\n y_transformed = merge(y_transformed, out)\n\n else: # Add unchanged column\n y_transformed = merge(y_transformed, bk.DataFrame(y)[col])\n\n y = y_transformed\n\n return variable_return(X, y)", "def transform(self, X, y=None):\n\n check_is_fitted(self, ('n_features_', ))\n X = check_array(X, accept_sparse=True)\n\n if X.shape[1] != self.n_features_:\n raise ValueError('num_features differ between fit and transform!')\n\n return X # dummy pass-through, doing nothing except for shape checks.", "def check_data_type_column_data(X):\n if type(X) is not numpy.ndarray:\n raise TypeError(\"X should be type numpy.ndarray\")\n\n if len(X.shape) == 2 and X.shape[1] > 1:\n raise TypeError(\"X should have a single column.\")", "def _check_array(self, X):\n x = np.copy(X)\n if np.isfortran(x) is False:\n # print (\"Array must be in Fortran-order. Converting now.\")\n x = np.asfortranarray(x)\n if self.sampling > x.shape:\n raise ValueError(\"'sampling' is greater than the dimensions of X\")\n return x", "def DatasetToTuple(sample):\n \n X_elem = []\n Y_elem = []\n for x,y in sample:\n X_elem.append(x if x.dim() > 0 else x.item())\n Y_elem.append(y if y.dim() > 0 else y.item()) \n return (torch.stack(X_elem),torch.stack(Y_elem))", "def DatasetToTuple(sample):\n \n X_elem = []\n Y_elem = []\n for x,y in sample:\n X_elem.append(x if x.dim() > 0 else x.item())\n Y_elem.append(y if y.dim() > 0 else y.item()) \n return (torch.stack(X_elem),torch.stack(Y_elem))", "def data_as_timesteps(X):\n if isinstance(X, list):\n # Make tabular data from a list of examples\n X = np.vstack(X)\n # Stack data so that features are the 3rd dimension\n return np.dstack([X])", "def transform(self, X, details=False):\n Xm = ma.masked_equal(X, self.missing_values)\n p_y_given_x, log_z = self.calculate_latent(self.theta, Xm)\n labels = self.label(p_y_given_x)\n if details == 'surprise':\n # Totally experimental\n log_marg_x = self.calculate_marginals_on_samples(self.theta, Xm, return_ratio=False)\n n_samples = Xm.shape[0]\n surprise = []\n for l in range(n_samples):\n q = - sum([max([log_marg_x[j,l,i,labels[l, j]]\n for j in range(self.n_hidden)])\n for i in range(self.n_visible)])\n surprise.append(q)\n return p_y_given_x, log_z, np.array(surprise)\n elif details:\n return p_y_given_x, log_z\n else:\n return labels", "def separate_feature_class(data):\n data_c = data.copy()\n y = data_c.reindex(columns=['class'])\n X = data_c.drop(columns='class')\n return X,y" ]

[ "0.60901403", "0.6069965", "0.57867116", "0.57052827", "0.56909966", "0.5635825", "0.5586665", "0.54974854", "0.54878813", "0.5452838", "0.5424291", "0.54226655", "0.54185116", "0.5416405", "0.5388056", "0.5387666", "0.53499806", "0.5334254", "0.5315664", "0.5304115", "0.52881277", "0.52755845", "0.52741414", "0.521712", "0.51826435", "0.5177065", "0.5177065", "0.5163846", "0.51504445", "0.5141156" ]

[ "def check_coords(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim):\n\tassert x_lat_dim in X.coords.keys(), 'XCast requires a dataset_lat_dim to be a coordinate on X'\n\tassert x_lon_dim in X.coords.keys(), 'XCast requires a dataset_lon_dim to be a coordinate on X'\n\tassert x_sample_dim in X.coords.keys(), 'XCast requires a dataset_sample_dim to be a coordinate on X'\n\tassert x_feature_dim in X.coords.keys(), 'XCast requires a dataset_feature_dim to be a coordinate on X'", "def check_all(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim):\n\tcheck_dimensions(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim)\n\tcheck_coords(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim)\n\tcheck_consistent(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim)\n\tcheck_type(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim)\n\t#check_transposed(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim)", "def dimension_check():\n print(\"### DIMENSION CHECK ###\")\n print(X.shape,\n y.shape,\n X_train.shape,\n y_train.shape,\n X_test.shape,\n y_test.shape,\n weights.shape)\n print(\"### END ###\")", "def check_consistent(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim):\n\tassert X.shape[list(X.dims).index(x_lat_dim)] == len(X.coords[x_lat_dim].values), \"XCast requires a dataset's x_lat_dim coordinate to be the same length as its x_lat_dim dimension\"\n\tassert X.shape[list(X.dims).index(x_lon_dim)] == len(X.coords[x_lon_dim].values), \"XCast requires a dataset's x_lon_dim coordinate to be the same length as its x_lon_dim dimension\"\n\tassert X.shape[list(X.dims).index(x_sample_dim)] == len(X.coords[x_sample_dim].values), \"XCast requires a dataset's x_sample_dim coordinate to be the same length as its x_sample_dim dimension\"\n\tassert X.shape[list(X.dims).index(x_feature_dim)] == len(X.coords[x_feature_dim].values), \"XCast requires a dataset's x_feature_dim coordinate to be the same length as its x_feature_dim dimension\"", "def _check_shape(input_shape):\n msg = ('Input to SpatialExpansion must be 4D with dimensions: '\n '(n_observations, n_spatial_0, n_spatial_1, n_features), '\n 'but received shape: {}'.format(input_shape))\n assert len(input_shape) == 4, msg", "def _check_dimensions(self) -> None:\n dims = (self.y_dim, self.x_dim)\n da = self._obj[self.vars[0]] if isinstance(self._obj, xr.Dataset) else self._obj\n extra_dims = [dim for dim in da.dims if dim not in dims]\n if len(extra_dims) == 1:\n dims = tuple(extra_dims) + dims\n self.set_attrs(dim0=extra_dims[0])\n elif len(extra_dims) == 0:\n self._obj.coords[GEO_MAP_COORD].attrs.pop(\"dim0\", None)\n elif len(extra_dims) > 1:\n raise ValueError(\"Only 2D and 3D data arrays supported.\")\n if isinstance(self._obj, xr.Dataset):\n check = np.all([self._obj[name].dims == dims for name in self.vars])\n else:\n check = self._obj.dims == dims\n if check == False:\n raise ValueError(\n f\"Invalid dimension order ({da.dims}). \"\n f\"You can use `obj.transpose({dims}) to reorder your dimensions.\"\n )", "def check_input_dimension(self, data):\n if len(data[0]) != self.input_dimension:\n raise ValueError(\"Received {} features, expected {}.\".format(self.input_dimension, len(data[0])))", "def check_transposed(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim):\n\tassert list(X.dims).index(x_lat_dim) == 0, 'XCast requires a dataset to be transposed to LAT x LON x SAMPLE x FEATURE'\n\tassert list(X.dims).index(x_lon_dim) == 1, 'XCast requires a dataset to be transposed to LAT x LON x SAMPLE x FEATURE'\n\tassert list(X.dims).index(x_sample_dim) == 2, 'XCast requires a dataset to be transposed to LAT x LON x SAMPLE x FEATURE'\n\tassert list(X.dims).index(x_feature_dim) == 3, 'XCast requires a dataset to be transposed to LAT x LON x SAMPLE x FEATURE'", "def check_type(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim):\n\tassert type(X) == xr.DataArray, 'XCast requires a dataset to be of type \"Xarray.DataArray\"'", "def _check_shape(self, X):\n return all([X.shape[i] == self.train_shape[i] for i in range(2)])", "def _check_shape(input_shape):\n msg = ('Input to FlattenAxis must be 5D with dimensions: '\n '(n_observations, n_spatial_0, n_spatial_1, n_temporal, '\n 'n_features), but received shape: {}'.format(input_shape))\n assert len(input_shape) == 5, msg", "def test_dimension_mapping(self):\n fh = NetCDF4()\n\n with tempfile.TemporaryDirectory() as tdir:\n tfile = os.path.join(tdir, 'testfile')\n before = xr.Dataset({\n \"var1\": (\"dim1\", np.arange(5)),\n \"group1/var1\": (\"group1/dim1\", np.arange(5)),\n \"group1/var2\": (\"group1/dim2\", np.arange(5)),\n \"group1/subgroup1/var1\":\n (\"group1/subgroup1/dim1\", np.arange(5)),\n \"group1/subgroup1/var2\":\n (\"group1/subgroup1/dim2\", np.arange(5)),\n \"group2/var1\": (\"group2/dim1\", np.arange(5)),\n \"group2/subgroup1/var1\":\n (\"group1/subgroup1/dim1\", np.arange(5)),\n \"group3/var1\": (\"group3/dim1\", np.arange(10)),\n }, coords={\n \"dim1\": (\"dim1\", np.arange(5)),\n \"group1/dim1\": (\"group1/dim1\", np.arange(5))\n })\n\n # Save the dataset and load it again:\n fh.write(before, tfile)\n after = fh.read(tfile)\n\n # How it should be after loading:\n check = xr.Dataset({\n \"var1\": (\"dim1\", np.arange(5)),\n \"group1/var1\": (\"group1/dim1\", np.arange(5)),\n \"group1/var2\": (\"group1/dim2\", np.arange(5)),\n \"group1/subgroup1/var1\": (\"group1/dim1\", np.arange(5)),\n \"group1/subgroup1/var2\": (\"group1/dim2\", np.arange(5)),\n \"group2/var1\": (\"dim1\", np.arange(5)),\n \"group2/subgroup1/var1\": (\"dim1\", np.arange(5)),\n \"group3/var1\": (\"group3/dim1\", np.arange(10)),\n }, coords={\n \"dim1\": (\"dim1\", np.arange(5)),\n \"group1/dim1\": (\"group1/dim1\", np.arange(5))\n })\n\n assert after.equals(check)", "def has_dims(xobj, dims, kind):\n if isinstance(dims, str):\n dims = [dims]\n\n if not all(dim in xobj.dims for dim in dims):\n raise DimensionError(\n f'Your {kind} object must contain the '\n f'following dimensions at the minimum: {dims}'\n )\n return True", "def test_check_X_too_many_dims():\n with pytest.raises(ValueError):\n check_X(np.ones((5,4,3)))", "def test_shapes(self):\n\n # Creates a raw layer\n self.validator.adata.raw = self.validator.adata\n self.validator.adata.raw.var.drop(\"feature_is_filtered\", axis=1, inplace=True)\n self.validator.adata.X = examples.adata_non_raw.X.copy()\n self.validator.adata.uns[\"X_normalization\"] = \"CPM\"\n\n # remove one gene\n self.validator.adata = self.validator.adata[:, 1:]\n self.validator.validate_adata()\n self.assertEqual(\n self.validator.errors,\n [\"ERROR: Number of genes in X (3) is different than raw.X (4).\"],\n )", "def check_dimensions(d_real, d_fake, d_real_logits, d_fake_logits):\n def _check_pair(a, b):\n if a != b:\n raise ValueError(\"Shape mismatch: %s vs %s.\" % (a, b))\n if len(a) != 2 or len(b) != 2:\n raise ValueError(\"Rank: expected 2, got %s and %s\" % (len(a), len(b)))\n\n if (d_real is not None) and (d_fake is not None):\n _check_pair(d_real.shape.as_list(), d_fake.shape.as_list())\n if (d_real_logits is not None) and (d_fake_logits is not None):\n _check_pair(d_real_logits.shape.as_list(), d_fake_logits.shape.as_list())\n if (d_real is not None) and (d_real_logits is not None):\n _check_pair(d_real.shape.as_list(), d_real_logits.shape.as_list())", "def _check_dimensions(self, workspace_to_check):\n for i in range(self._raw_ws.getNumDims()):\n if self._raw_ws.getDimension(i).getNBins() != workspace_to_check._raw_ws.getDimension(i).getNBins():\n return False\n return True", "def dims(x):\n return len(x.shape)", "def check_has_dims(hdr):\n try:\n return (hdr['startX'], hdr['startY'])\n except KeyError:\n return False", "def _validate_dimensionality(self):\r\n\r\n if self.time.ndim != 1:\r\n raise ValueError(\"time array must be one-dimensional\")\r\n npoints = self.data.shape[-1]\r\n if npoints != len(self.time):\r\n raise ValueError(\"mismatch of time and data dimensions\")", "def to_4d(x):\n xsh = np.asarray(x.get_shape().as_list())\n return tf.reshape(x, [xsh[0], xsh[1], xsh[2], np.prod(xsh[3:])])", "def nd_shape_checking(x, y, mvaxis, traxis):\n assert x.ndim == y.ndim\n dims = np.delete(np.arange(x.ndim), -2)\n assert all([x.shape[k] == y.shape[k] for k in dims])", "def assertIsNifti4D(*args):\n for f in args:\n assertIsNifti(f)\n d = ensure.ensureIsImage(f)\n assert len(d.shape) == 4, \\\n 'incorrect shape for 4D nifti: {}:{}'.format(d.shape, f)", "def test_get_dimension(self):\n\n v = Vector({ 'x': 1 })\n self.assertEqual(1, v.dimensions['x'])", "def do_grid_check(self,):\n self.ydim, self.xdim = self.data_fcst.shape \n if self.data_obs.shape != (self.ydim,self.xdim):\n raise FormatError(\"Obs and forecast data not same size.\")\n return", "def feature_dim(self):\n raise NotImplementedError", "def test_size_check(self):\n [x1, y1, s1, g1] = self.data.diffusion_data.shape\n [x2, y2, s2, g2] = module_05.run_module(self.data).diffusion_data.shape\n self.assertEqual(x1, x2)\n self.assertEqual(y1, y2)\n self.assertEqual(s1, s2)\n self.assertEqual(g1, g2)", "def x_dim(self) -> str:\n if self.get_attrs(\"x_dim\") not in self._obj.dims:\n self.set_spatial_dims()\n return self.attrs[\"x_dim\"]", "def is_float4x4(items):\n return len(items) == 4 and all(len(item) == 4 and all(isinstance(i, float) for i in item) for item in items)", "def test_slice_other_dimension(self):\n for i, shape in enumerate([(3, 0), (1, 2, 0), (2, 0, 1)]):\n dset = self.f.create_dataset('x%d'%i, shape, dtype=int, maxshape=(None,)*len(shape))\n self.assertEqual(dset.shape, shape)\n out = dset[:1]\n self.assertIsInstance(out, np.ndarray)\n self.assertEqual(out.shape, (1,)+shape[1:])" ]

[ "0.6943855", "0.6864585", "0.6622508", "0.6591821", "0.647431", "0.63964295", "0.6374549", "0.6134668", "0.6122223", "0.5947658", "0.583848", "0.57911134", "0.57625794", "0.565753", "0.56400055", "0.5597365", "0.5592346", "0.5584553", "0.55217546", "0.5503743", "0.54942316", "0.54282486", "0.54202354", "0.5416537", "0.54095894", "0.53979105", "0.5296823", "0.5296293", "0.5294601", "0.5280257" ]

[ "def check_all(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim):\n\tcheck_dimensions(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim)\n\tcheck_coords(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim)\n\tcheck_consistent(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim)\n\tcheck_type(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim)\n\t#check_transposed(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim)", "def check_dimensions(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim):\n\tassert 4 <= len(X.dims) <= 5, 'XCast requires a dataset to be 4-Dimensional'\n\tassert x_lat_dim in X.dims, 'XCast requires a dataset_lat_dim to be a dimension on X'\n\tassert x_lon_dim in X.dims, 'XCast requires a dataset_lon_dim to be a dimension on X'\n\tassert x_sample_dim in X.dims, 'XCast requires a dataset_sample_dim to be a dimension on X'\n\tassert x_feature_dim in X.dims, 'XCast requires a dataset_feature_dim to be a dimension on X'", "def check_consistent(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim):\n\tassert X.shape[list(X.dims).index(x_lat_dim)] == len(X.coords[x_lat_dim].values), \"XCast requires a dataset's x_lat_dim coordinate to be the same length as its x_lat_dim dimension\"\n\tassert X.shape[list(X.dims).index(x_lon_dim)] == len(X.coords[x_lon_dim].values), \"XCast requires a dataset's x_lon_dim coordinate to be the same length as its x_lon_dim dimension\"\n\tassert X.shape[list(X.dims).index(x_sample_dim)] == len(X.coords[x_sample_dim].values), \"XCast requires a dataset's x_sample_dim coordinate to be the same length as its x_sample_dim dimension\"\n\tassert X.shape[list(X.dims).index(x_feature_dim)] == len(X.coords[x_feature_dim].values), \"XCast requires a dataset's x_feature_dim coordinate to be the same length as its x_feature_dim dimension\"", "def check_type(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim):\n\tassert type(X) == xr.DataArray, 'XCast requires a dataset to be of type \"Xarray.DataArray\"'", "def check_input_dimension(self, data):\n if len(data[0]) != self.input_dimension:\n raise ValueError(\"Received {} features, expected {}.\".format(self.input_dimension, len(data[0])))", "def is_x(self, var):\n x_list = ['lon', 'longitude', 'LONGITUDE', 'Longitude', 'x']\n\n if self.get_units(var) == 'degrees_east':\n return True\n if self.get_name(var) in x_list:\n return True\n if self.get_description(var) in x_list:\n return True\n else:\n return False", "def _check_dimensions(self) -> None:\n dims = (self.y_dim, self.x_dim)\n da = self._obj[self.vars[0]] if isinstance(self._obj, xr.Dataset) else self._obj\n extra_dims = [dim for dim in da.dims if dim not in dims]\n if len(extra_dims) == 1:\n dims = tuple(extra_dims) + dims\n self.set_attrs(dim0=extra_dims[0])\n elif len(extra_dims) == 0:\n self._obj.coords[GEO_MAP_COORD].attrs.pop(\"dim0\", None)\n elif len(extra_dims) > 1:\n raise ValueError(\"Only 2D and 3D data arrays supported.\")\n if isinstance(self._obj, xr.Dataset):\n check = np.all([self._obj[name].dims == dims for name in self.vars])\n else:\n check = self._obj.dims == dims\n if check == False:\n raise ValueError(\n f\"Invalid dimension order ({da.dims}). \"\n f\"You can use `obj.transpose({dims}) to reorder your dimensions.\"\n )", "def check_transposed(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim):\n\tassert list(X.dims).index(x_lat_dim) == 0, 'XCast requires a dataset to be transposed to LAT x LON x SAMPLE x FEATURE'\n\tassert list(X.dims).index(x_lon_dim) == 1, 'XCast requires a dataset to be transposed to LAT x LON x SAMPLE x FEATURE'\n\tassert list(X.dims).index(x_sample_dim) == 2, 'XCast requires a dataset to be transposed to LAT x LON x SAMPLE x FEATURE'\n\tassert list(X.dims).index(x_feature_dim) == 3, 'XCast requires a dataset to be transposed to LAT x LON x SAMPLE x FEATURE'", "def _check_input(self, X):\n symbols = np.concatenate(X)\n if len(symbols) == 1: # not enough data\n raise ValueError(\"expected at least 1 observation \"\n \"but none found.\")\n elif (symbols < 0).any(): # contains negative integers\n raise ValueError(\"expected non-negative features \"\n \"for each observation.\")\n elif X.shape[1] > 1: # contains to many features\n raise ValueError(\"expected only 1 feature but got {0} \"\n \"for each observation.\".format(X.shape[1]))\n else:\n return True", "def _check_shape(self, X):\n return all([X.shape[i] == self.train_shape[i] for i in range(2)])", "def check_has_dims(hdr):\n try:\n return (hdr['startX'], hdr['startY'])\n except KeyError:\n return False", "def _validate_raster_attributes(self, x):\r\n if self.extent != x.extent:\r\n raise ValueError(\"Extents do not match.\")\r\n if self.resolution != x.resolution:\r\n raise ValueError(\"Resolutions do not match.\")\r\n if not np.array_equal(self.x, x.x):\r\n raise ValueError(\"x attributes do not match.\")\r\n if not np.array_equal(self.y, x.y):\r\n raise ValueError(\"y attributes do not match.\")\r\n if len(self.layers) != len(x.layers):\r\n raise ValueError(\"layers lengths do not match.\")\r\n if self.crs != x.crs:\r\n raise ValueError(\"crs attributes do not match.\")", "def _check_shape(input_shape):\n msg = ('Input to SpatialExpansion must be 4D with dimensions: '\n '(n_observations, n_spatial_0, n_spatial_1, n_features), '\n 'but received shape: {}'.format(input_shape))\n assert len(input_shape) == 4, msg", "def has_dims(xobj, dims, kind):\n if isinstance(dims, str):\n dims = [dims]\n\n if not all(dim in xobj.dims for dim in dims):\n raise DimensionError(\n f'Your {kind} object must contain the '\n f'following dimensions at the minimum: {dims}'\n )\n return True", "def check_inputs(x_unlabeled, x_labeled, y_labeled, y_true):\n if x_unlabeled is None:\n if x_labeled is None:\n raise Exception(\"No data, labeled or unlabeled, passed to check_inputs!\")\n x_unlabeled = x_labeled[0:0]\n if x_labeled is not None and y_labeled is not None:\n pass\n elif x_labeled is None and y_labeled is None:\n x_labeled = x_unlabeled[0:0]\n y_shape = y_true.get_shape()[1 : K.ndim(y_true)].as_list()\n y_labeled = np.empty([0] + y_shape)\n else:\n raise Exception(\"x_labeled and y_labeled must both be None or have a value\")\n return x_unlabeled, x_labeled, y_labeled", "def _sanity_check_datasource(ds):\n if len(ds) != 1:\n raise SanityCheckError('GeoJSON should have only 1 layer.')\n # TODO: add more checks", "def test_feature_values(iris, name, x_feature, y_feature, x_vals, y_vals):\n iris.x_feature = x_feature\n iris.y_feature = y_feature\n assert iris.title == \"{} x {}\".format(x_feature, y_feature)\n data = iris.sources[name].data\n np.testing.assert_array_almost_equal(data[\"x\"][:2], x_vals)\n np.testing.assert_array_almost_equal(data[\"y\"][:2], y_vals)", "def test_check_X_too_many_dims():\n with pytest.raises(ValueError):\n check_X(np.ones((5,4,3)))", "def validate_xy(x_train, y_train):\n try:\n x_train = x_train.astype('float64')\n except ValueError:\n raise ValueError('x_train should only contain numerical data.')\n\n if len(x_train.shape) < 2:\n raise ValueError('x_train should at least has 2 dimensions.')\n\n if x_train.shape[0] != y_train.shape[0]:\n raise ValueError('x_train and y_train should have the same number of instances.')", "def dimension_check():\n print(\"### DIMENSION CHECK ###\")\n print(X.shape,\n y.shape,\n X_train.shape,\n y_train.shape,\n X_test.shape,\n y_test.shape,\n weights.shape)\n print(\"### END ###\")", "def _check_shape(input_shape):\n msg = ('Input to FlattenAxis must be 5D with dimensions: '\n '(n_observations, n_spatial_0, n_spatial_1, n_temporal, '\n 'n_features), but received shape: {}'.format(input_shape))\n assert len(input_shape) == 5, msg", "def set_spatial_dims(self, x_dim=None, y_dim=None) -> None:\n _dims = list(self._obj.dims)\n # Switch to lower case to compare to XDIMS and YDIMS\n _dimslow = [d.lower() for d in _dims]\n if x_dim is None:\n for dim in XDIMS:\n if dim in _dimslow:\n idim = _dimslow.index(dim)\n x_dim = _dims[idim]\n break\n if x_dim and x_dim in _dims:\n self.set_attrs(x_dim=x_dim)\n else:\n raise ValueError(\n \"x dimension not found. Use 'set_spatial_dims'\"\n + \" functions with correct x_dim argument provided.\"\n )\n\n if y_dim is None:\n for dim in YDIMS:\n if dim in _dimslow:\n idim = _dimslow.index(dim)\n y_dim = _dims[idim]\n break\n if y_dim and y_dim in _dims:\n self.set_attrs(y_dim=y_dim)\n else:\n raise ValueError(\n \"y dimension not found. Use 'set_spatial_dims'\"\n + \" functions with correct y_dim argument provided.\"\n )\n\n check_x = np.all(np.isclose(np.diff(np.diff(self._obj[x_dim])), 0, atol=1e-4))\n check_y = np.all(np.isclose(np.diff(np.diff(self._obj[y_dim])), 0, atol=1e-4))\n if check_x == False or check_y == False:\n raise ValueError(\"raster only applies to regular grids\")", "def xcoords(self) -> xr.IndexVariable:\n xcoords = self._obj[self.x_dim]\n if self.x_dim not in self._obj.coords:\n for key in list(self._obj.coords.keys()):\n if key.startswith(self.x_dim):\n xcoords = self._obj.coords[key]\n break\n if xcoords.ndim == 2 and list(xcoords.dims).index(self.x_dim) != 1:\n raise ValueError(\n \"Invalid raster: dimension order wrong. Fix using\"\n f'\".transpose(..., {self.y_dim}, {self.x_dim})\"'\n )\n if xcoords.size < 2 or (xcoords.ndim == 2 and xcoords.shape[1] < 2):\n raise ValueError(f\"Invalid raster: less than 2 cells in x_dim {self.x_dim}\")\n return xcoords", "def is_resolution_and_offset_str(x):\n if x.count('x') == 1 and x.count('+') == 2:\n return True\n return False", "def _check_data_point(cube, metadata):\n point_index = []\n\n for dim_length in cube.shape:\n point_index.append(int(random.random() * dim_length))\n\n point_index = tuple(point_index)\n\n try:\n point_cube = cube[point_index]\n _data_point = point_cube.data\n except Exception:\n msg = 'Unable to extract data point {} from file: {}'.format(\n point_index, metadata['basename'])\n raise FileValidationError(msg)\n else:\n return True", "def _check_dimensions(self, workspace_to_check):\n for i in range(self._raw_ws.getNumDims()):\n if self._raw_ws.getDimension(i).getNBins() != workspace_to_check._raw_ws.getDimension(i).getNBins():\n return False\n return True", "def validate_data_format(\n Xs: List[Tensor], Ys: List[Tensor], Yvars: List[Tensor], metric_names: List[str]\n) -> None:\n if len({len(Xs), len(Ys), len(Yvars), len(metric_names)}) > 1:\n raise ValueError( # pragma: no cover\n \"Lengths of Xs, Ys, Yvars, and metric_names must match. Your \"\n f\"inputs have lengths {len(Xs)}, {len(Ys)}, {len(Yvars)}, and \"\n f\"{len(metric_names)}, respectively.\"\n )", "def validate_ndarray(ndarray, expected_dtypes, expected_dimentions, name):\n\tvalid_dtype_assertion(expected_dtypes, ndarray.dtype, name)\n\tvalid_ndim_assertion(expected_dimentions, ndarray.ndim, name)", "def check_bounds(x, param_name):\n for i in range(len(x)):\n if ((xmin[param_name][i] is not None and x[i] < xmin[param_name][i]) or\n (xmax[param_name][i] is not None and x[i] > xmax[param_name][i])):\n return False\n return True", "def _check_shape(placeholder_shape, data_shape):\n\n return True" ]

[ "0.77260077", "0.7620336", "0.7221872", "0.6576378", "0.6310555", "0.6308388", "0.6186717", "0.608041", "0.58673334", "0.5852697", "0.5782202", "0.5687635", "0.5607326", "0.5584896", "0.55696183", "0.5523855", "0.5504535", "0.5483882", "0.54531854", "0.54332227", "0.5432066", "0.5403734", "0.53723615", "0.5370909", "0.5358261", "0.53399915", "0.5332978", "0.53298247", "0.5316847", "0.52930784" ]

[ "def _check_dimensions(self) -> None:\n dims = (self.y_dim, self.x_dim)\n da = self._obj[self.vars[0]] if isinstance(self._obj, xr.Dataset) else self._obj\n extra_dims = [dim for dim in da.dims if dim not in dims]\n if len(extra_dims) == 1:\n dims = tuple(extra_dims) + dims\n self.set_attrs(dim0=extra_dims[0])\n elif len(extra_dims) == 0:\n self._obj.coords[GEO_MAP_COORD].attrs.pop(\"dim0\", None)\n elif len(extra_dims) > 1:\n raise ValueError(\"Only 2D and 3D data arrays supported.\")\n if isinstance(self._obj, xr.Dataset):\n check = np.all([self._obj[name].dims == dims for name in self.vars])\n else:\n check = self._obj.dims == dims\n if check == False:\n raise ValueError(\n f\"Invalid dimension order ({da.dims}). \"\n f\"You can use `obj.transpose({dims}) to reorder your dimensions.\"\n )", "def _check_shape(self, X):\n return all([X.shape[i] == self.train_shape[i] for i in range(2)])", "def check_dimensions(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim):\n\tassert 4 <= len(X.dims) <= 5, 'XCast requires a dataset to be 4-Dimensional'\n\tassert x_lat_dim in X.dims, 'XCast requires a dataset_lat_dim to be a dimension on X'\n\tassert x_lon_dim in X.dims, 'XCast requires a dataset_lon_dim to be a dimension on X'\n\tassert x_sample_dim in X.dims, 'XCast requires a dataset_sample_dim to be a dimension on X'\n\tassert x_feature_dim in X.dims, 'XCast requires a dataset_feature_dim to be a dimension on X'", "def check_coords(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim):\n\tassert x_lat_dim in X.coords.keys(), 'XCast requires a dataset_lat_dim to be a coordinate on X'\n\tassert x_lon_dim in X.coords.keys(), 'XCast requires a dataset_lon_dim to be a coordinate on X'\n\tassert x_sample_dim in X.coords.keys(), 'XCast requires a dataset_sample_dim to be a coordinate on X'\n\tassert x_feature_dim in X.coords.keys(), 'XCast requires a dataset_feature_dim to be a coordinate on X'", "def check_size(self,x,y):\n assert(x <= 10**3), 'Width larger than 1000' \n assert(y <= 10**3), 'Height larger than 1000' \n assert(x*y <= 3*(10**5)), 'Resolution larger than 300000'", "def _check_dimensions(self, workspace_to_check):\n for i in range(self._raw_ws.getNumDims()):\n if self._raw_ws.getDimension(i).getNBins() != workspace_to_check._raw_ws.getDimension(i).getNBins():\n return False\n return True", "def nd_shape_checking(x, y, mvaxis, traxis):\n assert x.ndim == y.ndim\n dims = np.delete(np.arange(x.ndim), -2)\n assert all([x.shape[k] == y.shape[k] for k in dims])", "def _checkSize(X1,X2):\n \n if len(X1) != len(X2):\n raise ValueError, 'Lists are differnt lengths'", "def test_size_check(self):\n [x1, y1, s1, g1] = self.data.diffusion_data.shape\n [x2, y2, s2, g2] = module_05.run_module(self.data).diffusion_data.shape\n self.assertEqual(x1, x2)\n self.assertEqual(y1, y2)\n self.assertEqual(s1, s2)\n self.assertEqual(g1, g2)", "def test_check_X_too_many_dims():\n with pytest.raises(ValueError):\n check_X(np.ones((5,4,3)))", "def verify_coords(self, piece_coords):\n if piece_coords[0] >= self.size or piece_coords[0] < 0:\n return False\n if piece_coords[1] >= self.size or piece_coords[1] < 0:\n return False\n return True", "def validate_dimensions(self, dimensions):\n\n #safety checking\n if len(dimensions) != self.dimensionality:\n raise ValueError(f\"The number of dimensions provided {len(dimensions)}\"\n f\"do not match that of this coordinate system \"\n f\"{self.dimensionality}.\")\n\n if not all(isinstance(elem, int) for elem in dimensions):\n raise ValueError(f\"Not all dimensions are ints {dimensions}\")\n\n if not all(elem > 0 for elem in dimensions):\n raise ValueError(f\"Dimensions must be greater than 1 {dimensions}\")\n\n if not checkallequal(dimensions):\n raise ValueError(f\"Not all dimensions are equal {dimensions}. They \"\n f\"must be equal. This will be changed in a future version\")", "def __len__(self):\n\t\treturn len(self._coords)", "def test_point_within_dimensions_invalid_sizes():\n point = np.array([20, 20, 20])\n image_dimensions = np.array([100, 100])\n\n with pytest.raises(AssertionError):\n assert not point_within_dimensions(point, image_dimensions)\n\n point = np.array([20, 20])\n image_dimensions = np.array([100, 100, 100])\n\n with pytest.raises(AssertionError):\n assert not point_within_dimensions(point, image_dimensions)", "def __len__(self):\n return len(self._coords)", "def _shape_check(self, X, y):\n if not len(y.shape) > 1:\n raise RuntimeError(\"The shape of y is incorrect.\")\n if y.shape != X.shape[:-1]:\n raise RuntimeError(\"X and y must have the same number of \" +\n \"samples and microstructure shape.\")\n if X.shape[-1] != 3:\n raise RuntimeError(\"X must have 3 continuous local states \" +\n \"(euler angles)\")", "def _validate_dimensionality(self):\r\n\r\n if self.time.ndim != 1:\r\n raise ValueError(\"time array must be one-dimensional\")\r\n npoints = self.data.shape[-1]\r\n if npoints != len(self.time):\r\n raise ValueError(\"mismatch of time and data dimensions\")", "def _autocheck_dimensions(self):\n # W dimensions check list\n assert len(self.W.shape) == 2, f\"W shape should be (N, N) but is {self.W.shape}.\"\n assert self.W.shape[0] == self.W.shape[1], f\"W shape should be (N, N) but is {self.W.shape}.\"\n\n # Win dimensions check list\n assert len(self.Win.shape) == 2, f\"Win shape should be (N, input) but is {self.Win.shape}.\"\n err = f\"Win shape should be ({self.W.shape[1]}, input) but is {self.Win.shape}.\"\n assert self.Win.shape[0] == self.W.shape[0], err\n\n # Wout dimensions check list\n assert len(self.Wout.shape) == 2, f\"Wout shape should be (output, nb_states) but is {self.Wout.shape}.\"\n nb_states = self.Win.shape[1] + self.W.shape[0] + 1 if self.use_raw_inp else self.W.shape[0] + 1\n err = f\"Wout shape should be (output, {nb_states}) but is {self.Wout.shape}.\"\n assert self.Wout.shape[1] == nb_states, err\n\n # Wfb dimensions check list\n if self.Wfb is not None:\n assert len(self.Wfb.shape) == 2, f\"Wfb shape should be (input, output) but is {self.Wfb.shape}.\"\n err = f\"Wfb shape should be ({self.Win.shape[0]}, {self.Wout.shape[0]}) but is {self.Wfb.shape}.\"\n assert (self.Win.shape[0],self.Wout.shape[0]) == self.Wfb.shape, err", "def test_point_within_dimensions_true():\n point = np.array([10, 20])\n image_dimensions = np.array([100, 100])\n assert point_within_dimensions(point, image_dimensions)", "def testgeovalues_atomcoords(self):\r\n count_geovalues = len(self.data.geovalues)\r\n count_coords = len(self.data.atomcoords) - self.extracoords\r\n msg = f\"len(atomcoords) is {int(count_coords)} but len(geovalues) is {int(count_geovalues)}\"\r\n assert count_geovalues == count_coords, msg", "def _check_inputlengths(self):\n # Check x and y have more than 1 item, and x and y are equal length\n if not len(self.x) > 1:\n raise ValueError(\"Route input 'x' must contain more than 1 item\")\n\n if not (len(self.y) > 1):\n raise ValueError(\"Route input 'y' must contain more than 1 item\")\n\n if not (len(self.x) == len(self.y)):\n raise ValueError(\"Route inputs 'x' and 'y' must be of equal length\")\n\n # Performs checks on z if not empty\n if self.z is not None:\n for v in self.z.values():\n if not (len(v) == len(self.x)):\n raise ValueError(\"Route input 'z' must be of equal length to 'x' and 'y'\")", "def do_grid_check(self,):\n self.ydim, self.xdim = self.data_fcst.shape \n if self.data_obs.shape != (self.ydim,self.xdim):\n raise FormatError(\"Obs and forecast data not same size.\")\n return", "def _validate_raster_attributes(self, x):\r\n if self.extent != x.extent:\r\n raise ValueError(\"Extents do not match.\")\r\n if self.resolution != x.resolution:\r\n raise ValueError(\"Resolutions do not match.\")\r\n if not np.array_equal(self.x, x.x):\r\n raise ValueError(\"x attributes do not match.\")\r\n if not np.array_equal(self.y, x.y):\r\n raise ValueError(\"y attributes do not match.\")\r\n if len(self.layers) != len(x.layers):\r\n raise ValueError(\"layers lengths do not match.\")\r\n if self.crs != x.crs:\r\n raise ValueError(\"crs attributes do not match.\")", "def dimension_check():\n print(\"### DIMENSION CHECK ###\")\n print(X.shape,\n y.shape,\n X_train.shape,\n y_train.shape,\n X_test.shape,\n y_test.shape,\n weights.shape)\n print(\"### END ###\")", "def test_check_x(self):\n r1 = Rectangle(10, 2)\n self.assertEqual(r1.x, 0)\n\n r2 = Rectangle(2, 10, 6)\n self.assertEqual(r2.x, 6)\n\n r3 = Rectangle(5, 2, 3, 9, 12)\n self.assertEqual(r3.x, 3)\n\n r4 = Rectangle(5, 2, 0, 3, 12)\n self.assertEqual(r4.x, 0)", "def isValidCoord(coord, size):\n return coord[0] >= 0 and coord[0] < size and \\\n coord[1] >= 0 and coord[1] < size", "def issquare(self):\r\n if self.width == self.height:\r\n return True\r\n else:\r\n return False", "def check_all(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim):\n\tcheck_dimensions(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim)\n\tcheck_coords(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim)\n\tcheck_consistent(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim)\n\tcheck_type(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim)\n\t#check_transposed(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim)", "def check_dims(self, data):\n if np.ndim(data) != 2:\n raise ValueError('Input data must be a two dimensional numpy array. '\n 'Data received has shape (%g, %g).' % data.shape)", "def check_dim(gr, DIM):\n l = len(gr)\n if(l != DIM):\n return False\n\n for i in range(0, DIM):\n if(len(gr[i]) != l):\n return False \n return True" ]

[ "0.7469548", "0.7054452", "0.7046964", "0.6944492", "0.66742504", "0.6647212", "0.6620178", "0.6618185", "0.6572067", "0.6569208", "0.65156883", "0.6446175", "0.6434718", "0.64269143", "0.64210254", "0.6420011", "0.64147735", "0.6348928", "0.6343616", "0.6322013", "0.63205206", "0.6301553", "0.6300499", "0.62992257", "0.62875843", "0.6274657", "0.62700593", "0.6265241", "0.62646836", "0.6264012" ]

[ "def __check_is_xarray(self, data):\n if type(data) is xr.core.dataarray.DataArray or \\\n type(data) is xr.core.dataarray.Dataset:\n\n return True\n else:\n msg = \"Variable {data} is not an xarray DataArray/Dataset\"\n raise Exception(msg)", "def is_dataarray(X, require_attrs=None):\n\n if require_attrs is None:\n require_attrs = [\"values\", \"coords\", \"dims\", \"to_dataset\"]\n\n return all([hasattr(X, name) for name in require_attrs])", "def _validate_X(X):\n if not isinstance(X, pd.DataFrame):\n raise ValueError(\"X should be a dataframe.\")", "def check_data_type_column_data(X):\n if type(X) is not numpy.ndarray:\n raise TypeError(\"X should be type numpy.ndarray\")\n\n if len(X.shape) == 2 and X.shape[1] > 1:\n raise TypeError(\"X should have a single column.\")", "def is_xarray(func, *dec_args):\n\n @wraps(func)\n def wrapper(*args, **kwargs):\n try:\n ds_da_locs = dec_args[0]\n if not isinstance(ds_da_locs, list):\n ds_da_locs = [ds_da_locs]\n\n for loc in ds_da_locs:\n if isinstance(loc, int):\n ds_da = args[loc]\n elif isinstance(loc, str):\n ds_da = kwargs[loc]\n\n is_ds_da = isinstance(ds_da, (xr.Dataset, xr.DataArray))\n if not is_ds_da:\n typecheck = type(ds_da)\n raise IOError(\n f\"\"\"The input data is not an xarray DataArray or\n Dataset. climpred is built to wrap xarray to make\n use of its awesome features. Please input an xarray\n object and retry the function.\n\n Your input was of type: {typecheck}\"\"\"\n )\n except IndexError:\n pass\n # this is outside of the try/except so that the traceback is relevant\n # to the actual function call rather than showing a simple Exception\n # (probably IndexError from trying to subselect an empty dec_args list)\n return func(*args, **kwargs)\n\n return wrapper", "def _validate_X(X):\n return X if not isinstance(X, pd.DataFrame) else X.as_matrix()", "def check_consistent_X(self, X):\n # X must be ndarray-type\n if not isinstance(X, np.ndarray):\n X = np.array(X)\n\n return X", "def _is_DataArrays(data):\n if isinstance(data, (Dataset, DataArray)):\n return True\n if isinstance(data, Mapping):\n for da in data.values():\n if not isinstance(da, DataArray):\n raise TypeError(\"Please provide List/Mapping of DataArrays\")\n return True\n if isinstance(data, Iterable):\n for da in data:\n if not isinstance(da, DataArray):\n return False\n # raise TypeError(\"Please provide List/Mapping of DataArrays\")\n return True\n return False", "def check_is_numpy(X):\n if isinstance(X, list):\n return np.asarray(X)\n if isinstance(X, np.ndarray):\n return X\n raise ValueError(\n \"Expected an python list or numpy array as input \"\n \"but got {}\".format(str(type(X)))\n )", "def check_is_numpy_or_pd(X):\n if isinstance(X, list):\n return np.asarray(X)\n if isinstance(X, pd.DataFrame):\n return X\n if isinstance(X, np.ndarray):\n return X\n \n raise ValueError(\n \"Expected an pandas DataFrame or numpy array or python list as input \"\n \"but got {}\".format(str(type(X)))\n )", "def _check_array(self, X):\n x = np.copy(X)\n if np.isfortran(x) is False:\n # print (\"Array must be in Fortran-order. Converting now.\")\n x = np.asfortranarray(x)\n if self.sampling > x.shape:\n raise ValueError(\"'sampling' is greater than the dimensions of X\")\n return x", "def check_array_1D(X):\n X = check_is_numpy(X)\n if X.ndim != 1:\n raise ValueError(\n \"If passed as a np.array, X must be a 1-dimensional \"\n \"array, but found shape: {}\".format(X.shape)\n )\n if X.size == 0:\n raise ValueError(\n \"Input is empty or have a dimension of size 0\"\n \", found shape: {}\".format(X.shape)\n )\n \n return X", "def check_coords(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim):\n\tassert x_lat_dim in X.coords.keys(), 'XCast requires a dataset_lat_dim to be a coordinate on X'\n\tassert x_lon_dim in X.coords.keys(), 'XCast requires a dataset_lon_dim to be a coordinate on X'\n\tassert x_sample_dim in X.coords.keys(), 'XCast requires a dataset_sample_dim to be a coordinate on X'\n\tassert x_feature_dim in X.coords.keys(), 'XCast requires a dataset_feature_dim to be a coordinate on X'", "def is_dataset(X, require_attrs=None):\n\n if require_attrs is None:\n require_attrs = [\"data_vars\", \"coords\", \"dims\", \"to_array\"]\n\n return all([hasattr(X, name) for name in require_attrs])", "def isscalar(x):\n arrayed_x = asarray(x)\n return asarray(x).ndim == 0 and arrayed_x.dtype != 'object'", "def _check_input(self, X):\n symbols = np.concatenate(X)\n if len(symbols) == 1: # not enough data\n raise ValueError(\"expected at least 1 observation \"\n \"but none found.\")\n elif (symbols < 0).any(): # contains negative integers\n raise ValueError(\"expected non-negative features \"\n \"for each observation.\")\n elif X.shape[1] > 1: # contains to many features\n raise ValueError(\"expected only 1 feature but got {0} \"\n \"for each observation.\".format(X.shape[1]))\n else:\n return True", "def _check_X(X, columns=None):\n if isinstance(X, (pd.DataFrame)):\n return X\n elif isinstance(X, (np.ndarray)):\n if columns is None:\n return pd.DataFrame(X)\n else:\n return pd.DataFrame(X, columns=columns)\n elif isinstance(X, pd.Series):\n return pd.DataFrame(X, columns=X.name)\n elif isinstance(X, (list, tuple)):\n X = np.array(X)\n return pd.DataFrame(X, columns=[str(i) for i in range(X.shape[1])])\n elif hasattr(X, (\"__array__\")):\n data = X.__array__()\n return pd.DataFrame(data, columns=[str(i) for i in range(data.shape[1])])\n return X", "def check_dimensions(X, x_lat_dim, x_lon_dim, x_sample_dim, x_feature_dim):\n\tassert 4 <= len(X.dims) <= 5, 'XCast requires a dataset to be 4-Dimensional'\n\tassert x_lat_dim in X.dims, 'XCast requires a dataset_lat_dim to be a dimension on X'\n\tassert x_lon_dim in X.dims, 'XCast requires a dataset_lon_dim to be a dimension on X'\n\tassert x_sample_dim in X.dims, 'XCast requires a dataset_sample_dim to be a dimension on X'\n\tassert x_feature_dim in X.dims, 'XCast requires a dataset_feature_dim to be a dimension on X'", "def _check_array(X):\n return check_array(X,\n accept_sparse=['csr', 'csc'], # Accept sparse csr, csc\n order=None, # Do not enforce C or Fortran\n copy=False, # Do not trigger copying\n force_all_finite=True, # Raise error on np.inf/np.nan\n ensure_2d=True, # Force 'X' do be a matrix\n allow_nd=True, # Allow 'X.ndim' > 2\n warn_on_dtype=False # Mute as 'dtype' is 'None'\n )", "def _check_input_timeseries(x: np.ndarray) -> np.ndarray:\n if not isinstance(x, np.ndarray):\n raise ValueError(\"The input time series must be a numpy array.\")\n if x.ndim <= 0 or x.ndim >= 4:\n raise ValueError(\n \"The input time series must have more than 0 dimensions and\"\n \"less than 4 dimensions.\"\n )\n if x.ndim == 3:\n return x[0]\n return x", "def is_array(self, arr):\n return isinstance(arr, np.ndarray)", "def _validate_input_data(self):\n\n if type(self.data) in [np.ndarray, da.Array]:\n if not self.data.dtype.names:\n raise ValueError('QuadTree: numpy array provided for data, but no names were found, array must be a structured array')\n if 'x' not in self.data.dtype.names or 'y' not in self.data.dtype.names:\n raise ValueError('QuadTree: numpy structured array provided for data, but \"x\" or \"y\" not found in variable names')\n self.layernames = [self.rev_layer_lookup[var] for var in self.data.dtype.names if var in ['z', 'tvu']]\n elif type(self.data) == xr.Dataset:\n if 'x' not in self.data:\n raise ValueError('QuadTree: xarray Dataset provided for data, but \"x\" or \"y\" not found in variable names')\n if len(self.data.dims) > 1:\n raise ValueError('QuadTree: xarray Dataset provided for data, but found multiple dimensions, must be one dimensional: {}'.format(self.data.dims))\n self.layernames = [self.rev_layer_lookup[var] for var in self.data if var in ['z', 'tvu']]\n self._convert_dataset() # internally we just convert xarray dataset to numpy for ease of use\n else:\n raise ValueError('QuadTree: numpy structured array or dask array with \"x\" and \"y\" as variable must be provided')", "def _check_input_for_asarray(array_like):\n if isinstance(array_like, (Tensor, list, tuple, int, float, bool, onp.ndarray)):\n return True\n raise TypeError(\"input data must be `int`, `float`, `bool`, `Tensor`, `list`, `tuple`\" + \\\n f\"or numpy.ndarray, but got {type(array_like)}\")", "def isarray(a):\n try:\n validity=isinstance(a,ndarray)\n except:\n validity=False\n\n return validity", "def isarray(a):\r\n try:\r\n validity = isinstance(a, ndarray)\r\n except:\r\n validity = False\r\n\r\n return validity", "def _check_support(X: np.ndarray, **kwargs) -> None:\n\n assert (X > 0).all() & isinteger(X), \"x should be greater then 0 and integer.\"", "def _check_support(X: np.ndarray, **kwargs) -> None:\n\n assert (X >= 0).all() & isinteger(\n X\n ), \"x should be greater or equal to 0 and integer.\"", "def test_data(self):\n\n self.assertIsInstance(self.image.data, np.ndarray)", "def check_array_3D(X, coerce_to_numpy=True, is_univariate=False, min_timestamps=2):\n X = check_is_numpy_or_pd(X)\n if X.ndim != 3:\n raise ValueError(\n \"If passed as a np.array, X must be a 3-dimensional \"\n \"array, but found shape: {}\".format(X.shape)\n )\n if X.size == 0:\n raise ValueError(\n \"Input is empty or have a dimension of size 0\"\n \", found shape: {}\".format(X.shape)\n )\n if X.shape[2] <= min_timestamps:\n raise ValueError(\n \"Input should have more than {} timestamp\"\n \", found only: {}\".format(min_timestamps,X.shape[2])\n )\n if isinstance(X, pd.DataFrame):\n raise ValueError('Only accepting numpy array as inputs for 3D')\n if is_univariate:\n if X.shape[1] != 1:\n raise ValueError(\n \"X must be a 3-dimensional array with dimension 1 equal to 1\"\n )\n return X", "def is_array(self):\n return False" ]

[ "0.86942047", "0.71866673", "0.7029208", "0.69669193", "0.6887847", "0.67700577", "0.66643125", "0.6535942", "0.63918483", "0.63843584", "0.636618", "0.63450086", "0.63026375", "0.6252001", "0.6233888", "0.6226298", "0.6150564", "0.61219764", "0.6118666", "0.6112856", "0.6090837", "0.60685945", "0.60465264", "0.60236305", "0.59703064", "0.59597814", "0.5922164", "0.59058094", "0.59038925", "0.5892678" ]

[ "def updated_object(self):\n o = deepcopy(self.object)\n o[\"name\"] += \"-copy\"\n return o", "def change_object(self, new_object):\n raise NotImplementedError", "def __call__(self, change: ChangeDict) -> None:\n old = None\n new = None\n ctype = change[\"type\"]\n if ctype == \"create\":\n new = change[\"value\"]\n elif ctype == \"update\":\n old = change[\"oldvalue\"]\n new = change[\"value\"]\n elif ctype == \"delete\":\n old = change[\"value\"]\n attr = self.attr\n owner = change[\"object\"]\n handler = getattr(owner, self.funcname)\n if isinstance(old, Atom):\n old.unobserve(attr, handler)\n if isinstance(new, Atom):\n new.observe(attr, handler)\n elif new is not None:\n msg = \"cannot attach observer '%s' to non-Atom %s\"\n raise TypeError(msg % (attr, new))", "def modified_object(obj, event):\n now = datetime.now(tz=_zone)\n obj.modification_date = now", "def modified(self, **attributes):\n new_obj = deepcopy(self)\n new_obj.__dict__.update(attributes)\n new_obj.initialize()\n return new_obj", "def exogenous_change(self):\n pass", "def exogenous_change(self):\n pass", "def exogenous_change(self):\n pass", "def save(self):\n if config is None: self.objects.reload_cache()\n # If this is a new object, we save it with config.item_add()\n if self.is_new is True or self._meta['filename'] is None:\n if not self._meta['filename']:\n 'discover a new filename'\n self._meta['filename'] = self.get_suggested_filename()\n for k,v in self._changes.items():\n self._defined_attributes[k] = v\n self._original_attributes[k] = v\n del self._changes[k]\n config.item_add(self._original_attributes, self._meta['filename'])\n return\n # If we get here, we are making modifications to an object\n number_of_changes = 0\n for field_name, new_value in self._changes.items():\n save_result = config.item_edit_field(item=self._original_attributes, field_name=field_name, new_value=new_value)\n if save_result == True:\n del self._changes[field_name]\n self._event(level='write', message=\"%s changed from '%s' to '%s'\" % (field_name, self[field_name], new_value))\n if not new_value:\n if self._defined_attributes.has_key(field_name):\n del self._defined_attributes[field_name]\n if self._original_attributes.has_key(field_name):\n del self._original_attributes[field_name]\n else:\n self._defined_attributes[field_name] = new_value\n self._original_attributes[field_name] = new_value\n number_of_changes += 1\n else:\n raise Exception(\"Failure saving object. filename=%s, object=%s\" % (self['meta']['filename'], self['shortname']) )\n self.objects.clean_cache()\n return number_of_changes", "def orig_obj(self):\n return self._orig_obj", "def orig_obj(self):\n return self._orig_obj", "def orig_obj(self):\n return self._orig_obj", "def patch(self, obj, field, value):\n return Patch(obj, field, value)", "def __copy__(self):\n copy = self.__class__(self.param)\n copy.last_string2object_failed = self.last_string2object_failed\n copy.msg_handler = self.msg_handler\n return copy", "def modified(self):\n raise NotImplementedError", "def make_immutable(self):\n # just set the flag to make object immutable and hashable\n self.immutable = True", "def _update_model_instance(self, obj_filter_dict, new_data_dict):\n obj = self._get_or_create_model_instance(obj_filter_dict)\n obj.modify(**new_data_dict)", "def get_change(self, ):\n return self.get_parameter('change')", "def add_change(self, action, name, type, ttl=600, alias_hosted_zone_id=None, alias_dns_name=None):\r\n change = Record(name, type, ttl, alias_hosted_zone_id=alias_hosted_zone_id, alias_dns_name=alias_dns_name)\r\n self.changes.append([action, change])\r\n return change", "def GetChanges(self):\n return self._changes", "def get_direct_change(self):\n return self._direct_change", "def created_changed(cls): # noqa\n\n def _set_created_and_changed(mapper, connection, instance):\n instance.created = instance.changed = datetime.utcnow()\n\n def _set_changed(mapper, connection, instance):\n instance.changed = datetime.utcnow()\n\n event.listen(cls, \"before_insert\", _set_created_and_changed)\n event.listen(cls, \"before_update\", _set_changed)\n return cls", "def __init__(self, changed_by=None, id=None, organization_id=None, entity=None, entity_id=None, audit_action=None, field_changes=None, new_entity=None, state=None, created=None):\n self.swagger_types = {\n 'changed_by': 'str',\n 'id': 'str',\n 'organization_id': 'str',\n 'entity': 'str',\n 'entity_id': 'str',\n 'audit_action': 'str',\n 'field_changes': 'list[str]',\n 'new_entity': 'list[str]',\n 'state': 'str',\n 'created': 'datetime'\n }\n\n self.attribute_map = {\n 'changed_by': 'changedBy',\n 'id': 'id',\n 'organization_id': 'organizationID',\n 'entity': 'entity',\n 'entity_id': 'entityID',\n 'audit_action': 'auditAction',\n 'field_changes': 'fieldChanges',\n 'new_entity': 'newEntity',\n 'state': 'state',\n 'created': 'created'\n }\n\n self._changed_by = changed_by\n self._id = id\n self._organization_id = organization_id\n self._entity = entity\n self._entity_id = entity_id\n self._audit_action = audit_action\n self._field_changes = field_changes\n self._new_entity = new_entity\n self._state = state\n self._created = created", "def diff(self):\n if self.event == 'Create':\n old = ''\n else:\n # Get the Change just ahead of _this_ change because that has the\n # state of the Resource before this Change occurred.\n # TODO(nickpegg): Get rid of this if we change the behavior of\n # Change to store the previous version of the object\n old_change = Change.objects.filter(\n change_at__lt=self.change_at,\n resource_id=self.resource_id,\n resource_name=self.resource_name\n ).order_by(\n '-change_at'\n ).first()\n old = json.dumps(old_change._resource, indent=2, sort_keys=True)\n\n if self.event == 'Delete':\n current = ''\n else:\n resource = apps.get_model(self._meta.app_label, self.resource_name)\n obj = resource.objects.get(pk=self.resource_id)\n\n serializer_class = self.get_serializer_for_resource(\n self.resource_name)\n serializer = serializer_class(obj)\n current = json.dumps(serializer.data, indent=2, sort_keys=True)\n\n diff = \"\\n\".join(difflib.ndiff(\n old.splitlines(),\n current.splitlines()\n ))\n\n return diff", "def getChanges():", "def assertLoggedChange(self, obj, **kwargs):\n self.assertLogged(obj, CHANGE, **kwargs)", "def make_change_plan_action(self) -> ChangePlanAction:\r\n return ChangePlanAction(\r\n change_plan_id=self.change_plan_id,\r\n step=self.step,\r\n action=self.action,\r\n original_asset_number=self.original_asset_number,\r\n new_record=self.new_record,\r\n )", "def modified(self):\n return self.__modified", "def modified(self):\n return self.__modified", "def new_object(cls):\n return cls.for_value([])" ]

[ "0.61876494", "0.5870512", "0.56965613", "0.5530178", "0.55052364", "0.54316956", "0.54316956", "0.54316956", "0.53980166", "0.5397867", "0.5397867", "0.5397867", "0.5333922", "0.53334", "0.531325", "0.5294916", "0.5289745", "0.528219", "0.5259374", "0.5217978", "0.52005905", "0.51784784", "0.5172461", "0.513816", "0.51311094", "0.5122082", "0.5120521", "0.5096946", "0.5096946", "0.5077663" ]

[ "def advertisement_id(self):\n return uuid.uuid4()", "def service_id(self) -> str:\n return pulumi.get(self, \"service_id\")", "def service_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"service_id\")", "def service_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"service_id\")", "def advertised_id(self):\n namespace = '0x' + self.uuid[:8] + self.uuid[-12:]\n major, minor = map(int, (self.major, self.minor))\n temp_instance = self._append_hex(major, minor)\n instance = self._add_padding(temp_instance)\n beacon_id = self._append_hex(int(namespace, 16), instance)\n return base64.b64encode(self.long_to_bytes(beacon_id))", "def id(self):\n return self.service_id", "def get_id(self):\n from ranger_performance_tool import perf_globals\n enabled_services = perf_globals.CONFIG_READER.get_config_value(\"secondary\", \"enabled_services\")\n service = random.choice(enabled_services)\n policy_list = self.remote_store.get_policy_list()[service]\n return random.choice(policy_list).id", "def get_uuid(self):\n uuid = self.request.GET.get('id')\n\n self.publisher = get_object_or_404(Publisher, verbose_id=uuid)\n\n if not self.publisher.is_active:\n raise Http404(\"Link already used or expired.\")\n\n self.publisher.session_start = timezone.now()\n self.publisher.save()\n\n return uuid", "def service_signal(self, service):\n signal = \"{}_{}_{}\".format(DOMAIN, service, self.unique_id.replace(\".\", \"_\"))\n return signal", "def sapd_id(self) -> str:\n return self._sapd_id", "def service_id(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"service_id\")", "def service_id(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"service_id\")", "def service_id(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"service_id\")", "def unique_id(self):\n return f\"sma-{self._sensor.key}-{self._sensor.name}\"", "def client_id(self) -> str:", "def getSerpentId(self):\n raise NotImplementedError", "def unique_id(self):\n id = \"{}{}{}\".format(\n DOMAIN, self._account, self.sensorName.lower().replace(\" \", \"\")\n )\n return id", "def id(self):\n\n return sha256(self.pub.export()).digest()", "def DeploymentId(self) -> _n_0_t_0:", "def get_primary_id(self):", "def identifier(self):\n return self._client.identifier", "def unique_id(self) -> str:\n return str(self.coordinator.gios.station_id)", "def identifier(self):\r\n return self.id", "def build_article_ap_id(self, author, article):\n if article.ap_id:\n return article.ap_id\n # Local article, build ID manually\n normalised_host = self.normalise_hostname(author.host)\n if normalised_host is None or author.host == \"\":\n normalised_host = self.normalise_hostname(self._host_name)\n return f'{normalised_host}/ap/@{author.handle}/{article.global_id}'", "async def uuid(self) -> str:\n if not hasattr(self, \"_uuid\"):\n result = await self.app.sparql.query(\"\"\"\n SELECT DISTINCT ?o\n WHERE {\n <{{uri}}> <http://mu.semte.ch/vocabularies/core/uuid> ?o .\n }\n \"\"\", uri=self.uri)\n self._uuid = result['results']['bindings'][0]['o']['value']\n return self._uuid", "def get_id(self) -> str:\n return self._register_id", "def unique_id(self):\n return f\"{self.device.id}-{self.key}\"", "def uuid(self):\n try:\n return self.keystore['id']\n except KeyError:\n return None", "def publisher(self) -> str:\n return pulumi.get(self, \"publisher\")", "def publisher(self) -> str:\n return pulumi.get(self, \"publisher\")" ]

[ "0.6714376", "0.67001706", "0.65665245", "0.65665245", "0.6548375", "0.65236896", "0.6251711", "0.6107556", "0.60676295", "0.60120785", "0.5996947", "0.59193593", "0.59193593", "0.5900588", "0.5853006", "0.5787707", "0.57624674", "0.57600904", "0.5751242", "0.5715866", "0.57096285", "0.56892776", "0.56833345", "0.566769", "0.56661624", "0.5646505", "0.56326485", "0.5629219", "0.56247574", "0.56247574" ]

[ "def monitor(self):", "def _get_status(self):\n return self.__status", "def status(self):\n raise NotImplementedError()", "def power_status(self):\n raise NotImplementedError(\"ERROR: Unimplemented function.\")", "def set_On(self):\n if not(self._locked):\n self.__dict__['statusOn']=True\n self._do_action()\n else:\n self._log.info('The JobProperty %s is blocked', self.__name__)", "def status(self):", "def get_status(self):\n return self._refreshed", "def status(self):\n pass", "def status(self):\n pass", "def GetStatus(self):\r\n return self.status", "def publish_actuator_status(self, reference):\n state, value = self.actuator_status_provider.get_actuator_status(reference)\n actuator_status = ActuatorStatus.ActuatorStatus(reference, state, value)\n outbound_message = self.outbound_message_factory.make_from_actuator_status(actuator_status)\n if not self.connectivity_service.publish(outbound_message):\n self.outbound_message_queue.put(outbound_message)", "def _ready(cls):\n sync_call(cls.ready)", "def get_raw_status(self):\n self.__param_lock.acquire()\n status = self.__status\n self.__param_lock.release()\n return status", "def get_status(self, state):\n raise NotImplementedError", "def status(self):\n return None", "def monitor(self, s):\n raise NotImplementedError()", "def poll(self):\n raise NotImplementedError()", "def status(self):\n\t\treturn self._status", "def publish_status(client):\n client.publish(config.topic_get, payload=getlight())", "def state(self):\n return self.status", "async def get_status():", "def status(self):\n return self.state", "def __await__(self):\n return self.waiter.__await__()", "def __await__(self):\n return self.waiter.__await__()", "def monitored(self):\n return self.monitor", "def getStatus():", "def status(self):\n with self.__lock:\n assert(self.__complete)\n return self.__status", "def get_Value(self):\n obj_p=object.__getattribute__(self, 'StoredValue')\n if isinstance(obj_p, type(True)):\n return obj_p & self.statusOn \n else: \n if self.statusOn: \n return obj_p \n else: \n self._log.warning('You are attempting to access the job'+ \n 'property %s which has not been set', self._context_name) \n return None", "def status(self):\r\n return self._status", "def status(self):\r\n return self._status" ]

[ "0.60354245", "0.5962349", "0.5958736", "0.59539264", "0.5925358", "0.59236515", "0.5900095", "0.57918376", "0.57918376", "0.5746601", "0.5694383", "0.56685543", "0.56662333", "0.5662871", "0.56223184", "0.5591586", "0.5569208", "0.5568028", "0.556712", "0.5565975", "0.556073", "0.5548806", "0.5547178", "0.5547178", "0.55319947", "0.5516137", "0.55028504", "0.550205", "0.5498743", "0.5498743" ]

[ "def topic(self) -> str:\n return self._topic", "def pubsub_topic(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"pubsub_topic\")", "def topic(self):\n return self.config.get('topic', f'{NAMESPACE}/{self.id}')", "def get_topic(self):\n return self.topic", "def pubsub_topic(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"pubsub_topic\")", "def kafka_topic(self) -> str:\n return self._kafka_topic", "def topic(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"topic\")", "def __get_topic(self) -> str:\n\t\treturn os.getenv('MQTT_DRIVEN_TOPIC', 'app/event')", "def __get_topic(self) -> str:\n\t\treturn os.getenv('MQTT_DRIVER_TOPIC', 'app/book/#')", "def __str__(self):\n return f\"topic: {self.__topic__}\"", "def response_kafka_topic_name(self) -> str:\n return self._response_kafka_topic_name", "def GetTopicName(args):\n if args.add_topic:\n topic_ref = args.CONCEPTS.add_topic.Parse()\n elif args.remove_topic:\n topic_ref = args.CONCEPTS.remove_topic.Parse()\n else:\n topic_ref = args.CONCEPTS.update_topic.Parse()\n\n return topic_ref.RelativeName()", "def publisher_name(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"publisher_name\")", "def partner_topic_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"partner_topic_name\")", "def getTopicName(nd_proj):\n # does not line &\n return '-'.join(nd_proj.generateProjectInfo())", "def kafka_topic(self):\n from corehq.apps.change_feed.topics import get_topic_for_doc_type\n return get_topic_for_doc_type(self.document_class().to_json()['doc_type'])", "def display_topic(self):\n return ', '.join(topic.name for topic in self.topic.all()[:3])", "def _topic(self, topic):\n base = \"engine.%s\" % self.engine_id\n\n return f\"{base}.{topic}\".encode()", "def topic(self, topic):\n self.connection.topic(str(self), topic)", "def topic_arn(self) -> Optional[str]:\n return pulumi.get(self, \"topic_arn\")", "def topic_name_from_path(path, project):\n return _name_from_project_path(path, project, _TOPIC_TEMPLATE)", "def publisher_name(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"publisher_name\")", "def publisher_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"publisher_name\")", "def topic_arn(self) -> str:\n return pulumi.get(self, \"topic_arn\")", "def sns_topic_arn(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"sns_topic_arn\")", "def create_name (self):\n return self.create_topic().create_name('Name')", "def topic_arn(self) -> str:\n return self[\"Sns\"][\"TopicArn\"]", "def publisher(self) -> str:\n return pulumi.get(self, \"publisher\")", "def publisher(self) -> str:\n return pulumi.get(self, \"publisher\")", "def publisher(self) -> str:\n return pulumi.get(self, \"publisher\")" ]

[ "0.7873912", "0.77815044", "0.7672942", "0.7589836", "0.7427634", "0.73527247", "0.7141051", "0.7079695", "0.70687497", "0.70312816", "0.7003432", "0.6849306", "0.6837315", "0.6716", "0.66638047", "0.6615674", "0.65900433", "0.6494008", "0.6449045", "0.6389532", "0.6370327", "0.62724817", "0.6259532", "0.62492216", "0.6246504", "0.6154337", "0.6149471", "0.6116299", "0.6116299", "0.6116299" ]

[ "def reset_node_ids(df):\n le = LabelEncoder()\n all_node_names = list(set(df['from_name'].values.tolist() + df['to_name'].values.tolist()))\n le.fit(all_node_names)\n df['from_id'] = le.transform(df['from_name'])\n df['to_id'] = le.transform(df['to_name'])\n return df, le", "def lemmatize(data: pd.Series) -> pd.Series:\n lemmatizer = WordNetLemmatizer()\n return data.apply(lambda row: re.sub(\n r'\\b\\w+\\b', lambda match: lemmatizer.lemmatize(\n match.group(), pos=to_pos([match.group()])), row))", "def addToGraph(tid,uid,mentions) :\n global G,found\n\n user = r.get(int(uid))\n \n if user == None :\n return\n\n user = re.findall('\"((?:(?!(?:\",\")).)*)\"', user)\n \n # lower the hashtags\n mentions = [t.lower() for t in mentions if t not in [\"\"]]\n \n usern = user[1].lower()\n\n G.add_node(usern)\n\n found = found + 1\n\n # iterate through mentions\n for m in mentions :\n # add hashtag to graph\n G.add_node(m)\n \n # update edge weight for every hashtag 2-permutation of the tweet\n if G.has_edge(usern,m) :\n G[usern][m]['weight'] += 1\n else :\n G.add_edge(usern,m,weight=1)", "def get_unlabelled_tweets_reannotation():\n conn = get_connection()\n c = conn.cursor()\n #res = c.execute('SELECT * FROM tweets WHERE tweets.is_about_depression is null AND tweets.username IN (SELECT username FROM users WHERE mentions_depr=1)').fetchall()\n res = c.execute('SELECT * FROM tweets WHERE tweets.is_about_depression IN (0, 1, 2) AND tweets.is_about_depression2 IS NULL ORDER BY random()').fetchall()\n conn.close()\n return np.array(res)", "def tweetDump2Neo(db, user, tweet_dump):\n \n # user->[tweeted/RTed/quoted]->(tweet/RT/quoteTweet)\n for label in ['tweet', 'retweet', 'quotetweet']:\n if tweet_dump[label]:\n tweets2Neo(db, tweet_dump[label], label=label)\n tweetActions(db, user, tweet_dump[label], label=label)\n \n # push original tweets from RTs/quotes\n for label in ['retweet', 'quotetweet']:\n tweets = [(tw[0],) for tw in tweet_dump[label]]\n if tweets:\n tweets2Neo(db, tweets, label='tweet')\n \n # (RT/quote)-[RETWEET_OF/QUOTE_OF]->(tweet)\n if tweet_dump['retweet']:\n tweetLinks(db, tweet_dump['retweet'], 'retweet', 'tweet', 'RETWEET_OF')\n if tweet_dump['quotetweet']:\n tweetLinks(db, tweet_dump['quotetweet'], 'quotetweet', 'tweet', 'QUOTE_OF')\n\n # push users of original tweets.\n if tweet_dump['users']:\n users2Neo(db, tweet_dump['users'].values())\n multi_user_tweet_actions(db, tweet_dump['users'])\n \n # mentions\n for label in ['tweet', 'retweet', 'quotetweet']:\n mentions = [m[1] for m in tweet_dump['entities'][label]['user_mentions']]\n if mentions:\n users2Neo(db, mentions)\n entities = tweet_dump['entities'][label]['user_mentions']\n entity_links(db, entities, 'MENTIONS', label, 'twitter_user', 'id_str', 'screen_name')\n\n # hashtags, urls and media\n for label in ['tweet', 'retweet', 'quotetweet']:\n for entity_type in ['hashtags', 'urls', 'media']:\n entities = [e[1] for e in tweet_dump['entities'][label][entity_type]]\n if entities:\n entities2neo(db, entities, entity_type)\n\n if tweet_dump['entities'][label]['hashtags']:\n entity_links(db, tweet_dump['entities'][label]['hashtags'],\n 'TAGGED', label, 'hashtag', 'id_str', 'text')\n \n if tweet_dump['entities'][label]['urls']:\n entity_links(db, tweet_dump['entities'][label]['urls'],\n 'LINKS_TO', label, 'url', 'id_str', 'expanded_url')\n \n if tweet_dump['entities'][label]['media']:\n entity_links(db, tweet_dump['entities'][label]['media'],\n 'EMBEDS', label, 'media', 'id_str', 'id_str')", "def preprocess_tweet(tweet):\n clean_tweet = tp.clean(tweet)\n\n # perform lemmatization\n tokenizer = TweetTokenizer()\n tweet_tokens = tokenizer.tokenize(clean_tweet)\n\n lemmatized_tweet = lemmatize_tweet(tweet_tokens)\n\n # remove stopwords\n preprocessed_tweet = remove_stopwords(lemmatized_tweet)\n return preprocessed_tweet", "def preprocess_tweet(tweet):\n\n\n clean_tweet, hashtags = separate_hastags_mentions_urls(tweet)\n clean_tweet = remove_emoji_punc(clean_tweet)\n return clean_tweet, hashtags", "def multiUserTweetDump2Neo(db, tweet_dump):\n\n # user->[tweeted/RTed/quoted]->(tweet/RT/quoteTweet)\n for label in ['tweet', 'retweet', 'quotetweet']:\n if tweet_dump[label]:\n tweets2Neo(db, tweet_dump[label], label=label)\n multi_user_labelled_tweet_actions(db, tweet_dump[label], label=label)\n\n # push original tweets from RTs/quotes\n for label in ['retweet', 'quotetweet']:\n tweets = [(tw[0],) for tw in tweet_dump[label]]\n if tweets:\n tweets2Neo(db, tweets, label='tweet')\n\n # (RT/quote)-[RETWEET_OF/QUOTE_OF]->(tweet)\n if tweet_dump['retweet']:\n tweetLinks(db, tweet_dump['retweet'], 'retweet', 'tweet', 'RETWEET_OF')\n if tweet_dump['quotetweet']:\n tweetLinks(db, tweet_dump['quotetweet'], 'quotetweet', 'tweet', 'QUOTE_OF')\n\n # push users of original tweets.\n if tweet_dump['users']:\n users2Neo(db, tweet_dump['users'].values())\n multi_user_tweet_actions(db, tweet_dump['users'])\n\n # mentions\n for label in ['tweet', 'retweet', 'quotetweet']:\n mentions = [m[1] for m in tweet_dump['entities'][label]['user_mentions']]\n if mentions:\n users2Neo(db, mentions)\n entities = tweet_dump['entities'][label]['user_mentions']\n entity_links(db, entities, 'MENTIONS', label, 'twitter_user', 'id_str', 'screen_name')\n\n # hashtags, urls and media\n for label in ['tweet', 'retweet', 'quotetweet']:\n for entity_type in ['hashtags', 'urls', 'media']:\n entities = [e[1] for e in tweet_dump['entities'][label][entity_type]]\n if entities:\n entities2neo(db, entities, entity_type)\n\n if tweet_dump['entities'][label]['hashtags']:\n entity_links(db, tweet_dump['entities'][label]['hashtags'],\n 'TAGGED', label, 'hashtag', 'id_str', 'text')\n\n if tweet_dump['entities'][label]['urls']:\n entity_links(db, tweet_dump['entities'][label]['urls'],\n 'LINKS_TO', label, 'url', 'id_str', 'expanded_url')\n\n if tweet_dump['entities'][label]['media']:\n entity_links(db, tweet_dump['entities'][label]['media'],\n 'EMBEDS', label, 'media', 'id_str', 'id_str')", "def simplify_directed_as_dataframe(df: gpd.GeoDataFrame) -> gpd.GeoDataFrame:\n df.reset_index(inplace=True)\n\n g = gt.Graph(directed=True)\n osm_id = g.new_edge_property('string')\n highway = g.new_edge_property('string')\n level = g.new_edge_property('int')\n lanes = g.new_edge_property('int')\n width = g.new_edge_property('float')\n bicycle = g.new_edge_property('bool')\n bicycle_safety = g.new_edge_property('int')\n foot = g.new_edge_property('bool')\n foot_safety = g.new_edge_property('int')\n max_speed = g.new_edge_property('int')\n motorcar = g.new_edge_property('bool')\n linestring = g.new_edge_property('python::object')\n\n edgelist = df[\n ['u', 'v', 'osm_id', 'highway', 'level', 'lanes', 'width', 'bicycle', 'bicycle_safety', 'foot', 'foot_safety',\n 'max_speed', 'motorcar', 'geometry']].values\n\n nodes_id = g.add_edge_list(edgelist, hashed=True,\n eprops=[osm_id, highway, level, lanes, width, bicycle, bicycle_safety, foot, foot_safety,\n max_speed, motorcar, linestring])\n\n # we are gonna replace the original repeated nodes with a linestring\n e_path = g.new_ep('vector<int64_t>')\n for e in g.edges():\n e_path[e] = []\n\n vs = g.get_vertices()\n in_out_deg_2 = (g.get_in_degrees(vs) == 2) & (g.get_out_degrees(vs) == 2)\n\n logging.debug('selecting degree 4 candidates')\n candidates = set()\n for i, v in enumerate(vs):\n if in_out_deg_2[i]:\n ns = list(set(g.get_all_neighbors(v)))\n if len(ns) == 2:\n u, w = ns[0], ns[1]\n uv, vw, wv, vu = g.edge(u, v), g.edge(v, w), g.edge(w, v), g.edge(v, u)\n if highway[uv] == highway[vw] and highway[wv] == highway[vu]:\n candidates.add(v)\n logging.debug('found {} degree 4 candidates to simplify'.format(len(candidates)))\n\n seen = set()\n unregister_candidates = set()\n\n for i, candidate in enumerate(candidates):\n if i == 100000:\n logging.debug('100000 degree 4 candidates')\n if candidate in seen:\n continue\n\n seen.add(candidate)\n\n u, w = g.get_out_neighbors(candidate)\n is_u_fringe, is_w_fringe = u not in candidates, w not in candidates\n\n cu, cw = g.edge(candidate, u), g.edge(candidate, w)\n\n us = []\n ws = []\n\n while not is_u_fringe:\n seen.add(u)\n us.append(u)\n neighbors = set(g.get_out_neighbors(u))\n neighbors -= seen\n if len(neighbors) > 0:\n u = neighbors.pop()\n is_u_fringe = u not in candidates\n elif u == w:\n us.pop(-1)\n u = us.pop(-1)\n unregister_candidates.add(u)\n unregister_candidates.add(w)\n is_u_fringe = True\n is_w_fringe = True\n g.remove_edge(g.edge(s=u, t=w))\n g.remove_edge(g.edge(s=w, t=u))\n else:\n logging.debug('degree 2: we got here somehow {} {} {} {}', candidate, u, v,\n g.get_all_neighbors(candidate))\n break\n\n while not is_w_fringe:\n seen.add(w)\n ws.append(w)\n neighbors = set(g.get_out_neighbors(w))\n neighbors -= seen\n if len(neighbors) > 0:\n w = neighbors.pop()\n is_w_fringe = w not in candidates\n else:\n logging.debug('degree 2: we got here somehow {} {} {} {}', candidate, u, v,\n g.get_all_neighbors(candidate))\n break\n\n if is_u_fringe and is_w_fringe:\n e = g.add_edge(source=u, target=w)\n path = [u] + list(reversed(us)) + [candidate] + ws + [w]\n e_path[e] = [int(nodes_id[node]) for node in path]\n linestrings = [linestring[g.edge(a, b)] for a, b in pairwise(path)]\n linestring[e] = join_linestrings(linestrings)\n osm_id[e], highway[e], level[e], lanes[e], width[e], bicycle[e], bicycle_safety[e], foot[e], foot_safety[e], \\\n max_speed[e], motorcar[e] = osm_id[cw], highway[cw], level[cw], lanes[cw], width[cw], bicycle[cw], \\\n bicycle_safety[cw], \\\n foot[cw], foot_safety[cw], max_speed[cw], motorcar[cw]\n\n e = g.add_edge(source=w, target=u)\n path = [w] + list(reversed(ws)) + [candidate] + us + [u]\n e_path[e] = [int(nodes_id[node]) for node in path]\n linestrings = [linestring[g.edge(a, b)] for a, b in pairwise(path)]\n linestring[e] = join_linestrings(linestrings)\n osm_id[e], highway[e], level[e], lanes[e], width[e], bicycle[e], bicycle_safety[e], foot[e], foot_safety[e], \\\n max_speed[e], motorcar[e] = osm_id[cu], highway[cu], level[cu], lanes[cu], width[cu], bicycle[cu], \\\n bicycle_safety[cu], \\\n foot[cu], foot_safety[cu], max_speed[cu], motorcar[cu]\n\n else:\n logging.debug(\n 'unexpected behavior, source={0}, target={1}, candidate={2}, us={3}, ws={4}'.format(u, w, candidate, us,\n ws))\n\n unseen = candidates - seen\n if len(unseen) > 0:\n logging.debug(\n 'Network scan after degree 4 simplification uncomplete: candidates {0} have not been examined'.format(\n unseen))\n\n candidates -= unregister_candidates\n g.remove_vertex(list(candidates))\n\n vs = g.get_vertices()\n in_out_deg_1 = (g.get_in_degrees(vs) == 1) & (g.get_out_degrees(vs) == 1)\n\n logging.debug('selecting degree 2 candidates')\n candidates = set()\n for i, v in enumerate(vs):\n if in_out_deg_1[i]:\n u = g.get_in_neighbors(v)[0]\n w = g.get_out_neighbors(v)[0]\n\n if u != w:\n uv, vw = g.edge(u, v), g.edge(v, w)\n if highway[uv] == highway[vw]:\n candidates.add(v)\n logging.debug('found {} degree 2 candidates to simplify'.format(len(candidates)))\n\n seen = set()\n unregister_candidates = set()\n\n for candidate in candidates:\n if candidate in seen:\n continue\n\n seen.add(candidate)\n\n u = g.get_in_neighbors(candidate)[0]\n w = g.get_out_neighbors(candidate)[0]\n\n uc = g.edge(u, candidate)\n\n is_u_fringe, is_w_fringe = u not in candidates, w not in candidates\n\n us = []\n ws = []\n\n while not is_u_fringe:\n seen.add(u)\n us.append(u)\n neighbors = set(g.get_in_neighbors(u))\n neighbors -= seen\n if len(neighbors) > 0:\n u = neighbors.pop()\n is_u_fringe = u not in candidates\n elif u == w:\n us.pop(-1)\n u = us.pop(-1)\n unregister_candidates.add(u)\n unregister_candidates.add(w)\n is_u_fringe = True\n is_w_fringe = True\n g.remove_edge(g.edge(s=w, t=u))\n else:\n logging.debug('degree 1: we got here somehow {} {} {} {}', candidate, u, v,\n g.get_all_neighbors(candidate))\n break\n\n while not is_w_fringe:\n seen.add(w)\n ws.append(w)\n neighbors = set(g.get_out_neighbors(w))\n neighbors -= seen\n if len(neighbors) > 0:\n w = neighbors.pop()\n is_w_fringe = w not in candidates\n else:\n logging.debug('degree 1: we got here somehow {} {} {} {}', candidate, u, v,\n g.get_all_neighbors(candidate))\n break\n\n if is_u_fringe and is_w_fringe:\n e = g.add_edge(source=u, target=w)\n path = [u] + list(reversed(us)) + [candidate] + ws + [w]\n e_path[e] = [int(nodes_id[node]) for node in path]\n linestrings = [linestring[g.edge(a, b)] for a, b in pairwise(path)]\n linestring[e] = join_linestrings(linestrings)\n osm_id[e], highway[e], level[e], lanes[e], width[e], bicycle[e], bicycle_safety[e], foot[e], foot_safety[e], \\\n max_speed[e], motorcar[e] = osm_id[uc], highway[uc], level[uc], lanes[uc], width[uc], bicycle[uc], \\\n bicycle_safety[uc], \\\n foot[uc], foot_safety[uc], max_speed[uc], motorcar[uc]\n else:\n logging.error('unexpected behavior, source={0}, target={1}, candidate={2}, us={3}, ws={4}', u, w, us, ws)\n\n unseen = candidates - seen\n if len(unseen) > 0:\n logging.debug(\n 'Network scan after degree 2 simplification not finished: candidates {0} have not been examined'.format(\n unseen))\n\n candidates -= unregister_candidates\n g.remove_vertex(list(candidates))\n\n logging.debug(' linestring path')\n edges_tuples = []\n for e in g.edges():\n source, target, path = nodes_id[e.source()], nodes_id[e.target()], e_path[e]\n if len(path) == 0:\n path = [source, target]\n else:\n path = [int(i) for i in path]\n\n e_tuples = (g.edge_index[e], source, target, path,\n osm_id[e], highway[e], level[e], lanes[e], width[e], bicycle[e], bicycle_safety[e], foot[e],\n foot_safety[e], max_speed[e], motorcar[e], linestring[e])\n edges_tuples.append(e_tuples)\n\n df_edges_simplified = pd.DataFrame.from_records(edges_tuples, index='edge_id',\n columns=['edge_id', 'u', 'v', 'path', 'osm_id', 'highway',\n 'level', 'lanes', 'width', 'bicycle', 'bicycle_safety',\n 'foot', 'foot_safety', 'max_speed', 'motorcar',\n 'geometry'])\n\n df_edges_simplified.osm_id = df_edges_simplified.osm_id.str.split('-').str[0]\n df_edges_simplified = gpd.GeoDataFrame(df_edges_simplified, geometry='geometry')\n df_edges_simplified.crs = df.crs\n return df_edges_simplified", "def annotate_tm_edge_label(self):\n if self._mapping is not None:\n kw = dict(fontsize=6, color='black', ha='center')\n m = self._mapping\n n_rows = m.metadata['n_rows']\n f_tm_top = lambda g: m.ix[m.ix[g.index]['row'].idxmax(), 'slot']\n f_tm_bottom = lambda g: m.ix[m.ix[g.index]['row'].idxmin(), 'slot']\n tm_top = np.unique(m.groupby('col').agg(f_tm_top)['slot'])\n tm_bottom = np.unique(m.groupby('col').agg(f_tm_bottom)['slot'])\n for tm in tm_top:\n df = m.loc[m['slot'] == tm]\n row = df['row'].max() + n_rows/48 + 0.4\n col = df['col'].mean()\n tm_txt = \"TM{:02d}\".format(tm)\n self.ax.text(col, row, tm_txt, va='bottom', **kw)\n for tm in tm_bottom:\n df = m.loc[m['slot'] == tm]\n row = df['row'].min() - n_rows/48 - 0.4\n col = df['col'].mean()\n tm_txt = \"TM{:02d}\".format(tm)\n self.ax.text(col, row, tm_txt, va='top', **kw)\n else:\n print(\"Cannot annotate, no mapping attached to class\")", "def sents(path):\n\n data = pd.read_csv( path , sep = \"\\t\", index_col=False, encoding='latin-1', low_memory=False)\n df = DataFrame(data)\n# print(df['Sentiment'])\n labelCount = df.groupby(df['Sentiment']).count()\n #print(labelCount)\n x = df['SentimentText'].str.replace('http\\S+|www.\\S+', '', case=False)\n y = df['Sentiment']\n x = x.str.replace('[^a-zA-Z]', ' ') #\n x_check = [\" \".join([lemmatize(word) for word in sentence.split(\" \")]) for sentence in x]\n stopset = set(stopwords.words('English'))\n x_check = [' '.join(w for w in sentence.split() if w.lower() not in stopset)\n for sentence in x\n ]\n #print(x_check)\n return x_check, y", "def flatten_row(row):\n # [u'hop_survey.node_id', u'hop_survey.created', u'hop_survey',\n # u'case.node_id', u'case',\n # u'experiment.node_id', u'experiment',\n # u'project.node_id', u'project',\n # u'program.node_id', u'program']\n label_created_col_name = [k for k in row.keys() if 'created' in k][0]\n label_object_col_name = label_created_col_name.split('.')[0]\n label_node_id_col_name = '{}.node_id'.format(label_object_col_name)\n\n flattened = row[label_object_col_name]\n flattened['_created'] = row[label_created_col_name]\n flattened['_node_id'] = row[label_node_id_col_name]\n\n path_members = [k for k in row.keys() if 'node_id' not in k and label_object_col_name not in k]\n for path_member in path_members:\n for k in row[path_member]:\n flattened['{}_{}'.format(path_member, k)] = row[path_member][k]\n flattened['{}_{}'.format(path_member, 'node_id')] = row['{}.node_id'.format(path_member)]\n\n return flattened", "def preprocess_tweet(self, tweet):\n\n\t\treplaced_urls = [] # Create an empty list\n\t\treplaced_mentions = [] # Create an empty list\n\n\t\t# Replace emojis\n\t\ttweet = emoji.demojize(tweet)\n\n\t\t# Tokenize using NLTK\n\t\ttokenizer = TweetTokenizer(preserve_case=False, reduce_len=True)\n\t\ttokens = tokenizer.tokenize(tweet)\n\n\t\t# Iterate over tokens\n\t\tfor index, token in enumerate(tokens):\n\t\t\t# Replace URLs\n\t\t\tif token[0:4] == \"http\":\n\t\t\t\treplaced_urls.append(token)\n\t\t\t\ttokens[index] = \"<URLURL>\"\n\t\t\t\t# ↳ *tokens[index]* will directly modify *tokens*, whereas any changes to *token* will be lost.\n\n\t\t\t# Replace mentions (Twitter handles; usernames)\n\t\t\telif token[0] == \"@\" and len(token) > 1:\n\t\t\t\t# ↳ Skip the single '@' tokens\n\t\t\t\treplaced_mentions.append(token)\n\t\t\t\ttokens[index] = \"<UsernameMention>\"\n\n\t\t# Detokenize using NLTK's Treebank Word Detokenizer\n\t\tdetokenizer = TreebankWordDetokenizer()\n\t\tprocessed_tweet = detokenizer.detokenize(tokens)\n\n\t\t# *replaced_urls* and *replaced_mentions* will contain all of the replaced URLs and Mentions of the input string.\n\t\treturn processed_tweet", "def process_pm_row(row):\n out = row.copy()\n new_input = insert_postmod_token(row['sentence'], row['target'])\n out['input'] = new_input\n del out['sentence']\n return out", "def cleaninto_df(frame:pd) -> pd:\n # remove repeated characters EXAMPLE: DIMPLLLLEEEEE -> DIMPLE\n # nopunc = word_tokenize(nopunc) this might not work. find something else\n\n stop = stopwords.words('english')\n newStopWords = ['get', 'http','there','and','i','t','it','d']\n stop.extend(newStopWords)\n lemmatizer = WordNetLemmatizer()\n clean = []\n new_col = []\n frame['Cleaned'] = None\n for tweet in frame.content:\n if 'RT' in tweet:\n if tweet.index('RT')>5:\n tweet = tweet[:tweet.index('RT')]\n else:\n tweet = tweet[2:]\n # WHAT ARE WE TRYING TO CLEAN HERE?\n # cleaning with preprocessor library https://pypi.org/project/tweet-preprocessor/\n tweet = ' '.join(re.sub(\"(@\\w+)|([^A-Za-z]+)|(\\w+:\\/\\/\\S+)\", \" \", tweet).split())\n # changes #November1 -> November: need to remove full hashtag?\n # changes @poetweatherford: -> poetweatherford\n # changes don’t -> don t, children's -> children s\n print(\"after regex:\" + str(tweet))\n clean.append(tweet.lower())\n for clean_tweet in clean:\n word_tokens = word_tokenize(clean_tweet)\n clean_tokens = [word for word in word_tokens if word not in stop]\n stems = []\n for item in clean_tokens:\n stems.append(lemmatizer.lemmatize(item))\n new_sentence = ' '.join(stems)\n new_col.append(new_sentence.lower())\n frame['Cleaned'] = new_col\n return frame", "def sanitize_labels(df):\n df['labels'] = df['query'].apply(lambda x: x.replace(' ', '<br>')) # linebreaks\n df['ranking_label'] = df.ranking.replace({'top': f'Evergreens - updated {df.date[0]}',\n 'rising': f'Trending - updated {df.date[0]}'})\n return df", "def convert_mel_spectrogram_to_linear(self, mel: 'torch.tensor', **kwargs) -> 'torch.tensor':", "def addTweetHashtagEdges(self):\n self.hashtagGraph.add_edges_from(self.builtEdgeList)", "def plot_reason(tweets, sentiment_scores):\n\n \"\"\"\n Calculate the sentiment of each individual token in the tweets.\n \"\"\"\n\n # list tokens, keeping only unique tokens (e.g. remove repeated words).\n all_toks = []\n for tweet in tweets:\n toks = tweet.lower().split()\n all_toks.extend(toks)\n all_toks = [tok for tok in set(all_toks)] # remove duplicates.\n\n # calculate sentiment of each token.\n sm = VaderSentimentModel()\n toks_sentiment = [sm.classify_sentiment(tok) for tok in all_toks]\n\n \"\"\" \n sort tokens by sentiment.\n if overall valence is negative, sort negative to postitive.\n if overall valence is positive, sort positive to negative.\n thus, in any case, the earliest elements in the list are the most informative words.\n \"\"\"\n\n nwords = 20\n\n # negative? sort neg -> positive.\n if np.mean(sentiment_scores) < 0:\n sorted_indices = np.argsort(toks_sentiment)\n # else (positive)? sort positive -> negative\n else:\n sorted_indices = np.argsort(toks_sentiment)[::-1]\n\n # toks_to_plot: shape (nwords, ) list of informative tokens.\n # sentiment_to_plot: shape (nwords, ) list of sentiment of these tokens.\n toks_to_plot = np.array(all_toks)[sorted_indices][:nwords]\n sentiment_to_plot = np.array(toks_sentiment)[sorted_indices][:nwords]\n\n # convert all sentiment scores to positive values.\n # this is for DISPLAY only, to make all plots go from left to right.\n # we still retain the correct tokens and sorting order.\n sentiment_to_plot = np.array([abs(v) for v in sentiment_to_plot])\n\n \"\"\"\n Set up plot.\n - create data source object.\n - define formatting variables. \n \"\"\"\n text_offset = 0.1\n\n source = ColumnDataSource(data={\n \"token\": toks_to_plot,\n \"sentiment\": sentiment_to_plot,\n \"x\": np.arange(len(toks_to_plot))[::-1],\n \"label_x\": sentiment_to_plot + text_offset\n })\n\n \"\"\"\n Make plot.\n \"\"\"\n\n # Create initial plot.\n width = 0.9\n xrange = [0, max(sentiment_to_plot) + 1]\n p2 = figure(x_axis_label=\"Sentiment\", y_axis_label=\"Word\", x_range=xrange)\n p2.hbar(source=source, y=\"x\", right=\"sentiment\", height=width)\n\n \"\"\"\n Format plot.\n \"\"\"\n\n # Annotate each bar with the word being represented.\n glyph = Text(x=\"label_x\", y=\"x\", text=\"token\")\n p2.add_glyph(source, glyph)\n\n # Axis labels.\n p2.xaxis.axis_label_text_font_size = \"15pt\"\n p2.yaxis.axis_label_text_font_size = \"15pt\"\n\n # Remove ticks.\n p2.xaxis.major_tick_line_color = None\n p2.xaxis.minor_tick_line_color = None\n p2.yaxis.major_tick_line_color = None\n p2.yaxis.minor_tick_line_color = None\n\n # Remove y axis tick labels.\n p2.yaxis.major_label_text_font_size = '0pt'\n\n # Plot width, height.\n scale = 1.5\n p2.plot_height = int(250 * scale)\n p2.plot_width = int(250 * scale)\n\n # remove toolbar (e.g. move, resize, etc) from right of plot.\n p2.toolbar.logo = None\n p2.toolbar_location = None\n\n # remove gridlines\n p2.xgrid.visible = False\n p2.ygrid.visible = False\n\n # remove x axis tick labels (set font to 0pt)\n p2.xaxis.major_label_text_font_size = '0pt'\n\n # get bokeh component for plot 2.\n script2, div2 = components(p2)\n\n return (script2, div2)", "def preprocess_data(data, tweet_column, column_label):\n\n le = LabelEncoder()\n ohe = OneHotEncoder(sparse=False)\n\n ints = le.fit_transform(data.loc[:, column_label].astype(str))\n labels = ohe.fit_transform(ints.reshape(len(ints), 1))\n\n lst = np.array(data.values.tolist())\n tweets = [clean_str(twt) for twt in list(lst[:, tweet_column])]\n padded = pad_tweets(tweets)\n vocabulary, vocabulary_inv = build_vocab(padded)\n x, y = build_input_data(padded, labels, vocabulary)\n return [x, y, vocabulary, vocabulary_inv, le, ohe]", "def extract_emo_relations(self):\n for tweet_idx, tweet in enumerate(self.tweets):\n tweet_tokens = []\n idx2word, child2parent = {}, {}\n for word in tweet.rstrip().split('\\n'):\n if not word:\n sys.stderr.write(\"wat\")\n continue\n curr_word = Word(word.rstrip().split('\\t'), tweet_idx)\n idx2word[curr_word.idx] = curr_word\n child2parent[curr_word] = curr_word.parent\n\n # Isolate emotion words that are Verbs or Adjectives\n if curr_word.text in self.emo_kws and curr_word.pos in self.POS_LIST:\n self.tweet2emo[tweet_idx].append(curr_word)\n curr_word.is_emotion_word = True\n\n tweet_tokens.append(curr_word.text)\n\n # update tweet dictionary and add children to words\n self.add_relatives(child2parent, idx2word)\n tweet_text = \" \".join(tweet_tokens)\n self.idx2tweet[tweet_idx] = tweet_text\n\n # Create Tweet object\n self.add_tweet(tweet_idx, tweet_text, tweet_tokens, list(idx2word.values()))", "def lemmatization(dataset):\n\n lemmatizer = WordNetLemmatizer()\n new_dataset = np.array([])\n for sent in dataset:\n new_sent = [lemmatizer.lemmatize(w) for w in sent]\n new_dataset = np.append(new_dataset, list([new_sent]))\n return new_dataset", "def extract_municipality_hashtags(df):\n mun_dict = {\n '@CityofCTAlerts' : 'Cape Town',\n '@CityPowerJhb' : 'Johannesburg',\n '@eThekwiniM' : 'eThekwini' ,\n '@EMMInfo' : 'Ekurhuleni',\n '@centlecutility' : 'Mangaung',\n '@NMBmunicipality' : 'Nelson Mandela Bay',\n '@CityTshwane' : 'Tshwane'\n }\n municipality = []\n hashtags = [] #creates two empty lists\n\n tweets = [i.split(\" \") for i in df['Tweets']] #creates a list from datframe column\n\n new_munic_list = []\n new_tag_list = [] #final set of lists that will be added into the dataframe\n\n for tweet in tweets: #appends the initial set of lists to extract words starting with # and key values of mun dict\n municipality.append([mun_dict[word] for word in tweet if word in list(mun_dict.keys())])\n hashtags.append([tag.lower() for tag in tweet if tag.startswith('#')])\n\n for item in municipality:\n if item == []: \n item = np.nan #if list is empty, retunr NaN\n new_munic_list.append(item) \n\n for tag in hashtags:\n if tag == []:\n tag = np.nan\n new_tag_list.append(tag)\n \n df['municipality'] = new_munic_list #creates two new columns in dataframe with #'s and key values from mun_dict dictionary\n df['hashtags'] = new_tag_list\n \n return df", "def _refine_matrix_with_additional_connections(self):\n new_graph = self.graph.copy()\n for node in tqdm.tqdm(self.graph.nodes(), disable=not self.verbose):\n if self.graph.node[node][\"type\"] == \"hashtag\":\n for neighbour in self.graph.neighbors(node):\n if self.graph.node[neighbour][\"type\"] == \"username\":\n for other_node in self.graph.neighbors(neighbour):\n if self.graph.node[other_node][\"type\"] == \"hashtag\" \\\n and not self.graph.has_edge(node, other_node) \\\n and not node == other_node:\n new_graph.add_edge(node, other_node)\n self.graph = new_graph", "def df_lda_preprocessing(df, col_name, remove_stopwords=True, add_features=False):\n df['text'] = df[col_name] # Create a copy of the input col_name: text\n \n # df_clean_sting(df, 'text') # Clean the text from col_name # TEST FJERN RENGØRING\n\n # Test other way of handling strings\n df_simple_clean_string(df, 'text')\n\n if add_features:\n df_make_features_from_string(df, 'text') # Add features\n\n # This is a hack soly for the scope of this project to concat ThreadSubject\n # When the message is initiated by the Member\n if col_name == 'SignalMessageBodyClean':\n df_aka = df.copy(deep=True)\n # df_aka['text_1'] = df_aka['ThreadSubject']\n # df_clean_sting(df_aka, 'ThreadTopic')\n df_simple_clean_string(df_aka, 'ThreadTopic')\n\n df['text'] = (df['text'] +' '+df_aka['ThreadTopic']).where(df['IsFirstMessageInthread']==1,df['text'])\n\n df_get_tokens(df, 'text') # Returns col: tokenized_text\n\n # df_stem_words(df, 'tokenized_text') # Returns col: stemmed_text\n\n df_bigrams(df, 'tokenized_text') # Returns bigrams\n df_trigrams(df, 'tokenized_text') # Returns trigrams\n\n df['ngrams'] = df['tokenized_text'] + df['bigrams'] + df['trigrams']\n\n if remove_stopwords:\n df_remove_stopwords(df, 'ngrams') # returns stopwords_removed", "def get_hashtags_df(graph_path: str = '/data/graphs/train_graph.p') -> pd.DataFrame:\n with open(PATH + graph_path, 'rb') as f:\n G = pickle.load(f)\n\n hashtags = [{'hashtag': node, **G.nodes[node]}\n for node in G.nodes\n if G.nodes[node]['node_type'] == 'hashtag']\n hashtags = pd.DataFrame(hashtags)\n return hashtags", "def extract_lemmas(lines_raw, mystem):\n lines_lemmatized = []\n for line_raw in lines_raw:\n words_analyses = mystem.analyze(line_raw)\n line_lemmas = \" \".join([parse[\"analysis\"][0][\"lex\"] for parse in words_analyses if parse.get(\"analysis\")])\n lines_lemmatized.append(line_lemmas)\n return lines_lemmatized", "def flattenAnnotations(transcriptAnnotations):\n root = StatNode()\n root.name = 'not_ok'\n for ta in transcriptAnnotations:\n pos = root\n # descend the implicit heirarchy of the labels and build a tree\n for label in ta.labels:\n label = cleanLabel(label)\n if label not in pos.childrenNames:\n n = StatNode()\n n.name = label\n n.parent = pos\n n.heirarchy = pos.heirarchy[:]\n n.heirarchy.append(n.name)\n pos.childrenNames[label] = n\n pos.children.append(n)\n pos = pos.childrenNames[label]\n return root", "def map_tweepy_array (self, tweet):\n new_tweet = [tweet.created_at,\n tweet.id,\n tweet.id_str,\n tweet.truncated,\n tweet.text,\n str(constants.TRACKS),\n tweet.source,\n tweet.source_url,\n tweet.in_reply_to_status_id,\n tweet.in_reply_to_status_id_str,\n tweet.in_reply_to_user_id,\n tweet.in_reply_to_user_id_str,\n tweet.in_reply_to_screen_name,\n tweet.user.screen_name,\n tweet.user.location,\n tweet.geo,\n tweet.coordinates,\n tweet.place,\n tweet.contributors,\n tweet.is_quote_status,\n tweet.retweet_count,\n tweet.favorite_count,\n tweet.favorited,\n tweet.retweeted,\n tweet.lang ]\n\n return new_tweet", "def tweet_preprocess(tweet, append_hashtag, test_file=False):\n if test_file:\n tweet = tweet.split(',', 1)[1]\n tweet = re.sub(r'<3|< 3', '<heart>', tweet)\n res = []\n for word in tweet.split(' '):\n w = re.sub(r'[\\.\\*,%/\\\\\"\\-\\_]+', ' ', word)\n w = tweet_grammar_rules(w)\n w = tweet_clean_numbers(w)\n w = tweet_clean_dup_chars(w)\n w = tweet_split_hashtags(w, append_hashtag)\n res.append(w)\n tweet = ' '.join(res).strip()\n tweet = re.sub(r'[ ]+', ' ', tweet)\n return tweet" ]

[ "0.53392446", "0.53363657", "0.53016007", "0.52973044", "0.5226778", "0.5155888", "0.51276714", "0.5085444", "0.4898099", "0.4861826", "0.48439053", "0.481717", "0.48156443", "0.4814153", "0.47771806", "0.4760283", "0.475947", "0.47401556", "0.47281075", "0.46995685", "0.46956778", "0.46571055", "0.46563962", "0.4650436", "0.46453455", "0.46387392", "0.46333063", "0.461716", "0.4615685", "0.4600078" ]

[ "def _initialize(self):\n for doc_index, doc in enumerate(self.document):\n temp_word_topic_matrix = []\n for word in doc:\n if word in self.word2id.keys():\n start_topic_index = np.random.randint(0, self.K)\n temp_word_topic_matrix.append(start_topic_index)\n self.doc_topic_matrix[doc_index, start_topic_index] += 1\n self.topic_word_matrix[start_topic_index, self.word2id[word]] += 1\n self.topic_matrix[start_topic_index] += 1\n self.current_word_topic_matrix.append(temp_word_topic_matrix)", "def __init__(self, n, sents, corpus='', gamma=None, addone=True):\n self.n = n\n self.smoothingtechnique = 'Interpolated (Jelinek Mercer) Smoothing'\n self.gamma = gamma\n self.addone = addone\n self.counts = counts = defaultdict(int)\n self.gamma_flag = True\n self.corpus = corpus\n # way more efficient than use set unions\n voc = ['</s>']\n for s in sents:\n voc += s\n self.voc = list(set(voc))\n\n if gamma is None:\n self.gamma_flag = False\n\n # if not gamma given\n if not self.gamma_flag:\n total_sents = len(sents)\n aux = int(total_sents * 90 / 100)\n # 90 per cent for training\n train_sents = sents[:aux]\n # 10 per cent for perplexity (held out data)\n held_out_sents = sents[-total_sents+aux:]\n\n train_sents = list(map((lambda x: ['<s>']*(n-1) + x), train_sents))\n train_sents = list(map((lambda x: x + ['</s>']), train_sents))\n\n for sent in train_sents:\n for j in range(n+1):\n # move along the sent saving all its j-grams\n for i in range(n-j, len(sent) - j + 1):\n ngram = tuple(sent[i: i + j])\n counts[ngram] += 1\n # added by hand\n counts[('</s>',)] = len(train_sents)\n # variable only for tests\n self.tocounts = counts\n # search the gamma that gives lower perplexity\n gamma_candidates = [i*50 for i in range(1, 15)]\n # xs is a list with (gamma, perplexity)\n xs = []\n sents = train_sents\n for aux_gamma in gamma_candidates:\n self.gamma = aux_gamma\n aux_perx = self.perplexity(held_out_sents)\n xs.append((aux_gamma, aux_perx))\n xs.sort(key=lambda x: x[1])\n self.gamma = xs[0][0]\n with open('old-stuff/interpolated_' + str(n) + '_parameters_'+corpus, 'a') as f:\n f.write('Order: {}\\n'.format(self.n))\n f.write('Gamma: {}\\n'.format(self.gamma))\n f.write('AddOne: {}\\n'.format(self.addone))\n f.write('Perplexity observed: {}\\n'.format(xs[0][1]))\n f.write('-------------------------------\\n')\n f.close()\n\n else:\n sents = list(map((lambda x: ['<s>']*(n-1) + x), sents))\n sents = list(map((lambda x: x + ['</s>']), sents))\n\n for sent in sents:\n # counts now holds all k-grams for 0 < k < n + 1\n for j in range(n+1):\n # move along the sent saving all its j-grams\n for i in range(n-j, len(sent) - j + 1):\n ngram = tuple(sent[i: i + j])\n counts[ngram] += 1\n # added by hand\n counts[('</s>',)] = len(sents)", "def get_features_train(tweets):\n feats = get_feature_array(tweets)\n tfidf = vectorizer.fit_transform(tweets).toarray()\n M = np.concatenate([tfidf,feats],axis=1)\n return M", "def __init__(self, n, sents, corpus='', beta=None, addone=True):\n self.n = n\n self.beta = beta\n self.corpus = corpus\n self.beta_flag = True\n self.addone = addone\n self.smoothingtechnique = 'Back Off (Katz) with Discounting Smoothing'\n self.counts = counts = defaultdict(int)\n self.A_set = defaultdict(set)\n voc = ['</s>']\n for s in sents:\n voc += s\n self.voc = set(voc)\n if beta is None:\n self.beta_flag = False\n\n # if no beta given, we compute it\n if not self.beta_flag:\n total_sents = len(sents)\n aux = int(total_sents * 90 / 100)\n # 90 per cent por training\n train_sents = sents[:aux]\n # 10 per cent for perplexity (held out data)\n held_out_sents = sents[-total_sents+aux:]\n\n train_sents = list(map((lambda x: ['<s>']*(n-1) + x), train_sents))\n train_sents = list(map((lambda x: x + ['</s>']), train_sents))\n for sent in train_sents:\n for j in range(n+1):\n for i in range(n-j, len(sent) - j + 1):\n ngram = tuple(sent[i: i + j])\n counts[ngram] += 1\n # for efficiency, we save the A set as a dict of sets\n if j:\n self.A_set[ngram[:-1]].add(ngram[-1])\n for i in range(1, n):\n counts[('<s>',)*i] += len(train_sents)\n counts[('</s>',)] = len(train_sents)\n\n self.tocounts = counts\n # search for the beta that gives lower perplexity\n beta_candidates = [i*0.1 for i in range(1, 10)]\n # xs is a list with (beta, perplexity)\n xs = []\n self.sents = train_sents\n for aux_beta in beta_candidates:\n self.beta = aux_beta\n aux_perx = self.perplexity(held_out_sents)\n xs.append((aux_beta, aux_perx))\n xs.sort(key=lambda x: x[1])\n self.beta = xs[0][0]\n with open('old-stuff/backoff_'+str(n)+'_parameters_'+corpus, 'a') as f:\n f.write('Order: {}\\n'.format(self.n))\n f.write('Beta: {}\\n'.format(self.beta))\n f.write('AddOne: {}\\n'.format(self.addone))\n f.write('Perplexity observed: {}\\n'.format(xs[0][1]))\n f.write('-------------------------------\\n')\n f.close()\n else:\n sents = list(map((lambda x: x + ['</s>']), sents))\n sents = list(map((lambda x: ['<s>']*(n-1) + x), sents))\n\n for sent in sents:\n for j in range(n+1):\n for i in range(n-j, len(sent) - j + 1):\n ngram = tuple(sent[i: i + j])\n counts[ngram] += 1\n # for efficiency, we save the A set as a dict of sets\n if j:\n self.A_set[ngram[:-1]].add(ngram[-1])\n for i in range(1, n):\n counts[('<s>',)*i] += len(sents)\n counts[('</s>',)] = len(sents)", "def build(self, Tweets):\n text = [t.text for t in Tweets]\n vectorizer = TfidfVectorizer(tokenizer=process_text,\n stop_words=stopwords.words('english'),\n max_df=0.5,\n min_df=0.1,\n lowercase=True,\n max_features=10000)\n\n return vectorizer.fit_transform(text).A", "def get_raw_seedling(datasource, n):\n matrix = MatrixDict()\n \n for lang, sent in SEEDLING[datasource].sents():\n features = sent2ngrams(sent, n=n)\n matrix.setdefault(lang, Counter()).update(features)\n \n return matrix", "def initialize(self):\n # Initializing the counter and distribution.\n for k in range(0, self.topic_number,1):\n self.topic_term_count_matrix[k]= [0.0] * self.term_number\n self.topic_distribution_over_term[k] = [0.0] * self.term_number\n self.sum_topic_by_term_count[k] = 0.0\n for m in range(0, self.document_number,1):\n self.document_topic_count_matrix[m] = [0.0] * self.topic_number\n self.document_distribution_over_topic[m] = [0.0] * self.topic_number\n self.sum_document_by_topic_count[m] = 0.0\n\n # Initializing topics assigned to all words of all documents.\n for m in range(0, self.document_number, 1):\n N = len(self.documents[m])\n self.word_topic_assignment[m] = [-1] * N\n for n in range(0, N,1):\n topic = int(random.uniform(0,1) * self.topic_number)\n self.document_topic_count_matrix[m][topic] += 1.0\n self.topic_term_count_matrix[topic][self.documents[m][n]] += 1.0\n self.sum_topic_by_term_count[topic] += 1.0\n self.word_topic_assignment[m][n] = topic\n self.sum_document_by_topic_count[m] = N", "def make_tweet_nparr( txt ):\n # result storage\n fvec = numpy.empty( len(testFeatures) )\n\n # search for each feature\n txtLow = ' ' + txt.lower() + ' '\n for i in range( 0, len(testFeatures) ):\n\n key = testFeatures[i][0]\n\n fvec[i] = False\n for tstr in testFeatures[i][1]:\n fvec[i] = fvec[i] or (txtLow.find(tstr) != -1)\n\n return fvec", "def get_feature_set_SC2(tweet, sentimentvalues):\n pos_tag_freq = {}\n additional_freq = {}\n for phrase in tweet.tagged_words:\n for word in phrase:\n try:\n tag = word['pos']\n pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n if tag in ADJECTIVES:\n additional_freq['adjectives'] = additional_freq.get(tag, 0) + 1\n elif tag in ADVERBS: \n additional_freq['adverbs'] = additional_freq.get(tag, 0) + 1\n elif tag in PRONOUNS:\n additional_freq['pronoun'] = 1\n except KeyError:\n continue\n for key in pos_tag_freq.keys():\n pos_tag_freq[key] = pos_tag_freq[key]*1.0\n #number of adjectives in sentence, number of adverbs in sentence(except ikke), pronoun in sentence(binary) \n #Number of exclamation marks, number of emoticons,\n emoticons = tweet.nrof_happyemoticons+tweet.nrof_sademoticons\n if emoticons>0:\n additional_freq['emoticons'] = emoticons*1.0\n if tweet.nrof_exclamations>0:\n additional_freq['exclamations'] = tweet.nrof_exclamations*1.0\n \n #Add lexicon values\n #total subjectivity score from word polarities, total objectivity score, number of subjective words, number of objective words, e\n sub_score = sentimentvalues[0]+sentimentvalues[1]\n obj_score = sentimentvalues[2]\n if sub_score>0:\n additional_freq[\"sub_score\"] = sub_score+1.0\n if obj_score>0:\n additional_freq[\"obj_score\"] = obj_score+1.0\n \n #Concatenate the dicts\n features= dict(pos_tag_freq.items() + additional_freq.items())\n \n return features", "def initialize(self):\n self.n_words = len(self.vocab)\n self.n_docs = len(self.documents)\n\n # Initialize the three count matrices.\n # The (i,j) entry of self.nmz is the number of words in document i assigned to topic j.\n self.nmz = np.zeros((self.n_docs, self.n_topics))\n # The (i,j) entry of self.nzw is the number of times term j is assigned to topic i.\n self.nzw = np.zeros((self.n_topics, self.n_words))\n # The (i)-th entry is the number of times topic i is assigned in the corpus.\n self.nz = np.zeros(self.n_topics)\n\n # Initialize the topic assignment dictionary.\n self.topics = {} # key-value pairs of form (m,i):z\n\n for m in range(self.n_docs):\n for i in self.documents[m]:\n # Get random topic assignment, i.e. z is a random integer in the range of topics\n z = np.random.randint(self.n_topics)\n # Increment count matrices\n self.nmz[m,z] += 1\n self.nzw[z,self.documents[m][i]] += 1\n self.nz[z] += 1\n # Store topic assignment\n self.topics[(m,i)] = z", "def construct_train_set(tweet_pos, tweet_neg):\n tweet_pos['pred'] = 1\n tweet_neg['pred'] = 0\n tweet_pos.columns = ['tweet', 'pred']\n tweet_neg.columns = ['tweet', 'pred']\n all_tweets = tweet_neg.append(tweet_pos)\n tweet_TR = all_tweets.reset_index().drop(['index'], axis = 1)\n return tweet_TR", "def get_features_test(tweets):\n feats = get_feature_array(tweets)\n tfidf = vectorizer.transform(tweets).toarray()\n M = np.concatenate([tfidf,feats],axis=1)\n return M", "def phrase_scoring_ranking(phrases,model,dataset,bitext):\n e_phrases = []\n f_phrases = []\n count = 0\n f_phrase_count = {}\n e_phrase_count = {} #not needed\n #e_f_pair_count = {} #e words as rows and f words as columns\n f_e_pair_count = {} #e words as rows and f words as columns\n for phrase_set in phrases:\n for phrase in phrase_set:\n e_phrases.append(phrase[3])\n f_phrases.append(phrase[2])\n if phrase[2] in f_phrase_count:\n f_phrase_count[phrase[2]] += 1\n else:\n f_phrase_count[phrase[2]] = 1\n if phrase[2] in f_e_pair_count:\n if phrase[3] in f_e_pair_count[phrase[2]]:\n f_e_pair_count[phrase[2]][phrase[3]] += 1\n else:\n f_e_pair_count[phrase[2]][phrase[3]] = 1\n else:\n f_e_pair_count[phrase[2]]={}\n f_e_pair_count[phrase[2]][phrase[3]] = 1\n\n e_phrases = list(set(e_phrases))\n f_phrases = list(set(f_phrases))\n ep_count = len(e_phrases)\n fp_count = len(f_phrases)\n #pmatrix = np.empty(ep_count*fp_count) # ######Not needed if dictionary is used\n #pmatrix = pmatrix.reshape(ep_count,fp_count)\n #pmatrix.fill(0)\n ef_prob_dict = {}\n for e in e_phrases:\n for f in f_phrases:\n ef_count =count_fe_pair(e,f,f_e_pair_count)# f_e_pair_count[e][f]\n f_count = f_phrase_count[f]\n e_idx = e_phrases.index(e) ###Check the count logic again\n f_idx = f_phrases.index(f)\n pair_prob = ef_count/f_count\n #pmatrix[e_idx][f_idx] = pair_prob\n if f in f_e_pair_count:\n if e in f_e_pair_count[f]:\n if f in ef_prob_dict:\n ef_prob_dict[f][e]=pair_prob\n else:\n ef_prob_dict[f] = {}\n ef_prob_dict[f][e] = pair_prob\n\n #if pmatrix[e_idx][f_idx] != 0:\n # print(e,f,ef_count,f_count,pair_prob)\n return ef_prob_dict", "def index_new_tweet(self, id_str, tweet_tokens: list):\n self.tweet_count += 1\n unique_words = set(tweet_tokens)\n unique_word_pairs = set()\n for i in unique_words:\n for j in unique_words - {i}:\n # To us [a, b] = [b, a], and sorting gives us a distinct representation.\n unique_word_pairs.add(tuple(sorted([i, j])))\n for w in unique_words | unique_word_pairs:\n self.index[self.epoch][w] = id_str\n current_freq = self.frequency_map.get(w, 0)\n self.frequency_map[w] = current_freq + 1\n # Get word statistics from hash table\n statistics_present = w in self.stats_map\n if not statistics_present:\n (mu, sigma) = (math.inf, math.inf)\n for h in self.hash_functions:\n c = get_hash(h(), repr(w)) % 2 ** self.bit_count\n if self.buckets[c][\"ewma\"] < mu:\n mu = self.buckets[c][\"ewma\"]\n sigma = self.buckets[c][\"ewmvar\"]\n self.stats_map[w] = (mu, sigma)\n (mu, sigma) = self.stats_map[w]\n # Test for significance threshold\n x = self.frequency_map[w]\n if self._is_frequency_significant(mu, sigma, x):\n self.refinement.append((w, self._get_significance(mu, sigma, x)))\n # if self.refinement:\n # r = self.refinement\n # self.refinement = []\n # return r", "def __init__(self, n, sents, gamma=None, addone=True):\n assert n > 0\n self._n = n\n\n if gamma is not None:\n # everything is training data\n train_sents = sents\n else:\n # 90% training, 10% held-out\n m = int(0.45 * len(sents))\n l = int(0.65 * len(sents))\n train_sents = sents[:m] + sents[l:]\n held_out_sents = sents[m:l]\n\n print('Computing counts...')\n count = defaultdict(int)\n while (n >= 0):\n for sent in train_sents:\n s = sent[:] ## En una oracion auxiliar agrego el item de start y end para contarlos\n s.insert(0, \"<s>\")\n s.append(\"</s>\")\n for i in range(len(s) - n + 1):\n count[tuple(s[i:i + n])] += 1\n n -= 1\n count[()] = count[()] - count[('<s>',)] - count[\n ('</s>',)] # Pero no quiero que <s> y </s> sean considerados por ()\n self._count = count\n # WORKed HERE!!\n # COMPUTE COUNTS FOR ALL K-GRAMS WITH K <= N\n\n # compute vocabulary size for add-one in the last step\n self._addone = addone\n if addone:\n print('Computing vocabulary...')\n self._voc = voc = set()\n for sent in sents:\n voc = voc.union(set(sent))\n voc.add('</s>')\n self._voc = voc\n self._V = len(voc)\n\n # compute gamma if not given\n if gamma is not None:\n self._gamma = gamma\n else:\n print('Computing gamma...')\n self._gamma = gamma = 1\n p = self.log_prob(held_out_sents)\n new_gamma = 2\n streak = 1\n growing = True\n turns = 0\n while (turns < 15):\n self._gamma = new_gamma\n np = self.log_prob(held_out_sents)\n gamma = new_gamma\n if (np > p):\n if growing:\n streak += 1\n else:\n turns += 1\n streak = 0\n growing = True\n new_gamma = new_gamma + 2 ** streak\n else:\n if growing:\n turns += 1\n streak = 0\n growing = False\n else:\n streak += 1\n new_gamma = new_gamma - 2 ** streak\n p = np\n self._gamma = new_gamma\n print(self._gamma)", "def get_feature_set_PC(tweet, sentimentvalues):\n features= {\n 'text_length': np.log(len(tweet.text))\n } #ADD ADDITIONAL FEATURES\n if tweet.nrof_sademoticons>0:\n features['sademoticons'] = tweet.nrof_sademoticons\n if tweet.nrof_happyemoticons>0:\n features['happyemoticons'] = tweet.nrof_happyemoticons\n \n for phrase in tweet.tagged_words:\n for word in phrase:\n try:\n tag = word['pos']\n features[tag] = features.get(tag, 0) + 1\n if tag in ADJECTIVES:\n features['adjectives'] = features.get(tag, 0) + 1\n elif tag in ADVERBS: \n features['adverbs'] = features.get(tag, 0) + 1\n elif tag in PRONOUNS:\n features['pronoun'] = 1\n except KeyError:\n continue\n for key in features.keys():\n features[key] = features[key]*1.0\n \n #Add lexical features\n # total polarity score, number of positive words, number of negative words\n pos_score = 0\n neg_score = 0\n nrof_pos_words = 0\n nrof_neg_words = 0\n for word in sentimentvalues.keys():\n if sentimentvalues[word][0]>0:\n nrof_pos_words = nrof_pos_words + 1\n pos_score = pos_score + sentimentvalues[word][0]\n if sentimentvalues[word][1]>0:\n nrof_neg_words = nrof_neg_words + 1\n neg_score = neg_score + sentimentvalues[word][1]\n\n if neg_score>0:\n features['neg_score'] = neg_score+1.0\n if pos_score>0:\n features['pos_score'] = pos_score+1.0\n if nrof_pos_words>0:\n features['positive_words'] = nrof_pos_words*1.0\n if nrof_neg_words>0:\n features['negative_words'] = nrof_neg_words*1.0\n \n return features", "def __init__(self, sents, n, corpus='', D=None):\n\n self.n = n\n self.D = D\n self.corpus = corpus\n self.smoothingtechnique = 'Kneser Ney Smoothing'\n # N1+(·w_<i+1>)\n self._N_dot_tokens_dict = N_dot_tokens = defaultdict(set)\n # N1+(w^<n-1> ·)\n self._N_tokens_dot_dict = N_tokens_dot = defaultdict(set)\n # N1+(· w^<i-1>_<i-n+1> ·)\n self._N_dot_tokens_dot_dict = N_dot_tokens_dot = defaultdict(set)\n self.counts = counts = defaultdict(int)\n vocabulary = []\n\n if D is None:\n total_sents = len(sents)\n k = int(total_sents*9/10)\n training_sents = sents[:k]\n held_out_sents = sents[k:]\n training_sents = list(map(lambda x: ['<s>']*(n-1) + x + ['</s>'], training_sents))\n for sent in training_sents:\n for j in range(n+1):\n for i in range(n-j, len(sent) - j + 1):\n ngram = tuple(sent[i: i + j])\n counts[ngram] += 1\n if ngram:\n if len(ngram) == 1:\n vocabulary.append(ngram[0])\n else:\n right_token, left_token, right_kgram, left_kgram, middle_kgram =\\\n ngram[-1:], ngram[:1], ngram[1:], ngram[:-1], ngram[1:-1]\n N_dot_tokens[right_kgram].add(left_token)\n N_tokens_dot[left_kgram].add(right_token)\n if middle_kgram:\n N_dot_tokens_dot[middle_kgram].add(right_token)\n N_dot_tokens_dot[middle_kgram].add(left_token)\n if n - 1:\n counts[('<s>',)*(n-1)] = len(sents)\n self.vocab = set(vocabulary)\n aux = 0\n for w in self.vocab:\n aux += len(self._N_dot_tokens_dict[(w,)])\n self._N_dot_dot_attr = aux\n D_candidates = [i*0.12 for i in range(1, 9)]\n xs = []\n for D in D_candidates:\n self.D = D\n aux_perplexity = self.perplexity(held_out_sents)\n xs.append((D, aux_perplexity))\n xs.sort(key=lambda x: x[1])\n self.D = xs[0][0]\n with open('old-stuff/kneserney_' + str(n) + '_parameters_'+corpus, 'a') as f:\n f.write('Order: {}\\n'.format(self.n))\n f.write('D: {}\\n'.format(self.D))\n f.write('Perplexity observed: {}\\n'.format(xs[0][1]))\n f.write('-------------------------------\\n')\n f.close()\n\n # discount value D provided\n else:\n sents = list(map(lambda x: ['<s>']*(n-1) + x + ['</s>'], sents))\n for sent in sents:\n for j in range(n+1):\n # all k-grams for 0 <= k <= n\n for i in range(n-j, len(sent) - j + 1):\n ngram = tuple(sent[i: i + j])\n counts[ngram] += 1\n if ngram:\n if len(ngram) == 1:\n vocabulary.append(ngram[0])\n else:\n # e.g., ngram = (1,2,3,4,5,6,7,8)\n # right_token = (8,)\n # left_token = (1,)\n # right_kgram = (2,3,4,5,6,7,8)\n # left_kgram = (1,2,3,4,5,6,7)\n # middle_kgram = (2,3,4,5,6,7)\n right_token, left_token, right_kgram, left_kgram, middle_kgram =\\\n ngram[-1:], ngram[:1], ngram[1:], ngram[:-1], ngram[1:-1]\n N_dot_tokens[right_kgram].add(left_token)\n N_tokens_dot[left_kgram].add(right_token)\n if middle_kgram:\n N_dot_tokens_dot[middle_kgram].add(right_token)\n N_dot_tokens_dot[middle_kgram].add(left_token)\n if n-1:\n counts[('<s>',)*(n-1)] = len(sents)\n self.vocab = set(vocabulary)\n\n aux = 0\n for w in self.vocab:\n aux += len(self._N_dot_tokens_dict[(w,)])\n self._N_dot_dot_attr = aux\n\n xs = [k for k, v in counts.items() if v == 1 and n == len(k)]\n ys = [k for k, v in counts.items() if v == 2 and n == len(k)]\n n1 = len(xs)\n n2 = len(ys)\n self.D = n1 / (n1 + 2 * n2)", "def feature_mining(features: np.array,\r\n query_chunk_size: int = 5000,\r\n corpus_chunk_size: int = 100000,\r\n max_pairs: int = 500000,\r\n top_k: int = 100) -> list:\r\n\r\n top_k += 1 # An image has the highest similarity to itself. Increase +1 as we are interest in distinct pairs\r\n\r\n # Mine for duplicates\r\n pairs = queue.PriorityQueue()\r\n min_score = -1\r\n num_added = 0\r\n\r\n for corpus_start_idx in range(0, len(features), corpus_chunk_size):\r\n corpus_end_idx = min(corpus_start_idx + corpus_chunk_size, len(features))\r\n for query_start_idx in range(0, len(features), query_chunk_size):\r\n query_end_idx = min(query_start_idx + query_chunk_size, len(features))\r\n\r\n cos_scores = torch.Tensor(\r\n cosine_similarity(features[query_start_idx:query_end_idx],\r\n features[corpus_start_idx:corpus_end_idx])\r\n )\r\n\r\n cos_scores_top_k_values, cos_scores_top_k_idx = torch.topk(cos_scores, min(top_k, len(cos_scores[0])),\r\n dim=1, largest=True, sorted=False)\r\n cos_scores_top_k_values = cos_scores_top_k_values.tolist()\r\n cos_scores_top_k_idx = cos_scores_top_k_idx.tolist()\r\n\r\n for query_itr in range(len(cos_scores)):\r\n for top_k_idx, corpus_itr in enumerate(cos_scores_top_k_idx[query_itr]):\r\n i = query_start_idx + query_itr\r\n j = corpus_start_idx + corpus_itr\r\n\r\n if i != j and cos_scores_top_k_values[query_itr][top_k_idx] > min_score:\r\n pairs.put((cos_scores_top_k_values[query_itr][top_k_idx], i, j))\r\n num_added += 1\r\n\r\n if num_added >= max_pairs:\r\n entry = pairs.get()\r\n min_score = entry[0]\r\n\r\n # Get the pairs\r\n added_pairs = set() # Used for duplicate detection\r\n pairs_list = []\r\n while not pairs.empty():\r\n score, i, j = pairs.get()\r\n sorted_i, sorted_j = sorted([i, j])\r\n\r\n if sorted_i != sorted_j and (sorted_i, sorted_j) not in added_pairs:\r\n added_pairs.add((sorted_i, sorted_j))\r\n pairs_list.append([score, i, j])\r\n\r\n return pairs_list", "def _create_sparse_train_and_test(ratings, n_users, n_items):\n \n # pick a random set of data as testing data, sorted ascending\n test_set_size = len(ratings) / TEST_SET_RATIO\n test_set_idx = np.random.choice(xrange(len(ratings)), size=test_set_size, replace=False)\n test_set_idx = sorted(test_set_idx)\n \n # use the remaining data to create a training set\n ts_ratings = ratings[test_set_idx]\n tr_ratings = np.delete(ratings, test_set_idx, axis=0)\n \n # create training and test matrices as coo_matrix\n u_tr, i_tr, r_tr = zip(*tr_ratings)\n tr_sparse = coo_matrix((r_tr, (u_tr, i_tr)), shape=(n_users, n_items))\n u_ts, i_ts, r_ts = zip(*ts_ratings)\n test_sparse = coo_matrix((r_ts, (u_ts, i_ts)), shape=(n_users, n_items))\n \n return tr_sparse, test_sparse", "def prepare_lexicons(self, topnwords = 80, distance_cutoff = 0.45):\n\n model = self.train_word2vec()\n\n\n # 10 topics\n topic_dict = {0: 'academics'\n , 1: 'career'\n , 2: 'commute'\n , 3: 'diversity'\n , 4: 'community'\n , 5: 'extracurricular'\n , 6: 'facilities'\n , 7: 'finance'\n , 8: 'housing'\n , 9: 'wellness'\n }\n\n # Some important words that should be included under each topic\n topics = [['academic', 'exam', 'study', 'learn', 'education', 'class', 'course', 'grade', 'assignment'\n , 'degree', 'research', 'elective'\n , 'professor', 'project', 'scholarship', 'knowledge']\n , ['career', 'job', 'coop', 'employment']\n , ['commute', 'skytrain', 'transport', 'commuter']\n , ['diversity', 'diverse', 'background']\n , ['community', 'welcome', 'support', 'social', 'friend', 'fun', 'network', 'home']\n , ['extracurricular', 'club', 'sport', 'activity']\n , ['facility', 'infrastructure', 'food', 'building', 'gym']\n , ['finance', 'tuition', 'expensive']\n , ['housing', 'live', 'residence']\n , ['wellness', 'health', 'stress', 'depression', 'anxiety']]\n\n # For each topic, collect the words most similar to them in a list of lists\n topic_lexicons = []\n\n # Loop through the ten topics\n for topic in topics:\n\n temp_words = []\n\n # Loop through each word that we have given manually under each topic\n for word in topic:\n\n # Consider most similar words according to some cutoffs\n similar_words = model.wv.most_similar(positive = word, topn = topnwords)\n temp_words1 = [x for (x,y) in similar_words if y >= distance_cutoff]\n\n temp_words = temp_words + temp_words1\n\n temp_words = temp_words + topic\n\n\n # Take unique words, there might be duplicates\n topic_lexicons.append(list(set(temp_words)))\n\n # Some manual adjustments\n # Remove 'commute' from other topic\n topic_lexicons[8].remove('commute')\n\n return topic_lexicons", "def __init__(words, pred_index):", "def srp_matrix(cls, words, ndims, _hashfunc=city_64(0)):\n multiplier = (ndims - 1) // 64 + 1\n hashes = [\n list(map(_hashfunc, ['{}_{}'.format(w, i)\n for i in range(multiplier)]))\n for w in words\n ]\n\n # Given a `multipier` value of 5, `hashes` is really a V x 5\n # array of 64-bit integers, where V is the vocabulary size...\n\n hash_arr = numpy.array(hashes, dtype=numpy.uint64)\n\n # ...but we could also think of it as a V x 40 array of bytes...\n\n hash_arr = hash_arr.view(dtype=numpy.uint8)\n\n # ...or even as an array of bits, where every word is represented\n # by 320 bits...\n\n hash_arr = numpy.unpackbits(hash_arr.ravel()).reshape(-1,\n 64 * multiplier)\n\n # ...or as an array of floating point values, all equal to either\n # 1.0 or 0.0, and truncated to give a final array of V x ndims.\n\n return (hash_arr.astype(numpy.float64) * 2 - 1)[:, :ndims]", "def train(self, sentences):\n\n dictionary = Dictionary(sentences)\n\n ft = Word2Vec(sentences, workers=cpu_count(), min_count=5, size=300, seed=12345)\n\n index = WordEmbeddingSimilarityIndex(ft.wv)\n matrix = SparseTermSimilarityMatrix(index, dictionary)\n\n self.dictionary = dictionary\n self.ft = ft\n self.matrix = matrix", "def get_user_feature_matrix(user_dict, user_index, aspect_index, N):\n result = np.zeros((len(user_index), len(aspect_index)))\n for key in user_dict.keys():\n index_user = user_index[key]\n user_reviews = user_dict[key]\n count_dict = {}\n for review in user_reviews:\n feature = review[0]\n if feature not in aspect_index:\n continue\n aspect = aspect_index[feature]\n if aspect not in count_dict:\n count_dict[aspect] = 0;\n count_dict[aspect] += 1\n for aspect in count_dict.keys():\n count = count_dict[aspect]\n result[index_user, aspect] = 1 + (N - 1) * (2 / (1 + exp(-count)) - 1)\n return result", "def get_feature_set_SC(tweet, sentimentvalues):\n pos_tag_freq = {}\n additional_freq = {}\n for phrase in tweet.tagged_words:\n for word in phrase:\n try:\n tag = word['pos']\n pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# if tag=='PRtinf':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# elif tag=='ADJS':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# elif tag=='ADJ':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# elif tag=='NP':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# elif tag=='DET':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# elif tag=='P':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n if tag in ADJECTIVES:\n additional_freq['adjectives'] = additional_freq.get(tag, 0) + 1\n elif tag in ADVERBS: \n additional_freq['adverbs'] = additional_freq.get(tag, 0) + 1\n elif tag in PRONOUNS:\n additional_freq['pronoun'] = 1\n except KeyError:\n continue\n for key in pos_tag_freq.keys():\n pos_tag_freq[key] = pos_tag_freq[key]*1.0\n #number of adjectives in sentence, number of adverbs in sentence(except ikke), pronoun in sentence(binary) \n #Number of exclamation marks, number of emoticons,\n emoticons = tweet.nrof_happyemoticons+tweet.nrof_sademoticons\n if emoticons>0:\n additional_freq['emoticons'] = emoticons*1.0\n if tweet.nrof_exclamations>0:\n additional_freq['exclamations'] = tweet.nrof_exclamations*1.0\n \n #Add lexicon values\n #total subjectivity score from word polarities, total objectivity score, number of subjective words, number of objective words, e\n sub_score = 0.0\n obj_score = 0.0\n nrof_subwords = 0\n nrof_objwords = 0\n for word in sentimentvalues.keys():\n if sentimentvalues[word][0]>0:\n sub_score = sub_score + sentimentvalues[word][0]\n nrof_subwords = nrof_subwords + 1\n if sentimentvalues[word][1]>0:\n sub_score = sub_score + sentimentvalues[word][1]\n nrof_subwords = nrof_subwords + 1\n if sentimentvalues[word][2]>0:\n obj_score = obj_score + sentimentvalues[word][2]\n nrof_objwords = nrof_objwords + 1\n if sub_score>0:\n additional_freq[\"sub_score\"] = sub_score+1.0\n if obj_score>0:\n additional_freq[\"obj_score\"] = obj_score+1.0\n if nrof_subwords>0:\n additional_freq[\"subjective_words\"] = nrof_subwords*1.0\n if nrof_objwords>0:\n additional_freq[\"objective_words\"] = nrof_objwords*1.0\n \n #Concatenate the dicts\n features= dict(pos_tag_freq.items() + additional_freq.items())\n \n return features", "def optimalize(): \n start = time()\n max = 0\n maxn=2\n maxm=3\n check = [(n,m) for n in range(24,30) for m in range(3,20)]\n dict = {}\n print \"start optimalization of: bigram-features,uniqueness\"\n for n,m in check:\n score=0\n print \">lem>>n(uniqueness):\"+str(n)\n print \">lem>>m(commonness):\"+str(m)\n wrds = common_but_unique(ngrams_dict(1,authors,compactcorpus,n,False),m)\n bigrams = common_but_unique(ngrams_dict(2,authors,compactcorpus,n,False),m)\n trigrams = common_but_unique(ngrams_dict(3,authors,compactcorpus,n,False),m)\n #pos_feat = [\"wrd:\"+wrd+\">\"+str(num) for wrd in wrds for num in range(0,1)]\n pos_feat = [\"bi:(\"+str(bi[0])+\",\"+str(bi[1])+\")>\"+str(num) for bi in bigrams for num in range(0,1)] + [\"wrd:\"+wrd+\">\"+str(num) for wrd in wrds for num in range(0,1)] + [\"tri:(\"+str(tri[0])+\",\"+str(tri[1])+\",\"+str(tri[2])+\")>\"+str(num) for tri in trigrams for num in range(0,1)]\n\n print \"number of features AFTER selection:\" + str(len(pos_feat))\n for x in range(0,4):\n data = split_train_test_data(authors, corp,45)\n train_set = [(feat_dict(pos_feat,d), c) for (d, c) in data[\"train\"]]\n train_set = [(feat_dict(pos_feat,d), c) for (d, c) in data[\"train\"]]\n test_set = [(feat_dict(pos_feat,d), c) for (d, c) in data[\"test\"]]\n classifier1 = NaiveBayesClassifier.train(train_set)\n acc = nltk.classify.accuracy(classifier1,test_set)\n print \"accuracy:\"+str(acc)\n score +=acc\n print \"time elapsed: \"+str(time()-start)\n print \"score(\" + str(n) +\")=\"+str(score/4)\n classifier1.show_most_informative_features(8)\n dict[(n,m)]=(score/4)\n if(score/4)>max:\n max = (score/4)\n maxn =n\n maxm = m\n print \"max score=\"+str(max)\n print \"where n = \"+str(maxn)\n print \"where m = \"+str(maxm)\n print \"time:\"+str(time()-start)\n writetofile(dict,\"optimalizedict_commonwrdsandbigrams_latest_lem.pkl\")", "def train_ngrams(dataset):\n trigram_counts = dict()\n bigram_counts = dict()\n unigram_counts = dict()\n token_count = 0\n ### YOUR CODE HERE\n raise NotImplementedError\n ### END YOUR CODE\n return trigram_counts, bigram_counts, unigram_counts, token_count", "def get_similarities(self, query, n=5):\n scores = self.get_scores(query)\n rank_n = np.argsort(scores)[::-1]\n if n > 0:\n rank_n = rank_n[:n]\n return [self.corpus[i] for i in rank_n]", "def weigthIndex(index, nPages): \n weighted_index = defaultdict(list)\n for term, docs in index.items():\n df = len(docs)\n for url, count in docs:\n weight = tf_idf(count, nPages, df)\n weighted_index[term].append((url, weight))\n return weighted_index", "def __init__(self, corpus):\n self.unigramCounts = collections.defaultdict(lambda: 0)\n self.bigramCounts = collections.defaultdict(lambda: 0)\n self.trigramCounts = collections.defaultdict(lambda: 0)\n self.followingWords = collections.defaultdict(lambda: set())\n self.precedingWords = collections.defaultdict(lambda: set())\n self.total = 0\n self.discount = 0.75\n self.train(corpus)" ]

[ "0.58001864", "0.56129664", "0.54644907", "0.54111147", "0.54101944", "0.53472745", "0.5298088", "0.52882266", "0.52852654", "0.52436393", "0.5239852", "0.52355725", "0.5232348", "0.5206258", "0.5178139", "0.51459336", "0.51324886", "0.51294774", "0.51167494", "0.51034796", "0.50909173", "0.5090226", "0.5073328", "0.50717324", "0.5059999", "0.505514", "0.5045857", "0.5039676", "0.50187135", "0.5017687" ]

[ "def upload_license(self):\n param = self.module.params[\"param\"]\n license_file_path = param['license_file_path']\n if license_file_path and os.access(license_file_path, os.F_OK) and os.access(license_file_path, os.R_OK):\n self.client.upload_license(license_file_path)\n self.module.exit_json(msg=\"Import license file Success.\", changed=True, status='success')\n else:\n self.module.fail_json(msg=\"Import license file Fail.Please add 'hw_license_file_path' \"\n \"and make sure it can be read.\",\n changed=True, status='fail')", "def activate_license(self):\n response = self.client.activate_license()\n if str(response[\"result\"][\"code\"]) == \"0\" and str(response[\"data\"][\"LicenseActiveResult\"]) == \"0\":\n self.module.exit_json(msg=\"Activate license file Success.\", changed=True, status='success')\n else:\n self.module.fail_json(msg=\"Activate license file fail.{0}\".format(response['result']['description']),\n status='fail', changed=False)", "def license(*args, borrow: bool=True, info: bool=True, isBorrowed: bool=True, isExported:\n bool=True, isTrial: bool=True, licenseMethod: bool=True, productChoice: bool=True,\n r: bool=True, showBorrowInfo: bool=True, showProductInfoDialog: bool=True, status:\n bool=True, usage: bool=True, **kwargs)->AnyStr:\n pass", "def query_active_license(self):\n response = self.client.query_active_license()\n if str(response[\"result\"][\"code\"]) == \"0\":\n if str(response[\"data\"][\"FileExist\"]) == \"0\":\n self.module.exit_json(msg=\"License file exists.\", changed=True, status='success')\n else:\n self.module.fail_json(msg=\"License file not exists.You should add the License file first.Your License \"\n \"Serial No is: {0}\".format(response[\"data\"][\"LicenseSerialNo\"]),\n changed=False, status='fail')\n else:\n self.module.fail_json(msg=\"Query active licenses in batches has an error.\"\n \"{0}\".format(response['result']['description']),\n status='fail', changed=False)", "def show_license(ctx, param, value):\n if not value or ctx.resilient_parsing:\n return\n click.echo(lic)\n ctx.exit()", "def checkoutlicense(self,feature_):\n res = __library__.MSK_XX_checkoutlicense(self.__nativep,feature_)\n if res != 0:\n raise Error(rescode(res),Env.getcodedesc(rescode(res))[1])", "def create_license(self) -> None:\n # copy the license file from the template to the package folder\n # option : append other license files\n shutil.copy(CONFIG.template_path / \"LICENSE.md\", self.package_path)", "def license(p):\n # Input file\n f = '/'.join([p, 'collector.stats'])\n check_path(f)\n\n # Open file with universal newline support\n with open(f, 'rU') as fh:\n for line in fh.readlines():\n if 'License key' in line:\n license = line.split(':')[1].strip()\n break\n\n return license", "def hacking_has_license(physical_line, filename, lines, line_number):\n # don't work about init files for now\n # TODO(sdague): enforce license in init file if it's not empty of content\n license_found = False\n\n # skip files that are < 10 lines, which isn't enough for a license to fit\n # this allows us to handle empty files, as well as not fail on the Okay\n # doctests.\n if _project_is_apache() and not line_number > 1 and len(lines) > 10:\n for idx, line in enumerate(lines):\n # if it's more than 10 characters in, it's probably not in the\n # header\n if 0 < line.find('Licensed under the Apache License') < 10:\n license_found = True\n if not license_found:\n return (0, \"H102: Apache 2.0 license header not found\")", "def update_frozen_license() -> int:\n srcpath = Path(\"doc/src/license.rst\")\n dstpath = Path(\"cx_Freeze/initscripts/frozen_application_license.txt\")\n try:\n content = srcpath.read_text(encoding=\"utf-8\")\n except OSError:\n print(ERROR1, file=sys.stderr)\n return 1\n content = FROZEN_HEADER + \"\\n\".join(content.splitlines()[1:]) + \"\\n\"\n try:\n dstpath.write_text(content, encoding=\"utf-8\")\n print(dstpath, \"ok\")\n except OSError as io_error:\n print(ERROR2, f\"({io_error}).\", file=sys.stderr)\n return 1\n return 0", "def set_pkg_license_from_file(self, doc, lic):\n self.assert_package_exists()\n if validations.validate_lics_from_file(lic):\n doc.package.licenses_from_files.append(lic)\n return True\n else:\n raise SPDXValueError('Package::LicensesFromFile')", "def show_license(license):\n if not os.path.isfile(license):\n sys.stderr.write(\"Error: %r. Not exist such license file.\\n\\\nThe data license has to be there before of continue.\\n\" % license)\n sys.exit(1)\n\n try:\n read_f = open(license)\n except IOError, err:\n sys.stderr.write(\"Error: %r. %s.\\n\" % (err.filename, err.strerror))\n sys.exit(1)\n\n print\n print ('=' * 78)\n for line in read_f:\n print line.rstrip()\n read_f.close()\n print ('=' * 78)\n print \"\\nBy writing 'yes' I am affirmatively declaring that\"\n print \"I have read, understand and agree to the license above.\"\n\n try:\n answer = raw_input('Do you accept the license? ')\n if answer.lower() != 'yes':\n sys.exit(0)\n except KeyboardInterrupt:\n print\n sys.exit(0)\n\n print", "def putlicensepath(self,licensepath_):\n if isinstance(licensepath_,unicode):\n licensepath_ = licensepath_.encode(\"utf-8\",errors=\"replace\")\n res = __library__.MSK_XX_putlicensepath(self.__nativep,licensepath_)\n if res != 0:\n raise Error(rescode(res),Env.getcodedesc(rescode(res))[1])", "def licensify(command_line_args):\n with open(command_line_args.license) as fp:\n license_header = fp.read()\n files = [\n path.join(dirname, f)\n for dirname, _, filenames in walk(command_line_args.directory)\n for f in fnmatch.filter(filenames, command_line_args.files)\n if not (command_line_args.exclude and fnmatch.fnmatch(f, command_line_args.exclude))\n ]\n try:\n result = apply_license_header(\n license_header, files,\n command_line_args.check, command_line_args.dry_run or command_line_args.check\n )\n except LicensesOutOfDateError as error:\n stdout.write(repr(error))\n exit(1)\n if result:\n message = 'The following files have been changed: {}'.format(', '.join(result))\n else:\n message = 'No files changed'\n stdout.write(message + linesep)", "def set_file_license_in_file(self, doc, lic):\n if self.has_package(doc) and self.has_file(doc):\n if validations.validate_file_lics_in_file(lic):\n self.file(doc).add_lics(lic)\n return True\n else:\n raise SPDXValueError('File::LicenseInFile')\n else:\n raise OrderError('File::LicenseInFile')", "def checkinlicense(self,feature_):\n res = __library__.MSK_XX_checkinlicense(self.__nativep,feature_)\n if res != 0:\n raise Error(rescode(res),Env.getcodedesc(rescode(res))[1])", "def putlicensepath(self,licensepath_): # 3\n res = self.__obj.putlicensepath(licensepath_)\n if res != 0:\n raise Error(rescode(res),\"\")", "def get_license():\n repo_fs()\n return LICENSE", "def hacking_has_correct_license(physical_line, filename, lines, line_number):\n # don't work about init files for now\n # skip files that are < 10 lines, which isn't enough for a license to fit\n # this allows us to handle empty files, as well as not fail on the Okay\n # doctests.\n if _project_is_apache() and not line_number > 1 and len(lines) > 10:\n for idx, line in enumerate(lines):\n # if it's more than 10 characters in, it's probably not in the\n # header\n if (0 < line.find('Licensed under the Apache License') < 10\n and not _check_for_exact_apache(idx, lines)):\n return (idx, \"H103: Header does not match Apache 2.0 \"\n \"License notice\")", "def checkinlicense(self,feature_): # 3\n if not isinstance(feature_,feature): raise TypeError(\"Argument feature has wrong type\")\n res = self.__obj.checkinlicense(feature_)\n if res != 0:\n raise Error(rescode(res),\"\")", "def set_file_license_comment(self, doc, text):\n if self.has_package(doc) and self.has_file(doc):\n if not self.file_license_comment_set:\n self.file_license_comment_set = True\n if validations.validate_file_lics_comment(text):\n self.file(doc).license_comment = str_from_text(text)\n else:\n raise SPDXValueError('File::LicenseComment')\n else:\n raise CardinalityError('File::LicenseComment')\n else:\n raise OrderError('File::LicenseComment')", "def checkoutlicense(self,feature_): # 3\n if not isinstance(feature_,feature): raise TypeError(\"Argument feature has wrong type\")\n res = self.__obj.checkoutlicense(feature_)\n if res != 0:\n raise Error(rescode(res),\"\")", "def accept_license():\r\n msg, status = \"\", True\r\n\r\n try:\r\n sleep(5)\r\n if g.platform == 'android':\r\n sleep(3)\r\n 'Click on license accept button'\r\n flag1 = ui_controls.button(get_obj_identifier('license_accept_btn'))\r\n \r\n \r\n\r\n status = False if not (flag1) else True\r\n else:\r\n \r\n 'Click on Agree button in EULA page for IOS'\r\n flag = ui_controls.button(get_obj_identifier('license_accept_btn'))\r\n status = flag\r\n\r\n except Exception as excp:\r\n traceback.print_exc()\r\n msg += str(excp)\r\n status = False\r\n\r\n return status, msg", "def update_license_file(data_dir):\n license_file = os.path.join(data_dir, LICENSE_FILENAME)\n temp_dir = tempfile.mkdtemp()\n gh_license_filename = os.path.join(temp_dir, LICENSE_FILENAME)\n try:\n _, headers = urlretrieve(LICENSE_URL, gh_license_filename)\n except IOError as e:\n # Python 2 uses the unhelpful IOError for this. Re-raise as the more\n # appropriate URLError.\n raise URLError(e.strerror)\n\n with open(gh_license_filename, \"rb\") as f:\n github_license = f.read()\n\n try:\n with open(license_file, \"rb\") as f:\n current_license = f.read()\n except (IOError, OSError):\n current_license = b\"\"\n\n github_digest = hashlib.sha256(github_license).hexdigest()\n current_digest = hashlib.sha256(current_license).hexdigest()\n\n if github_digest == current_digest:\n return False\n\n shutil.copyfile(gh_license_filename, license_file)\n shutil.rmtree(temp_dir, ignore_errors=True)\n return True", "def add_license(self, contents):\n buf_size = len(contents)\n buf = (ctypes.c_char * (buf_size + 1))(*contents.encode())\n\n res = self._dll.JLINK_EMU_AddLicense(buf)\n\n if res == -1:\n raise errors.JLinkException('Unspecified error.')\n elif res == -2:\n raise errors.JLinkException('Failed to read/write license area.')\n elif res == -3:\n raise errors.JLinkException('J-Link out of space.')\n\n return (res == 0)", "def set_concluded_license(self, doc, lic):\n if self.has_package(doc) and self.has_file(doc):\n if not self.file_conc_lics_set:\n self.file_conc_lics_set = True\n if validations.validate_lics_conc(lic):\n self.file(doc).conc_lics = lic\n return True\n else:\n raise SPDXValueError('File::ConcludedLicense')\n else:\n raise CardinalityError('File::ConcludedLicense')\n else:\n raise OrderError('File::ConcludedLicense')", "def get_license_text(self):\n\n if self.license_file:\n license_text = self.license_file.read_text(encoding=\"utf-8\")\n else:\n license_text = (\n \"Could not find foxBMS 2 license file.\\n\"\n f\"Please check {FOXBMS_LICENSE_FALLBACK_URL}.\"\n )\n self.license_file_missing_msg_box = wx.MessageBox(\n license_text, \"License file missing\", wx.OK | wx.ICON_WARNING\n )\n # self.Bind(wx.EVT_BUTTON, self.license_file_missing_msg_box)\n return license_text", "def test_license_policy_commands(runner, organization, tmp_path):\n\n # Generate the license policy configuration file.\n policy_name = random_str()\n\n policy_config_file_path = create_license_policy_config_file(\n directory=tmp_path,\n name=policy_name,\n description=random_str(),\n allow_unknown_licenses=random_bool(),\n on_violation_quarantine=random_bool(),\n package_query_string=\"format:python AND downloads:>50\",\n spdx_identifiers=[\"Apache-2.0\"],\n )\n\n # Create the license policy\n result = runner.invoke(\n create,\n args=[organization, str(policy_config_file_path)],\n catch_exceptions=False,\n )\n assert (\n \"Creating \" + policy_name + \" license policy for the cloudsmith namespace ...OK\"\n in result.output\n )\n slug_perm = assert_output_matches_policy_config(\n result.output, policy_config_file_path\n )\n\n # Use the cli to get the policy\n result = runner.invoke(ls, args=[organization], catch_exceptions=False)\n assert \"Getting license policies ... OK\" in result.output\n assert_output_matches_policy_config(result.output, policy_config_file_path)\n\n # Change the values in the config file\n policy_config_file_path = create_license_policy_config_file(\n directory=tmp_path,\n name=random_str(),\n description=random_str(),\n allow_unknown_licenses=random_bool(),\n on_violation_quarantine=random_bool(),\n package_query_string=\"format:go AND downloads:>15\",\n spdx_identifiers=[\"Apache-1.0\"],\n )\n\n # Use the cli to update the policy\n result = runner.invoke(\n update,\n args=[organization, slug_perm, str(policy_config_file_path)],\n catch_exceptions=False,\n )\n assert (\n \"Updating \" + slug_perm + \" license policy in the cloudsmith namespace ...OK\"\n in result.output\n )\n assert_output_matches_policy_config(result.output, policy_config_file_path)\n\n # Check that delete prompts for confirmation\n result = runner.invoke(\n delete, args=[organization, slug_perm], input=\"N\", catch_exceptions=False\n )\n assert (\n \"Are you absolutely certain you want to delete the \"\n + slug_perm\n + \" license policy from the cloudsmith namespace? [y/N]: N\"\n in result.output\n )\n assert \"OK, phew! Close call. :-)\" in result.output\n\n # Then actually delete it\n result = runner.invoke(\n delete, args=[organization, slug_perm], input=\"Y\", catch_exceptions=False\n )\n assert (\n \"Are you absolutely certain you want to delete the \"\n + slug_perm\n + \" license policy from the cloudsmith namespace? [y/N]: Y\"\n in result.output\n )\n assert (\n \"Deleting \" + slug_perm + \" from the cloudsmith namespace ... OK\"\n in result.output\n )", "def add_license(fitsfile, lic):\n try:\n hdulist = pyfits.open(fitsfile, mode=\"update\")\n except:\n print(\"Oops! Something's gone wrong :-(\", file=sys.stderr)\n else:\n prihdr = hdulist[0].header\n prihdr[\"LICENSE\"] = liclist[lic][\"name\"]\n prihdr[\"LICVER\"] = liclist[lic][\"ver\"]\n prihdr[\"LICURL\"] = liclist[lic][\"url\"]\n add_comments(prihdr)\n hdulist.close()", "def _check_for_license_acceptance(self, dep):\n if \"license\" in self.dependency_dict[dep]:\n license_name = self.dependency_dict[dep][\"license\"]\n else:\n license_name = \"restrictive\"\n if \"license_file\" in self.dependency_dict[dep]:\n license_text = Path(\n self.dependency_dict[dep][\"license_file\"]\n ).read_text()\n logger.warning(license_text)\n while \"invalid answer\":\n reply = (\n str(\n input(\n f\"Do you accept this {license_name} license? (y/n): \"\n )\n )\n .lower()\n .strip()\n )\n if len(reply) > 0:\n if reply[0] == \"y\":\n return True\n if reply[0] == \"n\":\n return False" ]

[ "0.6253657", "0.6131019", "0.5873717", "0.56893003", "0.5666623", "0.56539637", "0.5633931", "0.5633391", "0.5620481", "0.56039864", "0.56034553", "0.5600046", "0.5559953", "0.55529106", "0.5540216", "0.55401397", "0.5527236", "0.5520839", "0.5341878", "0.53384465", "0.5296292", "0.5267742", "0.5267312", "0.5243942", "0.5233447", "0.5208114", "0.52031684", "0.5199412", "0.51889795", "0.5157413" ]

[ "def getWireframeJoints(self, q):\n xline = [0. for _ in self.Joints]\n yline = [0. for _ in self.Joints]\n zline = [0. for _ in self.Joints]\n for cnt, jnt in enumerate(self.Joints.keys()):\n xyz = self.joint_syms[jnt][\"func_xyz_coj\"](*q)\n xline[cnt] = xyz[0, 0]\n yline[cnt] = xyz[1, 0]\n zline[cnt] = xyz[2, 0]\n return xline, yline, zline", "def get_fk(self, joints):\n\n header = Header()\n header.frame_id = self.group.get_planning_frame()\n\n robot_state = self.robot.get_current_state()\n robot_state.joint_state.position = joints\n\n links = [self.group.get_end_effector_link()]\n\n return self.fk_solver(header, links, robot_state).pose_stamped[0]", "def get_jpos(self, joint_name=None):\n raise NotImplementedError", "def get_dq_dynmat_q(phonon,q):\n groupvel = phonon._group_velocity\n return groupvel._get_dD(q)", "def quaternion(self, name, q):\n R = self.R(name=name, q=q)\n quat = transformations.unit_vector(\n transformations.quaternion_from_matrix(matrix=R))\n return quat", "def get_joint_states(self, joints: List[str]) -> Tuple[List[float], List[float], List[str]]:\n assert all([j in self.joints.names for j in joints]), 'All joints requested must be in self.joints'\n \n rospy.wait_for_service('/' + self.model_name + '/get_joint_states', timeout=2.0)\n try:\n resp = self.__get_joint_states(joint_names=joints)\n except rospy.ServiceException as e:\n print('Service did not process request:' + str(e))\n \n joint_positions = resp.joint_states.position\n joint_velocities = resp.joint_states.velocity\n joint_order = resp.joint_states.name\n \n return joint_positions, joint_velocities, joint_order", "def DQT(fp):\n # length is 2 + sum(t=1, N) of (65 + 64 * Pq(t))\n length = unpack('>H', fp.read(2))[0]\n _remaining = length - 2\n\n _pq, _tq, _qk = [], [], []\n while _remaining > 0:\n precision, table_id = _split_byte(fp.read(1))\n _remaining -= 1\n _pq.append(precision)\n _tq.append(table_id)\n\n # If Pq is 0, Qk is 8-bit, if Pq is 1, Qk is 16-bit\n Q_k = []\n for ii in range(64):\n if precision == 0:\n Q_k.append(unpack('>B', fp.read(1))[0])\n _remaining -= 1\n elif precision == 1:\n Q_k.append(unpack('>H', fp.read(2))[0])\n _remaining -= 2\n\n _qk.append(Q_k)\n\n info = {\n 'Lq' : length,\n 'Pq' : _pq,\n 'Tq' : _tq,\n 'Qk' : _qk\n }\n\n return info", "def getNametagJoints(self):\n # Not sure what the name is right now.\n return []", "def _get_kdl_joint_names(self):\n num_links = self._urdf_chain.getNrOfSegments()\n num_joints = self._urdf_chain.getNrOfJoints()\n joint_names = []\n for i in range(num_links):\n link = self._urdf_chain.getSegment(i)\n joint = link.getJoint()\n joint_type = joint.getType()\n # JointType definition: [RotAxis,RotX,RotY,RotZ,TransAxis,\n # TransX,TransY,TransZ,None]\n if joint_type > 1:\n continue\n joint_names.append(joint.getName())\n assert num_joints == len(joint_names)\n return copy.deepcopy(joint_names)", "def _named_attrs(self, parts:dict) -> \\\n (QA4SMNamedAttributes, list, QA4SMNamedAttributes):\n\n if not self.ismetr():\n raise IOError(self.varname, '{} is not in form of a QA4SM metric variable.')\n\n if self.g == 0:\n a = QA4SMAttributes(self.attrs)\n ref_ds = QA4SMNamedAttributes(a.ref_dc - a._offset_id_dc,\n a.get_ref_names()['short_name'], self.attrs)\n return ref_ds, None, None\n else:\n dss = []\n ref_ds = QA4SMNamedAttributes(parts['ref_id'], parts['ref_ds'], self.attrs)\n ds = QA4SMNamedAttributes(parts['sat_id0'], parts['sat_ds0'], self.attrs)\n dss.append(ds)\n if self.g == 3:\n ds = QA4SMNamedAttributes(parts['sat_id1'], parts['sat_ds1'], self.attrs)\n dss.append(ds)\n mds = QA4SMNamedAttributes(parts['mds_id'], parts['mds'], self.attrs)\n else:\n mds = None\n return ref_ds, dss, mds", "def check_qdof(base, q_dof):\n if base == 'linear_helix' or base == 'pure_helix':\n if q_dof != 2:\n raise ValueError(f'{base} should have 2 degrees of freedom, not {q_dof}.')\n elif base == 'quadratic' or base == 'linear':\n if q_dof < 2 or q_dof > 3:\n raise ValueError(f'{base} should have 2 or 3 degrees of freedom, not {q_dof}.')\n elif base == 'constant':\n if q_dof != 1:\n raise ValueError(f'{base} should have 1 degrees of freedom, not {q_dof}.')\n elif base == 'torsion_helix' or base == 'torsion_linear_helix':\n if q_dof != 3:\n raise ValueError(f'{base} should have 3 degrees of freedom, not {q_dof}.')\n elif base == 'full':\n if q_dof < 5 or q_dof > 8:\n raise ValueError(f'{base} should have 5-8 degrees of freedom, not {q_dof}.')\n else:\n print(f'{base} is not a defined strain base.')", "def q1(self):\n import numpy as np\n dipole = self.get('q1') # they are (so far) always given in AU\n if dipole is not None:\n dipole = np.array([dipole[2], dipole[0], dipole[1]])\n return dipole", "def get_joint_data(bagFile, joint_name, duration=True):\n # INITIALIZATION\n x = np.array([])\n y = np.array([])\n theta = np.array([])\n all_t = np.array([])\n bag = rosbag.Bag(bagFile) # Initialize rosbag object\n first = True # True on first iteration to take first timestamp\n\n # Add message values to collections\n for topic, msg, t in bag.read_messages(topics=['/tf']):\n\n joint = msg.transforms[0].child_frame_id\n translation = msg.transforms[0].transform.translation\n orientation = msg.transforms[0].transform.rotation\n euler = euler_from_quaternion(\n [orientation.x, orientation.y, orientation.z, orientation.w])\n\n if joint == joint_name:\n\n # Get timestamp in seconds\n t = msg.transforms[0].header.stamp\n t_sec = t.to_sec()\n if duration:\n if first:\n t_0 = t_sec\n first = False\n\n all_t = np.append(all_t, t_sec - t_0)\n\n else:\n all_t = np.append(all_t, t_sec)\n\n # Get x, y and z coordinates\n\n x = np.append(x, translation.x)\n y = np.append(y, translation.y)\n theta = np.append(theta, euler[2])\n\n pose = [x, y, theta]\n\n return pose, all_t", "def get_joints(joint_listener): \n if LOCAL_TEST: # dummy\n return np.array([-0.5596, 0.5123, 0.5575, -1.6929, 0.2937, 1.6097, -1.237, 0.04, 0.04])\n else:\n joints = joint_listener.joint_position\n print('robot joints', joints)\n return joints", "def get_quad_dip(q):\n N = get_quad_normal(q)\n V = get_vertical_vector(q)\n dip = np.degrees(np.arccos(Vector.dot(N, V)))\n return dip", "def test_fk():\n\n joints = [0.0, 2.9, 1.3, 4.2, 1.4, 0.0]\n\n path_planner = PathPlanner(\"manipulator\")\n\n pose = path_planner.get_fk(joints)\n\n print pose", "def get_joint_number(self) -> int:\n return self.DoF", "def make_dof_value_map(robot):\n names = [j.GetName() for j in robot.GetJoints()]\n indices = [j.GetDOFIndex() for j in robot.GetJoints()]\n\n def get_dofs():\n pose={}\n values=robot.GetDOFValues()\n for (i,n) in zip(indices,names):\n pose.setdefault(n,values[i])\n return pose\n\n return get_dofs", "def fk4(joint_rotations):\n h0_4 = htm4(joint_rotations)\n x0_4 = h0_4[0, 3]\n y0_4 = h0_4[1, 3]\n z0_4 = h0_4[2, 3]\n d0_4 = [x0_4, y0_4, z0_4]\n return d0_4", "def get_pose(self, joint_values: dict, query_node: str) -> SE3:\n if query_node == \"p0\":\n return SE3.identity()\n path_nodes = self.kinematic_map[\"p0\"][query_node][1:]\n q = np.array([joint_values[node][0] for node in path_nodes])\n alpha = np.array([joint_values[node][1] for node in path_nodes])\n a = np.array([self.a[node] for node in path_nodes])\n d = np.array([self.d[node] for node in path_nodes])\n\n return fk_3d_sph(a, alpha, d, q)", "def dJ(self, name, q, dq, x=None):\n\n x = self.x_zeros if x is None else x\n funcname = name + '[0,0,0]' if np.allclose(x, 0) else name\n # check for function in dictionary\n if self._dJ.get(funcname, None) is None:\n self._dJ[funcname] = self._calc_dJ(name=name, x=x)\n parameters = tuple(q) + tuple(dq) + tuple(x)\n return np.array(self._dJ[funcname](*parameters), dtype='float32')", "def FK(joint_params):\n joint_params = np.asarray(joint_params, dtype=float)\n q1, q2, q3, q4, q5, q6, q7 = joint_params\n TF = np.linalg.multi_dot([\n Rz(q1), Tz(a1), # Joint 1 to 2\n Rx(q2), # Joint 2 to 3\n Rz(q3), Tz(a2), # Joint 3 to 4\n Rx(q4), # Joint 4 to 5\n Rz(q5), Tz(a3), # Joint 5 to 6\n Rx(q6), # Joint 6 to 7\n Rz(q7), Tz(a4) # Joint 7 to E\n ])\n return TF", "def _csv3_q2x(self, Q, deriv = 0, out = None, var = None):\n \n natoms = 3 \n base_shape = Q.shape[1:]\n \n if var is None:\n var = [0, 1, 2] # Calculate derivatives for all Q\n \n nvar = len(var)\n \n # nd = adf.nck(deriv + nvar, min(deriv, nvar)) # The number of derivatives\n nd = dfun.nderiv(deriv, nvar)\n \n # Create adf symbols/constants for each coordinate\n q = [] \n for i in range(self.nQ):\n if i in var: # Derivatives requested for this variable\n q.append(adf.sym(Q[i], var.index(i), deriv, nvar))\n else: # Derivatives not requested, treat as constant\n q.append(adf.const(Q[i], deriv, nvar))\n # q = r1, r2, theta\n \n if out is None:\n out = np.ndarray( (nd, 3*natoms) + base_shape, dtype = Q.dtype)\n out.fill(0) # Initialize out to 0\n \n # Calculate Cartesian coordinates\n \n if self.angle == 'deg':\n q[2] = (np.pi / 180.0) * q[2] \n # q[2] is now in radians\n if self.supplementary:\n q[2] = np.pi - q[2] # theta <-- pi - theta \n \n if self.embedding_mode == 0:\n np.copyto(out[:,2], (-q[0]).d ) # -r1\n np.copyto(out[:,7], (q[1] * adf.sin(q[2])).d ) # r2 * sin(theta)\n np.copyto(out[:,8], (-q[1] * adf.cos(q[2])).d ) # -r2 * cos(theta)\n elif self.embedding_mode == 1:\n np.copyto(out[:,0], (q[0] * adf.cos(q[2]/2)).d ) # r1 * cos(theta/2)\n np.copyto(out[:,2], (q[0] * adf.sin(q[2]/2)).d ) # r1 * sin(theta/2)\n np.copyto(out[:,6], (q[1] * adf.cos(q[2]/2)).d ) # r2 * cos(theta/2)\n np.copyto(out[:,8], (-q[1] * adf.sin(q[2]/2)).d ) # -r2 * sin(theta/2)\n else:\n raise RuntimeError(\"Unexpected embedding_mode\")\n \n return out", "def default_qp(\n self,\n default_index: int = 0,\n joint_angle: Optional[jp.ndarray] = None,\n joint_velocity: Optional[jp.ndarray] = None) -> QP:\n qps = {}\n if joint_angle is None:\n joint_angle = self.default_angle(default_index)\n if joint_velocity is None:\n joint_velocity = jp.zeros_like(joint_angle)\n\n # build dof lookup for each joint\n dofs_idx = {}\n dof_beg = 0\n for joint in self.config.joints:\n dof = len(joint.angle_limit)\n dofs_idx[joint.name] = (dof_beg, dof_beg + dof)\n dof_beg += dof\n\n # check overrides in config defaults\n default_qps = {}\n if default_index < len(self.config.defaults):\n defaults = self.config.defaults[default_index]\n default_qps = {qp.name for qp in defaults.qps}\n for qp in defaults.qps:\n qps[qp.name] = QP(\n pos=vec_to_arr(qp.pos),\n rot=math.euler_to_quat(vec_to_arr(qp.rot)),\n vel=vec_to_arr(qp.vel),\n ang=vec_to_arr(qp.ang))\n\n # make the kinematic tree of bodies\n root = tree.Node.from_config(self.config)\n\n parent_joint = {j.child: j for j in self.config.joints}\n rot_axes = jp.vmap(math.rotate, [True, False])\n\n for body in root.depth_first():\n if body.name in qps:\n continue\n if body.name not in parent_joint:\n qps[body.name] = QP.zero()\n continue\n # qp can be determined if the body is the child of a joint\n joint = parent_joint[body.name]\n dof_beg, dof_end = dofs_idx[joint.name]\n rot = math.euler_to_quat(vec_to_arr(joint.rotation))\n axes = rot_axes(jp.eye(3), rot)[:dof_end - dof_beg]\n angles = joint_angle[dof_beg:dof_end]\n velocities = joint_velocity[dof_beg:dof_end]\n # for each joint angle, rotate by that angle.\n # these are euler intrinsic rotations, so the axes are rotated too\n local_rot = math.euler_to_quat(vec_to_arr(joint.reference_rotation))\n for axis, angle in zip(axes, angles):\n local_axis = math.rotate(axis, local_rot)\n next_rot = math.quat_rot_axis(local_axis, angle)\n local_rot = math.quat_mul(next_rot, local_rot)\n local_offset = math.rotate(vec_to_arr(joint.child_offset), local_rot)\n local_pos = vec_to_arr(joint.parent_offset) - local_offset\n parent_qp = qps[joint.parent]\n rot = math.quat_mul(parent_qp.rot, local_rot)\n pos = parent_qp.pos + math.rotate(local_pos, parent_qp.rot)\n # TODO: propagate ang through tree and account for joint offset\n ang = jp.dot(axes.T, velocities).T\n qps[body.name] = QP(pos=pos, rot=rot, vel=jp.zeros(3), ang=ang)\n\n # any trees that have no body qp overrides in the config are set just above\n # the xy plane. this convenience operation may be removed in the future.\n body_map = {body.name: body for body in self.config.bodies}\n for node in root.children:\n children = [node.name] + [n.name for n in node.depth_first()]\n if any(c in default_qps for c in children):\n continue # ignore a tree if some part of it is overriden\n\n zs = jp.array([bodies.min_z(qps[c], body_map[c]) for c in children])\n min_z = jp.amin(zs)\n for body in children:\n qp = qps[body]\n pos = qp.pos - min_z * jp.array([0., 0., 1.])\n qps[body] = qp.replace(pos=pos)\n\n qps = [qps[body.name] for body in self.config.bodies]\n return jp.tree_map(lambda *args: jp.stack(args), *qps)", "def get_quad_length(q):\n P0, P1, P2, P3 = q\n p0 = Vector.fromPoint(P0) # fromPoint converts to ECEF\n p1 = Vector.fromPoint(P1)\n qlength = (p1 - p0).mag() / 1000\n return qlength", "def quarter_chord(self) -> np.ndarray:\n return 0.75 * self.xyz_le + 0.25 * self.xyz_te()", "def from_quaternion(self, q: np.ndarray) -> np.ndarray:\n if q is None:\n return np.identity(3)\n if q.shape[-1]!=4 or q.ndim>2:\n raise ValueError(\"Quaternion must be of the form (4,) or (N, 4)\")\n if q.ndim>1:\n q /= np.linalg.norm(q, axis=1)[:, None] # Normalize\n R = np.zeros((q.shape[0], 3, 3))\n R[:, 0, 0] = 1.0 - 2.0*(q[:, 2]**2 + q[:, 3]**2)\n R[:, 1, 0] = 2.0*(q[:, 1]*q[:, 2]+q[:, 0]*q[:, 3])\n R[:, 2, 0] = 2.0*(q[:, 1]*q[:, 3]-q[:, 0]*q[:, 2])\n R[:, 0, 1] = 2.0*(q[:, 1]*q[:, 2]-q[:, 0]*q[:, 3])\n R[:, 1, 1] = 1.0 - 2.0*(q[:, 1]**2 + q[:, 3]**2)\n R[:, 2, 1] = 2.0*(q[:, 0]*q[:, 1]+q[:, 2]*q[:, 3])\n R[:, 0, 2] = 2.0*(q[:, 1]*q[:, 3]+q[:, 0]*q[:, 2])\n R[:, 1, 2] = 2.0*(q[:, 2]*q[:, 3]-q[:, 0]*q[:, 1])\n R[:, 2, 2] = 1.0 - 2.0*(q[:, 1]**2 + q[:, 2]**2)\n return R\n q /= np.linalg.norm(q)\n return np.array([\n [1.0-2.0*(q[2]**2+q[3]**2), 2.0*(q[1]*q[2]-q[0]*q[3]), 2.0*(q[1]*q[3]+q[0]*q[2])],\n [2.0*(q[1]*q[2]+q[0]*q[3]), 1.0-2.0*(q[1]**2+q[3]**2), 2.0*(q[2]*q[3]-q[0]*q[1])],\n [2.0*(q[1]*q[3]-q[0]*q[2]), 2.0*(q[0]*q[1]+q[2]*q[3]), 1.0-2.0*(q[1]**2+q[2]**2)]])", "def qsize_from_quadrangle(qpoints):\n assert len(qpoints) == 4, \"must have 4 qpoints, but got {}\".format(len(qpoints))\n tl, tr, br, bl = qpoints\n hmax = int(max((bl - tl).y(), (br - tr).y()))\n wmax = int(max((tr - tl).x(), (br - bl).x()))\n return QSize(wmax, hmax)", "def get_strains(names, q_dof):\n strain_functions = []\n for n, this_dof in zip(names, q_dof):\n check_qdof(n, this_dof)\n if n == 'linear_helix':\n strain_functions.append(linear_helix_strain)\n elif n == 'pure_helix':\n strain_functions.append(pure_helix_strain)\n elif n == 'torsion_helix':\n strain_functions.append(torsion_helix_strain)\n elif n == 'torsion_linear_helix':\n strain_functions.append(torsion_linear_helix_strain)\n elif n == 'quadratic':\n strain_functions.append(quadratic_strain)\n elif n == 'linear':\n strain_functions.append(linear_strain)\n elif n == 'constant':\n strain_functions.append(constant_strain)\n elif n == 'full':\n strain_functions.append(full_strain)\n else:\n print(f'{n} is not a defined strain base.')\n return strain_functions", "def orientation_gazebo_to_px4(orientation_q):\n return tf_enu_to_ned(tf_baselink_to_aircraft(orientation_q))" ]

[ "0.5734758", "0.5489396", "0.5309817", "0.5117031", "0.50999624", "0.5072133", "0.50482094", "0.50176036", "0.4997793", "0.49432415", "0.4891485", "0.4865569", "0.47592014", "0.47541997", "0.4749527", "0.47479632", "0.47286186", "0.4689717", "0.4671337", "0.46211225", "0.46206507", "0.46137872", "0.46024984", "0.45985946", "0.45778516", "0.45697257", "0.45388046", "0.45113033", "0.45034692", "0.44960293" ]

[ "def update_tree(tree, subtree_hierarchy):\n new_tree = subtree_hierarchy.copy()\n for bg_pop, row in subtree_hierarchy.iterrows():\n # Remove not showing pops from new_tree\n if row['To_show'] == 'no':\n new_tree = new_tree.drop(bg_pop)\n continue\n\n # Find Parent\n parent_to_show = row['Parent']\n # If bg_pop has no Parent, skip\n if parent_to_show == '':\n continue\n # If Parent not in subtree, skip\n if parent_to_show not in subtree_hierarchy.index:\n continue\n # If Parent has To_show = 'no', find Parent of Parent, etc.\n while subtree_hierarchy.at[parent_to_show, 'To_show'] == 'no':\n parent_to_show = subtree_hierarchy.at[parent_to_show, 'Parent']\n # Set Parent to show in new_tree\n new_tree.at[bg_pop, 'Parent'] = parent_to_show\n\n new_tree = new_tree.reset_index()[['index', 'BG_population', 'Parent', 'BG_label']]\n # For pairs ('BG_population', 'Parent') that has coords, add coords\n new_tree_pos = new_tree.merge(tree.reset_index(), how='left', on=['BG_population', 'Parent'])\n new_tree_pos = new_tree_pos[['index_x', 'BG_population', 'Parent', 'posX', 'posY', 'BG_label_x']] \\\n .rename(columns={'index_x': 'index', 'BG_label_x': 'BG_label'}) \\\n .fillna('')\n\n return new_tree_pos", "def make_dendrogram_tree(df):\n ZZZ = calculate_linkage_matrix_in_python_format(df)\n\n # set idx to the index of the root node (= the one with the largest number of descendants)\n root_node_idx = int(ZZZ[:, 3].argmax())\n\n N = len(df)\n return make_dendrogram_subtree(df, root_node_idx + N, ZZZ, N)", "def build_anchor_df(df):\n df_columns = df.columns\n forward_df = (df\n .rename({df_columns[0]: 'anchor_guide', df_columns[1]: 'target_guide',\n df_columns[2]: 'anchor_gene', df_columns[3]: 'target_gene'}, axis=1))\n reverse_df = (df\n .rename({df_columns[1]: 'anchor_guide', df_columns[0]: 'target_guide',\n df_columns[3]: 'anchor_gene', df_columns[2]: 'target_gene'}, axis=1))\n anchor_df = (pd.concat([forward_df, reverse_df])\n .drop_duplicates() # in case where guide1==guide2\n .reset_index(drop=True))\n return anchor_df", "def simplify_directed_as_dataframe(df: gpd.GeoDataFrame) -> gpd.GeoDataFrame:\n df.reset_index(inplace=True)\n\n g = gt.Graph(directed=True)\n osm_id = g.new_edge_property('string')\n highway = g.new_edge_property('string')\n level = g.new_edge_property('int')\n lanes = g.new_edge_property('int')\n width = g.new_edge_property('float')\n bicycle = g.new_edge_property('bool')\n bicycle_safety = g.new_edge_property('int')\n foot = g.new_edge_property('bool')\n foot_safety = g.new_edge_property('int')\n max_speed = g.new_edge_property('int')\n motorcar = g.new_edge_property('bool')\n linestring = g.new_edge_property('python::object')\n\n edgelist = df[\n ['u', 'v', 'osm_id', 'highway', 'level', 'lanes', 'width', 'bicycle', 'bicycle_safety', 'foot', 'foot_safety',\n 'max_speed', 'motorcar', 'geometry']].values\n\n nodes_id = g.add_edge_list(edgelist, hashed=True,\n eprops=[osm_id, highway, level, lanes, width, bicycle, bicycle_safety, foot, foot_safety,\n max_speed, motorcar, linestring])\n\n # we are gonna replace the original repeated nodes with a linestring\n e_path = g.new_ep('vector<int64_t>')\n for e in g.edges():\n e_path[e] = []\n\n vs = g.get_vertices()\n in_out_deg_2 = (g.get_in_degrees(vs) == 2) & (g.get_out_degrees(vs) == 2)\n\n logging.debug('selecting degree 4 candidates')\n candidates = set()\n for i, v in enumerate(vs):\n if in_out_deg_2[i]:\n ns = list(set(g.get_all_neighbors(v)))\n if len(ns) == 2:\n u, w = ns[0], ns[1]\n uv, vw, wv, vu = g.edge(u, v), g.edge(v, w), g.edge(w, v), g.edge(v, u)\n if highway[uv] == highway[vw] and highway[wv] == highway[vu]:\n candidates.add(v)\n logging.debug('found {} degree 4 candidates to simplify'.format(len(candidates)))\n\n seen = set()\n unregister_candidates = set()\n\n for i, candidate in enumerate(candidates):\n if i == 100000:\n logging.debug('100000 degree 4 candidates')\n if candidate in seen:\n continue\n\n seen.add(candidate)\n\n u, w = g.get_out_neighbors(candidate)\n is_u_fringe, is_w_fringe = u not in candidates, w not in candidates\n\n cu, cw = g.edge(candidate, u), g.edge(candidate, w)\n\n us = []\n ws = []\n\n while not is_u_fringe:\n seen.add(u)\n us.append(u)\n neighbors = set(g.get_out_neighbors(u))\n neighbors -= seen\n if len(neighbors) > 0:\n u = neighbors.pop()\n is_u_fringe = u not in candidates\n elif u == w:\n us.pop(-1)\n u = us.pop(-1)\n unregister_candidates.add(u)\n unregister_candidates.add(w)\n is_u_fringe = True\n is_w_fringe = True\n g.remove_edge(g.edge(s=u, t=w))\n g.remove_edge(g.edge(s=w, t=u))\n else:\n logging.debug('degree 2: we got here somehow {} {} {} {}', candidate, u, v,\n g.get_all_neighbors(candidate))\n break\n\n while not is_w_fringe:\n seen.add(w)\n ws.append(w)\n neighbors = set(g.get_out_neighbors(w))\n neighbors -= seen\n if len(neighbors) > 0:\n w = neighbors.pop()\n is_w_fringe = w not in candidates\n else:\n logging.debug('degree 2: we got here somehow {} {} {} {}', candidate, u, v,\n g.get_all_neighbors(candidate))\n break\n\n if is_u_fringe and is_w_fringe:\n e = g.add_edge(source=u, target=w)\n path = [u] + list(reversed(us)) + [candidate] + ws + [w]\n e_path[e] = [int(nodes_id[node]) for node in path]\n linestrings = [linestring[g.edge(a, b)] for a, b in pairwise(path)]\n linestring[e] = join_linestrings(linestrings)\n osm_id[e], highway[e], level[e], lanes[e], width[e], bicycle[e], bicycle_safety[e], foot[e], foot_safety[e], \\\n max_speed[e], motorcar[e] = osm_id[cw], highway[cw], level[cw], lanes[cw], width[cw], bicycle[cw], \\\n bicycle_safety[cw], \\\n foot[cw], foot_safety[cw], max_speed[cw], motorcar[cw]\n\n e = g.add_edge(source=w, target=u)\n path = [w] + list(reversed(ws)) + [candidate] + us + [u]\n e_path[e] = [int(nodes_id[node]) for node in path]\n linestrings = [linestring[g.edge(a, b)] for a, b in pairwise(path)]\n linestring[e] = join_linestrings(linestrings)\n osm_id[e], highway[e], level[e], lanes[e], width[e], bicycle[e], bicycle_safety[e], foot[e], foot_safety[e], \\\n max_speed[e], motorcar[e] = osm_id[cu], highway[cu], level[cu], lanes[cu], width[cu], bicycle[cu], \\\n bicycle_safety[cu], \\\n foot[cu], foot_safety[cu], max_speed[cu], motorcar[cu]\n\n else:\n logging.debug(\n 'unexpected behavior, source={0}, target={1}, candidate={2}, us={3}, ws={4}'.format(u, w, candidate, us,\n ws))\n\n unseen = candidates - seen\n if len(unseen) > 0:\n logging.debug(\n 'Network scan after degree 4 simplification uncomplete: candidates {0} have not been examined'.format(\n unseen))\n\n candidates -= unregister_candidates\n g.remove_vertex(list(candidates))\n\n vs = g.get_vertices()\n in_out_deg_1 = (g.get_in_degrees(vs) == 1) & (g.get_out_degrees(vs) == 1)\n\n logging.debug('selecting degree 2 candidates')\n candidates = set()\n for i, v in enumerate(vs):\n if in_out_deg_1[i]:\n u = g.get_in_neighbors(v)[0]\n w = g.get_out_neighbors(v)[0]\n\n if u != w:\n uv, vw = g.edge(u, v), g.edge(v, w)\n if highway[uv] == highway[vw]:\n candidates.add(v)\n logging.debug('found {} degree 2 candidates to simplify'.format(len(candidates)))\n\n seen = set()\n unregister_candidates = set()\n\n for candidate in candidates:\n if candidate in seen:\n continue\n\n seen.add(candidate)\n\n u = g.get_in_neighbors(candidate)[0]\n w = g.get_out_neighbors(candidate)[0]\n\n uc = g.edge(u, candidate)\n\n is_u_fringe, is_w_fringe = u not in candidates, w not in candidates\n\n us = []\n ws = []\n\n while not is_u_fringe:\n seen.add(u)\n us.append(u)\n neighbors = set(g.get_in_neighbors(u))\n neighbors -= seen\n if len(neighbors) > 0:\n u = neighbors.pop()\n is_u_fringe = u not in candidates\n elif u == w:\n us.pop(-1)\n u = us.pop(-1)\n unregister_candidates.add(u)\n unregister_candidates.add(w)\n is_u_fringe = True\n is_w_fringe = True\n g.remove_edge(g.edge(s=w, t=u))\n else:\n logging.debug('degree 1: we got here somehow {} {} {} {}', candidate, u, v,\n g.get_all_neighbors(candidate))\n break\n\n while not is_w_fringe:\n seen.add(w)\n ws.append(w)\n neighbors = set(g.get_out_neighbors(w))\n neighbors -= seen\n if len(neighbors) > 0:\n w = neighbors.pop()\n is_w_fringe = w not in candidates\n else:\n logging.debug('degree 1: we got here somehow {} {} {} {}', candidate, u, v,\n g.get_all_neighbors(candidate))\n break\n\n if is_u_fringe and is_w_fringe:\n e = g.add_edge(source=u, target=w)\n path = [u] + list(reversed(us)) + [candidate] + ws + [w]\n e_path[e] = [int(nodes_id[node]) for node in path]\n linestrings = [linestring[g.edge(a, b)] for a, b in pairwise(path)]\n linestring[e] = join_linestrings(linestrings)\n osm_id[e], highway[e], level[e], lanes[e], width[e], bicycle[e], bicycle_safety[e], foot[e], foot_safety[e], \\\n max_speed[e], motorcar[e] = osm_id[uc], highway[uc], level[uc], lanes[uc], width[uc], bicycle[uc], \\\n bicycle_safety[uc], \\\n foot[uc], foot_safety[uc], max_speed[uc], motorcar[uc]\n else:\n logging.error('unexpected behavior, source={0}, target={1}, candidate={2}, us={3}, ws={4}', u, w, us, ws)\n\n unseen = candidates - seen\n if len(unseen) > 0:\n logging.debug(\n 'Network scan after degree 2 simplification not finished: candidates {0} have not been examined'.format(\n unseen))\n\n candidates -= unregister_candidates\n g.remove_vertex(list(candidates))\n\n logging.debug(' linestring path')\n edges_tuples = []\n for e in g.edges():\n source, target, path = nodes_id[e.source()], nodes_id[e.target()], e_path[e]\n if len(path) == 0:\n path = [source, target]\n else:\n path = [int(i) for i in path]\n\n e_tuples = (g.edge_index[e], source, target, path,\n osm_id[e], highway[e], level[e], lanes[e], width[e], bicycle[e], bicycle_safety[e], foot[e],\n foot_safety[e], max_speed[e], motorcar[e], linestring[e])\n edges_tuples.append(e_tuples)\n\n df_edges_simplified = pd.DataFrame.from_records(edges_tuples, index='edge_id',\n columns=['edge_id', 'u', 'v', 'path', 'osm_id', 'highway',\n 'level', 'lanes', 'width', 'bicycle', 'bicycle_safety',\n 'foot', 'foot_safety', 'max_speed', 'motorcar',\n 'geometry'])\n\n df_edges_simplified.osm_id = df_edges_simplified.osm_id.str.split('-').str[0]\n df_edges_simplified = gpd.GeoDataFrame(df_edges_simplified, geometry='geometry')\n df_edges_simplified.crs = df.crs\n return df_edges_simplified", "def unflatten_to_tree(df, label_map=None, label_col='label', id_col='id'):\r\n\r\n tf_df = df.filter(like='level')\r\n n_lvls = len(tf_df.columns)\r\n lvl_list = range(n_lvls)\r\n\r\n # Construct all nodes\r\n uniq_ids = pd.Series(pd.unique(tf_df.values.ravel()))\r\n uniq_ids = uniq_ids.dropna()\r\n\r\n if label_map is not None:\r\n assert len(set(uniq_ids)-set(label_map[label_col].unique()))==0, '''\r\n If a label_map is specified, all labels in df must\r\n be present in the map '''\r\n rdict = { r[label_col]: r[id_col] for i, r in label_map.iterrows() }\r\n tf_df = tf_df.replace(rdict)\r\n uniq_ids = pd.Series(pd.unique(tf_df.values.ravel()))\r\n uniq_ids = uniq_ids.dropna()\r\n uniq_ids = uniq_ids.astype('int')\r\n\r\n assert len(tf_df['level_0'].unique())==1, '''there can only be\r\n one level_0 id'''\r\n root_id = tf_df['level_0'].unique()[0]\r\n\r\n nodes = {}\r\n for nid in uniq_ids:\r\n nodes[nid] = Node(nid, {}, None)\r\n\r\n # Make relationships\r\n for i in lvl_list:\r\n lvl_col = 'level_%s' % i\r\n nxtlvl_col = 'level_%s' % (i+1)\r\n assert ~tf_df[lvl_col].isin(tf_df.drop(lvl_col, axis=1)).any(), '''\r\n ids cannot span multiple levels'''\r\n\r\n if i<lvl_list[-1]:\r\n for pnid in tf_df[lvl_col].unique():\r\n child_locs = pd.Series(tf_df.ix[tf_df[lvl_col]==pnid,\r\n nxtlvl_col].unique()).dropna()\r\n for cnid in child_locs:\r\n nodes[cnid].parent = nodes[pnid]\r\n nodes[pnid].add_child(nodes[cnid])\r\n\r\n t = Tree(nodes[root_id])\r\n return t", "def transform(self, df):\n df = df.copy()\n \"\"\"\n if self.grouping is not None:\n df = self.hier.transform(df)\n \"\"\"\n # fill NaN\n df = self.fill_na(df)\n\n self.df_index = df.index\n self.df_colnames = df.columns\n # transformations\n for i in sorted(self.transformations.keys()):\n transformation = self.transformations[i]\n df = self.transformers[i].transform(df)\n # convert to DataFrame only if it isn't already\n if not isinstance(df, pd.DataFrame):\n df = pd.DataFrame(df)\n df.index = self.df_index\n df.columns = self.df_colnames\n # update index reference if sliced\n if transformation in ['Slice']:\n self.df_index = df.index\n self.df_colnames = df.columns\n df = df.replace([np.inf, -np.inf], 0) # .fillna(0)\n return df", "def reset_node_ids(df):\n le = LabelEncoder()\n all_node_names = list(set(df['from_name'].values.tolist() + df['to_name'].values.tolist()))\n le.fit(all_node_names)\n df['from_id'] = le.transform(df['from_name'])\n df['to_id'] = le.transform(df['to_name'])\n return df, le", "def get_reactome_hierarchy_df() -> pd.DataFrame:\n return pd.read_csv(REACTOME_HIERARCHICAL_MAPPINGS_PATH, sep='\\t')", "def edge_list_build(input_path, output_path):\n\n start_time = time.time()\n\n df = pd.read_csv(input_path, sep='\\t', header=None)\n\n for col in range(1, len(df.columns)):\n df.iloc[:, col] = df.iloc[:, col-1] + '_' + df.iloc[:, col]\n\n n_divs = len(df.columns) - 1\n\n\n dict_node_names = {}\n\n for id, node_name in enumerate(np.unique(df.values.flatten())):\n dict_node_names[node_name] = id + 1\n\n tmp_df = pd.DataFrame.from_dict(dict_node_names, orient='index')\n tmp_df.reset_index(inplace=True)\n tmp_df.rename({'index': 'nodes', 0: 'hash'}, inplace=True, axis=1)\n\n hash_df = tmp_df['nodes'].str.split('_', n=n_divs, expand=True)\n hash_df = pd.concat([hash_df, tmp_df['hash']], axis=1)\n\n for col_name in df.columns:\n df[col_name] = df[col_name].map(dict_node_names)\n\n df['root'] = 0\n colnames = df.columns.values\n colnames = list(colnames[-1:]) + list(colnames[:-1])\n df = df[colnames]\n\n df_tuples = pd.DataFrame()\n\n for i in range(len(df.columns) - 1):\n df_tuples[i] = list(df[df.columns[i:i + 2]].itertuples(index=False, name=None))\n del df\n gc.collect()\n\n nodes_list = []\n\n for col_id in range(0, df_tuples.shape[1]):\n father_child = df_tuples.iloc[:, col_id].drop_duplicates().values\n nodes_list.extend(father_child)\n\n graph = nx.DiGraph(nodes_list)\n graph_bfs = nx.bfs_tree(graph, 0)\n \n path = output_path + '.hashmap'\n hash_df.to_csv(path, index=False, sep='\\t')\n end_time = time.time()\n print(\"Time spent creating tree from csv file:\", end_time - start_time)\n return graph_bfs", "def update_tip_names(tree, taxdict):\n\n list_nodes = []\n uniprot_mapping = pd.DataFrame(columns=['taxid', 'name', 'uniprot'])\n\n counter = 0\n for node in tree.traverse(\"postorder\"):\n current_name = node.name\n\n if 'NMR' in current_name:\n new_name = \"Heterocephalus_glaber\"\n node.name = new_name\n list_nodes.append(node.name)\n taxid = \"NA\" \n uniprot_mapping.loc[counter] = (taxid, new_name, \"UP000006813\")\n counter += 1\n\n elif 'Nfurzer' in current_name:\n new_name = \"Nothobranchius_furzeri\"\n node.name = new_name\n list_nodes.append(node.name)\n taxid = \"NA\"\n uniprot_mapping.loc[counter] = (taxid, new_name, new_name)\n counter += 1\n\n elif 'TAX' in current_name:\n taxid = current_name[3:].split('x')[0]\n new_name = taxdict.get(taxid, taxid) \n node.name = new_name \n list_nodes.append(node.name)\n unip = get_uniprot(taxid, accession)\n uniprot_mapping.loc[counter] = (taxid, new_name, unip)\n counter += 1\n\n\n \n tree.write(outfile=\"../../data/tree/tree.nw\")\n\n nodes_df = pd.DataFrame(list_nodes)\n nodes_df.to_csv(\"../../data/tree/tree_list_nodes.txt\", index=False, header=False)\n\n uniprot_mapping.to_csv(\"../../data/tree/tree_uniprot.txt\", sep='\\t', index=False, header=True)\n\n return tree, list_nodes", "def write_anchor(args, synteny_parent=None, mailbox_reader=None):\n idx = args[0]\n with mailbox_reader(idx) as file_handle:\n anchor_frame = pd.read_csv(\n file_handle, sep=\"\\t\", index_col=0\n ).convert_dtypes()\n in_anchor = len(anchor_frame)\n if in_anchor == 0:\n return None\n # drop any duplicated ID's--normally shouldn't happen\n anchor_frame.drop(\n anchor_frame[anchor_frame.index.duplicated()].index, inplace=True\n )\n anchor_frame.sort_values(\n by=[\"syn.anchor.sub_id\", \"frag.idx\", \"frag.pos\"], inplace=True\n )\n # Make a dictionary of common anchor properties, order will be kept\n anchor_props = {\n \"anchor.id\": idx,\n \"sub\": None,\n \"code\": None,\n \"count\": None,\n \"n\": None,\n \"n_ambig\": None,\n \"n_adj\": None,\n \"adj_groups\": None,\n \"frag.direction\": None,\n \"syn.anchor.direction\": None,\n \"anchor.subframe.ok\": True,\n \"hash\": None,\n }\n code_set = set(anchor_frame[\"syn.code\"])\n for test_code in CODE_DICT.keys():\n if test_code in code_set:\n anchor_props[\"code\"] = test_code\n break\n bad_subframe = False\n prop_list = []\n for sub_no, subframe in anchor_frame.groupby(by=[\"syn.anchor.sub_id\"]):\n (subanchor_props, anchor_subframe, bad_subframe) = _subframe_props(\n anchor_props, subframe, sub_no\n )\n if bad_subframe:\n break\n write_tsv_or_parquet(\n anchor_subframe,\n synteny_parent / f\"{idx}.{sub_no}.{SYNTENY_FILETYPE}\",\n sort_cols=False,\n )\n prop_list.append(subanchor_props)\n if bad_subframe: # Probably means a hash collision\n logger.error(f\"bad anchor set {idx}\")\n prop_list = []\n sub_no = 0\n anchor_props[\"anchor.subframe.ok\"] = False\n for cluster_id, subframe in anchor_frame.groupby(by=[\"hom.cluster\"]):\n (\n subanchor_props,\n anchor_subframe,\n unused_bad_subframe,\n ) = _subframe_props(anchor_props, subframe, sub_no)\n write_tsv_or_parquet(\n anchor_subframe,\n synteny_parent / f\"{idx}.{sub_no}.{SYNTENY_FILETYPE}\",\n sort_cols=False,\n )\n sub_no += 1\n prop_list.append(subanchor_props)\n return prop_list", "def normalize_to_flat(classifier, df, col):\n name = str(classifier) + '_df'\n new_df= json_normalize(df.loc[classifier][col])\n new_df['classifier'] = [classifier]\n return new_df", "def get_node_positions(distance_df, y_offset=-0.5):\n\n # If there are more than two genomes/groups\n if distance_df.shape[0] > 2:\n\n # Format the distances as expected by skbio\n distances_dm = DistanceMatrix(\n distance_df.values, \n list(map(str, distance_df.index.values))\n )\n\n # Make a neighbor-joining tree\n tree = nj(distances_dm)\n\n # Root at midpoint\n tree = tree.root_at_midpoint()\n\n # If there are only two genomes/groups\n elif distance_df.shape[0] == 2:\n\n # Get the distance betweeen the genomes/groups\n distance_between = distance_df.values[0, 1]\n\n # Make a simple tree linking the two\n tree = TreeNode(\n name='root',\n children=[\n TreeNode(\n name=distance_df.index.values[0],\n length=distance_between / 2.\n ),\n TreeNode(\n name=distance_df.index.values[1],\n length=distance_between / 2.\n )\n ]\n )\n\n # If there is only one genomes/groups\n elif distance_df.shape[0] == 1:\n\n # Make a simple tree with a single leaf\n tree = TreeNode(\n name='root',\n children=[\n TreeNode(\n name=distance_df.index.values[0],\n length=0\n )\n ]\n )\n\n # Assign x/y to create a DataFrame\n node_positions = CartesianTree(\n tree,\n y_offset=y_offset,\n )\n\n # Return that CartesianTree object\n return node_positions", "def build_tree(df) -> dict:\r\n # initialize empty tree as a dictionary\r\n tree = {}\r\n # find column associated with best information gain\r\n next_att = best_inf_gain_att(df)\r\n # next_att = find_winner(df)\r\n tree[next_att] = {}\r\n\r\n # for each value of the attribute at hand\r\n for val in np.unique(df[next_att]):\r\n # get new table\r\n subtable = get_subtable(df, next_att, val)\r\n # get information on new y characteristics\r\n sub_val, sub_val_counts = np.unique(subtable.iloc[:, -1], return_counts=True)\r\n\r\n # if there's only one label value left, assign it\r\n if 1 == sub_val.shape[0]:\r\n tree[next_att][val] = sub_val[0]\r\n # if there are no more columns except the label column, assign the most frequent label\r\n elif 1 == subtable.columns.shape[0]:\r\n tree[next_att][val] = sub_val[np.argmax(sub_val_counts)]\r\n # otherwise add node recursively\r\n else:\r\n tree[next_att][val] = build_tree(subtable)\r\n\r\n return tree", "def prot_df_to_graph(df, edge_dist_cutoff=4.5):\n\n node_pos = torch.FloatTensor(df[['x', 'y', 'z']].to_numpy())\n\n kd_tree = ss.KDTree(node_pos)\n edge_tuples = list(kd_tree.query_pairs(edge_dist_cutoff))\n edges = torch.LongTensor(edge_tuples).t().contiguous()\n\n node_feats = torch.FloatTensor([one_of_k_encoding_unk(e, prot_atoms) for e in df['element']])\n edge_feats = torch.FloatTensor(\n [1.0 / (np.linalg.norm(node_pos[i] - node_pos[j]) + 1e-5) for i, j in edge_tuples]).view(-1, 1)\n # feats = F.one_hot(elems, num_classes=len(atom_int_dict))\n\n return node_feats, edges, edge_feats, node_pos", "def build_tree(self, df=None, tree=None, depth=0):\n if df is None:\n df = self.df\n target = self.target\n\n node = self.get_lowest_entropy_feature(df)\n if not node:\n print(\"Pure solution not possible in current branch...\")\n return tree\n variables = df[node].unique()\n\n if tree is None: \n tree = {}\n tree[node] = {}\n\n for value in variables:\n subtable = df[df[node] == value].reset_index(drop=True)\n inner_variables, counts = np.unique(subtable[target], return_counts=True) \n \n if len(counts) == 1:\n tree[node][value] = inner_variables[0] \n elif depth >= self.max_depth:\n return tree \n else:\n depth += 1 \n tree[node][value] = self.build_tree(df=subtable, depth=depth)\n \n return tree", "def related_df_shaper(df): \n id_related=list()\n id_primary=list()\n id_relation_type=list()\n for id_term in df.id_term:\n \n related_id_list=df.loc[df.id_term==id_term,'related_terms'].values[0]\n id_relation_type_list=df.loc[df.id_term==id_term,'id_relation_type'].values[0]\n for i in range(len(related_id_list)):\n id_related.append(related_id_list[i])\n id_relation_type.append(id_relation_type_list[i])\n id_primary.append(id_term)\n \n df_rs=pd.DataFrame({'id_term':id_primary,'id_term_related':id_related,'id_relation_type':id_relation_type})\n now=pd.to_datetime(datetime.datetime.now())\n df_rs=df_rs.assign(datetime_created=now)\n df_rs=df_rs.assign(datetime_updated=now)\n df_rs=df_rs.assign(id_user_created=7)\n df_rs=df_rs.assign(id_user_updated=7)\n \n return df_rs", "def __encode_genre_transform(self, df):\n\t\treturn df.join(\n\t\t\tpd.DataFrame(self.genre_mlb.transform(df.pop(\"genres\")), columns=self.genre_mlb.classes_, index=df.index),\n\t\t\tlsuffix='l')", "def remodeling(df, df_name):\n # df_name = get_df_name(df)\n new_df = country_code_update(df)\n # new_df.rename(columns={'country_code': 'date'}, inplace=True)\n new_df = new_df.set_index('country_code').transpose().rename_axis('', axis=1)\n new_df.index.name = 'date'\n new_df.index = pd.to_datetime(new_df.index)\n new_df = new_df.add_suffix('_' + df_name)\n return new_df", "def reindex_subcomponent_taxa(self):\n ti_mutable = self.taxon_set._is_mutable\n self.taxon_set._is_mutable = True\n new_map = CharacterDataMap()\n for taxon, seq in self.taxon_seq_map.items():\n taxon = self.taxon_set.require_taxon(label=taxon.label)\n new_map[taxon] = seq\n self.taxon_set._is_mutable = ti_mutable\n self.taxon_seq_map = new_map", "def flatten(self):\r\n df = pd.DataFrame([{'level_0': self.root.id}])\r\n for lvl in range(1, self.max_depth()+1):\r\n loc_pairs = [(l.parent.id, l.id) for l in self.level_n_descendants(lvl)]\r\n loc_pairs = pd.DataFrame(loc_pairs)\r\n loc_pairs.rename(columns={\r\n 0: 'level_'+str(lvl-1),\r\n 1: 'level_'+str(lvl)}, inplace=True)\r\n df = df.merge(loc_pairs, on='level_'+str(lvl-1), how='left')\r\n df['leaf_node'] = df.apply(lambda x:\r\n next(l for l in reversed(x) if pd.notnull(l)), axis=1)\r\n\r\n for c in df.columns:\r\n try:\r\n df[c] = df[c].astype('int')\r\n except:\r\n pass\r\n\r\n return df", "def table_with_routes(df, routes):\n full_names = []\n high_tax_list = []\n low_tax_list = []\n for org in in_taxa_dict.keys():\n group, subtax, long_name = in_taxa_dict[org]\n high_tax_list.append(group)\n low_tax_list.append(subtax)\n full_names.append(long_name)\n\n df = df[df.index.isin(in_taxa_dict.keys())]\n no_seqs = set(in_taxa_dict.keys()) - set(df.index)\n\n for taxon in no_seqs:\n df.loc[taxon] = len(df.columns) * [0]\n\n df.index.name = 'Unique ID'\n df.insert(loc=0, column='Lower Taxonomy', value=low_tax_list)\n df.insert(loc=0, column='Higher Taxonomy', value=high_tax_list)\n df.insert(loc=0, column='Full Name', value=full_names)\n\n df = df.sort_index(axis=0)\n df.to_csv(f'{output_fold}/occupancy.tsv', sep='\\t')\n\n # Adds routes to df\n for gene in df.columns:\n df[gene] = df[gene].apply(str)\n for org in df[gene].index:\n if org in routes[gene]:\n df.at[org, gene] = f'{df[gene][org]}_{routes[gene][org]}'\n\n df.to_csv(f'{output_fold}/occupancy_with_routes.tsv', sep='\\t')\n\n return df", "def build_gene_indexes(df):\n\tgeneDict = OrderedDict()\n\n\tgeneCount = 0\n\tpreviousGeneIndex = 0\n\n\tcurrent_id=\"\"\n\tcurrent_gene=\"\"\n\n\tfor i in range(len(df)):\n\n\t\tif df.loc[i,'feature'] == 'gene':\n\t\t\ttrdict = parse_entry(df.loc[i,'transcript_id'])\n\n\t\t\tcurGeneID = trdict['gene_id'][0]\n\t\t\n\t\t\tif geneCount != 0:\n\t\t\t\tnewGeneIndex = i\n\t\t\t\tgeneDict[current_id] = [previousGeneIndex,newGeneIndex]\n\t\t\t\tpreviousGeneIndex = i\n\t\t\t\tcurrent_id = trdict['gene_id'][0]\n\t\t\t\tgeneCount += 1\n\n\t\t\telse:\n\t\t\t\tnewgeneIndex = 0\n\t\t\t\tgeneCount +=1\n\t\t\t\tcurrent_id = trdict['gene_id'][0]\n\t\tif i == (len(df)-1):\n\t\t\tnewGeneIndex = i+1\n\t\t\tcurrent_id = trdict['gene_id'][0]\n\t\t\tgeneDict[current_id] = [previousGeneIndex,newGeneIndex]\n\treturn geneDict", "def edge_list_df_to_igraph(edge_list_df, node_id_mapper):\n nodes = list(set(edge_list_df.from_id.values.tolist() + edge_list_df.to_id.values.tolist()))\n #node_names = list(set(edge_list_df.from_name.values.tolist() + edge_list_df.to_name.values.tolist()))\n edges = list(zip(edge_list_df.from_id, edge_list_df.to_id))\n weights = list(edge_list_df.weight.values)\n g = Graph()\n g.add_vertices(len(nodes))\n g.add_edges(edges)\n g.es['weight'] = weights\n g.vs['label'] = list(node_id_mapper.inverse_transform(np.array(range(len(g.vs)))))\n g.vs['community'] = 0 # Set original community the same for all nodes\n return g, edges", "def expand_affiliation(df):\n from pandas import Series\n res = df[[\"source_id\", \"author_ids\", \"afid\"]].copy()\n res['afid'] = res[\"afid\"].str.split(';')\n res = (res[\"afid\"].apply(Series)\n .merge(res, right_index=True, left_index=True)\n .drop([\"afid\"], axis=1)\n .melt(id_vars=['source_id', 'author_ids'], value_name=\"afid\")\n .drop(\"variable\", axis=1)\n .dropna())\n res['afid'] = res['afid'].astype(float)\n return res", "def CreateAugmentedDataset(df: pd.DataFrame) -> pd.DataFrame:\n with prof.Profile(\"dead code mutations\"):\n seed = np.random.RandomState(0xCEC)\n\n candidate_kernels = df[\"program:opencl_src\"].values.copy()\n\n new_columns = list(df.columns.values) + [\"program:is_mutation\"]\n new_rows = []\n\n for _, row in df.iterrows():\n kernel = row[\"program:opencl_src\"]\n\n # Insert the original row.\n row[\"program:is_mutation\"] = False\n new_rows.append(row)\n\n # Create and insert mutation rows.\n for _ in range(3):\n row = row.copy()\n row[\"program:is_mutation\"] = True\n # Insert a single dead kernel into each original kernel.\n dci = opencl_deadcode_inserter.OpenClDeadcodeInserter(\n seed, kernel, candidate_kernels=candidate_kernels\n )\n dci.InsertBlockIntoKernel()\n row[\"program:opencl_src\"] = dci.opencl_source\n new_rows.append(row)\n\n return pd.DataFrame(new_rows, columns=new_columns)", "def aggregate_intermediate_data_frame(self, node_name, child, child_df, edge_df):\n expr = []\n for n in child_df.schema.names:\n if n in self.parser.reducer_by_prop:\n if self.parser.reducer_by_prop.get(n) in [\"list\", \"set\"]:\n expr.append(\n self.reducer_to_agg_func_expr(\n self.parser.reducer_by_prop.get(n), n, is_merging=False\n )\n )\n else:\n expr.append(\n self.reducer_to_agg_func_expr(\n self.parser.reducer_by_prop.get(n), n, is_merging=True\n )\n )\n if len(expr) == 0:\n expr.append(\n self.reducer_to_agg_func_expr(\"set\", get_node_id_name(child.name))\n )\n tmp_df = (\n self.join_two_dataframe(edge_df, child_df, how=\"left_outer\")\n .groupBy(get_node_id_name(node_name))\n .agg(*expr)\n )\n\n select_expr = [get_node_id_name(node_name)]\n for n in child_df.schema.names:\n if n in self.parser.reducer_by_prop and self.parser.reducer_by_prop.get(\n n\n ) in [\"list\", \"set\"]:\n select_expr.append(\n self.reducer_to_agg_func_expr(\n self.parser.reducer_by_prop.get(n), n, is_merging=True\n )\n )\n tmp_df = tmp_df.select(*select_expr)\n return self.return_dataframe(\n tmp_df,\n f\"{Translator.aggregate_intermediate_data_frame.__qualname__}__{node_name}__{child.name}\"\n )", "def make_homologues_mirnas(phylogenetic_tree, mirna_seqs):\n species = [leaf.taxon.label for leaf in phylogenetic_tree.leaf_iter()]\n mirhomologues = pd.DataFrame({sp: {mirid: mirna_seqs[mirid][:21]\n for mirid in mirna_seqs.keys()}\n for sp in species}).transpose()\n return mirhomologues", "def reduced_votes_to_predictions(df, schema, save_loc):\n predictions = get_predictions(df, schema)\n encoded_predictions = encode_answers(predictions, schema)\n\n if save_loc is not None:\n logging.info('Saved predictions to {}'.format(save_loc))\n encoded_predictions.to_csv(save_loc, index=False)\n\n return encoded_predictions", "def tree2pwdist(tree):\n if isinstance(tree, type(Phylo.BaseTree.Tree())):\n N = len(tree.get_terminals())\n names = [node.name for node in tree.get_terminals()]\n pwdist = np.zeros((N, N))\n for i, node1 in enumerate(tree.get_terminals()):\n for j, node2 in enumerate(tree.get_terminals()):\n \"\"\"Compute half of these and assume symmetry\"\"\"\n if i==j:\n pwdist[i, j] = 0\n elif i<j:\n pwdist[i, j] = tree.distance(node1, node2)\n pwdist[j, i] = pwdist[i, j]\n elif isinstance(tree, type(dendropy.Tree())):\n pdm = dendropy.treecalc.PatristicDistanceMatrix(tree)\n taxon_set = [n.taxon for n in tree.leaf_nodes()]\n N = len(taxon_set)\n names = [taxa.label for taxa in taxon_set]\n pwdist = np.zeros((N, N))\n for i, t1 in enumerate(taxon_set):\n for j, t2 in enumerate(taxon_set):\n \"\"\"Compute half of these and assume symmetry\"\"\"\n if i==j:\n pwdist[i, j] = 0\n elif i<j:\n pwdist[i, j] = pdm(t1, t2)\n pwdist[j, i] = pwdist[i, j]\n else:\n print('Tree type does not match Phylo.BaseTree.Tree or dendropy.Tree')\n return\n return pd.DataFrame(pwdist, index = names, columns = names)" ]

[ "0.54605395", "0.52514964", "0.52182794", "0.51729226", "0.5131557", "0.4997631", "0.49200213", "0.49033338", "0.47637245", "0.47538468", "0.4739272", "0.46873105", "0.46594372", "0.4646138", "0.46402073", "0.4636189", "0.4631968", "0.46285406", "0.46198457", "0.46106067", "0.45727736", "0.45533586", "0.45461905", "0.45452124", "0.45361745", "0.45145717", "0.45119193", "0.45046887", "0.4496976", "0.44905502" ]

[ "def urls(gh, user):\n return [repo.url for repo in getuserrepos(gh, user)]", "def get_organization_links(self):\n yield from self.get_resource_by_item(\"/orgs\")", "def repositories(self, user_name=None):\n user_name = user_name if user_name else self._auth[0]\n data = self._request('GET', 'users', user_name)\n return data.repositories\n #ret_val = []\n #for repository in data.repositories:\n # ret_val.append(repository.name)\n # #print 'repo', repository['name'] # can use as dict or as object\n #return ret_val", "def getuserrepos(gh, user):\n repos = list()\n pages = int(math.ceil(n_public_repos(gh, user) / float(R_PAGE)))\n for i in range(pages):\n # github index their pages from 1, hence the +1\n qs = user + \"/repos?page=\" + str(i + 1)\n repos.extend(gh.users(qs).get())\n return repos", "def user_repos(self, username: str) -> requests.Response:\n\n api_url = 'https://api.github.com/users/{username}/repos'\n url = api_url.format(username=username)\n response = requests.get(url)\n return response\n\n\n\n #user_url = self.user_info(username=username)\n #repos_url = user_url\n #pprint.pprint(repos_url)\n #url = repos_url['repos_url']\n #response = requests.get(url)\n #return response", "def organizations(self):\n return self.get('{}/orgs'.format(ApiVersion.A1.value))", "def _get_repo_list(self, *args, **kwargs): \r\n repo_list = kwargs['repositories'] if kwargs.get('repositories', None) else self.get_list(\r\n api_endpoint=settings.GITHUB_SETTINGS['GITHUB_USER_REPO_API'].format(**kwargs), **kwargs\r\n )\r\n for r in repo_list:\r\n if isinstance(r, dict):\r\n yield r['name']\r\n else:\r\n yield r", "def myorgs(request):\n context = RequestContext(request)\n \n user = request.user\n orgs = user.orgusers.get_query_set()\n \n context['orgs'] = orgs\n return render_to_response('myorgs.html', context)", "def get_organization_links_by_page(self):\n return self.get_resource_by_page(\"/orgs\")", "def list_public_repos():\n return Collaborator.objects.filter(user__username=settings.PUBLIC_ROLE)", "def get_repo_options(account, **kwargs):\n client = AsyncHTTPClient()\n uri = \"https://api.github.com/user/repos?per_page=100\"\n data = []\n while uri is not None:\n req = account.get_request(uri, headers={\"Accept\": \"application/vnd.github.moondragon+json\"})\n response = yield client.fetch(req)\n response_object = json.loads(response.body.decode('utf-8'))\n data += response_object\n links = parse_link_header(response.headers.get('Link', ''))\n uri = links.get('next', None)\n return [{\"title\": repo['full_name'], \"value\": repo['full_name']}\n for repo in data]", "def n_public_repos(gh, user):\n return getuser(gh, user).public_repos", "def get_repositories(github_user):\n\n if not github_user:\n return [1, {\"message\": \"GitHub username missing\"}]\n else:\n\n # build Request object\n request = urllib2.Request(\"https://api.github.com/users/\"\n + str(github_user) + \"/repos\")\n request.get_method = lambda: 'GET'\n try:\n '''try to send the request to the GitHub API and\n create Python dictionary from JSON response'''\n repositories = urllib2.urlopen(request)\n repositories = json.loads(\"\\n\".join(repositories.readlines()))\n\n return [0, repositories]\n\n except urllib2.HTTPError as e:\n\n # return HTTP error and the message from the API\n return [1, {\"message\": str(e) + \": \"\n + json.loads('\\n'.join(e.readlines()))['message']}]", "def _get_org_repos(self):\n url = f\"{BASE_URL}/orgs/{ORG}/repos\"\n return self.fetch_all_pages(url, flatten=True, query_params={\"per_page\": 100})", "def getContributors(auth):\n users = []\n r = requests.get(url='https://gist.github.com/paulmillr/2657075/',\n auth=auth)\n soup = BeautifulSoup(r.text, 'html.parser')\n users = [tr.select_one('a').text for tr in soup('tbody')[0].select('tr')]\n return users", "def get_repos_user(user='xmonader'):\n u = ghclient.get_user(login=user)\n repos = u.get_repos()\n repos_list = []\n for i in range(20):\n page = repos.get_page(i)\n if len(page) == 0:\n break\n repos_list.extend(repos.get_page(i))\n return repos_list", "def get_org_list():\r\n\r\n resp = requests.get(''.join([Kegg.BASE_URL, 'list/organism']))\r\n return resp.text", "async def All_orgs():\n\n links_13 = []\n links_14 = []\n valid_url = \"/?archive/?gsoc/\\d+[0-9]/orgs/[a-zA-Z]+\"\n for year in range(2009, 2016):\n year_url = melange + \"/archive/gsoc/{}\".format(year)\n soup = await get_page(year_url)\n\n for url in soup.find_all('a'):\n if re.match(valid_url, url.get(\"href\")):\n if year <= 2013:\n links_13.append(join(melange, url.get(\"href\")[1:]))\n else:\n links_14.append(join(melange, url.get(\"href\")[1:]))\n return links_13, links_14", "def get_repos(self):\n\n if self.url == 'test':\n repos = ['feature', 'dev', 'int']\n else:\n repos = []\n\n return repos", "def user_repositories(self, host: (str), user: (str)) -> Any:\n return search_api(\"user_repositories\", host, user)", "def users_organizations(user):\n if not user or not user.is_authenticated():\n return None\n else:\n return get_users_organizations(user)", "def do_list(client, args):\n\trepos = client.repos.list(args.user)\n\tprint '%s has the following repositories:' % args.user\n\tprint 'Name - Description'\n\tfor repo in repos:\n\t\tprint '%s - %s' % (repo.name, repo.description)", "def list_all_organizations(ctx):\n pprint(ctx.obj.orgs.get().data)", "def get_organizations_list_with_links(year_link):\n response = get_response(year_link)\n if response.ok:\n soup = BeautifulSoup(response.text, 'html.parser')\n orgs_li = soup.find_all(\n 'li', attrs={'class': 'organization-card__container'})\n orgs_dict = {}\n for orgs_html in orgs_li:\n org_name = orgs_html.select('h4')[0].text.replace('\\n', '')\n relative_link = orgs_html.select('a')[0].get('href')\n full_link = HOME_PAGE + relative_link\n orgs_dict[org_name] = full_link\n return orgs_dict\n else:\n print('Something Went Wrong')\n print(f'Status Code: {response.status_code}')\n sys.exit(1)", "def get(self, *args, **kwargs):\r\n url = '{0}/user/repositories/'.format(self.parent.get_url())\r\n return http.Request('GET', url), parsers.parse_json", "def query_repos(self):\n return [self.config[\"repo\"]]", "def get_repos(self):\n return requests.get(\"https://api.github.com/user/repos\",\n headers=self.headers).json", "def list_repositories(self):\n data = self._get_all_data('/user/repos')\n return [repo['full_name'] for repo in data]", "async def get_organizations(request: Request):\n redis = request.app.state.redis\n organizations_obj = orjson.loads(await redis.get_key(\"influxdb_organizations\"))\n return [org for org in organizations_obj]", "def get_members_repos(org_list):\n print(\"\\nGetting repositories of all members.\")\n jsonMembersRepo_list = []\n columns_list = [\n 'organization',\n 'user',\n 'full_name',\n 'fork',\n 'stargazers_count',\n 'forks_count',\n 'language',\n 'description'\n ]\n for org in org_list:\n print('\\nGetting members of', org)\n jsonMembers = load_json(\"https://api.github.com/orgs/\" + org +\n \"/members?per_page=100\")\n for member in jsonMembers:\n print('Getting repositories of', member['login'])\n jsonMembersRepos = load_json(\"https://api.github.com/users/\" +\n member['login'] +\n \"/repos?per_page=100\")\n for repo in jsonMembersRepos:\n # Add fields to make CSV file more usable\n repo['organization'] = org\n repo['user'] = member['login']\n # Python 2: Using smart_str to deal with encodings\n repo['description'] = smart_str(repo['description'])\n jsonMembersRepo_list.append(repo)\n generate_csv(\"members-list\", jsonMembersRepo_list, columns_list)" ]

[ "0.77288854", "0.6896512", "0.6850855", "0.6795222", "0.6704334", "0.6566785", "0.64914256", "0.64815396", "0.64218557", "0.6373243", "0.6368361", "0.6260303", "0.6226184", "0.62181467", "0.6191352", "0.61800104", "0.61728805", "0.6149173", "0.6129998", "0.61161196", "0.61137915", "0.6098523", "0.6093026", "0.6072319", "0.60618544", "0.6056337", "0.60363215", "0.60300016", "0.5989639", "0.5975776" ]

[ "def get_orgs():\n \n url = \"https://api.github.com/user/orgs\"\n \n org_urls = []\n orgs = utils.get_json(url)\n \n for org in orgs:\n org_urls.append(org[\"url\"])\n \n return org_urls", "def organizations(self):\n return self.get('{}/orgs'.format(ApiVersion.A1.value))", "def get_organization_links(self):\n yield from self.get_resource_by_item(\"/orgs\")", "def _get_org_members(self):\n url = f\"{BASE_URL}/orgs/{ORG}/members\"\n return self.fetch_all_pages(url, flatten=True, query_params={\"per_page\": 100})", "def get_org_list():\r\n\r\n resp = requests.get(''.join([Kegg.BASE_URL, 'list/organism']))\r\n return resp.text", "def get_members_repos(org_list):\n print(\"\\nGetting repositories of all members.\")\n jsonMembersRepo_list = []\n columns_list = [\n 'organization',\n 'user',\n 'full_name',\n 'fork',\n 'stargazers_count',\n 'forks_count',\n 'language',\n 'description'\n ]\n for org in org_list:\n print('\\nGetting members of', org)\n jsonMembers = load_json(\"https://api.github.com/orgs/\" + org +\n \"/members?per_page=100\")\n for member in jsonMembers:\n print('Getting repositories of', member['login'])\n jsonMembersRepos = load_json(\"https://api.github.com/users/\" +\n member['login'] +\n \"/repos?per_page=100\")\n for repo in jsonMembersRepos:\n # Add fields to make CSV file more usable\n repo['organization'] = org\n repo['user'] = member['login']\n # Python 2: Using smart_str to deal with encodings\n repo['description'] = smart_str(repo['description'])\n jsonMembersRepo_list.append(repo)\n generate_csv(\"members-list\", jsonMembersRepo_list, columns_list)", "def get_organization_links_by_page(self):\n return self.get_resource_by_page(\"/orgs\")", "def list_all_organizations(ctx):\n pprint(ctx.obj.orgs.get().data)", "async def All_orgs():\n\n links_13 = []\n links_14 = []\n valid_url = \"/?archive/?gsoc/\\d+[0-9]/orgs/[a-zA-Z]+\"\n for year in range(2009, 2016):\n year_url = melange + \"/archive/gsoc/{}\".format(year)\n soup = await get_page(year_url)\n\n for url in soup.find_all('a'):\n if re.match(valid_url, url.get(\"href\")):\n if year <= 2013:\n links_13.append(join(melange, url.get(\"href\")[1:]))\n else:\n links_14.append(join(melange, url.get(\"href\")[1:]))\n return links_13, links_14", "def test_getorgs(self):\n pass", "def organizations(self):\n self.elements('organizations')", "def myorgs(request):\n context = RequestContext(request)\n \n user = request.user\n orgs = user.orgusers.get_query_set()\n \n context['orgs'] = orgs\n return render_to_response('myorgs.html', context)", "def list_orgs(self):\n orgs = list(self.orgs.keys())\n orgs.sort()\n return orgs", "def get_members_info(org_list):\n print(\"\\nGetting user information of all members.\")\n jsonMembersInfo_list = []\n columns_list = [\n 'organization',\n 'login',\n 'name',\n 'url',\n 'type',\n 'company',\n 'blog',\n 'location',\n 'email'\n ]\n for org in org_list:\n print('\\nGetting members of', org)\n jsonMembers = load_json(\"https://api.github.com/orgs/\" + org +\n \"/members?per_page=100\")\n for member in jsonMembers:\n print(\"Getting user information for\", member[\"login\"])\n jsonMember = load_json(\"https://api.github.com/users/\" +\n member[\"login\"] + \"?per_page=100\",\n memberscrape=True)\n # Add field to make CSV file more usable\n jsonMember[\"organization\"] = org\n # Python 2: Using smart_str to deal with encodings\n jsonMember[\"location\"] = smart_str(jsonMember['location'])\n jsonMember[\"name\"] = smart_str(jsonMember['name'])\n jsonMember[\"company\"] = smart_str(jsonMember['company'])\n jsonMember[\"email\"] = smart_str(jsonMember['email'])\n jsonMembersInfo_list.append(jsonMember)\n generate_csv(\"members-info\", jsonMembersInfo_list, columns_list)", "def organizations(self) -> pulumi.Output[Optional[Sequence[str]]]:\n return pulumi.get(self, \"organizations\")", "def list_members_of_organisation(\n self, organisation_id: OrganisationId\n ) -> List[Publisher]:\n ...", "def urls(gh, user):\n return [repo.url for repo in getuserrepos(gh, user)]", "async def get_organizations(request: Request):\n redis = request.app.state.redis\n organizations_obj = orjson.loads(await redis.get_key(\"influxdb_organizations\"))\n return [org for org in organizations_obj]", "def _get_org_repos(self):\n url = f\"{BASE_URL}/orgs/{ORG}/repos\"\n return self.fetch_all_pages(url, flatten=True, query_params={\"per_page\": 100})", "def organizations(self):\r\n return organizations.Organizations(self)", "def users(self,org_id=None):\n if org_id is None:\n org_id = self.org_id\n return self.get('{}/orgs/{}/users'.format(ApiVersion.A1.value,org_id))", "async def org_info_above_14(orgs_urls14):\n org_info_14 = []\n project_urls_from14 = []\n for url in orgs_urls14:\n try:\n soup = await get_page(url)\n org_name = basename(url)\n org_info = soup.find_all('p')\n web_page = org_info[1].text.splitlines()[-1].strip()\n mailing_list = org_info[2].text.split(\":\")[-1].strip()\n description = soup.find('div', {'class': 'main mdl-cell mdl-cell--8-col\\\n mdl-card mdl-shadow--4dp'})\n detail = description.find_all('p')[2].nextSibling\n org_info_14.append({'name': org_name, 'page': web_page,\n 'about': detail, 'mail': mailing_list,\n 'link': url})\n project_urls_from14.extend(grab_project_links(soup))\n except IndexError:\n print(url)\n\n return org_info_14, get_project_info(project_urls_from14)", "def get_organizations_list_with_links(year_link):\n response = get_response(year_link)\n if response.ok:\n soup = BeautifulSoup(response.text, 'html.parser')\n orgs_li = soup.find_all(\n 'li', attrs={'class': 'organization-card__container'})\n orgs_dict = {}\n for orgs_html in orgs_li:\n org_name = orgs_html.select('h4')[0].text.replace('\\n', '')\n relative_link = orgs_html.select('a')[0].get('href')\n full_link = HOME_PAGE + relative_link\n orgs_dict[org_name] = full_link\n return orgs_dict\n else:\n print('Something Went Wrong')\n print(f'Status Code: {response.status_code}')\n sys.exit(1)", "def get_repos(org_list):\n jsonRepos = []\n for org in org_list:\n print(\"\\nScraping repositories of\", org)\n jsonRepo = load_json(\"https://api.github.com/orgs/\" + org +\n \"/repos?per_page=100\")\n for repo in jsonRepo:\n # Add field for org to make CSV file more useful\n repo['organization'] = org\n # Python 2: Using smart_str to deal with encodings\n repo['description'] = smart_str(repo['description'])\n jsonRepos.append(repo)\n # Create a list with the items I'm interested in, then call generate_csv\n columns_list = [\n 'organization',\n 'name',\n 'full_name',\n 'stargazers_count',\n 'language',\n 'created_at',\n 'updated_at',\n 'homepage',\n 'fork',\n 'description'\n ]\n generate_csv(\"repo-list\", jsonRepos, columns_list)", "def _list_orgs(self, context):\r\n try:\r\n rtn = {'context': context,\r\n 'orgs': sorted(list(self._bbreader.cache[context].keys()))}\r\n except KeyError:\r\n raise RequestError('Context {} not found'.format(context))\r\n return rtn", "def get_contributors(org_list):\n print(\"\\nCreating list of contributors.\")\n jsonContributor_list = []\n graph = nx.DiGraph()\n columns_list = [\n 'organization',\n 'repository',\n 'login',\n 'contributions',\n 'html_url',\n 'url'\n ]\n for org in org_list:\n print('\\nScraping contributors of', org)\n jsonRepo = load_json(\"https://api.github.com/orgs/\" + org +\n \"/repos?per_page=100\")\n for repo in jsonRepo:\n # try...except to deal with empty repositories\n try:\n print(\"Getting contributors of\", repo[\"name\"])\n # First, add repo as a node to the graph\n graph.add_node(repo['name'], organization=org)\n # Then get a list of contributors\n jsonContributors = load_json(\"https://api.github.com/\"\n \"repos/\" + org + \"/\" +\n repo[\"name\"] +\n \"/contributors?per_page=100\")\n for contributor in jsonContributors:\n # Add each contributor as an edge to the graph\n graph.add_edge(contributor['login'], repo['name'],\n organization=org)\n # Prepare CSV and add fields to make it more usable\n contributor[\"organization\"] = org\n contributor[\"repository\"] = repo[\"name\"]\n jsonContributor_list.append(contributor)\n except:\n # if repository is empty inform user and pass\n print(\"Repository '\" + repo[\"name\"] + \"' returned an error,\"\n \"possibly because it's empty.\")\n pass\n generate_csv(\"contributor-list\", jsonContributor_list, columns_list)\n nx.write_gexf(graph, \"data/contributor-network_\" +\n time.strftime(\"%Y-%m-%d_%H:%M:%S\") + '.gexf')\n print(\"\\nSaved graph file: data/contributor-network_\" +\n time.strftime(\"%Y-%m-%d_%H:%M:%S\") + \".gexf\")", "def organizations(self):\n return sorted(set([team.org for team in self.teams]), key=lambda o: o.title)", "def get_members(organization):\n raise Exception(\"Someone needs to fix this method to no longer be dependent on model relationship if they're going to use it!\")", "def listOrganizations(self, name='', type=''):\n return self.get_json('/organization', {'name': name, 'type': type})", "def organizations_owned(self):\n return sorted(set([team.org for team in self.teams if team.org.owners == team]),\n key=lambda o: o.title)" ]

[ "0.73141086", "0.6856046", "0.6766409", "0.66456306", "0.6501711", "0.64493275", "0.6426517", "0.62708795", "0.6261771", "0.6171711", "0.6152523", "0.605219", "0.6030204", "0.6027043", "0.60185575", "0.60124224", "0.5963386", "0.58976614", "0.5893394", "0.5823597", "0.5802018", "0.58008057", "0.5795049", "0.5792948", "0.5776702", "0.5745321", "0.5735663", "0.57141733", "0.56909424", "0.5648807" ]

[ "def test_should_pass_when_list_of_url_are_not_empty(self):\n self.ebooksPage = EbooksPage(self.driver)\n list_of_links = self.ebooksPage.get_all_links()\n\n assert (isinstance(list_of_links, list) and (len(list_of_links) > 0 ))", "def get_parliament_members_urls(self) -> list:\n directory = self.read_html(self.url)\n return [\n a.attrs[\"href\"]\n for a in directory.select(\".single-mp a\")\n if a.attrs[\"href\"].startswith(\"https\")\n ]", "def every_non_existing_owner_should_not_have_profile_link(context):\n items = context.response.json()['items']\n for item in items:\n owner = item['owner']\n if not owner['user_type'] == 'does_not_exist':\n continue\n assert 'link' not in owner\n logging.debug(\n 'Not existing Owner %s does not have a valid profile link',\n owner['display_name'])", "def extract_category_members(div):\n category_members = div.find_all('a')\n # remove any members with class\n category_members = list(filter(lambda x: x.get('class') is None, category_members))\n category_member_urls = list(map(lambda x: x['href'], category_members))\n for category_member in category_members:\n if(category_member.get('title') is None):\n print(f'bad category member {category_member}')\n category_member_names = list(map(lambda x: x['title'], category_members))\n # remove parens\n category_member_names = list(map(lambda x: PAREN_MATCHER.sub('', x), category_member_names))\n # combine\n category_member_info = list(zip(category_member_names, category_member_urls))\n # remove long names like 'Lo Nuestro Award for Pop New Artist of the Year'\n category_member_info = list(filter(lambda x: len(x[1]) <= MAX_TITLE_LEN, category_member_info))\n return category_member_info", "def extract_attributes_of_planes(self, cls, attr_name, filter_nones=False):\r\n if filter_nones:\r\n\r\n return [\r\n plane.extract_attribute(cls=cls, attr_name=attr_name)\r\n for plane in self.planes\r\n if plane.extract_attribute(cls=cls, attr_name=attr_name) is not None\r\n ]\r\n\r\n else:\r\n\r\n return [\r\n plane.extract_attribute(cls=cls, attr_name=attr_name)\r\n for plane in self.planes\r\n ]", "def _urls(*, repository, commit, mirrors):\n result_with_nulls = [\n _format_url(\n pattern = x,\n repository = repository,\n commit = commit,\n )\n for x in mirrors.get(\"github\")\n ]\n return [\n url\n for url in result_with_nulls\n if url != None\n ]", "def every_non_existing_owner_should_not_have_profile_image_link(context):\n items = context.response.json()['items']\n for item in items:\n owner = item['owner']\n if not owner['user_type'] == 'does_not_exist':\n continue\n assert 'profile_image' not in owner\n logging.debug(\n 'Not existing Owner %s does not have a valid profile image link',\n owner['display_name'])", "def listingURLs(soup):\n\n #Get URLs\n itemListing = soup.find_all(class_=\"user-ad-row link link--base-color-inherit link--hover-color-none link--no-underline\")\n itemListing += soup.find_all(class_=\"user-ad-row user-ad-row--featured-or-premium link link--base-color-inherit link--hover-color-none link--no-underline\")\n itemListing += soup.find_all(class_=\"user-ad-row user-ad-row--premium user-ad-row--featured-or-premium link link--base-color-inherit link--hover-color-none link--no-underline\")\n #Create list\n urlList = [i['href'] for i in itemListing]\n return urlList", "def extract_attributes_of_galaxies(self, cls, attr_name, filter_nones=False):\r\n if filter_nones:\r\n\r\n return [\r\n galaxy.extract_attribute(cls=cls, attr_name=attr_name)\r\n for galaxy in self.galaxies\r\n if galaxy.extract_attribute(cls=cls, attr_name=attr_name) is not None\r\n ]\r\n\r\n else:\r\n\r\n return [\r\n galaxy.extract_attribute(cls=cls, attr_name=attr_name)\r\n for galaxy in self.galaxies\r\n ]", "def get_urls_safely(self, **kwargs):\n urls = self.get_urls(**kwargs)\n if all(len(urls[cik]) == 0 for cik in urls.keys()):\n raise NoFilingsError(\"No filings available.\")\n return urls", "def _filter_url_list(self, regex_pattern: str) -> None:\n matcher = re.compile(regex_pattern)\n filtered_list = []\n if self.url_list:\n for url in self.url_list:\n if matcher.search(url.url):\n filtered_list.append(url)\n self.url_list = filtered_list", "def getUrls(url):\n f = requests.get(url)\n p = MyParser()\n p.feed(f.text)\n list_of_urls = p.output_list\n #deal with possible strange None values\n list_of_urls = [url for url in list_of_urls if url is not None]\n for url in list_of_urls:\n if 'http' not in url: list_of_urls.remove(url)\n return list_of_urls", "def get_member(self, filter_, attrlist=None):\n result = self.search('o=com,dc=mozilla', filter_, attrlist)\n if result == False:\n raise self.SearchError\n elif result == []:\n return []\n return result[1]", "def URLs(self, default=[{}]):\n tmp = self.data.get('metadata', {}).get('urls', default)\n return [HEP.URLObject(i) for i in tmp]", "def parse_urls(record):\n url_list = []\n try:\n page_url = record['WARC-Header-Metadata']['WARC-Target-URI']\n x = urlparse.urlparse(page_url)\n url_list += [(x.netloc, x.path)]\n except:\n pass\n try: \n links = record['Payload-Metadata']['HTTP-Response-Metadata']['HTML-Metadata']['Links']\n for url in links:\n x = urlparse.urlparse(url['url'])\n url_list += [(x.netloc, x.path)]\n except:\n pass\n \n return url_list", "def urls(self):\n header = \"URL,Linked From,Discovery Date\"\n gcsv = self.read()\n if gcsv[0] != header:\n raise Exception(\"Unexpected CSV format\")\n urls = set()\n for line in gcsv[1:]:\n # Get everything before the first commar (just the URL)\n line = line[:line.find(\",\")]\n urls.add(line)\n return urls", "def check_href(url, soup):\n # pdb.set_trace()\n ret_vals = []\n href = soup.find_all(\"a\")\n for link in href:\n if url in link.get(\"href\"):\n ret_vals.append(link.get(\"href\").split(url)[1])\n return list(set(ret_vals))", "def test_metric_source_urls_without_report(self, mock_url_read):\n mock_url_read.return_value = LAST_SCAN\n self.assertEqual([], self.__report.metric_source_urls())", "def attributes(self):\n\n attributes = []\n\n for member in self.members:\n if member.attribute:\n attributes.append(member)\n\n return attributes", "def GetValidAttributeValues(self, attr):\n return None", "def urls(self) -> list[str]:\r\n ...", "def by_member(self, member):\n return self.get_queryset().filter(member=member)", "def URLs(self, default=[{}]):\n tmp = self.data.get('urls', default)\n return [HEP.URLObject(i) for i in tmp]", "def get_urls():\r\n return []", "def list_members(orgs):\n members =[]\n \n \n if isinstance(orgs, list):\n #if list of orgs for each org get members list\n for url in orgs:\n #append /member to url - member_url is not valid canidate without a member list\n url = url + \"/members\"\n print(\"Checking \" + url)\n members_data = utils.get_json(url)\n\n for member in members_data:\n members.append(member[\"url\"])\n return members\n \n \n else:\n #build url from input org name and return member list\n url = \"https://api.github.com/orgs/\" + orgs + \"/members\"\n members_data = utils.get_json(url)\n \n #check for invalid GitHub credentials or invalid github org name\n try:\n for member in members_data:\n members.append(member[\"url\"])\n return members\n except TypeError:\n if(members_data[\"message\"] == \"Not Found\"):\n print(\"That organization doesn't exist try again\\n\")\n raise SystemExit\n elif(members_data[\"message\"] == \"Bad credentials\"):\n print(\"Please verify GitHub credentials are correct in config.py\")\n raise SystemExit\n else:\n print (members_data)\n raise SystemExit", "def test_get_non_existent_campaigns_returns_empty_list(self):\n response = self.client.get(self.endpoint_url)\n response_body = response.get_json()\n self.assertEqual(response.status_code, 200)\n self.assertEqual(response_body, {\"campaigns\": []})", "def test_get_collection_no_asset_urls(self, mock_get):\n # Arrange\n mock_resp = MockResponse({}, 200)\n mock_get.return_value = mock_resp\n\n # Act\n response = get_collection_item_asset_urls(self.item_id)\n\n # Assert\n self.assertListEqual(response, [])", "def get_attribut(cls, attribut):\n\n if attribut:\n lst_attribut = [\"%s\" % value for value in attribut.split(',')]\n return lst_attribut\n return False", "def get_urls(self):\n urls = []\n params = ['<{}>'.format(x) for x in self.args]\n args_length = len(self.args) - len(self.defaults)\n for i in range(len(self.defaults) + 1):\n index = -i if i > args_length else None\n urls.append(self.get_url(params[:index]))\n return urls", "def check_unlinkage(self, attribute=None):\n unlinked = self._related_robot_instance is None\n assert unlinked, type(self)\n _class_attributes = self._class_linkables\n if attribute is not None:\n _class_attributes = [var for var in self._class_linkables if var == attribute]\n else:\n for var in self._class_variables:\n if isinstance(getattr(self, var), Linkable):\n unlinked &= getattr(self, var).check_unlinkage()\n elif isinstance(getattr(self, var), list):\n for v in getattr(self, var):\n if isinstance(v, Linkable):\n unlinked &= v.check_unlinkage()\n for attribute in _class_attributes:\n unlinked &= (\n getattr(self, \"_\" + attribute) is None or\n type(getattr(self, \"_\" + attribute)) == str or\n (isinstance(getattr(self, \"_\" + attribute), list) and\n all([type(x) == str or x is None for x in getattr(self, \"_\" + attribute)]))\n )\n assert unlinked, f\"Attribute {attribute} of {type(self)} {str(self) if self.stringable() else ''} is still linked. type: {type(getattr(self, '_' + attribute))}\"\n return unlinked" ]

[ "0.5205275", "0.51647687", "0.4913061", "0.49125162", "0.49111745", "0.4911004", "0.48863113", "0.4880418", "0.48025796", "0.47962448", "0.47788674", "0.47781992", "0.47770363", "0.47515574", "0.47040161", "0.46784464", "0.45712367", "0.4568166", "0.45629707", "0.45522118", "0.45343316", "0.45338476", "0.44974712", "0.449056", "0.44749463", "0.4468246", "0.44643593", "0.44633552", "0.44391853", "0.4427086" ]

[ "def get_land_conso_per_year(self, level, group_name=None):\n fields = Cerema.get_art_field(self.analyse_start_date, self.analyse_end_date)\n qs = self.get_cerema_cities(group_name=group_name)\n qs = qs.values(level)\n qs = qs.annotate(**{f\"20{field[3:5]}\": Sum(field) / 10000 for field in fields})\n return {row[level]: {year: row[year] for year in self.years} for row in qs}", "def get_origins(self, account_id, **kwargs):\r\n\r\n return self.account.getOriginPullMappingInformation(id=account_id,\r\n **kwargs)", "def xbrl_years(self):\n return [year for year in self.years if year >= 2021]", "def get_land_artif_per_year(self, analysis_level):\n qs = CommuneDiff.objects.filter(city__in=self.cities.all())\n if analysis_level == \"DEPART\":\n qs = qs.annotate(name=F(\"city__departement__name\"))\n elif analysis_level == \"EPCI\":\n qs = qs.annotate(name=F(\"city__epci__name\"))\n elif analysis_level == \"REGION\":\n qs = qs.annotate(name=F(\"city__departement__region__name\"))\n elif analysis_level == \"SCOT\":\n qs = qs.annotate(name=F(\"city__scot__name\"))\n else:\n qs = qs.annotate(name=F(\"city__name\"))\n qs = qs.filter(year_old__gte=self.analyse_start_date, year_new__lte=self.analyse_end_date)\n qs = qs.annotate(\n period=Concat(\n \"year_old\",\n Value(\" - \"),\n \"year_new\",\n output_field=models.CharField(),\n )\n )\n qs = qs.values(\"name\", \"period\")\n qs = qs.annotate(net_artif=Sum(\"net_artif\"))\n\n results = collections.defaultdict(dict)\n for row in qs:\n results[row[\"name\"]][row[\"period\"]] = row[\"net_artif\"]\n return results", "def _fetch_laus_data(year=None):\n global _SIMPLECOUNT_COLUMNS\n\n try:\n if year is None:\n year = _get_max_year([27]) + 1\n url = f'http://www.ides.illinois.gov/LMI/Local%20Area%20Unemployment%20Statistics%20LAUS/historical/{year}-moaa.xls'\n\n raw = pd.read_excel(url, skiprows=6)\n raw.columns = ['fips', 'area', 'year', 'month', 'force', 'employed', 'unemployed', 'rate']\n \n filtered = raw[(~raw.fips.isna()) & (raw.month == 13)].drop(columns=['area', 'month', 'rate'])\n filtered.columns = ['fips', 'year', '1030', '1551', '1550']\n\n pivoted = pd.melt(\n filtered,\n id_vars = ['fips', 'year'],\n value_vars=['1030', '1550', '1551'],\n var_name = 'fk_simplecount_indicator'\n )\n \n pivoted['fk_simplecount_county'] = (pivoted['fips'] + 1) / 2\n\n return pivoted[_SIMPLECOUNT_COLUMNS]\n except HTTPError as e:\n if e.code == 404:\n raise ValueError(\"WARNING: Employment data is up to date.\")\n except:\n raise", "def ret_lYM(iYM, eYM):\n iYear, iMon = iYM\n eYear, eMon = eYM\n lYM = []\n for Year in range(iYear, eYear+1):\n if iYear == eYear:\n lMon = list(range(iMon,eMon+1))\n elif Year == iYear:\n lMon = list(range(iMon,12+1))\n elif Year == eYear:\n lMon = list(range(1,eMon+1))\n else:\n lMon = list(range(1,12+1)) \n\n for Mon in lMon:\n lYM.append([Year,Mon])\n return lYM", "def get_incidents(year):\n print 'Downloading year: %s' % year\n \n # Build URL from year.\n # If the year is 2007-2011, download the XML straight from ... my S3 account.\n if year in range(2007, 2011):\n url = 'http://wapo-projects.s3.amazonaws.com/techathon/scraperwiki/xml/crime_incidents_%s_plain.xml' % year\n \n # If the year is 2012, get it from the DC government. This is NOT the whole year.\n if year == 2012:\n url = 'http://data.octo.dc.gov/feeds/crime_incidents/crime_incidents_current.xml' \n \n # Request the data using the Requests library.\n request = requests.get(url)\n unzipped_request = request.content\n \n # Parse the XML using lxml's BeautifulSoup parser.\n crime_xml_parsed = fromstring(unzipped_request)\n\n # Return the parsed Element() objects by grabbing the xpath for <entry> tags.\n return crime_xml_parsed.xpath('//entry')", "def get_incidents(year):\n print 'Downloading year: %s' % year\n \n # Build URL from year.\n # If the year is 2007-2011, download the XML straight from ... my S3 account.\n if year in range(2007, 2011):\n url = 'http://wapo-projects.s3.amazonaws.com/techathon/scraperwiki/xml/crime_incidents_%s_plain.xml' % year\n \n # If the year is 2012, get it from the DC government. This is NOT the whole year.\n if year == 2012:\n url = 'http://data.octo.dc.gov/feeds/crime_incidents/crime_incidents_current.xml' \n \n # Request the data using the Requests library.\n request = requests.get(url)\n unzipped_request = request.content\n \n # Parse the XML using lxml's BeautifulSoup parser.\n crime_xml_parsed = fromstring(unzipped_request)\n\n # Return the parsed Element() objects by grabbing the xpath for <entry> tags.\n return crime_xml_parsed.xpath('//entry')", "def get_start_end_years(df: pd.DataFrame) -> Tuple[int, int]:\n return df.iloc[0].year, df.iloc[-1].year", "def get_age_fields():\n under_18_fields = CensusFields.get_under_18_fields()\n\n age_18_to_29_fields = [ \n 'B01001_007E', # Male:!!18 and 19 years\n 'B01001_008E', # Male:!!20 years\n 'B01001_009E', # Male:!!21 years\n 'B01001_010E', # Male:!!22 to 24 years\n 'B01001_011E', # Male:!!25 to 29 years\n 'B01001_031E', # Female:!!18 and 19 years\n 'B01001_032E', # Female:!!20 years\n 'B01001_033E', # Female:!!21 years\n 'B01001_034E', # Female:!!22 to 24 years\n 'B01001_035E', # Female:!!25 to 29 years\n ]\n age_30_to_39_fields = [\n 'B01001_012E', # Male:!!30 to 34 years\n 'B01001_013E', # Male:!!35 to 39 years\n 'B01001_036E', # Female:!!30 to 34 years\n 'B01001_037E', # Female:!!35 to 39 years\n ]\n age_40_to_49_fields = [\n 'B01001_014E', # Male:!!40 to 44 years\n 'B01001_038E', # Female:!!40 to 44 years\n 'B01001_015E', # Male:!!45 to 49 years\n 'B01001_039E', # Female:!!45 to 49 years\n\n ]\n age_50_to_59_fields = [\n 'B01001_016E', # Male:!!50 to 54 years\n 'B01001_017E', # Male:!!55 to 59 years\n 'B01001_040E', # Female:!!50 to 54 years\n 'B01001_041E', # Female:!!55 to 59 years\n\n ]\n age_60_to_69_fields = [\n 'B01001_018E', # Male:!!60 and 61 years\n 'B01001_019E', # Male:!!62 to 64 years\n 'B01001_020E', # Male:!!65 and 66 years\n 'B01001_021E', # Male:!!67 to 69 years\n 'B01001_042E', # Female:!!60 and 61 years\n 'B01001_043E', # Female:!!62 to 64 years\n 'B01001_044E', # Female:!!65 and 66 years\n 'B01001_045E', # Female:!!67 to 69 years\n ]\n age_70_to_79_fields = [\n 'B01001_022E', # Male:!!70 to 74 years\n 'B01001_023E', # Male:!!75 to 79 years\n 'B01001_046E', # Female:!!70 to 74 years\n 'B01001_047E', # Female:!!75 to 79 years\n ]\n age_81_plus_fields = [\n 'B01001_024E', # Male:!!80 to 84 years\n 'B01001_025E', # Male:!!85 years and over\n 'B01001_048E', # Female:!!80 to 84 years\n 'B01001_049E', # Female:!!85 years and over\n ]\n \n age_fields = OrderedDict()\n age_fields[ 'age_18_to_29' ] = { 'label': '18-29', 'fields': age_18_to_29_fields }\n age_fields[ 'age_30_to_39' ] = { 'label': '30s', 'fields': age_30_to_39_fields }\n age_fields[ 'age_40_to_49' ] = { 'label': '40s', 'fields': age_40_to_49_fields }\n age_fields[ 'age_50_to_59' ] = { 'label': '50s', 'fields': age_50_to_59_fields }\n age_fields[ 'age_60_to_69' ] = { 'label': '60s', 'fields': age_60_to_69_fields } \n age_fields[ 'age_70_to_79' ] = { 'label': '70s', 'fields': age_70_to_79_fields }\n age_fields[ 'age_81_plus' ] = { 'label': '80+', 'fields': age_81_plus_fields }\n\n return age_fields", "def lons(self):\n lons = []\n quads = self.getQuadrilaterals()\n groups = self._getGroupIndex()\n u_groups = np.unique(groups)\n ng = len(u_groups)\n for i in range(ng):\n q_ind = np.where(groups == u_groups[i])[0]\n nq = len(q_ind)\n top_lons = []\n bot_lons = []\n for j in range(nq):\n if j == 0:\n top0 = [quads[q_ind[j]][0].longitude]\n bot0 = [quads[q_ind[j]][3].longitude]\n top_lons = top_lons + top0\n bot_lons = bot_lons + bot0\n top_lons = top_lons + [quads[q_ind[j]][1].longitude]\n bot_lons = bot_lons + [quads[q_ind[j]][2].longitude]\n lons = lons + top_lons + bot_lons[::-1] + top0 + [np.nan]\n return np.array(lons)", "def _enumerate_years(self, preprocessed_data, disjoint):\n pass", "def get_look_a_like_conso_per_year(self):\n return {\n land.name: land.get_conso_per_year(\n self.analyse_start_date,\n self.analyse_end_date,\n )\n for land in self.get_look_a_like()\n }", "def get_city_conso_per_year(self, group_name=None):\n return self.get_land_conso_per_year(\"city_name\", group_name=group_name)", "def get_years():\n if request.method == 'OPTIONS':\n logging.info(\"Handle options\")\n return create_response({}, 200, '*', 'content-type, token')\n\n logging.info(\"Getting recruitment years\")\n\n role, response = handle_request_token(request)\n\n if role is None:\n logging.warning(\"Role is None!\")\n return response\n\n years = set()\n for rec in Recruitment.query.all():\n if rec.end_date.year not in years:\n years.add(rec.end_date.year)\n\n years = list(years)\n years.sort(reverse=True)\n\n return create_response(years, 200, '*')", "def lcode(self):\n###############################################################################\n lcode = []\n for M in list(self.estimates.values()):\n if (M.code not in lcode):lcode.append(M.code)\n return(lcode)", "def get_rates():\n orig_code = request.args.get(\"orig_code\")\n dest_code = request.args.get(\"dest_code\")\n date_from = parse_iso_date(request.args.get(\"date_from\"))\n date_to = parse_iso_date(request.args.get(\"date_to\"))\n\n if not date_from or not date_to:\n raise BadRequest(\"Invalid date arguments\")\n if orig_code and dest_code:\n return get_rates_using_codes(\n date_from, date_to, orig_code, dest_code\n )\n raise BadRequest(\"Invalid location arguments\")", "def get_clams_age(theta, eq_lat, day_of_year, as_timedelta=False, clams_dat=dict()):\n if len(clams_dat) == 0:\n # Take advantage of mutable default arguments to cache the CLAMS data. The first time this function is called,\n # the dict will be empty, so the data will be loaded. The second time, since the dict will have been modified,\n # with all the data, we don't need to load it. This should hopefully speed up this part of the code.\n with ncdf.Dataset(_clams_file, 'r') as clams:\n clams_dat['eqlat'] = clams.variables['lat'][:]\n clams_dat['theta'] = clams.variables['extended_theta'][:]\n clams_dat['doy'] = clams.variables['doy'][:]\n\n # The original CLAMS file provided by Arlyn only went up to 2000 K. At first we tried just using the top\n # for greater potential temperatures, but that led to too-great N2O values at those levels. We now\n # extrapolate using the three end points to calculate a slope of age vs. theta. This calculation takes some\n # time, so we've added the extended age to the CLAMS file using backend_analysis.clams.modify_clams_file().\n clams_dat['age'] = clams.variables['extended_age'][:]\n\n clams_dat['eqlat_grid'], clams_dat['theta_grid'] = np.meshgrid(clams_dat['eqlat'], clams_dat['theta'])\n if clams_dat['eqlat_grid'].shape != clams_dat['age'].shape[1:] or clams_dat['theta_grid'].shape != clams_dat['age'].shape[1:]:\n raise RuntimeError('Failed to create equivalent lat/theta grids the same shape as CLAMS age')\n\n idoy = np.argwhere(clams_dat['doy'] == day_of_year).item()\n\n el_grid, th_grid = np.meshgrid(clams_dat['eqlat'], clams_dat['theta'])\n clams_points = np.array([[el, th] for el, th in zip(el_grid.flat, th_grid.flat)])\n\n # interp2d does not behave well here; it interpolates to points outside the range of eqlat/theta and gives a much\n # noisier result.\n age_interp = LinearNDInterpolator(clams_points, clams_dat['age'][idoy, :, :].flatten())\n prof_ages = np.array([age_interp(el, th).item() for el, th in zip(eq_lat, theta)])\n\n if as_timedelta:\n # The CLAMS ages are in years, but relativedeltas don't accept fractional years. Instead, separate the whole\n # years and the fractional years.\n prof_ages = np.array(mod_utils.frac_years_to_reldelta(prof_ages))\n\n return prof_ages", "def lae_nccd(year):\n html = load_campdoc_html(year)\n table = extract_main_table_from_html(html)\n data = process_main_table(table)\n return(data)", "def build_messy_lookup_lad(source,dest):\n la = QuickGrid().open(source)\n\n lookup = QuickGrid()\n lookup.header = [\"gss-code\",\"local-authority-code\"]\n\n possible = [\"gss-code\",\"archaic-gss-code\"]\n possible = [p for p in possible if p in la.header]\n for r in la:\n for p in possible:\n if r[p]:\n values = r[p].split(\",\")\n for v in values:\n lookup.add([v,r[\"local-authority-code\"]])\n \n lookup.save(dest,force_unicode=True)", "def validated_origins(self, pfx):\n nodes = self.radix.search_covering(pfx)\n origins = set()\n\n for node in nodes:\n for roa in node.data[\"roas\"]:\n asn = int(roa[\"asn\"].lstrip(\"AS\"))\n maxlength = roa[\"maxLength\"]\n if maxlength >= int(pfx.split(\"/\")[1]):\n origins.add(asn)\n return origins", "def get_age_bounds(input_dir):\r\n ages = pd.read_csv(os.path.join(input_dir, \"age_bounds.csv\"))\r\n return ages", "def get(self):\n trainer_id = request.args.get(\"trainerId\")\n if trainer_id is not None:\n try:\n return TrainerService.get_years_for_trainer(int(trainer_id))\n except ValueError:\n return INVALID_ID_ERROR, 400 # Bad Request\n else:\n return []", "def linkage_or_origin_all_parents(elf, addr, linkage=False):\n result = subprocess.run(\n (DWARFDUMP, \"--lookup=0x\" + addr, \"-p\", elf), capture_output=True, text=True\n )\n dwarfdump = result.stdout\n regex = abstract_origin_re\n if linkage:\n regex = dw_at_linkage_name_re\n matches = re.findall(regex, dwarfdump)\n\n def getFunction(line):\n return line.strip().split('\"')[1]\n\n origins = list(map(getFunction, matches))\n return origins", "def hindu_lunar_holiday(l_month, l_day, gregorian_year):\n l_year = HinduLunarDate.from_fixed(GregorianDate.new_year(gregorian_year)).year\n date1 = hindu_date_occur(l_month, l_day, l_year)\n date2 = hindu_date_occur(l_month, l_day, l_year + 1)\n return list_range([date1, date2], GregorianDate.year_range(gregorian_year))", "def get_leagues_and_countries(source=utils.get_native_source):\n if not isinstance(source, games.models.Source):\n # If I used source=native_source() or if native_source was a global variable then\n # during db initialization (running command initialize) you would get an error since\n # it gets its value when the database is empty.\n source = source()\n logger.info(\"getting leagues and countries from source %s...\", source)\n if not source:\n return [], []\n data, meta, status_code = sportmonks.countries.all(include='leagues.seasons')\n if not data:\n # if the status code is not 200 data and meta are None\n return [], []\n # with open('sportmonks/response_texts/aws_01.txt', 'w') as outfile:\n # json.dump(meta, outfile, indent=4)\n # json.dump(data, outfile, indent=4)\n\n pre_countries, pre_competitions = [], []\n\n try:\n # Notice that only the first supported sport will be processed (currently this is is acceptable since we only\n # support football and so the first supported sport will always be football)\n sport_sids = parse_sport(meta)\n sports = []\n for sport_sid in sport_sids:\n sport = games.models.Sport.by_sid(sid=sport_sid, source=source)\n if not sport:\n logger.info(\"Sport contained in the response with sid {} is not supported\".format(sport_sid))\n continue\n sports.append(sport)\n if not sports:\n logger.error(\"No supported sport in the response\")\n return [], []\n football_gname = games.naming.sport_names.get('football', None)\n football = games.models.Sport.objects.get(name=football_gname)\n if football not in sports:\n logger.info(\"Football is not in response\")\n return [], []\n # logger.debug(\"Trying to get sport from source: %s and sid: %s\", source, sport_sid)\n sport_gname = football_gname\n for item in data:\n try:\n country_sid = item.get('id')\n # logger.debug('country_sid: %s', country_sid)\n country_sname = item.get('name')\n # logger.debug('country_sname: %s', country_sname)\n extra = item.get('extra')\n # logger.debug('extra: %s', extra)\n leagues = item.get('leagues').get('data')\n # logger.debug('leagues: %s', leagues)\n try:\n fifa_code = extra.get('fifa') # some countries might lack extra information\n except AttributeError:\n fifa_code = None\n except Exception as e:\n logger.data_error('%s', e)\n continue\n pre_country = pre_models.PreCountry(source=source, sname=country_sname, sid=country_sid, fifa_code=fifa_code)\n pre_countries.append(pre_country)\n for league in leagues:\n try:\n # sportmonks uses sgname for leagues. I use this sgname as an sname (comp_season_specific name)\n competition_sname = league.get('name')\n # logger.debug('competition_sname: %s', competition_sname)\n sid = league.get('id')\n # logger.debug('sid: %s', sid)\n seasons = league.get('seasons').get('data')\n # logger.debug('seasons: %s', seasons)\n except Exception as e:\n logger.data_error('%s', e)\n continue\n competition_season_utils = []\n # comp_seas_sids = []\n for season in seasons:\n try:\n season_name = season.get('name')\n # logger.debug('season_name: %s', season_name)\n # season_name = seasons_special_treatment(season_name)\n competition_season_sid = season.get('id')\n # logger.debug('competition_season_sid: %s', competition_season_sid)\n is_current_season = season.get('is_current_season', False)\n # logger.debug('is_current_season: %s', is_current_season)\n except Exception as e:\n logger.data_error('%s', e)\n continue\n # comp_seas_sids.append(competition_season_sid)\n zak_season_name = games.models.Season.zakandify_season_string(season_name)\n season = zakanda.utils.season_from_season_name(zak_season_name)\n competition_season_type = get_competition_season_type(season)\n competition_season_util = pre_models.CompetitionSeasonUtil(season, competition_season_sid, competition_sname, competition_season_type)\n competition_season_utils.append(competition_season_util)\n # logger.debug(\"competition season sids: %s\", comp_seas_sids)\n pre_competition = pre_models.PreCompetition(\n source=source, sname=competition_sname, sid=sid, sport_name=sport_gname,\n competition_season_utils=competition_season_utils, pre_country=pre_country)\n pre_competitions.append(pre_competition)\n\n except Exception as e:\n logger.error('%s Unexpected problem with sportmonks.countries.all from source %s', e, source)\n logger.info(\"%s pre countries and %s pre competitions were created\", len(pre_countries), len(pre_competitions))\n return pre_countries, pre_competitions", "def llincc(x,y):\r\n covar = lcov(x,y)*(len(x)-1)/float(len(x)) # correct denom to n\r\n xvar = lvar(x)*(len(x)-1)/float(len(x)) # correct denom to n\r\n yvar = lvar(y)*(len(y)-1)/float(len(y)) # correct denom to n\r\n lincc = (2 * covar) / ((xvar+yvar) +((amean(x)-amean(y))**2))\r\n return lincc", "def lats(self):\n lats = []\n quads = self.getQuadrilaterals()\n groups = self._getGroupIndex()\n u_groups = np.unique(groups)\n ng = len(u_groups)\n for i in range(ng):\n q_ind = np.where(groups == u_groups[i])[0]\n nq = len(q_ind)\n top_lats = []\n bot_lats = []\n for j in range(nq):\n if j == 0:\n top0 = [quads[q_ind[j]][0].latitude]\n bot0 = [quads[q_ind[j]][3].latitude]\n top_lats = top_lats + top0\n bot_lats = bot_lats + bot0\n top_lats = top_lats + [quads[q_ind[j]][1].latitude]\n bot_lats = bot_lats + [quads[q_ind[j]][2].latitude]\n lats = lats + top_lats + bot_lats[::-1] + top0 + [np.nan]\n\n return np.array(lats)", "def _getlons(self):\n dlon = 360. / self.nlon\n lons = np.linspace(0. + dlon / 2., 360. - dlon / 2., self.nlon)\n return lons", "def country_of_origin(self):\n if self.investor_company:\n return self.investor_company.address_country" ]

[ "0.54118204", "0.5000237", "0.4949208", "0.4931147", "0.4911661", "0.4811012", "0.47071233", "0.47071233", "0.47031814", "0.4534821", "0.45185816", "0.45088586", "0.45060778", "0.44371125", "0.4435685", "0.44336432", "0.4428876", "0.44172257", "0.44085371", "0.43731523", "0.43697885", "0.4329497", "0.43193823", "0.43125367", "0.4302499", "0.42985916", "0.42971858", "0.42867166", "0.42796117", "0.4272254" ]

[ "def load_data(self) -> None:", "def load_data(self):", "def branches(self):\r\n url = self.base_url + 'branches/'\r\n return json.loads(self.bb.load_url(url))", "def _finish_init(self):\n\n # This is usually done in set_other(), but we already set it as part of\n # the constructor.\n self.this_branch.fetch(self.other_branch,\n last_revision=self.other_basis)", "def load_tree(self, name='tree'):\n handle = self.target_connector.get_handle()\n handle.setContext(self.target_connector)\n fname = fs.path.join('.', name + '.json')\n with handle.open(fname, 'rb') as fp:\n data = fp.read()\n self.request.response.setHeader('content-type', 'application/json')\n return data", "def load_breeze(self, breeze_path):\n self.breeze = pd.read_pickle(os.path.join(self.data_path, 'breeze.pick'))", "def load_from_disk(self, file_name = \"vehicle_classifier.pkl\"):\n self.classifier.load_from_disk(file_name)", "def load(self):\n #self.df = read_file(\"../data/yelp_academic_dataset_user.json\") #Full Data.\n self.df = read_file(\"../data/user300.json\") #For local machine.\n #self.get_friend_list()\n #self.save_friend_nodes()", "def fetch_branches(self):\n for jrepo in self.json_repos['repos']:\n title = str(jrepo[\"title\"])\n self.branches[title] = str(jrepo['current'])", "def _load_tree(tree_pickle):\n try:\n with open(tree_pickle, 'rb') as f:\n tree = pickle.load(f)\n except Exception as e:\n logger.warning('Could not extract tree from {}: {}'\n .format(tree_pickle, e))\n tree = None\n\n return tree", "def testLoadIntegratedDrugBankData(self):\n try:\n crw = ChemRefEtlWorker(self.__cfgOb, self.__cachePath)\n crExt = ChemRefExtractor(self.__cfgOb)\n\n idD = crExt.getChemCompAccessionMapping(referenceResourceName=\"DrugBank\")\n logger.info(\"Mapping dictionary %r\", len(idD))\n #\n ok = crw.load(self.__updateId, extResource=\"DrugBank\", loadType=\"full\")\n #\n self.assertTrue(ok)\n except Exception as e:\n logger.exception(\"Failing with %s\", str(e))\n self.fail()", "def load_data_file(self):\n with open(self.files['data'], 'r') as infile:\n data = json.load(infile)\n self.boundary_nodes = data['boundary_nodes']\n self.nodes = {int(k): v for k, v in data['nodes'].items()}\n self.levels = data['levels']\n infile.close()", "def fetch(self, remote: str, branch: str) -> str:\n self.__verify_repo_initialized()\n address = heads.get_remote_address(self._env.branchenv, name=remote)\n self._client = HangarClient(envs=self._env, address=address)\n CW = ContentWriter(self._env)\n\n with closing(self._client) as client:\n client: HangarClient\n\n # ----------------- setup / validate operations -------------------\n\n try:\n cHEAD = heads.get_branch_head_commit(self._env.branchenv, branch)\n except ValueError:\n # branch does not exist on local client\n try:\n s_branch = client.fetch_branch_record(branch)\n sHEAD = s_branch.rec.commit\n except grpc.RpcError as rpc_error:\n if rpc_error.code() == grpc.StatusCode.NOT_FOUND:\n # branch does not exist on remote\n logger.error(rpc_error.details())\n raise rpc_error\n else:\n c_bhistory = summarize.list_history(\n self._env.refenv, self._env.branchenv, branch_name=branch)\n try:\n s_branch = client.fetch_branch_record(branch)\n sHEAD = s_branch.rec.commit\n except grpc.RpcError as rpc_error:\n if rpc_error.code() == grpc.StatusCode.NOT_FOUND:\n # branch does not exist on remote\n logger.error(rpc_error.details())\n raise rpc_error\n\n # verify histories are intact and should be synced\n if sHEAD == cHEAD:\n warnings.warn(f'NoOp: {sHEAD} == client HEAD {cHEAD}', UserWarning)\n return branch\n elif sHEAD in c_bhistory['order']:\n warnings.warn(\n f'REJECTED: remote HEAD: {sHEAD} behind local: {cHEAD}', UserWarning)\n return branch\n\n # ------------------- get data ------------------------------------\n\n mCmtResponse = client.fetch_find_missing_commits(branch)\n m_cmts = mCmtResponse.commits\n for commit in tqdm(m_cmts, desc='fetching commit data refs'):\n # Get missing label (metadata) digest & values\n m_labels = set(client.fetch_find_missing_labels(commit))\n for label in m_labels:\n received_hash, labelVal = client.fetch_label(label)\n CW.label(received_hash, labelVal)\n # Get missing data schema digests & values\n mSchemaResponse = client.fetch_find_missing_schemas(commit)\n for schema in mSchemaResponse.schema_digests:\n schema_hash, schemaVal = client.fetch_schema(schema)\n CW.schema(schema_hash, schemaVal)\n # Record missing data hash digests (does not get data itself)\n m_hashes = client.fetch_find_missing_hash_records(commit)\n m_schema_hash_map = defaultdict(list)\n for digest, schema_hash in m_hashes:\n m_schema_hash_map[schema_hash].append((digest, schema_hash))\n for schema_hash, received_data in m_schema_hash_map.items():\n CW.data(schema_hash, received_data, backend='50')\n\n # Get missing commit reference specification\n for commit in tqdm(m_cmts, desc='fetching commit spec'):\n cmt, parentVal, specVal, refVal = client.fetch_commit_record(commit)\n CW.commit(cmt, parentVal, specVal, refVal)\n\n # --------------------------- At completion -----------------------\n\n # Update (or create) remote branch pointer with new HEAD commit\n fetchBranchName = f'{remote}/{branch}'\n try:\n heads.create_branch(\n self._env.branchenv, name=fetchBranchName, base_commit=sHEAD)\n except ValueError:\n heads.set_branch_head_commit(\n self._env.branchenv, branch_name=fetchBranchName, commit_hash=sHEAD)\n\n return fetchBranchName", "def load_data(self):\n raise NotImplementedError()", "def _load_state(\n self, datapath: str, dpr_model: str, pretrained_path: str, encoder_type: str\n ):\n if dpr_model == 'bert':\n state_dict = BertConversionUtils.load_bert_state(\n datapath,\n self.state_dict(),\n pretrained_dpr_path=pretrained_path,\n encoder_type=encoder_type,\n )\n self.load_state_dict(state_dict)\n elif dpr_model == 'bert_from_parlai_rag':\n state_dict = torch.load(pretrained_path, map_location='cpu')[\"model\"]\n key = f\"{encoder_type}_encoder.\"\n state_dict = {\n k.split(key)[-1]: v for k, v in state_dict.items() if key in k\n }\n self.load_state_dict(state_dict)", "def _load_tree(tree_path):\n try:\n with open(tree_path, 'rb') as f:\n tree = pickle.load(f)\n except Exception as e:\n logger.warning('Could not extract tree from {}: {}'\n .format(tree_path, e))\n tree = None\n\n return tree", "def dumbcache_load(cache_dir=r'data\\cache'):\n DUMBCACHE = os.path.join(r'..', cache_dir, r'br_store.dmp')\n with open(DUMBCACHE, 'rb') as f:\n return pkl.load(f)", "def load_cleaned_data(self):\n try:\n self.train = pd.read_pickle('../input/train_clean.pkl')\n self.test = pd.read_pickle('../input/test_clean.pkl')\n except FileNotFoundError:\n self.load_raw_data()", "def _load_tree_pickle(self, folderpath):\n pickle_file = os.path.join(folderpath, 'grid.pickle')\n if os.path.exists(pickle_file):\n pf = open(pickle_file, \"rb\")\n self.__dict__.update(pickle.load(pf))\n else:\n raise EnvironmentError('Unable to load pickle file {}, does not exist'.format(pickle_file))\n self.tree.manager = self", "def load_and_fix(self):\n # Read in json\n self.read_json()\n\n if self.size_to_load:\n self.data = self.data[:self.size_to_load]\n\n # Add names from database given _bsn:\n self.extend_dataframe_with_personnames()\n\n # Clean rows in the data_frame where the names column is empty - > thus no response from the database\n self.clean_none_response()\n\n # Fix path from A09.pdf to A09.json\n self.fix_path()\n\n # Get the correct names from the database response\n self.parse_names_from_response()\n\n print(\" --- Final Shape Data ---\")\n print(self.data.shape)\n print(list(self.data))\n\n # Save pickled object in ./data map\n self.save_obj(self.data, self.file_name_to_save)", "def load (self, filename) :\n\t\tserialFile = open (filename, \"rb\")\n\t\tself.production_rules = pickle.load (serialFile)\n\t\tself.unitrelation = pickle.load (serialFile)\n\t\tself.labels = pickle.load (serialFile)\n\t\tself.keeper = pickle.load (serialFile)\n\t\tself.strnodes = pickle.load(serialFile)\n\t\tself.tokens = pickle.load (serialFile)\n\t\tserialFile.close()", "def load(self):\n pass", "def load(self):\n pass", "def load(self):\n pass", "def load(self):\n pass", "def get_repo_branch(self):\n # Load HEAD and find ref.\n with open('{path}HEAD'.format(path=self.workpath), 'rb') as fp:\n ref = fp.read().strip().decode().split(': ')[1]\n\n print('[+] Downloading {}'.format(ref))\n\n # Requests for head hash and save\n head_url = '{base_url}{ref}'.format(base_url=self.base_url, ref=ref)\n data = self._request(head_url).read().strip()\n\n # Save the hash inside the ref file into the target place.\n ref_path = '/'.join(ref.split('/')[:-1])\n if not os.path.exists('{path}{ref_path}'.format(path=self.workpath, ref_path=ref_path)):\n os.makedirs('{path}{ref_path}'.format(path=self.workpath, ref_path=ref_path))\n with open('{path}{ref}'.format(path=self.workpath, ref=ref), 'wb') as fp:\n fp.write(data)\n\n # After get ref->head_hash, why not share it.\n self.head_hash = data.decode()", "def _get_branches(self):\n logging.info('--- Get Branches ---')\n self.local_branches = set(self.find_branches())\n self.remote_branches = set(self.find_branches(remote=True))\n # Tags are remote branches that start with \"tags/\".\n self.tags = {\n single_branch for single_branch in self.remote_branches\n if PRX_SVNTAGS_PREFIX.match(single_branch)}", "def load(self):\n db = CrawlDBI.DBI(dbtype='crawler')\n if self.rowid is not None:\n rows = db.select(table='checkables',\n fields=['rowid',\n 'path',\n 'type',\n 'cos',\n 'cart',\n 'ttypes',\n 'checksum',\n 'last_check',\n 'fails',\n 'reported'],\n where=\"rowid = ?\",\n data=(self.rowid,))\n else:\n rows = db.select(table='checkables',\n fields=['rowid',\n 'path',\n 'type',\n 'cos',\n 'cart',\n 'ttypes',\n 'checksum',\n 'last_check',\n 'fails',\n 'reported'],\n where=\"path = ?\",\n data=(self.path,))\n if 0 == len(rows):\n self.in_db = False\n elif 1 == len(rows):\n self.in_db = True\n rz = list(rows[0])\n self.rowid = rz.pop(0)\n self.path = rz.pop(0)\n self.type = rz.pop(0)\n self.cos = rz.pop(0)\n self.cart = rz.pop(0)\n self.ttypes = rz.pop(0)\n self.checksum = rz.pop(0)\n self.last_check = rz.pop(0)\n try:\n self.fails = rz.pop(0)\n except IndexError:\n self.fails = 0\n try:\n self.reported = rz.pop(0)\n except IndexError:\n self.reported = 0\n self.dirty = False\n else:\n raise StandardError(\"There appears to be more than one copy \" +\n \"of %s in the database\" % self)\n\n db.close()", "def load_data(self):\n self.tif_file = self._find_tif_file()\n if self.with_labeling is not None:\n self.colabel_file = self._find_colabeled_file()\n self.colabel_stack = self._load_colabeled_img()\n self.dff, self.indices = self._populate_dff_data()\n self.loaded = True", "def post_load(self, data):\n return data" ]

[ "0.6128238", "0.592409", "0.57337046", "0.5703952", "0.56251985", "0.56168956", "0.5596647", "0.55911064", "0.5567281", "0.5439576", "0.5429689", "0.54277277", "0.5410592", "0.5379778", "0.5364775", "0.53645855", "0.53460085", "0.53446186", "0.5340837", "0.5321691", "0.53162515", "0.52969426", "0.52969426", "0.52969426", "0.52969426", "0.52903396", "0.528235", "0.5262936", "0.52548283", "0.5231266" ]

[ "def upload_package(self, __contents):\n raise NotImplementedError", "def deploy():\n build()\n collect()\n commit()\n push()", "def push(self, base_repo, branch=\"master\"):\n base_repo.push_to(self, branch)", "def push(self):\n out, err, code = self.command( [\"git\", \"push\"], self.directory )", "def upload(self, connection):\n if not self.already_deployed(connection):\n if self.config.project_type == \"java\":\n print(blue('Pushing jar to nexus server'))\n connection.local('mvn deploy')\n self._already_deployed = True\n else:\n raise Exception(f\"Unsupported project type: {self.config.project_type}\")", "def upload():\n sh('python setup.py register sdist upload')", "def __gitPush(self):\n self.vcs.gitPush(self.project.getProjectPath())", "def push():\n branch = git.current_branch().name\n shell.run('git push -u origin {}'.format(branch))", "def push(self) -> None:\n\n with ImportExtensions(required=True):\n import requests\n\n pkg_path = Path(self.args.path)\n if not pkg_path.exists():\n self.logger.critical(f'`{self.args.path}` is not a valid path!')\n exit(1)\n\n request_headers = self._get_request_header()\n\n try:\n # archive the executor package\n with TimeContext(f'Packaging {self.args.path}', self.logger):\n md5_hash = hashlib.md5()\n bytesio = archive_package(pkg_path)\n content = bytesio.getvalue()\n md5_hash.update(content)\n\n md5_digest = md5_hash.hexdigest()\n\n # upload the archived package\n form_data = {\n 'public': self.args.public if hasattr(self.args, 'public') else False,\n 'private': self.args.private\n if hasattr(self.args, 'private')\n else False,\n 'md5sum': md5_digest,\n 'force': self.args.force,\n 'secret': self.args.secret,\n }\n\n method = 'put' if self.args.force else 'post'\n\n hubble_url = get_hubble_url()\n # upload the archived executor to Jina Hub\n with TimeContext(\n f'Pushing to {hubble_url} ({method.upper()})',\n self.logger,\n ):\n resp = getattr(requests, method)(\n hubble_url,\n files={'file': content},\n data=form_data,\n headers=request_headers,\n )\n\n if 200 <= resp.status_code < 300:\n # TODO: only support single executor now\n image = resp.json()['executors'][0]\n\n uuid8 = image['id']\n secret = image['secret']\n visibility = image['visibility']\n\n info_table = [\n f'\\t🔑 ID:\\t\\t' + colored(f'{uuid8}', 'cyan'),\n f'\\t🔒 Secret:\\t'\n + colored(\n f'{secret}',\n 'cyan',\n )\n + colored(\n ' (👈 Please store this secret carefully, it wont show up again)',\n 'red',\n ),\n f'\\t👀 Visibility:\\t' + colored(f'{visibility}', 'cyan'),\n ]\n\n if 'alias' in image:\n info_table.append(f'\\t📛 Alias:\\t' + colored(image['alias'], 'cyan'))\n\n self.logger.success(f'🎉 Executor `{pkg_path}` is pushed successfully!')\n self.logger.info('\\n' + '\\n'.join(info_table))\n\n usage = (\n f'jinahub://{uuid8}'\n if visibility == 'public'\n else f'jinahub://{uuid8}:{secret}'\n )\n\n self.logger.info(f'You can use it via `uses={usage}` in the Flow/CLI.')\n elif resp.text:\n # NOTE: sometimes resp.text returns empty\n raise Exception(resp.text)\n else:\n resp.raise_for_status()\n except Exception as e: # IO related errors\n self.logger.error(\n f'Error while pushing `{self.args.path}` with session_id={request_headers[\"jinameta-session-id\"]}: '\n f'\\n{e!r}'\n )", "def git_push(c):\n c.run(\"git submodule foreach git push \")", "def push_updates():\n check_call(['git', 'push', '--tags', '--force'])", "def deploy():\n _confirm_branch()\n \n require('settings', provided_by=[production, staging])\n require('branch', provided_by=[stable, master, branch])\n \n with settings(warn_only=True):\n maintenance_up()\n \n checkout_latest()\n gzip_assets()\n deploy_to_s3()\n maintenance_down()", "def upload():\n\n # Our credentials are only available from within the main repository and not forks.\n # We need to prevent uploads from all BUT the branches in the main repository.\n # Pull requests and master-branches of forks are not allowed to upload.\n is_pull_request = (\n (\"TRAVIS_PULL_REQUEST\" in os.environ and os.environ[\"TRAVIS_PULL_REQUEST\"] != \"false\") or\n \"APPVEYOR_PULL_REQUEST_NUMBER\" in os.environ\n )\n if is_pull_request:\n click.echo(\"Refusing to upload artifacts from a pull request!\")\n return\n\n if \"AWS_ACCESS_KEY_ID\" in os.environ:\n subprocess.check_call([\n \"aws\", \"s3\", \"cp\",\n \"--acl\", \"public-read\",\n DIST_DIR + \"/\",\n \"s3://snapshots.mitmproxy.org/{}/\".format(UPLOAD_DIR),\n \"--recursive\",\n ])\n\n upload_pypi = (\n TAG and\n \"WHEEL\" in os.environ and\n \"TWINE_USERNAME\" in os.environ and\n \"TWINE_PASSWORD\" in os.environ\n )\n if upload_pypi:\n whl = glob.glob(join(DIST_DIR, 'mitmproxy-*-py3-none-any.whl'))[0]\n click.echo(\"Uploading {} to PyPi...\".format(whl))\n subprocess.check_call([\n \"twine\",\n \"upload\",\n whl\n ])\n\n upload_docker = (\n (TAG or BRANCH == \"master\") and\n \"DOCKER\" in os.environ and\n \"DOCKER_USERNAME\" in os.environ and\n \"DOCKER_PASSWORD\" in os.environ\n )\n if upload_docker:\n docker_tag = \"dev\" if BRANCH == \"master\" else VERSION\n\n click.echo(\"Uploading Docker image to tag={}...\".format(docker_tag))\n subprocess.check_call([\n \"docker\",\n \"login\",\n \"-u\", os.environ[\"DOCKER_USERNAME\"],\n \"-p\", os.environ[\"DOCKER_PASSWORD\"],\n ])\n subprocess.check_call([\n \"docker\",\n \"push\",\n \"mitmproxy/mitmproxy:{}\".format(docker_tag),\n ])", "def install():\n execute(generate)\n execute(upload)", "def upload_package(conn, module, remotepath = None, chunk_size = 16000):\n if remotepath is None:\n site = conn.modules[\"distutils.sysconfig\"].get_python_lib()\n remotepath = conn.modules.os.path.join(site, module.__name__)\n localpath = os.path.dirname(inspect.getsourcefile(module))\n upload(conn, localpath, remotepath, chunk_size = chunk_size)", "def push ():\n\n tagname = get_tag (comp_versions, 'ACE')\n\n if opts.push:\n if opts.take_action:\n vprint (\"Pushing ACE_TAO\", opts.ace_tao_branch, \"to origin\")\n ex (\"cd $DOC_ROOT/ACE_TAO && git push origin \" + opts.ace_tao_branch)\n\n vprint (\"Pushing tag %s on ACE_TAO\" % (tagname))\n ex (\"cd $DOC_ROOT/ACE_TAO && git push origin tag \" + tagname)\n\n vprint (\"Pushing tag %s on MPC\" % (tagname))\n ex (\"cd $DOC_ROOT/MPC && git push origin tag \" + tagname)\n\n # Push release branches\n latest_branch_helper (push_latest_branch, opts.release_type)\n else:\n vprint (\"Pushing tag %s on ACE_TAO\" % (tagname))\n vprint (\"Pushing tag %s on MPC\" % (tagname))\n print (\"Pushing tags:\\n\")\n print (\"Pushing tag \" + tagname + \"\\n\")", "def upload_tar_from_git():\n require(\"release\", provided_by=[deploy])\n tree = prompt(\"Please enter a branch or SHA1 to deploy\", default=\"master\")\n local(\"git archive --format=tar %s | gzip > %s.tar.gz\" % (tree, env['release']))\n sudo(\"mkdir %(path)s/releases/%(release)s\" % env)\n put(\"%(release)s.tar.gz\" % env, \"%(path)s/packages/\" % env, use_sudo=True)\n sudo(\"cd %(path)s/releases/%(release)s && tar zxf ../../packages/%(release)s.tar.gz\" % env)\n local(\"rm %(release)s.tar.gz\" % env)", "def prepare_deploy(ticket=None, msg=None, branch=None):\n test()\n commit(ticket, msg)\n push(branch)\n pull(branch)", "def _push(self):\n push_cmds = self.vcs.push_commands()\n if not push_cmds:\n return\n if utils.ask(\"OK to push commits to the server?\"):\n for push_cmd in push_cmds:\n output = execute_command(push_cmd)\n logger.info(output)", "def upload(ctx, release, rebuild, version):\n\n dist_path = Path(DIST_PATH)\n if rebuild is False:\n if not dist_path.exists() or not list(dist_path.glob('*')):\n print(\"No distribution files found. Please run 'build' command first\")\n return\n else:\n ctx.invoke(build, force=True, version=version)\n\n if release:\n args = ['twine', 'upload', 'dist/*']\n else:\n repository = 'https://test.pypi.org/legacy/'\n args = ['twine', 'upload', '--repository-url', repository, 'dist/*']\n\n env = os.environ.copy()\n\n p = subprocess.Popen(args, env=env)\n p.wait()", "def upload(bld):\n\n with bld.create_virtualenv() as venv:\n venv.run(\"python -m pip install twine\")\n\n wheel = _find_wheel(ctx=bld)\n\n venv.run(\"python -m twine upload {}\".format(wheel))", "def prepare_deploy():\n from fabdeploy.django import test as django_test\n django_test()\n git.add_commit_pull()\n git.push()", "def upload_wheels():\n build()\n sh(\"%s -m twine upload dist/*.whl\" % PYTHON)", "def push(ctx):\n dufl_root = ctx.obj['dufl_root']\n git = Git(ctx.obj.get('git', '/usr/bin/git'), dufl_root)\n git.run('push', 'origin', git.working_branch())", "def upload(ctx: click.Context, **kwargs):\n root_commands.cmd_upload(ctx.obj, **kwargs)", "def push_sources():\n ensure_src_dir()\n push_rev = getattr(env, 'push_rev', None)\n if push_rev is None:\n push_rev = datetime.datetime.now().strftime(\"%Y%m%d_%H%M%S\")\n local(\"git tag -a {0} -m \\\"Tagged for release\\\"\".format(push_rev))\n local(\"git push origin master --tags\")\n\n with cd(SRC_DIR):\n run(\"git pull origin master\")\n run(\"git fetch -t\")\n run(\"git checkout {0}\".format(push_rev))", "def upload_release_files():\n version = get_release_version()\n target = sf_files + sourceforge_target_dir(version)\n\n print()\n print(\"Uploading release files...\")\n print(\" Source:\", release_path)\n print(\" Target: \" + target)\n print(\" Files: \" + ', '.join(glob.glob('*')))\n print()\n call_rsync(\n username,\n \"\",\n path.join(release_path, \"*\"),\n target\n )\n print()", "def push():\n local('hg push jvacx')", "def deploy():\n build()\n copy()\n install()", "def push(self, remote, branch, *args):\n return self.cmd('push', remote, branch, *args)" ]

[ "0.6992921", "0.65332377", "0.6517984", "0.64805365", "0.6429827", "0.6415388", "0.64010024", "0.6369851", "0.6338582", "0.62850165", "0.6262531", "0.6237359", "0.6235568", "0.6226121", "0.61871606", "0.6132188", "0.60597724", "0.60434294", "0.60356283", "0.6010991", "0.59812975", "0.59805983", "0.59608626", "0.59449154", "0.59299654", "0.59215945", "0.59112567", "0.5909056", "0.59046596", "0.5881801" ]

[ "def bd_selectPackageList_byID(self, _c, _pckgID):\n\n result = {}\n\n _c.execute(\"SELECT id, num, desc, status, source_env, dest_env, app, last_rev FROM package WHERE id=? ORDER BY num DESC\", [_pckgID]) \n data = _c.fetchone()\n\n if data:\n result['id'] = data[0] \n result['desc'] = data[2]\n result['status'] = data[3]\n result['source_env'] = data[4]\n result['dest_env'] = data[5]\n result['app'] = data[6]\n result['last_rev'] = data[7]\n result['num'] = data[1] #Place this attribute the last because of print issue. I know this is a Dict, take it easy.\n #\n\n return result", "def get_package_id(name, version, arch, data):\n return \";\".join((name, version, arch, data))", "def get_info(self, pkgname):\n for pkg in self.rpc.info(pkgname):\n return pkg", "def get_package_info(package_name):\n r = requests.get(f'https://api.npms.io/v2/search?q={package_name}&size=1')\n response_json = r.json()\n\n if 'results' in response_json:\n result = response_json['results'][0]\n return result['package']", "def list_package_ids(self):\n raise NotImplementedError", "def get_distid(pkgtype, distslug, config):\n\n distindex = get_distributions(config)\n distributions = distindex[pkgtype]\n distname, codename = distslug.split('/')\n\n if config['debug']:\n print(\"DEBUG: Pkgtype: {} Distribution: {} Codename: {}\".\n format(pkgtype, distname, codename))\n\n for dist in distributions:\n if dist['index_name'] == distname:\n for ver in dist['versions']:\n if ver['index_name'] == codename:\n return ver['id']\n\n abort(\"No distribution id found for: {}\".format(distslug))", "def _package_ids_satisfying_requirement(pool, requirement):\n for package in pool.what_provides(requirement):\n yield pool.package_id(package)", "def get_package(self, __package_id):\n raise NotImplementedError", "def find_package(self, package_title):\n metadata = self.get_ckan_metadata()\n results = []\n for id, resource in metadata.items():\n if resource['dataset']['title'] == package_title:\n results.append(resource['dataset'])\n return results[0] if len(results) == 1 else results", "def getPackageInfo(self, pid):\n if pid == self.ROOT_PACKAGE:\n pack = RootPackage(self, OWNER).toInfoData()\n elif pid in self.packages:\n pack = self.packages[pid].toInfoData()\n pack.stats = self.db.getStatsForPackage(pid)\n else:\n pack = self.db.getPackageInfo(pid)\n\n if not pack: return None\n\n # todo: what does this todo mean?!\n #todo: fill child packs and files\n packs = self.db.getAllPackages(root=pid)\n if pid in packs: del packs[pid]\n pack.pids = packs.keys()\n\n files = self.db.getAllFiles(package=pid)\n pack.fids = files.keys()\n\n return pack", "def get_package_info():\n\n with open(hack.CONDA_ARTIFACT_FILENAME, 'r') as fn:\n pkg_location = fn.read().strip()\n pkg_name = os.path.basename(pkg_location)\n\n return pkg_location, pkg_name", "def get_item_id_from_list_by_name(self, item_name, list_of_items):\n\n for item in list_of_items:\n if item_name in item['content']:\n return item['id']\n\n return None", "def _get_item_id_for_upgrade(self, package_items, option, value,\r\n public=True):\r\n vs_id = {'memory': 3, 'cpus': 80, 'nic_speed': 26}\r\n for item in package_items:\r\n for j in range(len(item['categories'])):\r\n if not (item['categories'][j]['id'] == vs_id[option] and\r\n item['capacity'] == str(value)):\r\n continue\r\n if option == 'cpus':\r\n if public and ('Private' not in item['description']):\r\n return item['prices'][0]['id']\r\n elif not public and ('Private' in item['description']):\r\n return item['prices'][0]['id']\r\n elif option == 'nic_speed':\r\n if 'Public' in item['description']:\r\n return item['prices'][0]['id']\r\n else:\r\n return item['prices'][0]['id']", "def package(id = 0):\n\tresults = queries.package(id)\n\tif not results:\n\t\treturn render_template('package_not_found.html')\n\treturn render_template('package.html', package=results)", "def create_package_id(self):\n return self.create(\"TrackPackageIdentifier\")", "def test_package_id(self) -> str:\n return pulumi.get(self, \"test_package_id\")", "def get_spynl_package(name, packages=None):\n if packages is None:\n packages = get_spynl_packages()\n return next(filter(lambda p: p.project_name == name, packages), None)", "def populate_package(package_count: int) -> None:\n logging.info(f\"Fetching {package_count} packages\")\n response = CurlController.send_get_request(url=CONFIG.EXTERNAL_API.ALL_PACKAGES)\n get_version = False\n count = 0\n temp_dir = filestore.generate_temp_dir()\n # Local Testing\n # response_arr = ['Package: A3', 'Version: 1.0.0', 'Depends: R (>= 2.15.0), xtable, pbapply', 'Suggests: randomForest, e1071', 'License: GPL (>= 2)', 'MD5sum: 027ebdd8affce8f0effaecfcd5f5ade2', 'NeedsCompilation: no', '', 'Package: aaSEA', 'Version: 1.1.0', 'Depends: R(>= 3.4.0)', 'Imports: DT(>= 0.4), networkD3(>= 0.4), shiny(>= 1.0.5),', ' shinydashboard(>= 0.7.0), magrittr(>= 1.5), Bios2cor(>= 2.0),', ' seqinr(>= 3.4-5), plotly(>= 4.7.1), Hmisc(>= 4.1-1)', 'Suggests: knitr, rmarkdown', 'License: GPL-3', 'MD5sum: 0f9aaefc1f1cf18b6167f85dab3180d8', 'NeedsCompilation: no', '', 'Package: AATtools', 'Version: 0.0.1', 'Depends: R (>= 3.6.0)', 'Imports: magrittr, dplyr, doParallel, foreach', 'License: GPL-3', 'MD5sum: 3bd92dbd94573afb17ebc5eab23473cb', 'NeedsCompilation: no', '', 'Package: ABACUS', 'Version: 1.0.0', 'Depends: R (>= 3.1.0)', 'Imports: ggplot2 (>= 3.1.0), shiny (>= 1.3.1),', 'Suggests: rmarkdown (>= 1.13), knitr (>= 1.22)', 'License: GPL-3', 'MD5sum: 50c54c4da09307cb95a70aaaa54b9fbd', 'NeedsCompilation: no', '', 'Package: abbyyR', 'Version: 0.5.5', 'Depends: R (>= 3.2.0)', 'Imports: httr, XML, curl, readr, plyr, progress', 'Suggests: testthat, rmarkdown, knitr (>= 1.11), lintr', 'License: MIT + file LICENSE', 'MD5sum: e048a3bca6ea32126e6c367415c0bfaf', 'NeedsCompilation: no', '', 'Package: abc', 'Version: 2.1', 'Depends: R (>= 2.10), abc.data, nnet, quantreg, MASS, locfit', 'License: GPL (>= 3)', 'MD5sum: c9fffe4334c178917f762735aba59653', 'NeedsCompilation: no', '', 'Package: abc.data', 'Version: 1.0', 'Depends: R (>= 2.10)', 'License: GPL (>= 3)', 'MD5sum: 799079dbbdd0cfc9d9c61c3e35241806', 'NeedsCompilation: no', '', 'Package: ABC.RAP', 'Version: 0.9.0', 'Depends: R (>= 3.1.0)', 'Imports: graphics, stats, utils', 'Suggests: knitr, rmarkdown', 'License: GPL-3', 'MD5sum: 38c65a7251d28ef2462ee430ded95700', 'NeedsCompilation: no', '', 'Package: abcADM', 'Version: 1.0', 'Imports: Rcpp (>= 1.0.1)', 'LinkingTo: Rcpp, BH', 'License: GPL-3', 'MD5sum: 8134f67912b506194e3dab4ccd6e75f7', 'NeedsCompilation: yes', '', 'Package: ABCanalysis', 'Version: 1.2.1', 'Depends: R (>= 2.10)', 'Imports: plotrix', 'License: GPL-3', 'MD5sum: 678e03837e25a922bf71bafe1f8de617', 'NeedsCompilation: no', '', 'Package: abcdeFBA', 'Version: 0.4', 'Depends: Rglpk,rgl,corrplot,lattice,R (>= 2.10)', 'Suggests: LIM,sybil', 'License: GPL-2', 'MD5sum: c84d45a85d8ab6bbe517365e8845db83', 'NeedsCompilation: no', '', 'Package: ABCoptim', 'Version: 0.15.0', 'Imports: Rcpp, graphics, stats, utils', 'LinkingTo: Rcpp', 'Suggests: testthat, covr', 'License: MIT + file LICENSE', 'MD5sum: a62ed03650273c09899655065437078f', 'NeedsCompilation: yes', '', 'Package: ABCp2', 'Version: 1.2', 'Depends: MASS', 'License: GPL-2', 'MD5sum: e920282d5a369df71e15241be40cb60e', 'NeedsCompilation: no', '', 'Package: abcrf', 'Version: 1.8.1', 'Depends: R(>= 3.1)', 'Imports: readr, MASS, matrixStats, ranger, doParallel, parallel,', ' foreach, stringr, Rcpp (>= 0.11.2)', 'LinkingTo: Rcpp, RcppArmadillo', 'License: GPL (>= 2)', 'MD5sum: 4d5a304f46d117226791523cef4e2427', 'NeedsCompilation: yes', '', 'Package: abcrlda', 'Version: 1.0.3', 'Imports: stats', 'License: GPL-3', 'MD5sum: 651e6e18e08916b443aaf011b5a63525', 'NeedsCompilation: no', '', 'Package: abctools', 'Version: 1.1.3', 'Depends: R (>= 2.10), abc, abind, parallel, plyr, Hmisc', 'Suggests: ggplot2, abc.data', 'License: GPL (>= 2)', 'MD5sum: c5937b65837ef7e6bfbe141cea257f40', 'NeedsCompilation: yes', '', 'Package: abd', 'Version: 0.2-8', 'Depends: R (>= 3.0), nlme, lattice, grid, mosaic', 'Suggests: boot, car, ggplot2, plyr, HH, ICC, vcd, Hmisc', 'License: GPL-2', 'MD5sum: 1913d76a0fbc44222709381f63f385b9', 'NeedsCompilation: no', '', 'Package: abdiv', 'Version: 0.2.0', 'Imports: ape', 'Suggests: testthat (>= 2.1.0), vegan', 'License: MIT + file LICENSE', 'MD5sum: 80931c0ca85ba5386000bf617552c5ce', 'NeedsCompilation: no', '', 'Package: abe', 'Version: 3.0.1', 'License: GPL (>= 2)', 'MD5sum: 9c151db5397422c8927dee41dabfbfab', 'NeedsCompilation: no', '', 'Package: abess', 'Version: 0.3.0', 'Depends: R (>= 3.1.0)', 'Imports: Rcpp, MASS, methods, Matrix', 'LinkingTo: Rcpp, RcppEigen', 'Suggests: testthat, knitr, rmarkdown', 'License: GPL (>= 3) | file LICENSE', 'MD5sum: e0ea7d068147c49c011c7135ab290bd3', 'NeedsCompilation: yes', '', 'Package: abf2', 'Version: 0.7-1', 'License: Artistic-2.0', 'MD5sum: 6792a51c6fb3e239165d69aa8a71d3cd', 'NeedsCompilation: no', '', 'Package: abglasso', 'Version: 0.1.1', 'Imports: MASS, pracma, stats, statmod', 'Suggests: testthat', 'License: GPL-3', 'MD5sum: 18bd0759cd005c5ac6fb515799b3f3d8', 'NeedsCompilation: no', '', 'Package: ABHgenotypeR', 'Version: 1.0.1', 'Imports: ggplot2, reshape2, utils', 'Suggests: knitr, rmarkdown', 'License: GPL-3', 'MD5sum: ca4397ba7390c0e0a3728c0cda864494', 'NeedsCompilation: no', '', 'Package: abind', 'Version: 1.4-5', 'Depends: R (>= 1.5.0)', 'Imports: methods, utils', 'License: LGPL (>= 2)', 'MD5sum: 136f981e1c4f618b64a87faaa7797c97', 'NeedsCompilation: no', '', 'Package: abjutils', 'Version: 0.3.1', 'Depends: R (>= 4.0)', 'Imports: dplyr, magrittr, purrr, rlang, rstudioapi, stringi, stringr,', ' tidyr', 'Suggests: testthat', 'License: MIT + file LICENSE', 'MD5sum: a596c07aaa7f82e5d123b2f7354e5b55', 'NeedsCompilation: no', '', 'Package: abmR', 'Version: 1.0.2', 'Depends: R (>= 3.5)', 'Imports: sp, rgdal, table1, googledrive, swfscMisc, geosphere,', ' kableExtra, gtsummary, ggplot2, gstat, purrr, rnaturalearth,', ' rnaturalearthdata, sf, tmap, raster, utils, stats, methods,', ' rgeos', 'Suggests: jpeg, knitr', 'License: GPL (>= 3)', 'MD5sum: cf96d']\n response_arr = response.decode(\"utf-8\").split(\"\\n\")\n with temp_dir:\n for item in response_arr:\n if count >= package_count:\n break\n if get_version:\n # Fetching the version, once we have the package name\n package_version = Command.get_package_version(item=item)\n if package_version:\n # Generating the required URL for the package to fetch the details\n package_url = Template(\n CONFIG.EXTERNAL_API.PACKAGE_DETAIL\n ).substitute(\n package_name=package_name,\n separator=\"_\",\n package_version=package_version,\n )\n logging.info(f\"Downloading {package_url}\")\n # Downloading the details of the package and extracting the DESCRIPTION file\n extract_file_path = filestore.join_paths(\n prefix=package_name,\n suffix=CONFIG.EXTERNAL_API.DETAIL_FILE_NAME,\n )\n target_dir = filestore.download_file(\n url=package_url,\n temp_dir=temp_dir,\n extract_file_path=extract_file_path,\n )\n # Reading contents of DESCRIPTION file\n package_details = filestore.join_paths(\n prefix=temp_dir.name,\n suffix=extract_file_path,\n )\n with open(package_details) as details_file:\n for line in details_file:\n if line.startswith(PackageInfoPrefix.PUBLICATION_DATE):\n publication_time_str = (\n Command.get_publication_timestamp(line)\n )\n publication_timestamp = (\n datetime_util.string_to_datetime(\n publication_time_str\n )\n )\n elif line.startswith(PackageInfoPrefix.TITLE):\n title = Command.get_package_title(line)\n elif line.startswith(PackageInfoPrefix.DESCRIPTION):\n description = Command.get_package_description(line)\n elif line.startswith(PackageInfoPrefix.AUTHOR):\n (\n author_name,\n author_email,\n ) = Command.get_package_author(line)\n elif line.startswith(PackageInfoPrefix.MAINTAINER):\n (\n maintainer_name,\n maintainer_email,\n ) = Command.get_package_maintainer(line)\n\n package_info_dict = {\n \"name\": package_name,\n \"version\": package_version,\n \"publication_timestamp\": publication_timestamp,\n \"title\": title,\n \"description\": description,\n \"author_name\": author_name,\n \"author_email\": author_email,\n \"maintainer_name\": maintainer_name,\n \"maintainer_email\": maintainer_email,\n }\n logging.info(package_info_dict)\n obj = PackageManager.create_object(\n create_data=package_info_dict\n )\n if obj == CONFIG.DB.FAILURE:\n raise Exception(f\"Could not insert package in DB\")\n count += 1\n get_version = False\n # Fetching the package name\n package_name = Command.get_package_name(item=item)\n if package_name:\n get_version = True", "def get_package_id(self, ver):\n assert isinstance(ver, apt.package.Version)\n return \"%s;%s;%s;\" % (ver.package.shortname, ver.version, ver.package.architecture())", "def get_closest_nuget_package_name(query):\n url_nuget_service = \"https://api.nuget.org/v3/index.json\"\n url_nuget_search = \"\"\n\n api_resources = requests.get(url_nuget_service).json()\n for resource in api_resources.get(\"resources\") or []:\n if resource.get(\"@type\") == \"SearchQueryService\":\n url_nuget_search = resource[\"@id\"]\n break\n\n if url_nuget_search:\n url_query = urljoin(url_nuget_search, f\"?q={query}\")\n query_response = requests.get(url_query).json()\n if query_response.get(\"data\"):\n return query_response[\"data\"][0][\"id\"]", "def _find_rpms_in_packages(koji_api, name_list, major_minor):\n rpms_for_package = {}\n tags = _tags_for_version(major_minor)\n for package in name_list:\n for tag in tags:\n for build in koji_api.getLatestBuilds(tag=tag, package=package):\n rpm_list = set(rpm[\"name\"] for rpm in koji_api.listBuildRPMs(build[\"build_id\"]))\n rpms_for_package.setdefault(package, set()).update(rpm_list)\n\n if package not in rpms_for_package:\n # it wasn't in our tags; look for it by name\n pkg_info = koji_api.getPackage(package)\n if not pkg_info:\n continue\n latest_builds = koji_api.listBuilds(packageID=pkg_info[\"id\"], state=1, queryOpts=dict(limit=1))\n if not latest_builds:\n continue\n rpm_list = set(rpm[\"name\"] for rpm in koji_api.listBuildRPMs(latest_builds[0][\"build_id\"]))\n rpms_for_package[package] = set(rpm_list)\n\n return rpms_for_package", "def get_python_package_info(name):\n command = [\"python\", \"setup.py\", \"--name\"]\n with subprocess.Popen(command, stdout=subprocess.PIPE) as proc:\n assert proc.stdout.readline().strip().decode(\"utf-8\") == name\n\n command = [\"python\", \"setup.py\", \"--version\"]\n with subprocess.Popen(command, stdout=subprocess.PIPE) as proc:\n release_version = proc.stdout.readline().strip().decode(\"utf-8\")\n\n command = [\"python\", \"setup.py\", \"--url\"]\n with subprocess.Popen(command, stdout=subprocess.PIPE) as proc:\n github_url = proc.stdout.readline().strip().decode(\"utf-8\")\n\n github_repo = urlparse(github_url)\n assert github_repo.netloc == \"github.com\", \"specified repo is not on GitHub\"\n return (release_version, github_repo)", "def match_pkg(cache, serial, pkg):\n if pkg in cache:\n matched_packages.append([serial, pkg])\n elif ' ' in pkg:\n pkg2 = pkg.replace(' ', '-')\n match_pkg(cache,serial,pkg2)\n # # if pkg2 in cache:\n # matched_packages.append([serial, pkg2]) #\n else:\n not_found_packages.append([serial, pkg])", "def __extract_package_version(package_string):\n # remove leading whitespace\n package_string = package_string.strip()\n # create a re parser\n compil = re.compile(r'(?P<name>.+(-[^-])*)-(?P<version>.+)')\n # search package name and version\n search = compil.search(package_string)\n # retrieve result as list\n output = search.groupdict()\n\n return output", "def test_package_id(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"test_package_id\")", "def get_packages(packages):\n for package in package_data:\n p_id = package[\"packageId\"]\n p_lat = package[\"destination\"][\"latitude\"]\n p_long = package[\"destination\"][\"longitude\"]\n deadline = package[\"deadline\"]\n\n p = Package(p_id, Location(p_lat, p_long), deadline)\n p.set_latest_departure(DRONE_SPEED_kms, DEPOT)\n packages_list.append(p)", "def bootstrap_package_id(self) -> str:\n return pulumi.get(self, \"bootstrap_package_id\")", "def findPackages(self, pkgcode, packages=None):\n if not packages:\n if (self.system_pkgcode and pkgcode == self.system_pkgcode):\n scanlist = ['language-pack', 'language-support-fonts', 'language-support-input', 'language-support-writing']\n else:\n scanlist = ['language-pack']\n for x in scanlist:\n pkg = '%s-%s' % (x, pkgcode)\n if pkg in self._cache:\n if not self._cache[pkg].is_installed and \\\n not self._cache[pkg].marked_install:\n self.missing.add(pkg)\n else:\n self.installed.add(pkg)\n \n if pkgcode in self.pkg_translations:\n for (pkg, translation) in self.pkg_translations[pkgcode]:\n if packages:\n if pkg in packages and \\\n pkg in self._cache and \\\n translation in self._cache:\n if ((not self._cache[translation].is_installed and \\\n not self._cache[translation].marked_install and \\\n not self._cache[translation].marked_upgrade) or \\\n self._cache[translation].marked_delete):\n self.missing.add(translation)\n else:\n self.installed.add(translation)\n else:\n if pkg in self._cache and \\\n (self._cache[pkg].is_installed or \\\n self._cache[pkg].marked_install or \\\n self._cache[pkg].marked_upgrade) and \\\n translation in self._cache:\n if ((not self._cache[translation].is_installed and \\\n not self._cache[translation].marked_install and \\\n not self._cache[translation].marked_upgrade) or \\\n self._cache[translation].marked_delete):\n self.missing.add(translation)\n else:\n self.installed.add(translation)\n \n if pkgcode in self.pkg_writing and \\\n (pkgcode == self.system_pkgcode or \\\n ('language-support-writing-%s' % pkgcode in self._cache and \\\n self._cache['language-support-writing-%s' % pkgcode].is_installed) or \\\n ('language-support-writing-%s' % pkgcode in self._cache and \\\n self._cache['language-support-writing-%s' % pkgcode].mark_install) or \\\n ('language-support-writing-%s' % pkgcode in self._cache and \\\n self._cache['language-support-writing-%s' % pkgcode].markUpgrade)):\n for (pkg, pull_pkg) in self.pkg_writing[pkgcode]:\n if '|' in pkg:\n # multiple dependencies, if one of them is installed, pull the pull_pkg\n for p in pkg.split('|'):\n if packages:\n if p in packages and \\\n p in self._cache and \\\n pull_pkg in self._cache:\n if ((not self._cache[pull_pkg].is_installed and \\\n not self._cache[pull_pkg].marked_install and \\\n not self._cache[pull_pkg].marked_upgrade) or \\\n self._cache[pull_pkg].marked_delete):\n self.missing.add(pull_pkg)\n else:\n self.installed.add(pull_pkg)\n break\n else:\n if p in self._cache and \\\n (self._cache[p].is_installed or \\\n self._cache[p].marked_install or \\\n self._cache[p].marked_upgrade) and \\\n pull_pkg in self._cache:\n if ((not self._cache[pull_pkg].is_installed and \\\n not self._cache[pull_pkg].marked_install and \\\n not self._cache[pull_pkg].marked_upgrade) or \\\n self._cache[pull_pkg].marked_delete):\n self.missing.add(pull_pkg)\n else:\n self.installed.add(pull_pkg)\n break\n else:\n if packages:\n if pkg in packages and \\\n pkg in self._cache and \\\n pull_pkg in self._cache:\n if ((not self._cache[pull_pkg].is_installed and \\\n not self._cache[pull_pkg].marked_install and \\\n not self._cache[pull_pkg].marked_upgrade) or \\\n self._cache[pull_pkg].marked_delete):\n self.missing.add(pull_pkg)\n else:\n self.installed.add(pull_pkg)\n else:\n if pkg in self._cache and \\\n (self._cache[pkg].is_installed or \\\n self._cache[pkg].marked_install or \\\n self._cache[pkg].marked_upgrade) and \\\n pull_pkg in self._cache:\n if ((not self._cache[pull_pkg].is_installed and \\\n not self._cache[pull_pkg].marked_install and \\\n not self._cache[pull_pkg].marked_upgrade) or \\\n self._cache[pull_pkg].marked_delete):\n self.missing.add(pull_pkg)\n else:\n self.installed.add(pull_pkg)", "def get_package(self, package_id):\n return self._package_cache.get(package_id)", "def findSymbolByItemnum(itemnum, libs_dict):\n e_itemnum = re.escape(itemnum)\n for libname, dat in libs_dict.items():\n m = re.search(r'^DEF ([^ ]*) .*(?:\\n[^\\$].+)+\\nF ?\\d+ \"'+e_itemnum+r'\".* \"Item Number\"\\n', dat, re.MULTILINE)\n try:\n symname = m.group(1)\n return libname, symname\n except:\n continue\n return None, None" ]

[ "0.6142764", "0.59174037", "0.5913275", "0.58575547", "0.5794914", "0.57480824", "0.5745953", "0.56321526", "0.5583289", "0.55084556", "0.5450892", "0.5416782", "0.5412792", "0.5388353", "0.5381202", "0.5359032", "0.5345228", "0.5315372", "0.5281844", "0.5267592", "0.5251155", "0.5249847", "0.5241232", "0.52150255", "0.5211557", "0.52111346", "0.52034724", "0.5196443", "0.5172637", "0.5144054" ]

[ "def test_upsert_user_template_as_anonymous_with_access_right_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user1_template, request=mock_request\n )", "def test_upsert_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.global_template, request=mock_request\n )", "def test_upsert_global_template_as_anonymous_with_access_right_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.global_template, request=mock_request\n )", "def test_upsert_global_template_as_user_raises_access_control_error(self):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.global_template, request=mock_request\n )", "def test_upsert_other_users_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user2_template, request=mock_request\n )", "def test_upsert_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_upsert_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_upsert_own_template_as_user_saves(self):\n mock_request = create_mock_request(user=self.user1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_upsert_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user2_template, request=mock_request\n )", "def test_upsert_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.user2_template, request=mock_request)", "def test_set_display_name_user_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_upsert_global_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_upsert_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_update_template_registration(self):\n pass", "def test_get_user_template_as_anonymous_raises_access_control_error(self):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.get_by_id(\n self.fixture.user1_template.id, request=mock_request\n )", "def test_set_display_name_user_template_as_anonymous_with_access_right_access_raises_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_replace_user(self):\n pass", "def test_get_user_template_as_anonymous_with_access_right_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.get_by_id(\n self.fixture.user1_template.id, request=mock_request\n )", "def test_anonymous_user_update_anoymous_taskrun(self):\r\n\r\n with self.flask_app.test_request_context('/'):\r\n anonymous_taskrun = AnonymousTaskRunFactory.create()\r\n\r\n assert_raises(Unauthorized,\r\n getattr(require, 'taskrun').update,\r\n anonymous_taskrun)", "def test_post_update_regular_user(self):\n url = reverse('post-detail', kwargs={'pk': self.post.id})\n user_url = reverse('user-detail', kwargs={'pk': self.superuser.id})\n self.client.force_authenticate(user=self.user)\n title = 'Random New Title'\n body = 'Random New Body'\n response = self.client.put(url, {'title': title, 'body': body, 'user': user_url}, format='json')\n self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)", "def test_set_display_name_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_delete_user_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.delete(\n self.fixture.user1_template, request=mock_request\n )", "def test_post_update_unauthorized(self):\n url = reverse('post-detail', kwargs={'pk': self.post.id})\n user_url = reverse('user-detail', kwargs={'pk': self.superuser.id})\n title = 'Random New Title'\n body = 'Random New Body'\n response = self.client.put(url, {'title': title, 'body': body, 'user': user_url}, format='json')\n self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)", "def test_anonymous_user_update_user_taskrun(self):\r\n with self.flask_app.test_request_context('/'):\r\n user_taskrun = TaskRunFactory.create()\r\n\r\n assert_raises(Unauthorized,\r\n getattr(require, 'taskrun').update,\r\n user_taskrun)", "def test_set_display_name_global_template_as_anonymous_with_access_right_access_raises_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_get_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )", "def test_set_display_name_global_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_not_creator_cannot_update(self):\n\n logged_user = utils.create_user_and_authenticate(self)\n self.group.users.add(logged_user)\n expected_url = reverse('my_groups_view')\n\n utils.test_cannot_access(self, self.url,\n expected_url=expected_url,\n data=self.data)", "def test_not_logged_in(self):\n self.request.user = None\n result = user_id_put_view(self.request)['d']\n self.assertEqual(result, error_dict('api_errors', 'not authenticated for this request'))", "def test_delete_user_template_as_anonymous_with_access_right_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.delete(\n self.fixture.user1_template, request=mock_request\n )" ]

[ "0.79757524", "0.78699815", "0.77971363", "0.7779306", "0.7315423", "0.7268201", "0.72340584", "0.71491605", "0.711088", "0.70220673", "0.66764414", "0.6670372", "0.66626596", "0.6651719", "0.656055", "0.65165913", "0.6485727", "0.64777356", "0.64196575", "0.6418435", "0.64110607", "0.640406", "0.63888854", "0.6337296", "0.6316503", "0.6288584", "0.62806493", "0.62736815", "0.6254986", "0.62276226" ]

[ "def test_upsert_user_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user1_template, request=mock_request\n )", "def test_upsert_global_template_as_user_raises_access_control_error(self):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.global_template, request=mock_request\n )", "def test_upsert_global_template_as_anonymous_with_access_right_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.global_template, request=mock_request\n )", "def test_upsert_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.global_template, request=mock_request\n )", "def test_upsert_other_users_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user2_template, request=mock_request\n )", "def test_upsert_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user2_template, request=mock_request\n )", "def test_upsert_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_upsert_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_upsert_own_template_as_user_saves(self):\n mock_request = create_mock_request(user=self.user1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_upsert_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.user2_template, request=mock_request)", "def test_get_user_template_as_anonymous_with_access_right_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.get_by_id(\n self.fixture.user1_template.id, request=mock_request\n )", "def test_set_display_name_user_template_as_anonymous_with_access_right_access_raises_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_upsert_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_get_user_template_as_anonymous_raises_access_control_error(self):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.get_by_id(\n self.fixture.user1_template.id, request=mock_request\n )", "def test_upsert_global_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_update_template_registration(self):\n pass", "def test_set_display_name_user_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_post_update_regular_user(self):\n url = reverse('post-detail', kwargs={'pk': self.post.id})\n user_url = reverse('user-detail', kwargs={'pk': self.superuser.id})\n self.client.force_authenticate(user=self.user)\n title = 'Random New Title'\n body = 'Random New Body'\n response = self.client.put(url, {'title': title, 'body': body, 'user': user_url}, format='json')\n self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)", "def test_delete_user_template_as_anonymous_with_access_right_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.delete(\n self.fixture.user1_template, request=mock_request\n )", "def test_post_update_unauthorized(self):\n url = reverse('post-detail', kwargs={'pk': self.post.id})\n user_url = reverse('user-detail', kwargs={'pk': self.superuser.id})\n title = 'Random New Title'\n body = 'Random New Body'\n response = self.client.put(url, {'title': title, 'body': body, 'user': user_url}, format='json')\n self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)", "def test_not_creator_cannot_update(self):\n\n logged_user = utils.create_user_and_authenticate(self)\n self.group.users.add(logged_user)\n expected_url = reverse('my_groups_view')\n\n utils.test_cannot_access(self, self.url,\n expected_url=expected_url,\n data=self.data)", "def test_replace_user(self):\n pass", "def test_delete_user_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.delete(\n self.fixture.user1_template, request=mock_request\n )", "def test_set_display_name_global_template_as_anonymous_with_access_right_access_raises_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_update_by_non_owner(self):\n # User 1\n saved1 = self.create_article()\n article_url = saved1[0]\n # get user2 details\n token = self.create_article_user2()\n response = self.test_client.put(article_url,self.article_update_data, format='json', HTTP_AUTHORIZATION=token)\n self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)", "def test_anonymous_user_update_anoymous_taskrun(self):\r\n\r\n with self.flask_app.test_request_context('/'):\r\n anonymous_taskrun = AnonymousTaskRunFactory.create()\r\n\r\n assert_raises(Unauthorized,\r\n getattr(require, 'taskrun').update,\r\n anonymous_taskrun)", "def test_put_non_owner(self):\n another_user = CustomUser.objects.create(id=1067, email='[email protected]', is_active=True)\n another_user.set_password('testpassword')\n another_user.save()\n\n self.client.login(email='[email protected]', password='testpassword')\n\n data = {\n 'week_day': 3\n }\n\n url = reverse('notification',\n kwargs={'way_id': self.notification.way_id, 'notification_id': self.notification.id})\n response = self.client.put(url, json.dumps(data, cls=DjangoJSONEncoder), content_type='application/json')\n self.assertEqual(response.status_code, 403)", "def test_anonymous_user_update_user_taskrun(self):\r\n with self.flask_app.test_request_context('/'):\r\n user_taskrun = TaskRunFactory.create()\r\n\r\n assert_raises(Unauthorized,\r\n getattr(require, 'taskrun').update,\r\n user_taskrun)", "def test_delete_global_template_as_user_raises_access_control_error(self):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.delete(\n self.fixture.global_template, request=mock_request\n )" ]

[ "0.80965334", "0.7977133", "0.7963794", "0.7793425", "0.7664125", "0.7498813", "0.72754526", "0.7163729", "0.71102697", "0.708983", "0.6803297", "0.6699159", "0.6673843", "0.6615065", "0.66076845", "0.66003054", "0.6594539", "0.65447944", "0.6544686", "0.65272033", "0.64977634", "0.6496953", "0.6473507", "0.6436947", "0.6425713", "0.6418514", "0.64179814", "0.635491", "0.6345167", "0.63288957" ]

[ "def test_upsert_global_template_as_anonymous_with_access_right_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.global_template, request=mock_request\n )", "def test_upsert_global_template_as_user_raises_access_control_error(self):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.global_template, request=mock_request\n )", "def test_upsert_user_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user1_template, request=mock_request\n )", "def test_upsert_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_upsert_user_template_as_anonymous_with_access_right_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user1_template, request=mock_request\n )", "def test_update_template_registration(self):\n pass", "def test_upsert_global_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_upsert_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_upsert_own_template_as_user_saves(self):\n mock_request = create_mock_request(user=self.user1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_upsert_other_users_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user2_template, request=mock_request\n )", "def test_no_template(self):\n distillery = Distillery.objects.get_by_natural_key(\n 'mongodb.test_database.test_docs')\n try:\n distillery.save()\n except AttributeError:\n self.fail('put_template() raised AttributeError unexpectedly')", "def test_upsert_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.user2_template, request=mock_request)", "def test_unshare_template_registration(self):\n pass", "def test_upsert_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user2_template, request=mock_request\n )", "def test_register_template(self):\n pass", "def test_share_template_registration(self):\n pass", "def test_upsert_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_update_template_subscription(self):\n pass", "def test_replace_namespaced_template(self):\n pass", "def test_get_global_template_as_anonymous_with_access_right_returns_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n template = template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.global_template)", "def test_update_activity_template(self):\n pass", "def test_set_display_name_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_get_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )", "def test_patch_namespaced_template(self):\n pass", "def test_set_display_name_global_template_as_anonymous_with_access_right_access_raises_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_delete_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.delete(\n self.fixture.global_template, request=mock_request\n )", "def test_retrieve_template_registration(self):\n pass", "def test_invalidate_template_cache_in_virtualization_realm(self):\n pass", "def test_update_template_profile_for_system_module(self):\n pass", "def test_set_display_name_global_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )" ]

[ "0.7650722", "0.756786", "0.73319674", "0.72709674", "0.71599734", "0.6970519", "0.68684846", "0.67423", "0.65906715", "0.6536628", "0.64568055", "0.64072675", "0.6396326", "0.6376108", "0.6357626", "0.63539773", "0.6263191", "0.6222696", "0.6143397", "0.6139016", "0.6118972", "0.60936224", "0.6063915", "0.6031473", "0.59694725", "0.59293234", "0.5908521", "0.58814085", "0.587513", "0.5859355" ]

[ "def test_upsert_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.global_template, request=mock_request\n )", "def test_upsert_global_template_as_user_raises_access_control_error(self):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.global_template, request=mock_request\n )", "def test_upsert_user_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user1_template, request=mock_request\n )", "def test_upsert_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_upsert_user_template_as_anonymous_with_access_right_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user1_template, request=mock_request\n )", "def test_update_template_registration(self):\n pass", "def test_upsert_global_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_upsert_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_upsert_own_template_as_user_saves(self):\n mock_request = create_mock_request(user=self.user1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_upsert_other_users_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user2_template, request=mock_request\n )", "def test_no_template(self):\n distillery = Distillery.objects.get_by_natural_key(\n 'mongodb.test_database.test_docs')\n try:\n distillery.save()\n except AttributeError:\n self.fail('put_template() raised AttributeError unexpectedly')", "def test_upsert_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.user2_template, request=mock_request)", "def test_unshare_template_registration(self):\n pass", "def test_upsert_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user2_template, request=mock_request\n )", "def test_register_template(self):\n pass", "def test_share_template_registration(self):\n pass", "def test_upsert_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_update_template_subscription(self):\n pass", "def test_replace_namespaced_template(self):\n pass", "def test_get_global_template_as_anonymous_with_access_right_returns_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n template = template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.global_template)", "def test_update_activity_template(self):\n pass", "def test_set_display_name_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_get_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )", "def test_patch_namespaced_template(self):\n pass", "def test_set_display_name_global_template_as_anonymous_with_access_right_access_raises_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_delete_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.delete(\n self.fixture.global_template, request=mock_request\n )", "def test_retrieve_template_registration(self):\n pass", "def test_invalidate_template_cache_in_virtualization_realm(self):\n pass", "def test_update_template_profile_for_system_module(self):\n pass", "def test_set_display_name_global_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )" ]

[ "0.7756423", "0.75673836", "0.7331551", "0.7270877", "0.7159347", "0.6970686", "0.6868954", "0.6742805", "0.65919876", "0.6536369", "0.6457105", "0.6407503", "0.6395695", "0.63756883", "0.6357793", "0.6353528", "0.62642133", "0.6223189", "0.6144017", "0.61375785", "0.61193377", "0.6092641", "0.60622394", "0.6031787", "0.5968342", "0.59273356", "0.59084797", "0.5879845", "0.58750254", "0.58585554" ]

[ "def test_upsert_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_upsert_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_upsert_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.user2_template, request=mock_request)", "def test_upsert_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_upsert_global_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_update_template_registration(self):\n pass", "def test_upsert_user(self):\n db = database.Database()\n db.upsert_user('nick', 100, 100)\n\n the_args, _ = db._cursor.execute.call_args\n sql = the_args[0]\n expected_sql = 'INSERT INTO quota_violations (username, triggered, last_notified)\\n VALUES (%s, %s, %s)\\n ON CONFLICT (username)\\n DO UPDATE SET\\n (triggered, last_notified)\\n = (EXCLUDED.triggered, EXCLUDED.last_notified);\\n '\n\n self.assertEqual(sql, expected_sql)", "def test_upsert_global_template_as_user_raises_access_control_error(self):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.global_template, request=mock_request\n )", "def test_upsert_profile(mocker, mock_es_profile_serializer, user):\n patched_task = mocker.patch(\"search.search_index_helpers.tasks.upsert_profile\")\n upsert_profile(user.profile.id)\n patched_task.assert_called_once_with(user.profile.id)", "def test_delete_own_template_as_user_saves(self):\n mock_request = create_mock_request(user=self.user1)\n template_api.delete(self.fixture.user1_template, request=mock_request)", "def test_upsert_other_users_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user2_template, request=mock_request\n )", "def upsert(self, context: dict=None) -> None:\n assert(context.get('data', None) is not None)\n\n data = context.get('data', None)\n\n logging.info(f\"Upsert: {data}\")\n try:\n user_record = self.table.first(formula=f\"username='{data['username']}'\")\n user_id = user_record['id'] if user_record else None\n if user_id:\n self.table.update(user_id, fields=data, replace=True, typecast=True)\n else:\n self.table.create(fields=data, typecast=True)\n except Exception as ex:\n self.close_database()\n raise DatabaseError({\n \"code\": f\"Airtable exception\",\n \"description\": f'Database: `{self.db_name}`\\n`upsert({data})`\\nEnsure DB entities exist',\n \"message\": str(ex),\n }, 500)", "def test_is_data_in_template_and_database_same(self):\n SimplePersonFactory.create()\n contact = Person.objects.last()\n self.assertEqual(check_content_in_template(contact), True)\n contact.name = \"test_is_data_in_template_and_database_same\"\n contact.save()\n self.assertEqual(check_content_in_template(contact), True)", "def test_upsert_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user2_template, request=mock_request\n )", "def test_update_template_subscription(self):\n pass", "def test_delete_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.delete(self.fixture.user1_template, request=mock_request)", "def test_update_activity_template(self):\n pass", "def test_update_useruser_uuid_put(self):\n pass", "def test_06_datastore_upsert(self, Mock):\r\n html_request = FakeRequest(json.dumps(self.task_upsert), 200,\r\n {'content-type': 'application/json'})\r\n\r\n record = dict(info=dict(foo=\"bar\"))\r\n Mock.return_value = html_request\r\n with self.flask_app.test_request_context('/'):\r\n out = self.ckan.datastore_upsert(name='task',\r\n records=json.dumps([record]),\r\n resource_id=self.task_resource_id)\r\n err_msg = \"It should return True\"\r\n assert out is True, err_msg\r\n # Check the error\r\n Mock.return_value = self.server_error\r\n try:\r\n self.ckan.datastore_upsert(name='task',\r\n records=json.dumps([record]),\r\n resource_id=self.task_resource_id)\r\n except Exception as out:\r\n type, msg, status_code = out.args\r\n assert \"Server Error\" in msg, msg\r\n assert 500 == status_code, status_code\r\n assert \"CKAN: the remote site failed! datastore_upsert failed\" == type, type", "def test_update_user(self):\n pass", "def test_no_template(self):\n distillery = Distillery.objects.get_by_natural_key(\n 'mongodb.test_database.test_docs')\n try:\n distillery.save()\n except AttributeError:\n self.fail('put_template() raised AttributeError unexpectedly')", "def test_api_user_put(self):\n pass", "def test_upsert_user_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user1_template, request=mock_request\n )", "def test_collection_saved(self, mock_template):\n collection = Collection.objects.get_by_natural_key(\n 'elasticsearch', 'test_index', 'test_docs')\n collection.save()\n self.assertEqual(mock_template.call_count, 1)", "def test_update_template_success(self):\n template_id = util.MOCK_UUID_1\n template_name = \"template-3\"\n\n rv = TEST_CLIENT.patch(\n f\"/templates/{template_id}\", json={\"name\": template_name}\n )\n result = rv.json()\n\n expected = {\n \"uuid\": template_id,\n \"name\": template_name,\n \"tasks\": [\n {\n \"uuid\": util.MOCK_UUID_1,\n \"task_id\": util.MOCK_UUID_1,\n \"dependencies\": [],\n \"position_x\": 0.0,\n \"position_y\": 0.0,\n }\n ],\n \"experimentId\": util.MOCK_UUID_1,\n \"deploymentId\": None,\n \"createdAt\": util.MOCK_CREATED_AT_1.isoformat(),\n \"updatedAt\": mock.ANY,\n }\n self.assertEqual(result, expected)\n self.assertEqual(rv.status_code, 200)", "def test_replace_user(self):\n pass", "def post(self):\n self.reqparse.add_argument('templateName', type=str, required=True)\n self.reqparse.add_argument('template', type=str, required=True)\n args = self.reqparse.parse_args()\n\n template = db.Template.find_one(template_name=args['templateName'])\n if template:\n return self.make_response('Template already exists, update the existing template instead', HTTP.CONFLICT)\n\n template = Template()\n template.template_name = args['templateName']\n template.template = args['template']\n\n db.session.add(template)\n db.session.commit()\n auditlog(event='template.create', actor=session['user'].username, data=args)\n\n return self.make_response('Template {} has been created'.format(template.template_name), HTTP.CREATED)", "def test_createUser_single(self):\n #TODO: this and other tests", "def upsert_location(self, location):", "def test_register_template(self):\n pass" ]

[ "0.8351025", "0.80516064", "0.8045996", "0.8009917", "0.7813934", "0.6972186", "0.678505", "0.6546894", "0.63948953", "0.63871586", "0.6360882", "0.6320311", "0.63129383", "0.61979985", "0.6153889", "0.61455595", "0.61436296", "0.6135426", "0.6107875", "0.6063069", "0.6057141", "0.60564005", "0.6055595", "0.6018213", "0.5990856", "0.59901106", "0.59875154", "0.5979962", "0.59781814", "0.59447676" ]

[ "def test_upsert_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.user2_template, request=mock_request)", "def test_upsert_own_template_as_user_saves(self):\n mock_request = create_mock_request(user=self.user1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_upsert_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_upsert_global_template_as_user_raises_access_control_error(self):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.global_template, request=mock_request\n )", "def test_upsert_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user2_template, request=mock_request\n )", "def test_upsert_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_upsert_user_template_as_anonymous_with_access_right_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user1_template, request=mock_request\n )", "def test_upsert_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_upsert_user_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user1_template, request=mock_request\n )", "def test_upsert_global_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_upsert_global_template_as_anonymous_with_access_right_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.global_template, request=mock_request\n )", "def test_upsert_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.global_template, request=mock_request\n )", "def test_not_creator_cannot_update(self):\n\n logged_user = utils.create_user_and_authenticate(self)\n self.group.users.add(logged_user)\n expected_url = reverse('my_groups_view')\n\n utils.test_cannot_access(self, self.url,\n expected_url=expected_url,\n data=self.data)", "def test_update_template_registration(self):\n pass", "def test_delete_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.delete(self.fixture.user2_template, request=mock_request)", "def test_replace_user(self):\n pass", "def test_set_display_name_other_users_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_delete_other_users_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.delete(\n self.fixture.user2_template, request=mock_request\n )", "def test_update_by_non_owner(self):\n # User 1\n saved1 = self.create_article()\n article_url = saved1[0]\n # get user2 details\n token = self.create_article_user2()\n response = self.test_client.put(article_url,self.article_update_data, format='json', HTTP_AUTHORIZATION=token)\n self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)", "def test_upsert_user(self):\n db = database.Database()\n db.upsert_user('nick', 100, 100)\n\n the_args, _ = db._cursor.execute.call_args\n sql = the_args[0]\n expected_sql = 'INSERT INTO quota_violations (username, triggered, last_notified)\\n VALUES (%s, %s, %s)\\n ON CONFLICT (username)\\n DO UPDATE SET\\n (triggered, last_notified)\\n = (EXCLUDED.triggered, EXCLUDED.last_notified);\\n '\n\n self.assertEqual(sql, expected_sql)", "def test_admin_cannot_update_non_existant_user(self):\n resp = self.admin_create_user()\n reply = self.admin_login()\n token = reply['token']\n user = dict(\n name='Summer Lover',\n username='lover',\n password='Andela8',\n role='attendant'\n )\n resp = self.client.put(\n '/api/v1/users/5',\n content_type='application/json',\n data=json.dumps(user),\n headers={'Authorization': 'Bearer {}'.format(token)}\n )\n reply = json.loads(resp.data.decode())\n self.assertEqual(reply['message'], \"This user doesn't exist!\")\n self.assertEqual(resp.status_code, 400)", "def test_get_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.get_by_id(\n self.fixture.user2_template.id, request=mock_request\n )", "def test_post_update_regular_user(self):\n url = reverse('post-detail', kwargs={'pk': self.post.id})\n user_url = reverse('user-detail', kwargs={'pk': self.superuser.id})\n self.client.force_authenticate(user=self.user)\n title = 'Random New Title'\n body = 'Random New Body'\n response = self.client.put(url, {'title': title, 'body': body, 'user': user_url}, format='json')\n self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)", "def test_delete_own_template_as_user_saves(self):\n mock_request = create_mock_request(user=self.user1)\n template_api.delete(self.fixture.user1_template, request=mock_request)", "def test_delete_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.delete(self.fixture.user1_template, request=mock_request)", "def test_updateview_write_for_wrong_user(self):\n\n for user in self.users:\n updateview = reverse('account_update', args=(user.uuid,))\n other_users = self.users\n other_users.remove(user)\n random_user = random.choice(other_users)\n\n self.client.login(email=random_user.email, password='letmein')\n\n valid_data = {'email': user.email, 'first_name': user.first_name,\n 'last_name': user.last_name, 'language': user.language}\n invalid_data = valid_data.copy()\n invalid_data['email'] = 'invalid_email_address'\n valid_data_response = self.client.post(updateview, valid_data)\n invalid_data_response = self.client.post(updateview, invalid_data)\n\n self.assertEqual(valid_data_response.status_code, 403)\n self.assertEqual(invalid_data_response.status_code, 403)", "def test_get_other_users_template_raises_access_control_error(self):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.get_by_id(\n self.fixture.user2_template.id, request=mock_request\n )", "def test_delete_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.delete(\n self.fixture.user2_template, request=mock_request\n )", "def test_update_user(self):\n pass", "def test_not_creator_cannot_update_tab(self):\n\n logged_user = utils.create_user_and_authenticate(self)\n self.group.users.add(logged_user)\n expected_url = reverse('group_view', args=(self.group.pk,))\n\n utils.test_cannot_access(self, self.url, expected_url, self.data)" ]

[ "0.820034", "0.8083881", "0.8039612", "0.80145544", "0.80041873", "0.76042765", "0.7525442", "0.7524677", "0.7430861", "0.7153691", "0.7078404", "0.69165915", "0.67743903", "0.6736194", "0.6717341", "0.6690355", "0.6580235", "0.65308565", "0.6507076", "0.6504665", "0.6474388", "0.6453021", "0.6449245", "0.6447113", "0.6443009", "0.6431808", "0.6425109", "0.6398658", "0.63973486", "0.6363779" ]

[ "def test_upsert_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_upsert_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_upsert_own_template_as_user_saves(self):\n mock_request = create_mock_request(user=self.user1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_upsert_global_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_upsert_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.user2_template, request=mock_request)", "def test_upsert_global_template_as_anonymous_with_access_right_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.global_template, request=mock_request\n )", "def test_upsert_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.global_template, request=mock_request\n )", "def test_upsert_other_users_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user2_template, request=mock_request\n )", "def test_upsert_user_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user1_template, request=mock_request\n )", "def test_upsert_user_template_as_anonymous_with_access_right_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user1_template, request=mock_request\n )", "def test_upsert_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user2_template, request=mock_request\n )", "def test_update_template_registration(self):\n pass", "def test_upsert_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_share_template_registration(self):\n pass", "def test_delete_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.delete(self.fixture.global_template, request=mock_request)", "def test_set_display_name_global_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_replace_user(self):\n pass", "def test_unshare_template_registration(self):\n pass", "def test_delete_global_template_as_user_raises_access_control_error(self):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.delete(\n self.fixture.global_template, request=mock_request\n )", "def test_update_template_profile_for_system_module(self):\n pass", "def test_register_template(self):\n pass", "def test_no_template(self):\n distillery = Distillery.objects.get_by_natural_key(\n 'mongodb.test_database.test_docs')\n try:\n distillery.save()\n except AttributeError:\n self.fail('put_template() raised AttributeError unexpectedly')", "def test_functionality(self):\n templateName = \"Test Template\"\n self.browserObject = globalVars.browserObject\n \n #Check for current logged in user\n self.verifyCurrentUser(userRole='Administrator', loginAsUser=True)\n \n #Deleting Standard User\n userList = self.getLocalUsers(userName=globalVars.standardUser)\n if len(userList) > 0:\n self.deleteLocalUser(globalVars.standardUser, verifyUser=True)\n \n #Creates Sample Template if not exists\n self.createSampleTemplate(templateName=templateName, deleteAndCreate=True, publishedTemplate=True)", "def test_update_activity_template(self):\n pass", "async def test_rendering_template_admin(\n hass: HomeAssistant, mock_api_client: TestClient, hass_admin_user: MockUser\n) -> None:\n hass_admin_user.groups = []\n resp = await mock_api_client.post(const.URL_API_TEMPLATE)\n assert resp.status == HTTPStatus.UNAUTHORIZED", "def test_global_template_as_user_returns_template(self):\n mock_request = create_mock_request(user=self.user1)\n template = template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.global_template)", "def test_post_update_regular_user(self):\n url = reverse('post-detail', kwargs={'pk': self.post.id})\n user_url = reverse('user-detail', kwargs={'pk': self.superuser.id})\n self.client.force_authenticate(user=self.user)\n title = 'Random New Title'\n body = 'Random New Body'\n response = self.client.put(url, {'title': title, 'body': body, 'user': user_url}, format='json')\n self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)", "def test_update_template_subscription(self):\n pass", "def test_delete_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.delete(self.fixture.user1_template, request=mock_request)", "def test_retrieve_template_registration(self):\n pass" ]

[ "0.8106673", "0.76909196", "0.7503215", "0.7482491", "0.7482349", "0.747998", "0.74361557", "0.7395664", "0.7269864", "0.72538686", "0.72130823", "0.7131496", "0.701815", "0.6556384", "0.65447783", "0.6527001", "0.64378923", "0.6381135", "0.6367743", "0.6320074", "0.63030666", "0.6258095", "0.62367326", "0.6224009", "0.6196587", "0.6176663", "0.613376", "0.6124334", "0.6122764", "0.6072628" ]

[ "def test_upsert_global_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_upsert_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_upsert_own_template_as_user_saves(self):\n mock_request = create_mock_request(user=self.user1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_upsert_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_upsert_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.user2_template, request=mock_request)", "def test_update_template_registration(self):\n pass", "def test_is_data_in_template_and_database_same(self):\n SimplePersonFactory.create()\n contact = Person.objects.last()\n self.assertEqual(check_content_in_template(contact), True)\n contact.name = \"test_is_data_in_template_and_database_same\"\n contact.save()\n self.assertEqual(check_content_in_template(contact), True)", "def test_update_activity_template(self):\n pass", "def test_upsert_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user2_template, request=mock_request\n )", "def test_delete_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.delete(self.fixture.user1_template, request=mock_request)", "def test_team_template_folders_id_templates_fk_put(self):\n pass", "def test_team_template_folders_id_put(self):\n pass", "def test_no_template(self):\n distillery = Distillery.objects.get_by_natural_key(\n 'mongodb.test_database.test_docs')\n try:\n distillery.save()\n except AttributeError:\n self.fail('put_template() raised AttributeError unexpectedly')", "def test_06_datastore_upsert(self, Mock):\r\n html_request = FakeRequest(json.dumps(self.task_upsert), 200,\r\n {'content-type': 'application/json'})\r\n\r\n record = dict(info=dict(foo=\"bar\"))\r\n Mock.return_value = html_request\r\n with self.flask_app.test_request_context('/'):\r\n out = self.ckan.datastore_upsert(name='task',\r\n records=json.dumps([record]),\r\n resource_id=self.task_resource_id)\r\n err_msg = \"It should return True\"\r\n assert out is True, err_msg\r\n # Check the error\r\n Mock.return_value = self.server_error\r\n try:\r\n self.ckan.datastore_upsert(name='task',\r\n records=json.dumps([record]),\r\n resource_id=self.task_resource_id)\r\n except Exception as out:\r\n type, msg, status_code = out.args\r\n assert \"Server Error\" in msg, msg\r\n assert 500 == status_code, status_code\r\n assert \"CKAN: the remote site failed! datastore_upsert failed\" == type, type", "def test_update_template_subscription(self):\n pass", "def test_team_template_folders_id_replace_post(self):\n pass", "def test_upsert_content_file(mocker):\n patched_task = mocker.patch(\"search.tasks.upsert_content_file\")\n content_file = ContentFileFactory.create()\n upsert_content_file(content_file.id)\n patched_task.assert_called_once_with(content_file.id)", "def test_collection_saved(self, mock_template):\n collection = Collection.objects.get_by_natural_key(\n 'elasticsearch', 'test_index', 'test_docs')\n collection.save()\n self.assertEqual(mock_template.call_count, 1)", "def test_distillery_saved(self, mock_template):\n distillery = Distillery.objects.get_by_natural_key(\n 'elasticsearch.test_index.test_docs')\n distillery.save()\n self.assertEqual(mock_template.call_count, 1)", "def upsert_location(self, location):", "def test_update_template_success(self):\n template_id = util.MOCK_UUID_1\n template_name = \"template-3\"\n\n rv = TEST_CLIENT.patch(\n f\"/templates/{template_id}\", json={\"name\": template_name}\n )\n result = rv.json()\n\n expected = {\n \"uuid\": template_id,\n \"name\": template_name,\n \"tasks\": [\n {\n \"uuid\": util.MOCK_UUID_1,\n \"task_id\": util.MOCK_UUID_1,\n \"dependencies\": [],\n \"position_x\": 0.0,\n \"position_y\": 0.0,\n }\n ],\n \"experimentId\": util.MOCK_UUID_1,\n \"deploymentId\": None,\n \"createdAt\": util.MOCK_CREATED_AT_1.isoformat(),\n \"updatedAt\": mock.ANY,\n }\n self.assertEqual(result, expected)\n self.assertEqual(rv.status_code, 200)", "def test_delete_global_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.delete(self.fixture.global_template, request=mock_request)", "def test_xml_template_set(self):\n xmlTemplateResult = XmlTemplate.objects.get(id=1)\n xmlTemplateResult.set(\"newTemplate\", '''<?xml >\n <project name=\"newTemplate\">\n </project> ''',)\n self.assertEqual(xmlTemplateResult.template_name, \"newTemplate\")\n self.assertEqual(xmlTemplateResult.template_content, '''<?xml >\n <project name=\"newTemplate\">\n </project> ''')", "def test_upsert_global_template_as_user_raises_access_control_error(self):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.global_template, request=mock_request\n )", "def test_upsert_user(self):\n db = database.Database()\n db.upsert_user('nick', 100, 100)\n\n the_args, _ = db._cursor.execute.call_args\n sql = the_args[0]\n expected_sql = 'INSERT INTO quota_violations (username, triggered, last_notified)\\n VALUES (%s, %s, %s)\\n ON CONFLICT (username)\\n DO UPDATE SET\\n (triggered, last_notified)\\n = (EXCLUDED.triggered, EXCLUDED.last_notified);\\n '\n\n self.assertEqual(sql, expected_sql)", "def test_register_template(self):\n pass", "def test_06_datastore_upsert_without_resource_id(self, Mock):\r\n html_request = FakeRequest(json.dumps(self.task_upsert), 200,\r\n {'content-type': 'application/json'})\r\n\r\n record = dict(info=dict(foo=\"bar\"))\r\n Mock.return_value = html_request\r\n with self.flask_app.test_request_context('/'):\r\n out = self.ckan.datastore_upsert(name='task',\r\n records=json.dumps([record]),\r\n resource_id=None)\r\n err_msg = \"It should return True\"\r\n assert out is True, err_msg\r\n # Check the error\r\n Mock.return_value = self.server_error\r\n try:\r\n self.ckan.datastore_upsert(name='task',\r\n records=json.dumps([record]),\r\n resource_id=self.task_resource_id)\r\n except Exception as out:\r\n type, msg, status_code = out.args\r\n assert \"Server Error\" in msg, msg\r\n assert 500 == status_code, status_code\r\n assert \"CKAN: the remote site failed! datastore_upsert failed\" == type, type", "def test_delete_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.delete(self.fixture.user1_template, request=mock_request)", "def test_set_display_name_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_collection_put(testapp, execute_counter):\n initial = {\n 'title': \"Testing\",\n 'type': \"object\", # include a non-required field\n 'description': \"This is the initial insert\",\n }\n item_url = testapp.post_json('/embedding-tests', initial).location\n\n with execute_counter.expect(1):\n item = testapp.get(item_url).json\n\n for key in initial:\n assert item[key] == initial[key]\n\n update = {\n 'title': \"New Testing\",\n 'type': \"object\",\n 'description': \"This is the updated insert\",\n }\n testapp.put_json(item_url, update, status=200)\n\n res = testapp.get('/' + item['uuid']).follow().json\n\n for key in update:\n assert res[key] == update[key]" ]

[ "0.8371305", "0.80961037", "0.8029739", "0.7766117", "0.7704741", "0.70811933", "0.6713066", "0.648494", "0.64786816", "0.6461537", "0.6387213", "0.638419", "0.63225466", "0.6304995", "0.63047177", "0.62928706", "0.62527716", "0.6247133", "0.6220966", "0.62020767", "0.6166314", "0.6128568", "0.61061525", "0.6092912", "0.6081847", "0.6068162", "0.6007954", "0.5989855", "0.5960996", "0.5954581" ]

[ "def test_upsert_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.user2_template, request=mock_request)", "def test_upsert_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_upsert_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_upsert_other_users_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user2_template, request=mock_request\n )", "def test_upsert_own_template_as_user_saves(self):\n mock_request = create_mock_request(user=self.user1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_upsert_global_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_upsert_global_template_as_user_raises_access_control_error(self):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.global_template, request=mock_request\n )", "def test_upsert_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_upsert_user_template_as_anonymous_with_access_right_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user1_template, request=mock_request\n )", "def test_upsert_user_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user1_template, request=mock_request\n )", "def test_upsert_global_template_as_anonymous_with_access_right_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.global_template, request=mock_request\n )", "def test_get_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.get_by_id(\n self.fixture.user2_template.id, request=mock_request\n )", "def test_not_creator_cannot_update(self):\n\n logged_user = utils.create_user_and_authenticate(self)\n self.group.users.add(logged_user)\n expected_url = reverse('my_groups_view')\n\n utils.test_cannot_access(self, self.url,\n expected_url=expected_url,\n data=self.data)", "def test_upsert_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.global_template, request=mock_request\n )", "def test_update_template_registration(self):\n pass", "def test_set_display_name_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_delete_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.delete(\n self.fixture.user2_template, request=mock_request\n )", "def test_delete_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.delete(self.fixture.user2_template, request=mock_request)", "def test_replace_user(self):\n pass", "def test_delete_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.delete(self.fixture.user1_template, request=mock_request)", "def test_post_update_regular_user(self):\n url = reverse('post-detail', kwargs={'pk': self.post.id})\n user_url = reverse('user-detail', kwargs={'pk': self.superuser.id})\n self.client.force_authenticate(user=self.user)\n title = 'Random New Title'\n body = 'Random New Body'\n response = self.client.put(url, {'title': title, 'body': body, 'user': user_url}, format='json')\n self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)", "def test_delete_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.delete(self.fixture.user1_template, request=mock_request)", "def test_update_by_non_owner(self):\n # User 1\n saved1 = self.create_article()\n article_url = saved1[0]\n # get user2 details\n token = self.create_article_user2()\n response = self.test_client.put(article_url,self.article_update_data, format='json', HTTP_AUTHORIZATION=token)\n self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)", "def test_set_display_name_other_users_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_admin_cannot_update_non_existant_user(self):\n resp = self.admin_create_user()\n reply = self.admin_login()\n token = reply['token']\n user = dict(\n name='Summer Lover',\n username='lover',\n password='Andela8',\n role='attendant'\n )\n resp = self.client.put(\n '/api/v1/users/5',\n content_type='application/json',\n data=json.dumps(user),\n headers={'Authorization': 'Bearer {}'.format(token)}\n )\n reply = json.loads(resp.data.decode())\n self.assertEqual(reply['message'], \"This user doesn't exist!\")\n self.assertEqual(resp.status_code, 400)", "def test_not_creator_cannot_update_tab(self):\n\n logged_user = utils.create_user_and_authenticate(self)\n self.group.users.add(logged_user)\n expected_url = reverse('group_view', args=(self.group.pk,))\n\n utils.test_cannot_access(self, self.url, expected_url, self.data)", "def test_update_user(self):\n pass", "async def test_rendering_template_admin(\n hass: HomeAssistant, mock_api_client: TestClient, hass_admin_user: MockUser\n) -> None:\n hass_admin_user.groups = []\n resp = await mock_api_client.post(const.URL_API_TEMPLATE)\n assert resp.status == HTTPStatus.UNAUTHORIZED", "def test_updateview_write_for_wrong_user(self):\n\n for user in self.users:\n updateview = reverse('account_update', args=(user.uuid,))\n other_users = self.users\n other_users.remove(user)\n random_user = random.choice(other_users)\n\n self.client.login(email=random_user.email, password='letmein')\n\n valid_data = {'email': user.email, 'first_name': user.first_name,\n 'last_name': user.last_name, 'language': user.language}\n invalid_data = valid_data.copy()\n invalid_data['email'] = 'invalid_email_address'\n valid_data_response = self.client.post(updateview, valid_data)\n invalid_data_response = self.client.post(updateview, invalid_data)\n\n self.assertEqual(valid_data_response.status_code, 403)\n self.assertEqual(invalid_data_response.status_code, 403)", "def test_update_self_fail(self):\n new_user = self.create_user('1')\n url = '/0/chefs/' + str(new_user.pk)\n\n headers = self.login()\n resp = self.client.put(url, **headers)\n self.assertInvalidCredentials(resp)" ]

[ "0.8093766", "0.80680555", "0.80376196", "0.7835847", "0.77455807", "0.7744498", "0.76982164", "0.76218945", "0.736171", "0.7214227", "0.7022283", "0.6874125", "0.68300915", "0.68178946", "0.68173504", "0.6804541", "0.67034173", "0.66750884", "0.6632048", "0.6587507", "0.6538", "0.65097654", "0.6508674", "0.64719915", "0.6470846", "0.6451183", "0.6366788", "0.6325715", "0.6317642", "0.62718457" ]

[ "def test_upsert_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_upsert_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_upsert_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_upsert_own_template_as_user_saves(self):\n mock_request = create_mock_request(user=self.user1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_upsert_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.user2_template, request=mock_request)", "def test_update_template_registration(self):\n pass", "def test_delete_global_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.delete(self.fixture.global_template, request=mock_request)", "def test_update_activity_template(self):\n pass", "def test_is_data_in_template_and_database_same(self):\n SimplePersonFactory.create()\n contact = Person.objects.last()\n self.assertEqual(check_content_in_template(contact), True)\n contact.name = \"test_is_data_in_template_and_database_same\"\n contact.save()\n self.assertEqual(check_content_in_template(contact), True)", "def test_team_template_folders_id_put(self):\n pass", "def test_upsert_global_template_as_user_raises_access_control_error(self):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.global_template, request=mock_request\n )", "def test_team_template_folders_id_replace_post(self):\n pass", "def test_update_template_subscription(self):\n pass", "def test_06_datastore_upsert(self, Mock):\r\n html_request = FakeRequest(json.dumps(self.task_upsert), 200,\r\n {'content-type': 'application/json'})\r\n\r\n record = dict(info=dict(foo=\"bar\"))\r\n Mock.return_value = html_request\r\n with self.flask_app.test_request_context('/'):\r\n out = self.ckan.datastore_upsert(name='task',\r\n records=json.dumps([record]),\r\n resource_id=self.task_resource_id)\r\n err_msg = \"It should return True\"\r\n assert out is True, err_msg\r\n # Check the error\r\n Mock.return_value = self.server_error\r\n try:\r\n self.ckan.datastore_upsert(name='task',\r\n records=json.dumps([record]),\r\n resource_id=self.task_resource_id)\r\n except Exception as out:\r\n type, msg, status_code = out.args\r\n assert \"Server Error\" in msg, msg\r\n assert 500 == status_code, status_code\r\n assert \"CKAN: the remote site failed! datastore_upsert failed\" == type, type", "def test_team_template_folders_id_templates_fk_put(self):\n pass", "def test_delete_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.delete(self.fixture.user1_template, request=mock_request)", "def test_register_template(self):\n pass", "def test_no_template(self):\n distillery = Distillery.objects.get_by_natural_key(\n 'mongodb.test_database.test_docs')\n try:\n distillery.save()\n except AttributeError:\n self.fail('put_template() raised AttributeError unexpectedly')", "def test_delete_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.delete(self.fixture.global_template, request=mock_request)", "def test_upsert_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user2_template, request=mock_request\n )", "def test_share_template_registration(self):\n pass", "def upsert_location(self, location):", "def test_set_display_name_global_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_distillery_saved(self, mock_template):\n distillery = Distillery.objects.get_by_natural_key(\n 'elasticsearch.test_index.test_docs')\n distillery.save()\n self.assertEqual(mock_template.call_count, 1)", "def test_update_template_success(self):\n template_id = util.MOCK_UUID_1\n template_name = \"template-3\"\n\n rv = TEST_CLIENT.patch(\n f\"/templates/{template_id}\", json={\"name\": template_name}\n )\n result = rv.json()\n\n expected = {\n \"uuid\": template_id,\n \"name\": template_name,\n \"tasks\": [\n {\n \"uuid\": util.MOCK_UUID_1,\n \"task_id\": util.MOCK_UUID_1,\n \"dependencies\": [],\n \"position_x\": 0.0,\n \"position_y\": 0.0,\n }\n ],\n \"experimentId\": util.MOCK_UUID_1,\n \"deploymentId\": None,\n \"createdAt\": util.MOCK_CREATED_AT_1.isoformat(),\n \"updatedAt\": mock.ANY,\n }\n self.assertEqual(result, expected)\n self.assertEqual(rv.status_code, 200)", "def test_collection_saved(self, mock_template):\n collection = Collection.objects.get_by_natural_key(\n 'elasticsearch', 'test_index', 'test_docs')\n collection.save()\n self.assertEqual(mock_template.call_count, 1)", "def test_06_datastore_upsert_without_resource_id(self, Mock):\r\n html_request = FakeRequest(json.dumps(self.task_upsert), 200,\r\n {'content-type': 'application/json'})\r\n\r\n record = dict(info=dict(foo=\"bar\"))\r\n Mock.return_value = html_request\r\n with self.flask_app.test_request_context('/'):\r\n out = self.ckan.datastore_upsert(name='task',\r\n records=json.dumps([record]),\r\n resource_id=None)\r\n err_msg = \"It should return True\"\r\n assert out is True, err_msg\r\n # Check the error\r\n Mock.return_value = self.server_error\r\n try:\r\n self.ckan.datastore_upsert(name='task',\r\n records=json.dumps([record]),\r\n resource_id=self.task_resource_id)\r\n except Exception as out:\r\n type, msg, status_code = out.args\r\n assert \"Server Error\" in msg, msg\r\n assert 500 == status_code, status_code\r\n assert \"CKAN: the remote site failed! datastore_upsert failed\" == type, type", "def test_retrieve_template_registration(self):\n pass", "def test_xml_template_set(self):\n xmlTemplateResult = XmlTemplate.objects.get(id=1)\n xmlTemplateResult.set(\"newTemplate\", '''<?xml >\n <project name=\"newTemplate\">\n </project> ''',)\n self.assertEqual(xmlTemplateResult.template_name, \"newTemplate\")\n self.assertEqual(xmlTemplateResult.template_content, '''<?xml >\n <project name=\"newTemplate\">\n </project> ''')", "def test_upsert_user(self):\n db = database.Database()\n db.upsert_user('nick', 100, 100)\n\n the_args, _ = db._cursor.execute.call_args\n sql = the_args[0]\n expected_sql = 'INSERT INTO quota_violations (username, triggered, last_notified)\\n VALUES (%s, %s, %s)\\n ON CONFLICT (username)\\n DO UPDATE SET\\n (triggered, last_notified)\\n = (EXCLUDED.triggered, EXCLUDED.last_notified);\\n '\n\n self.assertEqual(sql, expected_sql)" ]

[ "0.817305", "0.8163642", "0.78363234", "0.76788574", "0.7538798", "0.72347766", "0.6604227", "0.64778715", "0.6405772", "0.6319687", "0.62832665", "0.6279908", "0.6232745", "0.62278795", "0.6200194", "0.61855614", "0.6185184", "0.61763513", "0.61297494", "0.6127971", "0.6123756", "0.6084244", "0.6077076", "0.5978184", "0.5977468", "0.59739614", "0.59425527", "0.592405", "0.5897395", "0.5868099" ]

[ "def test_upsert_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_upsert_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.user2_template, request=mock_request)", "def test_upsert_own_template_as_user_saves(self):\n mock_request = create_mock_request(user=self.user1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_upsert_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_upsert_global_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_update_template_registration(self):\n pass", "def test_delete_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.delete(self.fixture.user1_template, request=mock_request)", "def test_upsert_global_template_as_user_raises_access_control_error(self):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.global_template, request=mock_request\n )", "def test_upsert_user(self):\n db = database.Database()\n db.upsert_user('nick', 100, 100)\n\n the_args, _ = db._cursor.execute.call_args\n sql = the_args[0]\n expected_sql = 'INSERT INTO quota_violations (username, triggered, last_notified)\\n VALUES (%s, %s, %s)\\n ON CONFLICT (username)\\n DO UPDATE SET\\n (triggered, last_notified)\\n = (EXCLUDED.triggered, EXCLUDED.last_notified);\\n '\n\n self.assertEqual(sql, expected_sql)", "def test_delete_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.delete(self.fixture.user2_template, request=mock_request)", "def test_upsert_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user2_template, request=mock_request\n )", "def test_upsert_other_users_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user2_template, request=mock_request\n )", "def test_upsert_profile(mocker, mock_es_profile_serializer, user):\n patched_task = mocker.patch(\"search.search_index_helpers.tasks.upsert_profile\")\n upsert_profile(user.profile.id)\n patched_task.assert_called_once_with(user.profile.id)", "def test_post_update_admin(self):\n url = reverse('post-detail', kwargs={'pk': self.post.id})\n user_url = reverse('user-detail', kwargs={'pk': self.superuser.id})\n self.client.force_authenticate(user=self.superuser)\n title = 'Random New Title'\n body = 'Random New Body'\n response = self.client.put(url, {'title': title, 'body': body, 'user': user_url}, format='json')\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n self.assertIn(title, response.content)\n self.assertIn(body, response.content)\n self.assertIn(user_url, response.content)", "def test_delete_own_template_as_user_saves(self):\n mock_request = create_mock_request(user=self.user1)\n template_api.delete(self.fixture.user1_template, request=mock_request)", "def test_delete_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.delete(self.fixture.global_template, request=mock_request)", "def test_post_update_regular_user(self):\n url = reverse('post-detail', kwargs={'pk': self.post.id})\n user_url = reverse('user-detail', kwargs={'pk': self.superuser.id})\n self.client.force_authenticate(user=self.user)\n title = 'Random New Title'\n body = 'Random New Body'\n response = self.client.put(url, {'title': title, 'body': body, 'user': user_url}, format='json')\n self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)", "def test_set_display_name_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_update_template_subscription(self):\n pass", "def test_is_data_in_template_and_database_same(self):\n SimplePersonFactory.create()\n contact = Person.objects.last()\n self.assertEqual(check_content_in_template(contact), True)\n contact.name = \"test_is_data_in_template_and_database_same\"\n contact.save()\n self.assertEqual(check_content_in_template(contact), True)", "def test_customization_template_crud():\n template_crud = pxe.CustomizationTemplate(\n name=generate_random_string(size=8),\n description=generate_random_string(size=16),\n image_type='RHEL-6',\n script_type='Kickstart',\n script_data='Testing the script')\n\n template_crud.create()\n with update(template_crud):\n template_crud.name = template_crud.name + \"_update\"\n template_crud.delete(cancel=False)", "def test_customization_template_crud():\n template_crud = pxe.CustomizationTemplate(\n name=generate_random_string(size=8),\n description=generate_random_string(size=16),\n image_type='RHEL-6',\n script_type='Kickstart',\n script_data='Testing the script')\n\n template_crud.create()\n with update(template_crud):\n template_crud.name = template_crud.name + \"_update\"\n template_crud.delete(cancel=False)", "def test_update_activity_template(self):\n pass", "def test_06_datastore_upsert(self, Mock):\r\n html_request = FakeRequest(json.dumps(self.task_upsert), 200,\r\n {'content-type': 'application/json'})\r\n\r\n record = dict(info=dict(foo=\"bar\"))\r\n Mock.return_value = html_request\r\n with self.flask_app.test_request_context('/'):\r\n out = self.ckan.datastore_upsert(name='task',\r\n records=json.dumps([record]),\r\n resource_id=self.task_resource_id)\r\n err_msg = \"It should return True\"\r\n assert out is True, err_msg\r\n # Check the error\r\n Mock.return_value = self.server_error\r\n try:\r\n self.ckan.datastore_upsert(name='task',\r\n records=json.dumps([record]),\r\n resource_id=self.task_resource_id)\r\n except Exception as out:\r\n type, msg, status_code = out.args\r\n assert \"Server Error\" in msg, msg\r\n assert 500 == status_code, status_code\r\n assert \"CKAN: the remote site failed! datastore_upsert failed\" == type, type", "def test_set_display_name_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_no_template(self):\n distillery = Distillery.objects.get_by_natural_key(\n 'mongodb.test_database.test_docs')\n try:\n distillery.save()\n except AttributeError:\n self.fail('put_template() raised AttributeError unexpectedly')", "def upsert(self, context: dict=None) -> None:\n assert(context.get('data', None) is not None)\n\n data = context.get('data', None)\n\n logging.info(f\"Upsert: {data}\")\n try:\n user_record = self.table.first(formula=f\"username='{data['username']}'\")\n user_id = user_record['id'] if user_record else None\n if user_id:\n self.table.update(user_id, fields=data, replace=True, typecast=True)\n else:\n self.table.create(fields=data, typecast=True)\n except Exception as ex:\n self.close_database()\n raise DatabaseError({\n \"code\": f\"Airtable exception\",\n \"description\": f'Database: `{self.db_name}`\\n`upsert({data})`\\nEnsure DB entities exist',\n \"message\": str(ex),\n }, 500)", "def test_update_useruser_uuid_put(self):\n pass", "def test_delete_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.delete(self.fixture.user1_template, request=mock_request)", "def test_register_template(self):\n pass" ]

[ "0.83650684", "0.8313205", "0.83011836", "0.7990907", "0.77972287", "0.69682634", "0.6701379", "0.6564317", "0.64938676", "0.64082444", "0.63623893", "0.6311204", "0.6286057", "0.6261494", "0.6255452", "0.62456673", "0.6227969", "0.61704993", "0.61659986", "0.6132771", "0.61154544", "0.61154544", "0.6115227", "0.61126447", "0.60620207", "0.60610366", "0.60396665", "0.60388863", "0.60338706", "0.6014165" ]

[ "def test_upsert_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_upsert_own_template_as_user_saves(self):\n mock_request = create_mock_request(user=self.user1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_upsert_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_upsert_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_upsert_global_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_delete_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.delete(self.fixture.user2_template, request=mock_request)", "def test_update_template_registration(self):\n pass", "def test_delete_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.delete(self.fixture.user1_template, request=mock_request)", "def test_upsert_other_users_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user2_template, request=mock_request\n )", "def test_upsert_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user2_template, request=mock_request\n )", "def test_upsert_user(self):\n db = database.Database()\n db.upsert_user('nick', 100, 100)\n\n the_args, _ = db._cursor.execute.call_args\n sql = the_args[0]\n expected_sql = 'INSERT INTO quota_violations (username, triggered, last_notified)\\n VALUES (%s, %s, %s)\\n ON CONFLICT (username)\\n DO UPDATE SET\\n (triggered, last_notified)\\n = (EXCLUDED.triggered, EXCLUDED.last_notified);\\n '\n\n self.assertEqual(sql, expected_sql)", "def test_upsert_global_template_as_user_raises_access_control_error(self):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.global_template, request=mock_request\n )", "def test_delete_own_template_as_user_saves(self):\n mock_request = create_mock_request(user=self.user1)\n template_api.delete(self.fixture.user1_template, request=mock_request)", "def test_set_display_name_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def upsert(self, context: dict=None) -> None:\n assert(context.get('data', None) is not None)\n\n data = context.get('data', None)\n\n logging.info(f\"Upsert: {data}\")\n try:\n user_record = self.table.first(formula=f\"username='{data['username']}'\")\n user_id = user_record['id'] if user_record else None\n if user_id:\n self.table.update(user_id, fields=data, replace=True, typecast=True)\n else:\n self.table.create(fields=data, typecast=True)\n except Exception as ex:\n self.close_database()\n raise DatabaseError({\n \"code\": f\"Airtable exception\",\n \"description\": f'Database: `{self.db_name}`\\n`upsert({data})`\\nEnsure DB entities exist',\n \"message\": str(ex),\n }, 500)", "def test_upsert_profile(mocker, mock_es_profile_serializer, user):\n patched_task = mocker.patch(\"search.search_index_helpers.tasks.upsert_profile\")\n upsert_profile(user.profile.id)\n patched_task.assert_called_once_with(user.profile.id)", "def test_update_useruser_uuid_put(self):\n pass", "def test_set_display_name_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_delete_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.delete(self.fixture.global_template, request=mock_request)", "def test_post_update_regular_user(self):\n url = reverse('post-detail', kwargs={'pk': self.post.id})\n user_url = reverse('user-detail', kwargs={'pk': self.superuser.id})\n self.client.force_authenticate(user=self.user)\n title = 'Random New Title'\n body = 'Random New Body'\n response = self.client.put(url, {'title': title, 'body': body, 'user': user_url}, format='json')\n self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)", "def test_replace_user(self):\n pass", "def test_update_user(self):\n pass", "def test_post_update_admin(self):\n url = reverse('post-detail', kwargs={'pk': self.post.id})\n user_url = reverse('user-detail', kwargs={'pk': self.superuser.id})\n self.client.force_authenticate(user=self.superuser)\n title = 'Random New Title'\n body = 'Random New Body'\n response = self.client.put(url, {'title': title, 'body': body, 'user': user_url}, format='json')\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n self.assertIn(title, response.content)\n self.assertIn(body, response.content)\n self.assertIn(user_url, response.content)", "def test_delete_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.delete(self.fixture.user1_template, request=mock_request)", "def test_team_template_folders_id_templates_fk_put(self):\n pass", "def test_upsert_user_list(mocker, list_type):\n patched_task = mocker.patch(\"search.tasks.upsert_user_list\")\n user_list = UserListFactory.create(list_type=list_type)\n upsert_user_list(user_list.id)\n patched_task.assert_called_once_with(user_list.id)", "def test_update_template_subscription(self):\n pass", "def test_update_activity_template(self):\n pass", "def upsert(self):\n\n if self.cluster:\n self.cluster.upsert()\n else:\n super().upsert()", "def test_is_data_in_template_and_database_same(self):\n SimplePersonFactory.create()\n contact = Person.objects.last()\n self.assertEqual(check_content_in_template(contact), True)\n contact.name = \"test_is_data_in_template_and_database_same\"\n contact.save()\n self.assertEqual(check_content_in_template(contact), True)" ]

[ "0.8743067", "0.8495421", "0.82973075", "0.80561215", "0.77087814", "0.6882263", "0.67282534", "0.6710842", "0.6694126", "0.66577846", "0.66266376", "0.65471303", "0.63964623", "0.6395424", "0.6271223", "0.62125725", "0.6190717", "0.61589557", "0.6157732", "0.6142412", "0.60943884", "0.6058946", "0.6050152", "0.6037755", "0.5984046", "0.5909164", "0.5889306", "0.5885852", "0.5877269", "0.58673394" ]

[ "def test_upsert_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_upsert_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.user2_template, request=mock_request)", "def test_upsert_global_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_upsert_own_template_as_user_saves(self):\n mock_request = create_mock_request(user=self.user1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_upsert_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_update_template_registration(self):\n pass", "def test_delete_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.delete(self.fixture.global_template, request=mock_request)", "def test_upsert_global_template_as_user_raises_access_control_error(self):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.global_template, request=mock_request\n )", "def test_delete_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.delete(self.fixture.user1_template, request=mock_request)", "def test_set_display_name_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_delete_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.delete(self.fixture.user2_template, request=mock_request)", "def test_customization_template_crud():\n template_crud = pxe.CustomizationTemplate(\n name=generate_random_string(size=8),\n description=generate_random_string(size=16),\n image_type='RHEL-6',\n script_type='Kickstart',\n script_data='Testing the script')\n\n template_crud.create()\n with update(template_crud):\n template_crud.name = template_crud.name + \"_update\"\n template_crud.delete(cancel=False)", "def test_customization_template_crud():\n template_crud = pxe.CustomizationTemplate(\n name=generate_random_string(size=8),\n description=generate_random_string(size=16),\n image_type='RHEL-6',\n script_type='Kickstart',\n script_data='Testing the script')\n\n template_crud.create()\n with update(template_crud):\n template_crud.name = template_crud.name + \"_update\"\n template_crud.delete(cancel=False)", "def test_register_template(self):\n pass", "def test_upsert_user(self):\n db = database.Database()\n db.upsert_user('nick', 100, 100)\n\n the_args, _ = db._cursor.execute.call_args\n sql = the_args[0]\n expected_sql = 'INSERT INTO quota_violations (username, triggered, last_notified)\\n VALUES (%s, %s, %s)\\n ON CONFLICT (username)\\n DO UPDATE SET\\n (triggered, last_notified)\\n = (EXCLUDED.triggered, EXCLUDED.last_notified);\\n '\n\n self.assertEqual(sql, expected_sql)", "def test_update_activity_template(self):\n pass", "def test_share_template_registration(self):\n pass", "def test_update_template_subscription(self):\n pass", "def test_delete_global_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.delete(self.fixture.global_template, request=mock_request)", "def test_set_display_name_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_delete_own_template_as_user_saves(self):\n mock_request = create_mock_request(user=self.user1)\n template_api.delete(self.fixture.user1_template, request=mock_request)", "def test_set_display_name_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_upsert_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user2_template, request=mock_request\n )", "def test_no_template(self):\n distillery = Distillery.objects.get_by_natural_key(\n 'mongodb.test_database.test_docs')\n try:\n distillery.save()\n except AttributeError:\n self.fail('put_template() raised AttributeError unexpectedly')", "def test_post_update_admin(self):\n url = reverse('post-detail', kwargs={'pk': self.post.id})\n user_url = reverse('user-detail', kwargs={'pk': self.superuser.id})\n self.client.force_authenticate(user=self.superuser)\n title = 'Random New Title'\n body = 'Random New Body'\n response = self.client.put(url, {'title': title, 'body': body, 'user': user_url}, format='json')\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n self.assertIn(title, response.content)\n self.assertIn(body, response.content)\n self.assertIn(user_url, response.content)", "def test_upsert_other_users_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user2_template, request=mock_request\n )", "def test_06_datastore_upsert(self, Mock):\r\n html_request = FakeRequest(json.dumps(self.task_upsert), 200,\r\n {'content-type': 'application/json'})\r\n\r\n record = dict(info=dict(foo=\"bar\"))\r\n Mock.return_value = html_request\r\n with self.flask_app.test_request_context('/'):\r\n out = self.ckan.datastore_upsert(name='task',\r\n records=json.dumps([record]),\r\n resource_id=self.task_resource_id)\r\n err_msg = \"It should return True\"\r\n assert out is True, err_msg\r\n # Check the error\r\n Mock.return_value = self.server_error\r\n try:\r\n self.ckan.datastore_upsert(name='task',\r\n records=json.dumps([record]),\r\n resource_id=self.task_resource_id)\r\n except Exception as out:\r\n type, msg, status_code = out.args\r\n assert \"Server Error\" in msg, msg\r\n assert 500 == status_code, status_code\r\n assert \"CKAN: the remote site failed! datastore_upsert failed\" == type, type", "def test_post_update_regular_user(self):\n url = reverse('post-detail', kwargs={'pk': self.post.id})\n user_url = reverse('user-detail', kwargs={'pk': self.superuser.id})\n self.client.force_authenticate(user=self.user)\n title = 'Random New Title'\n body = 'Random New Body'\n response = self.client.put(url, {'title': title, 'body': body, 'user': user_url}, format='json')\n self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)", "async def test_rendering_template_admin(\n hass: HomeAssistant, mock_api_client: TestClient, hass_admin_user: MockUser\n) -> None:\n hass_admin_user.groups = []\n resp = await mock_api_client.post(const.URL_API_TEMPLATE)\n assert resp.status == HTTPStatus.UNAUTHORIZED", "def test_replace_user(self):\n pass" ]

[ "0.8367511", "0.80747837", "0.8019871", "0.7914993", "0.75762117", "0.7137918", "0.68105483", "0.6717558", "0.64962363", "0.6318845", "0.62885976", "0.62019926", "0.62019926", "0.61965513", "0.6134998", "0.61280674", "0.61277187", "0.61214155", "0.61206126", "0.6063399", "0.6007959", "0.6004008", "0.59354955", "0.59329104", "0.59180963", "0.5917277", "0.591029", "0.5891822", "0.58905816", "0.587862" ]

[ "def test_set_display_name_user_template_as_anonymous_with_access_right_access_raises_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_anonymous_with_access_right_access_raises_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_other_users_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_own_template_as_user_saves(self):\n mock_request = create_mock_request(user=self.user1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_profile_route_uses_right_templates(self):\n self.add_testuser()\n response = self.client.get(\"/profile/testuser/\")\n self.assertTemplateUsed(response, \"layout.html\")", "def test_automatic_default_public_username_role_administrator(self):\n\n consumer = LTIConsumerFactory(slug=\"consumer\")\n passport = LTIPassportFactory(title=\"consumer1_passport1\", consumer=consumer)\n\n user_count = get_user_model().objects.count()\n\n new_user = self._authenticate(\n {\n \"user_id\": \"3fd0ff83-a62d-4a12-9716-4d48821ae24f\",\n \"lti_message_type\": \"basic-lti-launch-request\",\n \"lti_version\": \"LTI-1p0\",\n \"resource_link_id\": \"aaa\",\n \"context_id\": \"course-v1:fooschool+authbackend+0001\",\n \"lis_person_contact_email_primary\": \"[email protected]\",\n \"roles\": \"Administrator\",\n },\n passport,\n )\n\n self.assertEqual(consumer, new_user.lti_consumer)\n self.assertEqual(\"[email protected]\", new_user.email)\n self.assertEqual(\n \"3fd0ff83-a62d-4a12-9716-4d48821ae24f@consumer\", new_user.username\n )\n self.assertEqual(user_count + 1, get_user_model().objects.count())\n self.assertEqual(\"Administrator\", new_user.public_username)", "def test_automatic_default_public_username_role_administrator_instructor(self):\n\n consumer = LTIConsumerFactory(slug=\"consumer\")\n passport = LTIPassportFactory(title=\"consumer1_passport1\", consumer=consumer)\n\n user_count = get_user_model().objects.count()\n\n new_user = self._authenticate(\n {\n \"user_id\": \"3fd0ff83-a62d-4a12-9716-4d48821ae24f\",\n \"lti_message_type\": \"basic-lti-launch-request\",\n \"lti_version\": \"LTI-1p0\",\n \"resource_link_id\": \"aaa\",\n \"context_id\": \"course-v1:fooschool+authbackend+0001\",\n \"lis_person_contact_email_primary\": \"[email protected]\",\n \"roles\": (\n \"Administrator,Instructor,urn:lti:sysrole:ims/lis/Administrator,\"\n \"urn:lti:instrole:ims/lis/Administrator\"\n ),\n },\n passport,\n )\n\n self.assertEqual(consumer, new_user.lti_consumer)\n self.assertEqual(\"[email protected]\", new_user.email)\n self.assertEqual(\n \"3fd0ff83-a62d-4a12-9716-4d48821ae24f@consumer\", new_user.username\n )\n self.assertEqual(user_count + 1, get_user_model().objects.count())\n self.assertEqual(\"Educational team\", new_user.public_username)", "def test_automatic_default_public_username_role_instructor(self):\n\n consumer = LTIConsumerFactory(slug=\"consumer\")\n passport = LTIPassportFactory(title=\"consumer1_passport1\", consumer=consumer)\n\n user_count = get_user_model().objects.count()\n\n new_user = self._authenticate(\n {\n \"user_id\": \"3fd0ff83-a62d-4a12-9716-4d48821ae24f\",\n \"lti_message_type\": \"basic-lti-launch-request\",\n \"lti_version\": \"LTI-1p0\",\n \"resource_link_id\": \"aaa\",\n \"context_id\": \"course-v1:fooschool+authbackend+0001\",\n \"lis_person_contact_email_primary\": \"[email protected]\",\n \"roles\": \"Instructor\",\n },\n passport,\n )\n\n self.assertEqual(consumer, new_user.lti_consumer)\n self.assertEqual(\"[email protected]\", new_user.email)\n self.assertEqual(\n \"3fd0ff83-a62d-4a12-9716-4d48821ae24f@consumer\", new_user.username\n )\n self.assertEqual(user_count + 1, get_user_model().objects.count())\n self.assertEqual(\"Educational team\", new_user.public_username)", "def test_optional_public_username(self):\n\n consumer = LTIConsumerFactory(slug=\"consumer\")\n passport = LTIPassportFactory(title=\"consumer1_passport1\", consumer=consumer)\n\n user_count = get_user_model().objects.count()\n\n new_user = self._authenticate(\n {\n \"user_id\": \"3fd0ff83-a62d-4a12-9716-4d48821ae24f\",\n \"lti_message_type\": \"basic-lti-launch-request\",\n \"lti_version\": \"LTI-1p0\",\n \"resource_link_id\": \"aaa\",\n \"context_id\": \"course-v1:fooschool+authbackend+0001\",\n \"lis_person_contact_email_primary\": \"[email protected]\",\n },\n passport,\n )\n\n self.assertEqual(\"\", new_user.public_username)\n self.assertEqual(consumer, new_user.lti_consumer)\n self.assertEqual(\"[email protected]\", new_user.email)\n self.assertEqual(\n \"3fd0ff83-a62d-4a12-9716-4d48821ae24f@consumer\", new_user.username\n )\n self.assertEqual(user_count + 1, get_user_model().objects.count())", "def test_replace_user(self):\n pass", "def test_anonymous_user_view(self):\n table = self.get_change_page_form(self.anonymous_client, self.question_1.pk)\n self.assertInHTML('<label>Title:</label><div class=\"readonly\">Lorem</div>', table)\n self.assertInHTML('<label>Body:</label><div class=\"readonly\">Foo bar</div>', table)\n self.assertInHTML(\n '<label>Author:</label><div class=\"readonly\"><a href=\"/auth/user/2/change/\">user_1</a></div>', table)", "def test_unknown_user(self, pytester: pytest.Pytester, caplog: pytest.LogCaptureFixture):\n pytester.makepyfile(\n \"\"\"\n import pytest\n\n def test_TEST_T123():\n assert True\n \"\"\"\n )\n with patch(\"pytest_adaptavist.atm_user_is_valid\", return_value=False):\n pytester.runpytest(\"--adaptavist\")\n assert caplog.records[-1].funcName == \"pytest_configure\"\n assert caplog.records[-1].levelno == logging.WARN\n assert (\n caplog.records[-1].msg\n == \"Local user '%s' is not known in Jira. Test cases will be reported without an executor!\"\n )", "def test_serve_user(self):\n pass", "def test_user(self):\n return True", "def test_get_user_template_as_anonymous_raises_access_control_error(self):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.get_by_id(\n self.fixture.user1_template.id, request=mock_request\n )", "def test_user_no_displayname(dummy_user_dict):\n del dummy_user_dict[\"displayname\"]\n dummy_user_dict[\"gecos\"] = [\"GCOS\"]\n user = User(dummy_user_dict)\n assert user.name == \"GCOS\"", "def test_functionality(self):\n templateName = \"Test Template\"\n self.browserObject = globalVars.browserObject\n \n #Check for current logged in user\n self.verifyCurrentUser(userRole='Administrator', loginAsUser=True)\n \n #Deleting Standard User\n userList = self.getLocalUsers(userName=globalVars.standardUser)\n if len(userList) > 0:\n self.deleteLocalUser(globalVars.standardUser, verifyUser=True)\n \n #Creates Sample Template if not exists\n self.createSampleTemplate(templateName=templateName, deleteAndCreate=True, publishedTemplate=True)", "def test_get_user_template_as_anonymous_with_access_right_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.get_by_id(\n self.fixture.user1_template.id, request=mock_request\n )", "def test_users_username_get(self):\n pass", "def page_test():\n # get user-name and access rights from IAM\n\n html = \"<h3>Hello world! 2</h3>\"\n return html", "def test_upsert_user_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user1_template, request=mock_request\n )", "def test_config(self):\n self.assertEqual(self.view.template_name, \"resources/templanguage_admin.html\")" ]

[ "0.7858779", "0.78346056", "0.7798927", "0.7767267", "0.7345611", "0.7203787", "0.7118784", "0.69429713", "0.6838001", "0.6815123", "0.65575707", "0.64346975", "0.6426258", "0.64122313", "0.6399105", "0.6327164", "0.6311326", "0.62794083", "0.62768495", "0.62200284", "0.6201237", "0.6169968", "0.61650825", "0.60941994", "0.6039872", "0.603194", "0.60054153", "0.597033", "0.5929794", "0.5902376" ]

[ "def test_set_display_name_global_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_user_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_anonymous_with_access_right_access_raises_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_other_users_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_own_template_as_user_saves(self):\n mock_request = create_mock_request(user=self.user1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_profile_route_uses_right_templates(self):\n self.add_testuser()\n response = self.client.get(\"/profile/testuser/\")\n self.assertTemplateUsed(response, \"layout.html\")", "def test_set_display_name_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_automatic_default_public_username_role_administrator(self):\n\n consumer = LTIConsumerFactory(slug=\"consumer\")\n passport = LTIPassportFactory(title=\"consumer1_passport1\", consumer=consumer)\n\n user_count = get_user_model().objects.count()\n\n new_user = self._authenticate(\n {\n \"user_id\": \"3fd0ff83-a62d-4a12-9716-4d48821ae24f\",\n \"lti_message_type\": \"basic-lti-launch-request\",\n \"lti_version\": \"LTI-1p0\",\n \"resource_link_id\": \"aaa\",\n \"context_id\": \"course-v1:fooschool+authbackend+0001\",\n \"lis_person_contact_email_primary\": \"[email protected]\",\n \"roles\": \"Administrator\",\n },\n passport,\n )\n\n self.assertEqual(consumer, new_user.lti_consumer)\n self.assertEqual(\"[email protected]\", new_user.email)\n self.assertEqual(\n \"3fd0ff83-a62d-4a12-9716-4d48821ae24f@consumer\", new_user.username\n )\n self.assertEqual(user_count + 1, get_user_model().objects.count())\n self.assertEqual(\"Administrator\", new_user.public_username)", "def test_automatic_default_public_username_role_administrator_instructor(self):\n\n consumer = LTIConsumerFactory(slug=\"consumer\")\n passport = LTIPassportFactory(title=\"consumer1_passport1\", consumer=consumer)\n\n user_count = get_user_model().objects.count()\n\n new_user = self._authenticate(\n {\n \"user_id\": \"3fd0ff83-a62d-4a12-9716-4d48821ae24f\",\n \"lti_message_type\": \"basic-lti-launch-request\",\n \"lti_version\": \"LTI-1p0\",\n \"resource_link_id\": \"aaa\",\n \"context_id\": \"course-v1:fooschool+authbackend+0001\",\n \"lis_person_contact_email_primary\": \"[email protected]\",\n \"roles\": (\n \"Administrator,Instructor,urn:lti:sysrole:ims/lis/Administrator,\"\n \"urn:lti:instrole:ims/lis/Administrator\"\n ),\n },\n passport,\n )\n\n self.assertEqual(consumer, new_user.lti_consumer)\n self.assertEqual(\"[email protected]\", new_user.email)\n self.assertEqual(\n \"3fd0ff83-a62d-4a12-9716-4d48821ae24f@consumer\", new_user.username\n )\n self.assertEqual(user_count + 1, get_user_model().objects.count())\n self.assertEqual(\"Educational team\", new_user.public_username)", "def test_replace_user(self):\n pass", "def test_user(self):\n return True", "def test_get_user_template_as_anonymous_with_access_right_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.get_by_id(\n self.fixture.user1_template.id, request=mock_request\n )", "def test_set_display_name_global_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_automatic_default_public_username_role_instructor(self):\n\n consumer = LTIConsumerFactory(slug=\"consumer\")\n passport = LTIPassportFactory(title=\"consumer1_passport1\", consumer=consumer)\n\n user_count = get_user_model().objects.count()\n\n new_user = self._authenticate(\n {\n \"user_id\": \"3fd0ff83-a62d-4a12-9716-4d48821ae24f\",\n \"lti_message_type\": \"basic-lti-launch-request\",\n \"lti_version\": \"LTI-1p0\",\n \"resource_link_id\": \"aaa\",\n \"context_id\": \"course-v1:fooschool+authbackend+0001\",\n \"lis_person_contact_email_primary\": \"[email protected]\",\n \"roles\": \"Instructor\",\n },\n passport,\n )\n\n self.assertEqual(consumer, new_user.lti_consumer)\n self.assertEqual(\"[email protected]\", new_user.email)\n self.assertEqual(\n \"3fd0ff83-a62d-4a12-9716-4d48821ae24f@consumer\", new_user.username\n )\n self.assertEqual(user_count + 1, get_user_model().objects.count())\n self.assertEqual(\"Educational team\", new_user.public_username)", "def test_serve_user(self):\n pass", "def test_get_user_template_as_anonymous_raises_access_control_error(self):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.get_by_id(\n self.fixture.user1_template.id, request=mock_request\n )", "def test_optional_public_username(self):\n\n consumer = LTIConsumerFactory(slug=\"consumer\")\n passport = LTIPassportFactory(title=\"consumer1_passport1\", consumer=consumer)\n\n user_count = get_user_model().objects.count()\n\n new_user = self._authenticate(\n {\n \"user_id\": \"3fd0ff83-a62d-4a12-9716-4d48821ae24f\",\n \"lti_message_type\": \"basic-lti-launch-request\",\n \"lti_version\": \"LTI-1p0\",\n \"resource_link_id\": \"aaa\",\n \"context_id\": \"course-v1:fooschool+authbackend+0001\",\n \"lis_person_contact_email_primary\": \"[email protected]\",\n },\n passport,\n )\n\n self.assertEqual(\"\", new_user.public_username)\n self.assertEqual(consumer, new_user.lti_consumer)\n self.assertEqual(\"[email protected]\", new_user.email)\n self.assertEqual(\n \"3fd0ff83-a62d-4a12-9716-4d48821ae24f@consumer\", new_user.username\n )\n self.assertEqual(user_count + 1, get_user_model().objects.count())", "def test_anonymous_user_view(self):\n table = self.get_change_page_form(self.anonymous_client, self.question_1.pk)\n self.assertInHTML('<label>Title:</label><div class=\"readonly\">Lorem</div>', table)\n self.assertInHTML('<label>Body:</label><div class=\"readonly\">Foo bar</div>', table)\n self.assertInHTML(\n '<label>Author:</label><div class=\"readonly\"><a href=\"/auth/user/2/change/\">user_1</a></div>', table)", "def page_test():\n # get user-name and access rights from IAM\n\n html = \"<h3>Hello world! 2</h3>\"\n return html", "def test_functionality(self):\n templateName = \"Test Template\"\n self.browserObject = globalVars.browserObject\n \n #Check for current logged in user\n self.verifyCurrentUser(userRole='Administrator', loginAsUser=True)\n \n #Deleting Standard User\n userList = self.getLocalUsers(userName=globalVars.standardUser)\n if len(userList) > 0:\n self.deleteLocalUser(globalVars.standardUser, verifyUser=True)\n \n #Creates Sample Template if not exists\n self.createSampleTemplate(templateName=templateName, deleteAndCreate=True, publishedTemplate=True)", "def test_unknown_user(self, pytester: pytest.Pytester, caplog: pytest.LogCaptureFixture):\n pytester.makepyfile(\n \"\"\"\n import pytest\n\n def test_TEST_T123():\n assert True\n \"\"\"\n )\n with patch(\"pytest_adaptavist.atm_user_is_valid\", return_value=False):\n pytester.runpytest(\"--adaptavist\")\n assert caplog.records[-1].funcName == \"pytest_configure\"\n assert caplog.records[-1].levelno == logging.WARN\n assert (\n caplog.records[-1].msg\n == \"Local user '%s' is not known in Jira. Test cases will be reported without an executor!\"\n )", "def test_upsert_user_template_as_anonymous_with_access_right_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user1_template, request=mock_request\n )", "def test_read_user(self):\n pass", "def test_admin_view_access(request_ctx):\n user = User.get(email=\"[email protected]\")\n with request_ctx(\"/org_invitatin_summary\") as ctx:\n login_user(user, remember=True)\n rv = ctx.app.full_dispatch_request()\n assert rv.status_code == 200\n assert b\"<!DOCTYPE html>\" in rv.data, \"Expected HTML content\"\n assert b\"Organisation Invitation Summary\" in rv.data\n assert b\"[email protected]\" in rv.data", "def test_upsert_user_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user1_template, request=mock_request\n )" ]

[ "0.7932997", "0.7856808", "0.7826848", "0.7630959", "0.75949347", "0.7490484", "0.7073472", "0.68847364", "0.6830498", "0.6753237", "0.6647094", "0.65420926", "0.6539563", "0.6489039", "0.6448539", "0.6360224", "0.63581413", "0.63525265", "0.6342854", "0.6306662", "0.6250822", "0.62251616", "0.6213233", "0.6142011", "0.6129865", "0.61056954", "0.6103878", "0.60918087", "0.6058757", "0.6053416" ]

[ "def test_set_display_name_global_template_as_anonymous_with_access_right_access_raises_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_user_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_user_template_as_anonymous_with_access_right_access_raises_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_config(self):\n self.assertEqual(self.view.template_name, \"resources/templanguage_admin.html\")", "def test_set_display_name_other_users_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_create_namespaced_template(self):\n pass", "def test_register_template(self):\n pass", "def test_set_display_name_own_template_as_user_saves(self):\n mock_request = create_mock_request(user=self.user1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def template_name(self):\n\t\traise NotImplementedError('template_name must be defined')", "def test_create_template_subsciption(self):\n pass", "def test_set_display_name_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_replace_namespaced_template(self):\n pass", "def test_set_display_name_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_template_feedback(self):\r\n pass", "def test_share_template_registration(self):\n pass", "def test_read_namespaced_template(self):\n pass", "def test_get_global_template_as_anonymous_with_access_right_returns_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n template = template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.global_template)", "def test_as_default(self):\n self.assertEqual(render('{% default_as %}...{{ snake }}'), '...hisss')", "def testbed_name(self): \n return \"C-Lab\"", "def test_for_template(self):\n self.assertTemplateUsed(self.response, 'my_info_template.html')", "def test_update_template_profile_for_system_module(self):\n pass", "def test_get_activity_template(self):\n pass", "def test_create_namespaced_processed_template(self):\n pass", "def test_correct_template(self):\n self.assertCorrectTemplateUsed('common/home.html')", "def test_retrieve_template_registration(self):\n pass" ]

[ "0.75897294", "0.7537711", "0.71880955", "0.7096142", "0.70061153", "0.6705285", "0.6676191", "0.66185564", "0.6505029", "0.6454833", "0.64344525", "0.64255494", "0.64228266", "0.637963", "0.6351018", "0.6320668", "0.6286474", "0.627791", "0.6211061", "0.6122106", "0.6110267", "0.6110193", "0.60683894", "0.6061314", "0.6053098", "0.60509646", "0.6046516", "0.6033503", "0.60289717", "0.5978048" ]

[ "def test_set_display_name_global_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_user_template_as_anonymous_with_access_right_access_raises_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_user_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_other_users_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_config(self):\n self.assertEqual(self.view.template_name, \"resources/templanguage_admin.html\")", "def test_set_display_name_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_create_template_subsciption(self):\n pass", "def test_create_namespaced_template(self):\n pass", "def test_get_global_template_as_anonymous_with_access_right_returns_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n template = template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.global_template)", "def test_register_template(self):\n pass", "def test_set_display_name_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_share_template_registration(self):\n pass", "def test_set_display_name_own_template_as_user_saves(self):\n mock_request = create_mock_request(user=self.user1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_template_feedback(self):\r\n pass", "def test_update_template_profile_for_system_module(self):\n pass", "def test_read_namespaced_template(self):\n pass", "def test_replace_namespaced_template(self):\n pass", "def test_correct_template(self):\n self.assertCorrectTemplateUsed('common/home.html')", "def test_retrieve_template_registration(self):\n pass", "def test_get_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )", "def test_get_activity_template(self):\n pass", "def test_profile_route_uses_right_templates(self):\n self.add_testuser()\n response = self.client.get(\"/profile/testuser/\")\n self.assertTemplateUsed(response, \"layout.html\")", "def test_for_template(self):\n self.assertTemplateUsed(self.response, 'my_info_template.html')", "def test_functionality(self):\n templateName = \"Test Template\"\n self.browserObject = globalVars.browserObject\n \n #Check for current logged in user\n self.verifyCurrentUser(userRole='Administrator', loginAsUser=True)\n \n #Deleting Standard User\n userList = self.getLocalUsers(userName=globalVars.standardUser)\n if len(userList) > 0:\n self.deleteLocalUser(globalVars.standardUser, verifyUser=True)\n \n #Creates Sample Template if not exists\n self.createSampleTemplate(templateName=templateName, deleteAndCreate=True, publishedTemplate=True)", "def test_create_namespaced_processed_template(self):\n pass" ]

[ "0.7787586", "0.7674045", "0.7377819", "0.7261662", "0.6899707", "0.68808687", "0.6835308", "0.66616756", "0.665786", "0.659236", "0.64996874", "0.64823717", "0.6461565", "0.64222765", "0.6356866", "0.63562834", "0.6349354", "0.62561953", "0.62519723", "0.6238655", "0.6195329", "0.61873204", "0.6165956", "0.6159323", "0.6148084", "0.61441016", "0.61355156", "0.6071756", "0.6063499", "0.600743" ]

[ "def test_set_display_name_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def save(self, *args, **kwargs):\n if self.pk is None:\n if not self.name.startswith(TEMPLATE_PREFIX):\n self.name = f'{TEMPLATE_PREFIX}{self.name}'\n super(Template, self).save(*args, **kwargs)", "def test_upsert_own_template_as_user_saves(self):\n mock_request = create_mock_request(user=self.user1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_upsert_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_create_with_username(self):\n properties = self.portal.portal_properties.site_properties\n properties.manage_changeProperties(use_email_as_login=True)\n\n user = api.user.create(\n username='chuck',\n email='[email protected]',\n password='secret',\n )\n self.assertEquals(user.getUserName(), '[email protected]')\n\n properties = self.portal.portal_properties.site_properties\n properties.manage_changeProperties(use_email_as_login=False)\n\n user = api.user.create(\n username='chuck',\n email='[email protected]',\n password='secret',\n )\n self.assertEquals(user.getUserName(), 'chuck')", "def test_set_display_name_other_users_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_profile_route_uses_right_templates(self):\n self.add_testuser()\n response = self.client.get(\"/profile/testuser/\")\n self.assertTemplateUsed(response, \"layout.html\")", "def autoname(self):\n\t\tself.name = self.role_profile", "def test_set_display_name_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_replace_user(self):\n pass", "def test_get_form_label_name(self):\n self.user.name = 'Full Name'\n self.assertEqual(\n self.user.get_form_label(),\n 'Full Name (testuser)',\n )", "def test_full_name(self):\n\n user = CustomUser.objects.get(email=\"[email protected]\")\n\n self.assertEqual(user.get_full_name(), \"TestName TestSecondName\")", "def test_set_display_name_user_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_functionality(self):\n templateName = \"Test Template\"\n self.browserObject = globalVars.browserObject\n \n #Check for current logged in user\n self.verifyCurrentUser(userRole='Administrator', loginAsUser=True)\n \n #Deleting Standard User\n userList = self.getLocalUsers(userName=globalVars.standardUser)\n if len(userList) > 0:\n self.deleteLocalUser(globalVars.standardUser, verifyUser=True)\n \n #Creates Sample Template if not exists\n self.createSampleTemplate(templateName=templateName, deleteAndCreate=True, publishedTemplate=True)", "def test_upsert_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_set_display_name_user_template_as_anonymous_with_access_right_access_raises_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_get_form_label_first_last(self):\n self.user.first_name = 'Full'\n self.user.last_name = 'Name'\n self.assertEqual(\n self.user.get_form_label(email=True),\n 'Full Name (testuser) <[email protected]>',\n )", "def test_upsert_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_create_template_subsciption(self):\n pass", "def test_register_template(self):\n pass", "def autoname(self):\n self.name = datetime.datetime.strftime(datetime.datetime.now(), \"%y%m%d %H%M%S\") + \"_\" + self.participant_role", "def test_set_display_name_global_template_as_anonymous_with_access_right_access_raises_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_update_template_registration(self):\n pass", "def test_useraccount_display(self):\n self.assertEqual(\"Partagez, échangez\", self.driver.title)", "def test_set_display_name_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )" ]

[ "0.8407966", "0.80694634", "0.8063102", "0.80549467", "0.7798652", "0.66668653", "0.6442892", "0.6430442", "0.64100146", "0.6407068", "0.6372801", "0.6296744", "0.62810963", "0.6225347", "0.62165725", "0.6200509", "0.614207", "0.6102368", "0.60813653", "0.606519", "0.6063235", "0.60435534", "0.6036475", "0.5999932", "0.59698373", "0.59656173", "0.5931319", "0.5916065", "0.5915174", "0.5887765" ]

[ "def test_set_display_name_global_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_own_template_as_user_saves(self):\n mock_request = create_mock_request(user=self.user1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_user_template_as_anonymous_with_access_right_access_raises_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_user_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_anonymous_with_access_right_access_raises_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_replace_user(self):\n pass", "def test_get_form_label_name(self):\n self.user.name = 'Full Name'\n self.assertEqual(\n self.user.get_form_label(),\n 'Full Name (testuser)',\n )", "def test_users_username_get(self):\n pass", "def test_profile_route_uses_right_templates(self):\n self.add_testuser()\n response = self.client.get(\"/profile/testuser/\")\n self.assertTemplateUsed(response, \"layout.html\")", "def test_expansionusers_name(self):\n user1 = ExpansionUsers.objects.get(username=\"[email protected]\")\n user2 = ExpansionUsers.objects.get(username=\"[email protected]\")\n print user1.first_name, user1.last_name\n print user2.first_name, user2.last_name", "def test_user(self):\n return True", "def test_useraccount_display(self):\n self.assertEqual(\"Partagez, échangez\", self.driver.title)", "def test_automatic_default_public_username_role_administrator(self):\n\n consumer = LTIConsumerFactory(slug=\"consumer\")\n passport = LTIPassportFactory(title=\"consumer1_passport1\", consumer=consumer)\n\n user_count = get_user_model().objects.count()\n\n new_user = self._authenticate(\n {\n \"user_id\": \"3fd0ff83-a62d-4a12-9716-4d48821ae24f\",\n \"lti_message_type\": \"basic-lti-launch-request\",\n \"lti_version\": \"LTI-1p0\",\n \"resource_link_id\": \"aaa\",\n \"context_id\": \"course-v1:fooschool+authbackend+0001\",\n \"lis_person_contact_email_primary\": \"[email protected]\",\n \"roles\": \"Administrator\",\n },\n passport,\n )\n\n self.assertEqual(consumer, new_user.lti_consumer)\n self.assertEqual(\"[email protected]\", new_user.email)\n self.assertEqual(\n \"3fd0ff83-a62d-4a12-9716-4d48821ae24f@consumer\", new_user.username\n )\n self.assertEqual(user_count + 1, get_user_model().objects.count())\n self.assertEqual(\"Administrator\", new_user.public_username)", "def test_get_short_name_with_user(self):\n user1 = User.objects.get(email=\"[email protected]\")\n user2 = User.objects.get(email=\"[email protected]\")\n self.assertEqual(user1.get_short_name(), '[email protected]')\n self.assertEqual(user2.get_short_name(), '[email protected]')", "def test_full_name(self):\n\n user = CustomUser.objects.get(email=\"[email protected]\")\n\n self.assertEqual(user.get_full_name(), \"TestName TestSecondName\")", "def test_automatic_default_public_username_role_administrator_instructor(self):\n\n consumer = LTIConsumerFactory(slug=\"consumer\")\n passport = LTIPassportFactory(title=\"consumer1_passport1\", consumer=consumer)\n\n user_count = get_user_model().objects.count()\n\n new_user = self._authenticate(\n {\n \"user_id\": \"3fd0ff83-a62d-4a12-9716-4d48821ae24f\",\n \"lti_message_type\": \"basic-lti-launch-request\",\n \"lti_version\": \"LTI-1p0\",\n \"resource_link_id\": \"aaa\",\n \"context_id\": \"course-v1:fooschool+authbackend+0001\",\n \"lis_person_contact_email_primary\": \"[email protected]\",\n \"roles\": (\n \"Administrator,Instructor,urn:lti:sysrole:ims/lis/Administrator,\"\n \"urn:lti:instrole:ims/lis/Administrator\"\n ),\n },\n passport,\n )\n\n self.assertEqual(consumer, new_user.lti_consumer)\n self.assertEqual(\"[email protected]\", new_user.email)\n self.assertEqual(\n \"3fd0ff83-a62d-4a12-9716-4d48821ae24f@consumer\", new_user.username\n )\n self.assertEqual(user_count + 1, get_user_model().objects.count())\n self.assertEqual(\"Educational team\", new_user.public_username)", "def test_user_no_displayname(dummy_user_dict):\n del dummy_user_dict[\"displayname\"]\n dummy_user_dict[\"gecos\"] = [\"GCOS\"]\n user = User(dummy_user_dict)\n assert user.name == \"GCOS\"", "def test_create_with_username(self):\n properties = self.portal.portal_properties.site_properties\n properties.manage_changeProperties(use_email_as_login=True)\n\n user = api.user.create(\n username='chuck',\n email='[email protected]',\n password='secret',\n )\n self.assertEquals(user.getUserName(), '[email protected]')\n\n properties = self.portal.portal_properties.site_properties\n properties.manage_changeProperties(use_email_as_login=False)\n\n user = api.user.create(\n username='chuck',\n email='[email protected]',\n password='secret',\n )\n self.assertEquals(user.getUserName(), 'chuck')", "def test_get_form_label_first_last(self):\n self.user.first_name = 'Full'\n self.user.last_name = 'Name'\n self.assertEqual(\n self.user.get_form_label(email=True),\n 'Full Name (testuser) <[email protected]>',\n )", "def autoname(self):\n\t\tself.name = self.role_profile", "def test_display_name(self):\r\n def verify_name(source_usage_key, parent_usage_key, expected_name, display_name=None):\r\n usage_key = self._duplicate_item(parent_usage_key, source_usage_key, display_name)\r\n duplicated_item = self.get_item_from_modulestore(usage_key, draft=True)\r\n self.assertEqual(duplicated_item.display_name, expected_name)\r\n return usage_key\r\n\r\n # Display name comes from template.\r\n dupe_usage_key = verify_name(self.problem_usage_key, self.seq_usage_key, \"Duplicate of 'Multiple Choice'\")\r\n # Test dupe of dupe.\r\n verify_name(dupe_usage_key, self.seq_usage_key, \"Duplicate of 'Duplicate of 'Multiple Choice''\")\r\n\r\n # Uses default display_name of 'Text' from HTML component.\r\n verify_name(self.html_usage_key, self.seq_usage_key, \"Duplicate of 'Text'\")\r\n\r\n # The sequence does not have a display_name set, so category is shown.\r\n verify_name(self.seq_usage_key, self.chapter_usage_key, \"Duplicate of sequential\")\r\n\r\n # Now send a custom display name for the duplicate.\r\n verify_name(self.seq_usage_key, self.chapter_usage_key, \"customized name\", display_name=\"customized name\")", "def test_serve_user(self):\n pass", "def test_optional_public_username(self):\n\n consumer = LTIConsumerFactory(slug=\"consumer\")\n passport = LTIPassportFactory(title=\"consumer1_passport1\", consumer=consumer)\n\n user_count = get_user_model().objects.count()\n\n new_user = self._authenticate(\n {\n \"user_id\": \"3fd0ff83-a62d-4a12-9716-4d48821ae24f\",\n \"lti_message_type\": \"basic-lti-launch-request\",\n \"lti_version\": \"LTI-1p0\",\n \"resource_link_id\": \"aaa\",\n \"context_id\": \"course-v1:fooschool+authbackend+0001\",\n \"lis_person_contact_email_primary\": \"[email protected]\",\n },\n passport,\n )\n\n self.assertEqual(\"\", new_user.public_username)\n self.assertEqual(consumer, new_user.lti_consumer)\n self.assertEqual(\"[email protected]\", new_user.email)\n self.assertEqual(\n \"3fd0ff83-a62d-4a12-9716-4d48821ae24f@consumer\", new_user.username\n )\n self.assertEqual(user_count + 1, get_user_model().objects.count())" ]

[ "0.781667", "0.76295245", "0.7623421", "0.7554093", "0.7485875", "0.7380692", "0.7249136", "0.72226626", "0.7183608", "0.71021247", "0.690039", "0.68378454", "0.6738137", "0.6521974", "0.65130067", "0.64845836", "0.6419813", "0.6398974", "0.62798584", "0.6274754", "0.6272008", "0.6271634", "0.6247738", "0.62350184", "0.6193381", "0.61929363", "0.6170838", "0.61533266", "0.6151526", "0.61416954" ]

[ "def test_set_display_name_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_anonymous_with_access_right_access_raises_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_other_users_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_own_template_as_user_saves(self):\n mock_request = create_mock_request(user=self.user1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_user_template_as_anonymous_with_access_right_access_raises_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_user_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_config(self):\n self.assertEqual(self.view.template_name, \"resources/templanguage_admin.html\")", "def test_update_template_profile_for_system_module(self):\n pass", "def test_functionality(self):\n templateName = \"Test Template\"\n self.browserObject = globalVars.browserObject\n \n #Check for current logged in user\n self.verifyCurrentUser(userRole='Administrator', loginAsUser=True)\n \n #Deleting Standard User\n userList = self.getLocalUsers(userName=globalVars.standardUser)\n if len(userList) > 0:\n self.deleteLocalUser(globalVars.standardUser, verifyUser=True)\n \n #Creates Sample Template if not exists\n self.createSampleTemplate(templateName=templateName, deleteAndCreate=True, publishedTemplate=True)", "def test_profile_route_uses_right_templates(self):\n self.add_testuser()\n response = self.client.get(\"/profile/testuser/\")\n self.assertTemplateUsed(response, \"layout.html\")", "def test_create_template_subsciption(self):\n pass", "def test_global_template_as_user_returns_template(self):\n mock_request = create_mock_request(user=self.user1)\n template = template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.global_template)", "def test_register_template(self):\n pass", "def test_share_template_registration(self):\n pass", "def template_name(self):\n\t\traise NotImplementedError('template_name must be defined')", "def test_create_namespaced_template(self):\n pass", "def test_replace_user(self):\n pass", "def test_correct_template(self):\n self.assertCorrectTemplateUsed('common/home.html')", "def test_get_form_label_name(self):\n self.user.name = 'Full Name'\n self.assertEqual(\n self.user.get_form_label(),\n 'Full Name (testuser)',\n )", "def test_retrieve_template_registration(self):\n pass", "def test_home_view_template(self):\n response = self.client.get(self.url)\n self.assertEqual(response.status_code, 200)\n self.assertTemplateUsed(response, 'user_data.html')", "def test_unknown_user(self, pytester: pytest.Pytester, caplog: pytest.LogCaptureFixture):\n pytester.makepyfile(\n \"\"\"\n import pytest\n\n def test_TEST_T123():\n assert True\n \"\"\"\n )\n with patch(\"pytest_adaptavist.atm_user_is_valid\", return_value=False):\n pytester.runpytest(\"--adaptavist\")\n assert caplog.records[-1].funcName == \"pytest_configure\"\n assert caplog.records[-1].levelno == logging.WARN\n assert (\n caplog.records[-1].msg\n == \"Local user '%s' is not known in Jira. Test cases will be reported without an executor!\"\n )", "def test_template_feedback(self):\r\n pass", "def hello_name(user):\r\n return render_template('edurekaHello.html', name = user)" ]

[ "0.7700821", "0.74678564", "0.74317616", "0.73584545", "0.71953356", "0.717542", "0.71707886", "0.7160337", "0.7133445", "0.7056015", "0.7030654", "0.6843602", "0.64356554", "0.63337344", "0.63230735", "0.6301633", "0.62698174", "0.61883277", "0.60796994", "0.6052181", "0.60245425", "0.6020464", "0.5956759", "0.59232557", "0.5893138", "0.5890204", "0.5846298", "0.584573", "0.5827404", "0.5793626" ]

[ "def test_set_display_name_global_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_own_template_as_user_saves(self):\n mock_request = create_mock_request(user=self.user1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_upsert_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_set_display_name_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def save(self, *args, **kwargs):\n if self.pk is None:\n if not self.name.startswith(TEMPLATE_PREFIX):\n self.name = f'{TEMPLATE_PREFIX}{self.name}'\n super(Template, self).save(*args, **kwargs)", "def test_upsert_global_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_create_template_subsciption(self):\n pass", "def test_set_display_name_global_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_upsert_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_register_template(self):\n pass", "def autoname(self):\n\t\tself.name = self.role_profile", "def test_get_create_post_as_staff_user_and_check_main_title_description(self):\n\n login = self.client.login(username='testuser_staff', password='password12345')\n\n if login:\n url = reverse('blogs:create')\n response = self.client.get(url)\n\n self.assertEqual(response.status_code, 200)\n self.assertTemplateUsed(response, 'create.html')\n self.assertIn(self.main_title, str(response.content))\n self.assertIn(self.description1, str(response.content))\n self.assertIn(self.description2, str(response.content))\n self.client.logout()\n else:\n # TODO Make this dynamic rather than hard coded text string\n self.fail('Login Failed for testuser_staff')", "def autoname(self):\n self.name = datetime.datetime.strftime(datetime.datetime.now(), \"%y%m%d %H%M%S\") + \"_\" + self.participant_role", "def test_delete_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.delete(self.fixture.user1_template, request=mock_request)", "def test_update_template_registration(self):\n pass", "def test_set_display_name_other_users_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_create_activity_template(self):\n pass", "def test_template_feedback(self):\r\n pass", "def test_config(self):\n self.assertEqual(self.view.template_name, \"resources/templanguage_admin.html\")", "def test_is_data_in_template_and_database_same(self):\n SimplePersonFactory.create()\n contact = Person.objects.last()\n self.assertEqual(check_content_in_template(contact), True)\n contact.name = \"test_is_data_in_template_and_database_same\"\n contact.save()\n self.assertEqual(check_content_in_template(contact), True)", "def test_upsert_own_template_as_user_saves(self):\n mock_request = create_mock_request(user=self.user1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_xml_template_set(self):\n xmlTemplateResult = XmlTemplate.objects.get(id=1)\n xmlTemplateResult.set(\"newTemplate\", '''<?xml >\n <project name=\"newTemplate\">\n </project> ''',)\n self.assertEqual(xmlTemplateResult.template_name, \"newTemplate\")\n self.assertEqual(xmlTemplateResult.template_content, '''<?xml >\n <project name=\"newTemplate\">\n </project> ''')", "def test_create_namespaced_template(self):\n pass", "def display_name(self):", "def test_upsert_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_retrieve_template_registration(self):\n pass", "def test_set_display_name_user_template_as_anonymous_with_access_right_access_raises_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )" ]

[ "0.81686586", "0.8027379", "0.7915645", "0.7679664", "0.7588453", "0.6449392", "0.63916004", "0.6336983", "0.62684387", "0.6225523", "0.6145685", "0.6063135", "0.5971488", "0.59581083", "0.59342474", "0.5905373", "0.58907783", "0.58565784", "0.5822107", "0.5810158", "0.5796048", "0.57873213", "0.5778512", "0.5778467", "0.57502913", "0.5732447", "0.57159036", "0.5715757", "0.5684516", "0.5676655" ]

[ "def test_set_display_name_global_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_other_users_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_user_template_as_anonymous_with_access_right_access_raises_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_anonymous_with_access_right_access_raises_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_user_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_own_template_as_user_saves(self):\n mock_request = create_mock_request(user=self.user1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_replace_user(self):\n pass", "def test_automatic_default_public_username_role_administrator_instructor(self):\n\n consumer = LTIConsumerFactory(slug=\"consumer\")\n passport = LTIPassportFactory(title=\"consumer1_passport1\", consumer=consumer)\n\n user_count = get_user_model().objects.count()\n\n new_user = self._authenticate(\n {\n \"user_id\": \"3fd0ff83-a62d-4a12-9716-4d48821ae24f\",\n \"lti_message_type\": \"basic-lti-launch-request\",\n \"lti_version\": \"LTI-1p0\",\n \"resource_link_id\": \"aaa\",\n \"context_id\": \"course-v1:fooschool+authbackend+0001\",\n \"lis_person_contact_email_primary\": \"[email protected]\",\n \"roles\": (\n \"Administrator,Instructor,urn:lti:sysrole:ims/lis/Administrator,\"\n \"urn:lti:instrole:ims/lis/Administrator\"\n ),\n },\n passport,\n )\n\n self.assertEqual(consumer, new_user.lti_consumer)\n self.assertEqual(\"[email protected]\", new_user.email)\n self.assertEqual(\n \"3fd0ff83-a62d-4a12-9716-4d48821ae24f@consumer\", new_user.username\n )\n self.assertEqual(user_count + 1, get_user_model().objects.count())\n self.assertEqual(\"Educational team\", new_user.public_username)", "def test_automatic_default_public_username_role_administrator(self):\n\n consumer = LTIConsumerFactory(slug=\"consumer\")\n passport = LTIPassportFactory(title=\"consumer1_passport1\", consumer=consumer)\n\n user_count = get_user_model().objects.count()\n\n new_user = self._authenticate(\n {\n \"user_id\": \"3fd0ff83-a62d-4a12-9716-4d48821ae24f\",\n \"lti_message_type\": \"basic-lti-launch-request\",\n \"lti_version\": \"LTI-1p0\",\n \"resource_link_id\": \"aaa\",\n \"context_id\": \"course-v1:fooschool+authbackend+0001\",\n \"lis_person_contact_email_primary\": \"[email protected]\",\n \"roles\": \"Administrator\",\n },\n passport,\n )\n\n self.assertEqual(consumer, new_user.lti_consumer)\n self.assertEqual(\"[email protected]\", new_user.email)\n self.assertEqual(\n \"3fd0ff83-a62d-4a12-9716-4d48821ae24f@consumer\", new_user.username\n )\n self.assertEqual(user_count + 1, get_user_model().objects.count())\n self.assertEqual(\"Administrator\", new_user.public_username)", "def test_profile_route_uses_right_templates(self):\n self.add_testuser()\n response = self.client.get(\"/profile/testuser/\")\n self.assertTemplateUsed(response, \"layout.html\")", "def test_user(self):\n return True", "def test_automatic_default_public_username_role_instructor(self):\n\n consumer = LTIConsumerFactory(slug=\"consumer\")\n passport = LTIPassportFactory(title=\"consumer1_passport1\", consumer=consumer)\n\n user_count = get_user_model().objects.count()\n\n new_user = self._authenticate(\n {\n \"user_id\": \"3fd0ff83-a62d-4a12-9716-4d48821ae24f\",\n \"lti_message_type\": \"basic-lti-launch-request\",\n \"lti_version\": \"LTI-1p0\",\n \"resource_link_id\": \"aaa\",\n \"context_id\": \"course-v1:fooschool+authbackend+0001\",\n \"lis_person_contact_email_primary\": \"[email protected]\",\n \"roles\": \"Instructor\",\n },\n passport,\n )\n\n self.assertEqual(consumer, new_user.lti_consumer)\n self.assertEqual(\"[email protected]\", new_user.email)\n self.assertEqual(\n \"3fd0ff83-a62d-4a12-9716-4d48821ae24f@consumer\", new_user.username\n )\n self.assertEqual(user_count + 1, get_user_model().objects.count())\n self.assertEqual(\"Educational team\", new_user.public_username)", "def test_users_username_get(self):\n pass", "def test_get_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.get_by_id(\n self.fixture.user2_template.id, request=mock_request\n )", "def test_get_form_label_name(self):\n self.user.name = 'Full Name'\n self.assertEqual(\n self.user.get_form_label(),\n 'Full Name (testuser)',\n )", "def test_admin_user_login(self):\n self.login(\"admin\", \"admin\")\n self.should_see(\"This is your profile, admin.\")", "def test_get_create_post_as_staff_user_and_check_main_title_description(self):\n\n login = self.client.login(username='testuser_staff', password='password12345')\n\n if login:\n url = reverse('blogs:create')\n response = self.client.get(url)\n\n self.assertEqual(response.status_code, 200)\n self.assertTemplateUsed(response, 'create.html')\n self.assertIn(self.main_title, str(response.content))\n self.assertIn(self.description1, str(response.content))\n self.assertIn(self.description2, str(response.content))\n self.client.logout()\n else:\n # TODO Make this dynamic rather than hard coded text string\n self.fail('Login Failed for testuser_staff')", "def test_add_admin_to_org(self):\n pass", "def test_serve_user(self):\n pass", "def test_modify_nonexist_username(self):\n print('(' + self.test_modify_nonexist_username.__name__+')',\n self.test_modify_nonexist_username.__doc__)\n self.assertIsNone(self.connection.modify_user(\n NON_EXIST_PATIENT_USERNAME, PATIENT['public_profile'],\n PATIENT['restricted_profile']))", "def autoname(self):\n\t\tself.name = self.role_profile", "def test_access_portal_user(self):\n # Portal user can see the confirmed SO for which they are assigned as a customer\n with self.assertRaises(AccessError):\n self.order.with_user(self.company_data['default_user_portal']).read()\n\n self.order.partner_id = self.company_data['default_user_portal'].partner_id\n self.order.action_confirm()\n # Portal user can't edit the SO\n with self.assertRaises(AccessError):\n self.order.with_user(self.company_data['default_user_portal']).write({'team_id': self.company_data['default_sale_team'].id})\n # Portal user can't create the SO\n with self.assertRaises(AccessError):\n self.env['sale.order'].with_user(self.company_data['default_user_portal']).create({\n 'partner_id': self.partner_a.id,\n })\n # Portal user can't delete the SO which is in 'draft' or 'cancel' state\n self.order.action_cancel()\n with self.assertRaises(AccessError):\n self.order.with_user(self.company_data['default_user_portal']).unlink()", "def test_user_can_change_superuser(self):\n self.assertTrue(self.story.user_can_change(self.superuser))", "def test_full_name(self):\n\n user = CustomUser.objects.get(email=\"[email protected]\")\n\n self.assertEqual(user.get_full_name(), \"TestName TestSecondName\")" ]

[ "0.7605984", "0.75114775", "0.7504308", "0.7466337", "0.73538816", "0.73237705", "0.72009385", "0.71532315", "0.7143435", "0.70679027", "0.7065211", "0.68900466", "0.6495203", "0.6303495", "0.62762886", "0.62031066", "0.61975324", "0.611186", "0.60808223", "0.6078109", "0.6051237", "0.6001153", "0.5995575", "0.59801877", "0.5960284", "0.59576535", "0.59442914", "0.5938382", "0.5925997", "0.5919122" ]

[ "def test_set_display_name_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_own_template_as_user_saves(self):\n mock_request = create_mock_request(user=self.user1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_upsert_global_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_config(self):\n self.assertEqual(self.view.template_name, \"resources/templanguage_admin.html\")", "def save(self, *args, **kwargs):\n if self.pk is None:\n if not self.name.startswith(TEMPLATE_PREFIX):\n self.name = f'{TEMPLATE_PREFIX}{self.name}'\n super(Template, self).save(*args, **kwargs)", "def test_register_template(self):\n pass", "def test_set_display_name_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_upsert_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_create_template_subsciption(self):\n pass", "def test_set_display_name_global_template_as_anonymous_with_access_right_access_raises_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def autoname(self):\n\t\tself.name = self.role_profile", "def test_update_template_registration(self):\n pass", "def autoname(self):\n self.name = datetime.datetime.strftime(datetime.datetime.now(), \"%y%m%d %H%M%S\") + \"_\" + self.participant_role", "def test_set_display_name_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_title(self):\n key = api.portal.get_registry_record(\n 'plone.site_title'\n )\n self.assertEqual(u'Briefy CMS', key)", "def test_upsert_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_delete_global_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.delete(self.fixture.global_template, request=mock_request)", "def display_name(self):", "def test_functionality(self):\n templateName = \"Test Template\"\n self.browserObject = globalVars.browserObject\n \n #Check for current logged in user\n self.verifyCurrentUser(userRole='Administrator', loginAsUser=True)\n \n #Deleting Standard User\n userList = self.getLocalUsers(userName=globalVars.standardUser)\n if len(userList) > 0:\n self.deleteLocalUser(globalVars.standardUser, verifyUser=True)\n \n #Creates Sample Template if not exists\n self.createSampleTemplate(templateName=templateName, deleteAndCreate=True, publishedTemplate=True)", "def test_retrieve_template_registration(self):\n pass", "def test_share_template_registration(self):\n pass", "def test_update_template_profile_for_system_module(self):\n pass", "def test_create_namespaced_template(self):\n pass", "def test_config(self):\n self.assertIs(self.view.model, TempLanguage)\n self.assertEqual(self.view.template_name, \"resources/templanguage_detail.html\")", "def template_name(self):\n\t\traise NotImplementedError('template_name must be defined')", "def test_template_feedback(self):\r\n pass" ]

[ "0.797732", "0.7899517", "0.7656996", "0.74912006", "0.7292097", "0.63268197", "0.63199025", "0.6077075", "0.60042024", "0.5964463", "0.5939839", "0.59352934", "0.5881993", "0.58463675", "0.5831961", "0.57987887", "0.5791329", "0.57893497", "0.5787537", "0.57783663", "0.5767516", "0.5669767", "0.5657676", "0.56473136", "0.56433237", "0.5629268", "0.5626993", "0.5601542", "0.55943996", "0.5591233" ]

[ "def test_set_display_name_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_own_template_as_user_saves(self):\n mock_request = create_mock_request(user=self.user1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_upsert_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_set_display_name_global_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_upsert_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_set_display_name_other_users_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def save(self, *args, **kwargs):\n if self.pk is None:\n if not self.name.startswith(TEMPLATE_PREFIX):\n self.name = f'{TEMPLATE_PREFIX}{self.name}'\n super(Template, self).save(*args, **kwargs)", "def test_upsert_own_template_as_user_saves(self):\n mock_request = create_mock_request(user=self.user1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_delete_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.delete(self.fixture.user1_template, request=mock_request)", "def autoname(self):\n\t\tself.name = self.role_profile", "def test_profile_route_uses_right_templates(self):\n self.add_testuser()\n response = self.client.get(\"/profile/testuser/\")\n self.assertTemplateUsed(response, \"layout.html\")", "def test_create_template_subsciption(self):\n pass", "def test_set_display_name_user_template_as_anonymous_with_access_right_access_raises_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_upsert_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.user2_template, request=mock_request)", "def test_set_display_name_user_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_upsert_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_create_with_username(self):\n properties = self.portal.portal_properties.site_properties\n properties.manage_changeProperties(use_email_as_login=True)\n\n user = api.user.create(\n username='chuck',\n email='[email protected]',\n password='secret',\n )\n self.assertEquals(user.getUserName(), '[email protected]')\n\n properties = self.portal.portal_properties.site_properties\n properties.manage_changeProperties(use_email_as_login=False)\n\n user = api.user.create(\n username='chuck',\n email='[email protected]',\n password='secret',\n )\n self.assertEquals(user.getUserName(), 'chuck')", "def test_set_display_name_global_template_as_anonymous_with_access_right_access_raises_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_user_command_createsuperadmin(self):\n management.call_command('createsuperadmin', '--force')\n user = UserModel.objects.get(\n username=\"admin\"\n )\n self.assertEqual(user.email, \"[email protected]\")\n self.assertEqual(user.username, \"admin\")", "def test_replace_user(self):\n pass", "def test_set_display_name_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_customization_template_crud():\n template_crud = pxe.CustomizationTemplate(\n name=generate_random_string(size=8),\n description=generate_random_string(size=16),\n image_type='RHEL-6',\n script_type='Kickstart',\n script_data='Testing the script')\n\n template_crud.create()\n with update(template_crud):\n template_crud.name = template_crud.name + \"_update\"\n template_crud.delete(cancel=False)", "def test_customization_template_crud():\n template_crud = pxe.CustomizationTemplate(\n name=generate_random_string(size=8),\n description=generate_random_string(size=16),\n image_type='RHEL-6',\n script_type='Kickstart',\n script_data='Testing the script')\n\n template_crud.create()\n with update(template_crud):\n template_crud.name = template_crud.name + \"_update\"\n template_crud.delete(cancel=False)", "def test_register_template(self):\n pass", "def test_upsert_global_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_get_form_label_name(self):\n self.user.name = 'Full Name'\n self.assertEqual(\n self.user.get_form_label(),\n 'Full Name (testuser)',\n )" ]

[ "0.8438995", "0.83652455", "0.833537", "0.8102639", "0.78686064", "0.68850815", "0.68802756", "0.6551571", "0.6550452", "0.65084565", "0.6417714", "0.6282435", "0.6254965", "0.62019694", "0.6200222", "0.6199461", "0.6178686", "0.6174682", "0.61705583", "0.6166246", "0.6165622", "0.61522186", "0.61121315", "0.6083355", "0.607221", "0.60686606", "0.60686606", "0.601896", "0.5937406", "0.5930861" ]

[ "def test_set_display_name_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_own_template_as_user_saves(self):\n mock_request = create_mock_request(user=self.user1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_other_users_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_upsert_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_replace_user(self):\n pass", "def test_create_with_username(self):\n properties = self.portal.portal_properties.site_properties\n properties.manage_changeProperties(use_email_as_login=True)\n\n user = api.user.create(\n username='chuck',\n email='[email protected]',\n password='secret',\n )\n self.assertEquals(user.getUserName(), '[email protected]')\n\n properties = self.portal.portal_properties.site_properties\n properties.manage_changeProperties(use_email_as_login=False)\n\n user = api.user.create(\n username='chuck',\n email='[email protected]',\n password='secret',\n )\n self.assertEquals(user.getUserName(), 'chuck')", "def test_get_form_label_name(self):\n self.user.name = 'Full Name'\n self.assertEqual(\n self.user.get_form_label(),\n 'Full Name (testuser)',\n )", "def test_user_command_createsuperadmin(self):\n management.call_command('createsuperadmin', '--force')\n user = UserModel.objects.get(\n username=\"admin\"\n )\n self.assertEqual(user.email, \"[email protected]\")\n self.assertEqual(user.username, \"admin\")", "def test_expansionusers_name(self):\n user1 = ExpansionUsers.objects.get(username=\"[email protected]\")\n user2 = ExpansionUsers.objects.get(username=\"[email protected]\")\n print user1.first_name, user1.last_name\n print user2.first_name, user2.last_name", "def autoname(self):\n\t\tself.name = self.role_profile", "def test_full_name(self):\n\n user = CustomUser.objects.get(email=\"[email protected]\")\n\n self.assertEqual(user.get_full_name(), \"TestName TestSecondName\")", "def test_upsert_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.user2_template, request=mock_request)", "def test_upsert_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_upsert_own_template_as_user_saves(self):\n mock_request = create_mock_request(user=self.user1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_profile_route_uses_right_templates(self):\n self.add_testuser()\n response = self.client.get(\"/profile/testuser/\")\n self.assertTemplateUsed(response, \"layout.html\")", "def test_get_form_label_first_last(self):\n self.user.first_name = 'Full'\n self.user.last_name = 'Name'\n self.assertEqual(\n self.user.get_form_label(email=True),\n 'Full Name (testuser) <[email protected]>',\n )", "def update_firstname(state: UserCreate, firstname: str) -> None:\n state.name.first = firstname\n state.slug = slugify(f\"super-user: {state.name.first} {state.name.last}\")", "def test_set_display_name_user_template_as_anonymous_with_access_right_access_raises_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_user_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_get_short_name_with_user(self):\n user1 = User.objects.get(email=\"[email protected]\")\n user2 = User.objects.get(email=\"[email protected]\")\n self.assertEqual(user1.get_short_name(), '[email protected]')\n self.assertEqual(user2.get_short_name(), '[email protected]')", "def test_delete_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.delete(self.fixture.user1_template, request=mock_request)", "def test_upsert_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def test_set_display_name_global_template_as_anonymous_with_access_right_access_raises_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_create(self):\n userValue = {'name': 'User Test 1',\n 'login': 'usertest1',\n 'user_profile_id': self.user_profile2.id,\n }\n Users = self.env['res.users']\n user_test = Users.create(userValue)\n newUser = self.env['res.users'].browse(user_test.id)\n self.assertEqual(userValue['name'], newUser['name'])", "def test_user_profile_setname(url):\n test_clear(url)\n admin_tk, admin_id = channel_user_create_0(url)\n\n test_profile = {\n 'token': admin_tk,\n 'u_id': admin_id\n }\n resp = requests.get(url + \"user/profile\", params=test_profile)\n profile_resp = resp.json()\n assert profile_resp['user']['u_id'] == admin_id\n assert profile_resp['user']['email'] == '[email protected]'\n assert profile_resp['user']['name_first'] == 'admin'\n assert profile_resp['user']['name_last'] == 'admin'\n\n test_profile_setname = {\n 'token': admin_tk,\n 'name_first': 'new_first',\n 'name_last': 'new_last'\n }\n requests.put(url + \"user/profile/setname\", json=test_profile_setname)\n \n test_profile = {\n 'token': admin_tk,\n 'u_id': admin_id\n }\n resp = requests.get(url + \"user/profile\", params=test_profile)\n profile_resp = resp.json()\n assert profile_resp['user']['u_id'] == admin_id\n assert profile_resp['user']['email'] == '[email protected]'\n assert profile_resp['user']['name_first'] == 'new_first'\n assert profile_resp['user']['name_last'] == 'new_last'" ]

[ "0.86954796", "0.84089637", "0.8315249", "0.81048167", "0.7789354", "0.68137443", "0.67180014", "0.671064", "0.66610336", "0.64608216", "0.64309955", "0.6357091", "0.6354265", "0.62896585", "0.6275033", "0.62726456", "0.6256851", "0.6253841", "0.6180666", "0.61602503", "0.6159232", "0.6144701", "0.61203706", "0.6108653", "0.6088398", "0.605461", "0.60220265", "0.59485894", "0.59469914", "0.594321" ]

[ "def test_set_display_name_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_other_users_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_own_template_as_user_saves(self):\n mock_request = create_mock_request(user=self.user1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_own_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_upsert_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_upsert_own_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.upsert(self.fixture.user1_template, request=mock_request)", "def save(self, *args, **kwargs):\n if self.pk is None:\n if not self.name.startswith(TEMPLATE_PREFIX):\n self.name = f'{TEMPLATE_PREFIX}{self.name}'\n super(Template, self).save(*args, **kwargs)", "def test_set_display_name_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_global_template_as_anonymous_with_access_right_access_raises_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def autoname(self):\n\t\tself.name = self.role_profile", "def test_config(self):\n self.assertEqual(self.view.template_name, \"resources/templanguage_admin.html\")", "def test_delete_global_template_as_superuser_saves(self):\n mock_request = create_mock_request(user=self.superuser1)\n template_api.delete(self.fixture.global_template, request=mock_request)", "def test_register_template(self):\n pass", "def test_update_template_profile_for_system_module(self):\n pass", "def test_set_display_name_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_set_display_name_other_users_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_upsert_global_template_as_staff_saves(self):\n mock_request = create_mock_request(user=self.staff_user1)\n template_api.upsert(self.fixture.global_template, request=mock_request)", "def test_functionality(self):\n templateName = \"Test Template\"\n self.browserObject = globalVars.browserObject\n \n #Check for current logged in user\n self.verifyCurrentUser(userRole='Administrator', loginAsUser=True)\n \n #Deleting Standard User\n userList = self.getLocalUsers(userName=globalVars.standardUser)\n if len(userList) > 0:\n self.deleteLocalUser(globalVars.standardUser, verifyUser=True)\n \n #Creates Sample Template if not exists\n self.createSampleTemplate(templateName=templateName, deleteAndCreate=True, publishedTemplate=True)", "def home_edituser():\n\tpass", "def test_customization_template_crud():\n template_crud = pxe.CustomizationTemplate(\n name=generate_random_string(size=8),\n description=generate_random_string(size=16),\n image_type='RHEL-6',\n script_type='Kickstart',\n script_data='Testing the script')\n\n template_crud.create()\n with update(template_crud):\n template_crud.name = template_crud.name + \"_update\"\n template_crud.delete(cancel=False)", "def test_customization_template_crud():\n template_crud = pxe.CustomizationTemplate(\n name=generate_random_string(size=8),\n description=generate_random_string(size=16),\n image_type='RHEL-6',\n script_type='Kickstart',\n script_data='Testing the script')\n\n template_crud.create()\n with update(template_crud):\n template_crud.name = template_crud.name + \"_update\"\n template_crud.delete(cancel=False)", "def test_create_template_subsciption(self):\n pass", "def test_profile_route_uses_right_templates(self):\n self.add_testuser()\n response = self.client.get(\"/profile/testuser/\")\n self.assertTemplateUsed(response, \"layout.html\")", "def test_update_template_registration(self):\n pass", "def test_replace_user(self):\n pass", "def test_create_with_username(self):\n properties = self.portal.portal_properties.site_properties\n properties.manage_changeProperties(use_email_as_login=True)\n\n user = api.user.create(\n username='chuck',\n email='[email protected]',\n password='secret',\n )\n self.assertEquals(user.getUserName(), '[email protected]')\n\n properties = self.portal.portal_properties.site_properties\n properties.manage_changeProperties(use_email_as_login=False)\n\n user = api.user.create(\n username='chuck',\n email='[email protected]',\n password='secret',\n )\n self.assertEquals(user.getUserName(), 'chuck')", "def test_user_command_createsuperadmin(self):\n management.call_command('createsuperadmin', '--force')\n user = UserModel.objects.get(\n username=\"admin\"\n )\n self.assertEqual(user.email, \"[email protected]\")\n self.assertEqual(user.username, \"admin\")", "def test_global_template_as_user_returns_template(self):\n mock_request = create_mock_request(user=self.user1)\n template = template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.global_template)" ]

[ "0.8349105", "0.8043521", "0.803114", "0.78980434", "0.76408404", "0.6944795", "0.6716076", "0.63315207", "0.6187099", "0.6185814", "0.6185624", "0.6144165", "0.6111398", "0.6052481", "0.6048025", "0.6025103", "0.6016196", "0.60104704", "0.59897846", "0.5963223", "0.59628075", "0.595675", "0.595675", "0.59353", "0.59280634", "0.5853178", "0.5845013", "0.58176553", "0.5811317", "0.58111846" ]

[ "def test_get_global_template_as_anonymous_with_access_right_returns_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n template = template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.global_template)", "def test_get_user_template_as_anonymous_with_access_right_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.get_by_id(\n self.fixture.user1_template.id, request=mock_request\n )", "def test_get_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )", "def test_get_all_as_anonymous_with_access_right_returns_global_templates(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 1)\n self.assertTrue((template.user is None for template in templates))", "def test_get_all_accessible_by_hash_as_anonymous_with_access_right_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_as_anonymous_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_set_display_name_user_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_get_all_accessible_by_hash_as_anonymous_with_access_right_returns_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 1)\n self.assertTrue((template.user is None for template in templates))", "def test_set_display_name_user_template_as_anonymous_with_access_right_access_raises_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_get_all_accessible_by_hash_list_as_anonymous_with_access_right_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_delete_user_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.delete(\n self.fixture.user1_template, request=mock_request\n )", "def test_get_all_as_user_returns_accessible_templates(self):\n mock_request = create_mock_request(user=self.user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 2)\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_anonymous_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_set_display_name_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_profile_route_uses_right_templates(self):\n self.add_testuser()\n response = self.client.get(\"/profile/testuser/\")\n self.assertTemplateUsed(response, \"layout.html\")", "def test_set_display_name_global_template_as_anonymous_with_access_right_access_raises_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_get_all_accessible_by_id_list_as_anonymous_with_access_right_returns_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_id_list(\n self.template_id_list, request=mock_request\n )\n self.assertTrue(templates.count() == 1)\n self.assertTrue((template.user is None for template in templates))", "def test_get_any_template_as_superuser_returns_template(self):\n mock_request = create_mock_request(user=self.superuser1)\n template = template_api.get_by_id(\n self.fixture.user1_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.user1_template)\n template = template_api.get_by_id(\n self.fixture.user2_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.user2_template)\n template = template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.global_template)", "def test_home_as_anonymous(self):\n response = self.client.get(\"/images/contents/\")\n self.assertEqual(response.status_code, 401)", "def test_home_as_anonymous(self):\n response = self.client.get(\"/images/contents/\")\n self.assertEqual(response.status_code, 401)", "def test_home_view_template(self):\n response = self.client.get(self.url)\n self.assertEqual(response.status_code, 200)\n self.assertTemplateUsed(response, 'user_data.html')", "def test_upsert_user_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user1_template, request=mock_request\n )", "def test_delete_user_template_as_anonymous_with_access_right_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.delete(\n self.fixture.user1_template, request=mock_request\n )", "def test_get_all_accessible_by_hash_list_as_anonymous_with_access_right_returns_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 1)\n self.assertTrue((template.user is None for template in templates))", "def test_global_template_as_user_returns_template(self):\n mock_request = create_mock_request(user=self.user1)\n template = template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.global_template)", "def test_upsert_user_template_as_anonymous_with_access_right_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user1_template, request=mock_request\n )", "def test_xblockcompletion_get_user_is_anonymous(self):\n client = Client()\n response = self.client.get(reverse('xblockcompletion-data:data'))\n request = response.request\n self.assertEqual(response.status_code, 404)", "def test_delete_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.delete(\n self.fixture.global_template, request=mock_request\n )", "def test_upsert_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.global_template, request=mock_request\n )", "def test_logged_in_uses_correct_template(self):\n login = self.client.login(\n username='testuser1',\n password='1X<ISRUkw+tuK'\n )\n response = self.client.get(reverse('my-borrowed'))\n\n # Check if user is logged in\n self.assertEqual(str(response.context['user']), 'testuser1')\n\n # Check response status is success(200)\n self.assertEqual(response.status_code, 200)\n\n # Check view uses correct template\n self.assertTemplateUsed(\n response,\n 'catalog/loaned_book_by_user.html'\n )" ]

[ "0.7613135", "0.7530476", "0.74307054", "0.7373814", "0.7083884", "0.70543534", "0.68818855", "0.68209565", "0.6811224", "0.6782865", "0.67101246", "0.6708908", "0.6702115", "0.6648804", "0.6645128", "0.6643842", "0.6637662", "0.66228014", "0.6600431", "0.6600431", "0.6591543", "0.6583339", "0.65542316", "0.6507907", "0.6503029", "0.6466591", "0.6461621", "0.64601374", "0.6457847", "0.6437014" ]

[ "def test_get_user_template_as_anonymous_raises_access_control_error(self):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.get_by_id(\n self.fixture.user1_template.id, request=mock_request\n )", "def test_get_global_template_as_anonymous_with_access_right_returns_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n template = template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.global_template)", "def test_get_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )", "def test_get_all_accessible_by_hash_as_anonymous_with_access_right_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_as_anonymous_with_access_right_returns_global_templates(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 1)\n self.assertTrue((template.user is None for template in templates))", "def test_get_all_accessible_by_hash_as_anonymous_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_list_as_anonymous_with_access_right_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_as_anonymous_with_access_right_returns_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 1)\n self.assertTrue((template.user is None for template in templates))", "def test_set_display_name_user_template_as_anonymous_with_access_right_access_raises_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_get_all_accessible_by_id_list_as_anonymous_with_access_right_returns_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_id_list(\n self.template_id_list, request=mock_request\n )\n self.assertTrue(templates.count() == 1)\n self.assertTrue((template.user is None for template in templates))", "def test_get_all_as_user_returns_accessible_templates(self):\n mock_request = create_mock_request(user=self.user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 2)\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_delete_user_template_as_anonymous_with_access_right_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.delete(\n self.fixture.user1_template, request=mock_request\n )", "def test_get_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.get_by_id(\n self.fixture.user2_template.id, request=mock_request\n )", "def test_upsert_user_template_as_anonymous_with_access_right_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user1_template, request=mock_request\n )", "def test_set_display_name_user_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user1_template, \"new_name\", request=mock_request\n )", "def test_get_other_users_template_raises_access_control_error(self):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.get_by_id(\n self.fixture.user2_template.id, request=mock_request\n )", "def test_delete_user_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.delete(\n self.fixture.user1_template, request=mock_request\n )", "def test_get_all_accessible_by_hash_list_as_anonymous_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_set_display_name_global_template_as_anonymous_with_access_right_access_raises_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_profile_route_uses_right_templates(self):\n self.add_testuser()\n response = self.client.get(\"/profile/testuser/\")\n self.assertTemplateUsed(response, \"layout.html\")", "def test_get_all_accessible_by_hash_list_as_anonymous_with_access_right_returns_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 1)\n self.assertTrue((template.user is None for template in templates))", "def test_upsert_global_template_as_anonymous_with_access_right_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.global_template, request=mock_request\n )", "def test_upsert_user_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user1_template, request=mock_request\n )", "def test_delete_global_template_as_anonymous_with_access_right_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.delete(\n self.fixture.global_template, request=mock_request\n )", "def test_get_any_template_as_superuser_returns_template(self):\n mock_request = create_mock_request(user=self.superuser1)\n template = template_api.get_by_id(\n self.fixture.user1_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.user1_template)\n template = template_api.get_by_id(\n self.fixture.user2_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.user2_template)\n template = template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.global_template)", "def test_allowed_if_superuser(self):\n\n @task_or_superuser_only\n def view(request):\n return HttpResponse(\"Hello\")\n\n class User(object):\n is_superuser = True\n is_authenticated = True\n\n request = self.factory.get(\"/\")\n request.user = None\n response = view(request)\n self.assertEqual(response.status_code, 403)\n\n request.user = User()\n response = view(request)\n self.assertEqual(response.status_code, 200)", "def test_logged_in_uses_correct_template(self):\n login = self.client.login(\n username='testuser1',\n password='1X<ISRUkw+tuK'\n )\n response = self.client.get(reverse('my-borrowed'))\n\n # Check if user is logged in\n self.assertEqual(str(response.context['user']), 'testuser1')\n\n # Check response status is success(200)\n self.assertEqual(response.status_code, 200)\n\n # Check view uses correct template\n self.assertTemplateUsed(\n response,\n 'catalog/loaned_book_by_user.html'\n )", "def test_set_display_name_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_delete_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.delete(\n self.fixture.global_template, request=mock_request\n )", "def test_get_non_owner(self):\n another_user = CustomUser(id=101, email='[email protected]', is_active=True)\n another_user.set_password('testpassword')\n another_user.save()\n self.client.login(email='[email protected]', password='testpassword')\n\n url = reverse('route', kwargs={'way_id': self.route.way_id, 'route_id': self.route.id})\n response = self.client.get(url)\n self.assertEqual(response.status_code, 403)" ]

[ "0.7802844", "0.761705", "0.74833226", "0.7385939", "0.73700815", "0.71119964", "0.7104591", "0.7072025", "0.70250964", "0.69441444", "0.69394386", "0.6929122", "0.6896489", "0.6861342", "0.6857833", "0.68518734", "0.68487626", "0.6787184", "0.67862386", "0.67814267", "0.677961", "0.6741332", "0.6727716", "0.67043173", "0.6674795", "0.6664192", "0.658799", "0.6566975", "0.65610045", "0.6559522" ]

[ "def test_get_global_template_as_anonymous_with_access_right_returns_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n template = template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.global_template)", "def test_get_all_as_anonymous_with_access_right_returns_global_templates(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 1)\n self.assertTrue((template.user is None for template in templates))", "def test_register_template(self):\n pass", "def test_retrieve_template_registration(self):\n pass", "def test_read_namespaced_template(self):\n pass", "def test_template(self):\n\t\tself.assertTemplateUsed(self.resp, 'inicio.html')", "def test_global_template_as_user_returns_template(self):\n mock_request = create_mock_request(user=self.user1)\n template = template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.global_template)", "def test_get_activity_template(self):\n pass", "def test_get_templates_in_virtualization_realm(self):\n pass", "def test_share_template_registration(self):\n pass", "def test_for_template(self):\n self.assertTemplateUsed(self.response, 'my_info_template.html')", "def test_template_feedback(self):\r\n pass", "def testTemplateGet(self):\n self.assertRaises(NotImplementedError, getattr,\n self.tempfile, 'template')", "def test_template_home(self):\n self.assertTemplateUsed(self.response, 'index.html')", "def test_correct_main_page_template(self):\n response = self.client.get('/')\n self.assertTemplateUsed(response, 'main.html')", "def test_unregister_template(self):\n pass", "def test_get_template_subscription(self):\n pass", "def test_get_user_template_as_anonymous_raises_access_control_error(self):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.get_by_id(\n self.fixture.user1_template.id, request=mock_request\n )", "def test_template(self):\n\t\tself.assertTemplateUsed(self.resp, 'cadastro.html')", "def test_config(self):\n self.assertEqual(self.view.template_name, \"resources/templanguage_admin.html\")", "def test_create_namespaced_template(self):\n pass", "def test_get_all_accessible_by_hash_as_anonymous_with_access_right_returns_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 1)\n self.assertTrue((template.user is None for template in templates))", "def test_set_display_name_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_correct_template(self):\n self.assertCorrectTemplateUsed('common/home.html')", "def test_delete_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.delete(\n self.fixture.global_template, request=mock_request\n )", "def test_unshare_template_registration(self):\n pass", "def test_create_namespaced_processed_template(self):\n pass", "def test_upsert_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.global_template, request=mock_request\n )", "def test_set_display_name_global_template_as_anonymous_with_access_right_access_raises_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.global_template, \"new_name\", request=mock_request\n )", "def test_create_template_subsciption(self):\n pass" ]

[ "0.785796", "0.71265125", "0.6954985", "0.68960994", "0.6858321", "0.6774985", "0.6732087", "0.6653357", "0.6604685", "0.6559678", "0.65291065", "0.6520919", "0.6491397", "0.64557844", "0.6435501", "0.6425238", "0.6417766", "0.64098907", "0.6396767", "0.6332146", "0.63056093", "0.6304798", "0.62850976", "0.6272534", "0.6249289", "0.62411815", "0.6204792", "0.62016195", "0.6194045", "0.6191536" ]

[ "def test_register_template(self):\n pass", "def test_template(self):\n\t\tself.assertTemplateUsed(self.resp, 'inicio.html')", "def test_global_template_as_user_returns_template(self):\n mock_request = create_mock_request(user=self.user1)\n template = template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.global_template)", "def test_retrieve_template_registration(self):\n pass", "def test_read_namespaced_template(self):\n pass", "def test_get_all_as_anonymous_with_access_right_returns_global_templates(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 1)\n self.assertTrue((template.user is None for template in templates))", "def test_for_template(self):\n self.assertTemplateUsed(self.response, 'my_info_template.html')", "def test_template(self):\n\t\tself.assertTemplateUsed(self.resp, 'cadastro.html')", "def test_get_activity_template(self):\n pass", "def T(request):\n\treturn all_templates[request.param]", "def test_templater(self):\n\n # Set a global templater for all items\n self.site.template(r\"(.*)\", lambda item: \"ALL\")\n # Set another templater on the index item\n self.site.template(r\"index.html\", lambda item: \"INDEX\")\n\n # Since an item can only have one templater, the index templater should have been overwritten\n self.assertEqual(\"INDEX\", self.site.items[\"index.html\"].templated)\n self.assertEqual(\"ALL\", self.site.items[\"test/test.html\"].templated)", "def test_theme_template_loading_by_prefix():\n app = create_ctfd()\n with app.test_request_context():\n tpl1 = render_template_string(\"{% extends 'core/page.html' %}\", content=\"test\")\n tpl2 = render_template(\"page.html\", content=\"test\")\n assert tpl1 == tpl2", "def test_template(project):\n project.add_mock_file(\"templates\", \"test.tmpl\", \"{{ value }}\")\n project.compile(\"\"\"import unittest\nvalue = \"1234\"\nstd::print(std::template(\"unittest/test.tmpl\"))\n \"\"\")\n\n assert project.get_stdout() == \"1234\\n\"", "def test_template_lookup_result_returned(self, template_override_mock):\n mock_template = mock.Mock()\n mock_template.name = 'site-1/base_site.html'\n request = mock.Mock()\n request.resolver_match.kwargs.get.return_value = 'site-1'\n template_override_mock.return_value = mock_template\n context = context_processors.decide_base_template(request)\n self.assertEqual(\n context['base_template'], 'site-1/base_site.html'\n )", "def test_get_template_subscription(self):\n pass", "def test_create_namespaced_template(self):\n pass", "def test_template_home(self):\n self.assertTemplateUsed(self.response, 'index.html')", "def test_get_tosca_template(self):\n pass", "def test_correct_main_page_template(self):\n response = self.client.get('/')\n self.assertTemplateUsed(response, 'main.html')", "def test_template_feedback(self):\r\n pass", "def test_create_namespaced_processed_template(self):\n pass", "def test_get_page_template_tag(self):\n context = Context({})\n pl1 = \"\"\"{% load pages_tags %}{% get_page get-page-slug as toto %}{{ toto }}\"\"\"\n template = get_template_from_string(pl1)\n self.assertEqual(template.render(context), u'None')\n page = self.new_page({'slug':'get-page-slug'})\n self.assertEqual(template.render(context), u'get-page-slug')", "def test_get_templates_in_virtualization_realm(self):\n pass", "def test_create_template_for_all_namespaces(self):\n pass", "def lookup_template(namespace, name):\r\n return LOOKUP[namespace].get_template(name)", "def test_share_template_registration(self):\n pass", "def test_template(self):\n self.assertTemplateUsed(self.response, 'formularios.html')", "def GetTemplate(self, _page_data):\n return self.template", "def test_replace_namespaced_template(self):\n pass", "def testTemplateGet(self):\n self.assertRaises(NotImplementedError, getattr,\n self.tempfile, 'template')" ]

[ "0.70452297", "0.6979728", "0.6953223", "0.6897253", "0.6785385", "0.67305106", "0.6662983", "0.6630868", "0.6611546", "0.6584987", "0.64204043", "0.6409127", "0.6400355", "0.63896936", "0.6384356", "0.6382421", "0.63582236", "0.63414955", "0.6315141", "0.63053435", "0.6300632", "0.6294936", "0.62853754", "0.62838537", "0.62665963", "0.6254365", "0.62350154", "0.62235653", "0.6219698", "0.6218512" ]

[ "def test_global_template_as_user_returns_template(self):\n mock_request = create_mock_request(user=self.user1)\n template = template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.global_template)", "def test_get_any_template_as_superuser_returns_template(self):\n mock_request = create_mock_request(user=self.superuser1)\n template = template_api.get_by_id(\n self.fixture.user1_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.user1_template)\n template = template_api.get_by_id(\n self.fixture.user2_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.user2_template)\n template = template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.global_template)", "def test_retrieve_template_registration(self):\n pass", "def test_template(self):\n\t\tself.assertTemplateUsed(self.resp, 'inicio.html')", "def test_for_template(self):\n self.assertTemplateUsed(self.response, 'my_info_template.html')", "def test_get_activity_template(self):\n pass", "def GetTemplate(self, _page_data):\n return self.template", "def test_get_global_template_as_anonymous_with_access_right_returns_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n template = template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.global_template)", "def test_template(self):\n\t\tself.assertTemplateUsed(self.resp, 'cadastro.html')", "def test_get_template_subscription(self):\n pass", "def test_get_subscription_template(self):\n pass", "def test_correct_template_is_used(self):\n login = self.client.login(username='test_user1', password='test_user1_test')\n response = self.client.get('/search/result/?q=apples')\n \n self.assertEqual(response.context['user'].username, 'test_user1')\n self.assertEqual(response.status_code, 200)\n self.assertTemplateUsed(response,'search/savedcharts.html')", "def test_correct_template_is_used(self):\n login = self.client.login(username='test_user1', password='test_user1_test')\n response = self.client.get(reverse('search:all_charts'))\n\n self.assertEqual(response.context['user'].username, 'test_user1')\n self.assertEqual(response.status_code, 200)\n self.assertTemplateUsed(response,'search/savedcharts.html')", "def test_get_template_data(self, mock_gsiup):\n mock_gsiup.return_value = models.UserPref(\n email='[email protected]')\n with test_app.test_request_context(self.request_path):\n template_data = self.handler.get_template_data()\n\n # Everything is done in JS, so there is no template_data\n self.assertEqual({}, template_data)", "def get_template(self):\n if self.get_website:\n return self.get_website.get_template()\n else:\n return default_entity.get_website.get_template()", "def test_home_view_template(self):\n response = self.client.get(self.url)\n self.assertEqual(response.status_code, 200)\n self.assertTemplateUsed(response, 'user_data.html')", "def test_profile_route_uses_right_templates(self):\n self.add_testuser()\n response = self.client.get(\"/profile/testuser/\")\n self.assertTemplateUsed(response, \"layout.html\")", "def test_template_lookup_result_returned(self, template_override_mock):\n mock_template = mock.Mock()\n mock_template.name = 'site-1/base_site.html'\n request = mock.Mock()\n request.resolver_match.kwargs.get.return_value = 'site-1'\n template_override_mock.return_value = mock_template\n context = context_processors.decide_base_template(request)\n self.assertEqual(\n context['base_template'], 'site-1/base_site.html'\n )", "def get_template(self):\n endpoint = \"/isam/wga_templates/dynurl_template\"\n response = self.client.get_json(endpoint)\n response.success = response.status_code == 200\n return response", "def test_get_all_as_user_returns_accessible_templates(self):\n mock_request = create_mock_request(user=self.user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 2)\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_template_success(self):\n template_id = util.MOCK_UUID_1\n\n rv = TEST_CLIENT.get(f\"/templates/{template_id}\")\n result = rv.json()\n\n expected = util.MOCK_TEMPLATE_1\n self.assertEqual(result, expected)\n self.assertEqual(rv.status_code, 200)", "def test_view_uses_correct_template(self):\n response = self.client.get(reverse('home'))\n self.assertEqual(response.status_code, 200)\n self.assertTemplateUsed(response, 'home.html')", "def testTemplateGet(self):\n self.assertRaises(NotImplementedError, getattr,\n self.tempfile, 'template')", "def test_template(self):\n self.assertTemplateUsed(self.response, 'formularios.html')", "def test_get_tosca_template(self):\n pass", "def test_register_template(self):\n pass", "def get_template(self, template):\n\n\n env = Environment(\n loader=FileSystemLoader('templates')\n )\n return env.get_template(template)", "def get_template(self):\n return self.template", "def test_create_template_subsciption(self):\n pass", "def test_render_template(self):\n template = self.block.meta.template\n self.assertEqual(template, 'common/blocks/journals_tab_block.html', 'Templates were not the same')" ]

[ "0.7584183", "0.7570242", "0.72331774", "0.70984966", "0.7098218", "0.7063988", "0.7001504", "0.6864687", "0.68602484", "0.68589157", "0.68428886", "0.683652", "0.6823558", "0.6793858", "0.678562", "0.6754005", "0.67517126", "0.6653689", "0.6648483", "0.663962", "0.6636065", "0.6633312", "0.6623896", "0.66213876", "0.6568499", "0.65636396", "0.6492114", "0.647311", "0.64674735", "0.6467388" ]

[ "def test_template(self):\n\t\tself.assertTemplateUsed(self.resp, 'inicio.html')", "def test_for_template(self):\n self.assertTemplateUsed(self.response, 'my_info_template.html')", "def test_register_template(self):\n pass", "def test_correct_template(self):\n self.assertCorrectTemplateUsed('common/home.html')", "def test_correct_main_page_template(self):\n response = self.client.get('/')\n self.assertTemplateUsed(response, 'main.html')", "def test_retrieve_template_registration(self):\n pass", "def test_template(self):\n\t\tself.assertTemplateUsed(self.resp, 'cadastro.html')", "def test_get_global_template_as_anonymous_with_access_right_returns_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n template = template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.global_template)", "def test_template_home(self):\n self.assertTemplateUsed(self.response, 'index.html')", "def test_template(self):\n self.assertTemplateUsed(self.response, 'formularios.html')", "def test_template_lookup_result_returned(self, template_override_mock):\n mock_template = mock.Mock()\n mock_template.name = 'site-1/base_site.html'\n request = mock.Mock()\n request.resolver_match.kwargs.get.return_value = 'site-1'\n template_override_mock.return_value = mock_template\n context = context_processors.decide_base_template(request)\n self.assertEqual(\n context['base_template'], 'site-1/base_site.html'\n )", "def test_get_any_template_as_superuser_returns_template(self):\n mock_request = create_mock_request(user=self.superuser1)\n template = template_api.get_by_id(\n self.fixture.user1_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.user1_template)\n template = template_api.get_by_id(\n self.fixture.user2_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.user2_template)\n template = template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.global_template)", "def test_config(self):\n self.assertEqual(self.view.template_name, \"resources/templanguage_admin.html\")", "def test_view_uses_correct_template(self):\n response = self.client.get(reverse('home'))\n self.assertEqual(response.status_code, 200)\n self.assertTemplateUsed(response, 'home.html')", "def test_home_view_template(self):\n response = self.client.get(self.url)\n self.assertEqual(response.status_code, 200)\n self.assertTemplateUsed(response, 'user_data.html')", "def test_correct_template_is_used(self):\n login = self.client.login(username='test_user1', password='test_user1_test')\n response = self.client.get('/search/result/?q=apples')\n \n self.assertEqual(response.context['user'].username, 'test_user1')\n self.assertEqual(response.status_code, 200)\n self.assertTemplateUsed(response,'search/savedcharts.html')", "def test_template_feedback(self):\r\n pass", "def test_templater(self):\n\n # Set a global templater for all items\n self.site.template(r\"(.*)\", lambda item: \"ALL\")\n # Set another templater on the index item\n self.site.template(r\"index.html\", lambda item: \"INDEX\")\n\n # Since an item can only have one templater, the index templater should have been overwritten\n self.assertEqual(\"INDEX\", self.site.items[\"index.html\"].templated)\n self.assertEqual(\"ALL\", self.site.items[\"test/test.html\"].templated)", "def test_theme_template_loading_by_prefix():\n app = create_ctfd()\n with app.test_request_context():\n tpl1 = render_template_string(\"{% extends 'core/page.html' %}\", content=\"test\")\n tpl2 = render_template(\"page.html\", content=\"test\")\n assert tpl1 == tpl2", "def test_correct_template_is_used(self):\n login = self.client.login(username='test_user1', password='test_user1_test')\n response = self.client.get(reverse('search:all_charts'))\n\n self.assertEqual(response.context['user'].username, 'test_user1')\n self.assertEqual(response.status_code, 200)\n self.assertTemplateUsed(response,'search/savedcharts.html')", "def test_home_route_uses_right_templates(self):\n response = self.client.get(\"/\")\n self.assertTemplateUsed(response, \"layout.html\")", "def test_share_template_registration(self):\n pass", "def test_render_template(self):\n template = self.block.meta.template\n self.assertEqual(template, 'common/blocks/google_calendar.html', 'The templates are not the same')", "def _get_template(self):\n # Get templates and put them in the order of importance:\n # 1. template specified in \"modules.yaml\"\n # 2. template specified in a package directly\n # 3. default template (must be defined, check in __init__)\n module_system_name = str(self.module.__name__).split(\".\")[-1]\n package_attribute = \"{0}_template\".format(module_system_name)\n choices = [\n self.conf.template,\n getattr(self.spec.package, package_attribute, None),\n self.default_template, # This is always defined at this point\n ]\n # Filter out false-ish values\n choices = list(filter(lambda x: bool(x), choices))\n # ... and return the first match\n return choices.pop(0)", "def test_get_own_template_as_user_returns_template(self):\n mock_request = create_mock_request(user=self.user1)\n template = template_api.get_by_id(\n self.fixture.user1_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.user1_template)", "def test_search_template(self):\n self.assertTemplateUsed(self.response, 'rango/search.html', f\"{FAILURE_HEADER}Your search() view does not use the expected template.{FAILURE_FOOTER}\")", "def test_get_activity_template(self):\n pass", "def test_templates(self):\n path = str(Template())\n self.assertTrue(os.path.exists(path))", "def test_render_template(self):\n template = self.block.meta.template\n self.assertEqual(template, 'common/blocks/journals_tab_block.html', 'Templates were not the same')", "def test_create_template_subsciption(self):\n pass" ]

[ "0.7413665", "0.71893036", "0.71573037", "0.7118237", "0.70851064", "0.70015204", "0.70013285", "0.69383097", "0.69311833", "0.6842954", "0.6815864", "0.6794427", "0.675918", "0.67283905", "0.67238855", "0.67194635", "0.67149615", "0.66608965", "0.66568184", "0.6656136", "0.6604196", "0.65992594", "0.6572148", "0.65539294", "0.6552954", "0.6542512", "0.6527986", "0.65254647", "0.6521116", "0.6491365" ]

[ "def test_get_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.get_by_id(\n self.fixture.user2_template.id, request=mock_request\n )", "def test_get_all_as_user_returns_accessible_templates(self):\n mock_request = create_mock_request(user=self.user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 2)\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_any_template_as_superuser_returns_template(self):\n mock_request = create_mock_request(user=self.superuser1)\n template = template_api.get_by_id(\n self.fixture.user1_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.user1_template)\n template = template_api.get_by_id(\n self.fixture.user2_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.user2_template)\n template = template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.global_template)", "def test_get_user_template_as_anonymous_with_access_right_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.get_by_id(\n self.fixture.user1_template.id, request=mock_request\n )", "def test_get_all_accessible_by_hash_as_superuser_returns_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user2_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_own_template_as_user_returns_template(self):\n mock_request = create_mock_request(user=self.user1)\n template = template_api.get_by_id(\n self.fixture.user1_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.user1_template)", "def test_get_user_template_as_anonymous_raises_access_control_error(self):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.get_by_id(\n self.fixture.user1_template.id, request=mock_request\n )", "def test_get_all_accessible_by_hash_list_as_superuser_returns_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user2_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_user_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user2_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_global_template_as_anonymous_with_access_right_returns_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n template = template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.global_template)", "def test_get_all_accessible_by_hash_as_anonymous_with_access_right_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_as_superuser_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_as_staff_returns_accessible_templates(self):\n mock_request = create_mock_request(user=self.staff_user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 2)\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_as_anonymous_with_access_right_returns_global_templates(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 1)\n self.assertTrue((template.user is None for template in templates))", "def test_profile_route_uses_right_templates(self):\n self.add_testuser()\n response = self.client.get(\"/profile/testuser/\")\n self.assertTemplateUsed(response, \"layout.html\")", "def test_get_all_accessible_by_hash_as_staff_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user2_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_user_returns_user_template(self):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_anonymous_with_access_right_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_non_owner(self):\n another_user = CustomUser(id=101, email='[email protected]', is_active=True)\n another_user.set_password('testpassword')\n another_user.save()\n self.client.login(email='[email protected]', password='testpassword')\n\n url = reverse('route', kwargs={'way_id': self.route.way_id, 'route_id': self.route.id})\n response = self.client.get(url)\n self.assertEqual(response.status_code, 403)", "def test_global_template_as_user_returns_template(self):\n mock_request = create_mock_request(user=self.user1)\n template = template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.global_template)", "def test_get_all_accessible_by_hash_list_as_user_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user2_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_global_template_as_anonymous_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )", "def test_detail_not_contributor_forbidden(self):\n self.login(self.user1)\n resp = self.client.get(self.get_url(self.c2.pk))\n self.assert403(resp)", "def test_set_display_name_other_users_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_get_all_accessible_by_hash_as_superuser_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_delete_other_users_template_as_user_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.delete(\n self.fixture.user2_template, request=mock_request\n )", "def test_delete_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.delete(\n self.fixture.user2_template, request=mock_request\n )", "def test_detailview_read_for_wrong_user(self):\n\n for user in self.users:\n detailview = reverse('account_detail', args=(user.uuid,))\n\n other_users = self.users\n other_users.remove(user)\n random_user = random.choice(self.users)\n\n self.client.login(email=random_user.email, password='letmein')\n\n response = self.client.get(detailview)\n\n self.assertEqual(response.status_code, 403)", "def test_get_all_accessible_by_hash_list_as_superuser_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_staff_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user2_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))" ]

[ "0.77614397", "0.744975", "0.7427578", "0.74270964", "0.73795503", "0.7345958", "0.7273537", "0.71408963", "0.70783716", "0.70651674", "0.7050977", "0.7047117", "0.7017474", "0.6984865", "0.69814235", "0.6955635", "0.69546133", "0.6926745", "0.691739", "0.68871033", "0.68857586", "0.6845435", "0.679227", "0.67907417", "0.6784877", "0.67842543", "0.67618877", "0.675162", "0.6730873", "0.6725665" ]

[ "def test_get_own_template_as_user_returns_template(self):\n mock_request = create_mock_request(user=self.user1)\n template = template_api.get_by_id(\n self.fixture.user1_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.user1_template)", "def test_get_all_as_user_returns_accessible_templates(self):\n mock_request = create_mock_request(user=self.user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 2)\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_as_superuser_returns_all_templates(self):\n mock_request = create_mock_request(user=self.superuser)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 3)\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_superuser_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_global_template_as_user_returns_template(self):\n mock_request = create_mock_request(user=self.user1)\n template = template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.global_template)", "def test_get_all_as_staff_returns_accessible_templates(self):\n mock_request = create_mock_request(user=self.staff_user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 2)\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_superuser_returns_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user2_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_profile_route_uses_right_templates(self):\n self.add_testuser()\n response = self.client.get(\"/profile/testuser/\")\n self.assertTemplateUsed(response, \"layout.html\")", "def test_get_all_accessible_by_hash_list_as_superuser_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_home_view_template(self):\n response = self.client.get(self.url)\n self.assertEqual(response.status_code, 200)\n self.assertTemplateUsed(response, 'user_data.html')", "def test_retrieve_template_registration(self):\n pass", "def test_get_all_accessible_by_hash_as_superuser_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_superuser_returns_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user2_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_template(self):\n\t\tself.assertTemplateUsed(self.resp, 'inicio.html')", "def test_for_template(self):\n self.assertTemplateUsed(self.response, 'my_info_template.html')", "def test_get_all_accessible_by_hash_as_staff_returns_user_template(self):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_templates_in_virtualization_realm(self):\n pass", "def test_get_all_accessible_by_hash_as_user_returns_user_template(self):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_correct_template_is_used(self):\n login = self.client.login(username='test_user1', password='test_user1_test')\n response = self.client.get('/search/result/?q=apples')\n \n self.assertEqual(response.context['user'].username, 'test_user1')\n self.assertEqual(response.status_code, 200)\n self.assertTemplateUsed(response,'search/savedcharts.html')", "def test_get_all_accessible_by_hash_list_as_superuser_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_correct_template_is_used(self):\n login = self.client.login(username='test_user1', password='test_user1_test')\n response = self.client.get(reverse('search:all_charts'))\n\n self.assertEqual(response.context['user'].username, 'test_user1')\n self.assertEqual(response.status_code, 200)\n self.assertTemplateUsed(response,'search/savedcharts.html')", "def test_template(self):\n\t\tself.assertTemplateUsed(self.resp, 'cadastro.html')", "def test_get_global_template_as_anonymous_with_access_right_returns_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n template = template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.global_template)", "def test_get_all_accessible_by_id_list_as_superuser_returns_accessible_templates(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_id_list(\n self.template_id_list, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_template_subscription(self):\n pass", "def test_get_all_accessible_by_hash_list_as_staff_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_register_template(self):\n pass", "def test_get_all_accessible_by_hash_list_as_user_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_template(self):\n self.assertTemplateUsed(self.response, 'formularios.html')", "def test_get_all_as_anonymous_with_access_right_returns_global_templates(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 1)\n self.assertTrue((template.user is None for template in templates))" ]

[ "0.7339057", "0.7293115", "0.72650164", "0.7177737", "0.71384394", "0.7035053", "0.69855136", "0.6984406", "0.69122374", "0.68956125", "0.6870337", "0.6849097", "0.68091345", "0.6803988", "0.6782561", "0.6699082", "0.6676653", "0.66753626", "0.6625917", "0.6607886", "0.6598229", "0.65615445", "0.64661396", "0.6459205", "0.6447713", "0.64471996", "0.64246136", "0.6421988", "0.64184517", "0.64160997" ]

[ "def test_get_all_as_staff_returns_accessible_templates(self):\n mock_request = create_mock_request(user=self.staff_user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 2)\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_any_template_as_superuser_returns_template(self):\n mock_request = create_mock_request(user=self.superuser1)\n template = template_api.get_by_id(\n self.fixture.user1_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.user1_template)\n template = template_api.get_by_id(\n self.fixture.user2_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.user2_template)\n template = template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.global_template)", "def test_get_other_users_template_raises_access_control_error(self):\n mock_request = create_mock_request(user=self.user1)\n with self.assertRaises(AccessControlError):\n template_api.get_by_id(\n self.fixture.user2_template.id, request=mock_request\n )", "def test_get_all_as_user_returns_accessible_templates(self):\n mock_request = create_mock_request(user=self.user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 2)\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_superuser_returns_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user2_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_own_template_as_user_returns_template(self):\n mock_request = create_mock_request(user=self.user1)\n template = template_api.get_by_id(\n self.fixture.user1_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.user1_template)", "def test_get_all_accessible_by_hash_as_staff_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user2_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_staff_returns_user_template(self):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_user_template_as_anonymous_with_access_right_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.get_by_id(\n self.fixture.user1_template.id, request=mock_request\n )", "def test_get_all_accessible_by_hash_list_as_superuser_returns_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user2_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_staff_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user2_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_superuser_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_global_template_as_anonymous_with_access_right_returns_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n template = template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.global_template)", "def test_set_display_name_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.set_display_name(\n self.fixture.user2_template, \"new_name\", request=mock_request\n )", "def test_delete_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.delete(\n self.fixture.user2_template, request=mock_request\n )", "def test_get_user_template_as_anonymous_raises_access_control_error(self):\n mock_request = create_mock_request(user=self.anonymous_user)\n with self.assertRaises(AccessControlError):\n template_api.get_by_id(\n self.fixture.user1_template.id, request=mock_request\n )", "def test_get_all_accessible_by_hash_list_as_staff_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_as_anonymous_with_access_right_returns_global_templates(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 1)\n self.assertTrue((template.user is None for template in templates))", "def test_profile_route_uses_right_templates(self):\n self.add_testuser()\n response = self.client.get(\"/profile/testuser/\")\n self.assertTemplateUsed(response, \"layout.html\")", "def test_get_all_accessible_by_hash_as_staff_returns_global_template(self):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_upsert_other_users_template_as_staff_raises_access_control_error(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n with self.assertRaises(AccessControlError):\n template_api.upsert(\n self.fixture.user2_template, request=mock_request\n )", "def test_global_template_as_user_returns_template(self):\n mock_request = create_mock_request(user=self.user1)\n template = template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.global_template)", "def test_get_all_accessible_by_hash_as_anonymous_with_access_right_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_id_list_as_staff_returns_accessible_templates(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_id_list(\n self.template_id_list, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_superuser_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_user_returns_user_template(self):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_anonymous_with_access_right_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_list_as_superuser_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_user_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user2_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_id_list_as_superuser_returns_accessible_templates(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_id_list(\n self.template_id_list, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))" ]

[ "0.7629151", "0.7563176", "0.7399048", "0.7349483", "0.7239654", "0.72377974", "0.71758187", "0.7138686", "0.7097173", "0.70346177", "0.69860995", "0.69852465", "0.6982948", "0.6961766", "0.69112176", "0.68938357", "0.6879274", "0.68733513", "0.68609065", "0.6852134", "0.68514264", "0.6834315", "0.67852104", "0.6782215", "0.674879", "0.6721703", "0.67022896", "0.6701556", "0.6701198", "0.6693769" ]

[ "def test_get_all_accessible_by_id_list_as_superuser_returns_accessible_templates(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_id_list(\n self.template_id_list, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_id_list_as_staff_returns_accessible_templates(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_id_list(\n self.template_id_list, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_as_user_returns_accessible_templates(self):\n mock_request = create_mock_request(user=self.user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 2)\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_id_list_as_anonymous_with_access_right_returns_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_id_list(\n self.template_id_list, request=mock_request\n )\n self.assertTrue(templates.count() == 1)\n self.assertTrue((template.user is None for template in templates))", "def test_get_all_accessible_by_hash_list_as_user_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_as_staff_returns_accessible_templates(self):\n mock_request = create_mock_request(user=self.staff_user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 2)\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_anonymous_with_access_right_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_list_as_superuser_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_staff_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_user_returns_user_template(self):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_anonymous_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_list_as_user_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_anonymous_with_access_right_returns_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 1)\n self.assertTrue((template.user is None for template in templates))", "def test_get_all_accessible_by_hash_as_superuser_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_user_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user2_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_id_list_as_anonymous_returns_nothing(self):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_id_list(\n self.template_id_list, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_as_superuser_returns_all_templates(self):\n mock_request = create_mock_request(user=self.superuser)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 3)\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_superuser_returns_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user2_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_staff_returns_user_template(self):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_superuser_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_anonymous_with_access_right_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_as_anonymous_with_access_right_returns_global_templates(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 1)\n self.assertTrue((template.user is None for template in templates))", "def test_get_all_accessible_by_hash_list_as_staff_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_user_returns_global_template(self):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_staff_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user2_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_superuser_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_superuser_returns_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user2_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_anonymous_with_access_right_returns_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 1)\n self.assertTrue((template.user is None for template in templates))", "def test_get_all_accessible_by_hash_as_user_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user2_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_as_anonymous_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)" ]

[ "0.8352081", "0.80351096", "0.79949486", "0.7815422", "0.7592258", "0.7508703", "0.74799454", "0.74594754", "0.73707", "0.73137105", "0.7222853", "0.72029865", "0.7198696", "0.7193153", "0.7169572", "0.71223384", "0.7113321", "0.7107858", "0.7107429", "0.7094072", "0.7044061", "0.7014902", "0.70113677", "0.6812363", "0.6806468", "0.67862624", "0.6783991", "0.67820954", "0.6771787", "0.67148715" ]

[ "def test_get_all_accessible_by_id_list_as_superuser_returns_accessible_templates(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_id_list(\n self.template_id_list, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_id_list_as_user_returns_accessible_templates(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_id_list(\n self.template_id_list, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_as_staff_returns_accessible_templates(self):\n mock_request = create_mock_request(user=self.staff_user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 2)\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_id_list_as_anonymous_with_access_right_returns_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_id_list(\n self.template_id_list, request=mock_request\n )\n self.assertTrue(templates.count() == 1)\n self.assertTrue((template.user is None for template in templates))", "def test_get_all_accessible_by_hash_list_as_staff_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_as_user_returns_accessible_templates(self):\n mock_request = create_mock_request(user=self.user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 2)\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_staff_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_staff_returns_user_template(self):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_anonymous_with_access_right_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_id_list_as_anonymous_returns_nothing(self):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_id_list(\n self.template_id_list, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_list_as_superuser_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_user_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_staff_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user2_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_anonymous_with_access_right_returns_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 1)\n self.assertTrue((template.user is None for template in templates))", "def test_get_all_accessible_by_hash_as_staff_returns_global_template(self):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_anonymous_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_list_as_superuser_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_superuser_returns_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user2_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_superuser_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_user_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_anonymous_with_access_right_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_list_as_user_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user2_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_as_user_returns_user_template(self):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_as_superuser_returns_all_templates(self):\n mock_request = create_mock_request(user=self.superuser)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 3)\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_staff_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user2_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_as_anonymous_with_access_right_returns_global_templates(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 1)\n self.assertTrue((template.user is None for template in templates))", "def test_get_all_accessible_by_hash_as_anonymous_with_access_right_returns_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 1)\n self.assertTrue((template.user is None for template in templates))", "def test_get_all_accessible_by_hash_as_superuser_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_superuser_returns_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user2_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_permission_resource_list(self):\n for i in API_MODELS_LOOKUP + API_MODELS:\n url = reverse('api:{}_api_resource'.format(i))\n self.client.logout()\n response = self.client.get(url) # Anonymous user\n self.assertEqual(response.status_code, 200)\n self.client.login(username='normaluser', password='pass')\n response = self.client.get(url)\n self.assertEqual(response.status_code, 200)\n self.client.login(username='readonlyuser', password='pass')\n response = self.client.get(url)\n self.assertEqual(response.status_code, 200)" ]

[ "0.82006174", "0.8090239", "0.77482426", "0.75997865", "0.7364636", "0.7320834", "0.7100239", "0.709316", "0.70638084", "0.6977362", "0.6968302", "0.6900248", "0.6848204", "0.68399364", "0.6752305", "0.67282224", "0.66968644", "0.6675989", "0.6672316", "0.6604715", "0.6595715", "0.65856385", "0.6573663", "0.6568465", "0.654624", "0.645865", "0.6386813", "0.6365158", "0.6332485", "0.62987024" ]

[ "def test_get_all_accessible_by_id_list_as_user_returns_accessible_templates(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_id_list(\n self.template_id_list, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_id_list_as_staff_returns_accessible_templates(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_id_list(\n self.template_id_list, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_as_user_returns_accessible_templates(self):\n mock_request = create_mock_request(user=self.user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 2)\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_id_list_as_anonymous_with_access_right_returns_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_id_list(\n self.template_id_list, request=mock_request\n )\n self.assertTrue(templates.count() == 1)\n self.assertTrue((template.user is None for template in templates))", "def test_get_all_as_staff_returns_accessible_templates(self):\n mock_request = create_mock_request(user=self.staff_user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 2)\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_superuser_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_anonymous_with_access_right_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_list_as_user_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_staff_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_as_superuser_returns_all_templates(self):\n mock_request = create_mock_request(user=self.superuser)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 3)\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_superuser_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_superuser_returns_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user2_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_superuser_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_id_list_as_anonymous_returns_nothing(self):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_id_list(\n self.template_id_list, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_list_as_anonymous_with_access_right_returns_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 1)\n self.assertTrue((template.user is None for template in templates))", "def test_get_all_accessible_by_hash_list_as_anonymous_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_as_user_returns_user_template(self):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_user_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user2_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_as_staff_returns_user_template(self):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_user_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_staff_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_anonymous_with_access_right_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_as_superuser_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_superuser_returns_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user2_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_staff_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user2_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_as_anonymous_with_access_right_returns_global_templates(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 1)\n self.assertTrue((template.user is None for template in templates))", "def test_get_all_accessible_by_hash_as_staff_returns_global_template(self):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_permission_resource_list(self):\n for i in API_MODELS_LOOKUP + API_MODELS:\n url = reverse('api:{}_api_resource'.format(i))\n self.client.logout()\n response = self.client.get(url) # Anonymous user\n self.assertEqual(response.status_code, 200)\n self.client.login(username='normaluser', password='pass')\n response = self.client.get(url)\n self.assertEqual(response.status_code, 200)\n self.client.login(username='readonlyuser', password='pass')\n response = self.client.get(url)\n self.assertEqual(response.status_code, 200)", "def test_get_any_template_as_superuser_returns_template(self):\n mock_request = create_mock_request(user=self.superuser1)\n template = template_api.get_by_id(\n self.fixture.user1_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.user1_template)\n template = template_api.get_by_id(\n self.fixture.user2_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.user2_template)\n template = template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.global_template)", "def test_get_all_accessible_by_hash_as_anonymous_with_access_right_returns_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 1)\n self.assertTrue((template.user is None for template in templates))" ]

[ "0.8283416", "0.8071495", "0.7812368", "0.7686281", "0.7590276", "0.7461408", "0.73253256", "0.7286531", "0.72477025", "0.7221876", "0.7189584", "0.7163987", "0.71550506", "0.7076607", "0.70374113", "0.7007362", "0.6996137", "0.6994254", "0.69909936", "0.6976883", "0.6971435", "0.68669784", "0.684167", "0.68350774", "0.6767802", "0.674829", "0.6641443", "0.6614265", "0.6611149", "0.6592106" ]

[ "def test_get_all_accessible_by_hash_as_user_returns_user_template(self):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_anonymous_with_access_right_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_as_superuser_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_user_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_anonymous_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_as_anonymous_with_access_right_returns_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 1)\n self.assertTrue((template.user is None for template in templates))", "def test_get_all_accessible_by_hash_list_as_anonymous_with_access_right_returns_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 1)\n self.assertTrue((template.user is None for template in templates))", "def test_get_all_accessible_by_hash_list_as_anonymous_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_list_as_superuser_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_staff_returns_user_template(self):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_user_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user2_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_as_user_returns_global_template(self):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_superuser_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_user_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user2_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_list_as_user_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_staff_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_superuser_returns_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user2_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_superuser_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_superuser_returns_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user2_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_staff_returns_global_template(self):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_staff_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_staff_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user2_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_anonymous_does_not_return_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_list_as_anonymous_does_not_return_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_as_user_returns_accessible_templates(self):\n mock_request = create_mock_request(user=self.user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 2)\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_staff_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user2_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_as_anonymous_with_access_right_returns_global_templates(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 1)\n self.assertTrue((template.user is None for template in templates))", "def test_get_all_accessible_by_id_list_as_anonymous_with_access_right_returns_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_id_list(\n self.template_id_list, request=mock_request\n )\n self.assertTrue(templates.count() == 1)\n self.assertTrue((template.user is None for template in templates))", "def test_get_all_accessible_by_id_list_as_user_returns_accessible_templates(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_id_list(\n self.template_id_list, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_id_list_as_superuser_returns_accessible_templates(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_id_list(\n self.template_id_list, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))" ]

[ "0.8095653", "0.806779", "0.80041444", "0.7907132", "0.78913945", "0.7886816", "0.78815126", "0.78513587", "0.7806266", "0.78028685", "0.77374506", "0.7678337", "0.7658116", "0.7651516", "0.764455", "0.76145715", "0.76107323", "0.75198156", "0.74943686", "0.74373174", "0.73494947", "0.73231965", "0.72596925", "0.7246245", "0.71592957", "0.7140907", "0.70216334", "0.6815881", "0.6720545", "0.6607452" ]

[ "def test_get_all_accessible_by_hash_list_as_anonymous_with_access_right_returns_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 1)\n self.assertTrue((template.user is None for template in templates))", "def test_get_all_accessible_by_hash_as_anonymous_does_not_return_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_list_as_anonymous_does_not_return_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_as_user_returns_global_template(self):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_superuser_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_user_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_staff_returns_global_template(self):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_anonymous_with_access_right_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_list_as_superuser_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_staff_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_anonymous_with_access_right_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_as_anonymous_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def access():", "def test_get_all_accessible_by_hash_list_as_anonymous_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_as_user_returns_user_template(self):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_id_list_as_anonymous_with_access_right_returns_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_id_list(\n self.template_id_list, request=mock_request\n )\n self.assertTrue(templates.count() == 1)\n self.assertTrue((template.user is None for template in templates))", "def test_get_all_accessible_by_hash_as_superuser_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_keys(self):\n response = self.client.get_keys()\n assert isinstance(response, dict)\n assert 'public' in response\n assert 'private' in response\n assert response['public'] is not None\n assert response['private'] is not None", "def test_get_all_as_anonymous_with_access_right_returns_global_templates(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 1)\n self.assertTrue((template.user is None for template in templates))", "def test_variables_get(self):\n pass", "def test_get_all_accessible_by_hash_list_as_user_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_token_supply_all_using_get(self):\n pass", "def test_get_all_accessible_by_hash_as_staff_returns_user_template(self):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_user_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user2_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def get_all_access():\n\t# Get the email from the user making the request\n\temail = get_jwt_identity()\n\treturn get_all_access_helper(email)", "def test_get_all_accessible_by_hash_list_as_superuser_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_superuser_returns_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user2_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get1(self):\n pass", "def test_get_all_accessible_by_hash_list_as_user_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user2_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_list_as_staff_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))" ]

[ "0.73483837", "0.689207", "0.67723614", "0.670583", "0.6545129", "0.65434605", "0.6489687", "0.6428047", "0.6337772", "0.6308074", "0.62926304", "0.6243798", "0.62265044", "0.6103865", "0.60600764", "0.59886754", "0.5965506", "0.5956311", "0.58755183", "0.5861098", "0.5853029", "0.58292425", "0.581165", "0.5794263", "0.57237345", "0.57161146", "0.5665495", "0.5643762", "0.56198066", "0.5594259" ]

[ "def test_get_all_accessible_by_hash_list_as_user_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_superuser_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_superuser_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_staff_returns_user_template(self):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_staff_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_user_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_superuser_returns_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user2_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_user_returns_global_template(self):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_user_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user2_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_as_superuser_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_superuser_returns_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user2_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_user_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user2_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_list_as_anonymous_with_access_right_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_list_as_superuser_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_anonymous_with_access_right_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_list_as_anonymous_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_as_anonymous_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_list_as_anonymous_with_access_right_returns_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 1)\n self.assertTrue((template.user is None for template in templates))", "def test_get_all_accessible_by_hash_as_staff_returns_global_template(self):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_staff_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_as_user_returns_accessible_templates(self):\n mock_request = create_mock_request(user=self.user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 2)\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_anonymous_with_access_right_returns_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 1)\n self.assertTrue((template.user is None for template in templates))", "def test_get_all_accessible_by_hash_as_staff_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user2_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_staff_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user2_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_as_superuser_returns_all_templates(self):\n mock_request = create_mock_request(user=self.superuser)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 3)\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_id_list_as_user_returns_accessible_templates(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_id_list(\n self.template_id_list, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_list_user(self):\n pass", "def test_get_all_accessible_by_hash_list_as_anonymous_does_not_return_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def get_all_users():", "def test_get_all_as_anonymous_with_access_right_returns_global_templates(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 1)\n self.assertTrue((template.user is None for template in templates))" ]

[ "0.8098597", "0.8081005", "0.7892589", "0.78061783", "0.7657671", "0.7553108", "0.75217694", "0.7494131", "0.74738395", "0.7454518", "0.74189186", "0.7417", "0.7356148", "0.7336483", "0.7324792", "0.7279816", "0.72666675", "0.709681", "0.70890576", "0.7072468", "0.70683414", "0.70600444", "0.69417274", "0.6794414", "0.6472232", "0.64617306", "0.63827753", "0.6367161", "0.6340235", "0.6338451" ]

[ "def test_get_all_accessible_by_hash_as_superuser_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_user_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_user_returns_user_template(self):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_superuser_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_staff_returns_global_template(self):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_superuser_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_anonymous_with_access_right_returns_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 1)\n self.assertTrue((template.user is None for template in templates))", "def test_get_all_accessible_by_hash_list_as_staff_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_anonymous_with_access_right_returns_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 1)\n self.assertTrue((template.user is None for template in templates))", "def test_get_all_accessible_by_hash_list_as_user_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_staff_returns_user_template(self):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_superuser_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_superuser_returns_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user2_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_staff_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_anonymous_with_access_right_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_as_user_returns_accessible_templates(self):\n mock_request = create_mock_request(user=self.user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 2)\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_superuser_returns_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user2_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_anonymous_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_as_user_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user2_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_list_as_anonymous_with_access_right_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_as_anonymous_with_access_right_returns_global_templates(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 1)\n self.assertTrue((template.user is None for template in templates))", "def test_get_all_accessible_by_hash_as_anonymous_does_not_return_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_list_as_anonymous_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_list_as_anonymous_does_not_return_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_list_as_user_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user2_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_as_staff_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user2_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def T(request):\n\treturn all_templates[request.param]", "def test_get_all_as_superuser_returns_all_templates(self):\n mock_request = create_mock_request(user=self.superuser)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 3)\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_global_template_as_user_returns_template(self):\n mock_request = create_mock_request(user=self.user1)\n template = template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.global_template)", "def test_retrieve_template_registration(self):\n pass" ]

[ "0.78114414", "0.7711554", "0.7618051", "0.7576764", "0.7534922", "0.7504542", "0.7402011", "0.7372285", "0.7325458", "0.73088026", "0.72421944", "0.7232947", "0.7059146", "0.69722897", "0.6888439", "0.6876363", "0.6872592", "0.6841043", "0.6835622", "0.6817873", "0.6812515", "0.6807194", "0.67374057", "0.67337674", "0.6683139", "0.6565077", "0.6525472", "0.64283234", "0.6407897", "0.6342455" ]

[ "def test_get_all_accessible_by_hash_list_as_staff_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_superuser_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_user_returns_user_template(self):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_superuser_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_user_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_staff_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_staff_returns_global_template(self):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_superuser_returns_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user2_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_superuser_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_superuser_returns_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user2_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_anonymous_with_access_right_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_list_as_superuser_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_user_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_staff_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user2_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_anonymous_with_access_right_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_list_as_staff_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user2_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_user_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user2_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_list_as_anonymous_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_as_user_returns_global_template(self):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_anonymous_with_access_right_returns_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 1)\n self.assertTrue((template.user is None for template in templates))", "def test_get_all_accessible_by_hash_as_user_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user2_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_as_anonymous_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_as_anonymous_with_access_right_returns_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 1)\n self.assertTrue((template.user is None for template in templates))", "def test_get_all_as_staff_returns_accessible_templates(self):\n mock_request = create_mock_request(user=self.staff_user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 2)\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_as_user_returns_accessible_templates(self):\n mock_request = create_mock_request(user=self.user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 2)\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_id_list_as_staff_returns_accessible_templates(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_id_list(\n self.template_id_list, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_id_list_as_superuser_returns_accessible_templates(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_id_list(\n self.template_id_list, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_id_list_as_user_returns_accessible_templates(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_id_list(\n self.template_id_list, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_anonymous_does_not_return_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_as_superuser_returns_all_templates(self):\n mock_request = create_mock_request(user=self.superuser)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 3)\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))" ]

[ "0.8139061", "0.8013623", "0.7913836", "0.79138297", "0.78755826", "0.76368785", "0.7610415", "0.7501855", "0.74841386", "0.748", "0.7479454", "0.7447994", "0.7435938", "0.7394545", "0.7359369", "0.7324257", "0.7323782", "0.730924", "0.73041713", "0.727378", "0.7266767", "0.71808624", "0.7146986", "0.7020219", "0.6979782", "0.66771424", "0.66362226", "0.66207165", "0.65432656", "0.6505416" ]

[ "def test_get_all_accessible_by_hash_as_superuser_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_staff_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_user_returns_global_template(self):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_superuser_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_user_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_staff_returns_user_template(self):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_superuser_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_user_returns_user_template(self):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_staff_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_anonymous_with_access_right_returns_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 1)\n self.assertTrue((template.user is None for template in templates))", "def test_get_all_accessible_by_hash_as_anonymous_with_access_right_returns_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 1)\n self.assertTrue((template.user is None for template in templates))", "def test_get_all_accessible_by_hash_list_as_superuser_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_user_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_superuser_returns_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user2_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_anonymous_with_access_right_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_list_as_superuser_returns_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user2_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_anonymous_with_access_right_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_as_staff_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user2_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_anonymous_does_not_return_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_as_anonymous_does_not_return_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_list_as_anonymous_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_as_anonymous_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_as_user_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user2_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_list_as_staff_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user2_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_user_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user2_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_as_user_returns_accessible_templates(self):\n mock_request = create_mock_request(user=self.user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 2)\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_retrieve_template_registration(self):\n pass", "def T(request):\n\treturn all_templates[request.param]", "def test_get_all_as_staff_returns_accessible_templates(self):\n mock_request = create_mock_request(user=self.staff_user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 2)\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_as_anonymous_with_access_right_returns_global_templates(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 1)\n self.assertTrue((template.user is None for template in templates))" ]

[ "0.7497486", "0.74746835", "0.7385293", "0.7356151", "0.73261195", "0.72790205", "0.7225152", "0.71621686", "0.7087019", "0.7080861", "0.7057837", "0.7043345", "0.6963795", "0.678838", "0.66819537", "0.6676437", "0.6665664", "0.66606534", "0.66260237", "0.65794927", "0.6556352", "0.65523887", "0.6497468", "0.64881843", "0.6438338", "0.639747", "0.6362575", "0.63470334", "0.63466936", "0.6313803" ]

[ "def test_get_all_accessible_by_hash_list_as_superuser_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_user_returns_user_template(self):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_user_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_staff_returns_user_template(self):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_superuser_returns_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user2_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_superuser_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_superuser_returns_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user2_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_staff_returns_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_list_as_superuser_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_user_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_user_returns_global_template(self):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_user_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user2_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_list_as_user_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user2_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_list_as_anonymous_with_access_right_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_as_anonymous_with_access_right_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_as_staff_returns_global_template(self):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_staff_returns_global_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_anonymous_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user1_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_as_user_returns_accessible_templates(self):\n mock_request = create_mock_request(user=self.user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 2)\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_as_anonymous_does_not_return_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user1_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 0)", "def test_get_all_accessible_by_hash_list_as_anonymous_with_access_right_returns_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.global_template.hash], request=mock_request\n )\n self.assertTrue(templates.count() == 1)\n self.assertTrue((template.user is None for template in templates))", "def test_get_all_accessible_by_hash_as_staff_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.user2_template.hash, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_hash_as_anonymous_with_access_right_returns_global(\n self,\n ):\n mock_request = create_mock_request(user=self.anonymous_user)\n templates = template_api.get_all_accessible_by_hash(\n self.fixture.global_template.hash, request=mock_request\n )\n self.assertTrue(templates.count() == 1)\n self.assertTrue((template.user is None for template in templates))", "def test_get_all_as_superuser_returns_all_templates(self):\n mock_request = create_mock_request(user=self.superuser)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 3)\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_all_accessible_by_hash_list_as_staff_does_not_return_other_user_template(\n self,\n ):\n mock_request = create_mock_request(user=self.staff_user1)\n templates = template_api.get_all_accessible_by_hash_list(\n [self.fixture.user2_template.hash], request=mock_request\n )\n self.assertTrue(self.fixture.user1_template not in list(templates))\n self.assertTrue(self.fixture.user2_template not in list(templates))\n self.assertTrue(self.fixture.global_template not in list(templates))", "def test_get_all_accessible_by_id_list_as_superuser_returns_accessible_templates(\n self,\n ):\n mock_request = create_mock_request(user=self.superuser1)\n templates = template_api.get_all_accessible_by_id_list(\n self.template_id_list, request=mock_request\n )\n self.assertTrue(self.fixture.user1_template in list(templates))\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_any_template_as_superuser_returns_template(self):\n mock_request = create_mock_request(user=self.superuser1)\n template = template_api.get_by_id(\n self.fixture.user1_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.user1_template)\n template = template_api.get_by_id(\n self.fixture.user2_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.user2_template)\n template = template_api.get_by_id(\n self.fixture.global_template.id, request=mock_request\n )\n self.assertEqual(template, self.fixture.global_template)", "def test_list_user(self):\n pass", "def test_get_all_as_staff_returns_accessible_templates(self):\n mock_request = create_mock_request(user=self.staff_user)\n templates = template_api.get_all(request=mock_request)\n self.assertEqual(templates.count(), 2)\n self.assertTrue(self.fixture.user2_template in list(templates))\n self.assertTrue(self.fixture.global_template in list(templates))", "def test_get_superuser(self):\n url = reverse('projectroles:api_user_list')\n response = self.request_knox(url) # Default token is for superuser\n self.assertEqual(response.status_code, 200)\n response_data = json.loads(response.content)\n self.assertEqual(len(response_data), 4)\n expected = [\n self.get_serialized_user(self.user),\n self.get_serialized_user(self.user_owner_cat),\n self.get_serialized_user(self.user_owner),\n self.get_serialized_user(self.domain_user),\n ]\n self.assertEqual(response_data, expected)" ]

[ "0.8170202", "0.80604655", "0.7951915", "0.7856463", "0.7822592", "0.7790313", "0.7743123", "0.7713884", "0.76898307", "0.7519109", "0.74388695", "0.74056834", "0.7391", "0.7362122", "0.72886634", "0.72467566", "0.72302586", "0.72219735", "0.7183007", "0.7155218", "0.7108288", "0.70308304", "0.7028285", "0.69622594", "0.69195396", "0.6696285", "0.66908276", "0.66031414", "0.6602681", "0.6566947" ]